diff --git a/README b/README
index 2e84fbb..81b1f6c 100644
--- a/README
+++ b/README
@@ -11,7 +11,7 @@
 1. Install Ubuntu 14.04 or Debian 7.5 64-bit.
 2. Install the packages necessary for the build:
 > sudo apt-get install cscope ctags libz-dev libexpat-dev \
-  python language-pack-en \
+  python language-pack-en texinfo \
   build-essential g++ git bison flex unzip \
   libxml-simple-perl libxml-sax-perl libxml2-dev libxml2-utils xsltproc
 3. Continue with the clone, environment setup, and build as noted above.
diff --git a/buildroot b/buildroot
index 80a2f83..f1b6fca 160000
--- a/buildroot
+++ b/buildroot
@@ -1 +1 @@
-Subproject commit 80a2f83e60f3fd21a38e2bc9aac149f2c3a9ffdd
+Subproject commit f1b6fcafc3e82ca84505f5c16ad687b7a2d5d282
diff --git a/openpower/configs/firestone_defconfig b/openpower/configs/firestone_defconfig
index 4eae3ef..bdf2c77 100644
--- a/openpower/configs/firestone_defconfig
+++ b/openpower/configs/firestone_defconfig
@@ -35,15 +35,17 @@
 
 # petitboot requirements
 BR2_ENABLE_LOCALE_PURGE=y
-BR2_ENABLE_LOCALE_WHITELIST="C en_US"
-BR2_GENERATE_LOCALE="en_US.UTF-8"
+BR2_ENABLE_LOCALE_WHITELIST="C de en es fr it ja ko pt_BR ru zh_CN zh_TW"
+BR2_GENERATE_LOCALE="en_US.UTF-8 de_DE.UTF-8 es_ES.UTF-8 fr_FR.UTF-8 it_IT.UTF-8 ja_JP.UTF-8 ko_KR.UTF-8 pt_BR.UTF-8 ru_RU.UTF-8 zh_CN.UTF-8 zh_TW.UTF-8"
 BR2_ROOTFS_DEVICE_CREATION_DYNAMIC_EUDEV=y
 BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_ROOTFS_OVERLAY="overlay"
+BR2_ROOTFS_OVERLAY="../openpower/overlay"
+BR2_ROOTFS_DEVICE_TABLE="../openpower/device_table.txt"
+BR2_ROOTFS_POST_BUILD_SCRIPT="../openpower/scripts/fixup-target-var"
 BR2_LINUX_KERNEL=y
-BR2_LINUX_KERNEL_CUSTOM_GIT=y
-BR2_LINUX_KERNEL_CUSTOM_REPO_URL="git://github.com/open-power/linux.git"
-BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="8adc30a30b88c793c2058e85426f4f94158797ad"
+BR2_LINUX_KERNEL_VERSION="4.2.5"
+BR2_KERNEL_HEADERS_4_2=y
+BR2_LINUX_KERNEL_PATCH="$(BR2_EXTERNAL)/linux"
 BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
 BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="$(BR2_EXTERNAL)/configs/linux/skiroot_defconfig"
 BR2_LINUX_KERNEL_ZIMAGE_EPAPR=y
@@ -61,5 +63,6 @@
 BR2_PACKAGE_PETITBOOT=y
 BR2_PACKAGE_IPMITOOL=y
 BR2_PACKAGE_POWERPC_UTILS=y
+BR2_PACKAGE_MDADM=y
 BR2_TARGET_ROOTFS_CPIO_XZ=y
 BR2_TARGET_ROOTFS_INITRAMFS=y
diff --git a/openpower/configs/garrison_defconfig b/openpower/configs/garrison_defconfig
index 3dd7751..3dc2f02 100644
--- a/openpower/configs/garrison_defconfig
+++ b/openpower/configs/garrison_defconfig
@@ -4,12 +4,14 @@
 
 BR2_BINUTILS_EXTRA_CONFIG_OPTIONS="--enable-targets=powerpc64-linux"
 BR2_EXTRA_GCC_CONFIG_OPTIONS="--enable-targets=powerpc64-linux"
+BR2_TOOLCHAIN_BUILDROOT_CXX=y
+# BR2_TOOLCHAIN_BUILDROOT_LIBSTDCPP is not set
 
 BR2_OPENPOWER_CONFIG_NAME="garrison"
 BR2_OPENPOWER_XML_PACKAGE="garrison-xml"
 BR2_HOSTBOOT_CONFIG_FILE="garrison.config"
 
-BR2_HOSTBOOT_BINARY_SBE_FILENAME="venice_sbe.img.ecc"
+BR2_HOSTBOOT_BINARY_SBE_FILENAME="naples_sbe.img.ecc"
 BR2_HOSTBOOT_BINARY_SBEC_FILENAME="centaur_sbec_pad.img.ecc"
 BR2_HOSTBOOT_BINARY_WINK_FILENAME="n1.ref_image.hdr.bin.ecc"
 
@@ -30,6 +32,8 @@
 # skiboot requirements
 BR2_TARGET_SKIBOOT=y
 BR2_TARGET_SKIBOOT_EMBED_PAYLOAD=n
+BR2_SKIBOOT_CUSTOM_VERSION=y
+BR2_SKIBOOT_CUSTOM_VERSION_VALUE="d8830fd"
 
 # petitboot requirements
 BR2_ENABLE_LOCALE_PURGE=y
@@ -37,11 +41,13 @@
 BR2_GENERATE_LOCALE="en_US.UTF-8"
 BR2_ROOTFS_DEVICE_CREATION_DYNAMIC_EUDEV=y
 BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_ROOTFS_OVERLAY="overlay"
+BR2_ROOTFS_OVERLAY="../openpower/overlay"
+BR2_ROOTFS_DEVICE_TABLE="../openpower/device_table.txt"
+BR2_ROOTFS_POST_BUILD_SCRIPT="../openpower/scripts/fixup-target-var"
 BR2_LINUX_KERNEL=y
-BR2_LINUX_KERNEL_CUSTOM_GIT=y
-BR2_LINUX_KERNEL_CUSTOM_REPO_URL="git://github.com/open-power/linux.git"
-BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="8adc30a30b88c793c2058e85426f4f94158797ad"
+BR2_LINUX_KERNEL_VERSION="4.2.5"
+BR2_KERNEL_HEADERS_4_2=y
+BR2_LINUX_KERNEL_PATCH="$(BR2_EXTERNAL)/linux"
 BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
 BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="$(BR2_EXTERNAL)/configs/linux/skiroot_defconfig"
 BR2_LINUX_KERNEL_ZIMAGE_EPAPR=y
@@ -59,5 +65,6 @@
 BR2_PACKAGE_PETITBOOT=y
 BR2_PACKAGE_IPMITOOL=y
 BR2_PACKAGE_POWERPC_UTILS=y
+BR2_PACKAGE_MDADM=y
 BR2_TARGET_ROOTFS_CPIO_XZ=y
 BR2_TARGET_ROOTFS_INITRAMFS=y
diff --git a/openpower/configs/habanero_defconfig b/openpower/configs/habanero_defconfig
index 381b92b..1713606 100644
--- a/openpower/configs/habanero_defconfig
+++ b/openpower/configs/habanero_defconfig
@@ -35,15 +35,17 @@
 
 # petitboot requirements
 BR2_ENABLE_LOCALE_PURGE=y
-BR2_ENABLE_LOCALE_WHITELIST="C en_US"
-BR2_GENERATE_LOCALE="en_US.UTF-8"
+BR2_ENABLE_LOCALE_WHITELIST="C de en es fr it ja ko pt_BR ru zh_CN zh_TW"
+BR2_GENERATE_LOCALE="en_US.UTF-8 de_DE.UTF-8 es_ES.UTF-8 fr_FR.UTF-8 it_IT.UTF-8 ja_JP.UTF-8 ko_KR.UTF-8 pt_BR.UTF-8 ru_RU.UTF-8 zh_CN.UTF-8 zh_TW.UTF-8"
 BR2_ROOTFS_DEVICE_CREATION_DYNAMIC_EUDEV=y
 BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_ROOTFS_OVERLAY="overlay"
+BR2_ROOTFS_OVERLAY="../openpower/overlay"
+BR2_ROOTFS_DEVICE_TABLE="../openpower/device_table.txt"
+BR2_ROOTFS_POST_BUILD_SCRIPT="../openpower/scripts/fixup-target-var"
 BR2_LINUX_KERNEL=y
-BR2_LINUX_KERNEL_CUSTOM_GIT=y
-BR2_LINUX_KERNEL_CUSTOM_REPO_URL="git://github.com/open-power/linux.git"
-BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="8adc30a30b88c793c2058e85426f4f94158797ad"
+BR2_LINUX_KERNEL_VERSION="4.2.5"
+BR2_KERNEL_HEADERS_4_2=y
+BR2_LINUX_KERNEL_PATCH="$(BR2_EXTERNAL)/linux"
 BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
 BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="$(BR2_EXTERNAL)/configs/linux/skiroot_defconfig"
 BR2_LINUX_KERNEL_ZIMAGE_EPAPR=y
@@ -61,5 +63,6 @@
 BR2_PACKAGE_PETITBOOT=y
 BR2_PACKAGE_IPMITOOL=y
 BR2_PACKAGE_POWERPC_UTILS=y
+BR2_PACKAGE_MDADM=y
 BR2_TARGET_ROOTFS_CPIO_XZ=y
 BR2_TARGET_ROOTFS_INITRAMFS=y
diff --git a/openpower/configs/hostboot/firestone.config b/openpower/configs/hostboot/firestone.config
index 942e242..c435b4c 100755
--- a/openpower/configs/hostboot/firestone.config
+++ b/openpower/configs/hostboot/firestone.config
@@ -41,7 +41,6 @@
 # Enable Kingston dimm voltage workaround
 set KINGSTON_1_35_VOLT
 
-set NO_DMI_EREPAIR
 unset DISABLE_HOSTBOOT_RUNTIME
 
 # Compile in hostboot runtime PRD
diff --git a/openpower/configs/hostboot/garrison.config b/openpower/configs/hostboot/garrison.config
index c78bc7a..102c147 100755
--- a/openpower/configs/hostboot/garrison.config
+++ b/openpower/configs/hostboot/garrison.config
@@ -41,10 +41,12 @@
 # Enable Kingston dimm voltage workaround
 set KINGSTON_1_35_VOLT
 
-set NO_DMI_EREPAIR
-set DISABLE_HOSTBOOT_RUNTIME
-unset HTMGT
-unset START_OCC_DURING_BOOT
+unset DISABLE_HOSTBOOT_RUNTIME
+
+# Compile in hostboot runtime PRD
+set HBRT_PRD
+set HTMGT
+set START_OCC_DURING_BOOT
 
 #PNOR flags
 set PNOR_TWO_SIDE_SUPPORT
diff --git a/openpower/configs/hostboot/habanero.config b/openpower/configs/hostboot/habanero.config
index e6d95ad..1f2cedf 100755
--- a/openpower/configs/hostboot/habanero.config
+++ b/openpower/configs/hostboot/habanero.config
@@ -41,7 +41,6 @@
 # Enable Kingston dimm voltage workaround
 set KINGSTON_1_35_VOLT
 
-set NO_DMI_EREPAIR
 unset DISABLE_HOSTBOOT_RUNTIME
 
 # Compile in hostboot runtime PRD
diff --git a/openpower/configs/hostboot/palmetto.config b/openpower/configs/hostboot/palmetto.config
index cf328ee..bebb858 100755
--- a/openpower/configs/hostboot/palmetto.config
+++ b/openpower/configs/hostboot/palmetto.config
@@ -40,7 +40,6 @@
 
 set PNOR_IS_32MB
 
-set NO_DMI_EREPAIR
 unset DISABLE_HOSTBOOT_RUNTIME
 
 # Compile in hostboot runtime PRD
diff --git a/openpower/configs/linux/skiroot_defconfig b/openpower/configs/linux/skiroot_defconfig
index 648de48..1a80631 100644
--- a/openpower/configs/linux/skiroot_defconfig
+++ b/openpower/configs/linux/skiroot_defconfig
@@ -7,8 +7,7 @@
 # CONFIG_SWAP is not set
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
-CONFIG_AUDIT=y
-CONFIG_AUDITSYSCALL=y
+# CONFIG_CROSS_MEMORY_ATTACH is not set
 CONFIG_IRQ_DOMAIN_DEBUG=y
 CONFIG_NO_HZ=y
 CONFIG_HIGH_RES_TIMERS=y
@@ -19,9 +18,14 @@
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=20
-# CONFIG_NAMESPACES is not set
 CONFIG_RELAY=y
 CONFIG_BLK_DEV_INITRD=y
+# CONFIG_RD_GZIP is not set
+# CONFIG_RD_BZIP2 is not set
+# CONFIG_RD_LZMA is not set
+# CONFIG_RD_LZO is not set
+# CONFIG_RD_LZ4 is not set
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_KALLSYMS_ALL=y
 CONFIG_PERF_EVENTS=y
 # CONFIG_COMPAT_BRK is not set
@@ -29,6 +33,8 @@
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_PARTITION_ADVANCED=y
+# CONFIG_IOSCHED_DEADLINE is not set
+# CONFIG_PPC_PSERIES is not set
 # CONFIG_PPC_PMAC is not set
 CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
 CONFIG_HZ_100=y
@@ -37,16 +43,14 @@
 # CONFIG_COMPACTION is not set
 # CONFIG_MIGRATION is not set
 # CONFIG_BOUNCE is not set
-# CONFIG_CROSS_MEMORY_ATTACH is not set
 CONFIG_PPC_64K_PAGES=y
 CONFIG_SCHED_SMT=y
-# CONFIG_SUSPEND is not set
 # CONFIG_SECCOMP is not set
+CONFIG_NET=y
 CONFIG_PACKET=y
 CONFIG_UNIX=y
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
-CONFIG_NET=y
 CONFIG_NET_IPIP=y
 CONFIG_SYN_COOKIES=y
 # CONFIG_INET_XFRM_MODE_TRANSPORT is not set
@@ -57,8 +61,6 @@
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
 CONFIG_DEVTMPFS=y
 CONFIG_DEVTMPFS_MOUNT=y
-# CONFIG_FW_LOADER_USER_HELPER is not set
-CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=65536
@@ -70,15 +72,15 @@
 CONFIG_BLK_DEV_SR=y
 CONFIG_BLK_DEV_SR_VENDOR=y
 CONFIG_CHR_DEV_SG=y
-CONFIG_SCSI_MULTI_LUN=y
 CONFIG_SCSI_CONSTANTS=y
 CONFIG_SCSI_SCAN_ASYNC=y
+CONFIG_SCSI_FC_ATTRS=y
 CONFIG_SCSI_CXGB3_ISCSI=y
 CONFIG_SCSI_CXGB4_ISCSI=y
 CONFIG_SCSI_BNX2_ISCSI=y
 CONFIG_BE2ISCSI=y
+CONFIG_SCSI_AACRAID=y
 CONFIG_SCSI_MPT2SAS=y
-CONFIG_SCSI_IBMVSCSI=y
 CONFIG_SCSI_SYM53C8XX_2=y
 CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=0
 CONFIG_SCSI_IPR=y
@@ -120,7 +122,6 @@
 CONFIG_CHELSIO_T1=y
 CONFIG_BE2NET=y
 CONFIG_S2IO=y
-CONFIG_IBMVETH=y
 CONFIG_E100=y
 CONFIG_E1000=y
 CONFIG_E1000E=y
@@ -136,10 +137,8 @@
 CONFIG_INPUT_EVDEV=y
 CONFIG_INPUT_MISC=y
 # CONFIG_SERIO_SERPORT is not set
-CONFIG_VT_HW_CONSOLE_BINDING=y
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
-CONFIG_HVC_CONSOLE=y
 CONFIG_IPMI_HANDLER=y
 CONFIG_IPMI_DEVICE_INTERFACE=y
 CONFIG_IPMI_POWERNV=y
@@ -176,14 +175,6 @@
 CONFIG_VIRT_DRIVERS=y
 CONFIG_VIRTIO_PCI=y
 # CONFIG_IOMMU_SUPPORT is not set
-CONFIG_EXT2_FS=y
-CONFIG_EXT2_FS_XATTR=y
-CONFIG_EXT2_FS_POSIX_ACL=y
-CONFIG_EXT2_FS_SECURITY=y
-CONFIG_EXT2_FS_XIP=y
-CONFIG_EXT3_FS=y
-CONFIG_EXT3_FS_POSIX_ACL=y
-CONFIG_EXT3_FS_SECURITY=y
 CONFIG_EXT4_FS=y
 CONFIG_EXT4_FS_POSIX_ACL=y
 CONFIG_EXT4_FS_SECURITY=y
@@ -209,16 +200,14 @@
 CONFIG_NLS_ASCII=y
 CONFIG_NLS_ISO8859_1=y
 CONFIG_NLS_UTF8=y
-# CONFIG_XZ_DEC_POWERPC is not set
 CONFIG_PRINTK_TIME=y
-CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_FS=y
+CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
+CONFIG_DEBUG_STACKOVERFLOW=y
 CONFIG_LOCKUP_DETECTOR=y
 CONFIG_SCHEDSTATS=y
 # CONFIG_FTRACE is not set
-CONFIG_DEBUG_STACKOVERFLOW=y
 CONFIG_XMON=y
 CONFIG_XMON_DEFAULT=y
-# CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
diff --git a/openpower/configs/openpower_mambo_defconfig b/openpower/configs/openpower_mambo_defconfig
index e10d5e4..6f29cc8 100644
--- a/openpower/configs/openpower_mambo_defconfig
+++ b/openpower/configs/openpower_mambo_defconfig
@@ -27,11 +27,13 @@
 BR2_GENERATE_LOCALE="en_US.UTF-8"
 BR2_ROOTFS_DEVICE_CREATION_DYNAMIC_EUDEV=y
 BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_ROOTFS_OVERLAY="overlay"
+BR2_ROOTFS_OVERLAY="../openpower/overlay"
+BR2_ROOTFS_DEVICE_TABLE="../openpower/device_table.txt"
+BR2_ROOTFS_POST_BUILD_SCRIPT="../openpower/scripts/fixup-target-var"
 BR2_LINUX_KERNEL=y
-BR2_LINUX_KERNEL_CUSTOM_GIT=y
-BR2_LINUX_KERNEL_CUSTOM_REPO_URL="git://github.com/open-power/linux.git"
-BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="8adc30a30b88c793c2058e85426f4f94158797ad"
+BR2_LINUX_KERNEL_VERSION="4.2.5"
+BR2_KERNEL_HEADERS_4_2=y
+BR2_LINUX_KERNEL_PATCH="$(BR2_EXTERNAL)/linux"
 BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
 BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="$(BR2_EXTERNAL)/configs/linux/skiroot_defconfig"
 BR2_LINUX_KERNEL_ZIMAGE_EPAPR=y
@@ -49,5 +51,6 @@
 BR2_PACKAGE_PETITBOOT=y
 BR2_PACKAGE_IPMITOOL=y
 BR2_PACKAGE_POWERPC_UTILS=y
+BR2_PACKAGE_MDADM=y
 BR2_TARGET_ROOTFS_CPIO_XZ=y
 BR2_TARGET_ROOTFS_INITRAMFS=y
diff --git a/openpower/configs/palmetto_defconfig b/openpower/configs/palmetto_defconfig
index 9ebb2c5..1b343a2 100644
--- a/openpower/configs/palmetto_defconfig
+++ b/openpower/configs/palmetto_defconfig
@@ -38,11 +38,13 @@
 BR2_GENERATE_LOCALE="en_US.UTF-8"
 BR2_ROOTFS_DEVICE_CREATION_DYNAMIC_EUDEV=y
 BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_ROOTFS_OVERLAY="overlay"
+BR2_ROOTFS_OVERLAY="../openpower/overlay"
+BR2_ROOTFS_DEVICE_TABLE="../openpower/device_table.txt"
+BR2_ROOTFS_POST_BUILD_SCRIPT="../openpower/scripts/fixup-target-var"
 BR2_LINUX_KERNEL=y
-BR2_LINUX_KERNEL_CUSTOM_GIT=y
-BR2_LINUX_KERNEL_CUSTOM_REPO_URL="git://github.com/open-power/linux.git"
-BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="8adc30a30b88c793c2058e85426f4f94158797ad"
+BR2_LINUX_KERNEL_VERSION="4.2.5"
+BR2_KERNEL_HEADERS_4_2=y
+BR2_LINUX_KERNEL_PATCH="$(BR2_EXTERNAL)/linux"
 BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
 BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="$(BR2_EXTERNAL)/configs/linux/skiroot_defconfig"
 BR2_LINUX_KERNEL_ZIMAGE_EPAPR=y
@@ -60,6 +62,7 @@
 BR2_PACKAGE_PETITBOOT=y
 BR2_PACKAGE_IPMITOOL=y
 BR2_PACKAGE_POWERPC_UTILS=y
+BR2_PACKAGE_MDADM=y
 BR2_TARGET_ROOTFS_CPIO_XZ=y
 BR2_TARGET_ROOTFS_INITRAMFS=y
 
diff --git a/openpower/device_table.txt b/openpower/device_table.txt
new file mode 100644
index 0000000..450aab6
--- /dev/null
+++ b/openpower/device_table.txt
@@ -0,0 +1,23 @@
+# See package/makedevs/README for details
+#
+# This device table is used to assign proper ownership and permissions
+# on various files. It doesn't create any device file, as it is used
+# in both static device configurations (where /dev/ is static) and in
+# dynamic configurations (where devtmpfs, mdev or udev are used).
+#
+# <name>				<type>	<mode>	<uid>	<gid>	<major>	<minor>	<start>	<inc>	<count>
+/dev					d	755	0	0	-	-	-	-	-
+/etc					d	755	0	0	-	-	-	-	-
+/root					d	700	0	0	-	-	-	-	-
+/var/www				d	755	33	33	-	-	-	-	-
+/etc/random-seed			f	600	0	0	-	-	-	-	-
+/etc/shadow				f	600	0	0	-	-	-	-	-
+/etc/passwd				f	644	0	0	-	-	-	-	-
+/etc/network/if-up.d			d	755	0	0	-	-	-	-	-
+/etc/network/if-pre-up.d		d	755	0	0	-	-	-	-	-
+/etc/network/if-post-up.d		d	755	0	0	-	-	-	-	-
+/etc/network/if-down.d			d	755	0	0	-	-	-	-	-
+/etc/network/if-pre-down.d		d	755	0	0	-	-	-	-	-
+/etc/network/if-post-down.d		d	755	0	0	-	-	-	-	-
+# uncomment this to allow starting x as non-root
+#/usr/X11R6/bin/Xfbdev		     	f	4755	0	0	-	-	-	-	-
diff --git a/openpower/linux/linux-0001-powerpc-Add-openpower_defconfig.patch b/openpower/linux/linux-0001-powerpc-Add-openpower_defconfig.patch
new file mode 100644
index 0000000..3dfb56e
--- /dev/null
+++ b/openpower/linux/linux-0001-powerpc-Add-openpower_defconfig.patch
@@ -0,0 +1,241 @@
+From 3700065f5c1b076e49aa81eff729012fd2da6b54 Mon Sep 17 00:00:00 2001
+From: Jeremy Kerr <jk@ozlabs.org>
+Date: Fri, 12 Dec 2014 08:03:11 +0800
+Subject: [PATCH 01/17] powerpc: Add openpower_defconfig
+
+Simplifies building an openpower kernel a little. It is based on the
+configuration used by the op-build openpower buildroot overlay.
+
+Signed-off-by: Jeremy Kerr <jk@ozlabs.org>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ arch/powerpc/configs/openpower_defconfig | 217 +++++++++++++++++++++++++++++++
+ 1 file changed, 217 insertions(+)
+ create mode 100644 arch/powerpc/configs/openpower_defconfig
+
+diff --git a/arch/powerpc/configs/openpower_defconfig b/arch/powerpc/configs/openpower_defconfig
+new file mode 100644
+index 0000000..4d6779a
+--- /dev/null
++++ b/arch/powerpc/configs/openpower_defconfig
+@@ -0,0 +1,217 @@
++CONFIG_PPC64=y
++CONFIG_ALTIVEC=y
++CONFIG_VSX=y
++CONFIG_SMP=y
++CONFIG_NR_CPUS=2048
++CONFIG_CPU_LITTLE_ENDIAN=y
++# CONFIG_SWAP is not set
++CONFIG_SYSVIPC=y
++CONFIG_POSIX_MQUEUE=y
++# CONFIG_CROSS_MEMORY_ATTACH is not set
++CONFIG_IRQ_DOMAIN_DEBUG=y
++CONFIG_NO_HZ=y
++CONFIG_HIGH_RES_TIMERS=y
++CONFIG_TASKSTATS=y
++CONFIG_TASK_DELAY_ACCT=y
++CONFIG_TASK_XACCT=y
++CONFIG_TASK_IO_ACCOUNTING=y
++CONFIG_IKCONFIG=y
++CONFIG_IKCONFIG_PROC=y
++CONFIG_LOG_BUF_SHIFT=20
++CONFIG_RELAY=y
++CONFIG_BLK_DEV_INITRD=y
++# CONFIG_RD_GZIP is not set
++# CONFIG_RD_BZIP2 is not set
++# CONFIG_RD_LZMA is not set
++# CONFIG_RD_LZO is not set
++# CONFIG_RD_LZ4 is not set
++CONFIG_KALLSYMS_ALL=y
++CONFIG_PERF_EVENTS=y
++# CONFIG_COMPAT_BRK is not set
++CONFIG_JUMP_LABEL=y
++CONFIG_MODULES=y
++CONFIG_MODULE_UNLOAD=y
++CONFIG_PARTITION_ADVANCED=y
++# CONFIG_IOSCHED_DEADLINE is not set
++# CONFIG_PPC_PMAC is not set
++CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
++CONFIG_HZ_100=y
++CONFIG_KEXEC=y
++CONFIG_IRQ_ALL_CPUS=y
++# CONFIG_COMPACTION is not set
++# CONFIG_MIGRATION is not set
++# CONFIG_BOUNCE is not set
++CONFIG_PPC_64K_PAGES=y
++CONFIG_SCHED_SMT=y
++# CONFIG_SUSPEND is not set
++# CONFIG_SECCOMP is not set
++CONFIG_NET=y
++CONFIG_PACKET=y
++CONFIG_UNIX=y
++CONFIG_INET=y
++CONFIG_IP_MULTICAST=y
++CONFIG_NET_IPIP=y
++CONFIG_SYN_COOKIES=y
++# CONFIG_INET_XFRM_MODE_TRANSPORT is not set
++# CONFIG_INET_XFRM_MODE_TUNNEL is not set
++# CONFIG_INET_XFRM_MODE_BEET is not set
++# CONFIG_IPV6 is not set
++# CONFIG_WIRELESS is not set
++CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
++CONFIG_DEVTMPFS=y
++CONFIG_DEVTMPFS_MOUNT=y
++CONFIG_BLK_DEV_LOOP=y
++CONFIG_BLK_DEV_RAM=y
++CONFIG_BLK_DEV_RAM_SIZE=65536
++CONFIG_ATA_OVER_ETH=y
++CONFIG_VIRTIO_BLK=y
++CONFIG_EEPROM_AT24=y
++CONFIG_CXL=y
++CONFIG_BLK_DEV_SD=y
++CONFIG_CHR_DEV_ST=y
++CONFIG_BLK_DEV_SR=y
++CONFIG_BLK_DEV_SR_VENDOR=y
++CONFIG_CHR_DEV_SG=y
++CONFIG_SCSI_CONSTANTS=y
++CONFIG_SCSI_SCAN_ASYNC=y
++CONFIG_SCSI_FC_ATTRS=y
++CONFIG_SCSI_CXGB3_ISCSI=y
++CONFIG_SCSI_CXGB4_ISCSI=y
++CONFIG_SCSI_BNX2_ISCSI=y
++CONFIG_BE2ISCSI=y
++CONFIG_SCSI_AACRAID=y
++CONFIG_SCSI_MPT2SAS=y
++CONFIG_SCSI_IBMVSCSI=y
++CONFIG_SCSI_SYM53C8XX_2=y
++CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=0
++CONFIG_SCSI_IPR=y
++# CONFIG_SCSI_IPR_TRACE is not set
++# CONFIG_SCSI_IPR_DUMP is not set
++CONFIG_SCSI_QLA_FC=y
++CONFIG_SCSI_QLA_ISCSI=y
++CONFIG_SCSI_LPFC=y
++CONFIG_SCSI_VIRTIO=y
++CONFIG_SCSI_DH=y
++CONFIG_SCSI_DH_ALUA=y
++CONFIG_ATA=y
++CONFIG_SATA_AHCI=y
++# CONFIG_ATA_SFF is not set
++CONFIG_MD=y
++CONFIG_BLK_DEV_MD=y
++CONFIG_MD_LINEAR=y
++CONFIG_MD_RAID0=y
++CONFIG_MD_RAID1=y
++CONFIG_MD_RAID10=y
++CONFIG_MD_RAID456=y
++CONFIG_MD_MULTIPATH=y
++CONFIG_MD_FAULTY=y
++CONFIG_BLK_DEV_DM=y
++CONFIG_DM_CRYPT=y
++CONFIG_DM_SNAPSHOT=y
++CONFIG_DM_MIRROR=y
++CONFIG_DM_ZERO=y
++CONFIG_DM_MULTIPATH=y
++CONFIG_NETCONSOLE=y
++CONFIG_TUN=y
++CONFIG_VIRTIO_NET=y
++CONFIG_VORTEX=y
++CONFIG_ACENIC=y
++CONFIG_ACENIC_OMIT_TIGON_I=y
++CONFIG_PCNET32=y
++CONFIG_TIGON3=y
++CONFIG_BNX2X=y
++CONFIG_CHELSIO_T1=y
++CONFIG_BE2NET=y
++CONFIG_S2IO=y
++CONFIG_IBMVETH=y
++CONFIG_E100=y
++CONFIG_E1000=y
++CONFIG_E1000E=y
++CONFIG_IXGB=y
++CONFIG_IXGBE=y
++CONFIG_MLX4_EN=y
++CONFIG_MYRI10GE=y
++CONFIG_QLGE=y
++CONFIG_NETXEN_NIC=y
++CONFIG_SFC=y
++# CONFIG_WLAN is not set
++# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
++CONFIG_INPUT_EVDEV=y
++CONFIG_INPUT_MISC=y
++# CONFIG_SERIO_SERPORT is not set
++CONFIG_SERIAL_8250=y
++CONFIG_SERIAL_8250_CONSOLE=y
++CONFIG_HVC_CONSOLE=y
++CONFIG_IPMI_HANDLER=y
++CONFIG_IPMI_DEVICE_INTERFACE=y
++CONFIG_IPMI_POWERNV=y
++CONFIG_HW_RANDOM=y
++CONFIG_GEN_RTC=y
++CONFIG_RAW_DRIVER=y
++CONFIG_MAX_RAW_DEVS=1024
++# CONFIG_I2C_COMPAT is not set
++CONFIG_I2C_CHARDEV=y
++# CONFIG_I2C_HELPER_AUTO is not set
++CONFIG_DRM=y
++CONFIG_DRM_RADEON=y
++CONFIG_DRM_AST=y
++CONFIG_FIRMWARE_EDID=y
++CONFIG_FB_MODE_HELPERS=y
++CONFIG_FB_OF=y
++CONFIG_FB_MATROX=y
++CONFIG_FB_MATROX_MILLENIUM=y
++CONFIG_FB_MATROX_MYSTIQUE=y
++CONFIG_FB_MATROX_G=y
++CONFIG_BACKLIGHT_LCD_SUPPORT=y
++# CONFIG_LCD_CLASS_DEVICE is not set
++# CONFIG_BACKLIGHT_GENERIC is not set
++# CONFIG_VGA_CONSOLE is not set
++CONFIG_LOGO=y
++CONFIG_USB_HIDDEV=y
++CONFIG_USB=y
++CONFIG_USB_MON=y
++CONFIG_USB_XHCI_HCD=y
++CONFIG_USB_EHCI_HCD=y
++# CONFIG_USB_EHCI_HCD_PPC_OF is not set
++CONFIG_USB_OHCI_HCD=y
++CONFIG_USB_STORAGE=y
++CONFIG_VIRT_DRIVERS=y
++CONFIG_VIRTIO_PCI=y
++# CONFIG_IOMMU_SUPPORT is not set
++CONFIG_EXT4_FS=y
++CONFIG_EXT4_FS_POSIX_ACL=y
++CONFIG_EXT4_FS_SECURITY=y
++CONFIG_XFS_FS=y
++CONFIG_XFS_POSIX_ACL=y
++CONFIG_BTRFS_FS=y
++CONFIG_BTRFS_FS_POSIX_ACL=y
++CONFIG_AUTOFS4_FS=y
++CONFIG_ISO9660_FS=y
++CONFIG_UDF_FS=y
++CONFIG_MSDOS_FS=y
++CONFIG_VFAT_FS=y
++CONFIG_PROC_KCORE=y
++CONFIG_TMPFS=y
++CONFIG_TMPFS_POSIX_ACL=y
++CONFIG_NFS_FS=y
++CONFIG_NFS_V3_ACL=y
++CONFIG_NFS_V4=y
++CONFIG_CIFS=y
++# CONFIG_CIFS_DEBUG is not set
++CONFIG_NLS_DEFAULT="utf8"
++CONFIG_NLS_CODEPAGE_437=y
++CONFIG_NLS_ASCII=y
++CONFIG_NLS_ISO8859_1=y
++CONFIG_NLS_UTF8=y
++CONFIG_PRINTK_TIME=y
++CONFIG_DEBUG_FS=y
++CONFIG_MAGIC_SYSRQ=y
++CONFIG_DEBUG_KERNEL=y
++CONFIG_DEBUG_STACKOVERFLOW=y
++CONFIG_LOCKUP_DETECTOR=y
++CONFIG_SCHEDSTATS=y
++# CONFIG_FTRACE is not set
++CONFIG_XMON=y
++CONFIG_XMON_DEFAULT=y
++CONFIG_CRYPTO_ECHAINIV=y
++# CONFIG_CRYPTO_HW is not set
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0002-xhci-Use-xhci_pci_remove-for-xhci-device-shutdown.patch b/openpower/linux/linux-0002-xhci-Use-xhci_pci_remove-for-xhci-device-shutdown.patch
new file mode 100644
index 0000000..b97fe3d
--- /dev/null
+++ b/openpower/linux/linux-0002-xhci-Use-xhci_pci_remove-for-xhci-device-shutdown.patch
@@ -0,0 +1,27 @@
+From bb607985cc1eec5693851dd68af1ab0a87986ec5 Mon Sep 17 00:00:00 2001
+From: Thadeu Lima De Souza Cascardo <thadeul@br.ibm.com>
+Date: Tue, 25 Mar 2014 10:45:16 -0400
+Subject: [PATCH 02/17] xhci: Use xhci_pci_remove for xhci device shutdown
+
+Signed-off-by: Jeremy Kerr <jk@ozlabs.org>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/usb/host/xhci-pci.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
+index c79d336..5492bc6 100644
+--- a/drivers/usb/host/xhci-pci.c
++++ b/drivers/usb/host/xhci-pci.c
+@@ -419,7 +419,7 @@ static struct pci_driver xhci_pci_driver = {
+ 	.remove =	xhci_pci_remove,
+ 	/* suspend and resume implemented later */
+ 
+-	.shutdown = 	usb_hcd_pci_shutdown,
++	.shutdown = 	xhci_pci_remove,
+ #ifdef CONFIG_PM
+ 	.driver = {
+ 		.pm = &usb_hcd_pci_pm_ops
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0003-drm-ast-Default-to-8bpp-on-big-endian.patch b/openpower/linux/linux-0003-drm-ast-Default-to-8bpp-on-big-endian.patch
new file mode 100644
index 0000000..c163f4d
--- /dev/null
+++ b/openpower/linux/linux-0003-drm-ast-Default-to-8bpp-on-big-endian.patch
@@ -0,0 +1,45 @@
+From 962e22b1eb505a50671f47b62d52c7d23acf69f3 Mon Sep 17 00:00:00 2001
+From: Benjamin Herrenschmidt <benh@kernel.crashing.org>
+Date: Fri, 31 Oct 2014 15:06:38 +1100
+Subject: [PATCH 03/17] drm/ast: Default to 8bpp on big endian
+
+This chip is LE only (some versions support HW swappers but not
+the latest and the driver doesn't anyway).
+
+I tried using the "foreign endian" fb flag but it appears to be
+busted, so instead, default to endian-neutral 8bpp for BE.
+
+Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/gpu/drm/ast/ast_fb.c | 13 +++++++++++++
+ 1 file changed, 13 insertions(+)
+
+diff --git a/drivers/gpu/drm/ast/ast_fb.c b/drivers/gpu/drm/ast/ast_fb.c
+index ff68eef..c532c69 100644
+--- a/drivers/gpu/drm/ast/ast_fb.c
++++ b/drivers/gpu/drm/ast/ast_fb.c
+@@ -345,7 +345,20 @@ int ast_fbdev_init(struct drm_device *dev)
+ 	/* disable all the possible outputs/crtcs before entering KMS mode */
+ 	drm_helper_disable_unused_functions(dev);
+ 
++	/*
++	 * This chip is LE only (some versions support HW swappers but not
++	 * the latest and the driver doesn't anyway).
++	 *
++	 * I tried using the "foreign endian" fb flag but it appears to be
++	 * busted, so instead, default to endian-neutral 8bpp for BE.
++	 *
++	 * (and it's faster !)
++	 */
++#if defined(__BIG_ENDIAN)
++	ret = drm_fb_helper_initial_config(&afbdev->helper, 8);
++#else
+ 	ret = drm_fb_helper_initial_config(&afbdev->helper, 32);
++#endif
+ 	if (ret)
+ 		goto fini;
+ 
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0004-powerpc-kexec-Reset-secondary-cpu-endianess-before-k.patch b/openpower/linux/linux-0004-powerpc-kexec-Reset-secondary-cpu-endianess-before-k.patch
new file mode 100644
index 0000000..48c89a8
--- /dev/null
+++ b/openpower/linux/linux-0004-powerpc-kexec-Reset-secondary-cpu-endianess-before-k.patch
@@ -0,0 +1,48 @@
+From 7d09146cc906efed651f227864c8603fc57ee325 Mon Sep 17 00:00:00 2001
+From: Samuel Mendoza-Jonas <sam.mj@au1.ibm.com>
+Date: Mon, 29 Jun 2015 13:43:51 +1000
+Subject: [PATCH 04/17] powerpc/kexec: Reset secondary cpu endianess before
+ kexec
+
+If the target kernel does not inlcude the FIXUP_ENDIAN check, coming
+from a different-endian kernel will cause the target kernel to panic.
+All ppc64 kernels can handle starting in big-endian mode, so return to
+big-endian before branching into the target kernel.
+
+This mainly affects pseries as secondaries on powernv are returned to
+OPAL.
+
+Signed-off-by: Samuel Mendoza-Jonas <sam.mj@au1.ibm.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ arch/powerpc/kernel/misc_64.S | 13 +++++++++++--
+ 1 file changed, 11 insertions(+), 2 deletions(-)
+
+diff --git a/arch/powerpc/kernel/misc_64.S b/arch/powerpc/kernel/misc_64.S
+index 4e314b9..6e4168c 100644
+--- a/arch/powerpc/kernel/misc_64.S
++++ b/arch/powerpc/kernel/misc_64.S
+@@ -475,9 +475,18 @@ _GLOBAL(kexec_wait)
+ #ifdef CONFIG_KEXEC		/* use no memory without kexec */
+ 	lwz	r4,0(r5)
+ 	cmpwi	0,r4,0
+-	bnea	0x60
++	beq	99b
++#ifdef CONFIG_PPC_BOOK3S_64
++	li	r10,0x60
++	mfmsr	r11
++	clrrdi	r11,r11,1	/* Clear MSR_LE */
++	mtsrr0	r10
++	mtsrr1	r11
++	rfid
++#else
++	ba	0x60
++#endif
+ #endif
+-	b	99b
+ 
+ /* this can be in text because we won't change it until we are
+  * running in real anyways
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0005-powerpc-kexec-Reset-HILE-before-kexec_sequence.patch b/openpower/linux/linux-0005-powerpc-kexec-Reset-HILE-before-kexec_sequence.patch
new file mode 100644
index 0000000..05e884d
--- /dev/null
+++ b/openpower/linux/linux-0005-powerpc-kexec-Reset-HILE-before-kexec_sequence.patch
@@ -0,0 +1,40 @@
+From 67b97ec555099b7f84cd98c6f8e93cac588aa830 Mon Sep 17 00:00:00 2001
+From: Samuel Mendoza-Jonas <sam.mj@au1.ibm.com>
+Date: Wed, 22 Jul 2015 11:09:15 +1000
+Subject: [PATCH 05/17] powerpc/kexec: Reset HILE before kexec_sequence
+
+On powernv secondary cpus are returned to OPAL, and will then enter
+the target kernel in big-endian. However if it is set the HILE bit
+will persist, causing the first exception in the target kernel to be
+delivered in litte-endian regardless of the current endianess.
+
+If running on top of OPAL make sure the HILE bit is reset once we've
+finished waiting for all of the secondaries to be returned to OPAL.
+
+Signed-off-by: Samuel Mendoza-Jonas <sam.mj@au1.ibm.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ arch/powerpc/platforms/powernv/setup.c | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/powerpc/platforms/powernv/setup.c b/arch/powerpc/platforms/powernv/setup.c
+index 53737e0..59076db 100644
+--- a/arch/powerpc/platforms/powernv/setup.c
++++ b/arch/powerpc/platforms/powernv/setup.c
+@@ -243,6 +243,13 @@ static void pnv_kexec_cpu_down(int crash_shutdown, int secondary)
+ 	} else {
+ 		/* Primary waits for the secondaries to have reached OPAL */
+ 		pnv_kexec_wait_secondaries_down();
++
++		/*
++		 * We might be running as little-endian - now that interrupts
++		 * are disabled, reset the HILE bit to big-endian so we don't
++		 * take interrupts in the wrong endian later
++		 */
++		opal_reinit_cpus(OPAL_REINIT_CPUS_HILE_BE);
+ 	}
+ }
+ #endif /* CONFIG_KEXEC */
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0006-Revert-powerpc-Reject-binutils-2.24-when-building-li.patch b/openpower/linux/linux-0006-Revert-powerpc-Reject-binutils-2.24-when-building-li.patch
new file mode 100644
index 0000000..3968fbc
--- /dev/null
+++ b/openpower/linux/linux-0006-Revert-powerpc-Reject-binutils-2.24-when-building-li.patch
@@ -0,0 +1,38 @@
+From a24b6a40ae28997b8543b5912dbcb69be94c3e69 Mon Sep 17 00:00:00 2001
+From: Joel Stanley <joel@jms.id.au>
+Date: Fri, 11 Sep 2015 14:43:18 +0930
+Subject: [PATCH 06/17] Revert "powerpc: Reject binutils 2.24 when building
+ little endian"
+
+This reverts commit 60e065f70bdb0b0e916389024922ad40f3270c96.
+
+We know better than Michael does; we carry a patch that fixes our
+binutils.
+
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ arch/powerpc/Makefile | 8 --------
+ 1 file changed, 8 deletions(-)
+
+diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
+index 05f464e..b2ae85d 100644
+--- a/arch/powerpc/Makefile
++++ b/arch/powerpc/Makefile
+@@ -358,14 +358,6 @@ checkbin:
+ 		echo 'disable kernel modules' ; \
+ 		false ; \
+ 	fi
+-	@if test "x${CONFIG_CPU_LITTLE_ENDIAN}" = "xy" \
+-	    && $(LD) --version | head -1 | grep ' 2\.24$$' >/dev/null ; then \
+-		echo -n '*** binutils 2.24 miscompiles weak symbols ' ; \
+-		echo 'in some circumstances.' ; \
+-		echo -n '*** Please use a different binutils version.' ; \
+-		false ; \
+-	fi
+-
+ 
+ CLEAN_FILES += $(TOUT)
+ 
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0007-aacraid-Fix-for-LD-name-and-UID-not-exposed-to-OS.patch b/openpower/linux/linux-0007-aacraid-Fix-for-LD-name-and-UID-not-exposed-to-OS.patch
new file mode 100644
index 0000000..0137c0b
--- /dev/null
+++ b/openpower/linux/linux-0007-aacraid-Fix-for-LD-name-and-UID-not-exposed-to-OS.patch
@@ -0,0 +1,41 @@
+From 6e9462ff5c5a1a4acdea277a8a5ba5c82c287b62 Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:33 -0400
+Subject: [PATCH 07/17] aacraid: Fix for LD name and UID not exposed to OS
+
+Driver sends the right size of the response buffer.
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aachba.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
+index 9b3dd6e..fe59b00 100644
+--- a/drivers/scsi/aacraid/aachba.c
++++ b/drivers/scsi/aacraid/aachba.c
+@@ -570,7 +570,7 @@ static int aac_get_container_name(struct scsi_cmnd * scsicmd)
+ 
+ 	status = aac_fib_send(ContainerCommand,
+ 		  cmd_fibcontext,
+-		  sizeof (struct aac_get_name),
++		  sizeof(struct aac_get_name_resp),
+ 		  FsaNormal,
+ 		  0, 1,
+ 		  (fib_callback)get_container_name_callback,
+@@ -1052,7 +1052,7 @@ static int aac_get_container_serial(struct scsi_cmnd * scsicmd)
+ 
+ 	status = aac_fib_send(ContainerCommand,
+ 		  cmd_fibcontext,
+-		  sizeof (struct aac_get_serial),
++		  sizeof(struct aac_get_serial_resp),
+ 		  FsaNormal,
+ 		  0, 1,
+ 		  (fib_callback) get_container_serial_callback,
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0008-aacraid-Add-Power-Management-support.patch b/openpower/linux/linux-0008-aacraid-Add-Power-Management-support.patch
new file mode 100644
index 0000000..d0b5a34
--- /dev/null
+++ b/openpower/linux/linux-0008-aacraid-Add-Power-Management-support.patch
@@ -0,0 +1,441 @@
+From 608f633800ba170ccdcaf8797fce5787f038eefb Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:34 -0400
+Subject: [PATCH 08/17] aacraid: Add Power Management support
+
+* .suspend() and .resume() routines implemented in the driver
+* aac_release_resources() initiates firmware shutdown
+* aac_acquire_resources re-initializes the host interface
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aacraid.h  |   5 ++
+ drivers/scsi/aacraid/comminit.c | 154 ++++++++++++++++++++--------------------
+ drivers/scsi/aacraid/linit.c    | 147 ++++++++++++++++++++++++++++++++++++++
+ drivers/scsi/aacraid/rx.c       |   1 +
+ drivers/scsi/aacraid/sa.c       |   1 +
+ drivers/scsi/aacraid/src.c      |   2 +
+ 6 files changed, 232 insertions(+), 78 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
+index 40fe65c..62b0999 100644
+--- a/drivers/scsi/aacraid/aacraid.h
++++ b/drivers/scsi/aacraid/aacraid.h
+@@ -547,6 +547,7 @@ struct adapter_ops
+ 	int  (*adapter_sync_cmd)(struct aac_dev *dev, u32 command, u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4);
+ 	int  (*adapter_check_health)(struct aac_dev *dev);
+ 	int  (*adapter_restart)(struct aac_dev *dev, int bled);
++	void (*adapter_start)(struct aac_dev *dev);
+ 	/* Transport operations */
+ 	int  (*adapter_ioremap)(struct aac_dev * dev, u32 size);
+ 	irq_handler_t adapter_intr;
+@@ -1247,6 +1248,9 @@ struct aac_dev
+ #define aac_adapter_restart(dev,bled) \
+ 	(dev)->a_ops.adapter_restart(dev,bled)
+ 
++#define aac_adapter_start(dev) \
++	((dev)->a_ops.adapter_start(dev))
++
+ #define aac_adapter_ioremap(dev, size) \
+ 	(dev)->a_ops.adapter_ioremap(dev, size)
+ 
+@@ -2127,6 +2131,7 @@ int aac_sa_init(struct aac_dev *dev);
+ int aac_src_init(struct aac_dev *dev);
+ int aac_srcv_init(struct aac_dev *dev);
+ int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw_fib, int wait, struct fib * fibptr, unsigned long *nonotify);
++void aac_define_int_mode(struct aac_dev *dev);
+ unsigned int aac_response_normal(struct aac_queue * q);
+ unsigned int aac_command_normal(struct aac_queue * q);
+ unsigned int aac_intr_normal(struct aac_dev *dev, u32 Index,
+diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
+index 45db84a..45a0a04 100644
+--- a/drivers/scsi/aacraid/comminit.c
++++ b/drivers/scsi/aacraid/comminit.c
+@@ -43,8 +43,6 @@
+ 
+ #include "aacraid.h"
+ 
+-static void aac_define_int_mode(struct aac_dev *dev);
+-
+ struct aac_common aac_config = {
+ 	.irq_mod = 1
+ };
+@@ -338,6 +336,82 @@ static int aac_comm_init(struct aac_dev * dev)
+ 	return 0;
+ }
+ 
++void aac_define_int_mode(struct aac_dev *dev)
++{
++	int i, msi_count;
++
++	msi_count = i = 0;
++	/* max. vectors from GET_COMM_PREFERRED_SETTINGS */
++	if (dev->max_msix == 0 ||
++	    dev->pdev->device == PMC_DEVICE_S6 ||
++	    dev->sync_mode) {
++		dev->max_msix = 1;
++		dev->vector_cap =
++			dev->scsi_host_ptr->can_queue +
++			AAC_NUM_MGT_FIB;
++		return;
++	}
++
++	/* Don't bother allocating more MSI-X vectors than cpus */
++	msi_count = min(dev->max_msix,
++		(unsigned int)num_online_cpus());
++
++	dev->max_msix = msi_count;
++
++	if (msi_count > AAC_MAX_MSIX)
++		msi_count = AAC_MAX_MSIX;
++
++	for (i = 0; i < msi_count; i++)
++		dev->msixentry[i].entry = i;
++
++	if (msi_count > 1 &&
++	    pci_find_capability(dev->pdev, PCI_CAP_ID_MSIX)) {
++		i = pci_enable_msix(dev->pdev,
++				    dev->msixentry,
++				    msi_count);
++		 /* Check how many MSIX vectors are allocated */
++		if (i >= 0) {
++			dev->msi_enabled = 1;
++			if (i) {
++				msi_count = i;
++				if (pci_enable_msix(dev->pdev,
++				    dev->msixentry,
++				    msi_count)) {
++					dev->msi_enabled = 0;
++					printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
++							dev->name, dev->id, i);
++				}
++			}
++		} else {
++			dev->msi_enabled = 0;
++			printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
++					dev->name, dev->id, i);
++		}
++	}
++
++	if (!dev->msi_enabled) {
++		msi_count = 1;
++		i = pci_enable_msi(dev->pdev);
++
++		if (!i) {
++			dev->msi_enabled = 1;
++			dev->msi = 1;
++		} else {
++			printk(KERN_ERR "%s%d: MSI not supported!! Will try INTx 0x%x.\n",
++					dev->name, dev->id, i);
++		}
++	}
++
++	if (!dev->msi_enabled)
++		dev->max_msix = msi_count = 1;
++	else {
++		if (dev->max_msix > msi_count)
++			dev->max_msix = msi_count;
++	}
++	dev->vector_cap =
++		(dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) /
++		msi_count;
++}
+ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
+ {
+ 	u32 status[5];
+@@ -508,79 +582,3 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
+ 	return dev;
+ }
+ 
+-static void aac_define_int_mode(struct aac_dev *dev)
+-{
+-
+-	int i, msi_count;
+-
+-	msi_count = i = 0;
+-	/* max. vectors from GET_COMM_PREFERRED_SETTINGS */
+-	if (dev->max_msix == 0 ||
+-	    dev->pdev->device == PMC_DEVICE_S6 ||
+-	    dev->sync_mode) {
+-		dev->max_msix = 1;
+-		dev->vector_cap =
+-			dev->scsi_host_ptr->can_queue +
+-			AAC_NUM_MGT_FIB;
+-		return;
+-	}
+-
+-	msi_count = min(dev->max_msix,
+-		(unsigned int)num_online_cpus());
+-
+-	dev->max_msix = msi_count;
+-
+-	if (msi_count > AAC_MAX_MSIX)
+-		msi_count = AAC_MAX_MSIX;
+-
+-	for (i = 0; i < msi_count; i++)
+-		dev->msixentry[i].entry = i;
+-
+-	if (msi_count > 1 &&
+-	    pci_find_capability(dev->pdev, PCI_CAP_ID_MSIX)) {
+-		i = pci_enable_msix(dev->pdev,
+-				    dev->msixentry,
+-				    msi_count);
+-		 /* Check how many MSIX vectors are allocated */
+-		if (i >= 0) {
+-			dev->msi_enabled = 1;
+-			if (i) {
+-				msi_count = i;
+-				if (pci_enable_msix(dev->pdev,
+-				    dev->msixentry,
+-				    msi_count)) {
+-					dev->msi_enabled = 0;
+-					printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
+-							dev->name, dev->id, i);
+-				}
+-			}
+-		} else {
+-			dev->msi_enabled = 0;
+-			printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
+-					dev->name, dev->id, i);
+-		}
+-	}
+-
+-	if (!dev->msi_enabled) {
+-		msi_count = 1;
+-		i = pci_enable_msi(dev->pdev);
+-
+-		if (!i) {
+-			dev->msi_enabled = 1;
+-			dev->msi = 1;
+-		} else {
+-			printk(KERN_ERR "%s%d: MSI not supported!! Will try INTx 0x%x.\n",
+-					dev->name, dev->id, i);
+-		}
+-	}
+-
+-	if (!dev->msi_enabled)
+-		dev->max_msix = msi_count = 1;
+-	else {
+-		if (dev->max_msix > msi_count)
+-			dev->max_msix = msi_count;
+-	}
+-	dev->vector_cap =
+-		(dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) /
+-		msi_count;
+-}
+diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
+index 9eec027..37375cf 100644
+--- a/drivers/scsi/aacraid/linit.c
++++ b/drivers/scsi/aacraid/linit.c
+@@ -1317,6 +1317,149 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
+ 	return error;
+ }
+ 
++#if (defined(CONFIG_PM))
++void aac_release_resources(struct aac_dev *aac)
++{
++	int i;
++
++	aac_adapter_disable_int(aac);
++	if (aac->pdev->device == PMC_DEVICE_S6 ||
++	    aac->pdev->device == PMC_DEVICE_S7 ||
++	    aac->pdev->device == PMC_DEVICE_S8 ||
++	    aac->pdev->device == PMC_DEVICE_S9) {
++		if (aac->max_msix > 1) {
++			for (i = 0; i < aac->max_msix; i++)
++				free_irq(aac->msixentry[i].vector,
++					&(aac->aac_msix[i]));
++		} else {
++			free_irq(aac->pdev->irq, &(aac->aac_msix[0]));
++		}
++	} else {
++		free_irq(aac->pdev->irq, aac);
++	}
++	if (aac->msi)
++		pci_disable_msi(aac->pdev);
++	else if (aac->max_msix > 1)
++		pci_disable_msix(aac->pdev);
++
++}
++
++static int aac_acquire_resources(struct aac_dev *dev)
++{
++	int i, j;
++	int instance = dev->id;
++	const char *name = dev->name;
++	unsigned long status;
++	/*
++	 *	First clear out all interrupts.  Then enable the one's that we
++	 *	can handle.
++	 */
++	while (!((status = src_readl(dev, MUnit.OMR)) & KERNEL_UP_AND_RUNNING)
++		|| status == 0xffffffff)
++			msleep(20);
++
++	aac_adapter_disable_int(dev);
++	aac_adapter_enable_int(dev);
++
++
++	if ((dev->pdev->device == PMC_DEVICE_S7 ||
++	     dev->pdev->device == PMC_DEVICE_S8 ||
++	     dev->pdev->device == PMC_DEVICE_S9))
++		aac_define_int_mode(dev);
++
++	if (dev->msi_enabled)
++		aac_src_access_devreg(dev, AAC_ENABLE_MSIX);
++
++	if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
++		for (i = 0; i < dev->max_msix; i++) {
++			dev->aac_msix[i].vector_no = i;
++			dev->aac_msix[i].dev = dev;
++
++			if (request_irq(dev->msixentry[i].vector,
++					dev->a_ops.adapter_intr,
++					0, "aacraid", &(dev->aac_msix[i]))) {
++				printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
++						name, instance, i);
++				for (j = 0 ; j < i ; j++)
++					free_irq(dev->msixentry[j].vector,
++						 &(dev->aac_msix[j]));
++				pci_disable_msix(dev->pdev);
++				goto error_iounmap;
++			}
++		}
++	} else {
++		dev->aac_msix[0].vector_no = 0;
++		dev->aac_msix[0].dev = dev;
++
++		if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
++			IRQF_SHARED, "aacraid",
++			&(dev->aac_msix[0])) < 0) {
++			if (dev->msi)
++				pci_disable_msi(dev->pdev);
++			printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
++					name, instance);
++			goto error_iounmap;
++		}
++	}
++
++	aac_adapter_enable_int(dev);
++
++	if (!dev->sync_mode)
++		aac_adapter_start(dev);
++	return 0;
++
++error_iounmap:
++	return -1;
++
++}
++static int aac_suspend(struct pci_dev *pdev, pm_message_t state)
++{
++
++	struct Scsi_Host *shost = pci_get_drvdata(pdev);
++	struct aac_dev *aac = (struct aac_dev *)shost->hostdata;
++
++	scsi_block_requests(shost);
++	aac_send_shutdown(aac);
++
++	aac_release_resources(aac);
++
++	pci_set_drvdata(pdev, shost);
++	pci_save_state(pdev);
++	pci_disable_device(pdev);
++	pci_set_power_state(pdev, pci_choose_state(pdev, state));
++
++	return 0;
++}
++
++static int aac_resume(struct pci_dev *pdev)
++{
++	struct Scsi_Host *shost = pci_get_drvdata(pdev);
++	struct aac_dev *aac = (struct aac_dev *)shost->hostdata;
++	int r;
++
++	pci_set_power_state(pdev, PCI_D0);
++	pci_enable_wake(pdev, PCI_D0, 0);
++	pci_restore_state(pdev);
++	r = pci_enable_device(pdev);
++
++	if (r)
++		goto fail_device;
++
++	pci_set_master(pdev);
++	if (aac_acquire_resources(aac))
++		goto fail_device;
++	scsi_unblock_requests(shost);
++
++	return 0;
++
++fail_device:
++	printk(KERN_INFO "%s%d: resume failed.\n", aac->name, aac->id);
++	scsi_host_put(shost);
++	pci_disable_device(pdev);
++	return -ENODEV;
++}
++#endif
++
+ static void aac_shutdown(struct pci_dev *dev)
+ {
+ 	struct Scsi_Host *shost = pci_get_drvdata(dev);
+@@ -1356,6 +1499,10 @@ static struct pci_driver aac_pci_driver = {
+ 	.id_table	= aac_pci_tbl,
+ 	.probe		= aac_probe_one,
+ 	.remove		= aac_remove_one,
++#if (defined(CONFIG_PM))
++	.suspend	= aac_suspend,
++	.resume		= aac_resume,
++#endif
+ 	.shutdown	= aac_shutdown,
+ };
+ 
+diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c
+index 9570612..ac16380 100644
+--- a/drivers/scsi/aacraid/rx.c
++++ b/drivers/scsi/aacraid/rx.c
+@@ -623,6 +623,7 @@ int _aac_rx_init(struct aac_dev *dev)
+ 	dev->a_ops.adapter_sync_cmd = rx_sync_cmd;
+ 	dev->a_ops.adapter_check_health = aac_rx_check_health;
+ 	dev->a_ops.adapter_restart = aac_rx_restart_adapter;
++	dev->a_ops.adapter_start = aac_rx_start_adapter;
+ 
+ 	/*
+ 	 *	First clear out all interrupts.  Then enable the one's that we
+diff --git a/drivers/scsi/aacraid/sa.c b/drivers/scsi/aacraid/sa.c
+index e66477c..869aea2 100644
+--- a/drivers/scsi/aacraid/sa.c
++++ b/drivers/scsi/aacraid/sa.c
+@@ -372,6 +372,7 @@ int aac_sa_init(struct aac_dev *dev)
+ 	dev->a_ops.adapter_sync_cmd = sa_sync_cmd;
+ 	dev->a_ops.adapter_check_health = aac_sa_check_health;
+ 	dev->a_ops.adapter_restart = aac_sa_restart_adapter;
++	dev->a_ops.adapter_start = aac_sa_start_adapter;
+ 	dev->a_ops.adapter_intr = aac_sa_intr;
+ 	dev->a_ops.adapter_deliver = aac_rx_deliver_producer;
+ 	dev->a_ops.adapter_ioremap = aac_sa_ioremap;
+diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
+index e63cf9f..b147341 100644
+--- a/drivers/scsi/aacraid/src.c
++++ b/drivers/scsi/aacraid/src.c
+@@ -726,6 +726,7 @@ int aac_src_init(struct aac_dev *dev)
+ 	dev->a_ops.adapter_sync_cmd = src_sync_cmd;
+ 	dev->a_ops.adapter_check_health = aac_src_check_health;
+ 	dev->a_ops.adapter_restart = aac_src_restart_adapter;
++	dev->a_ops.adapter_start = aac_src_start_adapter;
+ 
+ 	/*
+ 	 *	First clear out all interrupts.  Then enable the one's that we
+@@ -892,6 +893,7 @@ int aac_srcv_init(struct aac_dev *dev)
+ 	dev->a_ops.adapter_sync_cmd = src_sync_cmd;
+ 	dev->a_ops.adapter_check_health = aac_src_check_health;
+ 	dev->a_ops.adapter_restart = aac_src_restart_adapter;
++	dev->a_ops.adapter_start = aac_src_start_adapter;
+ 
+ 	/*
+ 	 *	First clear out all interrupts.  Then enable the one's that we
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0009-aacraid-Change-interrupt-mode-to-MSI-for-Series-6.patch b/openpower/linux/linux-0009-aacraid-Change-interrupt-mode-to-MSI-for-Series-6.patch
new file mode 100644
index 0000000..f7443a7
--- /dev/null
+++ b/openpower/linux/linux-0009-aacraid-Change-interrupt-mode-to-MSI-for-Series-6.patch
@@ -0,0 +1,46 @@
+From 9b99db2b1e54238f98477cdad37dba34731792be Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:35 -0400
+Subject: [PATCH 09/17] aacraid: Change interrupt mode to MSI for Series 6
+
+This change always sets MSI interrupt mode for series-6 controller.
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aachba.c | 2 +-
+ drivers/scsi/aacraid/src.c    | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
+index fe59b00..05f2a02 100644
+--- a/drivers/scsi/aacraid/aachba.c
++++ b/drivers/scsi/aacraid/aachba.c
+@@ -259,7 +259,7 @@ MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the"
+ 	" 0=off, 1=on");
+ module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR);
+ MODULE_PARM_DESC(msi, "IRQ handling."
+-	" 0=PIC(default), 1=MSI, 2=MSI-X(unsupported, uses MSI)");
++	" 0=PIC(default), 1=MSI, 2=MSI-X)");
+ module_param(startup_timeout, int, S_IRUGO|S_IWUSR);
+ MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for"
+ 	" adapter to have it's kernel up and\n"
+diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
+index b147341..eb07b3d 100644
+--- a/drivers/scsi/aacraid/src.c
++++ b/drivers/scsi/aacraid/src.c
+@@ -742,7 +742,7 @@ int aac_src_init(struct aac_dev *dev)
+ 	if (dev->comm_interface != AAC_COMM_MESSAGE_TYPE1)
+ 		goto error_iounmap;
+ 
+-	dev->msi = aac_msi && !pci_enable_msi(dev->pdev);
++	dev->msi = !pci_enable_msi(dev->pdev);
+ 
+ 	dev->aac_msix[0].vector_no = 0;
+ 	dev->aac_msix[0].dev = dev;
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0010-aacraid-Tune-response-path-if-IsFastPath-bit-set.patch b/openpower/linux/linux-0010-aacraid-Tune-response-path-if-IsFastPath-bit-set.patch
new file mode 100644
index 0000000..6b00b29
--- /dev/null
+++ b/openpower/linux/linux-0010-aacraid-Tune-response-path-if-IsFastPath-bit-set.patch
@@ -0,0 +1,319 @@
+From 841c01b02751a163bd66ab6ad0c5b7b7e147b47d Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:37 -0400
+Subject: [PATCH 10/17] aacraid: Tune response path if IsFastPath bit set
+
+If 'IsFastPath' bit is set, then response path assumes no error and skips error check.
+
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aachba.c | 259 ++++++++++++++++++++++--------------------
+ 1 file changed, 137 insertions(+), 122 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
+index 05f2a02..e4c2437 100644
+--- a/drivers/scsi/aacraid/aachba.c
++++ b/drivers/scsi/aacraid/aachba.c
+@@ -2977,11 +2977,16 @@ static void aac_srb_callback(void *context, struct fib * fibptr)
+ 		return;
+ 
+ 	BUG_ON(fibptr == NULL);
+-
+ 	dev = fibptr->dev;
+ 
+-	srbreply = (struct aac_srb_reply *) fib_data(fibptr);
++	scsi_dma_unmap(scsicmd);
+ 
++	/* expose physical device if expose_physicald flag is on */
++	if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01)
++	  && expose_physicals > 0)
++		aac_expose_phy_device(scsicmd);
++
++	srbreply = (struct aac_srb_reply *) fib_data(fibptr);
+ 	scsicmd->sense_buffer[0] = '\0';  /* Initialize sense valid flag to false */
+ 
+ 	if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) {
+@@ -2994,147 +2999,157 @@ static void aac_srb_callback(void *context, struct fib * fibptr)
+ 		 */
+ 		scsi_set_resid(scsicmd, scsi_bufflen(scsicmd)
+ 				   - le32_to_cpu(srbreply->data_xfer_length));
+-	}
+-
+-	scsi_dma_unmap(scsicmd);
+-
+-	/* expose physical device if expose_physicald flag is on */
+-	if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01)
+-	  && expose_physicals > 0)
+-		aac_expose_phy_device(scsicmd);
++		/*
++		 * First check the fib status
++		 */
+ 
+-	/*
+-	 * First check the fib status
+-	 */
++		if (le32_to_cpu(srbreply->status) != ST_OK) {
++			int len;
+ 
+-	if (le32_to_cpu(srbreply->status) != ST_OK){
+-		int len;
+-		printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status));
+-		len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
+-			    SCSI_SENSE_BUFFERSIZE);
+-		scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
+-		memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
+-	}
++			printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status));
++			len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
++				    SCSI_SENSE_BUFFERSIZE);
++			scsicmd->result = DID_ERROR << 16
++						| COMMAND_COMPLETE << 8
++						| SAM_STAT_CHECK_CONDITION;
++			memcpy(scsicmd->sense_buffer,
++					srbreply->sense_data, len);
++		}
+ 
+-	/*
+-	 * Next check the srb status
+-	 */
+-	switch( (le32_to_cpu(srbreply->srb_status))&0x3f){
+-	case SRB_STATUS_ERROR_RECOVERY:
+-	case SRB_STATUS_PENDING:
+-	case SRB_STATUS_SUCCESS:
+-		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
+-		break;
+-	case SRB_STATUS_DATA_OVERRUN:
+-		switch(scsicmd->cmnd[0]){
+-		case  READ_6:
+-		case  WRITE_6:
+-		case  READ_10:
+-		case  WRITE_10:
+-		case  READ_12:
+-		case  WRITE_12:
+-		case  READ_16:
+-		case  WRITE_16:
+-			if (le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow) {
+-				printk(KERN_WARNING"aacraid: SCSI CMD underflow\n");
+-			} else {
+-				printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n");
++		/*
++		 * Next check the srb status
++		 */
++		switch ((le32_to_cpu(srbreply->srb_status))&0x3f) {
++		case SRB_STATUS_ERROR_RECOVERY:
++		case SRB_STATUS_PENDING:
++		case SRB_STATUS_SUCCESS:
++			scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
++			break;
++		case SRB_STATUS_DATA_OVERRUN:
++			switch (scsicmd->cmnd[0]) {
++			case  READ_6:
++			case  WRITE_6:
++			case  READ_10:
++			case  WRITE_10:
++			case  READ_12:
++			case  WRITE_12:
++			case  READ_16:
++			case  WRITE_16:
++				if (le32_to_cpu(srbreply->data_xfer_length)
++							< scsicmd->underflow)
++					printk(KERN_WARNING"aacraid: SCSI CMD underflow\n");
++				else
++					printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n");
++				scsicmd->result = DID_ERROR << 16
++							| COMMAND_COMPLETE << 8;
++				break;
++			case INQUIRY: {
++				scsicmd->result = DID_OK << 16
++							| COMMAND_COMPLETE << 8;
++				break;
++			}
++			default:
++				scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
++				break;
+ 			}
+-			scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8;
+ 			break;
+-		case INQUIRY: {
+-			scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
++		case SRB_STATUS_ABORTED:
++			scsicmd->result = DID_ABORT << 16 | ABORT << 8;
+ 			break;
+-		}
+-		default:
+-			scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
++		case SRB_STATUS_ABORT_FAILED:
++			/*
++			 * Not sure about this one - but assuming the
++			 * hba was trying to abort for some reason
++			 */
++			scsicmd->result = DID_ERROR << 16 | ABORT << 8;
++			break;
++		case SRB_STATUS_PARITY_ERROR:
++			scsicmd->result = DID_PARITY << 16
++						| MSG_PARITY_ERROR << 8;
++			break;
++		case SRB_STATUS_NO_DEVICE:
++		case SRB_STATUS_INVALID_PATH_ID:
++		case SRB_STATUS_INVALID_TARGET_ID:
++		case SRB_STATUS_INVALID_LUN:
++		case SRB_STATUS_SELECTION_TIMEOUT:
++			scsicmd->result = DID_NO_CONNECT << 16
++						| COMMAND_COMPLETE << 8;
+ 			break;
+-		}
+-		break;
+-	case SRB_STATUS_ABORTED:
+-		scsicmd->result = DID_ABORT << 16 | ABORT << 8;
+-		break;
+-	case SRB_STATUS_ABORT_FAILED:
+-		// Not sure about this one - but assuming the hba was trying to abort for some reason
+-		scsicmd->result = DID_ERROR << 16 | ABORT << 8;
+-		break;
+-	case SRB_STATUS_PARITY_ERROR:
+-		scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8;
+-		break;
+-	case SRB_STATUS_NO_DEVICE:
+-	case SRB_STATUS_INVALID_PATH_ID:
+-	case SRB_STATUS_INVALID_TARGET_ID:
+-	case SRB_STATUS_INVALID_LUN:
+-	case SRB_STATUS_SELECTION_TIMEOUT:
+-		scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
+-		break;
+ 
+-	case SRB_STATUS_COMMAND_TIMEOUT:
+-	case SRB_STATUS_TIMEOUT:
+-		scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8;
+-		break;
++		case SRB_STATUS_COMMAND_TIMEOUT:
++		case SRB_STATUS_TIMEOUT:
++			scsicmd->result = DID_TIME_OUT << 16
++						| COMMAND_COMPLETE << 8;
++			break;
+ 
+-	case SRB_STATUS_BUSY:
+-		scsicmd->result = DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8;
+-		break;
++		case SRB_STATUS_BUSY:
++			scsicmd->result = DID_BUS_BUSY << 16
++						| COMMAND_COMPLETE << 8;
++			break;
+ 
+-	case SRB_STATUS_BUS_RESET:
+-		scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8;
+-		break;
++		case SRB_STATUS_BUS_RESET:
++			scsicmd->result = DID_RESET << 16
++						| COMMAND_COMPLETE << 8;
++			break;
+ 
+-	case SRB_STATUS_MESSAGE_REJECTED:
+-		scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8;
+-		break;
+-	case SRB_STATUS_REQUEST_FLUSHED:
+-	case SRB_STATUS_ERROR:
+-	case SRB_STATUS_INVALID_REQUEST:
+-	case SRB_STATUS_REQUEST_SENSE_FAILED:
+-	case SRB_STATUS_NO_HBA:
+-	case SRB_STATUS_UNEXPECTED_BUS_FREE:
+-	case SRB_STATUS_PHASE_SEQUENCE_FAILURE:
+-	case SRB_STATUS_BAD_SRB_BLOCK_LENGTH:
+-	case SRB_STATUS_DELAYED_RETRY:
+-	case SRB_STATUS_BAD_FUNCTION:
+-	case SRB_STATUS_NOT_STARTED:
+-	case SRB_STATUS_NOT_IN_USE:
+-	case SRB_STATUS_FORCE_ABORT:
+-	case SRB_STATUS_DOMAIN_VALIDATION_FAIL:
+-	default:
++		case SRB_STATUS_MESSAGE_REJECTED:
++			scsicmd->result = DID_ERROR << 16
++						| MESSAGE_REJECT << 8;
++			break;
++		case SRB_STATUS_REQUEST_FLUSHED:
++		case SRB_STATUS_ERROR:
++		case SRB_STATUS_INVALID_REQUEST:
++		case SRB_STATUS_REQUEST_SENSE_FAILED:
++		case SRB_STATUS_NO_HBA:
++		case SRB_STATUS_UNEXPECTED_BUS_FREE:
++		case SRB_STATUS_PHASE_SEQUENCE_FAILURE:
++		case SRB_STATUS_BAD_SRB_BLOCK_LENGTH:
++		case SRB_STATUS_DELAYED_RETRY:
++		case SRB_STATUS_BAD_FUNCTION:
++		case SRB_STATUS_NOT_STARTED:
++		case SRB_STATUS_NOT_IN_USE:
++		case SRB_STATUS_FORCE_ABORT:
++		case SRB_STATUS_DOMAIN_VALIDATION_FAIL:
++		default:
+ #ifdef AAC_DETAILED_STATUS_INFO
+-		printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n",
+-			le32_to_cpu(srbreply->srb_status) & 0x3F,
+-			aac_get_status_string(
+-				le32_to_cpu(srbreply->srb_status) & 0x3F),
+-			scsicmd->cmnd[0],
+-			le32_to_cpu(srbreply->scsi_status));
++			printk(KERN_INFO "aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n",
++				le32_to_cpu(srbreply->srb_status) & 0x3F,
++				aac_get_status_string(
++					le32_to_cpu(srbreply->srb_status) & 0x3F),
++				scsicmd->cmnd[0],
++				le32_to_cpu(srbreply->scsi_status));
+ #endif
+-		if ((scsicmd->cmnd[0] == ATA_12)
+-		  || (scsicmd->cmnd[0] == ATA_16)) {
+-			if (scsicmd->cmnd[2] & (0x01 << 5)) {
+-				scsicmd->result = DID_OK << 16
+-						| COMMAND_COMPLETE << 8;
++			if ((scsicmd->cmnd[0] == ATA_12)
++				|| (scsicmd->cmnd[0] == ATA_16)) {
++					if (scsicmd->cmnd[2] & (0x01 << 5)) {
++						scsicmd->result = DID_OK << 16
++							| COMMAND_COMPLETE << 8;
+ 				break;
++				} else {
++					scsicmd->result = DID_ERROR << 16
++						| COMMAND_COMPLETE << 8;
++					break;
++				}
+ 			} else {
+ 				scsicmd->result = DID_ERROR << 16
+-						| COMMAND_COMPLETE << 8;
++					| COMMAND_COMPLETE << 8;
+ 				break;
+ 			}
+-		} else {
+-			scsicmd->result = DID_ERROR << 16
+-					| COMMAND_COMPLETE << 8;
+-			break;
+ 		}
+-	}
+-	if (le32_to_cpu(srbreply->scsi_status) == SAM_STAT_CHECK_CONDITION) {
+-		int len;
+-		scsicmd->result |= SAM_STAT_CHECK_CONDITION;
+-		len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
+-			    SCSI_SENSE_BUFFERSIZE);
++		if (le32_to_cpu(srbreply->scsi_status)
++				== SAM_STAT_CHECK_CONDITION) {
++			int len;
++
++			scsicmd->result |= SAM_STAT_CHECK_CONDITION;
++			len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
++				    SCSI_SENSE_BUFFERSIZE);
+ #ifdef AAC_DETAILED_STATUS_INFO
+-		printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n",
+-					le32_to_cpu(srbreply->status), len);
++			printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n",
++						le32_to_cpu(srbreply->status), len);
+ #endif
+-		memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
++			memcpy(scsicmd->sense_buffer,
++					srbreply->sense_data, len);
++		}
+ 	}
+ 	/*
+ 	 * OR in the scsi status (already shifted up a bit)
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0011-aacraid-Enable-64bit-write-to-controller-register.patch b/openpower/linux/linux-0011-aacraid-Enable-64bit-write-to-controller-register.patch
new file mode 100644
index 0000000..7215274
--- /dev/null
+++ b/openpower/linux/linux-0011-aacraid-Enable-64bit-write-to-controller-register.patch
@@ -0,0 +1,92 @@
+From a7aac5e60943c0d40f2b7d9ce0a6462e4479800d Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:36 -0400
+Subject: [PATCH 11/17] aacraid: Enable 64bit write to controller register
+
+If writeq() not supported, then do atomic two 32bit write
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aacraid.h  |  9 +++++++++
+ drivers/scsi/aacraid/comminit.c |  1 +
+ drivers/scsi/aacraid/src.c      | 12 ++++++++++--
+ 3 files changed, 20 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
+index 62b0999..e54f597 100644
+--- a/drivers/scsi/aacraid/aacraid.h
++++ b/drivers/scsi/aacraid/aacraid.h
+@@ -844,6 +844,10 @@ struct src_registers {
+ 						&((AEP)->regs.src.bar0->CSR))
+ #define src_writel(AEP, CSR, value)	writel(value, \
+ 						&((AEP)->regs.src.bar0->CSR))
++#if defined(writeq)
++#define	src_writeq(AEP, CSR, value)	writeq(value, \
++						&((AEP)->regs.src.bar0->CSR))
++#endif
+ 
+ #define SRC_ODR_SHIFT		12
+ #define SRC_IDR_SHIFT		9
+@@ -1163,6 +1167,11 @@ struct aac_dev
+ 	struct fsa_dev_info	*fsa_dev;
+ 	struct task_struct	*thread;
+ 	int			cardtype;
++	/*
++	 *This lock will protect the two 32-bit
++	 *writes to the Inbound Queue
++	 */
++	spinlock_t		iq_lock;
+ 
+ 	/*
+ 	 *	The following is the device specific extension.
+diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
+index 45a0a04..b4b6088 100644
+--- a/drivers/scsi/aacraid/comminit.c
++++ b/drivers/scsi/aacraid/comminit.c
+@@ -424,6 +424,7 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
+ 	dev->management_fib_count = 0;
+ 	spin_lock_init(&dev->manage_lock);
+ 	spin_lock_init(&dev->sync_lock);
++	spin_lock_init(&dev->iq_lock);
+ 	dev->max_fib_size = sizeof(struct hw_fib);
+ 	dev->sg_tablesize = host->sg_tablesize = (dev->max_fib_size
+ 		- sizeof(struct aac_fibhdr)
+diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
+index eb07b3d..1409a0b 100644
+--- a/drivers/scsi/aacraid/src.c
++++ b/drivers/scsi/aacraid/src.c
+@@ -447,6 +447,10 @@ static int aac_src_deliver_message(struct fib *fib)
+ 	u32 fibsize;
+ 	dma_addr_t address;
+ 	struct aac_fib_xporthdr *pFibX;
++#if !defined(writeq)
++	unsigned long flags;
++#endif
++
+ 	u16 hdr_size = le16_to_cpu(fib->hw_fib_va->header.Size);
+ 
+ 	atomic_inc(&q->numpending);
+@@ -511,10 +515,14 @@ static int aac_src_deliver_message(struct fib *fib)
+ 			return -EINVAL;
+ 		address |= fibsize;
+ 	}
+-
++#if defined(writeq)
++	src_writeq(dev, MUnit.IQ_L, (u64)address);
++#else
++	spin_lock_irqsave(&fib->dev->iq_lock, flags);
+ 	src_writel(dev, MUnit.IQ_H, upper_32_bits(address) & 0xffffffff);
+ 	src_writel(dev, MUnit.IQ_L, address & 0xffffffff);
+-
++	spin_unlock_irqrestore(&fib->dev->iq_lock, flags);
++#endif
+ 	return 0;
+ }
+ 
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0012-aacraid-IOCTL-fix.patch b/openpower/linux/linux-0012-aacraid-IOCTL-fix.patch
new file mode 100644
index 0000000..f4057e3
--- /dev/null
+++ b/openpower/linux/linux-0012-aacraid-IOCTL-fix.patch
@@ -0,0 +1,36 @@
+From 97d883832a9083aad13b736b2e513307edd1216d Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:39 -0400
+Subject: [PATCH 12/17] aacraid: IOCTL fix
+
+Driver blocks ioctls once it received shutdown/suspend request during
+suspend/hybernation. This patch unblocks ioctls on resume path.
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/linit.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
+index 37375cf..3b6e5c6 100644
+--- a/drivers/scsi/aacraid/linit.c
++++ b/drivers/scsi/aacraid/linit.c
+@@ -1448,6 +1448,11 @@ static int aac_resume(struct pci_dev *pdev)
+ 	pci_set_master(pdev);
+ 	if (aac_acquire_resources(aac))
+ 		goto fail_device;
++	/*
++	* reset this flag to unblock ioctl() as it was set at
++	* aac_send_shutdown() to block ioctls from upperlayer
++	*/
++	aac->adapter_shutdown = 0;
+ 	scsi_unblock_requests(shost);
+ 
+ 	return 0;
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0013-aacraid-Reset-irq-affinity-hints.patch b/openpower/linux/linux-0013-aacraid-Reset-irq-affinity-hints.patch
new file mode 100644
index 0000000..d32e6fb
--- /dev/null
+++ b/openpower/linux/linux-0013-aacraid-Reset-irq-affinity-hints.patch
@@ -0,0 +1,242 @@
+From 39231523523eadf49e7cc88426dfebc1bf3fcfbe Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:38 -0400
+Subject: [PATCH 13/17] aacraid: Reset irq affinity hints
+
+Reset irq affinity hints before releasing IRQ.
+Removed duplicate code of IRQ acquire/release.
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aacraid.h |   2 +
+ drivers/scsi/aacraid/commsup.c | 113 ++++++++++++++++++++++++++++++-----------
+ drivers/scsi/aacraid/src.c     |  48 ++---------------
+ 3 files changed, 88 insertions(+), 75 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
+index e54f597..7b95227 100644
+--- a/drivers/scsi/aacraid/aacraid.h
++++ b/drivers/scsi/aacraid/aacraid.h
+@@ -2110,6 +2110,8 @@ static inline unsigned int cap_to_cyls(sector_t capacity, unsigned divisor)
+ #define AAC_OWNER_ERROR_HANDLER	0x103
+ #define AAC_OWNER_FIRMWARE	0x106
+ 
++int aac_acquire_irq(struct aac_dev *dev);
++void aac_free_irq(struct aac_dev *dev);
+ const char *aac_driverinfo(struct Scsi_Host *);
+ struct fib *aac_fib_alloc(struct aac_dev *dev);
+ int aac_fib_setup(struct aac_dev *dev);
+diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
+index 4da5749..a1f90fe 100644
+--- a/drivers/scsi/aacraid/commsup.c
++++ b/drivers/scsi/aacraid/commsup.c
+@@ -1270,13 +1270,12 @@ retry_next:
+ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
+ {
+ 	int index, quirks;
+-	int retval, i;
++	int retval;
+ 	struct Scsi_Host *host;
+ 	struct scsi_device *dev;
+ 	struct scsi_cmnd *command;
+ 	struct scsi_cmnd *command_list;
+ 	int jafo = 0;
+-	int cpu;
+ 
+ 	/*
+ 	 * Assumptions:
+@@ -1339,35 +1338,7 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
+ 	aac->comm_phys = 0;
+ 	kfree(aac->queues);
+ 	aac->queues = NULL;
+-	cpu = cpumask_first(cpu_online_mask);
+-	if (aac->pdev->device == PMC_DEVICE_S6 ||
+-	    aac->pdev->device == PMC_DEVICE_S7 ||
+-	    aac->pdev->device == PMC_DEVICE_S8 ||
+-	    aac->pdev->device == PMC_DEVICE_S9) {
+-		if (aac->max_msix > 1) {
+-			for (i = 0; i < aac->max_msix; i++) {
+-				if (irq_set_affinity_hint(
+-				    aac->msixentry[i].vector,
+-				    NULL)) {
+-					printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n",
+-						aac->name,
+-						aac->id,
+-						cpu);
+-				}
+-				cpu = cpumask_next(cpu,
+-						cpu_online_mask);
+-				free_irq(aac->msixentry[i].vector,
+-					 &(aac->aac_msix[i]));
+-			}
+-			pci_disable_msix(aac->pdev);
+-		} else {
+-			free_irq(aac->pdev->irq, &(aac->aac_msix[0]));
+-		}
+-	} else {
+-		free_irq(aac->pdev->irq, aac);
+-	}
+-	if (aac->msi)
+-		pci_disable_msi(aac->pdev);
++	aac_free_irq(aac);
+ 	kfree(aac->fsa_dev);
+ 	aac->fsa_dev = NULL;
+ 	quirks = aac_get_driver_ident(index)->quirks;
+@@ -1978,3 +1949,83 @@ int aac_command_thread(void *data)
+ 	dev->aif_thread = 0;
+ 	return 0;
+ }
++
++int aac_acquire_irq(struct aac_dev *dev)
++{
++	int i;
++	int j;
++	int ret = 0;
++	int cpu;
++
++	cpu = cpumask_first(cpu_online_mask);
++	if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
++		for (i = 0; i < dev->max_msix; i++) {
++			dev->aac_msix[i].vector_no = i;
++			dev->aac_msix[i].dev = dev;
++			if (request_irq(dev->msixentry[i].vector,
++					dev->a_ops.adapter_intr,
++					0, "aacraid", &(dev->aac_msix[i]))) {
++				printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
++						dev->name, dev->id, i);
++				for (j = 0 ; j < i ; j++)
++					free_irq(dev->msixentry[j].vector,
++						 &(dev->aac_msix[j]));
++				pci_disable_msix(dev->pdev);
++				ret = -1;
++			}
++			if (irq_set_affinity_hint(dev->msixentry[i].vector,
++							get_cpu_mask(cpu))) {
++				printk(KERN_ERR "%s%d: Failed to set IRQ affinity for cpu %d\n",
++					    dev->name, dev->id, cpu);
++			}
++			cpu = cpumask_next(cpu, cpu_online_mask);
++		}
++	} else {
++		dev->aac_msix[0].vector_no = 0;
++		dev->aac_msix[0].dev = dev;
++
++		if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
++			IRQF_SHARED, "aacraid",
++			&(dev->aac_msix[0])) < 0) {
++			if (dev->msi)
++				pci_disable_msi(dev->pdev);
++			printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
++					dev->name, dev->id);
++			ret = -1;
++		}
++	}
++	return ret;
++}
++
++void aac_free_irq(struct aac_dev *dev)
++{
++	int i;
++	int cpu;
++
++	cpu = cpumask_first(cpu_online_mask);
++	if (dev->pdev->device == PMC_DEVICE_S6 ||
++	    dev->pdev->device == PMC_DEVICE_S7 ||
++	    dev->pdev->device == PMC_DEVICE_S8 ||
++	    dev->pdev->device == PMC_DEVICE_S9) {
++		if (dev->max_msix > 1) {
++			for (i = 0; i < dev->max_msix; i++) {
++				if (irq_set_affinity_hint(
++					dev->msixentry[i].vector, NULL)) {
++					printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n",
++					    dev->name, dev->id, cpu);
++				}
++				cpu = cpumask_next(cpu, cpu_online_mask);
++				free_irq(dev->msixentry[i].vector,
++						&(dev->aac_msix[i]));
++			}
++		} else {
++			free_irq(dev->pdev->irq, &(dev->aac_msix[0]));
++		}
++	} else {
++		free_irq(dev->pdev->irq, dev);
++	}
++	if (dev->msi)
++		pci_disable_msi(dev->pdev);
++	else if (dev->max_msix > 1)
++		pci_disable_msix(dev->pdev);
++}
+diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
+index 1409a0b..2aa34ea 100644
+--- a/drivers/scsi/aacraid/src.c
++++ b/drivers/scsi/aacraid/src.c
+@@ -798,9 +798,7 @@ int aac_srcv_init(struct aac_dev *dev)
+ 	unsigned long status;
+ 	int restart = 0;
+ 	int instance = dev->id;
+-	int i, j;
+ 	const char *name = dev->name;
+-	int cpu;
+ 
+ 	dev->a_ops.adapter_ioremap = aac_srcv_ioremap;
+ 	dev->a_ops.adapter_comm = aac_src_select_comm;
+@@ -918,48 +916,10 @@ int aac_srcv_init(struct aac_dev *dev)
+ 		goto error_iounmap;
+ 	if (dev->msi_enabled)
+ 		aac_src_access_devreg(dev, AAC_ENABLE_MSIX);
+-	if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
+-		cpu = cpumask_first(cpu_online_mask);
+-		for (i = 0; i < dev->max_msix; i++) {
+-			dev->aac_msix[i].vector_no = i;
+-			dev->aac_msix[i].dev = dev;
+-
+-			if (request_irq(dev->msixentry[i].vector,
+-					dev->a_ops.adapter_intr,
+-					0,
+-					"aacraid",
+-					&(dev->aac_msix[i]))) {
+-				printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
+-						name, instance, i);
+-				for (j = 0 ; j < i ; j++)
+-					free_irq(dev->msixentry[j].vector,
+-						 &(dev->aac_msix[j]));
+-				pci_disable_msix(dev->pdev);
+-				goto error_iounmap;
+-			}
+-			if (irq_set_affinity_hint(
+-			   dev->msixentry[i].vector,
+-			   get_cpu_mask(cpu))) {
+-				printk(KERN_ERR "%s%d: Failed to set IRQ affinity for cpu %d\n",
+-						name, instance, cpu);
+-			}
+-			cpu = cpumask_next(cpu, cpu_online_mask);
+-		}
+-	} else {
+-		dev->aac_msix[0].vector_no = 0;
+-		dev->aac_msix[0].dev = dev;
+-
+-		if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
+-				IRQF_SHARED,
+-				"aacraid",
+-				&(dev->aac_msix[0])) < 0) {
+-			if (dev->msi)
+-				pci_disable_msi(dev->pdev);
+-			printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
+-					name, instance);
+-			goto error_iounmap;
+-		}
+-	}
++
++	if (aac_acquire_irq(dev))
++		goto error_iounmap;
++
+ 	dev->dbg_base = dev->base_start;
+ 	dev->dbg_base_mapped = dev->base;
+ 	dev->dbg_size = dev->base_size;
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0014-aacraid-Use-pci_enable_msix_range.patch b/openpower/linux/linux-0014-aacraid-Use-pci_enable_msix_range.patch
new file mode 100644
index 0000000..41c281b
--- /dev/null
+++ b/openpower/linux/linux-0014-aacraid-Use-pci_enable_msix_range.patch
@@ -0,0 +1,74 @@
+From f0b1e9c3d16c488ef8a92e87c99bdd30ea7c3f11 Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:40 -0400
+Subject: [PATCH 14/17] aacraid: Use pci_enable_msix_range()
+
+As pci_enable_msix() deprecated, replaced with pci_enable_msix_range()
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aacraid.h  |  2 +-
+ drivers/scsi/aacraid/comminit.c | 20 ++++++--------------
+ 2 files changed, 7 insertions(+), 15 deletions(-)
+
+diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
+index 7b95227..2de5ebc 100644
+--- a/drivers/scsi/aacraid/aacraid.h
++++ b/drivers/scsi/aacraid/aacraid.h
+@@ -12,7 +12,7 @@
+  *              D E F I N E S
+  *----------------------------------------------------------------------------*/
+ 
+-#define AAC_MAX_MSIX		8	/* vectors */
++#define AAC_MAX_MSIX		32	/* vectors */
+ #define AAC_PCI_MSI_ENABLE	0x8000
+ 
+ enum {
+diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
+index b4b6088..0e954e3 100644
+--- a/drivers/scsi/aacraid/comminit.c
++++ b/drivers/scsi/aacraid/comminit.c
+@@ -338,7 +338,7 @@ static int aac_comm_init(struct aac_dev * dev)
+ 
+ void aac_define_int_mode(struct aac_dev *dev)
+ {
+-	int i, msi_count;
++	int i, msi_count, min_msix;
+ 
+ 	msi_count = i = 0;
+ 	/* max. vectors from GET_COMM_PREFERRED_SETTINGS */
+@@ -366,22 +366,14 @@ void aac_define_int_mode(struct aac_dev *dev)
+ 
+ 	if (msi_count > 1 &&
+ 	    pci_find_capability(dev->pdev, PCI_CAP_ID_MSIX)) {
+-		i = pci_enable_msix(dev->pdev,
++		min_msix = 2;
++		i = pci_enable_msix_range(dev->pdev,
+ 				    dev->msixentry,
++				    min_msix,
+ 				    msi_count);
+-		 /* Check how many MSIX vectors are allocated */
+-		if (i >= 0) {
++		if (i > 0) {
+ 			dev->msi_enabled = 1;
+-			if (i) {
+-				msi_count = i;
+-				if (pci_enable_msix(dev->pdev,
+-				    dev->msixentry,
+-				    msi_count)) {
+-					dev->msi_enabled = 0;
+-					printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
+-							dev->name, dev->id, i);
+-				}
+-			}
++			msi_count = i;
+ 		} else {
+ 			dev->msi_enabled = 0;
+ 			printk(KERN_ERR "%s%d: MSIX not supported!! Will try MSI 0x%x.\n",
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0015-aacraid-Update-driver-version.patch b/openpower/linux/linux-0015-aacraid-Update-driver-version.patch
new file mode 100644
index 0000000..a815580
--- /dev/null
+++ b/openpower/linux/linux-0015-aacraid-Update-driver-version.patch
@@ -0,0 +1,30 @@
+From 89253aff92b94764266fad985ef25103836575d0 Mon Sep 17 00:00:00 2001
+From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Date: Fri, 28 Aug 2015 06:38:41 -0400
+Subject: [PATCH 15/17] aacraid: Update driver version
+
+Reviewed-by: Tomas Henzl <thenzl@redhat.com>
+Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
+Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
+Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/scsi/aacraid/aacraid.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
+index 2de5ebc..074878b 100644
+--- a/drivers/scsi/aacraid/aacraid.h
++++ b/drivers/scsi/aacraid/aacraid.h
+@@ -62,7 +62,7 @@ enum {
+ #define	PMC_GLOBAL_INT_BIT0		0x00000001
+ 
+ #ifndef AAC_DRIVER_BUILD
+-# define AAC_DRIVER_BUILD 40709
++# define AAC_DRIVER_BUILD 41010
+ # define AAC_DRIVER_BRANCH "-ms"
+ #endif
+ #define MAXIMUM_NUM_CONTAINERS	32
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0016-fbcon-initialize-blink-interval-before-calling-fb_se.patch b/openpower/linux/linux-0016-fbcon-initialize-blink-interval-before-calling-fb_se.patch
new file mode 100644
index 0000000..ff76e76
--- /dev/null
+++ b/openpower/linux/linux-0016-fbcon-initialize-blink-interval-before-calling-fb_se.patch
@@ -0,0 +1,37 @@
+From a9f6fe770be903195109d0839f8192052859251d Mon Sep 17 00:00:00 2001
+From: Scot Doyle <lkml14@scotdoyle.com>
+Date: Fri, 9 Oct 2015 15:08:10 +0000
+Subject: [PATCH 16/17] fbcon: initialize blink interval before calling
+ fb_set_par
+
+Since commit 27a4c827c34ac4256a190cc9d24607f953c1c459
+    fbcon: use the cursor blink interval provided by vt
+
+a PPC64LE kernel fails to boot when fbcon_add_cursor_timer uses an
+uninitialized ops->cur_blink_jiffies. Prevent by initializing
+in fbcon_init before the call to info->fbops->fb_set_par.
+
+Reported-and-tested-by: Alistair Popple <alistair@popple.id.au>
+Signed-off-by: Scot Doyle <lkml14@scotdoyle.com>
+Cc: <stable@vger.kernel.org> [v4.2]
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ drivers/video/console/fbcon.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
+index 1aaf893..92f3949 100644
+--- a/drivers/video/console/fbcon.c
++++ b/drivers/video/console/fbcon.c
+@@ -1093,6 +1093,7 @@ static void fbcon_init(struct vc_data *vc, int init)
+ 		con_copy_unimap(vc, svc);
+ 
+ 	ops = info->fbcon_par;
++	ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms);
+ 	p->con_rotate = initial_rotation;
+ 	set_blitting_type(vc, info);
+ 
+-- 
+2.5.0
+
diff --git a/openpower/linux/linux-0017-Release-4.2.5-openpower1.patch b/openpower/linux/linux-0017-Release-4.2.5-openpower1.patch
new file mode 100644
index 0000000..13e5a90
--- /dev/null
+++ b/openpower/linux/linux-0017-Release-4.2.5-openpower1.patch
@@ -0,0 +1,26 @@
+From b9e362ebebec9d427afd0bf21b1e370929736785 Mon Sep 17 00:00:00 2001
+From: Joel Stanley <joel@jms.id.au>
+Date: Tue, 20 Oct 2015 15:01:06 +1030
+Subject: [PATCH 17/17] Release 4.2.5-openpower1
+
+Signed-off-by: Joel Stanley <joel@jms.id.au>
+---
+ Makefile | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/Makefile b/Makefile
+index 96076dc..e6d6eac2 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ VERSION = 4
+ PATCHLEVEL = 2
+ SUBLEVEL = 5
+-EXTRAVERSION =
++EXTRAVERSION = -openpower1
+ NAME = Hurr durr I'ma sheep
+ 
+ # *DOCUMENTATION*
+-- 
+2.5.0
+
diff --git a/openpower/overlay/etc/fstab b/openpower/overlay/etc/fstab
new file mode 100644
index 0000000..d373dc6
--- /dev/null
+++ b/openpower/overlay/etc/fstab
@@ -0,0 +1,6 @@
+# <file system>	<mount pt>	<type>	<options>	<dump>	<pass>
+/dev/root	/		ext2	rw,noauto	0	1
+proc		/proc		proc	defaults	0	0
+devpts		/dev/pts	devpts	defaults,gid=5,mode=620	0	0
+tmpfs		/dev/shm	tmpfs	mode=0777	0	0
+sysfs		/sys		sysfs	defaults	0	0
diff --git a/openpower/overlay/etc/inittab b/openpower/overlay/etc/inittab
new file mode 100644
index 0000000..235c835
--- /dev/null
+++ b/openpower/overlay/etc/inittab
@@ -0,0 +1,34 @@
+# /etc/inittab
+#
+# Copyright (C) 2001 Erik Andersen <andersen@codepoet.org>
+#
+# Note: BusyBox init doesn't support runlevels.  The runlevels field is
+# completely ignored by BusyBox init. If you want runlevels, use
+# sysvinit.
+#
+# Format for each entry: <id>:<runlevels>:<action>:<process>
+#
+# id        == tty to run on, or empty for /dev/console
+# runlevels == ignored
+# action    == one of sysinit, respawn, askfirst, wait, and once
+# process   == program to run
+
+# Startup the system
+null::sysinit:/bin/mount -t proc proc /proc
+null::sysinit:/bin/mount -o remount,rw / # REMOUNT_ROOTFS_RW
+null::sysinit:/bin/mkdir -p /dev/pts
+null::sysinit:/bin/mkdir -p /dev/shm
+null::sysinit:/bin/mount -a
+null::sysinit:/bin/hostname -F /etc/hostname
+# now run any rc scripts
+null::sysinit:/etc/init.d/rcS
+
+# Stuff to do for the 3-finger salute
+::ctrlaltdel:/sbin/reboot
+
+# Stuff to do before rebooting
+null::shutdown:/etc/init.d/rcK
+null::shutdown:/bin/umount -a -r
+null::shutdown:/sbin/swapoff -a
+
+null::restart:/usr/sbin/kexec-restart
diff --git a/openpower/overlay/etc/locale b/openpower/overlay/etc/locale
new file mode 100644
index 0000000..6737e87
--- /dev/null
+++ b/openpower/overlay/etc/locale
@@ -0,0 +1 @@
+LANG=en_US.utf8
diff --git a/openpower/package/Config.in b/openpower/package/Config.in
index 92ab00f..ab00242 100644
--- a/openpower/package/Config.in
+++ b/openpower/package/Config.in
@@ -6,6 +6,7 @@
 source "$BR2_EXTERNAL/package/firestone-xml/Config.in"
 source "$BR2_EXTERNAL/package/garrison-xml/Config.in"
 source "$BR2_EXTERNAL/package/openpower-pnor/Config.in"
+source "$BR2_EXTERNAL/package/petitboot/Config.in"
 source "$BR2_EXTERNAL/package/p8-pore-binutils/Config.in"
 source "$BR2_EXTERNAL/package/occ/Config.in"
 source "$BR2_EXTERNAL/package/capp-ucode/Config.in"
diff --git a/openpower/package/firestone-xml/firestone.mk b/openpower/package/firestone-xml/firestone.mk
index 66db0ec..d84e29c 100644
--- a/openpower/package/firestone-xml/firestone.mk
+++ b/openpower/package/firestone-xml/firestone.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-FIRESTONE_XML_VERSION ?= 8765927c10dcf06a8e7ad8c64ddb07f3bb9c9ead
+FIRESTONE_XML_VERSION ?= e7b4fa206116b93b02345234ace4c40999593578
 FIRESTONE_XML_SITE ?= $(call github,open-power,firestone-xml,$(FIRESTONE_XML_VERSION))
 
 FIRESTONE_XML_LICENSE = Apache-2.0
diff --git a/openpower/package/garrison-xml/garrison.mk b/openpower/package/garrison-xml/garrison.mk
index 4c07ca0..9b96606 100644
--- a/openpower/package/garrison-xml/garrison.mk
+++ b/openpower/package/garrison-xml/garrison.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-GARRISON_XML_VERSION ?= ec525e1d5f869a94c278b4cf9b7a0ec1dfeb5abe
+GARRISON_XML_VERSION ?= 884bf2466dcc1b63baf92758e50fcc8e2ec551c5
 GARRISON_XML_SITE ?= $(call github,open-power,garrison-xml,$(GARRISON_XML_VERSION))
 
 GARRISON_XML_LICENSE = Apache-2.0
diff --git a/openpower/package/habanero-xml/habanero-xml.mk b/openpower/package/habanero-xml/habanero-xml.mk
index f7b417d..a862044 100644
--- a/openpower/package/habanero-xml/habanero-xml.mk
+++ b/openpower/package/habanero-xml/habanero-xml.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-HABANERO_XML_VERSION ?= 3ad2b324330987755584d7d0aa1d19f18c9e225e
+HABANERO_XML_VERSION ?= a71550e65d7377d2aa5d50c21369c80409ee4edd
 HABANERO_XML_SITE ?= $(call github,open-power,habanero-xml,$(HABANERO_XML_VERSION))
 
 HABANERO_XML_LICENSE = Apache-2.0
diff --git a/openpower/package/hostboot-binaries/hostboot_binaries.mk b/openpower/package/hostboot-binaries/hostboot_binaries.mk
index d9a23df..bf8934b 100644
--- a/openpower/package/hostboot-binaries/hostboot_binaries.mk
+++ b/openpower/package/hostboot-binaries/hostboot_binaries.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-HOSTBOOT_BINARIES_VERSION ?= 22470e51b6342f9c307e28b3ea7cdb194ff954d4
+HOSTBOOT_BINARIES_VERSION ?= 43d5a59c0ed2dae44bceb6ebeb2a0d453ee91565
 HOSTBOOT_BINARIES_SITE ?= $(call github,open-power,hostboot-binaries,$(HOSTBOOT_BINARIES_VERSION))
 HOSTBOOT_BINARIES_LICENSE = Apache-2.0
 
diff --git a/openpower/package/hostboot/hostboot-0003-Remove-gard-actions-for-memory-plugging-errors.patch b/openpower/package/hostboot/hostboot-0003-Remove-gard-actions-for-memory-plugging-errors.patch
deleted file mode 100644
index ef2a896..0000000
--- a/openpower/package/hostboot/hostboot-0003-Remove-gard-actions-for-memory-plugging-errors.patch
+++ /dev/null
@@ -1,764 +0,0 @@
-From c53b40e0dcc250d75a159389e099dd40b64e5468 Mon Sep 17 00:00:00 2001
-From: Dan Crowell <dcrowell@us.ibm.com>
-Date: Wed, 27 May 2015 16:39:23 -0500
-Subject: [PATCH] Remove gard actions for memory plugging errors
-
-Modified errors related to unsupported or invalid dimm
-configurations to no longer gard any hardware.
-
-Change-Id: I67459425e973ad1c6f4cf95ccd164b73bdd46a80
----
- .../mss_eff_config/memory_mss_eff_config.xml       | 208 +++++----------------
- .../memory_mss_eff_config_termination.xml          |  69 +------
- 2 files changed, 50 insertions(+), 227 deletions(-)
-
-diff --git a/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config.xml b/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config.xml
-index ed1de55..c6a2d37 100644
---- a/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config.xml
-+++ b/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config.xml
-@@ -5,7 +5,7 @@
- <!--                                                                        -->
- <!-- OpenPOWER HostBoot Project                                             -->
- <!--                                                                        -->
--<!-- Contributors Listed Below - COPYRIGHT 2013,2014                        -->
-+<!-- Contributors Listed Below - COPYRIGHT 2013,2015                        -->
- <!-- [+] International Business Machines Corp.                              -->
- <!--                                                                        -->
- <!--                                                                        -->
-@@ -22,7 +22,7 @@
- <!-- permissions and limitations under the License.                         -->
- <!--                                                                        -->
- <!-- IBM_PROLOG_END_TAG                                                     -->
--<!-- $Id: memory_mss_eff_config.xml,v 1.3 2014/10/20 22:12:59 asaetow Exp $ -->
-+<!-- $Id: memory_mss_eff_config.xml,v 1.4 2015-05-27 19:56:31 asaetow Exp $ -->
- <!-- For file ../../ipl/fapi/mss_eff_config.C -->
- <!-- // *! OWNER NAME  : Anuwat Saetow     Email: asaetow@us.ibm.com -->
- <!-- // *! BACKUP NAME : Mark Bellows      Email: bellows@us.ibm.com -->
-@@ -47,9 +47,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -71,9 +68,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -98,9 +92,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -125,9 +116,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -169,10 +157,10 @@
-     <description>Plug rule violation, one position is empty but other are present
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_0</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_1</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_0</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_1</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_0</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_1</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_0</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_1</ffdc>
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-         <priority>HIGH</priority>
-@@ -186,10 +174,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -198,10 +182,10 @@
-     <description>Plug rule violation, sides do not match
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_0</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_1</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_0</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_1</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_0</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_1</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_0</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -216,10 +200,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- 
-@@ -229,10 +209,10 @@
-     <description>Plug rule violation,  top and bottom do not match
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_0</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_1</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_0</ffdc>
--    <ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_1</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_0</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_0_1</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_0</ffdc>
-+	<ffdc>CUR_DIMM_SPD_VALID_U8ARRAY_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -247,10 +227,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -259,10 +235,10 @@
-     <description>Incompatable DRAM generation 
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>DRAM_DEVICE_TYPE_0_0</ffdc>
--    <ffdc>DRAM_DEVICE_TYPE_0_1</ffdc>
--    <ffdc>DRAM_DEVICE_TYPE_1_0</ffdc>
--    <ffdc>DRAM_DEVICE_TYPE_1_1</ffdc>
-+	<ffdc>DRAM_DEVICE_TYPE_0_0</ffdc>
-+	<ffdc>DRAM_DEVICE_TYPE_0_1</ffdc>
-+	<ffdc>DRAM_DEVICE_TYPE_1_0</ffdc>
-+	<ffdc>DRAM_DEVICE_TYPE_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -277,10 +253,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -289,10 +261,10 @@
-     <description>Incompatable DIMM type
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>MODULE_TYPE_0_0</ffdc>
--    <ffdc>MODULE_TYPE_0_1</ffdc>
--    <ffdc>MODULE_TYPE_1_0</ffdc>
--    <ffdc>MODULE_TYPE_1_1</ffdc>
-+	<ffdc>MODULE_TYPE_0_0</ffdc>
-+	<ffdc>MODULE_TYPE_0_1</ffdc>
-+	<ffdc>MODULE_TYPE_1_0</ffdc>
-+	<ffdc>MODULE_TYPE_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -307,10 +279,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -319,10 +287,10 @@
-     <description>Incompatable DIMM ranks
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>NUM_RANKS_0_0</ffdc>
--    <ffdc>NUM_RANKS_0_1</ffdc>
--    <ffdc>NUM_RANKS_1_0</ffdc>
--    <ffdc>NUM_RANKS_1_1</ffdc>
-+	<ffdc>NUM_RANKS_0_0</ffdc>
-+	<ffdc>NUM_RANKS_0_1</ffdc>
-+	<ffdc>NUM_RANKS_1_0</ffdc>
-+	<ffdc>NUM_RANKS_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -337,10 +305,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -349,10 +313,10 @@
-     <description>Incompatable DIMM banks
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>SDRAM_BANKS_0_0</ffdc>
--    <ffdc>SDRAM_BANKS_0_1</ffdc>
--    <ffdc>SDRAM_BANKS_1_0</ffdc>
--    <ffdc>SDRAM_BANKS_1_1</ffdc>
-+	<ffdc>SDRAM_BANKS_0_0</ffdc>
-+	<ffdc>SDRAM_BANKS_0_1</ffdc>
-+	<ffdc>SDRAM_BANKS_1_0</ffdc>
-+	<ffdc>SDRAM_BANKS_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -367,10 +331,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -379,10 +339,10 @@
-     <description>Incompatable DIMM rows
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>SDRAM_ROWS_0_0</ffdc>
--    <ffdc>SDRAM_ROWS_0_1</ffdc>
--    <ffdc>SDRAM_ROWS_1_0</ffdc>
--    <ffdc>SDRAM_ROWS_1_1</ffdc>
-+	<ffdc>SDRAM_ROWS_0_0</ffdc>
-+	<ffdc>SDRAM_ROWS_0_1</ffdc>
-+	<ffdc>SDRAM_ROWS_1_0</ffdc>
-+	<ffdc>SDRAM_ROWS_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -397,10 +357,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -409,10 +365,10 @@
-     <description>Incompatable DIMM columns
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>SDRAM_COLS_0_0</ffdc>
--    <ffdc>SDRAM_COLS_0_1</ffdc>
--    <ffdc>SDRAM_COLS_1_0</ffdc>
--    <ffdc>SDRAM_COLS_1_1</ffdc>
-+	<ffdc>SDRAM_COLS_0_0</ffdc>
-+	<ffdc>SDRAM_COLS_0_1</ffdc>
-+	<ffdc>SDRAM_COLS_1_0</ffdc>
-+	<ffdc>SDRAM_COLS_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -427,10 +383,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -439,10 +391,10 @@
-     <description>Incompatable DRAM primary bus width
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>BUS_WIDTH_0_0</ffdc>
--    <ffdc>BUS_WIDTH_0_1</ffdc>
--    <ffdc>BUS_WIDTH_1_0</ffdc>
--    <ffdc>BUS_WIDTH_1_1</ffdc>
-+	<ffdc>BUS_WIDTH_0_0</ffdc>
-+	<ffdc>BUS_WIDTH_0_1</ffdc>
-+	<ffdc>BUS_WIDTH_1_0</ffdc>
-+	<ffdc>BUS_WIDTH_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -457,10 +409,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- 
-@@ -483,10 +431,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- 
-@@ -496,10 +440,10 @@
-     <description>Incompatable DRAM width
-         </description>
-     <FFDC>TARGET_MBA</FFDC>
--    <ffdc>DRAM_WIDTH_0_0</ffdc>
--    <ffdc>DRAM_WIDTH_0_1</ffdc>
--    <ffdc>DRAM_WIDTH_1_0</ffdc>
--    <ffdc>DRAM_WIDTH_1_1</ffdc>
-+	<ffdc>DRAM_WIDTH_0_0</ffdc>
-+	<ffdc>DRAM_WIDTH_0_1</ffdc>
-+	<ffdc>DRAM_WIDTH_1_0</ffdc>
-+	<ffdc>DRAM_WIDTH_1_1</ffdc>
- 
-     <callout>
-         <procedure>MEMORY_PLUGGING_ERROR</procedure>
-@@ -514,10 +458,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -540,10 +480,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -566,10 +502,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -591,10 +523,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -616,10 +544,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -641,10 +565,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -666,10 +586,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -691,10 +607,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -716,10 +628,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -741,10 +649,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -766,10 +670,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -791,10 +691,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -816,10 +712,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -841,10 +733,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -866,10 +754,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--        <priority>HIGH</priority>
--    </gard>
- </hwpError>
- 
- 
-diff --git a/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config_termination.xml b/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config_termination.xml
-index 9f3c89c..f04b0a6 100644
---- a/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config_termination.xml
-+++ b/src/usr/hwpf/hwp/mc_config/mss_eff_config/memory_mss_eff_config_termination.xml
-@@ -5,7 +5,9 @@
- <!--                                                                        -->
- <!-- OpenPOWER HostBoot Project                                             -->
- <!--                                                                        -->
--<!-- COPYRIGHT International Business Machines Corp. 2013,2014              -->
-+<!-- Contributors Listed Below - COPYRIGHT 2013,2015                        -->
-+<!-- [+] International Business Machines Corp.                              -->
-+<!--                                                                        -->
- <!--                                                                        -->
- <!-- Licensed under the Apache License, Version 2.0 (the "License");        -->
- <!-- you may not use this file except in compliance with the License.       -->
-@@ -20,7 +22,7 @@
- <!-- permissions and limitations under the License.                         -->
- <!--                                                                        -->
- <!-- IBM_PROLOG_END_TAG                                                     -->
--<!-- $Id: memory_mss_eff_config_termination.xml,v 1.2 2014/04/07 23:02:10 lapietra Exp $ -->
-+<!-- $Id: memory_mss_eff_config_termination.xml,v 1.3 2015-05-27 20:02:29 asaetow Exp $ -->
- <!-- For file ../../ipl/fapi/mss_eff_config_termination.C -->
- <!-- // *! OWNER NAME  : Dave Cadigan      Email: dcadiga@us.ibm.com -->
- <!-- // *! BACKUP NAME : Anuwat Saetow     Email: asaetow@us.ibm.com -->
-@@ -195,9 +197,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -220,9 +219,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- <!-- *********************************************************************** -->
-   <hwpError>
-@@ -245,9 +241,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -271,9 +264,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -297,9 +287,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -323,9 +310,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -349,9 +333,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -374,9 +355,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -400,9 +378,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -425,9 +400,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -450,9 +422,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -476,9 +445,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -497,9 +463,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -523,9 +486,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- <!-- *********************************************************************** -->
-   <hwpError>
-@@ -650,9 +610,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -675,9 +632,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -699,9 +653,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- 
-@@ -724,9 +675,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -750,9 +698,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -820,9 +765,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- <!-- *********************************************************************** -->
-@@ -845,9 +787,6 @@
-         <target>TARGET_MBA</target>
-     </deconfigure>
- 
--    <gard>
--        <target>TARGET_MBA</target>
--    </gard>
- </hwpError>
- 
- </hwpErrors>
--- 
-2.3.0
-
diff --git a/openpower/package/hostboot/hostboot-0004-SBE-update-support-for-adjusted-nest-freq.patch b/openpower/package/hostboot/hostboot-0004-SBE-update-support-for-adjusted-nest-freq.patch
deleted file mode 100644
index b937bf0..0000000
--- a/openpower/package/hostboot/hostboot-0004-SBE-update-support-for-adjusted-nest-freq.patch
+++ /dev/null
@@ -1,1376 +0,0 @@
-From da7ff638a6ca5c5588bf8cecc00e335d8ea92c91 Mon Sep 17 00:00:00 2001
-From: Andres Lugo-Reyes <aalugore@us.ibm.com>
-Date: Mon, 24 Aug 2015 16:45:40 -0500
-Subject: [PATCH] SBE Update Support for Adjusted Nest Frequency
-
-This commit adds a check in istep 8.1 to see if the SBE Seeproms are
-programmed with the same NEST_FREQ_MHZ attribute value that the system is
-currently running at.  If necessary, it will update the SBE Seeproms in this
-step which might result in a re-IPL.
-
-Change-Id: I1dca7196cd02a2704a238665b73b522c9e103936
-RTC:133406
-Depends-on:I9bba92f55f1b67ff4a15d79113f19d39272ec72d
-Backport: release-fips840
----
- src/include/usr/isteps/istep08list.H               |   2 +
- src/include/usr/sbe/sbeif.H                        |  19 +-
- .../hwpf/hwp/activate_powerbus/activate_powerbus.C |   5 +-
- .../edi_ei_initialization/edi_ei_initialization.C  |  37 +-
- src/usr/hwpf/hwp/slave_sbe/slave_sbe.C             |  11 +-
- src/usr/sbe/sbe_update.C                           | 640 ++++++++++++++++-----
- src/usr/sbe/sbe_update.H                           |  57 +-
- src/usr/sbe/test/sbeupdatetest.H                   |   4 +-
- src/usr/targeting/common/genHwsvMrwXml.pl          |  19 +
- .../targeting/common/xmltohb/attribute_types.xml   |  18 +
- src/usr/targeting/common/xmltohb/target_types.xml  |  12 +
- 11 files changed, 668 insertions(+), 156 deletions(-)
-
-diff --git a/src/include/usr/isteps/istep08list.H b/src/include/usr/isteps/istep08list.H
-index 9496539..0a721c6 100644
---- a/src/include/usr/isteps/istep08list.H
-+++ b/src/include/usr/isteps/istep08list.H
-@@ -120,6 +120,8 @@ const DepModInfo g_istep08Dependancies = {
-         DEP_LIB(libnest_chiplets.so),
-         DEP_LIB(libsecure_boot.so),
-         DEP_LIB(libslave_sbe.so),
-+        DEP_LIB(libsbe.so),
-+        DEP_LIB(libbuild_winkle_images.so),
-         NULL
-     }
- };
-diff --git a/src/include/usr/sbe/sbeif.H b/src/include/usr/sbe/sbeif.H
-index 9cf20c6..b00e01f 100644
---- a/src/include/usr/sbe/sbeif.H
-+++ b/src/include/usr/sbe/sbeif.H
-@@ -59,14 +59,31 @@ namespace SBE
-                              size_t& o_imgSize,
-                              sbe_image_version_t* o_version = NULL);
- 
-+    /**
-+     * @enum sbeUpdateCheckType
-+     *
-+     * @brief Determines what types of checks are performed on the SBE Seeproms
-+     *        to determine if an update is necessary.
-+     *
-+     */
-+    enum sbeUpdateCheckType
-+    {
-+        SBE_UPDATE_CHECK_ALL                   = 0x00,
-+        SBE_UPDATE_ONLY_CHECK_NEST_FREQ        = 0x01
-+    };
- 
-     /**
-      * @brief Iterates through all the functional processors and updates
-      *        the SBE Image in a SEEPROM, if necessary.
-      *
-+     * @param[in] i_check_type    Indicates what types of checks are performed
-+     *                            on the SBE Seeproms to determine if an update
-+     *                            is necessary.
-+     *
-      * @return errlHndl_t    Error log handle on failure.
-      */
--    errlHndl_t updateProcessorSbeSeeproms();
-+    errlHndl_t updateProcessorSbeSeeproms(
-+                   sbeUpdateCheckType i_check_type = SBE_UPDATE_CHECK_ALL);
- 
-     /**
-      * @brief Iterates through all the functional processors and resolves
-diff --git a/src/usr/hwpf/hwp/activate_powerbus/activate_powerbus.C b/src/usr/hwpf/hwp/activate_powerbus/activate_powerbus.C
-index 4cb1d3a..642b539 100644
---- a/src/usr/hwpf/hwp/activate_powerbus/activate_powerbus.C
-+++ b/src/usr/hwpf/hwp/activate_powerbus/activate_powerbus.C
-@@ -347,9 +347,12 @@ void * call_host_slave_sbe_update( void * io_pArgs )
-     do
-     {
- 
-+        // Slave processors should now use Host I2C Access Method
-+        I2C::i2cSetAccessMode( I2C::I2C_SET_ACCESS_MODE_PROC_HOST );
-+
-         // Reset I2C devices before trying to access the SBE SEEPROMs
-         // Any error returned should not fail istep
--        l_errl = I2C::i2cResetActiveMasters( I2C::I2C_PROC_HOST );
-+        l_errl = I2C::i2cResetActiveMasters( I2C::I2C_PROC_ALL );
-         if (l_errl)
-         {
-             // Commit error and keep going
-diff --git a/src/usr/hwpf/hwp/edi_ei_initialization/edi_ei_initialization.C b/src/usr/hwpf/hwp/edi_ei_initialization/edi_ei_initialization.C
-index ae02ad8..e1ab17d 100644
---- a/src/usr/hwpf/hwp/edi_ei_initialization/edi_ei_initialization.C
-+++ b/src/usr/hwpf/hwp/edi_ei_initialization/edi_ei_initialization.C
-@@ -5,7 +5,9 @@
- /*                                                                        */
- /* OpenPOWER HostBoot Project                                             */
- /*                                                                        */
--/* COPYRIGHT International Business Machines Corp. 2012,2014              */
-+/* Contributors Listed Below - COPYRIGHT 2012,2015                        */
-+/* [+] International Business Machines Corp.                              */
-+/*                                                                        */
- /*                                                                        */
- /* Licensed under the Apache License, Version 2.0 (the "License");        */
- /* you may not use this file except in compliance with the License.       */
-@@ -53,6 +55,8 @@
- #include    <hwas/common/deconfigGard.H>
- #include    <hwas/common/hwasCommon.H>
- 
-+#include    <sbe/sbeif.H>
-+
- //  targeting support
- #include    <targeting/common/commontargeting.H>
- #include    <targeting/common/utilFilter.H>
-@@ -102,6 +106,35 @@ void*    call_fabric_erepair( void    *io_pArgs )
-     errlHndl_t l_errl = NULL;
-     TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_fabric_erepair entry" );
- 
-+    do {
-+
-+    // Check if the system can support multiple nest frequencies
-+    // and if so, see if an SBE Update is required
-+    TARGETING::Target* l_sys = NULL;
-+    targetService().getTopLevelTarget(l_sys);
-+    assert( l_sys != NULL, "call_fabric_erepair: sys target is NULL" );
-+    MRW_NEST_CAPABLE_FREQUENCIES_SYS l_mrw_nest_capable;
-+    l_mrw_nest_capable =
-+               l_sys->getAttr<ATTR_MRW_NEST_CAPABLE_FREQUENCIES_SYS>();
-+    if ( l_mrw_nest_capable ==
-+               MRW_NEST_CAPABLE_FREQUENCIES_SYS_2000_MHZ_OR_2400_MHZ )
-+    {
-+        // Call to check Processor SBE SEEPROM Images against NEST_FREQ_MHZ
-+        // attributes and make any necessary updates
-+        l_errl = SBE::updateProcessorSbeSeeproms(
-+                            SBE::SBE_UPDATE_ONLY_CHECK_NEST_FREQ);
-+
-+        if (l_errl)
-+        {
-+            // Create IStep error log and cross reference error that occurred
-+            l_StepError.addErrorDetails( l_errl );
-+            // Commit error
-+            errlCommit( l_errl, HWPF_COMP_ID );
-+            break;
-+        }
-+
-+    }
-+
-     std::vector<uint8_t> l_endp1_txFaillanes;
-     std::vector<uint8_t> l_endp1_rxFaillanes;
-     std::vector<uint8_t> l_endp2_txFaillanes;
-@@ -278,6 +311,8 @@ void*    call_fabric_erepair( void    *io_pArgs )
-         } // end for l_PbusConnections
-     } // end for MaxBusSet
- 
-+    } while (0);
-+
-     TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_fabric_erepair exit" );
- 
-     return l_StepError.getErrorHandle();
-diff --git a/src/usr/hwpf/hwp/slave_sbe/slave_sbe.C b/src/usr/hwpf/hwp/slave_sbe/slave_sbe.C
-index c74402d..9493144 100644
---- a/src/usr/hwpf/hwp/slave_sbe/slave_sbe.C
-+++ b/src/usr/hwpf/hwp/slave_sbe/slave_sbe.C
-@@ -194,6 +194,7 @@ void* call_host_slave_sbe_config(void *io_pArgs)
-         errlCommit( err, HWPF_COMP_ID );
-     }
- 
-+
-     TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                "call_host_slave_sbe_config exit" );
- 
-@@ -616,16 +617,6 @@ void* call_proc_check_slave_sbe_seeprom_complete( void *io_pArgs )
- 
-     }   // endfor
- 
--    // Slave processors should now use Host I2C Access Method
--    I2C::i2cSetAccessMode( I2C::I2C_SET_ACCESS_MODE_PROC_HOST );
--
--    // Reset the Processor's I2C Masters
--    l_errl = I2C::i2cResetActiveMasters(I2C::I2C_PROC_ALL);
--    if (l_errl)
--    {
--        // Commit error
--        errlCommit( l_errl, HWPF_COMP_ID );
--    }
- 
-     TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-               "call_proc_check_slave_sbe_seeprom_complete exit");
-diff --git a/src/usr/sbe/sbe_update.C b/src/usr/sbe/sbe_update.C
-index 28e42fc..1faad63 100644
---- a/src/usr/sbe/sbe_update.C
-+++ b/src/usr/sbe/sbe_update.C
-@@ -34,6 +34,7 @@
- #include <targeting/common/predicates/predicatectm.H>
- #include <targeting/common/utilFilter.H>
- #include <targeting/common/targetservice.H>
-+#include <targeting/common/target.H>
- #include <util/align.H>
- #include <util/crc32.H>
- #include <util/misc.H>
-@@ -82,13 +83,13 @@ static bool g_mbox_query_done   = false;
- static bool g_mbox_query_result = false;
- static bool g_istep_mode        = false;
- static bool g_update_both_sides = false;
-+static uint32_t g_current_nest_freq = 0;
- 
- using namespace ERRORLOG;
- using namespace TARGETING;
- 
- namespace SBE
- {
--
-     enum {
-         SBE_IMG_VADDR = VMM_VADDR_SBE_UPDATE,
-         RING_BUF1_VADDR = FIXED_SEEPROM_WORK_SPACE + SBE_IMG_VADDR,
-@@ -100,7 +101,7 @@ namespace SBE
-     };
- 
- /////////////////////////////////////////////////////////////////////
--    errlHndl_t updateProcessorSbeSeeproms()
-+    errlHndl_t updateProcessorSbeSeeproms(sbeUpdateCheckType i_check_type)
-     {
-         errlHndl_t err = NULL;
-         errlHndl_t err_cleanup = NULL;
-@@ -111,7 +112,8 @@ namespace SBE
-         bool l_restartNeeded   = false;
- 
-         TRACUCOMP( g_trac_sbe,
--                   ENTER_MRK"updateProcessorSbeSeeproms()" );
-+                   ENTER_MRK"updateProcessorSbeSeeproms(): i_check_type=%d",
-+                   i_check_type);
- 
-         do{
- 
-@@ -171,6 +173,10 @@ namespace SBE
-                 g_update_both_sides = true;
-             }
- 
-+            // Collect ATTR_NEST_FREQ_MHZ for reference later
-+            g_current_nest_freq = sys->getAttr<ATTR_NEST_FREQ_MHZ>();
-+
-+
-             //Make sure procedure constants keep within expected range.
-             assert((FIXED_SEEPROM_WORK_SPACE <= VMM_SBE_UPDATE_SIZE/2),
-                    "updateProcessorSbeSeeproms() FIXED_SEEPROM_WORK_SPACE "
-@@ -261,7 +267,8 @@ namespace SBE
-                     sbeState.target_is_master = false;
-                 }
- 
--                err = getSbeInfoState(sbeState);
-+                err = getSbeInfoState(sbeState,
-+                                      i_check_type);
- 
-                 if (err)
-                 {
-@@ -273,15 +280,29 @@ namespace SBE
-                                TARGETING::get_huid(sbeState.target));
- 
-                     // Don't break - handle error at the end of the loop
--
-                 }
- 
- 
-+                // Continue if we're just doing the nest freq check and don't
-+                // have a mismatch
-+                if ( ( i_check_type == SBE_UPDATE_ONLY_CHECK_NEST_FREQ ) &&
-+                     ( sbeState.seeprom_0_ver_Nest_Freq_Mismatch == false ) &&
-+                     ( sbeState.seeprom_1_ver_Nest_Freq_Mismatch == false ) )
-+                {
-+                    TRACFCOMP( g_trac_sbe,
-+                               INFO_MRK"updateProcessorSbeSeeproms(): "
-+                               "Only looking for Nest Freq Mismatch and "
-+                               "none found for Target UID=0x%X",
-+                               TARGETING::get_huid(sbeState.target));
-+
-+                    sbeState.update_actions = CLEAR_ACTIONS;
-+                }
-+
-                 /**********************************************/
-                 /*  Determine update actions for this target  */
-                 /**********************************************/
-                 // Skip if we got an error collecting SBE Info State
--                if ( err == NULL )
-+                else if ( err == NULL )
-                 {
-                     err = getTargetUpdateActions(sbeState);
-                     if (err)
-@@ -295,6 +316,7 @@ namespace SBE
- 
-                         // Don't break - handle error at the end of the loop,
-                     }
-+
-                 }
- 
-                 /**********************************************/
-@@ -406,15 +428,19 @@ namespace SBE
-             /* Deconfigure any Processors that have a Version different */
-             /*   from the Master Processor's Version                    */
-             /************************************************************/
--            err = masterVersionCompare(sbeStates_vector);
--
--            if ( err )
-+            // skip if we're only checking for NEST_FREQ mismatch
-+            if ( i_check_type != SBE_UPDATE_ONLY_CHECK_NEST_FREQ )
-             {
--                // Something failed on the check
--                TRACFCOMP( g_trac_sbe,
--                           INFO_MRK"updateProcessorSbeSeeproms(): Call to "
--                           "masterVersionCompare() failed rc=0x%.4X",
--                           err->reasonCode());
-+                err = masterVersionCompare(sbeStates_vector);
-+
-+                if ( err )
-+                {
-+                    // Something failed on the check
-+                    TRACFCOMP( g_trac_sbe,
-+                               INFO_MRK"updateProcessorSbeSeeproms(): Call to "
-+                               "masterVersionCompare() failed rc=0x%.4X",
-+                               err->reasonCode());
-+                }
-             }
- 
-         }while(0);
-@@ -451,7 +477,6 @@ namespace SBE
-             }
-         }
- 
--
-         TRACUCOMP( g_trac_sbe,
-                    EXIT_MRK"updateProcessorSbeSeeproms()" );
- 
-@@ -865,6 +890,7 @@ namespace SBE
-                 }
-             }  // end of while loop
- 
-+
-             if(err)
-             {
-                 // There was a previous error, so break here
-@@ -1312,14 +1338,16 @@ namespace SBE
-         }while(0);
- 
-         TRACFCOMP( g_trac_sbe,
--                   EXIT_MRK"getSbeBootSeeprom(): o_bootSide=0x%X (reg=0x%X)",
--                   o_bootSide, scomData );
-+                   EXIT_MRK"getSbeBootSeeprom(): o_bootSide=0x%X (reg=0x%X, "
-+                   "tgt=0x%X)",
-+                   o_bootSide, scomData, TARGETING::get_huid(i_target) );
- 
-         return err;
-     }
- 
- /////////////////////////////////////////////////////////////////////
--    errlHndl_t getSbeInfoState(sbeTargetState_t& io_sbeState)
-+    errlHndl_t getSbeInfoState(sbeTargetState_t& io_sbeState,
-+                               sbeUpdateCheckType& i_check_type)
-     {
- 
-         TRACUCOMP( g_trac_sbe,
-@@ -1328,6 +1356,7 @@ namespace SBE
- 
- 
-         errlHndl_t err = NULL;
-+        bool skip_customization = false;
- 
-         do{
- 
-@@ -1338,6 +1367,74 @@ namespace SBE
- 
- 
-             /*******************************************/
-+            /*  Get SEEPROM A SBE Version Information  */
-+            /*******************************************/
-+            err = getSeepromSideVersion(io_sbeState.target,
-+                                       EEPROM::SBE_PRIMARY,
-+                                       io_sbeState.seeprom_0_ver,
-+                                       io_sbeState.seeprom_0_ver_ECC_fail);
-+
-+            if(err)
-+            {
-+                TRACFCOMP( g_trac_sbe, ERR_MRK"getSbeInfoState() - Error "
-+                           "getting SBE Information from SEEPROM A (0x%X)",
-+                EEPROM::SBE_PRIMARY);
-+                break;
-+            }
-+
-+            TRACDBIN(g_trac_sbe, "getSbeInfoState-spA",
-+                     &(io_sbeState.seeprom_0_ver),
-+                     sizeof(sbeSeepromVersionInfo_t));
-+
-+
-+            /*******************************************/
-+            /*  Get SEEPROM B SBE Version Information  */
-+            /*******************************************/
-+            err = getSeepromSideVersion(io_sbeState.target,
-+                                        EEPROM::SBE_BACKUP,
-+                                        io_sbeState.seeprom_1_ver,
-+                                        io_sbeState.seeprom_1_ver_ECC_fail);
-+
-+            if(err)
-+            {
-+                TRACFCOMP( g_trac_sbe, ERR_MRK"getSbeInfoState() - Error "
-+                           "getting SBE Information from SEEPROM B (0x%X)",
-+                           EEPROM::SBE_BACKUP);
-+                break;
-+            }
-+
-+            TRACDBIN(g_trac_sbe, "getSbeInfoState-spB",
-+                     &(io_sbeState.seeprom_1_ver),
-+                    sizeof(sbeSeepromVersionInfo_t));
-+
-+
-+            // Check NEST_FREQ settings
-+            err = checkNestFreqSettings(io_sbeState);
-+
-+            if (err)
-+            {
-+                TRACFCOMP( g_trac_sbe, ERR_MRK"getSbeInfoState() - "
-+                           "Error returned from checkNestFreqSettings() ");
-+                break;
-+            }
-+            else if ((i_check_type == SBE_UPDATE_ONLY_CHECK_NEST_FREQ) &&
-+                     (io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch == false) &&
-+                     (io_sbeState.seeprom_1_ver_Nest_Freq_Mismatch == false))
-+            {
-+                TRACFCOMP( g_trac_sbe,
-+                           INFO_MRK"getSbeInfoState(): "
-+                           "Only looking for Nest Freq Mismatch and "
-+                           "none found for Target UID=0x%X. Skipping "
-+                           "SBE customization",
-+                           TARGETING::get_huid(io_sbeState.target));
-+
-+                // Skipping SBE customization, but still need other info like
-+                // MVPD in the case another processor requires a re-IPL
-+                skip_customization = true;
-+            }
-+
-+
-+            /*******************************************/
-             /*  Get PNOR SBE Version Information       */
-             /*******************************************/
-             void* sbePnorPtr = NULL;
-@@ -1367,12 +1464,15 @@ namespace SBE
-             /*  Calculate CRC of the image             */
-             /*******************************************/
-             size_t sbeImgSize = 0;
--            err = procCustomizeSbeImg(io_sbeState.target,
-+            if ( skip_customization == false )
-+            {
-+                err = procCustomizeSbeImg(io_sbeState.target,
-                                 sbePnorPtr,     //SBE vaddr in PNOR
-                                 FIXED_SEEPROM_WORK_SPACE,  //max size
-                                 reinterpret_cast<void*>
-                                 (SBE_IMG_VADDR),  //destination
-                                 sbeImgSize);
-+            }
- 
-             if(err)
-             {
-@@ -1421,47 +1521,6 @@ namespace SBE
-             }
- 
- 
--            /*******************************************/
--            /*  Get SEEPROM A SBE Version Information  */
--            /*******************************************/
--            err = getSeepromSideVersion(io_sbeState.target,
--                                       EEPROM::SBE_PRIMARY,
--                                       io_sbeState.seeprom_0_ver,
--                                       io_sbeState.seeprom_0_ver_ECC_fail);
--
--            if(err)
--            {
--                TRACFCOMP( g_trac_sbe, ERR_MRK"getSbeInfoState() - Error "
--                           "getting SBE Information from SEEPROM A (0x%X)",
--                EEPROM::SBE_PRIMARY);
--                break;
--            }
--
--            TRACDBIN(g_trac_sbe, "getSbeInfoState-spA",
--                     &(io_sbeState.seeprom_0_ver),
--                     sizeof(sbeSeepromVersionInfo_t));
--
--            /*******************************************/
--            /*  Get SEEPROM B SBE Version Information  */
--            /*******************************************/
--            err = getSeepromSideVersion(io_sbeState.target,
--                                        EEPROM::SBE_BACKUP,
--                                        io_sbeState.seeprom_1_ver,
--                                        io_sbeState.seeprom_1_ver_ECC_fail);
--
--            if(err)
--            {
--                TRACFCOMP( g_trac_sbe, ERR_MRK"getSbeInfoState() - Error "
--                           "getting SBE Information from SEEPROM B (0x%X)",
--                           EEPROM::SBE_BACKUP);
--                break;
--            }
--
--
--            TRACDBIN(g_trac_sbe, "getSbeInfoState-spB",
--                     &(io_sbeState.seeprom_1_ver),
--                    sizeof(sbeSeepromVersionInfo_t));
--
-             /***********************************************/
-             /*  Determine which SEEPROM System Booted On   */
-             /***********************************************/
-@@ -1525,7 +1584,6 @@ namespace SBE
-                                      sbeSeepromVersionInfo_t& o_info,
-                                      bool& o_seeprom_ver_ECC_fail)
-     {
--
-         TRACUCOMP( g_trac_sbe,
-                    ENTER_MRK"getSeepromSideVersion(): HUID=0x%.8X, side:%d",
-                    TARGETING::get_huid(i_target), i_seepromSide);
-@@ -1534,22 +1592,21 @@ namespace SBE
-         PNOR::ECC::eccStatus eccStatus = PNOR::ECC::CLEAN;
-         o_seeprom_ver_ECC_fail = false;
- 
--        size_t sbeInfoSize_ECC = (sizeof(sbeSeepromVersionInfo_t)*9)/8;
--        size_t sbeInfoSize_ECC_aligned = ALIGN_8(sbeInfoSize_ECC);
--
--        // Create data buffer of larger size
--        // NOTE:  EEPROM read will fill in smaller, unaligned size
-+        // Set these variables to the read out the max struct size
-+        // Supported version 1 is a subset of supported version 2
-+        size_t sbeInfoSize = sizeof(sbeSeepromVersionInfo_t);
-+        size_t sbeInfoSize_ECC = (sbeInfoSize*9)/8;
-         uint8_t * tmp_data_ECC = static_cast<uint8_t*>(
--        malloc(sbeInfoSize_ECC_aligned));
-+                                        malloc(sbeInfoSize_ECC));
- 
--        do{
- 
--            /*******************************************/
--            /*  Read SBE Version SBE Version Information       */
--            /*******************************************/
-+        do{
- 
-+            /***********************************************/
-+            /*  Read SBE Version SBE Version Information   */
-+            /***********************************************/
-             // Clear Buffer
--            memset( tmp_data_ECC, 0, sbeInfoSize_ECC_aligned );
-+            memset( tmp_data_ECC, 0, sbeInfoSize_ECC );
- 
-             //Read SBE Versions
-             err = deviceRead( i_target,
-@@ -1568,43 +1625,68 @@ namespace SBE
-             }
- 
-             TRACDBIN(g_trac_sbe,
--                     "getSeepromSideVersion()- tmp_data_ECC (not-aligned)",
-+                     "getSeepromSideVersion()- tmp_data_ECC",
-                      tmp_data_ECC,
-                      sbeInfoSize_ECC);
- 
--            TRACDBIN(g_trac_sbe,
--                     "getSeepromSideVersion()- tmp_data_ECC (aligned)",
--                     tmp_data_ECC,
--                     sbeInfoSize_ECC_aligned);
--
- 
-             // Clear destination
-             memset( &o_info, 0, sizeof(o_info) );
- 
- 
-+
-+            // Initially only look at the first 8-Bytes which should include
-+            // the struct version value
-             // Remove ECC
-             eccStatus = PNOR::ECC::removeECC(
-                                          tmp_data_ECC,
-                                          reinterpret_cast<uint8_t*>(&o_info),
--                                         sizeof(o_info));
-+                                         8);
-+
-+            TRACUCOMP( g_trac_sbe, "getSeepromSideVersion(): First 8-Bytes: "
-+                       "eccStatus=%d, version=0x%X, data_crc=0x%X",
-+                       eccStatus, o_info.struct_version, o_info.data_crc);
-+
-+
-+            if ( ( o_info.struct_version == 1 ) ||
-+                   o_info.struct_version == 2 )
-+            {
-+                // Supported Versions - set size variable to remove ECC
-+                sbeInfoSize = SBE_SEEPROM_STRUCT_SIZES[o_info.struct_version];
-+                sbeInfoSize_ECC = (sbeInfoSize*9)/8;
-+
-+            }
-+            else
-+            {
-+                // Unsupported versions - ignoring any ECC errors
-+                TRACFCOMP( g_trac_sbe, "getSeepromSideVersion(): Unsupported "
-+                           "Struct Version=0x%X, ignoring any eccStatus=%d",
-+                           o_info.struct_version, eccStatus);
-+                break;
-+            }
-+
-+
-+            // Remove ECC for full SBE Version struct
-+            eccStatus = PNOR::ECC::CLEAN;
-+            eccStatus = PNOR::ECC::removeECC(
-+                                         tmp_data_ECC,
-+                                         reinterpret_cast<uint8_t*>(&o_info),
-+                                         sbeInfoSize);
- 
-             TRACUCOMP( g_trac_sbe, "getSeepromSideVersion(): eccStatus=%d, "
--                       "sizeof o_info=%d, sI_ECC=%d, sI_ECC_aligned=%d",
--                       eccStatus, sizeof(o_info), sbeInfoSize_ECC,
--                       sbeInfoSize_ECC_aligned);
-+                       "sizeof o_info/sI=%d, sI_ECC=%d",
-+                       eccStatus, sbeInfoSize, sbeInfoSize_ECC);
- 
-             // Handle Uncorrectable ECC - no error log:
-             // clear data and set o_seeprom_ver_ECC_fail=true
--            // -- unless SIM version found:  than just ignore
--            if ( (eccStatus == PNOR::ECC::UNCORRECTABLE) &&
--                 (o_info.struct_version != SBE_SEEPROM_STRUCT_SIMICS_VERSION) )
-+            if ( eccStatus == PNOR::ECC::UNCORRECTABLE )
-             {
- 
-                 TRACFCOMP( g_trac_sbe,ERR_MRK"getSeepromSideVersion() - ECC "
-                            "ERROR: Handled. eccStatus=%d, side=%d, sizeof "
--                           "o_info=%d, sI_ECC=%d, sI_ECC_aligned=%d",
--                           eccStatus, i_seepromSide, sizeof(o_info),
--                           sbeInfoSize_ECC, sbeInfoSize_ECC_aligned);
-+                           "o_info/sI=%d, sI_ECC=%d",
-+                           eccStatus, i_seepromSide, sbeInfoSize,
-+                           sbeInfoSize_ECC);
- 
-                 memset( &o_info, 0, sizeof(o_info));
-                 o_seeprom_ver_ECC_fail = true;
-@@ -2065,17 +2147,21 @@ namespace SBE
-                 isSimics_check = true;
-             }
- 
--            if ( (pnor_check_dirty || crc_check_dirty )
-+            if ( ( pnor_check_dirty ||
-+                   crc_check_dirty  ||
-+                   io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch )
-                  && !isSimics_check )
-             {
-                 seeprom_0_isDirty = true;
-                 TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: Seeprom0 "
-                            "dirty: pnor=%d, crc=%d (custom=0x%X/s0=0x%X), "
--                           "isSimics=%d",
-+                           "nest_freq=%d, isSimics=%d",
-                            TARGETING::get_huid(io_sbeState.target),
-                            pnor_check_dirty, crc_check_dirty,
-                            io_sbeState.customizedImage_crc,
--                           io_sbeState.seeprom_0_ver.data_crc, isSimics_check);
-+                           io_sbeState.seeprom_0_ver.data_crc,
-+                           io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch,
-+                           isSimics_check);
-             }
- 
-             /**************************************************************/
-@@ -2111,17 +2197,21 @@ namespace SBE
-                 isSimics_check = true;
-             }
- 
--            if ( (pnor_check_dirty || crc_check_dirty )
-+            if ( (pnor_check_dirty ||
-+                  crc_check_dirty  ||
-+                  io_sbeState.seeprom_1_ver_Nest_Freq_Mismatch )
-                  && !isSimics_check )
-             {
-                 seeprom_1_isDirty = true;
-                 TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: Seeprom1 "
-                            "dirty: pnor=%d, crc=%d (custom=0x%X/s1=0x%X), "
--                           "isSimics=%d",
-+                           "nest_freq=%d, isSimics=%d",
-                            TARGETING::get_huid(io_sbeState.target),
-                            pnor_check_dirty, crc_check_dirty,
-                            io_sbeState.customizedImage_crc,
--                           io_sbeState.seeprom_1_ver.data_crc, isSimics_check);
-+                           io_sbeState.seeprom_1_ver.data_crc,
-+                           io_sbeState.seeprom_1_ver_Nest_Freq_Mismatch,
-+                           isSimics_check);
-             }
- 
- 
-@@ -2158,11 +2248,15 @@ namespace SBE
-             {
-                 current_side_isDirty = seeprom_0_isDirty;
-                 alt_side_isDirty     = seeprom_1_isDirty;
-+                io_sbeState.cur_seeprom_ver_Nest_Freq_Mismatch =
-+                            io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch;
-             }
-             else
-             {
-                 current_side_isDirty = seeprom_1_isDirty;
-                 alt_side_isDirty     = seeprom_0_isDirty;
-+                io_sbeState.cur_seeprom_ver_Nest_Freq_Mismatch =
-+                            io_sbeState.seeprom_1_ver_Nest_Freq_Mismatch;
-             }
- 
-             // Set system_situation - bits defined in sbe_update.H
-@@ -2204,7 +2298,8 @@ namespace SBE
-             /**************************************************************/
-             /*  Setup new SBE Image Version Info, if necessary            */
-             /**************************************************************/
--            if ( io_sbeState.update_actions & UPDATE_SBE )
-+            if ( ( io_sbeState.update_actions & UPDATE_SBE ) ||
-+                 ( io_sbeState.update_actions & UPDATE_NEST_FREQ ) )
-             {
-                 memset(&(io_sbeState.new_seeprom_ver),
-                        0x0,
-@@ -2222,6 +2317,19 @@ namespace SBE
-                         &(io_sbeState.customizedImage_crc),
-                         sizeof(io_sbeState.new_seeprom_ver.data_crc));
- 
-+                if (  io_sbeState.update_actions & UPDATE_SBE )
-+                {
-+                    io_sbeState.new_seeprom_ver.nest_freq_mhz =
-+                                g_current_nest_freq;
-+                }
-+                else
-+                {
-+                    // UPDATE_NEST_FREQ: set the nest freq to what the
-+                    // current SBE Seeprom booted from
-+                     io_sbeState.new_seeprom_ver.nest_freq_mhz =
-+                                 io_sbeState.mproc_nest_freq_mhz;
-+                }
-+
-                 // If there was an ECC fail on either SEEPROM, do a read-back
-                 // Check when writing this information to the SEEPROM
-                 io_sbeState.new_readBack_check = (
-@@ -2299,7 +2407,6 @@ namespace SBE
-                 // The 2 SBE SEEPROMs are independent of each other
-                 // Determine if PNOR is 1- or 2-sided and if the current
-                 // Seeprom is pointing at PNOR's GOLDEN side
--
-                 PNOR::SideId tmp_side = PNOR::WORKING;
-                 PNOR::SideInfo_t pnor_side_info;
-                 err = PNOR::getSideInfo (tmp_side, pnor_side_info);
-@@ -2322,10 +2429,30 @@ namespace SBE
- 
-                 if ( pnor_side_info.isGolden == true )
-                 {
--                    // If true, nothing to do (covered in istep 6 function)
--                    l_actions = CLEAR_ACTIONS;
-+                    // Check for NEST_FREQ mismatch
-+                    if ( ( io_sbeState.target_is_master == true ) &&
-+                         ( io_sbeState.cur_seeprom_ver_Nest_Freq_Mismatch
-+                                       == true ) )
-+                    {
-+                        l_actions |= DO_UPDATE;
-+                        l_actions |= UPDATE_NEST_FREQ;
- 
--                    TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-+                        TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-+                            "Booting Master Proc READ_ONLY SEEPROM pointing at "
-+                            "PNOR's GOLDEN side and NEST_FREQ mismatch. Update "
-+                            "NEST_FREQ. Continue IPL. "
-+                            "(sit=0x%.2X, act=0x%.8X flags=0x%.2X)",
-+                            TARGETING::get_huid(io_sbeState.target),
-+                            i_system_situation, l_actions,
-+                            io_sbeState.mvpdSbKeyword.flags);
-+                    }
-+
-+                    else
-+                    {
-+                        // Nothing to do (covered in istep 6 function)
-+                        l_actions = CLEAR_ACTIONS;
-+
-+                        TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-                             "Booting READ_ONLY SEEPROM pointing at PNOR's "
-                             "GOLDEN side. No updates for cur side=%d. Continue "
-                             "IPL. (sit=0x%.2X, act=0x%.8X flags=0x%.2X)",
-@@ -2333,19 +2460,38 @@ namespace SBE
-                             io_sbeState.cur_seeprom_side,
-                             i_system_situation, l_actions,
-                             io_sbeState.mvpdSbKeyword.flags);
--                    break;
-+                    }
-                 }
--
-                 else if (  ( pnor_side_info.hasOtherSide == false ) &&
-                          ( io_sbeState.cur_seeprom_side == READ_ONLY_SEEPROM ) )
-                 {
--                    // Even though current seeprom is not pointing at PNOR's
--                    // GOLDEN side, treat like READ_ONLY if booting from
--                    // READ_ONLY seeprom and and PNOR does not have another side
--                    // - No Update (ie, Palmetto configuration)
--                    l_actions = CLEAR_ACTIONS;
-+                    // Check for NEST_FREQ mismatch
-+                    if ( ( io_sbeState.target_is_master == true ) &&
-+                         ( io_sbeState.cur_seeprom_ver_Nest_Freq_Mismatch
-+                                       == true ) )
-+                    {
-+                        l_actions |= DO_UPDATE;
-+                        l_actions |= UPDATE_NEST_FREQ;
- 
--                    TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-+                        TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-+                            "Treating cur of Master Proc like READ_ONLY SBE "
-+                            "SEEPROM and NEST_FREQ mismatch. Update "
-+                            "NEST_FREQ. Continue IPL. "
-+                            "(sit=0x%.2X, act=0x%.8X flags=0x%.2X)",
-+                            TARGETING::get_huid(io_sbeState.target),
-+                            i_system_situation, l_actions,
-+                            io_sbeState.mvpdSbKeyword.flags);
-+                    }
-+                    else
-+                    {
-+
-+                        // Even though current seeprom is not pointing at PNOR's
-+                        // GOLDEN side, treat like READ_ONLY if booting from
-+                        // READ_ONLY seeprom and PNOR does not have another side
-+                        // - No Update (ie, Palmetto configuration)
-+                        l_actions = CLEAR_ACTIONS;
-+
-+                        TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-                                "Treating cur like READ_ONLY SBE SEEPROM. "
-                                "No updates for cur side=%d. Continue IPL. "
-                                "(sit=0x%.2X, act=0x%.8X flags=0x%.2X)",
-@@ -2353,7 +2499,7 @@ namespace SBE
-                                io_sbeState.cur_seeprom_side,
-                                i_system_situation, l_actions,
-                                io_sbeState.mvpdSbKeyword.flags);
--                    break;
-+                    }
-                 }
-                 else // proceed to update this side
-                 {
-@@ -2363,44 +2509,43 @@ namespace SBE
-                                " on cur side=%d ",
-                                TARGETING::get_huid(io_sbeState.target),
-                                io_sbeState.cur_seeprom_side)
--                }
--
- 
--                // Check for clean vs. dirty only on cur side
--                if ( i_system_situation & SITUATION_CUR_IS_DIRTY )
--                {
--                    //  Update cur side and re-ipl
--                    l_actions |= IPL_RESTART;
--                    l_actions |= DO_UPDATE;
--                    l_actions |= UPDATE_SBE;
--                    //even though flags byte not updated
--                    l_actions |= UPDATE_MVPD;
-+                    // Check for clean vs. dirty only on cur side
-+                    if ( i_system_situation & SITUATION_CUR_IS_DIRTY )
-+                    {
-+                        //  Update cur side and re-ipl
-+                        l_actions |= IPL_RESTART;
-+                        l_actions |= DO_UPDATE;
-+                        l_actions |= UPDATE_SBE;
-+                        //even though flags byte not updated
-+                        l_actions |= UPDATE_MVPD;
- 
--                    // Set Update side to cur
--                    io_sbeState.seeprom_side_to_update =
-+                        // Set Update side to cur
-+                        io_sbeState.seeprom_side_to_update =
-                                     ( io_sbeState.cur_seeprom_side ==
-                                                   SBE_SEEPROM0 )
-                                      ? EEPROM::SBE_PRIMARY : EEPROM::SBE_BACKUP;
- 
--                    TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
--                               "cur side (%d) dirty. Update cur. Re-IPL. "
--                               "(sit=0x%.2X, act=0x%.8X flags=0x%.2X)",
--                               TARGETING::get_huid(io_sbeState.target),
--                               io_sbeState.cur_seeprom_side,
--                               i_system_situation, l_actions,
--                               io_sbeState.mvpdSbKeyword.flags);
--                }
--                else
--                {
--                    // Cur side clean - No Updates - Continue IPL
--                    l_actions = CLEAR_ACTIONS;
-+                        TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-+                                   "cur side (%d) dirty. Update cur. Re-IPL. "
-+                                   "(sit=0x%.2X, act=0x%.8X flags=0x%.2X)",
-+                                   TARGETING::get_huid(io_sbeState.target),
-+                                   io_sbeState.cur_seeprom_side,
-+                                   i_system_situation, l_actions,
-+                                   io_sbeState.mvpdSbKeyword.flags);
-+                    }
-+                    else
-+                    {
-+                        // Cur side clean - No Updates - Continue IPL
-+                        l_actions = CLEAR_ACTIONS;
- 
--                    TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
--                               "cur side (%d) clean-no updates. "
--                               "Continue IPL. (sit=0x%.2X, act=0x%.8X)",
--                               TARGETING::get_huid(io_sbeState.target),
--                               io_sbeState.cur_seeprom_side,
--                               i_system_situation, l_actions);
-+                        TRACFCOMP( g_trac_sbe, INFO_MRK"SBE Update tgt=0x%X: "
-+                                   "cur side (%d) clean-no updates. "
-+                                   "Continue IPL. (sit=0x%.2X, act=0x%.8X)",
-+                                   TARGETING::get_huid(io_sbeState.target),
-+                                   io_sbeState.cur_seeprom_side,
-+                                   i_system_situation, l_actions);
-+                    }
-                 }
-             }
- #elif CONFIG_SBE_UPDATE_SIMULTANEOUS
-@@ -2835,6 +2980,32 @@ namespace SBE
-         do{
- 
-             /**************************************************************/
-+            /*  Update NEST_FREQ, if necessary                            */
-+            /**************************************************************/
-+#ifdef CONFIG_SBE_UPDATE_INDEPENDENT
-+            // This can only be set with Golden/READ-ONLY Seeprom situation
-+            if (l_actions & UPDATE_NEST_FREQ)
-+            {
-+                // Call targeting function to update NEST_FREQ
-+                TargetService& tS = targetService();
-+                TARGETING::Target* sys = NULL;
-+                (void) tS.getTopLevelTarget( sys );
-+                assert(sys, "performUpdateActions() system target is NULL");
-+
-+                TRACFCOMP( g_trac_sbe, "performUpdateActions(): "
-+                           "UPDATE_NEST_FREQ to %d ",
-+                           io_sbeState.mproc_nest_freq_mhz);
-+
-+                TARGETING::setFrequencyAttributes(
-+                                       sys,
-+                                       io_sbeState.mproc_nest_freq_mhz);
-+
-+                // This opeation only done by itself and does not need
-+                // an informational error log
-+                break;
-+            }
-+#endif
-+            /**************************************************************/
-             /*  Update SEEPROM, if necessary                              */
-             /**************************************************************/
-             if (l_actions & UPDATE_SBE)
-@@ -3806,4 +3977,195 @@ namespace SBE
-     }
- 
- 
-+
-+/////////////////////////////////////////////////////////////////////
-+    void checkSeepromNestFreq(TARGETING::Target* i_tgt,
-+                              uint32_t i_default_nest_freq,
-+                              uint32_t i_struct_version,
-+                              uint32_t i_seeprom_nest_freq,
-+                              size_t   i_seeprom_num,
-+                              bool &   o_mismatch)
-+    {
-+        TRACUCOMP( g_trac_sbe,
-+                   ENTER_MRK"checkSeepromNestFreq: tgt=0x%X current_freq=%d, "
-+                   "default_freq=%d, version=0x%X, i_seeprom_nest_freq=%d, "
-+                   "seeprom_num=%d",
-+                   TARGETING::get_huid(i_tgt), g_current_nest_freq,
-+                   i_default_nest_freq, i_struct_version,
-+                   i_seeprom_nest_freq, i_seeprom_num);
-+
-+        o_mismatch = false;
-+
-+        // Check Seeprom
-+        if ( i_struct_version == 2 )
-+        {
-+            // Only version that tracks the nest freq when the image was
-+            // customized
-+            if ( g_current_nest_freq == i_seeprom_nest_freq )
-+            {
-+                TRACUCOMP( g_trac_sbe,"checkSeepromNestFreq: tgt=0x%X: "
-+                           "Seeprom%d: ver%d found and current "
-+                           "nest_freq(%d) and image nest_freq(%d) match",
-+                           TARGETING::get_huid(i_tgt),
-+                           i_seeprom_num, i_struct_version,
-+                           g_current_nest_freq,
-+                           i_seeprom_nest_freq);
-+            }
-+            else
-+            {
-+                o_mismatch = true;
-+                TRACFCOMP( g_trac_sbe,"checkSeepromNestFreq: tgt=0x%X: "
-+                           "Seeprom%d: ver%d found and current "
-+                           "nest_freq(%d) and image nest_freq(%d) DO NOT match",
-+                           TARGETING::get_huid(i_tgt),
-+                           i_seeprom_num, i_struct_version,
-+                           g_current_nest_freq, i_seeprom_nest_freq);
-+            }
-+        }
-+
-+        else
-+        {
-+            // Either old version (like 1), unitialized, simics, corrupted, etc
-+            // Assume SBE image created with the module's default frequency
-+            if ( g_current_nest_freq == i_default_nest_freq )
-+            {
-+                TRACUCOMP( g_trac_sbe,"checkSeepromNestFreq: tgt=0x%X: "
-+                           "Seeprom%d: ver=0x%X found and current "
-+                           "nest_freq(%d) and default nest_freq(%d) match",
-+                           TARGETING::get_huid(i_tgt),
-+                           i_seeprom_num, i_struct_version,
-+                           g_current_nest_freq, i_default_nest_freq);
-+            }
-+            else
-+            {
-+                o_mismatch = true;
-+                TRACFCOMP( g_trac_sbe,"checkSeepromNestFreq: tgt=0x%X: "
-+                           "Seeprom%d: ver=0x%X found and current "
-+                           "nest_freq(%d) and default nest_freq(%d) "
-+                           "DO NOT match. ",
-+                           TARGETING::get_huid(i_tgt),
-+                           i_seeprom_num, i_struct_version,
-+                           g_current_nest_freq, i_default_nest_freq);
-+            }
-+
-+        }
-+
-+        TRACUCOMP( g_trac_sbe,
-+                   EXIT_MRK"checkSeepromNestFreq: tgt=0x%X "
-+                   "Seeprom%d: return o_mismatch=%d",
-+                   TARGETING::get_huid(i_tgt), i_seeprom_num, o_mismatch);
-+
-+        return;
-+    }
-+
-+
-+/////////////////////////////////////////////////////////////////////
-+    errlHndl_t checkNestFreqSettings(sbeTargetState_t& io_sbeState)
-+    {
-+        TRACDCOMP( g_trac_sbe,
-+                   ENTER_MRK"checkNestFreqSettings");
-+
-+        errlHndl_t err = NULL;
-+
-+        uint32_t default_nest_freq = 0;
-+
-+        do{
-+
-+            // Set defaults
-+            io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch = false;
-+            io_sbeState.seeprom_1_ver_Nest_Freq_Mismatch = false;
-+
-+            // Get DEFAULT_PROC_MODULE_NEST_FREQ_MHZ attribute
-+            default_nest_freq = io_sbeState.target->getAttr<
-+                         TARGETING::ATTR_DEFAULT_PROC_MODULE_NEST_FREQ_MHZ>();
-+
-+            TRACUCOMP( g_trac_sbe,"checkNestFreqSettings(): ATTR_NEST_FREQ_MHZ "
-+                       "=%d, ATTR_DEFAULT_PROC_MODULE_NEST_FREQ_MHZ=%d",
-+                       g_current_nest_freq, default_nest_freq);
-+
-+            // Check Seeprom 0
-+            checkSeepromNestFreq(io_sbeState.target,
-+                                 default_nest_freq,
-+                                 io_sbeState.seeprom_0_ver.struct_version,
-+                                 io_sbeState.seeprom_0_ver.nest_freq_mhz,
-+                                 0,
-+                                 io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch);
-+
-+            // Check Seeprom 1
-+            checkSeepromNestFreq(io_sbeState.target,
-+                                 default_nest_freq,
-+                                 io_sbeState.seeprom_1_ver.struct_version,
-+                                 io_sbeState.seeprom_1_ver.nest_freq_mhz,
-+                                 1,
-+                                 io_sbeState.seeprom_1_ver_Nest_Freq_Mismatch);
-+
-+            // Set the frequency at which the master processor booted from
-+            if ( io_sbeState.target_is_master == true )
-+            {
-+                //Get Current (boot) Side
-+                sbeSeepromSide_t tmp_cur_side = SBE_SEEPROM_INVALID;
-+                err = getSbeBootSeeprom(io_sbeState.target, tmp_cur_side);
-+                if(err)
-+                {
-+                    TRACFCOMP( g_trac_sbe, ERR_MRK"checkNestFreqSettings() - "
-+                               "Error returned from getSbeBootSeeprom()");
-+
-+                    // Assume it was default frequency for this module
-+                    io_sbeState.mproc_nest_freq_mhz = default_nest_freq;
-+
-+                    break;
-+                }
-+
-+                if (tmp_cur_side == SBE_SEEPROM0)
-+                {
-+                    if ( io_sbeState.seeprom_0_ver.struct_version == 2 )
-+                    {
-+                        io_sbeState.mproc_nest_freq_mhz =
-+                                    io_sbeState.seeprom_0_ver.nest_freq_mhz;
-+                    }
-+                    else
-+                    {
-+                        // Assume it was default frequency for this module
-+                        io_sbeState.mproc_nest_freq_mhz = default_nest_freq;
-+                    }
-+                }
-+                else if ( io_sbeState.cur_seeprom_side == SBE_SEEPROM1)
-+                {
-+                    if ( io_sbeState.seeprom_1_ver.struct_version == 2 )
-+                    {
-+                        io_sbeState.mproc_nest_freq_mhz =
-+                                    io_sbeState.seeprom_1_ver.nest_freq_mhz;
-+                    }
-+                    else
-+                    {
-+                        // Assume it was default frequency for this module
-+                        io_sbeState.mproc_nest_freq_mhz = default_nest_freq;
-+                    }
-+                }
-+                else
-+                {
-+                    // Assume it was default frequency for this module
-+                    io_sbeState.mproc_nest_freq_mhz = default_nest_freq;
-+                }
-+
-+            }
-+
-+            TRACUCOMP( g_trac_sbe,"checkNestFreqSettings(): s0-mismatch=%d, "
-+                       "s1-mismatch=%d, mproc_nest_freq_mhz=%d",
-+                       io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch,
-+                       io_sbeState.seeprom_0_ver_Nest_Freq_Mismatch,
-+                       io_sbeState.mproc_nest_freq_mhz);
-+
-+        }while(0);
-+
-+
-+        TRACDCOMP( g_trac_sbe,
-+                   EXIT_MRK"checkNestFreqSettings");
-+
-+        return err;
-+
-+    }
-+
-+
-+
- } //end SBE Namespace
-diff --git a/src/usr/sbe/sbe_update.H b/src/usr/sbe/sbe_update.H
-index 1d4b208..f13e9b1 100644
---- a/src/usr/sbe/sbe_update.H
-+++ b/src/usr/sbe/sbe_update.H
-@@ -44,9 +44,21 @@ namespace SBE
-     const size_t   SBE_MVPD_SHORT_IMAGE_VERSION_SIZE = 20;
- 
-     // Version of Struct stored in SEEPROM
--    const uint32_t SBE_SEEPROM_STRUCT_VERSION        = 0x00000001;
-+    const uint32_t SBE_SEEPROM_STRUCT_VERSION        = 0x00000002;
-     const uint32_t SBE_SEEPROM_STRUCT_SIMICS_VERSION = 0x5A5A5A5A;
- 
-+    // Number of versions supported
-+    const uint8_t SBE_SEEPROM_STRUCT_MAX_VERSIONS    = 0x03;
-+
-+    // Size of supported versions - must be 8-byte aligned
-+    const size_t  SBE_SEEPROM_STRUCT_SIZES[SBE_SEEPROM_STRUCT_MAX_VERSIONS] =
-+                      {
-+                        0,   // ver0: uninitialized - no size
-+                        72,  // ver1: size of struct is 72 bytes
-+                        80,  // ver2: size of struct is 80 bytes
-+                      };
-+
-+
-     // Constant written to SBE SEEPROM version struct to invalidate the
-     // struct and the image - 'INVALID\0'
-     const uint64_t SBE_SEEPROM_STRUCT_INVALID = 0x494E56414C494400;
-@@ -126,6 +138,7 @@ namespace SBE
-         MVPD_UPDATE_COMPLETE   = 0x00000008,
-         UPDATE_SBE             = 0x00000010,
-         SBE_UPDATE_COMPLETE    = 0x00000020,
-+        UPDATE_NEST_FREQ       = 0x00000100,
-         UNSUPPORTED_SITUATION  = 0x80000000,
-     };
- 
-@@ -138,18 +151,25 @@ namespace SBE
-      *
-      * NOTE: For ECC purposes, this must be 8-byte aligned,
-      *       so pad data if necessary
--     *       struct_version 1: size = 4+64+4 = 72 (aligned)
-+     *       struct_version 1: size = 4+4+64 = 72 (aligned)
-+     *       struct_version 2: size = 4+4+64+4+4 = 80 (aligned)
-      */
-     struct sbeSeepromVersionInfo_t
-     {
-+        // The first 64-bits will be read out to check for struct_version
-         uint32_t  struct_version;
-         uint32_t  data_crc;
-         uint8_t   image_version[SBE_IMAGE_VERSION_SIZE];
-+
-+        // New parameters for version 2: nest_freq_mhz and uin32_t/reserved
-+        uint32_t  nest_freq_mhz;
-+        uint32_t  reserved;      // reserved; added for alignment
-     } PACKED;
- 
-     // This line forces a compile fail if struct is NOT 8-byte-alaigned
-     CPPASSERT(0 == (sizeof(sbeSeepromVersionInfo_t) % 8));
- 
-+
-     /**
-      * @brief Struct of individual SBE entry in SBE and SBEC
-      *        Table of Contents in PNOR partitions
-@@ -208,6 +228,11 @@ namespace SBE
-         bool                     seeprom_0_ver_ECC_fail;
-         bool                     seeprom_1_ver_ECC_fail;
- 
-+        bool                     seeprom_0_ver_Nest_Freq_Mismatch;
-+        bool                     seeprom_1_ver_Nest_Freq_Mismatch;
-+        bool                     cur_seeprom_ver_Nest_Freq_Mismatch;
-+        uint32_t                 mproc_nest_freq_mhz;
-+
-         sbeSeepromSide_t         cur_seeprom_side; // aka 'booted' side
-         sbeSeepromSide_t         alt_seeprom_side;
-         sbeSeepromSide_t         permanent_seeprom_side;
-@@ -231,6 +256,10 @@ namespace SBE
-         sbeTargetState_t() :
-           target(NULL), target_is_master(false), ec(0x0),
-           seeprom_0_ver_ECC_fail(false), seeprom_1_ver_ECC_fail(false),
-+          seeprom_0_ver_Nest_Freq_Mismatch(false),
-+          seeprom_1_ver_Nest_Freq_Mismatch(false),
-+          cur_seeprom_ver_Nest_Freq_Mismatch(false),
-+          mproc_nest_freq_mhz(0x0),
-           customizedImage_size(0x0), customizedImage_crc(0x0),
-           new_readBack_check(false),
-           err_plid(0x0), err_eid(0x0), err_rc(0x0)
-@@ -248,9 +277,13 @@ namespace SBE
-      *
-      * @param[io/out] io_sbeState   Struct containing SBE State of the target
-      *
-+     * @param[io/out] i_check_type  Determines if an early check should be run
-+     *                              before collecting all of the information.
-+     *
-      * @return errlHndl_t    Error log handle on failure.
-      */
--    errlHndl_t getSbeInfoState(sbeTargetState_t& io_sbeState);
-+    errlHndl_t getSbeInfoState(sbeTargetState_t& io_sbeState,
-+                               sbeUpdateCheckType& i_check_type);
- 
-     /**
-      * @brief Analyze and Determine Update Actions for a specific target
-@@ -501,5 +534,23 @@ namespace SBE
-                          size_t i_maxBits);
- 
- 
-+    /**
-+     * @brief Checks the Nest Frequency value stored in the the version struct
-+     *        and compares it ot the NEST_FREQ_MHZ attribute of the system
-+     *
-+     * @param[io/out] io_sbeState   Struct containing SBE State of the target
-+     *                              and is updated based on the situation
-+     *
-+     * @pre   seeprom_0_ver and seeprom_1_ver have been filled in
-+     *
-+     * @post  seeprom_0_ver_Nest_Freq_Mismatch,
-+     *        seeprom_1_ver_Nest_Freq_Mismatch, and nest_freq_check_complete
-+     *        are set.
-+     *
-+     * @return errlHndl_t    Error log handle on failure.
-+     */
-+    errlHndl_t checkNestFreqSettings(sbeTargetState_t& io_sbeState);
-+
-+
- } //end namespace SBE
- #endif
-diff --git a/src/usr/sbe/test/sbeupdatetest.H b/src/usr/sbe/test/sbeupdatetest.H
-index c5a3dd5..bbdeb1e 100644
---- a/src/usr/sbe/test/sbeupdatetest.H
-+++ b/src/usr/sbe/test/sbeupdatetest.H
-@@ -444,9 +444,11 @@ class SBEUpdateTest: public CxxTest::TestSuite
-             // set bad ec just for comparison to local_ec later
-             sbeState.ec = 0xFF;
- 
-+            // send input part to perform all checks
-+            sbeUpdateCheckType i_check_type = SBE_UPDATE_CHECK_ALL;
- 
-             total++;
--            err = getSbeInfoState(sbeState);
-+            err = getSbeInfoState(sbeState, i_check_type);
-             if(err)
-             {
-                 fails++;
-diff --git a/src/usr/targeting/common/genHwsvMrwXml.pl b/src/usr/targeting/common/genHwsvMrwXml.pl
-index a720c44..18746cc 100755
---- a/src/usr/targeting/common/genHwsvMrwXml.pl
-+++ b/src/usr/targeting/common/genHwsvMrwXml.pl
-@@ -2352,6 +2352,25 @@ sub generate_sys
- ";
-     }
- 
-+    # Tuletas can now support multiple nest frequencies
-+    if ($sysname =~ /tuleta/)
-+    {
-+        print "
-+    <attribute><id>MRW_NEST_CAPABLE_FREQUENCIES_SYS</id>
-+        <default>2000_MHZ_OR_2400_MHZ</default>
-+    </attribute>
-+";
-+    }
-+    else
-+    {
-+        print "
-+    <attribute><id>MRW_NEST_CAPABLE_FREQUENCIES_SYS</id>
-+        <default>UNSUPPORTED_FREQ</default>
-+    </attribute>
-+";
-+    }
-+
-+
-     if( $haveFSPs == 0 )
-     {
-         generate_apss_adc_config()
-diff --git a/src/usr/targeting/common/xmltohb/attribute_types.xml b/src/usr/targeting/common/xmltohb/attribute_types.xml
-index 22467ea..05497fd 100644
---- a/src/usr/targeting/common/xmltohb/attribute_types.xml
-+++ b/src/usr/targeting/common/xmltohb/attribute_types.xml
-@@ -16600,5 +16600,23 @@ firmware notes: Platforms should initialize this attribute to AUTO (0)</descript
-         <macro>DIRECT</macro>
-     </hwpfToHbAttrMap>
- </attribute>
-+<attribute>
-+    <id>DEFAULT_PROC_MODULE_NEST_FREQ_MHZ</id>
-+    <description>
-+        Default Nest frequency in MHz for Processor Modules
-+        Default to 2000 MHz for Murano-based Modules
-+        Default to 2400 MHz for Venice- and Naples-based Modules
-+    </description>
-+    <simpleType>
-+        <uint32_t>
-+            <default>2000</default>
-+        </uint32_t>
-+    </simpleType>
-+    <persistency>non-volatile</persistency>
-+    <readable/>
-+</attribute>
-+
-+
-+
- 
- </attributes>
-diff --git a/src/usr/targeting/common/xmltohb/target_types.xml b/src/usr/targeting/common/xmltohb/target_types.xml
-index 0b45bb0..9475cc4 100644
---- a/src/usr/targeting/common/xmltohb/target_types.xml
-+++ b/src/usr/targeting/common/xmltohb/target_types.xml
-@@ -666,6 +666,10 @@
-         <id>PROC_PCIE_REFCLOCK_ENABLE</id>
-         <default>0xE0</default>
-     </attribute>
-+    <attribute>
-+        <id>DEFAULT_PROC_MODULE_NEST_FREQ_MHZ</id>
-+        <default>2400</default>
-+    </attribute>
- </targetType>
- 
- <targetType>
-@@ -691,6 +695,10 @@
-         <id>PROC_PCIE_REFCLOCK_ENABLE</id>
-         <default>0xE0</default>
-     </attribute>
-+    <attribute>
-+        <id>DEFAULT_PROC_MODULE_NEST_FREQ_MHZ</id>
-+        <default>2000</default>
-+    </attribute>
- </targetType>
- 
- <targetType>
-@@ -716,6 +724,10 @@
-         <id>PROC_PCIE_REFCLOCK_ENABLE</id>
-         <default>0xF0</default>
-     </attribute>
-+    <attribute>
-+        <id>DEFAULT_PROC_MODULE_NEST_FREQ_MHZ</id>
-+        <default>2400</default>
-+    </attribute>
- </targetType>
- 
- <targetType>
--- 
-1.8.2.2
-
diff --git a/openpower/package/hostboot/hostboot-0005-Function-to-set-nest-freq-based-off-dimms.patch b/openpower/package/hostboot/hostboot-0005-Function-to-set-nest-freq-based-off-dimms.patch
deleted file mode 100644
index d64991a..0000000
--- a/openpower/package/hostboot/hostboot-0005-Function-to-set-nest-freq-based-off-dimms.patch
+++ /dev/null
@@ -1,937 +0,0 @@
-From 8afc07837b303e5621ba28fed8a070eba633475d Mon Sep 17 00:00:00 2001
-From: aalugore <aalugore@us.ibm.com>
-Date: Mon, 24 Aug 2015 13:42:24 -0500
-Subject: [PATCH] Function to set Nest Frequency based off DIMM memory
- capability
-
--Needed for 32x32GB DIMM support
--Finds max capable frequency of system and all present DIMMs
- and deconfigures any DIMM that cannot run at desired frequency
--If necessary, Sets Nest Freq and triggers SBE update
-
-Change-Id: I9bba92f55f1b67ff4a15d79113f19d39272ec72d
-RTC:122884
-Depends-on:I1dca7196cd02a2704a238665b73b522c9e103936
----
- src/include/usr/hwpf/hwpf_reasoncodes.H            |   4 +-
- src/include/usr/isteps/istep12list.H               |   4 +-
- src/include/usr/sbe/sbeif.H                        |  16 +
- src/include/usr/targeting/common/target.H          |  11 +
- src/include/util/algorithm.H                       |  18 +-
- src/include/util/align.H                           |  17 +-
- src/usr/hwpf/hwp/mc_config/mc_config.C             | 437 ++++++++++++++++++++-
- src/usr/hwpf/hwp/memory_attributes.xml             |  12 +-
- src/usr/hwpf/plat/fapiPlatUtil.C                   |   2 +-
- src/usr/sbe/sbe_update.C                           |  62 +++
- src/usr/targeting/common/target.C                  |  47 +++
- .../targeting/common/xmltohb/attribute_types.xml   |  10 +-
- 12 files changed, 608 insertions(+), 32 deletions(-)
-
-diff --git a/src/include/usr/hwpf/hwpf_reasoncodes.H b/src/include/usr/hwpf/hwpf_reasoncodes.H
-index e1a00da..ea326c1 100644
---- a/src/include/usr/hwpf/hwpf_reasoncodes.H
-+++ b/src/include/usr/hwpf/hwpf_reasoncodes.H
-@@ -80,7 +80,9 @@ namespace fapi
-         MOD_PLAT_MVPD_GET_VLTG_BUCKET_ATTR         = 0x26,
-         MOD_PLAT_ATTR_SVC_CEN_DQ_TO_DIMM_CONN_DQ   = 0x27,
-         MOD_PLAT_ATTR_SVC_GET_MEM_ATTR_DATA        = 0x28,
--
-+        MOD_GET_WOF_FREQ_UPLIFT_SELECTED           = 0x29,
-+        MOD_SET_NEST_FREQ                          = 0x2A,
-+        MOD_FIND_MAX_DMI_SPD                       = 0x2B,
-     };
- 
-     /**
-diff --git a/src/include/usr/isteps/istep12list.H b/src/include/usr/isteps/istep12list.H
-index 2e724f2..f668733 100644
---- a/src/include/usr/isteps/istep12list.H
-+++ b/src/include/usr/isteps/istep12list.H
-@@ -5,7 +5,7 @@
- /*                                                                        */
- /* OpenPOWER HostBoot Project                                             */
- /*                                                                        */
--/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
-+/* Contributors Listed Below - COPYRIGHT 2012,2015                        */
- /* [+] Google Inc.                                                        */
- /* [+] International Business Machines Corp.                              */
- /*                                                                        */
-@@ -105,6 +105,8 @@ const DepModInfo g_istep12Dependancies = {
- #ifndef CONFIG_VPO_COMPILE
-         DEP_LIB(libmc_config.so),
- #endif
-+        DEP_LIB(libsbe.so),
-+        DEP_LIB(libbuild_winkle_images.so),
-         NULL
-     }
- };
-diff --git a/src/include/usr/sbe/sbeif.H b/src/include/usr/sbe/sbeif.H
-index b00e01f..ff397ca 100644
---- a/src/include/usr/sbe/sbeif.H
-+++ b/src/include/usr/sbe/sbeif.H
-@@ -94,6 +94,22 @@ namespace SBE
-      */
-     errlHndl_t resolveProcessorSbeSeeproms();
- 
-+    /**
-+     * @brief Determines whether we are on the Golden side or not
-+     *
-+     * @param[out] o_isGolden boolean, True if we are on Golden side, False
-+     *                        otherwise.
-+     *
-+     * @return errlHndl_t Error log handle on failure.
-+     *
-+     * NOTE: -Golden Side means we booted from the Golden Seeprom pointing
-+     *        at the Golden side of PNOR.
-+     *       -Using master processor to make this determination.
-+     */
-+
-+    errlHndl_t isGoldenSide( bool & o_isGolden );
-+
-+
- 
- } //end namespace SBE
- 
-diff --git a/src/include/usr/targeting/common/target.H b/src/include/usr/targeting/common/target.H
-index 25e7be6..bf5b7da 100644
---- a/src/include/usr/targeting/common/target.H
-+++ b/src/include/usr/targeting/common/target.H
-@@ -672,6 +672,17 @@ const char* Target::getAttrAsString() const
-     return attrToString<A>(l_attrValue);
- }
- 
-+// Function to set various frequency related attributes
-+/**
-+ * @brief - sets various attributes directly related to the nest frequency.
-+ *
-+ * @param[in] i_sys - top level system target to set attributes for
-+ * @param[in] i_newNestFreq - the new nest frequency to base all the attributes
-+ *                            off of.
-+ */
-+void setFrequencyAttributes(Target * i_sys, uint32_t i_newNestFreq);
-+
-+
- // WARNING: The following #include imports any platform specific template
- // specializations for getAttr and tryGetAttr
- #include <targeting/adapters/targetadapter.H>
-diff --git a/src/include/util/algorithm.H b/src/include/util/algorithm.H
-index 54baa02..dac0f47 100644
---- a/src/include/util/algorithm.H
-+++ b/src/include/util/algorithm.H
-@@ -5,7 +5,9 @@
- /*                                                                        */
- /* OpenPOWER HostBoot Project                                             */
- /*                                                                        */
--/* COPYRIGHT International Business Machines Corp. 2012,2014              */
-+/* Contributors Listed Below - COPYRIGHT 2012,2015                        */
-+/* [+] International Business Machines Corp.                              */
-+/*                                                                        */
- /*                                                                        */
- /* Licensed under the Apache License, Version 2.0 (the "License");        */
- /* you may not use this file except in compliance with the License.       */
-@@ -52,6 +54,20 @@ namespace Util
-             static const T value = (a > b) ? a : b;
-         };
- 
-+        /**
-+         * @brief - utility function that determines if a given number is
-+         *          power of 2.
-+         *
-+         * @param[in] i_num - given number.
-+         *
-+         * @return bool - True if the number is a power of 2, False otherwise.
-+         */
-+        template <typename T>
-+        bool isPow2(T i_num)
-+        {
-+            return (!(i_num & (i_num-1)));
-+        }
-+
-     };
- };
- #endif
-diff --git a/src/include/util/align.H b/src/include/util/align.H
-index e0132b2..10a8369 100644
---- a/src/include/util/align.H
-+++ b/src/include/util/align.H
-@@ -51,18 +51,7 @@
- #define ALIGN_MEGABYTE(u)       (ALIGN_X(u,MEGABYTE))
- #define ALIGN_MEGABYTE_DOWN(u)  (ALIGN_DOWN_X(u,MEGABYTE))
- 
--// Returns a number that is aligned to the next highest power of 2 number of
--// pages for the given buffer.
--#define ALIGN_TO_NEXT_POWER_OF_TWO_PAGES(b)   ({\
--    unsigned int v = ALIGN_PAGE(b)/PAGE_SIZE;\
--    v--;\
--    v |= v >> 1;\
--    v |= v >> 2;\
--    v |= v >> 4;\
--    v |= v >> 8;\
--    v |= v >> 16;\
--    v++;\
--    v * PAGE_SIZE;\
--    })
--
-+// Return a number rounded to the next power of two.
-+#define ALIGN_POW2(u)           ((u&(u-1)) ? 1 << (64 - __builtin_clzl(u)) : u)
-+#define ALIGN_POW2_DOWN(u)      (u ? 1 << (63 - __builtin_clzl(u)) : 0)
- #endif
-diff --git a/src/usr/hwpf/hwp/mc_config/mc_config.C b/src/usr/hwpf/hwp/mc_config/mc_config.C
-index b2bc2f1..f29ee7c 100644
---- a/src/usr/hwpf/hwp/mc_config/mc_config.C
-+++ b/src/usr/hwpf/hwp/mc_config/mc_config.C
-@@ -44,16 +44,19 @@
- 
- #include    <trace/interface.H>
- #include    <initservice/taskargs.H>
-+#include    <initservice/initserviceif.H>
- #include    <errl/errlentry.H>
- 
- #include    <hwpisteperror.H>
-+#include    <hwpf/hwpf_reasoncodes.H>
- #include    <errl/errludtarget.H>
- 
- #include    <initservice/isteps_trace.H>
--
-+#include    <sbe/sbeif.H>
- //  targeting support
- #include    <targeting/common/commontargeting.H>
- #include    <targeting/common/utilFilter.H>
-+#include    <attributetraits.H>
- 
- //  fapi support
- #include    <fapi.H>
-@@ -79,6 +82,8 @@
- #include    "mss_volt/mss_volt_dimm_count.H"
- 
- #include <config.h>
-+#include <util/align.H>
-+#include <util/algorithm.H>
- 
- namespace   MC_CONFIG
- {
-@@ -129,7 +134,8 @@ void set_eff_config_attrs_helper( const EFF_CONFIG_ATTRIBUTES_BASE i_base,
-     // Get Node Target
-     TARGETING::Target* sysTgt = NULL;
-     TARGETING::targetService().getTopLevelTarget(sysTgt);
--    assert(sysTgt != NULL,"System target was NULL.");
-+    assert(sysTgt != NULL,"set_eff_config_attrs_helper: "
-+                        "System target was NULL.");
- 
-     TARGETING::TargetHandleList l_nodeList;
- 
-@@ -467,7 +473,8 @@ errlHndl_t setMemoryVoltageDomainOffsetVoltage()
- 
-     TARGETING::Target* pSysTarget = NULL;
-     TARGETING::targetService().getTopLevelTarget(pSysTarget);
--    assert(pSysTarget != NULL,"System target was NULL.");
-+    assert(pSysTarget != NULL,"setMemoryVoltageDomainOffsetVoltage: "
-+                                        "System target was NULL.");
- 
-     typename AttributeTraits< OFFSET_DISABLEMENT_ATTR >::Type
-         disableOffsetVoltage =
-@@ -717,13 +724,16 @@ void  call_mss_volt_hwp (std::vector<TARGETING::ATTR_VMEM_ID_type>& i_VmemList,
-                 l_membufFapiTargets.push_back( l_membuf_fapi_target );
-             }
-         }
-+
-+        TRACDCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                    "Calling mss_volt_hwp...");
-         FAPI_INVOKE_HWP(l_err, mss_volt_hwp, l_membufFapiTargets);
- 
-         //  process return code.
-         if ( l_err )
-         {
-             TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
--                    "ERROR 0x%.8X:  mss_volt_dimm_count HWP( ) ",
-+                    "ERROR 0x%.8X:  mss_volt HWP( ) ",
-                     l_err->reasonCode());
- 
-             // Create IStep error log and cross reference to error that occurred
-@@ -872,7 +882,411 @@ void* call_mss_volt( void *io_pArgs )
- 
-     return l_StepError.getErrorHandle();
- }
-+/**
-+ * @brief - this utility function takes in the frequency in
-+ *          ATTR_MRW_NEST_CAPABLE_FREQUENCIES_SYS and returns the corresponding
-+ *          dmi bus speed from ATTR_MSS_NEST_CAPABLE_FREQUENCIES
-+ *
-+ * @param[in] i_freq - the input frequency
-+ * @param[in/out] io_speed - the corresponding dmi bus speed
-+ */
-+void sysFreq_to_dmiSpeed(ATTR_MRW_NEST_CAPABLE_FREQUENCIES_SYS_type i_freq,
-+                         ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type & io_speed)
-+{
-+    switch(i_freq)
-+    {
-+        case TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_UNSUPPORTED_FREQ:
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,"Unsupported nest freq!");
-+            io_speed = 0;
-+            break;
-+        case TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_2000_MHZ:
-+            io_speed=fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_8_0G;
-+            break;
-+        case TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_2400_MHZ:
-+            io_speed=fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_9_6G;
-+            break;
-+        case TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_2000_MHZ_OR_2400_MHZ:
-+            io_speed=fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_8_0G_OR_9_6G;
-+            break;
-+        default:
-+            io_speed = 0;
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,"Invalid nest freq!");
-+    }
-+}
- 
-+/**
-+ * @brief - this utility function takes in the dmi bus speed enumeration
-+ *          value as described in MSS_NEST_CAPABLE_FREQUENCIES and outputs
-+ *          the actual corresponding nest frequency in MHz supported by the
-+ *          given dmi bus speed.
-+ *
-+ * @param[in] i_speed - the input dmi bus speed
-+ * @param[in/out] io_freq - the corresponding frequency in MHz
-+ *
-+ */
-+void dmiSpeed_to_sysFreq(ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type i_speed,
-+                         ATTR_NEST_FREQ_MHZ_type & io_freq)
-+{
-+    switch(i_speed)
-+    {
-+        case fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_8_0G:
-+            io_freq = 2000;
-+            break;
-+        case fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_9_6G:
-+            io_freq = 2400;
-+            break;
-+        default:
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "Invalid dmi speed!");
-+            io_freq = 0;
-+    }
-+}
-+
-+
-+
-+//
-+// calloutChildDimms
-+//
-+void calloutChildDimms(errlHndl_t & io_errl, const TARGETING::Target * i_membuf)
-+{
-+    TargetHandleList l_dimmList;
-+
-+    // Get child dimms
-+    getChildAffinityTargets( l_dimmList,
-+                             i_membuf,
-+                             CLASS_NA,
-+                             TYPE_DIMM );
-+
-+    if( !l_dimmList.empty())
-+    {
-+        // iterate over the DIMMs and call them out
-+        TargetHandleList::iterator l_iter = l_dimmList.begin();
-+
-+        for(;l_iter != l_dimmList.end(); ++l_iter)
-+        {
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                      "Calling out DIMM Target huid = %x",
-+                      get_huid(*l_iter));
-+
-+            io_errl->addHwCallout( *l_iter,
-+                                   HWAS::SRCI_PRIORITY_MED,
-+                                   HWAS::DELAYED_DECONFIG,
-+                                   HWAS::GARD_NULL );
-+        }
-+    }
-+    else
-+    {
-+        TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "No child DIMMs found!");
-+    }
-+}
-+
-+
-+// TODO RTC 135720 - Support for mixed DIMM configuration with 32GB DIMMs.
-+
-+/**
-+ * @brief - Recursive utility function for finding the max dmi
-+ *          bus speed to run at based on the nest dmi bus speed
-+ *          and the membuf's dmi bus speed
-+ *
-+ * @param[in] i_iter - Iterator over the list of membufs.
-+ * @param[in] i_membufs - Pointer to the list of membufs.
-+ * @param[in/out] io_currentMaxSpeed - The speed to run at will be returned here
-+ * @param[in] i_capableNestDmiBusSpeed - The nest capable dmi bus speed.
-+ */
-+void findMaxSpdAndDeconfigIncompatible(TargetHandleList::iterator i_iter,
-+              TargetHandleList * i_membufs,
-+              ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type & io_currentMaxSpeed,
-+              ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type i_capableNestDmiBusSpeed )
-+{
-+    do
-+    {
-+        // Base Case: If we are at the end of the membuf list return
-+        if(i_iter == i_membufs->end())
-+        {
-+            // find the left most bit of the max speed found. This bit
-+            // represents the highest dmi bus speed setting we can support
-+            // across the nest and all membufs and the speed we will boot with.
-+            io_currentMaxSpeed = ALIGN_POW2_DOWN(io_currentMaxSpeed);
-+            break;
-+        }
-+
-+        // Get the current membuf's dmi bus speed
-+        ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type l_currentMembufSpd =
-+            (*i_iter)->getAttr<TARGETING::ATTR_MSS_NEST_CAPABLE_FREQUENCIES>();
-+
-+        // update current max speed.
-+        // Max is restricted by nest capable dmi bus speed
-+        if(((l_currentMembufSpd & i_capableNestDmiBusSpeed) != 0) &&
-+                (l_currentMembufSpd > io_currentMaxSpeed))
-+        {
-+            io_currentMaxSpeed = l_currentMembufSpd;
-+        }
-+
-+        //Save the current membuf for when we come back from recursive call.
-+        TARGETING::Target * l_currentMembuf = (*i_iter);
-+
-+        // Recursive call to go down the list of membufs and find the max
-+        // capable dmi speed across the nest and membufs.
-+        findMaxSpdAndDeconfigIncompatible(++i_iter,
-+                                          i_membufs,
-+                                          io_currentMaxSpeed,
-+                                          i_capableNestDmiBusSpeed );
-+
-+        // deconfigure any membufs with incompatible
-+        // speeds on the way up the stack
-+        if((l_currentMembufSpd & io_currentMaxSpeed) == 0)
-+        {
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                    "Deconfiguring Membuf Huid: %X, membuf speed: %d",
-+                    TARGETING::get_huid(l_currentMembuf),
-+                    l_currentMembufSpd);
-+            // Membuf has incompatible frequency. Deconfigure it.
-+            /*@
-+             * @errortype
-+             * @moduleid    MOD_FIND_MAX_DMI_SPD
-+             * @reasoncode  RC_INVALID_FREQ
-+             * @userdata1   HUID of membuf
-+             * @userdata2   [0:7] membuf frequency enumeration value
-+             * @userdata2   [8:15] dmi bus speed enumeration value
-+             * @devdesc     Invalid nest frequency found for given membuf
-+             * @custdesc    Invalid memory configuration
-+             */
-+            errlHndl_t l_err = new ERRORLOG::ErrlEntry(
-+                                          ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-+                                          fapi::MOD_FIND_MAX_DMI_SPD,
-+                                          fapi::RC_INVALID_FREQ,
-+                                          TARGETING::get_huid(l_currentMembuf),
-+                                          TO_UINT64(TWO_UINT8_TO_UINT16
-+                                          (l_currentMembufSpd,
-+                                           i_capableNestDmiBusSpeed)));
-+
-+            l_err->addHwCallout(l_currentMembuf, HWAS::SRCI_PRIORITY_HIGH,
-+                                          HWAS::DELAYED_DECONFIG,
-+                                          HWAS::GARD_NULL );
-+            l_err->addProcedureCallout(
-+                    HWAS::EPUB_PRC_MEMORY_PLUGGING_ERROR,
-+                    HWAS::SRCI_PRIORITY_HIGH );
-+
-+
-+            // add hw callouts for current membuf child DIMMs
-+            calloutChildDimms( l_err, l_currentMembuf );
-+
-+            errlCommit( l_err, HWPF_COMP_ID );
-+            l_err = NULL;
-+        }
-+    }while( 0 );
-+}
-+
-+
-+//
-+// setNestBasedOffDimms
-+//
-+errlHndl_t setNestBasedOffDimms()
-+{
-+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, ENTER_MRK"mc_config::setNestBasedOffDimms()");
-+    errlHndl_t l_err = NULL;
-+    bool l_isGoldenSide = false;
-+    ATTR_MRW_NEST_CAPABLE_FREQUENCIES_SYS_type l_capableNestFreq =
-+            MRW_NEST_CAPABLE_FREQUENCIES_SYS_UNSUPPORTED_FREQ;
-+
-+    ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type l_selectedBootSpeed =
-+            fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_NONE;
-+
-+    ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type l_capableNestDmiBusSpeed =
-+            fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_NONE;
-+
-+    ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type l_compatibleSpeed =
-+            fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_NONE;
-+
-+    ATTR_NEST_FREQ_MHZ_type l_maxFreqMhz = 0;
-+
-+    l_isGoldenSide = false;
-+
-+    do
-+    {
-+        // First, get the systems capable nest frequency. If 0, then stick with
-+        // already set nest frequency
-+        TARGETING::Target * l_sys = NULL;
-+        targetService().getTopLevelTarget(l_sys);
-+
-+        uint32_t l_currentSysNestFreq =
-+            l_sys->getAttr<TARGETING::ATTR_NEST_FREQ_MHZ>();
-+
-+        // Check to see if we booted from the Golden side
-+        l_err = SBE::isGoldenSide(l_isGoldenSide);
-+
-+        if(l_err)
-+        {
-+            // Error getting Golden side. Proceeding as if booting from safe Golden side
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                ERR_MRK"setNestBasedOffDimms::isGoldenSide returned an error");
-+            errlCommit( l_err, HWPF_COMP_ID );
-+            l_isGoldenSide = true;
-+        }
-+
-+        if(!l_isGoldenSide)
-+        {
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                    INFO_MRK"Booting from normal side. use "
-+                    "MRW_NEST_CAPABLE_FREQUENCIES_SYS to calculate best freq "
-+                    "across  membufs");
-+            l_capableNestFreq = l_sys->getAttr
-+                                      <ATTR_MRW_NEST_CAPABLE_FREQUENCIES_SYS>();
-+        }
-+        else
-+        {
-+            // We booted using the Golden Side. Use NEST_FREQ_MHZ
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                   INFO_MRK"Booting from Golden Side. Use default NEST_FREQ"
-+                           "to calculate best freq across membufs");
-+            if(l_currentSysNestFreq == 2000)
-+            {
-+                l_capableNestFreq =
-+                      TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_2000_MHZ;
-+            }
-+            else if( l_currentSysNestFreq == 2400 )
-+            {
-+                l_capableNestFreq =
-+                      TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_2400_MHZ;
-+            }
-+            else
-+            {
-+                l_capableNestFreq =
-+                  TARGETING::MRW_NEST_CAPABLE_FREQUENCIES_SYS_UNSUPPORTED_FREQ;
-+            }
-+
-+        }
-+
-+        // convert the frequency to its corresponding dmi bus speed
-+        sysFreq_to_dmiSpeed( l_capableNestFreq, l_capableNestDmiBusSpeed );
-+
-+        if(!l_capableNestDmiBusSpeed)
-+        {
-+            // Unknown frequency was given to sysFreq_to_dmiSpeed
-+            // break out of function and proceed with value already in
-+            // ATTR_NEST_FREQ_MHZ
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,"Invalid dmi speed. Proceeding with default value in NEST_FREQ_MHZ.");
-+            break;
-+        }
-+
-+        // Get a list of all the membufs
-+        TargetHandleList l_membufs;
-+        TARGETING::getAllChips(l_membufs, TYPE_MEMBUF);
-+        TargetHandleList::iterator l_iter = l_membufs.begin();
-+
-+
-+        // If the nest capable dmi bus speed can only support one setting,
-+        // that speed is the speed we want to boot with.
-+        // Deconfigure all membufs with incompatible speeds
-+        if(Util::Algorithm::isPow2(l_capableNestDmiBusSpeed))
-+        {
-+            // We are forced to boot with the nest freq.
-+            // Save boot freq for later.
-+            l_selectedBootSpeed = l_capableNestDmiBusSpeed;
-+
-+
-+            ATTR_MSS_NEST_CAPABLE_FREQUENCIES_type l_membufDmiBusSpeed = 0;
-+            for(;l_iter != l_membufs.end(); ++l_iter )
-+            {
-+                l_membufDmiBusSpeed = (*l_iter)->getAttr
-+                               <TARGETING::ATTR_MSS_NEST_CAPABLE_FREQUENCIES>();
-+
-+                // if the intersection of the membuf's and nest's dmi speed
-+                // is zero, the membuf is incompatible with the nest and must be
-+                // deconfigured.
-+                l_compatibleSpeed = l_membufDmiBusSpeed &
-+                                   l_capableNestDmiBusSpeed;
-+
-+                if(l_compatibleSpeed ==
-+                        fapi::ENUM_ATTR_MSS_NEST_CAPABLE_FREQUENCIES_NONE )
-+                {
-+                    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                        "Deconfiguring Membuf Huid: %X, membuf speed: %d",
-+                        TARGETING::get_huid(*l_iter),
-+                        l_membufDmiBusSpeed);
-+                    // Membuf has incompatible frequency. Deconfigure it.
-+                    /*@
-+                     * @errortype
-+                     * @moduleid    MOD_SET_NEST_FREQ
-+                     * @reasoncode  RC_INVALID_FREQ
-+                     * @userdata1   HUID of membuf
-+                     * @userdata2   [0:7] membuf frequency enumeration value
-+                     * @userdata2   [8:15] dmi bus speed enumeration value
-+                     * @devdesc     Invalid nest found for given membuf
-+                     * @custdesc    Invalid memory configuration
-+                     */
-+                    l_err = new ERRORLOG::ErrlEntry(
-+                                             ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-+                                             fapi::MOD_SET_NEST_FREQ,
-+                                             fapi::RC_INVALID_FREQ,
-+                                             TARGETING::get_huid(*l_iter),
-+                                             TO_UINT64(TWO_UINT8_TO_UINT16
-+                                             (l_membufDmiBusSpeed,
-+                                              l_capableNestDmiBusSpeed)));
-+
-+                    l_err->addHwCallout(*l_iter, HWAS::SRCI_PRIORITY_HIGH,
-+                                                   HWAS::DELAYED_DECONFIG,
-+                                                   HWAS::GARD_NULL );
-+
-+
-+                    // add hw callouts for current membufs child DIMMs
-+                    calloutChildDimms( l_err, *l_iter);
-+
-+                    errlCommit( l_err, HWPF_COMP_ID );
-+                    l_err = NULL;
-+                    continue;
-+                }
-+
-+            } // end for-loop
-+
-+        }
-+        else
-+        {
-+            // The nest supports multiple frequencies. Find the max dmi bus
-+            // speed shared by the nest and at least 1 membuf and boot with that
-+            // speed.
-+            findMaxSpdAndDeconfigIncompatible(l_iter,
-+                                              &l_membufs,
-+                                              l_selectedBootSpeed,
-+                                              l_capableNestDmiBusSpeed);
-+
-+        }
-+
-+        //Convert the selected boot speed to frequency
-+        dmiSpeed_to_sysFreq(l_selectedBootSpeed, l_maxFreqMhz);
-+
-+        TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+            "The max supported frequency across the processor and all dimms "
-+            "is %d", l_maxFreqMhz );
-+
-+        if( l_maxFreqMhz == l_currentSysNestFreq)
-+        {
-+            //do nothing. go with current Nest freq, break.
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+            "Nest did not need to change. Proceeding with default NEST_FREQ");
-+            break;
-+        }
-+        else
-+        {
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+              "DIMM config determined NEST_FREQ needs to be changed to %d",
-+              l_maxFreqMhz );
-+            //set all the attributes and trigger an sbe update
-+            TARGETING::setFrequencyAttributes(l_sys, l_maxFreqMhz);
-+            //trigger sbe update so we can update all the frequency attributes
-+            l_err = SBE::updateProcessorSbeSeeproms(
-+                                    SBE::SBE_UPDATE_ONLY_CHECK_NEST_FREQ);
-+
-+            if( l_err )
-+            {
-+                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                            "Error triggering sbe update.");
-+            }
-+        }
-+    }while( 0 );
-+
-+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "setNestBasedOffDimms exit" );
-+    return l_err;
-+}
- //
- //  Wrapper function to call mss_freq
- //
-@@ -931,6 +1345,21 @@ void*    call_mss_freq( void *io_pArgs )
-         }
-     } // End memBuf loop
- 
-+    if(! INITSERVICE::spBaseServicesEnabled() )
-+    {
-+        //set nest frequency based off present membufs
-+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-+            INFO_MRK"Setting Nest Frequency based off Membuf capability.");
-+        l_err = setNestBasedOffDimms();
-+
-+        if( l_err )
-+        {
-+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-+                ERR_MRK"Error: call_mss_freq()::setNestBasedOffDimms()");
-+            l_StepError.addErrorDetails(l_err);
-+        }
-+    }
-+
-     TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_mss_freq exit" );
- 
-     return l_StepError.getErrorHandle();
-diff --git a/src/usr/hwpf/hwp/memory_attributes.xml b/src/usr/hwpf/hwp/memory_attributes.xml
-index b4059a2..df3a2ef 100644
---- a/src/usr/hwpf/hwp/memory_attributes.xml
-+++ b/src/usr/hwpf/hwp/memory_attributes.xml
-@@ -1,7 +1,7 @@
- <!-- IBM_PROLOG_BEGIN_TAG                                                   -->
- <!-- This is an automatically generated prolog.                             -->
- <!--                                                                        -->
--<!-- $Source: /afs/awd/projects/eclipz/KnowledgeBase/.cvsroot/eclipz/chips/centaur/working/procedures/xml/attribute_info/memory_attributes.xml,v $                      -->
-+<!-- $Source: src/usr/hwpf/hwp/memory_attributes.xml $                      -->
- <!--                                                                        -->
- <!-- OpenPOWER HostBoot Project                                             -->
- <!--                                                                        -->
-@@ -23,7 +23,7 @@
- <!--                                                                        -->
- <!-- IBM_PROLOG_END_TAG                                                     -->
- <attributes>
--<!-- $Id: memory_attributes.xml,v 1.159 2015/09/09 18:10:53 thi Exp $ -->
-+<!-- $Id: memory_attributes.xml,v 1.159AL_custom 2014/11/18 17:35:29 aalugore Exp $ -->
- <!-- DO NOT EDIT THIS FILE DIRECTLY PLEASE UPDATE THE ODS FILE AND FOLLOW THE INSTRUCTION TAB -->
- <!-- PLEASE SEE MARK BELLOWS (BELLOWS.IBM.COM) OR OTHERS ON MEMORY TEAM FOR HELP -->
- <!-- *********************************************************************** -->
-@@ -108,7 +108,7 @@ Set by: PLL settings written by Dave Cadigan</description>
-     <odmChangeable/>
-     <persistRuntime/>
- </attribute>
--        
-+
- <attribute>
-     <id>ATTR_MSS_DIMM_MFG_ID_CODE</id>
-     <targetType>TARGET_TYPE_MBA_CHIPLET</targetType>
-@@ -3051,8 +3051,8 @@ Will be set at an MBA level with one policy to be used</description>
-     <writeable/>
-     <odmVisable/>
-     <odmChangeable/>
--    <enum>8_0G = 1, 9_6G = 2</enum>
--</attribute> 
-+    <enum>NONE = 0, 8_0G = 1, 9_6G = 2, 8_0G_OR_9_6G = 3</enum>
-+</attribute>
- 
- <attribute>
-     <id>ATTR_MRW_STRICT_MBA_PLUG_RULE_CHECKING</id>
-@@ -3425,7 +3425,7 @@ Will be set at an MBA level with one policy to be used</description>
-     <valueType>uint32</valueType>
-     <platInit/>
-     <odmVisable/>
--</attribute>  
-+</attribute>
- 
- <attribute>
-     <id>ATTR_MRW_MEM_SENSOR_CACHE_ADDR_MAP</id>
-diff --git a/src/usr/hwpf/plat/fapiPlatUtil.C b/src/usr/hwpf/plat/fapiPlatUtil.C
-index d03b670..269c36f 100644
---- a/src/usr/hwpf/plat/fapiPlatUtil.C
-+++ b/src/usr/hwpf/plat/fapiPlatUtil.C
-@@ -334,7 +334,7 @@ void* fapiPlatMalloc(size_t s)
- {
-     if (s > PAGE_SIZE)
-     {
--        s = ALIGN_TO_NEXT_POWER_OF_TWO_PAGES(s);
-+        s = PAGE_SIZE * ALIGN_POW2(ALIGN_PAGE(s) / PAGE_SIZE);
-     }
-     return malloc(s);
- }
-diff --git a/src/usr/sbe/sbe_update.C b/src/usr/sbe/sbe_update.C
-index 1faad63..237838f 100644
---- a/src/usr/sbe/sbe_update.C
-+++ b/src/usr/sbe/sbe_update.C
-@@ -3976,6 +3976,68 @@ namespace SBE
- 
-     }
- 
-+/////////////////////////////////////////////////////////////////////
-+    errlHndl_t isGoldenSide( bool & o_isGolden )
-+    {
-+        errlHndl_t l_errl = NULL;
-+        o_isGolden = false;
-+
-+#ifndef CONFIG_SBE_UPDATE_SEQUENTIAL
-+        do
-+        {
-+            // Get the master processor
-+            TARGETING::Target * l_masterProc = NULL;
-+            TARGETING::targetService().masterProcChipTargetHandle(l_masterProc);
-+            assert( l_masterProc != NULL );
-+
-+            sbeSeepromSide_t l_currentSide = SBE_SEEPROM_INVALID;
-+
-+            // Get Seeprom side
-+            l_errl = getSbeBootSeeprom(l_masterProc, l_currentSide);
-+
-+            if( l_errl )
-+            {
-+                TRACFCOMP( g_trac_sbe, ERR_MRK
-+                           "isGoldenSide() - Error returned "
-+                           "from getSbeBootSeeprom() "
-+                           "rc=0x%.4X, Target UID=0x%X",
-+                           l_errl->reasonCode(),
-+                           TARGETING::get_huid(l_masterProc));
-+                break;
-+            }
-+
-+            //Get PNOR Side
-+            PNOR::SideId l_pnorSide = PNOR::WORKING;
-+            PNOR::SideInfo_t l_sideInfo;
-+
-+            l_errl = PNOR::getSideInfo( l_pnorSide, l_sideInfo );
-+
-+            if( l_errl )
-+            {
-+                TRACFCOMP(g_trac_sbe, ERR_MRK
-+                          "isGoldenSide() - Error returned "
-+                          "from PNOR::getSideInfo() "
-+                          "rc=0x%.4X, Target UID=0x%X",
-+                          l_errl->reasonCode(),
-+                          TARGETING::get_huid( l_masterProc ));
-+                break;
-+            }
-+
-+            // SBE_SEEPROM1 by itself does not imply golden side.
-+            // cross reference sbe side with pnor side to make sure.
-+            if(( l_currentSide == SBE_SEEPROM1 ) &&
-+               (( l_sideInfo.isGolden ) || (l_sideInfo.hasOtherSide == false )))
-+            {
-+                TRACUCOMP(g_trac_sbe, INFO_MRK
-+                          "sbe_update.C::isGoldenSide() - "
-+                          "Booted from Golden side!");
-+                o_isGolden = true;
-+            }
-+
-+        }while( 0 );
-+#endif
-+        return l_errl;
-+    }
- 
- 
- /////////////////////////////////////////////////////////////////////
-diff --git a/src/usr/targeting/common/target.C b/src/usr/targeting/common/target.C
-index 2248283..559fd4e 100644
---- a/src/usr/targeting/common/target.C
-+++ b/src/usr/targeting/common/target.C
-@@ -645,6 +645,53 @@ bool Target::uninstallWriteAttributeCallback()
-     #undef TARG_FN
- }
- 
-+
-+//******************************************************************************
-+// setFrequencyAttributes
-+//******************************************************************************
-+void setFrequencyAttributes(Target * i_sys, uint32_t i_newNestFreq)
-+{
-+
-+    // Calculate the new value for PIB_I2C_NEST_PLL using old freq attributes.
-+    uint32_t l_oldPll = i_sys->getAttr<TARGETING::ATTR_PIB_I2C_NEST_PLL>();
-+    uint32_t l_oldNestFreq = i_sys->getAttr<TARGETING::ATTR_NEST_FREQ_MHZ>();
-+    uint32_t l_newPll = (i_newNestFreq * l_oldPll)/l_oldNestFreq;
-+
-+    //NEST_FREQ
-+    i_sys->setAttr<TARGETING::ATTR_NEST_FREQ_MHZ>(i_newNestFreq);
-+    TRACFCOMP(g_trac_targeting,
-+            "ATTR_NEST_FREQ_MHZ getting set from %d to %d",
-+            l_oldNestFreq,
-+            i_newNestFreq );
-+
-+    //FREQ_X
-+    uint32_t l_freqX = i_newNestFreq * 2;
-+    i_sys->setAttr<TARGETING::ATTR_FREQ_X>(l_freqX);
-+    TRACFCOMP(g_trac_targeting,
-+            "ATTR_FREQ_X getting set to from %d to %d",
-+            l_oldNestFreq*2,
-+            l_freqX );
-+
-+    //FREQ_PB
-+    uint32_t l_freqPb = i_newNestFreq;
-+    i_sys->setAttr<TARGETING::ATTR_FREQ_PB>(l_freqPb);
-+    TRACFCOMP(g_trac_targeting,
-+            "ATTR_FREQ_PB getting set from %d to %d",
-+            l_oldNestFreq,
-+            l_freqPb );
-+
-+    //PIB_I2C_NEST_PLL
-+    i_sys->setAttr<TARGETING::ATTR_PIB_I2C_NEST_PLL>(l_newPll);
-+    TRACFCOMP(g_trac_targeting,
-+            "ATTR_PIB_I2C_NEST_PLL getting set from %x to %x",
-+            l_oldPll,
-+            l_newPll);
-+
-+    return;
-+}
-+
-+
-+
- //******************************************************************************
- // Attribute Tanks
- //******************************************************************************
-diff --git a/src/usr/targeting/common/xmltohb/attribute_types.xml b/src/usr/targeting/common/xmltohb/attribute_types.xml
-index 05497fd..88041b4 100644
---- a/src/usr/targeting/common/xmltohb/attribute_types.xml
-+++ b/src/usr/targeting/common/xmltohb/attribute_types.xml
-@@ -2049,6 +2049,7 @@
-     <simpleType><uint32_t></uint32_t></simpleType>
-     <persistency>non-volatile</persistency>
-     <readable/>
-+    <writeable/>
-     <hwpfToHbAttrMap>
-         <id>ATTR_FREQ_PB</id>
-         <macro>DIRECT</macro>
-@@ -2083,6 +2084,7 @@
-     <simpleType><uint32_t></uint32_t></simpleType>
-     <persistency>non-volatile</persistency>
-     <readable/>
-+    <writeable/>
-     <hwpfToHbAttrMap>
-         <id>ATTR_FREQ_X</id>
-         <macro>DIRECT</macro>
-@@ -6103,7 +6105,7 @@ firmware notes: Used as override attribute for pstate procedure
-             <default>2000</default>
-         </uint32_t>
-     </simpleType>
--    <persistency>volatile</persistency>
-+    <persistency>non-volatile</persistency>
-     <readable/>
-     <writeable/>
-     <hwpfToHbAttrMap>
-@@ -15666,7 +15668,7 @@ firmware notes: Platforms should initialize this attribute to AUTO (0)</descript
- 
- <attribute>
-     <id>MRW_VMEM_REGULATOR_POWER_LIMIT_PER_DIMM_ADJ_ENABLE</id>
--    <description>Machine Readable Workbook enablement of the HWP code to adjust 
-+    <description>Machine Readable Workbook enablement of the HWP code to adjust
-     the VMEM regulator power limit based on number of installed DIMMs.
-     </description>
-     <simpleType>
-@@ -15702,7 +15704,7 @@ firmware notes: Platforms should initialize this attribute to AUTO (0)</descript
- 
- <attribute>
-     <id>MRW_VMEM_REGULATOR_MEMORY_POWER_LIMIT_PER_DIMM</id>
--    <description>Machine Readable Workbook VMEM regulator power limit per CDIMM 
-+    <description>Machine Readable Workbook VMEM regulator power limit per CDIMM
-     assuming a full configuration. Units in cW.
-     </description>
-     <simpleType>
-@@ -15741,7 +15743,7 @@ firmware notes: Platforms should initialize this attribute to AUTO (0)</descript
- 
- <attribute>
-     <id>MRW_NEST_CAPABLE_FREQUENCIES_SYS</id>
--    <description>The NEST frequencies that the system can support.  This is a bit-wise value that represents which of the possible nest frequencies are supported : 2.0GHz, 2.4GHz, or both.
-+    <description>The NEST frequencies that the system can support.  This is a bit-wise value that represents which of the possible nest frequencies are supported. : 2.0GHz, 2.4GHz, or both. New frequencies should be added in ascending order.
-     </description>
-     <simpleType>
-         <enumeration>
--- 
-1.8.2.2
-
diff --git a/openpower/package/hostboot/hostboot.mk b/openpower/package/hostboot/hostboot.mk
index a934119..8c0a35b 100644
--- a/openpower/package/hostboot/hostboot.mk
+++ b/openpower/package/hostboot/hostboot.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-HOSTBOOT_VERSION ?= 6ff3e00062b894a880937ce41f748e26105b579a
+HOSTBOOT_VERSION ?= a811529cb668e42f50017d2cfd5aa98ab92ce2e8
 HOSTBOOT_SITE ?= $(call github,open-power,hostboot,$(HOSTBOOT_VERSION))
 
 HOSTBOOT_LICENSE = Apache-2.0
diff --git a/openpower/package/openpower-pnor/openpower-pnor.mk b/openpower/package/openpower-pnor/openpower-pnor.mk
index 658a949..1d11f14 100644
--- a/openpower/package/openpower-pnor/openpower-pnor.mk
+++ b/openpower/package/openpower-pnor/openpower-pnor.mk
@@ -8,7 +8,7 @@
 # make doesn't care for quotes in the dependencies.
 XML_PACKAGE=$(subst $\",,$(BR2_OPENPOWER_XML_PACKAGE))
 
-OPENPOWER_PNOR_VERSION ?= ed1682e10526ebd85825427fbf397361bb0e34aa
+OPENPOWER_PNOR_VERSION ?= 40e407735b317d0174645b7543e0a72019709ce2
 OPENPOWER_PNOR_SITE ?= $(call github,open-power,pnor,$(OPENPOWER_PNOR_VERSION))
 
 OPENPOWER_PNOR_LICENSE = Apache-2.0
@@ -17,7 +17,7 @@
 ifeq ($(BR2_TARGET_SKIBOOT_EMBED_PAYLOAD),n)
 
 ifeq ($(BR2_TARGET_ROOTFS_INITRAMFS),y)
-OPENPOWER_PNOR_DEPENDENCIES += linux26-rebuild-with-initramfs
+OPENPOWER_PNOR_DEPENDENCIES += linux-rebuild-with-initramfs
 else
 OPENPOWER_PNOR_DEPENDENCIES += linux
 endif
diff --git a/openpower/package/palmetto-xml/palmetto-xml.mk b/openpower/package/palmetto-xml/palmetto-xml.mk
index 771574b..bcdee08 100644
--- a/openpower/package/palmetto-xml/palmetto-xml.mk
+++ b/openpower/package/palmetto-xml/palmetto-xml.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-PALMETTO_XML_VERSION = 92fe7abe1ab5cb328390762e3437e39f3a812839
+PALMETTO_XML_VERSION = 8ce36f33a1b4f3467488a57bba733c16bfc161f8
 PALMETTO_XML_SITE = $(call github,open-power,palmetto-xml,$(PALMETTO_XML_VERSION))
 
 PALMETTO_XML_LICENSE = Apache-2.0
diff --git a/openpower/package/petitboot/63-md-raid-arrays.rules b/openpower/package/petitboot/63-md-raid-arrays.rules
new file mode 100644
index 0000000..385a8da
--- /dev/null
+++ b/openpower/package/petitboot/63-md-raid-arrays.rules
@@ -0,0 +1,41 @@
+# do not edit this file, it will be overwritten on update
+
+SUBSYSTEM!="block", GOTO="md_end"
+
+# handle md arrays
+ACTION!="add|change", GOTO="md_end"
+KERNEL!="md*", GOTO="md_end"
+
+# partitions have no md/{array_state,metadata_version}, but should not
+# for that reason be ignored.
+ENV{DEVTYPE}=="partition", GOTO="md_ignore_state"
+
+# container devices have a metadata version of e.g. 'external:ddf' and
+# never leave state 'inactive'
+ATTR{md/metadata_version}=="external:[A-Za-z]*", ATTR{md/array_state}=="inactive", GOTO="md_ignore_state"
+TEST!="md/array_state", ENV{SYSTEMD_READY}="0", GOTO="md_end"
+ATTR{md/array_state}=="|clear|inactive", ENV{SYSTEMD_READY}="0", GOTO="md_end"
+LABEL="md_ignore_state"
+
+IMPORT{program}="/usr/sbin/mdadm --detail --export $devnode"
+ENV{DEVTYPE}=="disk", ENV{MD_NAME}=="?*", SYMLINK+="disk/by-id/md-name-$env{MD_NAME}", OPTIONS+="string_escape=replace"
+ENV{DEVTYPE}=="disk", ENV{MD_UUID}=="?*", SYMLINK+="disk/by-id/md-uuid-$env{MD_UUID}"
+ENV{DEVTYPE}=="disk", ENV{MD_DEVNAME}=="?*", SYMLINK+="md/$env{MD_DEVNAME}"
+ENV{DEVTYPE}=="partition", ENV{MD_NAME}=="?*", SYMLINK+="disk/by-id/md-name-$env{MD_NAME}-part%n", OPTIONS+="string_escape=replace"
+ENV{DEVTYPE}=="partition", ENV{MD_UUID}=="?*", SYMLINK+="disk/by-id/md-uuid-$env{MD_UUID}-part%n"
+ENV{DEVTYPE}=="partition", ENV{MD_DEVNAME}=="*[^0-9]", SYMLINK+="md/$env{MD_DEVNAME}%n"
+ENV{DEVTYPE}=="partition", ENV{MD_DEVNAME}=="*[0-9]", SYMLINK+="md/$env{MD_DEVNAME}p%n"
+
+IMPORT{builtin}="blkid"
+OPTIONS+="link_priority=100"
+OPTIONS+="watch"
+ENV{ID_FS_USAGE}=="filesystem|other|crypto", ENV{ID_FS_UUID_ENC}=="?*", SYMLINK+="disk/by-uuid/$env{ID_FS_UUID_ENC}"
+ENV{ID_FS_USAGE}=="filesystem|other", ENV{ID_FS_LABEL_ENC}=="?*", SYMLINK+="disk/by-label/$env{ID_FS_LABEL_ENC}"
+
+ENV{MD_LEVEL}=="raid[1-9]*", ENV{SYSTEMD_WANTS}+="mdmonitor.service"
+
+# Tell systemd to run mdmon for our container, if we need it.
+ENV{MD_LEVEL}=="raid[1-9]*", ENV{MD_CONTAINER}=="?*", PROGRAM="/usr/bin/readlink $env{MD_CONTAINER}", ENV{MD_MON_THIS}="%c"
+ENV{MD_MON_THIS}=="?*", PROGRAM="/usr/bin/basename $env{MD_MON_THIS}", ENV{SYSTEMD_WANTS}+="mdmon@%c.service"
+
+LABEL="md_end"
diff --git a/openpower/package/petitboot/65-md-incremental.rules b/openpower/package/petitboot/65-md-incremental.rules
new file mode 100644
index 0000000..a8ad636
--- /dev/null
+++ b/openpower/package/petitboot/65-md-incremental.rules
@@ -0,0 +1,69 @@
+# This file causes block devices with Linux RAID (mdadm) signatures to
+# automatically cause mdadm to be run.
+# See udev(8) for syntax
+
+# Don't process any events if anaconda is running as anaconda brings up
+# raid devices manually
+ENV{ANACONDA}=="?*", GOTO="md_end"
+
+# Also don't process disks that are slated to be a multipath device
+ENV{DM_MULTIPATH_DEVICE_PATH}=="?*", GOTO="md_end"
+
+# We process add events on block devices (since they are ready as soon as
+# they are added to the system), but we must process change events as well
+# on any dm devices (like LUKS partitions or LVM logical volumes) and on
+# md devices because both of these first get added, then get brought live
+# and trigger a change event.  The reason we don't process change events
+# on bare hard disks is because if you stop all arrays on a disk, then
+# run fdisk on the disk to change the partitions, when fdisk exits it
+# triggers a change event, and we want to wait until all the fdisks on
+# all member disks are done before we do anything.  Unfortunately, we have
+# no way of knowing that, so we just have to let those arrays be brought
+# up manually after fdisk has been run on all of the disks.
+
+# First, process all add events (md and dm devices will not really do
+# anything here, just regular disks, and this also won't get any imsm
+# array members either)
+SUBSYSTEM=="block", ACTION=="add|change", ENV{ID_FS_TYPE}=="linux_raid_member", \
+	RUN+="/usr/sbin/mdadm -I --export $env{DEVNAME}"
+
+# Next, check to make sure the BIOS raid stuff wasn't turned off via cmdline
+IMPORT{cmdline}="noiswmd"
+IMPORT{cmdline}="nodmraid"
+ENV{noiswmd}=="?*", GOTO="md_imsm_inc_end"
+ENV{nodmraid}=="?*", GOTO="md_imsm_inc_end"
+SUBSYSTEM=="block", ACTION=="add", ENV{ID_FS_TYPE}=="isw_raid_member", \
+	RUN+="/usr/sbin/mdadm -I $env{DEVNAME}"
+LABEL="md_imsm_inc_end"
+
+SUBSYSTEM=="block", ACTION=="remove", ENV{ID_PATH}=="?*", \
+	RUN+="/usr/sbin/mdadm -If $name --path $env{ID_PATH}"
+SUBSYSTEM=="block", ACTION=="remove", ENV{ID_PATH}!="?*", \
+	RUN+="/usr/sbin/mdadm -If $name"
+
+# Next make sure that this isn't a dm device we should skip for some reason
+ENV{DM_UDEV_RULES_VSN}!="?*", GOTO="dm_change_end"
+ENV{DM_UDEV_DISABLE_OTHER_RULES_FLAG}=="1", GOTO="dm_change_end"
+ENV{DM_SUSPENDED}=="1", GOTO="dm_change_end"
+KERNEL=="dm-*", SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="linux_raid_member", \
+	ACTION=="change", RUN+="/usr/sbin/mdadm -I $env{DEVNAME}"
+LABEL="dm_change_end"
+
+# Finally catch any nested md raid arrays.  If we brought up an md raid
+# array that's part of another md raid array, it won't be ready to be used
+# until the change event that occurs when it becomes live
+KERNEL=="md*", SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="linux_raid_member", \
+	ACTION=="change", RUN+="/usr/sbin/mdadm -I $env{DEVNAME}"
+
+# In case the initramfs only started some of the arrays in our container,
+# run incremental assembly on the container itself.  Note: we ran mdadm
+# on the container in 64-md-raid.rules, and that's how the MD_LEVEL
+# environment variable is already set.  If that disappears from the other
+# file, we will need to add this line into the middle of the next rule:
+#	IMPORT{program}="/usr/sbin/mdadm -D --export $tempnode", \
+
+SUBSYSTEM=="block", ACTION=="add|change", KERNEL=="md*", \
+	ENV{MD_LEVEL}=="container", RUN+="/usr/sbin/mdadm -I $env{DEVNAME}"
+
+
+LABEL="md_end"
diff --git a/openpower/package/petitboot/Config.in b/openpower/package/petitboot/Config.in
new file mode 100644
index 0000000..a6021dd
--- /dev/null
+++ b/openpower/package/petitboot/Config.in
@@ -0,0 +1,21 @@
+config BR2_PACKAGE_PETITBOOT
+	bool "petitboot"
+	# petitboot needs udev /dev management
+	depends on BR2_PACKAGE_HAS_UDEV
+	select BR2_PACKAGE_NCURSES
+	select BR2_PACKAGE_NCURSES_TARGET_PANEL
+	select BR2_PACKAGE_NCURSES_TARGET_FORM
+	select BR2_PACKAGE_NCURSES_TARGET_MENU
+	# run-time dependency only
+	select BR2_PACKAGE_KEXEC_LITE if !BR2_PACKAGE_KEXEC
+	# run-time dependency only
+	select BR2_PACKAGE_POWERPC_UTILS if BR2_powerpc || BR2_powerpc64 || BR2_powerpc64le
+	# run-time dependency only
+	select BR2_PACKAGE_IPRUTILS if BR2_powerpc || BR2_powerpc64 || BR2_powerpc64le
+	help
+	  Petitboot is a small kexec-based bootloader
+
+	  http://www.kernel.org/pub/linux/kernel/people/geoff/petitboot/petitboot.html
+
+comment "petitboot requires udev to be enabled"
+	depends on !BR2_PACKAGE_HAS_UDEV
diff --git a/openpower/package/petitboot/S14silence-console b/openpower/package/petitboot/S14silence-console
new file mode 100755
index 0000000..6570200
--- /dev/null
+++ b/openpower/package/petitboot/S14silence-console
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+case "$1" in
+    start)
+        echo 0 0 7 0 > /proc/sys/kernel/printk
+        ;;
+esac
+
+exit 0
diff --git a/openpower/package/petitboot/S15pb-discover b/openpower/package/petitboot/S15pb-discover
new file mode 100755
index 0000000..8f9638c
--- /dev/null
+++ b/openpower/package/petitboot/S15pb-discover
@@ -0,0 +1,33 @@
+#!/bin/sh
+
+LOGFILE=/var/log/petitboot/pb-discover.log
+PIDFILE=/var/run/petitboot.pid
+
+PATH=/usr/bin:/usr/sbin:/bin:/sbin
+export PATH
+
+verbose=
+if pb-config debug | grep -q enabled
+then
+	verbose=-v
+fi
+
+case "$1" in
+    start)
+        ulimit -c unlimited
+        mkdir -p $(dirname $LOGFILE)
+        export $(cat /etc/locale)
+        pb-discover -l $LOGFILE $verbose &
+        echo $! > $PIDFILE
+        ;;
+    stop)
+        pid=$(cat $PIDFILE)
+        [ -n "$pid" ] && kill -TERM $pid
+        ;;
+    *)
+        echo "Usage: $0 {start|stop}"
+        exit 1
+        ;;
+esac
+
+exit 0
diff --git a/openpower/package/petitboot/kexec-restart b/openpower/package/petitboot/kexec-restart
new file mode 100755
index 0000000..0175e76
--- /dev/null
+++ b/openpower/package/petitboot/kexec-restart
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+/usr/sbin/kexec -f -e
+
+while :
+do
+    sleep 1
+done
diff --git a/openpower/package/petitboot/petitboot-01-autotools-Add-autopoint-generated-files.patch b/openpower/package/petitboot/petitboot-01-autotools-Add-autopoint-generated-files.patch
new file mode 100644
index 0000000..5c2c0c0
--- /dev/null
+++ b/openpower/package/petitboot/petitboot-01-autotools-Add-autopoint-generated-files.patch
@@ -0,0 +1,6764 @@
+From c99b7d366a5e11414befbe653af3bc4b642aede8 Mon Sep 17 00:00:00 2001
+From: Jeremy Kerr <jk@ozlabs.org>
+Date: Fri, 12 Dec 2014 09:35:40 +0800
+Subject: [PATCH] autotools: Add autopoint-generated files
+
+Since buildroot doesn't give us an autopoint, we're unable to regenerate
+these files. Add the autopoint artefacts required to do an autoreconf
+without autopoint.
+
+Generated with:
+
+  touch .stamp
+  autopoint
+  find . -type f -newer stamp | xargs git add
+
+Signed-off-by: Jeremy Kerr <jk@ozlabs.org>
+---
+ ABOUT-NLS              | 1282 ++++++++++++++++++++++++++++++++++++++++++++++++
+ config.rpath           |  672 +++++++++++++++++++++++++
+ m4/codeset.m4          |   21 +
+ m4/fcntl-o.m4          |   81 +++
+ m4/gettext.m4          |  383 +++++++++++++++
+ m4/glibc2.m4           |   30 ++
+ m4/glibc21.m4          |   30 ++
+ m4/iconv.m4            |  214 ++++++++
+ m4/intdiv0.m4          |   84 ++++
+ m4/intl.m4             |  294 +++++++++++
+ m4/intldir.m4          |   19 +
+ m4/intlmacosx.m4       |   51 ++
+ m4/intmax.m4           |   33 ++
+ m4/inttypes-pri.m4     |   36 ++
+ m4/inttypes_h.m4       |   26 +
+ m4/lcmessage.m4        |   31 ++
+ m4/lib-ld.m4           |  110 +++++
+ m4/lib-link.m4         |  774 +++++++++++++++++++++++++++++
+ m4/lib-prefix.m4       |  224 +++++++++
+ m4/lock.m4             |   37 ++
+ m4/longlong.m4         |  106 ++++
+ m4/nls.m4              |   32 ++
+ m4/po.m4               |  449 +++++++++++++++++
+ m4/printf-posix.m4     |   45 ++
+ m4/progtest.m4         |   92 ++++
+ m4/size_max.m4         |   75 +++
+ m4/stdint_h.m4         |   26 +
+ m4/threadlib.m4        |  347 +++++++++++++
+ m4/uintmax_t.m4        |   30 ++
+ m4/visibility.m4       |   74 +++
+ m4/wchar_t.m4          |   20 +
+ m4/wint_t.m4           |   28 ++
+ m4/xsize.m4            |   13 +
+ po/Makefile.in.in      |  444 +++++++++++++++++
+ po/Makevars.template   |   41 ++
+ po/Rules-quot          |   47 ++
+ po/boldquot.sed        |   10 +
+ po/en@boldquot.header  |   25 +
+ po/en@quot.header      |   22 +
+ po/insert-header.sin   |   23 +
+ po/quot.sed            |    6 +
+ po/remove-potcdate.sin |   19 +
+ 42 files changed, 6406 insertions(+)
+ create mode 100644 ABOUT-NLS
+ create mode 100755 config.rpath
+ create mode 100644 m4/codeset.m4
+ create mode 100644 m4/fcntl-o.m4
+ create mode 100644 m4/gettext.m4
+ create mode 100644 m4/glibc2.m4
+ create mode 100644 m4/glibc21.m4
+ create mode 100644 m4/iconv.m4
+ create mode 100644 m4/intdiv0.m4
+ create mode 100644 m4/intl.m4
+ create mode 100644 m4/intldir.m4
+ create mode 100644 m4/intlmacosx.m4
+ create mode 100644 m4/intmax.m4
+ create mode 100644 m4/inttypes-pri.m4
+ create mode 100644 m4/inttypes_h.m4
+ create mode 100644 m4/lcmessage.m4
+ create mode 100644 m4/lib-ld.m4
+ create mode 100644 m4/lib-link.m4
+ create mode 100644 m4/lib-prefix.m4
+ create mode 100644 m4/lock.m4
+ create mode 100644 m4/longlong.m4
+ create mode 100644 m4/nls.m4
+ create mode 100644 m4/po.m4
+ create mode 100644 m4/printf-posix.m4
+ create mode 100644 m4/progtest.m4
+ create mode 100644 m4/size_max.m4
+ create mode 100644 m4/stdint_h.m4
+ create mode 100644 m4/threadlib.m4
+ create mode 100644 m4/uintmax_t.m4
+ create mode 100644 m4/visibility.m4
+ create mode 100644 m4/wchar_t.m4
+ create mode 100644 m4/wint_t.m4
+ create mode 100644 m4/xsize.m4
+ create mode 100644 po/Makefile.in.in
+ create mode 100644 po/Makevars.template
+ create mode 100644 po/Rules-quot
+ create mode 100644 po/boldquot.sed
+ create mode 100644 po/en@boldquot.header
+ create mode 100644 po/en@quot.header
+ create mode 100644 po/insert-header.sin
+ create mode 100644 po/quot.sed
+ create mode 100644 po/remove-potcdate.sin
+
+diff --git a/ABOUT-NLS b/ABOUT-NLS
+new file mode 100644
+index 0000000..b1de1b6
+--- /dev/null
++++ b/ABOUT-NLS
+@@ -0,0 +1,1282 @@
++1 Notes on the Free Translation Project
++***************************************
++
++Free software is going international!  The Free Translation Project is
++a way to get maintainers of free software, translators, and users all
++together, so that free software will gradually become able to speak many
++languages.  A few packages already provide translations for their
++messages.
++
++   If you found this `ABOUT-NLS' file inside a distribution, you may
++assume that the distributed package does use GNU `gettext' internally,
++itself available at your nearest GNU archive site.  But you do _not_
++need to install GNU `gettext' prior to configuring, installing or using
++this package with messages translated.
++
++   Installers will find here some useful hints.  These notes also
++explain how users should proceed for getting the programs to use the
++available translations.  They tell how people wanting to contribute and
++work on translations can contact the appropriate team.
++
++1.1 INSTALL Matters
++===================
++
++Some packages are "localizable" when properly installed; the programs
++they contain can be made to speak your own native language.  Most such
++packages use GNU `gettext'.  Other packages have their own ways to
++internationalization, predating GNU `gettext'.
++
++   By default, this package will be installed to allow translation of
++messages.  It will automatically detect whether the system already
++provides the GNU `gettext' functions.  Installers may use special
++options at configuration time for changing the default behaviour.  The
++command:
++
++     ./configure --disable-nls
++
++will _totally_ disable translation of messages.
++
++   When you already have GNU `gettext' installed on your system and run
++configure without an option for your new package, `configure' will
++probably detect the previously built and installed `libintl' library
++and will decide to use it.  If not, you may have to to use the
++`--with-libintl-prefix' option to tell `configure' where to look for it.
++
++   Internationalized packages usually have many `po/LL.po' files, where
++LL gives an ISO 639 two-letter code identifying the language.  Unless
++translations have been forbidden at `configure' time by using the
++`--disable-nls' switch, all available translations are installed
++together with the package.  However, the environment variable `LINGUAS'
++may be set, prior to configuration, to limit the installed set.
++`LINGUAS' should then contain a space separated list of two-letter
++codes, stating which languages are allowed.
++
++1.2 Using This Package
++======================
++
++As a user, if your language has been installed for this package, you
++only have to set the `LANG' environment variable to the appropriate
++`LL_CC' combination.  If you happen to have the `LC_ALL' or some other
++`LC_xxx' environment variables set, you should unset them before
++setting `LANG', otherwise the setting of `LANG' will not have the
++desired effect.  Here `LL' is an ISO 639 two-letter language code, and
++`CC' is an ISO 3166 two-letter country code.  For example, let's
++suppose that you speak German and live in Germany.  At the shell
++prompt, merely execute `setenv LANG de_DE' (in `csh'),
++`export LANG; LANG=de_DE' (in `sh') or `export LANG=de_DE' (in `bash').
++This can be done from your `.login' or `.profile' file, once and for
++all.
++
++   You might think that the country code specification is redundant.
++But in fact, some languages have dialects in different countries.  For
++example, `de_AT' is used for Austria, and `pt_BR' for Brazil.  The
++country code serves to distinguish the dialects.
++
++   The locale naming convention of `LL_CC', with `LL' denoting the
++language and `CC' denoting the country, is the one use on systems based
++on GNU libc.  On other systems, some variations of this scheme are
++used, such as `LL' or `LL_CC.ENCODING'.  You can get the list of
++locales supported by your system for your language by running the
++command `locale -a | grep '^LL''.
++
++   Not all programs have translations for all languages.  By default, an
++English message is shown in place of a nonexistent translation.  If you
++understand other languages, you can set up a priority list of languages.
++This is done through a different environment variable, called
++`LANGUAGE'.  GNU `gettext' gives preference to `LANGUAGE' over `LANG'
++for the purpose of message handling, but you still need to have `LANG'
++set to the primary language; this is required by other parts of the
++system libraries.  For example, some Swedish users who would rather
++read translations in German than English for when Swedish is not
++available, set `LANGUAGE' to `sv:de' while leaving `LANG' to `sv_SE'.
++
++   Special advice for Norwegian users: The language code for Norwegian
++bokma*l changed from `no' to `nb' recently (in 2003).  During the
++transition period, while some message catalogs for this language are
++installed under `nb' and some older ones under `no', it's recommended
++for Norwegian users to set `LANGUAGE' to `nb:no' so that both newer and
++older translations are used.
++
++   In the `LANGUAGE' environment variable, but not in the `LANG'
++environment variable, `LL_CC' combinations can be abbreviated as `LL'
++to denote the language's main dialect.  For example, `de' is equivalent
++to `de_DE' (German as spoken in Germany), and `pt' to `pt_PT'
++(Portuguese as spoken in Portugal) in this context.
++
++1.3 Translating Teams
++=====================
++
++For the Free Translation Project to be a success, we need interested
++people who like their own language and write it well, and who are also
++able to synergize with other translators speaking the same language.
++Each translation team has its own mailing list.  The up-to-date list of
++teams can be found at the Free Translation Project's homepage,
++`http://translationproject.org/', in the "Teams" area.
++
++   If you'd like to volunteer to _work_ at translating messages, you
++should become a member of the translating team for your own language.
++The subscribing address is _not_ the same as the list itself, it has
++`-request' appended.  For example, speakers of Swedish can send a
++message to `sv-request@li.org', having this message body:
++
++     subscribe
++
++   Keep in mind that team members are expected to participate
++_actively_ in translations, or at solving translational difficulties,
++rather than merely lurking around.  If your team does not exist yet and
++you want to start one, or if you are unsure about what to do or how to
++get started, please write to `coordinator@translationproject.org' to
++reach the coordinator for all translator teams.
++
++   The English team is special.  It works at improving and uniformizing
++the terminology in use.  Proven linguistic skills are praised more than
++programming skills, here.
++
++1.4 Available Packages
++======================
++
++Languages are not equally supported in all packages.  The following
++matrix shows the current state of internationalization, as of June
++2010.  The matrix shows, in regard of each package, for which languages
++PO files have been submitted to translation coordination, with a
++translation percentage of at least 50%.
++
++     Ready PO files       af am an ar as ast az be be@latin bg bn_IN bs ca
++                        +--------------------------------------------------+
++     a2ps               |                       []                      [] |
++     aegis              |                                                  |
++     ant-phone          |                                                  |
++     anubis             |                                                  |
++     aspell             |                []                             [] |
++     bash               |                                                  |
++     bfd                |                                                  |
++     bibshelf           |                []                                |
++     binutils           |                                                  |
++     bison              |                                                  |
++     bison-runtime      |                []                                |
++     bluez-pin          | []             []                                |
++     bombono-dvd        |                                                  |
++     buzztard           |                                                  |
++     cflow              |                                                  |
++     clisp              |                                                  |
++     coreutils          |                                   []          [] |
++     cpio               |                                                  |
++     cppi               |                                                  |
++     cpplib             |                                               [] |
++     cryptsetup         |                                                  |
++     dfarc              |                                                  |
++     dialog             |                             []                [] |
++     dico               |                                                  |
++     diffutils          |                                               [] |
++     dink               |                                                  |
++     doodle             |                                                  |
++     e2fsprogs          |                                               [] |
++     enscript           |                                               [] |
++     exif               |                                                  |
++     fetchmail          |                                               [] |
++     findutils          |                                   []             |
++     flex               |                                               [] |
++     freedink           |                                                  |
++     gas                |                                                  |
++     gawk               |                []                             [] |
++     gcal               |                                               [] |
++     gcc                |                                                  |
++     gettext-examples   | []             []                 []          [] |
++     gettext-runtime    |                                   []          [] |
++     gettext-tools      |                                   []          [] |
++     gip                |                                   []             |
++     gjay               |                                                  |
++     gliv               |                                   []             |
++     glunarclock        |                []                 []             |
++     gnubiff            |                                                  |
++     gnucash            |                                               [] |
++     gnuedu             |                                                  |
++     gnulib             |                                                  |
++     gnunet             |                                                  |
++     gnunet-gtk         |                                                  |
++     gnutls             |                                                  |
++     gold               |                                                  |
++     gpe-aerial         |                                                  |
++     gpe-beam           |                                                  |
++     gpe-bluetooth      |                                                  |
++     gpe-calendar       |                                                  |
++     gpe-clock          |                []                                |
++     gpe-conf           |                                                  |
++     gpe-contacts       |                                                  |
++     gpe-edit           |                                                  |
++     gpe-filemanager    |                                                  |
++     gpe-go             |                                                  |
++     gpe-login          |                                                  |
++     gpe-ownerinfo      |                []                                |
++     gpe-package        |                                                  |
++     gpe-sketchbook     |                                                  |
++     gpe-su             |                []                                |
++     gpe-taskmanager    |                []                                |
++     gpe-timesheet      |                []                                |
++     gpe-today          |                []                                |
++     gpe-todo           |                                                  |
++     gphoto2            |                                                  |
++     gprof              |                                   []             |
++     gpsdrive           |                                                  |
++     gramadoir          |                                                  |
++     grep               |                                                  |
++     grub               |                []                             [] |
++     gsasl              |                                                  |
++     gss                |                                                  |
++     gst-plugins-bad    |                                   []             |
++     gst-plugins-base   |                                   []             |
++     gst-plugins-good   |                                   []             |
++     gst-plugins-ugly   |                                   []             |
++     gstreamer          | []                                []          [] |
++     gtick              |                                                  |
++     gtkam              |                       []                         |
++     gtkorphan          |                                   []             |
++     gtkspell           | []             []     []                         |
++     gutenprint         |                                                  |
++     hello              |                                   []             |
++     help2man           |                                                  |
++     hylafax            |                                                  |
++     idutils            |                                                  |
++     indent             |                                   []          [] |
++     iso_15924          |                                                  |
++     iso_3166           | []          []        []          []  []   [] [] |
++     iso_3166_2         |                                                  |
++     iso_4217           |                                                  |
++     iso_639            |             [] []     []              []         |
++     iso_639_3          |                                                  |
++     jwhois             |                                                  |
++     kbd                |                                                  |
++     keytouch           |                                               [] |
++     keytouch-editor    |                                                  |
++     keytouch-keyboa... |                                               [] |
++     klavaro            |          []                                      |
++     latrine            |                                                  |
++     ld                 |                                   []             |
++     leafpad            |                                   []          [] |
++     libc               |                                   []          [] |
++     libexif            |                       ()                         |
++     libextractor       |                                                  |
++     libgnutls          |                                                  |
++     libgpewidget       |                                                  |
++     libgpg-error       |                                                  |
++     libgphoto2         |                                                  |
++     libgphoto2_port    |                                                  |
++     libgsasl           |                                                  |
++     libiconv           |                                   []             |
++     libidn             |                                                  |
++     lifelines          |                                                  |
++     liferea            |                             []                [] |
++     lilypond           |                                                  |
++     linkdr             |          []                                      |
++     lordsawar          |                                                  |
++     lprng              |                                                  |
++     lynx               |                                               [] |
++     m4                 |                                                  |
++     mailfromd          |                                                  |
++     mailutils          |                                                  |
++     make               |                                                  |
++     man-db             |                                                  |
++     man-db-manpages    |                                                  |
++     minicom            |                                                  |
++     mkisofs            |                                                  |
++     myserver           |                                                  |
++     nano               |                                   []          [] |
++     opcodes            |                                                  |
++     parted             |                                                  |
++     pies               |                                                  |
++     popt               |                                                  |
++     psmisc             |                                                  |
++     pspp               |                                               [] |
++     pwdutils           |                                                  |
++     radius             |                                               [] |
++     recode             |                       []                      [] |
++     rosegarden         |                                                  |
++     rpm                |                                                  |
++     rush               |                                                  |
++     sarg               |                                                  |
++     screem             |                                                  |
++     scrollkeeper       |                    [] []                      [] |
++     sed                |                []                             [] |
++     sharutils          |                                   []          [] |
++     shishi             |                                                  |
++     skencil            |                                                  |
++     solfege            |                                                  |
++     solfege-manual     |                                                  |
++     soundtracker       |                                                  |
++     sp                 |                                                  |
++     sysstat            |                                                  |
++     tar                |                                   []             |
++     texinfo            |                                                  |
++     tin                |                                                  |
++     unicode-han-tra... |                                                  |
++     unicode-transla... |                                                  |
++     util-linux-ng      |                                               [] |
++     vice               |                                                  |
++     vmm                |                                                  |
++     vorbis-tools       |                                                  |
++     wastesedge         |                                                  |
++     wdiff              |                                                  |
++     wget               |                       []                      [] |
++     wyslij-po          |                                                  |
++     xchat              |                []     []          []          [] |
++     xdg-user-dirs      | []    []    [] []     []    []    []  []      [] |
++     xkeyboard-config   |                                   []          [] |
++                        +--------------------------------------------------+
++                          af am an ar as ast az be be@latin bg bn_IN bs ca
++                           6  0  1  2  3 19   1 10     3    28   3    1 38
++
++                          crh cs da  de  el en en_GB en_ZA eo es et eu fa
++                        +-------------------------------------------------+
++     a2ps               |     [] []  []  []     []            [] []       |
++     aegis              |        []  []                       []          |
++     ant-phone          |        []  ()                                   |
++     anubis             |        []  []                                   |
++     aspell             |     [] []  []         []            []          |
++     bash               |     []                           [] []          |
++     bfd                |                                     []          |
++     bibshelf           |        []  []                       []          |
++     binutils           |                                     []          |
++     bison              |            []  []                               |
++     bison-runtime      |        []  []  []                      []       |
++     bluez-pin          |     [] []  []  []                [] []          |
++     bombono-dvd        |        []                                       |
++     buzztard           |     [] []  []                                   |
++     cflow              |        []  []                                   |
++     clisp              |        []  []     []                []          |
++     coreutils          |     [] []  []                          []       |
++     cpio               |                                                 |
++     cppi               |                                                 |
++     cpplib             |        []  []                       []          |
++     cryptsetup         |            []                                   |
++     dfarc              |        []  []                       []          |
++     dialog             |        []  []                    [] []    []    |
++     dico               |                                                 |
++     diffutils          |     [] []  []  []                [] []          |
++     dink               |        []  []                       []          |
++     doodle             |            []                                   |
++     e2fsprogs          |     []     []                       []          |
++     enscript           |        []  []         []                        |
++     exif               |     () []  []                                   |
++     fetchmail          |     [] []  ()  []     []            []          |
++     findutils          |     [] []  []                                   |
++     flex               |            []                       []          |
++     freedink           |        []  []                       []          |
++     gas                |                                     []          |
++     gawk               |        []  []                       []          |
++     gcal               |                                     []          |
++     gcc                |            []                       []          |
++     gettext-examples   |            []  []                [] []          |
++     gettext-runtime    |        []  []                    [] []          |
++     gettext-tools      |            []                       []    []    |
++     gip                |        []  []                       []    []    |
++     gjay               |            []                                   |
++     gliv               |     [] []  []                                   |
++     glunarclock        |        []  []                                   |
++     gnubiff            |            ()                                   |
++     gnucash            |     []     ()  ()     ()            ()          |
++     gnuedu             |        []                           []          |
++     gnulib             |            []                       []          |
++     gnunet             |                                                 |
++     gnunet-gtk         |        []                                       |
++     gnutls             |     []     []                                   |
++     gold               |                                     []          |
++     gpe-aerial         |     [] []  []                       []          |
++     gpe-beam           |     [] []  []                       []          |
++     gpe-bluetooth      |        []  []                                   |
++     gpe-calendar       |        []                                       |
++     gpe-clock          |     [] []  []                       []          |
++     gpe-conf           |     [] []  []                                   |
++     gpe-contacts       |        []  []                       []          |
++     gpe-edit           |        []  []                                   |
++     gpe-filemanager    |        []  []                       []          |
++     gpe-go             |     [] []  []                       []          |
++     gpe-login          |        []  []                                   |
++     gpe-ownerinfo      |     [] []  []                       []          |
++     gpe-package        |        []  []                       []          |
++     gpe-sketchbook     |     [] []  []                       []          |
++     gpe-su             |     [] []  []                       []          |
++     gpe-taskmanager    |     [] []  []                       []          |
++     gpe-timesheet      |     [] []  []                       []          |
++     gpe-today          |     [] []  []                       []          |
++     gpe-todo           |        []  []                       []          |
++     gphoto2            |     [] []  ()         []            []    []    |
++     gprof              |        []  []                       []          |
++     gpsdrive           |        []                           [] []       |
++     gramadoir          |        []  []                    []             |
++     grep               |     []                                          |
++     grub               |        []  []                                   |
++     gsasl              |            []                                   |
++     gss                |                                                 |
++     gst-plugins-bad    |     [] []  []                       []    []    |
++     gst-plugins-base   |     [] []  []                       []    []    |
++     gst-plugins-good   |     [] []  []  []                   []    []    |
++     gst-plugins-ugly   |     [] []  []  []                   []    []    |
++     gstreamer          |     [] []  []                       []    []    |
++     gtick              |        []  ()                    []             |
++     gtkam              |     [] []  ()                    [] []          |
++     gtkorphan          |     [] []  []                    []             |
++     gtkspell           |     [] []  []  []                [] []    []    |
++     gutenprint         |        []  []         []                        |
++     hello              |        []  []                    [] []          |
++     help2man           |            []                                   |
++     hylafax            |            []                       []          |
++     idutils            |        []  []                                   |
++     indent             |     [] []  []                    [] [] [] []    |
++     iso_15924          |        []      ()                [] []          |
++     iso_3166           | []  [] []  []  ()                [] [] [] ()    |
++     iso_3166_2         |                ()                               |
++     iso_4217           |     [] []  []  ()                   [] []       |
++     iso_639            | []  [] []  []  ()                [] []          |
++     iso_639_3          | []                                              |
++     jwhois             |                                     []          |
++     kbd                |     [] []  []  []                   []          |
++     keytouch           |        []  []                                   |
++     keytouch-editor    |        []  []                                   |
++     keytouch-keyboa... |        []                                       |
++     klavaro            |     [] []  []                    []             |
++     latrine            |        []  ()                                   |
++     ld                 |        []                           []          |
++     leafpad            |     [] []  []  []                   []    []    |
++     libc               |     [] []  []                       []          |
++     libexif            |        []  []         ()                        |
++     libextractor       |                                                 |
++     libgnutls          |     []                                          |
++     libgpewidget       |        []  []                                   |
++     libgpg-error       |     []     []                                   |
++     libgphoto2         |        []  ()                                   |
++     libgphoto2_port    |        []  ()                             []    |
++     libgsasl           |                                                 |
++     libiconv           |     [] []  []                    []    []       |
++     libidn             |     []     []                    []             |
++     lifelines          |        []  ()                                   |
++     liferea            |     []     []  []                   []    []    |
++     lilypond           |     []     []                       []          |
++     linkdr             |        []  []                       []          |
++     lordsawar          |        []                                       |
++     lprng              |                                                 |
++     lynx               |     [] []  []                          []       |
++     m4                 |     [] []  []  []                               |
++     mailfromd          |                                                 |
++     mailutils          |                                     []          |
++     make               |        []  []                       []          |
++     man-db             |                                                 |
++     man-db-manpages    |                                                 |
++     minicom            |     [] []  []                       []          |
++     mkisofs            |                                                 |
++     myserver           |                                                 |
++     nano               |            []                       []    []    |
++     opcodes            |            []                       []          |
++     parted             |     []     []                                   |
++     pies               |                                                 |
++     popt               |     [] []  []                    [] []          |
++     psmisc             |     []     []                             []    |
++     pspp               |                                     []          |
++     pwdutils           |        []                                       |
++     radius             |                                     []          |
++     recode             |     [] []  []  []                [] []          |
++     rosegarden         |     ()     ()                       ()          |
++     rpm                |        []  []                       []          |
++     rush               |                                                 |
++     sarg               |                                                 |
++     screem             |                                                 |
++     scrollkeeper       |     [] []  []         []            []          |
++     sed                |     []     []  []                [] [] []       |
++     sharutils          |        []  []                       [] []       |
++     shishi             |                                                 |
++     skencil            |        []  ()                       []          |
++     solfege            |            []                    []    []       |
++     solfege-manual     |                                  []    []       |
++     soundtracker       |        []  []                       []          |
++     sp                 |            []                                   |
++     sysstat            |        []  []                             []    |
++     tar                |     []     []                          [] []    |
++     texinfo            |            []                    [] []          |
++     tin                |            []                          []       |
++     unicode-han-tra... |                                                 |
++     unicode-transla... |                                                 |
++     util-linux-ng      |     [] []  []                       []          |
++     vice               |        ()  ()                                   |
++     vmm                |            []                                   |
++     vorbis-tools       |     []                           []             |
++     wastesedge         |        []                                       |
++     wdiff              |            []                       []          |
++     wget               |     []     []                          []       |
++     wyslij-po          |                                                 |
++     xchat              |     []     []  []                   [] []       |
++     xdg-user-dirs      | []  [] []  []  []                [] [] [] []    |
++     xkeyboard-config   | []  [] []  []                    [] []          |
++                        +-------------------------------------------------+
++                          crh cs da  de  el en en_GB en_ZA eo es et eu fa
++                           5  64 105 117 18  1   8     0   28 89 18 19  0
++
++                          fi  fr  ga gl gu he hi hr hu hy id  is it ja ka kn
++                        +----------------------------------------------------+
++     a2ps               | []  []                          []        []       |
++     aegis              |     []                                 []          |
++     ant-phone          |     []                                 []          |
++     anubis             | []  []                          []     []          |
++     aspell             |     []  []                      []     []          |
++     bash               | []  []                          []        []       |
++     bfd                | []  []                          []                 |
++     bibshelf           | []  []  []                      []     []          |
++     binutils           | []  []                          []                 |
++     bison              | []  []  []                      []                 |
++     bison-runtime      | []  []  []                      []     [] []       |
++     bluez-pin          | []  []  []                [] [] []  []    []       |
++     bombono-dvd        | []                                                 |
++     buzztard           |                                 []                 |
++     cflow              | []      []                      []                 |
++     clisp              |     []                                             |
++     coreutils          |     []  []                []    []     []          |
++     cpio               | []  []  []                      []                 |
++     cppi               | []  []                                             |
++     cpplib             | []  []                          []                 |
++     cryptsetup         |     []                          []     []          |
++     dfarc              | []  []                                 []          |
++     dialog             |     []  [] []                   []  [] [] []       |
++     dico               |                                                    |
++     diffutils          | []  []  [] []    []       []    []     [] []       |
++     dink               |     []                                             |
++     doodle             |         []                             []          |
++     e2fsprogs          |     []                          []                 |
++     enscript           |     []  []             []       []                 |
++     exif               | []  []                          []  [] [] []       |
++     fetchmail          |     []                          []     [] []       |
++     findutils          | []  []  []                []    []     []          |
++     flex               | []  []  []                                         |
++     freedink           | []  []                          []                 |
++     gas                |     []                          []                 |
++     gawk               |     []  []       []             []     () []       |
++     gcal               |     []                                             |
++     gcc                |                                 []                 |
++     gettext-examples   | []  []  []                []    []     [] []       |
++     gettext-runtime    | []  []  []                      []     [] []       |
++     gettext-tools      |     []                          []     [] []       |
++     gip                | []  []  [] []                   []        []       |
++     gjay               | []                                                 |
++     gliv               | []  ()                                             |
++     glunarclock        | []      []                []    []                 |
++     gnubiff            |     ()                          []     ()          |
++     gnucash            | ()  ()           ()       ()           () []       |
++     gnuedu             |     []                                 []          |
++     gnulib             | []  []  []                []           [] []       |
++     gnunet             |                                                    |
++     gnunet-gtk         |     []                                             |
++     gnutls             |     []                                 []          |
++     gold               | []                              []                 |
++     gpe-aerial         | []  []                          []                 |
++     gpe-beam           | []  []                          []        []       |
++     gpe-bluetooth      | []                              []     [] []       |
++     gpe-calendar       | []                                        []       |
++     gpe-clock          | []  []                    []    []        []       |
++     gpe-conf           | []  []                          []        []       |
++     gpe-contacts       | []  []                          []        []       |
++     gpe-edit           | []                              []        []       |
++     gpe-filemanager    | []                        []    []        []       |
++     gpe-go             | []  []                    []    []        []       |
++     gpe-login          | []                              []        []       |
++     gpe-ownerinfo      | []  []                    []    []        []       |
++     gpe-package        | []                              []        []       |
++     gpe-sketchbook     | []  []                          []        []       |
++     gpe-su             | []  []     []             []    []        []       |
++     gpe-taskmanager    | []  []                    []    []        []       |
++     gpe-timesheet      | []  []  []                      []        []       |
++     gpe-today          | []  []  [] []             []    []        []       |
++     gpe-todo           | []                              []        []       |
++     gphoto2            | []  []                    []    []     [] []       |
++     gprof              | []  []  []                      []                 |
++     gpsdrive           |            []                   []     []          |
++     gramadoir          |     []  []                      []                 |
++     grep               | []                                     []          |
++     grub               | []                        []    []     []          |
++     gsasl              | []  []  []                      []     []          |
++     gss                | []  []  []                      []     []          |
++     gst-plugins-bad    | []  []                    []    []     [] []       |
++     gst-plugins-base   | []  []                    []    []     [] []       |
++     gst-plugins-good   | []  []                    []    []     [] []       |
++     gst-plugins-ugly   | []  []                    []    []     [] []       |
++     gstreamer          | []  []                    []    []     []          |
++     gtick              | []  []  []                      []     []          |
++     gtkam              |     []                    []    []     [] []       |
++     gtkorphan          |     []                          []     []          |
++     gtkspell           | []  []  [] []             [] [] []     [] []       |
++     gutenprint         | []  []                    []           []          |
++     hello              | []      []                      []                 |
++     help2man           | []  []                                             |
++     hylafax            |                                 []                 |
++     idutils            | []  []  []                []    []     []          |
++     indent             | []  []  [] []             []    []     [] []       |
++     iso_15924          | []  ()                          []     []          |
++     iso_3166           | []  ()  [] [] [] [] [] [] []    []     [] []       |
++     iso_3166_2         |     ()                    []    []     []          |
++     iso_4217           | []  ()                    []    []     [] []       |
++     iso_639            | []  ()  []    []          []    []     [] []    [] |
++     iso_639_3          |     ()                                 []       [] |
++     jwhois             | []  []                    []    []     []          |
++     kbd                |     []                          []                 |
++     keytouch           | []  []  []                []    []     []          |
++     keytouch-editor    | []      []                []    []     []          |
++     keytouch-keyboa... | []      []                []    []     []          |
++     klavaro            |            []             []                       |
++     latrine            | []                              []     []          |
++     ld                 | []  []  []                      []                 |
++     leafpad            | []  []  []       []       []    []     [] ()       |
++     libc               | []  []     []                   []        []       |
++     libexif            |                                        []          |
++     libextractor       |                                                    |
++     libgnutls          |     []                                 []          |
++     libgpewidget       | []      []                      []        []       |
++     libgpg-error       |     []                                 []          |
++     libgphoto2         |     []                                 [] []       |
++     libgphoto2_port    |     []                                 [] []       |
++     libgsasl           | []  []  []                      []     []          |
++     libiconv           | []  []  []                      []     [] []       |
++     libidn             | []  []                          []     []          |
++     lifelines          |     ()                                             |
++     liferea            |     []                    []           [] []       |
++     lilypond           | []  []                                             |
++     linkdr             | []               []    [] []           []          |
++     lordsawar          |                                                    |
++     lprng              |                                 []                 |
++     lynx               |     []                    []    []     [] []       |
++     m4                 | []  []  [] []                   []        []       |
++     mailfromd          |                                                    |
++     mailutils          |     []                          []                 |
++     make               | []  []  [] []    []    []       []     [] []       |
++     man-db             |                                 []     []          |
++     man-db-manpages    |                                 []                 |
++     minicom            | []  []                    []    []        []       |
++     mkisofs            | []  []                          []     []          |
++     myserver           |                                                    |
++     nano               | []  []  [] []             []           []          |
++     opcodes            | []  []  []                      []                 |
++     parted             |     []                          []     [] []       |
++     pies               |                                                    |
++     popt               | []  []  [] []             []    []  [] [] []       |
++     psmisc             | []  []                          []                 |
++     pspp               |                                                    |
++     pwdutils           |     []                          []                 |
++     radius             |     []                          []                 |
++     recode             | []  []  [] []    []       []    []     []          |
++     rosegarden         | ()  ()                          ()     () ()       |
++     rpm                |                                 []        []       |
++     rush               |                                                    |
++     sarg               |     []                                             |
++     screem             |                                        [] []       |
++     scrollkeeper       | []                        []    []     []          |
++     sed                | []  []  [] []             []    []     [] []       |
++     sharutils          | []  []  []                []    []     [] []       |
++     shishi             |     []                                             |
++     skencil            |     []                                             |
++     solfege            | []  []     []                          []          |
++     solfege-manual     |     []     []                                      |
++     soundtracker       |     []                                 []          |
++     sp                 |     []                                    ()       |
++     sysstat            | []  []                          []     [] []       |
++     tar                | []  []  []                []    []     [] []       |
++     texinfo            |     []                          []     [] []       |
++     tin                |     []                                             |
++     unicode-han-tra... |                                                    |
++     unicode-transla... |     []  []                                         |
++     util-linux-ng      | []  []                    []    []     [] []       |
++     vice               |     ()                    ()           ()          |
++     vmm                |     []                                             |
++     vorbis-tools       |                                 []                 |
++     wastesedge         |     ()                                 ()          |
++     wdiff              | []                                                 |
++     wget               | []  []  []             [] []    []     [] []       |
++     wyslij-po          | []  []                          []                 |
++     xchat              | []  []        []    []    []    []     [] []    [] |
++     xdg-user-dirs      | []  []  [] [] [] [] []    []    []  [] [] []    [] |
++     xkeyboard-config   | []  []                    []    []     []          |
++                        +----------------------------------------------------+
++                          fi  fr  ga gl gu he hi hr hu hy id  is it ja ka kn
++                          105 121 53 20  4  8  3  5 53  2 120  5 84 67  0  4
++
++                          ko ku ky lg lt lv mk ml mn mr ms mt nb nds ne
++                        +-----------------------------------------------+
++     a2ps               |                               []              |
++     aegis              |                                               |
++     ant-phone          |                                               |
++     anubis             |                               []    []        |
++     aspell             |                         []                    |
++     bash               |                                               |
++     bfd                |                                               |
++     bibshelf           |                []             []              |
++     binutils           |                                               |
++     bison              |                               []              |
++     bison-runtime      |       []    [] []             []    []        |
++     bluez-pin          |    [] []    [] []             []              |
++     bombono-dvd        |                                               |
++     buzztard           |                                               |
++     cflow              |                                               |
++     clisp              |                                               |
++     coreutils          |          []                                   |
++     cpio               |                                               |
++     cppi               |                                               |
++     cpplib             |                                               |
++     cryptsetup         |                                               |
++     dfarc              |                   []                          |
++     dialog             |    []       [] []             []    []        |
++     dico               |                                               |
++     diffutils          |                []             []              |
++     dink               |                                               |
++     doodle             |                                               |
++     e2fsprogs          |                                               |
++     enscript           |                                               |
++     exif               |                []                             |
++     fetchmail          |                                               |
++     findutils          |                                               |
++     flex               |                                               |
++     freedink           |                                     []        |
++     gas                |                                               |
++     gawk               |                                               |
++     gcal               |                                               |
++     gcc                |                                               |
++     gettext-examples   |       []       []             [] []           |
++     gettext-runtime    | []                                            |
++     gettext-tools      | []                                            |
++     gip                |                []             []              |
++     gjay               |                                               |
++     gliv               |                                               |
++     glunarclock        |                []                             |
++     gnubiff            |                                               |
++     gnucash            | ()          ()                      ()     () |
++     gnuedu             |                                               |
++     gnulib             |                                               |
++     gnunet             |                                               |
++     gnunet-gtk         |                                               |
++     gnutls             |                               []              |
++     gold               |                                               |
++     gpe-aerial         |                []                             |
++     gpe-beam           |                []                             |
++     gpe-bluetooth      |                []                []           |
++     gpe-calendar       |                []                             |
++     gpe-clock          | []    []       []             [] []           |
++     gpe-conf           | []             []                             |
++     gpe-contacts       | []             []                             |
++     gpe-edit           |                []                             |
++     gpe-filemanager    | []             []                             |
++     gpe-go             | []             []                []           |
++     gpe-login          |                []                             |
++     gpe-ownerinfo      |                []             []              |
++     gpe-package        | []             []                             |
++     gpe-sketchbook     | []             []                             |
++     gpe-su             | []    []       []             [] [] []        |
++     gpe-taskmanager    | [] [] []       []             [] []           |
++     gpe-timesheet      |                []             []              |
++     gpe-today          |       []       []             [] []           |
++     gpe-todo           |                []                   []        |
++     gphoto2            |                                               |
++     gprof              |                               []              |
++     gpsdrive           |                                               |
++     gramadoir          |                                               |
++     grep               |                                               |
++     grub               |                                               |
++     gsasl              |                                               |
++     gss                |                                               |
++     gst-plugins-bad    |             [] []                [] []        |
++     gst-plugins-base   |             [] []                             |
++     gst-plugins-good   |                []                []           |
++     gst-plugins-ugly   |             [] []             [] [] []        |
++     gstreamer          |                                               |
++     gtick              |                                               |
++     gtkam              |                                     []        |
++     gtkorphan          |                []                      []     |
++     gtkspell           |       []    [] []       []    []    [] []     |
++     gutenprint         |                                               |
++     hello              | []             []             []              |
++     help2man           |                                               |
++     hylafax            |                                               |
++     idutils            |                                               |
++     indent             |                                               |
++     iso_15924          |             [] []                             |
++     iso_3166           | [] []       () [] [] []    []       []        |
++     iso_3166_2         |                                               |
++     iso_4217           |             []                      []        |
++     iso_639            |                      []    []                 |
++     iso_639_3          |                            []                 |
++     jwhois             |                []                             |
++     kbd                |                                               |
++     keytouch           |                []                             |
++     keytouch-editor    |                []                             |
++     keytouch-keyboa... |                []                             |
++     klavaro            |                                     []        |
++     latrine            |                []                             |
++     ld                 |                                               |
++     leafpad            | []          [] []                             |
++     libc               | []                                            |
++     libexif            |                                               |
++     libextractor       |                                               |
++     libgnutls          |                               []              |
++     libgpewidget       |                []             []              |
++     libgpg-error       |                                               |
++     libgphoto2         |                                               |
++     libgphoto2_port    |                                               |
++     libgsasl           |                                               |
++     libiconv           |                                               |
++     libidn             |                                               |
++     lifelines          |                                               |
++     liferea            |                                               |
++     lilypond           |                                               |
++     linkdr             |                                               |
++     lordsawar          |                                               |
++     lprng              |                                               |
++     lynx               |                                               |
++     m4                 |                                               |
++     mailfromd          |                                               |
++     mailutils          |                                               |
++     make               | []                                            |
++     man-db             |                                               |
++     man-db-manpages    |                                               |
++     minicom            |                                     []        |
++     mkisofs            |                                               |
++     myserver           |                                               |
++     nano               |                               []    []        |
++     opcodes            |                                               |
++     parted             |                                               |
++     pies               |                                               |
++     popt               | []             []                   []        |
++     psmisc             |                                               |
++     pspp               |                                               |
++     pwdutils           |                                               |
++     radius             |                                               |
++     recode             |                                               |
++     rosegarden         |                                               |
++     rpm                |                                               |
++     rush               |                                               |
++     sarg               |                                               |
++     screem             |                                               |
++     scrollkeeper       |                                     []     [] |
++     sed                |                                               |
++     sharutils          |                                               |
++     shishi             |                                               |
++     skencil            |                                               |
++     solfege            |                                     []        |
++     solfege-manual     |                                               |
++     soundtracker       |                                               |
++     sp                 |                                               |
++     sysstat            |                []                             |
++     tar                |       []                                      |
++     texinfo            |                                     []        |
++     tin                |                                               |
++     unicode-han-tra... |                                               |
++     unicode-transla... |                                               |
++     util-linux-ng      |                                               |
++     vice               |                                               |
++     vmm                |                                               |
++     vorbis-tools       |                                               |
++     wastesedge         |                                               |
++     wdiff              |                                               |
++     wget               |             []                                |
++     wyslij-po          |                                               |
++     xchat              | []             [] []                          |
++     xdg-user-dirs      | [] []       [] [] []       []       [] []     |
++     xkeyboard-config   | []    []    []                                |
++                        +-----------------------------------------------+
++                          ko ku ky lg lt lv mk ml mn mr ms mt nb nds ne
++                          20  5 10  1 13 48  4  2  2  4 24 10 20  3   1
++
++                          nl  nn or pa pl  ps pt pt_BR ro ru rw sk sl sq sr
++                        +---------------------------------------------------+
++     a2ps               | []           []     []  []   [] []       []    [] |
++     aegis              | []                      []      []                |
++     ant-phone          |                         []   []                   |
++     anubis             | []           []                 []                |
++     aspell             | []                           [] []    [] []       |
++     bash               | []                                    []          |
++     bfd                |                                 []                |
++     bibshelf           | []  []                                            |
++     binutils           |                                 []    []          |
++     bison              | []           []                 []                |
++     bison-runtime      | []           []     []  []   [] []       []       |
++     bluez-pin          | []           []         []   [] []    [] []    [] |
++     bombono-dvd        |     []                          ()                |
++     buzztard           | []  []                                            |
++     cflow              |              []                                   |
++     clisp              | []                              []                |
++     coreutils          | []           []     []  []      []       []       |
++     cpio               | []           []                 []                |
++     cppi               |              []                                   |
++     cpplib             | []                                                |
++     cryptsetup         | []                                                |
++     dfarc              |              []                                   |
++     dialog             | []           []         []      []                |
++     dico               |              []                                   |
++     diffutils          | []           []         []   [] []             [] |
++     dink               | ()                                                |
++     doodle             | []                                          []    |
++     e2fsprogs          | []           []                                   |
++     enscript           | []                      []   [] []       []       |
++     exif               | []           []              [] ()    []          |
++     fetchmail          | []           []                 []          []    |
++     findutils          | []           []     []          []       []       |
++     flex               | []           []         []   [] []                |
++     freedink           | []           []                                   |
++     gas                |                                                   |
++     gawk               | []           []         []   []                   |
++     gcal               |                                                   |
++     gcc                |                                                [] |
++     gettext-examples   | []           []     []       [] []    [] []    [] |
++     gettext-runtime    | []  []       []     []       [] []    [] []    [] |
++     gettext-tools      |              []              [] []    [] []    [] |
++     gip                | []           []                 []    []       [] |
++     gjay               |                                                   |
++     gliv               | []           []         []   [] []    []          |
++     glunarclock        | []                      []   []       []       [] |
++     gnubiff            | []                           ()                   |
++     gnucash            | []           ()         ()      ()                |
++     gnuedu             | []                                                |
++     gnulib             | []           []                 []       []       |
++     gnunet             |                                                   |
++     gnunet-gtk         |                                                   |
++     gnutls             | []           []                                   |
++     gold               |                                                   |
++     gpe-aerial         | []                  []  []   [] []       []    [] |
++     gpe-beam           | []                  []  []   [] []       []    [] |
++     gpe-bluetooth      | []                      []                        |
++     gpe-calendar       |                         []      []       []    [] |
++     gpe-clock          | []                  []  []   [] []    [] []    [] |
++     gpe-conf           | []                  []  []   [] []    [] []       |
++     gpe-contacts       |                         []   [] []       []    [] |
++     gpe-edit           | []           []                          []       |
++     gpe-filemanager    | []                              []       []       |
++     gpe-go             | []           []         []   [] []    [] []    [] |
++     gpe-login          | []                      []                        |
++     gpe-ownerinfo      | []                  []  []   [] []    [] []    [] |
++     gpe-package        | []                                       []       |
++     gpe-sketchbook     | []                  []  []   [] []       []    [] |
++     gpe-su             | []                  []  []   [] []    [] []    [] |
++     gpe-taskmanager    | []                  []  []   [] []    [] []    [] |
++     gpe-timesheet      | []                  []  []   [] []    [] []    [] |
++     gpe-today          | []                  []  []   [] []    [] []    [] |
++     gpe-todo           | []                      []      []       []    [] |
++     gphoto2            | []        [] []         []   [] []    []       [] |
++     gprof              | []                      []   []                   |
++     gpsdrive           | []                              []                |
++     gramadoir          | []                                    []          |
++     grep               | []           []                 []    []          |
++     grub               | []           []                 []                |
++     gsasl              | []           []                       []       [] |
++     gss                |              []              []       []          |
++     gst-plugins-bad    | []           []         []      []    []    []    |
++     gst-plugins-base   | []           []         []      []    []          |
++     gst-plugins-good   | []           []         []      []    []          |
++     gst-plugins-ugly   | []           []         []      []    [] []       |
++     gstreamer          | []           []         []      []    []          |
++     gtick              | []                              []    []          |
++     gtkam              | []        [] []         []      []    []          |
++     gtkorphan          | []                                                |
++     gtkspell           | []           []     []  []   [] []    [] [] [] [] |
++     gutenprint         | []                              []                |
++     hello              | []           []                       [] []       |
++     help2man           |              []                 []                |
++     hylafax            | []                                                |
++     idutils            | []           []         []   [] []                |
++     indent             | []           []         []   [] []    []       [] |
++     iso_15924          | []           []                 []       []       |
++     iso_3166           | []  [] [] [] []     ()  []   [] [] [] [] [] [] [] |
++     iso_3166_2         | []           []                          []       |
++     iso_4217           | []  []       []     []          [] []    []    [] |
++     iso_639            | []     [] [] []                 [] [] [] []    [] |
++     iso_639_3          |        [] []                                      |
++     jwhois             | []           []         []   []                   |
++     kbd                | []           []              []                   |
++     keytouch           | []           []                       []          |
++     keytouch-editor    | []           []                       []          |
++     keytouch-keyboa... | []           []                       []          |
++     klavaro            | []                      []                        |
++     latrine            |              []                 []                |
++     ld                 |                                                   |
++     leafpad            | []  []       []     []  []      []    [] []    [] |
++     libc               | []           []                 []    []          |
++     libexif            | []           []         ()            []          |
++     libextractor       |                                                   |
++     libgnutls          | []           []                                   |
++     libgpewidget       | []           []                          []       |
++     libgpg-error       |              []              []                   |
++     libgphoto2         | []           []                                   |
++     libgphoto2_port    | []           []         []      []    []          |
++     libgsasl           | []           []              []       []       [] |
++     libiconv           | []           []                       [] []    [] |
++     libidn             | []           []                                   |
++     lifelines          | []           []                                   |
++     liferea            | []           []     []  []   [] ()    ()    []    |
++     lilypond           | []                                                |
++     linkdr             | []                  []          []                |
++     lordsawar          |                                                   |
++     lprng              |              []                                   |
++     lynx               | []                      []      []                |
++     m4                 | []           []         []   [] []                |
++     mailfromd          |              []                                   |
++     mailutils          |              []                                   |
++     make               | []           []         []      []                |
++     man-db             | []           []                 []                |
++     man-db-manpages    | []           []                 []                |
++     minicom            |              []         []   [] []                |
++     mkisofs            | []           []                 []                |
++     myserver           |                                                   |
++     nano               | []           []         []      []                |
++     opcodes            | []                           []                   |
++     parted             | []           []                 []    []          |
++     pies               |              []                                   |
++     popt               | []           []     []          []                |
++     psmisc             | []           []                 []                |
++     pspp               | []                      []                        |
++     pwdutils           |              []                                   |
++     radius             | []           []                 []                |
++     recode             | []           []     []  []   [] []    [] []       |
++     rosegarden         |              ()                 ()                |
++     rpm                | []           []     []                            |
++     rush               | []           []                                   |
++     sarg               |                                                   |
++     screem             |                                                   |
++     scrollkeeper       | []  []       []              [] []    []    [] [] |
++     sed                | []           []     []  []   [] []    [] []    [] |
++     sharutils          | []           []                 []             [] |
++     shishi             |              []                                   |
++     skencil            |                     []  []                        |
++     solfege            | []           []         []      []                |
++     solfege-manual     | []           []         []                        |
++     soundtracker       |                                       []          |
++     sp                 |                                                   |
++     sysstat            | []           []         []      []                |
++     tar                | []           []                 []       []       |
++     texinfo            | []           []              [] []                |
++     tin                |                                 []                |
++     unicode-han-tra... |                                                   |
++     unicode-transla... |                                                   |
++     util-linux-ng      | []           []         []      []       []       |
++     vice               | []                                                |
++     vmm                | []                                                |
++     vorbis-tools       | []           []                                   |
++     wastesedge         | []                                                |
++     wdiff              | []           []                                   |
++     wget               | []           []     []  []      []    [] []       |
++     wyslij-po          | []  []       []                                   |
++     xchat              | []        [] []     []          []    [] [] [] [] |
++     xdg-user-dirs      | []  [] [] [] []  [] []  []   [] []    [] [] [] [] |
++     xkeyboard-config   | []           []                 []                |
++                        +---------------------------------------------------+
++                          nl  nn or pa pl  ps pt pt_BR ro ru rw sk sl sq sr
++                          135 10  4  7 105  1 29  62   47 91  3 54 46  9 37
++
++                          sv  sw ta te tg th tr uk vi  wa zh_CN zh_HK zh_TW
++                        +---------------------------------------------------+
++     a2ps               | []              [] [] [] []                       | 27
++     aegis              |                          []                       |  9
++     ant-phone          | []                 []    []      []               |  9
++     anubis             | []                 [] [] []                       | 15
++     aspell             |                       [] []  []                   | 20
++     bash               | []                    [] []                       | 12
++     bfd                |                          []                       |  6
++     bibshelf           | []                       []      []               | 16
++     binutils           |                       [] []                       |  8
++     bison              | []                       []                       | 12
++     bison-runtime      | []              []    [] []      []          []   | 29
++     bluez-pin          | []              [] [] [] []  []  []          []   | 37
++     bombono-dvd        |                          []                       |  4
++     buzztard           |                          []                       |  7
++     cflow              |                       [] []      []               |  9
++     clisp              |                                                   | 10
++     coreutils          | []                    [] []      []               | 22
++     cpio               | []                 [] [] []      []          []   | 13
++     cppi               |                       [] []                       |  5
++     cpplib             | []                 [] [] []      []          []   | 14
++     cryptsetup         | []                       []                       |  7
++     dfarc              |                          []                       |  9
++     dialog             | []  []          []       []  []  []          []   | 30
++     dico               |                       []                          |  2
++     diffutils          | []                 [] [] []      []          []   | 30
++     dink               |                                                   |  4
++     doodle             | []                       []                       |  7
++     e2fsprogs          | []                 []    []                       | 11
++     enscript           | []                 [] [] []                       | 17
++     exif               | []                       []      []               | 16
++     fetchmail          |                    []    []      []               | 17
++     findutils          | []                 [] [] []      []               | 20
++     flex               | []                 []    []                  []   | 15
++     freedink           |                          []                       | 10
++     gas                |                    []                             |  4
++     gawk               | []                 []    []      []               | 18
++     gcal               | []                 []                             |  5
++     gcc                | []                 []            []               |  7
++     gettext-examples   | []                 [] [] []      []    []    []   | 34
++     gettext-runtime    | []                 [] [] []      []    []    []   | 29
++     gettext-tools      | []                 [] [] []      []          []   | 22
++     gip                | []                       []      []          []   | 22
++     gjay               |                          []                       |  3
++     gliv               | []                 []    []                       | 14
++     glunarclock        | []                       []  []  []          []   | 19
++     gnubiff            | []                       []                       |  4
++     gnucash            |                    () [] ()      []          ()   | 10
++     gnuedu             |                          []                  []   |  7
++     gnulib             | []                    [] []      []               | 16
++     gnunet             |                          []                       |  1
++     gnunet-gtk         | []                 []    []                       |  5
++     gnutls             | []                       []      []               | 10
++     gold               |                          []                       |  4
++     gpe-aerial         | []                       []      []               | 18
++     gpe-beam           | []                       []      []               | 19
++     gpe-bluetooth      | []                       []      []               | 13
++     gpe-calendar       | []                       []  []  []               | 12
++     gpe-clock          | []                 []    []  []  []               | 28
++     gpe-conf           | []                       []  []  []               | 20
++     gpe-contacts       | []                       []      []               | 17
++     gpe-edit           | []                       []      []               | 12
++     gpe-filemanager    | []                       []  []  []               | 16
++     gpe-go             | []                 []    []  []  []               | 25
++     gpe-login          | []                       []      []               | 11
++     gpe-ownerinfo      | []                 []    []      []          []   | 25
++     gpe-package        | []                       []      []               | 13
++     gpe-sketchbook     | []                       []      []               | 20
++     gpe-su             | []                 []    []  []  []               | 30
++     gpe-taskmanager    | []                 []    []  []  []               | 29
++     gpe-timesheet      | []                 []    []      []          []   | 25
++     gpe-today          | []                 []    []  []  []          []   | 30
++     gpe-todo           | []                       []  []  []               | 17
++     gphoto2            | []                    [] []      []          []   | 24
++     gprof              | []                 []    []                       | 15
++     gpsdrive           | []                       []      []               | 11
++     gramadoir          | []                       []      []               | 11
++     grep               |                 []       []      []               | 10
++     grub               | []                       []      []               | 14
++     gsasl              | []                       []      []          []   | 14
++     gss                | []                       []      []               | 11
++     gst-plugins-bad    | []                 []    []      []               | 26
++     gst-plugins-base   | []                 [] [] []      []               | 24
++     gst-plugins-good   | []                 []    []      []               | 24
++     gst-plugins-ugly   | []                 [] [] []      []               | 29
++     gstreamer          | []                    [] []      []               | 22
++     gtick              |                       [] []      []               | 13
++     gtkam              | []                       []      []               | 20
++     gtkorphan          | []                       []      []               | 14
++     gtkspell           | []              [] [] [] []  []  []    []    []   | 45
++     gutenprint         | []                                                | 10
++     hello              | []              [] []    []      []          []   | 21
++     help2man           | []                       []                       |  7
++     hylafax            |                          []                       |  5
++     idutils            | []                 []    []      []               | 17
++     indent             | []                 [] [] []      []          []   | 30
++     iso_15924          |                 ()    [] ()      []          []   | 16
++     iso_3166           | []        []    () [] [] ()  []  []    []    ()   | 53
++     iso_3166_2         |                 ()    [] ()      []               |  9
++     iso_4217           | []              () [] [] ()      []    []         | 26
++     iso_639            | []     [] []    ()    [] ()  []  []    []    []   | 38
++     iso_639_3          |        []                ()                       |  8
++     jwhois             | []                 []    []      []          []   | 16
++     kbd                | []                 [] [] []      []               | 15
++     keytouch           | []                       []      []               | 16
++     keytouch-editor    | []                       []      []               | 14
++     keytouch-keyboa... | []                       []      []               | 14
++     klavaro            |                          []                       | 11
++     latrine            |                    []    []      []               | 10
++     ld                 | []                 []    []                  []   | 11
++     leafpad            | []                 [] [] []      []          []   | 33
++     libc               | []                 []    []      []          []   | 21
++     libexif            |                          []      ()               |  7
++     libextractor       |                          []                       |  1
++     libgnutls          | []                       []      []               |  9
++     libgpewidget       | []                       []      []               | 14
++     libgpg-error       | []                       []      []               |  9
++     libgphoto2         |                       [] []                       |  8
++     libgphoto2_port    | []                    [] []                  []   | 14
++     libgsasl           | []                       []      []               | 13
++     libiconv           | []                       []  []  []               | 21
++     libidn             | ()                       []      []               | 11
++     lifelines          | []                                                |  4
++     liferea            | []                 []            []               | 21
++     lilypond           |                          []                       |  7
++     linkdr             | []                 []    []      []          []   | 17
++     lordsawar          |                                                   |  1
++     lprng              |                          []                       |  3
++     lynx               | []                 [] [] []                       | 17
++     m4                 | []                       []      []          []   | 19
++     mailfromd          |                       [] []                       |  3
++     mailutils          |                          []                       |  5
++     make               | []                 []    []      []               | 21
++     man-db             | []                       []      []               |  8
++     man-db-manpages    |                                                   |  4
++     minicom            | []                       []                       | 16
++     mkisofs            |                          []      []               |  9
++     myserver           |                                                   |  0
++     nano               | []                       []      []          []   | 21
++     opcodes            | []                 []    []                       | 11
++     parted             | []                 [] [] []                  []   | 15
++     pies               |                       [] []                       |  3
++     popt               | []              [] []    []      []          []   | 27
++     psmisc             | []                       []                       | 11
++     pspp               |                                                   |  4
++     pwdutils           | []                       []                       |  6
++     radius             |                       [] []                       |  9
++     recode             | []                 []    []      []               | 28
++     rosegarden         | ()                                                |  0
++     rpm                | []                       []                  []   | 11
++     rush               |                       [] []                       |  4
++     sarg               |                                                   |  1
++     screem             |                          []                       |  3
++     scrollkeeper       | []                 [] [] []                  []   | 27
++     sed                | []                 []    []      []          []   | 30
++     sharutils          | []                 []    []      []          []   | 22
++     shishi             |                          []                       |  3
++     skencil            | []                       []                       |  7
++     solfege            | []                 []    []      []               | 16
++     solfege-manual     |                    []                             |  8
++     soundtracker       | []                 []    []                       |  9
++     sp                 |                    []                             |  3
++     sysstat            |                          []      []               | 15
++     tar                | []                 [] [] []      []          []   | 23
++     texinfo            | []                 [] [] []      []               | 17
++     tin                |                                                   |  4
++     unicode-han-tra... |                                                   |  0
++     unicode-transla... |                                                   |  2
++     util-linux-ng      | []                 [] [] []                       | 20
++     vice               | ()                 ()                             |  1
++     vmm                |                          []                       |  4
++     vorbis-tools       |                          []                       |  6
++     wastesedge         |                                                   |  2
++     wdiff              | []                       []                       |  7
++     wget               | []                 []    []      []          []   | 26
++     wyslij-po          |                       [] []                       |  8
++     xchat              | []              []    [] []      []          []   | 36
++     xdg-user-dirs      | []     [] []    [] [] [] []      []    []    []   | 63
++     xkeyboard-config   | []                    [] []                       | 22
++                        +---------------------------------------------------+
++       85 teams           sv  sw ta te tg th tr uk vi  wa zh_CN zh_HK zh_TW
++      178 domains         119  1  3  3  0 10 65 51 155 17  98     7    41    2618
++
++   Some counters in the preceding matrix are higher than the number of
++visible blocks let us expect.  This is because a few extra PO files are
++used for implementing regional variants of languages, or language
++dialects.
++
++   For a PO file in the matrix above to be effective, the package to
++which it applies should also have been internationalized and
++distributed as such by its maintainer.  There might be an observable
++lag between the mere existence a PO file and its wide availability in a
++distribution.
++
++   If June 2010 seems to be old, you may fetch a more recent copy of
++this `ABOUT-NLS' file on most GNU archive sites.  The most up-to-date
++matrix with full percentage details can be found at
++`http://translationproject.org/extra/matrix.html'.
++
++1.5 Using `gettext' in new packages
++===================================
++
++If you are writing a freely available program and want to
++internationalize it you are welcome to use GNU `gettext' in your
++package.  Of course you have to respect the GNU Library General Public
++License which covers the use of the GNU `gettext' library.  This means
++in particular that even non-free programs can use `libintl' as a shared
++library, whereas only free software can use `libintl' as a static
++library or use modified versions of `libintl'.
++
++   Once the sources are changed appropriately and the setup can handle
++the use of `gettext' the only thing missing are the translations.  The
++Free Translation Project is also available for packages which are not
++developed inside the GNU project.  Therefore the information given above
++applies also for every other Free Software Project.  Contact
++`coordinator@translationproject.org' to make the `.pot' files available
++to the translation teams.
++
+diff --git a/config.rpath b/config.rpath
+new file mode 100755
+index 0000000..17298f2
+--- /dev/null
++++ b/config.rpath
+@@ -0,0 +1,672 @@
++#! /bin/sh
++# Output a system dependent set of variables, describing how to set the
++# run time search path of shared libraries in an executable.
++#
++#   Copyright 1996-2010 Free Software Foundation, Inc.
++#   Taken from GNU libtool, 2001
++#   Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
++#
++#   This file is free software; the Free Software Foundation gives
++#   unlimited permission to copy and/or distribute it, with or without
++#   modifications, as long as this notice is preserved.
++#
++# The first argument passed to this file is the canonical host specification,
++#    CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
++# or
++#    CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
++# The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld
++# should be set by the caller.
++#
++# The set of defined variables is at the end of this script.
++
++# Known limitations:
++# - On IRIX 6.5 with CC="cc", the run time search patch must not be longer
++#   than 256 bytes, otherwise the compiler driver will dump core. The only
++#   known workaround is to choose shorter directory names for the build
++#   directory and/or the installation directory.
++
++# All known linkers require a `.a' archive for static linking (except MSVC,
++# which needs '.lib').
++libext=a
++shrext=.so
++
++host="$1"
++host_cpu=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
++host_vendor=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
++host_os=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
++
++# Code taken from libtool.m4's _LT_CC_BASENAME.
++
++for cc_temp in $CC""; do
++  case $cc_temp in
++    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
++    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
++    \-*) ;;
++    *) break;;
++  esac
++done
++cc_basename=`echo "$cc_temp" | sed -e 's%^.*/%%'`
++
++# Code taken from libtool.m4's _LT_COMPILER_PIC.
++
++wl=
++if test "$GCC" = yes; then
++  wl='-Wl,'
++else
++  case "$host_os" in
++    aix*)
++      wl='-Wl,'
++      ;;
++    darwin*)
++      case $cc_basename in
++        xlc*)
++          wl='-Wl,'
++          ;;
++      esac
++      ;;
++    mingw* | cygwin* | pw32* | os2* | cegcc*)
++      ;;
++    hpux9* | hpux10* | hpux11*)
++      wl='-Wl,'
++      ;;
++    irix5* | irix6* | nonstopux*)
++      wl='-Wl,'
++      ;;
++    newsos6)
++      ;;
++    linux* | k*bsd*-gnu)
++      case $cc_basename in
++        ecc*)
++          wl='-Wl,'
++          ;;
++        icc* | ifort*)
++          wl='-Wl,'
++          ;;
++        lf95*)
++          wl='-Wl,'
++          ;;
++        pgcc | pgf77 | pgf90)
++          wl='-Wl,'
++          ;;
++        ccc*)
++          wl='-Wl,'
++          ;;
++        como)
++          wl='-lopt='
++          ;;
++        *)
++          case `$CC -V 2>&1 | sed 5q` in
++            *Sun\ C*)
++              wl='-Wl,'
++              ;;
++          esac
++          ;;
++      esac
++      ;;
++    osf3* | osf4* | osf5*)
++      wl='-Wl,'
++      ;;
++    rdos*)
++      ;;
++    solaris*)
++      wl='-Wl,'
++      ;;
++    sunos4*)
++      wl='-Qoption ld '
++      ;;
++    sysv4 | sysv4.2uw2* | sysv4.3*)
++      wl='-Wl,'
++      ;;
++    sysv4*MP*)
++      ;;
++    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
++      wl='-Wl,'
++      ;;
++    unicos*)
++      wl='-Wl,'
++      ;;
++    uts4*)
++      ;;
++  esac
++fi
++
++# Code taken from libtool.m4's _LT_LINKER_SHLIBS.
++
++hardcode_libdir_flag_spec=
++hardcode_libdir_separator=
++hardcode_direct=no
++hardcode_minus_L=no
++
++case "$host_os" in
++  cygwin* | mingw* | pw32* | cegcc*)
++    # FIXME: the MSVC++ port hasn't been tested in a loooong time
++    # When not using gcc, we currently assume that we are using
++    # Microsoft Visual C++.
++    if test "$GCC" != yes; then
++      with_gnu_ld=no
++    fi
++    ;;
++  interix*)
++    # we just hope/assume this is gcc and not c89 (= MSVC++)
++    with_gnu_ld=yes
++    ;;
++  openbsd*)
++    with_gnu_ld=no
++    ;;
++esac
++
++ld_shlibs=yes
++if test "$with_gnu_ld" = yes; then
++  # Set some defaults for GNU ld with shared library support. These
++  # are reset later if shared libraries are not supported. Putting them
++  # here allows them to be overridden if necessary.
++  # Unlike libtool, we use -rpath here, not --rpath, since the documented
++  # option of GNU ld is called -rpath, not --rpath.
++  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
++  case "$host_os" in
++    aix[3-9]*)
++      # On AIX/PPC, the GNU linker is very broken
++      if test "$host_cpu" != ia64; then
++        ld_shlibs=no
++      fi
++      ;;
++    amigaos*)
++      hardcode_libdir_flag_spec='-L$libdir'
++      hardcode_minus_L=yes
++      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
++      # that the semantics of dynamic libraries on AmigaOS, at least up
++      # to version 4, is to share data among multiple programs linked
++      # with the same dynamic library.  Since this doesn't match the
++      # behavior of shared libraries on other platforms, we cannot use
++      # them.
++      ld_shlibs=no
++      ;;
++    beos*)
++      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
++        :
++      else
++        ld_shlibs=no
++      fi
++      ;;
++    cygwin* | mingw* | pw32* | cegcc*)
++      # hardcode_libdir_flag_spec is actually meaningless, as there is
++      # no search path for DLLs.
++      hardcode_libdir_flag_spec='-L$libdir'
++      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
++        :
++      else
++        ld_shlibs=no
++      fi
++      ;;
++    interix[3-9]*)
++      hardcode_direct=no
++      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
++      ;;
++    gnu* | linux* | k*bsd*-gnu)
++      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
++        :
++      else
++        ld_shlibs=no
++      fi
++      ;;
++    netbsd*)
++      ;;
++    solaris*)
++      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
++        ld_shlibs=no
++      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
++        :
++      else
++        ld_shlibs=no
++      fi
++      ;;
++    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
++      case `$LD -v 2>&1` in
++        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
++          ld_shlibs=no
++          ;;
++        *)
++          if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
++            hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
++          else
++            ld_shlibs=no
++          fi
++          ;;
++      esac
++      ;;
++    sunos4*)
++      hardcode_direct=yes
++      ;;
++    *)
++      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
++        :
++      else
++        ld_shlibs=no
++      fi
++      ;;
++  esac
++  if test "$ld_shlibs" = no; then
++    hardcode_libdir_flag_spec=
++  fi
++else
++  case "$host_os" in
++    aix3*)
++      # Note: this linker hardcodes the directories in LIBPATH if there
++      # are no directories specified by -L.
++      hardcode_minus_L=yes
++      if test "$GCC" = yes; then
++        # Neither direct hardcoding nor static linking is supported with a
++        # broken collect2.
++        hardcode_direct=unsupported
++      fi
++      ;;
++    aix[4-9]*)
++      if test "$host_cpu" = ia64; then
++        # On IA64, the linker does run time linking by default, so we don't
++        # have to do anything special.
++        aix_use_runtimelinking=no
++      else
++        aix_use_runtimelinking=no
++        # Test if we are trying to use run time linking or normal
++        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
++        # need to do runtime linking.
++        case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
++          for ld_flag in $LDFLAGS; do
++            if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
++              aix_use_runtimelinking=yes
++              break
++            fi
++          done
++          ;;
++        esac
++      fi
++      hardcode_direct=yes
++      hardcode_libdir_separator=':'
++      if test "$GCC" = yes; then
++        case $host_os in aix4.[012]|aix4.[012].*)
++          collect2name=`${CC} -print-prog-name=collect2`
++          if test -f "$collect2name" && \
++            strings "$collect2name" | grep resolve_lib_name >/dev/null
++          then
++            # We have reworked collect2
++            :
++          else
++            # We have old collect2
++            hardcode_direct=unsupported
++            hardcode_minus_L=yes
++            hardcode_libdir_flag_spec='-L$libdir'
++            hardcode_libdir_separator=
++          fi
++          ;;
++        esac
++      fi
++      # Begin _LT_AC_SYS_LIBPATH_AIX.
++      echo 'int main () { return 0; }' > conftest.c
++      ${CC} ${LDFLAGS} conftest.c -o conftest
++      aix_libpath=`dump -H conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
++}'`
++      if test -z "$aix_libpath"; then
++        aix_libpath=`dump -HX64 conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
++}'`
++      fi
++      if test -z "$aix_libpath"; then
++        aix_libpath="/usr/lib:/lib"
++      fi
++      rm -f conftest.c conftest
++      # End _LT_AC_SYS_LIBPATH_AIX.
++      if test "$aix_use_runtimelinking" = yes; then
++        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
++      else
++        if test "$host_cpu" = ia64; then
++          hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
++        else
++          hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
++        fi
++      fi
++      ;;
++    amigaos*)
++      hardcode_libdir_flag_spec='-L$libdir'
++      hardcode_minus_L=yes
++      # see comment about different semantics on the GNU ld section
++      ld_shlibs=no
++      ;;
++    bsdi[45]*)
++      ;;
++    cygwin* | mingw* | pw32* | cegcc*)
++      # When not using gcc, we currently assume that we are using
++      # Microsoft Visual C++.
++      # hardcode_libdir_flag_spec is actually meaningless, as there is
++      # no search path for DLLs.
++      hardcode_libdir_flag_spec=' '
++      libext=lib
++      ;;
++    darwin* | rhapsody*)
++      hardcode_direct=no
++      if test "$GCC" = yes ; then
++        :
++      else
++        case $cc_basename in
++          xlc*)
++            ;;
++          *)
++            ld_shlibs=no
++            ;;
++        esac
++      fi
++      ;;
++    dgux*)
++      hardcode_libdir_flag_spec='-L$libdir'
++      ;;
++    freebsd1*)
++      ld_shlibs=no
++      ;;
++    freebsd2.2*)
++      hardcode_libdir_flag_spec='-R$libdir'
++      hardcode_direct=yes
++      ;;
++    freebsd2*)
++      hardcode_direct=yes
++      hardcode_minus_L=yes
++      ;;
++    freebsd* | dragonfly*)
++      hardcode_libdir_flag_spec='-R$libdir'
++      hardcode_direct=yes
++      ;;
++    hpux9*)
++      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
++      hardcode_libdir_separator=:
++      hardcode_direct=yes
++      # hardcode_minus_L: Not really in the search PATH,
++      # but as the default location of the library.
++      hardcode_minus_L=yes
++      ;;
++    hpux10*)
++      if test "$with_gnu_ld" = no; then
++        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
++        hardcode_libdir_separator=:
++        hardcode_direct=yes
++        # hardcode_minus_L: Not really in the search PATH,
++        # but as the default location of the library.
++        hardcode_minus_L=yes
++      fi
++      ;;
++    hpux11*)
++      if test "$with_gnu_ld" = no; then
++        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
++        hardcode_libdir_separator=:
++        case $host_cpu in
++          hppa*64*|ia64*)
++            hardcode_direct=no
++            ;;
++          *)
++            hardcode_direct=yes
++            # hardcode_minus_L: Not really in the search PATH,
++            # but as the default location of the library.
++            hardcode_minus_L=yes
++            ;;
++        esac
++      fi
++      ;;
++    irix5* | irix6* | nonstopux*)
++      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
++      hardcode_libdir_separator=:
++      ;;
++    netbsd*)
++      hardcode_libdir_flag_spec='-R$libdir'
++      hardcode_direct=yes
++      ;;
++    newsos6)
++      hardcode_direct=yes
++      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
++      hardcode_libdir_separator=:
++      ;;
++    openbsd*)
++      if test -f /usr/libexec/ld.so; then
++        hardcode_direct=yes
++        if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
++          hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
++        else
++          case "$host_os" in
++            openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
++              hardcode_libdir_flag_spec='-R$libdir'
++              ;;
++            *)
++              hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
++              ;;
++          esac
++        fi
++      else
++        ld_shlibs=no
++      fi
++      ;;
++    os2*)
++      hardcode_libdir_flag_spec='-L$libdir'
++      hardcode_minus_L=yes
++      ;;
++    osf3*)
++      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
++      hardcode_libdir_separator=:
++      ;;
++    osf4* | osf5*)
++      if test "$GCC" = yes; then
++        hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
++      else
++        # Both cc and cxx compiler support -rpath directly
++        hardcode_libdir_flag_spec='-rpath $libdir'
++      fi
++      hardcode_libdir_separator=:
++      ;;
++    solaris*)
++      hardcode_libdir_flag_spec='-R$libdir'
++      ;;
++    sunos4*)
++      hardcode_libdir_flag_spec='-L$libdir'
++      hardcode_direct=yes
++      hardcode_minus_L=yes
++      ;;
++    sysv4)
++      case $host_vendor in
++        sni)
++          hardcode_direct=yes # is this really true???
++          ;;
++        siemens)
++          hardcode_direct=no
++          ;;
++        motorola)
++          hardcode_direct=no #Motorola manual says yes, but my tests say they lie
++          ;;
++      esac
++      ;;
++    sysv4.3*)
++      ;;
++    sysv4*MP*)
++      if test -d /usr/nec; then
++        ld_shlibs=yes
++      fi
++      ;;
++    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
++      ;;
++    sysv5* | sco3.2v5* | sco5v6*)
++      hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
++      hardcode_libdir_separator=':'
++      ;;
++    uts4*)
++      hardcode_libdir_flag_spec='-L$libdir'
++      ;;
++    *)
++      ld_shlibs=no
++      ;;
++  esac
++fi
++
++# Check dynamic linker characteristics
++# Code taken from libtool.m4's _LT_SYS_DYNAMIC_LINKER.
++# Unlike libtool.m4, here we don't care about _all_ names of the library, but
++# only about the one the linker finds when passed -lNAME. This is the last
++# element of library_names_spec in libtool.m4, or possibly two of them if the
++# linker has special search rules.
++library_names_spec=      # the last element of library_names_spec in libtool.m4
++libname_spec='lib$name'
++case "$host_os" in
++  aix3*)
++    library_names_spec='$libname.a'
++    ;;
++  aix[4-9]*)
++    library_names_spec='$libname$shrext'
++    ;;
++  amigaos*)
++    library_names_spec='$libname.a'
++    ;;
++  beos*)
++    library_names_spec='$libname$shrext'
++    ;;
++  bsdi[45]*)
++    library_names_spec='$libname$shrext'
++    ;;
++  cygwin* | mingw* | pw32* | cegcc*)
++    shrext=.dll
++    library_names_spec='$libname.dll.a $libname.lib'
++    ;;
++  darwin* | rhapsody*)
++    shrext=.dylib
++    library_names_spec='$libname$shrext'
++    ;;
++  dgux*)
++    library_names_spec='$libname$shrext'
++    ;;
++  freebsd1*)
++    ;;
++  freebsd* | dragonfly*)
++    case "$host_os" in
++      freebsd[123]*)
++        library_names_spec='$libname$shrext$versuffix' ;;
++      *)
++        library_names_spec='$libname$shrext' ;;
++    esac
++    ;;
++  gnu*)
++    library_names_spec='$libname$shrext'
++    ;;
++  hpux9* | hpux10* | hpux11*)
++    case $host_cpu in
++      ia64*)
++        shrext=.so
++        ;;
++      hppa*64*)
++        shrext=.sl
++        ;;
++      *)
++        shrext=.sl
++        ;;
++    esac
++    library_names_spec='$libname$shrext'
++    ;;
++  interix[3-9]*)
++    library_names_spec='$libname$shrext'
++    ;;
++  irix5* | irix6* | nonstopux*)
++    library_names_spec='$libname$shrext'
++    case "$host_os" in
++      irix5* | nonstopux*)
++        libsuff= shlibsuff=
++        ;;
++      *)
++        case $LD in
++          *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= ;;
++          *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 ;;
++          *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 ;;
++          *) libsuff= shlibsuff= ;;
++        esac
++        ;;
++    esac
++    ;;
++  linux*oldld* | linux*aout* | linux*coff*)
++    ;;
++  linux* | k*bsd*-gnu)
++    library_names_spec='$libname$shrext'
++    ;;
++  knetbsd*-gnu)
++    library_names_spec='$libname$shrext'
++    ;;
++  netbsd*)
++    library_names_spec='$libname$shrext'
++    ;;
++  newsos6)
++    library_names_spec='$libname$shrext'
++    ;;
++  nto-qnx*)
++    library_names_spec='$libname$shrext'
++    ;;
++  openbsd*)
++    library_names_spec='$libname$shrext$versuffix'
++    ;;
++  os2*)
++    libname_spec='$name'
++    shrext=.dll
++    library_names_spec='$libname.a'
++    ;;
++  osf3* | osf4* | osf5*)
++    library_names_spec='$libname$shrext'
++    ;;
++  rdos*)
++    ;;
++  solaris*)
++    library_names_spec='$libname$shrext'
++    ;;
++  sunos4*)
++    library_names_spec='$libname$shrext$versuffix'
++    ;;
++  sysv4 | sysv4.3*)
++    library_names_spec='$libname$shrext'
++    ;;
++  sysv4*MP*)
++    library_names_spec='$libname$shrext'
++    ;;
++  sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
++    library_names_spec='$libname$shrext'
++    ;;
++  uts4*)
++    library_names_spec='$libname$shrext'
++    ;;
++esac
++
++sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
++escaped_wl=`echo "X$wl" | sed -e 's/^X//' -e "$sed_quote_subst"`
++shlibext=`echo "$shrext" | sed -e 's,^\.,,'`
++escaped_libname_spec=`echo "X$libname_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
++escaped_library_names_spec=`echo "X$library_names_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
++escaped_hardcode_libdir_flag_spec=`echo "X$hardcode_libdir_flag_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
++
++LC_ALL=C sed -e 's/^\([a-zA-Z0-9_]*\)=/acl_cv_\1=/' <<EOF
++
++# How to pass a linker flag through the compiler.
++wl="$escaped_wl"
++
++# Static library suffix (normally "a").
++libext="$libext"
++
++# Shared library suffix (normally "so").
++shlibext="$shlibext"
++
++# Format of library name prefix.
++libname_spec="$escaped_libname_spec"
++
++# Library names that the linker finds when passed -lNAME.
++library_names_spec="$escaped_library_names_spec"
++
++# Flag to hardcode \$libdir into a binary during linking.
++# This must work even if \$libdir does not exist.
++hardcode_libdir_flag_spec="$escaped_hardcode_libdir_flag_spec"
++
++# Whether we need a single -rpath flag with a separated argument.
++hardcode_libdir_separator="$hardcode_libdir_separator"
++
++# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the
++# resulting binary.
++hardcode_direct="$hardcode_direct"
++
++# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
++# resulting binary.
++hardcode_minus_L="$hardcode_minus_L"
++
++EOF
+diff --git a/m4/codeset.m4 b/m4/codeset.m4
+new file mode 100644
+index 0000000..a53c042
+--- /dev/null
++++ b/m4/codeset.m4
+@@ -0,0 +1,21 @@
++# codeset.m4 serial 4 (gettext-0.18)
++dnl Copyright (C) 2000-2002, 2006, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_DEFUN([AM_LANGINFO_CODESET],
++[
++  AC_CACHE_CHECK([for nl_langinfo and CODESET], [am_cv_langinfo_codeset],
++    [AC_TRY_LINK([#include <langinfo.h>],
++      [char* cs = nl_langinfo(CODESET); return !cs;],
++      [am_cv_langinfo_codeset=yes],
++      [am_cv_langinfo_codeset=no])
++    ])
++  if test $am_cv_langinfo_codeset = yes; then
++    AC_DEFINE([HAVE_LANGINFO_CODESET], [1],
++      [Define if you have <langinfo.h> and nl_langinfo(CODESET).])
++  fi
++])
+diff --git a/m4/fcntl-o.m4 b/m4/fcntl-o.m4
+new file mode 100644
+index 0000000..d416a61
+--- /dev/null
++++ b/m4/fcntl-o.m4
+@@ -0,0 +1,81 @@
++# fcntl-o.m4 serial 1
++dnl Copyright (C) 2006, 2009-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl Written by Paul Eggert.
++
++# Test whether the flags O_NOATIME and O_NOFOLLOW actually work.
++# Define HAVE_WORKING_O_NOATIME to 1 if O_NOATIME works, or to 0 otherwise.
++# Define HAVE_WORKING_O_NOFOLLOW to 1 if O_NOFOLLOW works, or to 0 otherwise.
++AC_DEFUN([gl_FCNTL_O_FLAGS],
++[
++  dnl Persuade glibc <fcntl.h> to define O_NOATIME and O_NOFOLLOW.
++  AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
++  AC_CACHE_CHECK([for working fcntl.h], [gl_cv_header_working_fcntl_h],
++    [AC_RUN_IFELSE(
++       [AC_LANG_PROGRAM(
++          [[#include <sys/types.h>
++           #include <sys/stat.h>
++           #include <unistd.h>
++           #include <fcntl.h>
++           #ifndef O_NOATIME
++            #define O_NOATIME 0
++           #endif
++           #ifndef O_NOFOLLOW
++            #define O_NOFOLLOW 0
++           #endif
++           static int const constants[] =
++            {
++              O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, O_APPEND,
++              O_NONBLOCK, O_SYNC, O_ACCMODE, O_RDONLY, O_RDWR, O_WRONLY
++            };
++          ]],
++          [[
++            int status = !constants;
++            {
++              static char const sym[] = "conftest.sym";
++              if (symlink (".", sym) != 0
++                  || close (open (sym, O_RDONLY | O_NOFOLLOW)) == 0)
++                status |= 32;
++              unlink (sym);
++            }
++            {
++              static char const file[] = "confdefs.h";
++              int fd = open (file, O_RDONLY | O_NOATIME);
++              char c;
++              struct stat st0, st1;
++              if (fd < 0
++                  || fstat (fd, &st0) != 0
++                  || sleep (1) != 0
++                  || read (fd, &c, 1) != 1
++                  || close (fd) != 0
++                  || stat (file, &st1) != 0
++                  || st0.st_atime != st1.st_atime)
++                status |= 64;
++            }
++            return status;]])],
++       [gl_cv_header_working_fcntl_h=yes],
++       [case $? in #(
++        32) gl_cv_header_working_fcntl_h='no (bad O_NOFOLLOW)';; #(
++        64) gl_cv_header_working_fcntl_h='no (bad O_NOATIME)';; #(
++        96) gl_cv_header_working_fcntl_h='no (bad O_NOATIME, O_NOFOLLOW)';; #(
++         *) gl_cv_header_working_fcntl_h='no';;
++        esac],
++       [gl_cv_header_working_fcntl_h=cross-compiling])])
++
++  case $gl_cv_header_working_fcntl_h in #(
++  *O_NOATIME* | no | cross-compiling) ac_val=0;; #(
++  *) ac_val=1;;
++  esac
++  AC_DEFINE_UNQUOTED([HAVE_WORKING_O_NOATIME], [$ac_val],
++    [Define to 1 if O_NOATIME works.])
++
++  case $gl_cv_header_working_fcntl_h in #(
++  *O_NOFOLLOW* | no | cross-compiling) ac_val=0;; #(
++  *) ac_val=1;;
++  esac
++  AC_DEFINE_UNQUOTED([HAVE_WORKING_O_NOFOLLOW], [$ac_val],
++    [Define to 1 if O_NOFOLLOW works.])
++])
+diff --git a/m4/gettext.m4 b/m4/gettext.m4
+new file mode 100644
+index 0000000..f84e6a5
+--- /dev/null
++++ b/m4/gettext.m4
+@@ -0,0 +1,383 @@
++# gettext.m4 serial 63 (gettext-0.18)
++dnl Copyright (C) 1995-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Authors:
++dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
++dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2006, 2008-2010.
++
++dnl Macro to add for using GNU gettext.
++
++dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]).
++dnl INTLSYMBOL can be one of 'external', 'no-libtool', 'use-libtool'. The
++dnl    default (if it is not specified or empty) is 'no-libtool'.
++dnl    INTLSYMBOL should be 'external' for packages with no intl directory,
++dnl    and 'no-libtool' or 'use-libtool' for packages with an intl directory.
++dnl    If INTLSYMBOL is 'use-libtool', then a libtool library
++dnl    $(top_builddir)/intl/libintl.la will be created (shared and/or static,
++dnl    depending on --{enable,disable}-{shared,static} and on the presence of
++dnl    AM-DISABLE-SHARED). If INTLSYMBOL is 'no-libtool', a static library
++dnl    $(top_builddir)/intl/libintl.a will be created.
++dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext
++dnl    implementations (in libc or libintl) without the ngettext() function
++dnl    will be ignored.  If NEEDSYMBOL is specified and is
++dnl    'need-formatstring-macros', then GNU gettext implementations that don't
++dnl    support the ISO C 99 <inttypes.h> formatstring macros will be ignored.
++dnl INTLDIR is used to find the intl libraries.  If empty,
++dnl    the value `$(top_builddir)/intl/' is used.
++dnl
++dnl The result of the configuration is one of three cases:
++dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled
++dnl    and used.
++dnl    Catalog format: GNU --> install in $(datadir)
++dnl    Catalog extension: .mo after installation, .gmo in source tree
++dnl 2) GNU gettext has been found in the system's C library.
++dnl    Catalog format: GNU --> install in $(datadir)
++dnl    Catalog extension: .mo after installation, .gmo in source tree
++dnl 3) No internationalization, always use English msgid.
++dnl    Catalog format: none
++dnl    Catalog extension: none
++dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur.
++dnl The use of .gmo is historical (it was needed to avoid overwriting the
++dnl GNU format catalogs when building on a platform with an X/Open gettext),
++dnl but we keep it in order not to force irrelevant filename changes on the
++dnl maintainers.
++dnl
++AC_DEFUN([AM_GNU_GETTEXT],
++[
++  dnl Argument checking.
++  ifelse([$1], [], , [ifelse([$1], [external], , [ifelse([$1], [no-libtool], , [ifelse([$1], [use-libtool], ,
++    [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT
++])])])])])
++  ifelse(ifelse([$1], [], [old])[]ifelse([$1], [no-libtool], [old]), [old],
++    [AC_DIAGNOSE([obsolete], [Use of AM_GNU_GETTEXT without [external] argument is deprecated.])])
++  ifelse([$2], [], , [ifelse([$2], [need-ngettext], , [ifelse([$2], [need-formatstring-macros], ,
++    [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT
++])])])])
++  define([gt_included_intl],
++    ifelse([$1], [external],
++      ifdef([AM_GNU_GETTEXT_][INTL_SUBDIR], [yes], [no]),
++      [yes]))
++  define([gt_libtool_suffix_prefix], ifelse([$1], [use-libtool], [l], []))
++  gt_NEEDS_INIT
++  AM_GNU_GETTEXT_NEED([$2])
++
++  AC_REQUIRE([AM_PO_SUBDIRS])dnl
++  ifelse(gt_included_intl, yes, [
++    AC_REQUIRE([AM_INTL_SUBDIR])dnl
++  ])
++
++  dnl Prerequisites of AC_LIB_LINKFLAGS_BODY.
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  AC_REQUIRE([AC_LIB_RPATH])
++
++  dnl Sometimes libintl requires libiconv, so first search for libiconv.
++  dnl Ideally we would do this search only after the
++  dnl      if test "$USE_NLS" = "yes"; then
++  dnl        if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then
++  dnl tests. But if configure.in invokes AM_ICONV after AM_GNU_GETTEXT
++  dnl the configure script would need to contain the same shell code
++  dnl again, outside any 'if'. There are two solutions:
++  dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'.
++  dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE.
++  dnl Since AC_PROVIDE_IFELSE is only in autoconf >= 2.52 and not
++  dnl documented, we avoid it.
++  ifelse(gt_included_intl, yes, , [
++    AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY])
++  ])
++
++  dnl Sometimes, on MacOS X, libintl requires linking with CoreFoundation.
++  gt_INTL_MACOSX
++
++  dnl Set USE_NLS.
++  AC_REQUIRE([AM_NLS])
++
++  ifelse(gt_included_intl, yes, [
++    BUILD_INCLUDED_LIBINTL=no
++    USE_INCLUDED_LIBINTL=no
++  ])
++  LIBINTL=
++  LTLIBINTL=
++  POSUB=
++
++  dnl Add a version number to the cache macros.
++  case " $gt_needs " in
++    *" need-formatstring-macros "*) gt_api_version=3 ;;
++    *" need-ngettext "*) gt_api_version=2 ;;
++    *) gt_api_version=1 ;;
++  esac
++  gt_func_gnugettext_libc="gt_cv_func_gnugettext${gt_api_version}_libc"
++  gt_func_gnugettext_libintl="gt_cv_func_gnugettext${gt_api_version}_libintl"
++
++  dnl If we use NLS figure out what method
++  if test "$USE_NLS" = "yes"; then
++    gt_use_preinstalled_gnugettext=no
++    ifelse(gt_included_intl, yes, [
++      AC_MSG_CHECKING([whether included gettext is requested])
++      AC_ARG_WITH([included-gettext],
++        [  --with-included-gettext use the GNU gettext library included here],
++        nls_cv_force_use_gnu_gettext=$withval,
++        nls_cv_force_use_gnu_gettext=no)
++      AC_MSG_RESULT([$nls_cv_force_use_gnu_gettext])
++
++      nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
++      if test "$nls_cv_force_use_gnu_gettext" != "yes"; then
++    ])
++        dnl User does not insist on using GNU NLS library.  Figure out what
++        dnl to use.  If GNU gettext is available we use this.  Else we have
++        dnl to fall back to GNU NLS library.
++
++        if test $gt_api_version -ge 3; then
++          gt_revision_test_code='
++#ifndef __GNU_GETTEXT_SUPPORTED_REVISION
++#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1)
++#endif
++changequote(,)dnl
++typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1];
++changequote([,])dnl
++'
++        else
++          gt_revision_test_code=
++        fi
++        if test $gt_api_version -ge 2; then
++          gt_expression_test_code=' + * ngettext ("", "", 0)'
++        else
++          gt_expression_test_code=
++        fi
++
++        AC_CACHE_CHECK([for GNU gettext in libc], [$gt_func_gnugettext_libc],
++         [AC_TRY_LINK([#include <libintl.h>
++$gt_revision_test_code
++extern int _nl_msg_cat_cntr;
++extern int *_nl_domain_bindings;],
++            [bindtextdomain ("", "");
++return * gettext ("")$gt_expression_test_code + _nl_msg_cat_cntr + *_nl_domain_bindings],
++            [eval "$gt_func_gnugettext_libc=yes"],
++            [eval "$gt_func_gnugettext_libc=no"])])
++
++        if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then
++          dnl Sometimes libintl requires libiconv, so first search for libiconv.
++          ifelse(gt_included_intl, yes, , [
++            AM_ICONV_LINK
++          ])
++          dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL
++          dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv])
++          dnl because that would add "-liconv" to LIBINTL and LTLIBINTL
++          dnl even if libiconv doesn't exist.
++          AC_LIB_LINKFLAGS_BODY([intl])
++          AC_CACHE_CHECK([for GNU gettext in libintl],
++            [$gt_func_gnugettext_libintl],
++           [gt_save_CPPFLAGS="$CPPFLAGS"
++            CPPFLAGS="$CPPFLAGS $INCINTL"
++            gt_save_LIBS="$LIBS"
++            LIBS="$LIBS $LIBINTL"
++            dnl Now see whether libintl exists and does not depend on libiconv.
++            AC_TRY_LINK([#include <libintl.h>
++$gt_revision_test_code
++extern int _nl_msg_cat_cntr;
++extern
++#ifdef __cplusplus
++"C"
++#endif
++const char *_nl_expand_alias (const char *);],
++              [bindtextdomain ("", "");
++return * gettext ("")$gt_expression_test_code + _nl_msg_cat_cntr + *_nl_expand_alias ("")],
++              [eval "$gt_func_gnugettext_libintl=yes"],
++              [eval "$gt_func_gnugettext_libintl=no"])
++            dnl Now see whether libintl exists and depends on libiconv.
++            if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" != yes; } && test -n "$LIBICONV"; then
++              LIBS="$LIBS $LIBICONV"
++              AC_TRY_LINK([#include <libintl.h>
++$gt_revision_test_code
++extern int _nl_msg_cat_cntr;
++extern
++#ifdef __cplusplus
++"C"
++#endif
++const char *_nl_expand_alias (const char *);],
++                [bindtextdomain ("", "");
++return * gettext ("")$gt_expression_test_code + _nl_msg_cat_cntr + *_nl_expand_alias ("")],
++               [LIBINTL="$LIBINTL $LIBICONV"
++                LTLIBINTL="$LTLIBINTL $LTLIBICONV"
++                eval "$gt_func_gnugettext_libintl=yes"
++               ])
++            fi
++            CPPFLAGS="$gt_save_CPPFLAGS"
++            LIBS="$gt_save_LIBS"])
++        fi
++
++        dnl If an already present or preinstalled GNU gettext() is found,
++        dnl use it.  But if this macro is used in GNU gettext, and GNU
++        dnl gettext is already preinstalled in libintl, we update this
++        dnl libintl.  (Cf. the install rule in intl/Makefile.in.)
++        if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \
++           || { { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; } \
++                && test "$PACKAGE" != gettext-runtime \
++                && test "$PACKAGE" != gettext-tools; }; then
++          gt_use_preinstalled_gnugettext=yes
++        else
++          dnl Reset the values set by searching for libintl.
++          LIBINTL=
++          LTLIBINTL=
++          INCINTL=
++        fi
++
++    ifelse(gt_included_intl, yes, [
++        if test "$gt_use_preinstalled_gnugettext" != "yes"; then
++          dnl GNU gettext is not found in the C library.
++          dnl Fall back on included GNU gettext library.
++          nls_cv_use_gnu_gettext=yes
++        fi
++      fi
++
++      if test "$nls_cv_use_gnu_gettext" = "yes"; then
++        dnl Mark actions used to generate GNU NLS library.
++        BUILD_INCLUDED_LIBINTL=yes
++        USE_INCLUDED_LIBINTL=yes
++        LIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LIBICONV $LIBTHREAD"
++        LTLIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LTLIBICONV $LTLIBTHREAD"
++        LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'`
++      fi
++
++      CATOBJEXT=
++      if test "$gt_use_preinstalled_gnugettext" = "yes" \
++         || test "$nls_cv_use_gnu_gettext" = "yes"; then
++        dnl Mark actions to use GNU gettext tools.
++        CATOBJEXT=.gmo
++      fi
++    ])
++
++    if test -n "$INTL_MACOSX_LIBS"; then
++      if test "$gt_use_preinstalled_gnugettext" = "yes" \
++         || test "$nls_cv_use_gnu_gettext" = "yes"; then
++        dnl Some extra flags are needed during linking.
++        LIBINTL="$LIBINTL $INTL_MACOSX_LIBS"
++        LTLIBINTL="$LTLIBINTL $INTL_MACOSX_LIBS"
++      fi
++    fi
++
++    if test "$gt_use_preinstalled_gnugettext" = "yes" \
++       || test "$nls_cv_use_gnu_gettext" = "yes"; then
++      AC_DEFINE([ENABLE_NLS], [1],
++        [Define to 1 if translation of program messages to the user's native language
++   is requested.])
++    else
++      USE_NLS=no
++    fi
++  fi
++
++  AC_MSG_CHECKING([whether to use NLS])
++  AC_MSG_RESULT([$USE_NLS])
++  if test "$USE_NLS" = "yes"; then
++    AC_MSG_CHECKING([where the gettext function comes from])
++    if test "$gt_use_preinstalled_gnugettext" = "yes"; then
++      if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then
++        gt_source="external libintl"
++      else
++        gt_source="libc"
++      fi
++    else
++      gt_source="included intl directory"
++    fi
++    AC_MSG_RESULT([$gt_source])
++  fi
++
++  if test "$USE_NLS" = "yes"; then
++
++    if test "$gt_use_preinstalled_gnugettext" = "yes"; then
++      if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then
++        AC_MSG_CHECKING([how to link with libintl])
++        AC_MSG_RESULT([$LIBINTL])
++        AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL])
++      fi
++
++      dnl For backward compatibility. Some packages may be using this.
++      AC_DEFINE([HAVE_GETTEXT], [1],
++       [Define if the GNU gettext() function is already present or preinstalled.])
++      AC_DEFINE([HAVE_DCGETTEXT], [1],
++       [Define if the GNU dcgettext() function is already present or preinstalled.])
++    fi
++
++    dnl We need to process the po/ directory.
++    POSUB=po
++  fi
++
++  ifelse(gt_included_intl, yes, [
++    dnl If this is used in GNU gettext we have to set BUILD_INCLUDED_LIBINTL
++    dnl to 'yes' because some of the testsuite requires it.
++    if test "$PACKAGE" = gettext-runtime || test "$PACKAGE" = gettext-tools; then
++      BUILD_INCLUDED_LIBINTL=yes
++    fi
++
++    dnl Make all variables we use known to autoconf.
++    AC_SUBST([BUILD_INCLUDED_LIBINTL])
++    AC_SUBST([USE_INCLUDED_LIBINTL])
++    AC_SUBST([CATOBJEXT])
++
++    dnl For backward compatibility. Some configure.ins may be using this.
++    nls_cv_header_intl=
++    nls_cv_header_libgt=
++
++    dnl For backward compatibility. Some Makefiles may be using this.
++    DATADIRNAME=share
++    AC_SUBST([DATADIRNAME])
++
++    dnl For backward compatibility. Some Makefiles may be using this.
++    INSTOBJEXT=.mo
++    AC_SUBST([INSTOBJEXT])
++
++    dnl For backward compatibility. Some Makefiles may be using this.
++    GENCAT=gencat
++    AC_SUBST([GENCAT])
++
++    dnl For backward compatibility. Some Makefiles may be using this.
++    INTLOBJS=
++    if test "$USE_INCLUDED_LIBINTL" = yes; then
++      INTLOBJS="\$(GETTOBJS)"
++    fi
++    AC_SUBST([INTLOBJS])
++
++    dnl Enable libtool support if the surrounding package wishes it.
++    INTL_LIBTOOL_SUFFIX_PREFIX=gt_libtool_suffix_prefix
++    AC_SUBST([INTL_LIBTOOL_SUFFIX_PREFIX])
++  ])
++
++  dnl For backward compatibility. Some Makefiles may be using this.
++  INTLLIBS="$LIBINTL"
++  AC_SUBST([INTLLIBS])
++
++  dnl Make all documented variables known to autoconf.
++  AC_SUBST([LIBINTL])
++  AC_SUBST([LTLIBINTL])
++  AC_SUBST([POSUB])
++])
++
++
++dnl gt_NEEDS_INIT ensures that the gt_needs variable is initialized.
++m4_define([gt_NEEDS_INIT],
++[
++  m4_divert_text([DEFAULTS], [gt_needs=])
++  m4_define([gt_NEEDS_INIT], [])
++])
++
++
++dnl Usage: AM_GNU_GETTEXT_NEED([NEEDSYMBOL])
++AC_DEFUN([AM_GNU_GETTEXT_NEED],
++[
++  m4_divert_text([INIT_PREPARE], [gt_needs="$gt_needs $1"])
++])
++
++
++dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version])
++AC_DEFUN([AM_GNU_GETTEXT_VERSION], [])
+diff --git a/m4/glibc2.m4 b/m4/glibc2.m4
+new file mode 100644
+index 0000000..f148c12
+--- /dev/null
++++ b/m4/glibc2.m4
+@@ -0,0 +1,30 @@
++# glibc2.m4 serial 2
++dnl Copyright (C) 2000-2002, 2004, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++# Test for the GNU C Library, version 2.0 or newer.
++# From Bruno Haible.
++
++AC_DEFUN([gt_GLIBC2],
++  [
++    AC_CACHE_CHECK([whether we are using the GNU C Library 2 or newer],
++      [ac_cv_gnu_library_2],
++      [AC_EGREP_CPP([Lucky GNU user],
++        [
++#include <features.h>
++#ifdef __GNU_LIBRARY__
++ #if (__GLIBC__ >= 2)
++  Lucky GNU user
++ #endif
++#endif
++        ],
++        [ac_cv_gnu_library_2=yes],
++        [ac_cv_gnu_library_2=no])
++      ]
++    )
++    AC_SUBST([GLIBC2])
++    GLIBC2="$ac_cv_gnu_library_2"
++  ]
++)
+diff --git a/m4/glibc21.m4 b/m4/glibc21.m4
+new file mode 100644
+index 0000000..68ada9d
+--- /dev/null
++++ b/m4/glibc21.m4
+@@ -0,0 +1,30 @@
++# glibc21.m4 serial 4
++dnl Copyright (C) 2000-2002, 2004, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++# Test for the GNU C Library, version 2.1 or newer.
++# From Bruno Haible.
++
++AC_DEFUN([gl_GLIBC21],
++  [
++    AC_CACHE_CHECK([whether we are using the GNU C Library 2.1 or newer],
++      [ac_cv_gnu_library_2_1],
++      [AC_EGREP_CPP([Lucky GNU user],
++        [
++#include <features.h>
++#ifdef __GNU_LIBRARY__
++ #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2)
++  Lucky GNU user
++ #endif
++#endif
++        ],
++        [ac_cv_gnu_library_2_1=yes],
++        [ac_cv_gnu_library_2_1=no])
++      ]
++    )
++    AC_SUBST([GLIBC21])
++    GLIBC21="$ac_cv_gnu_library_2_1"
++  ]
++)
+diff --git a/m4/iconv.m4 b/m4/iconv.m4
+new file mode 100644
+index 0000000..e2041b9
+--- /dev/null
++++ b/m4/iconv.m4
+@@ -0,0 +1,214 @@
++# iconv.m4 serial 11 (gettext-0.18.1)
++dnl Copyright (C) 2000-2002, 2007-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_DEFUN([AM_ICONV_LINKFLAGS_BODY],
++[
++  dnl Prerequisites of AC_LIB_LINKFLAGS_BODY.
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  AC_REQUIRE([AC_LIB_RPATH])
++
++  dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV
++  dnl accordingly.
++  AC_LIB_LINKFLAGS_BODY([iconv])
++])
++
++AC_DEFUN([AM_ICONV_LINK],
++[
++  dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
++  dnl those with the standalone portable GNU libiconv installed).
++  AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
++
++  dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV
++  dnl accordingly.
++  AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY])
++
++  dnl Add $INCICONV to CPPFLAGS before performing the following checks,
++  dnl because if the user has installed libiconv and not disabled its use
++  dnl via --without-libiconv-prefix, he wants to use it. The first
++  dnl AC_TRY_LINK will then fail, the second AC_TRY_LINK will succeed.
++  am_save_CPPFLAGS="$CPPFLAGS"
++  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV])
++
++  AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [
++    am_cv_func_iconv="no, consider installing GNU libiconv"
++    am_cv_lib_iconv=no
++    AC_TRY_LINK([#include <stdlib.h>
++#include <iconv.h>],
++      [iconv_t cd = iconv_open("","");
++       iconv(cd,NULL,NULL,NULL,NULL);
++       iconv_close(cd);],
++      [am_cv_func_iconv=yes])
++    if test "$am_cv_func_iconv" != yes; then
++      am_save_LIBS="$LIBS"
++      LIBS="$LIBS $LIBICONV"
++      AC_TRY_LINK([#include <stdlib.h>
++#include <iconv.h>],
++        [iconv_t cd = iconv_open("","");
++         iconv(cd,NULL,NULL,NULL,NULL);
++         iconv_close(cd);],
++        [am_cv_lib_iconv=yes]
++        [am_cv_func_iconv=yes])
++      LIBS="$am_save_LIBS"
++    fi
++  ])
++  if test "$am_cv_func_iconv" = yes; then
++    AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [
++      dnl This tests against bugs in AIX 5.1, HP-UX 11.11, Solaris 10.
++      am_save_LIBS="$LIBS"
++      if test $am_cv_lib_iconv = yes; then
++        LIBS="$LIBS $LIBICONV"
++      fi
++      AC_TRY_RUN([
++#include <iconv.h>
++#include <string.h>
++int main ()
++{
++  /* Test against AIX 5.1 bug: Failures are not distinguishable from successful
++     returns.  */
++  {
++    iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8");
++    if (cd_utf8_to_88591 != (iconv_t)(-1))
++      {
++        static const char input[] = "\342\202\254"; /* EURO SIGN */
++        char buf[10];
++        const char *inptr = input;
++        size_t inbytesleft = strlen (input);
++        char *outptr = buf;
++        size_t outbytesleft = sizeof (buf);
++        size_t res = iconv (cd_utf8_to_88591,
++                            (char **) &inptr, &inbytesleft,
++                            &outptr, &outbytesleft);
++        if (res == 0)
++          return 1;
++      }
++  }
++  /* Test against Solaris 10 bug: Failures are not distinguishable from
++     successful returns.  */
++  {
++    iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646");
++    if (cd_ascii_to_88591 != (iconv_t)(-1))
++      {
++        static const char input[] = "\263";
++        char buf[10];
++        const char *inptr = input;
++        size_t inbytesleft = strlen (input);
++        char *outptr = buf;
++        size_t outbytesleft = sizeof (buf);
++        size_t res = iconv (cd_ascii_to_88591,
++                            (char **) &inptr, &inbytesleft,
++                            &outptr, &outbytesleft);
++        if (res == 0)
++          return 1;
++      }
++  }
++#if 0 /* This bug could be worked around by the caller.  */
++  /* Test against HP-UX 11.11 bug: Positive return value instead of 0.  */
++  {
++    iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591");
++    if (cd_88591_to_utf8 != (iconv_t)(-1))
++      {
++        static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
++        char buf[50];
++        const char *inptr = input;
++        size_t inbytesleft = strlen (input);
++        char *outptr = buf;
++        size_t outbytesleft = sizeof (buf);
++        size_t res = iconv (cd_88591_to_utf8,
++                            (char **) &inptr, &inbytesleft,
++                            &outptr, &outbytesleft);
++        if ((int)res > 0)
++          return 1;
++      }
++  }
++#endif
++  /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is
++     provided.  */
++  if (/* Try standardized names.  */
++      iconv_open ("UTF-8", "EUC-JP") == (iconv_t)(-1)
++      /* Try IRIX, OSF/1 names.  */
++      && iconv_open ("UTF-8", "eucJP") == (iconv_t)(-1)
++      /* Try AIX names.  */
++      && iconv_open ("UTF-8", "IBM-eucJP") == (iconv_t)(-1)
++      /* Try HP-UX names.  */
++      && iconv_open ("utf8", "eucJP") == (iconv_t)(-1))
++    return 1;
++  return 0;
++}], [am_cv_func_iconv_works=yes], [am_cv_func_iconv_works=no],
++        [case "$host_os" in
++           aix* | hpux*) am_cv_func_iconv_works="guessing no" ;;
++           *)            am_cv_func_iconv_works="guessing yes" ;;
++         esac])
++      LIBS="$am_save_LIBS"
++    ])
++    case "$am_cv_func_iconv_works" in
++      *no) am_func_iconv=no am_cv_lib_iconv=no ;;
++      *)   am_func_iconv=yes ;;
++    esac
++  else
++    am_func_iconv=no am_cv_lib_iconv=no
++  fi
++  if test "$am_func_iconv" = yes; then
++    AC_DEFINE([HAVE_ICONV], [1],
++      [Define if you have the iconv() function and it works.])
++  fi
++  if test "$am_cv_lib_iconv" = yes; then
++    AC_MSG_CHECKING([how to link with libiconv])
++    AC_MSG_RESULT([$LIBICONV])
++  else
++    dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV
++    dnl either.
++    CPPFLAGS="$am_save_CPPFLAGS"
++    LIBICONV=
++    LTLIBICONV=
++  fi
++  AC_SUBST([LIBICONV])
++  AC_SUBST([LTLIBICONV])
++])
++
++dnl Define AM_ICONV using AC_DEFUN_ONCE for Autoconf >= 2.64, in order to
++dnl avoid warnings like
++dnl "warning: AC_REQUIRE: `AM_ICONV' was expanded before it was required".
++dnl This is tricky because of the way 'aclocal' is implemented:
++dnl - It requires defining an auxiliary macro whose name ends in AC_DEFUN.
++dnl   Otherwise aclocal's initial scan pass would miss the macro definition.
++dnl - It requires a line break inside the AC_DEFUN_ONCE and AC_DEFUN expansions.
++dnl   Otherwise aclocal would emit many "Use of uninitialized value $1"
++dnl   warnings.
++m4_define([gl_iconv_AC_DEFUN],
++  m4_version_prereq([2.64],
++    [[AC_DEFUN_ONCE(
++        [$1], [$2])]],
++    [[AC_DEFUN(
++        [$1], [$2])]]))
++gl_iconv_AC_DEFUN([AM_ICONV],
++[
++  AM_ICONV_LINK
++  if test "$am_cv_func_iconv" = yes; then
++    AC_MSG_CHECKING([for iconv declaration])
++    AC_CACHE_VAL([am_cv_proto_iconv], [
++      AC_TRY_COMPILE([
++#include <stdlib.h>
++#include <iconv.h>
++extern
++#ifdef __cplusplus
++"C"
++#endif
++#if defined(__STDC__) || defined(__cplusplus)
++size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
++#else
++size_t iconv();
++#endif
++], [], [am_cv_proto_iconv_arg1=""], [am_cv_proto_iconv_arg1="const"])
++      am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
++    am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
++    AC_MSG_RESULT([
++         $am_cv_proto_iconv])
++    AC_DEFINE_UNQUOTED([ICONV_CONST], [$am_cv_proto_iconv_arg1],
++      [Define as const if the declaration of iconv() needs const.])
++  fi
++])
+diff --git a/m4/intdiv0.m4 b/m4/intdiv0.m4
+new file mode 100644
+index 0000000..289c4df
+--- /dev/null
++++ b/m4/intdiv0.m4
+@@ -0,0 +1,84 @@
++# intdiv0.m4 serial 3 (gettext-0.18)
++dnl Copyright (C) 2002, 2007-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_DEFUN([gt_INTDIV0],
++[
++  AC_REQUIRE([AC_PROG_CC])dnl
++  AC_REQUIRE([AC_CANONICAL_HOST])dnl
++
++  AC_CACHE_CHECK([whether integer division by zero raises SIGFPE],
++    gt_cv_int_divbyzero_sigfpe,
++    [
++      gt_cv_int_divbyzero_sigfpe=
++changequote(,)dnl
++      case "$host_os" in
++        macos* | darwin[6-9]* | darwin[1-9][0-9]*)
++          # On MacOS X 10.2 or newer, just assume the same as when cross-
++          # compiling. If we were to perform the real test, 1 Crash Report
++          # dialog window would pop up.
++          case "$host_cpu" in
++            i[34567]86 | x86_64)
++              gt_cv_int_divbyzero_sigfpe="guessing yes" ;;
++          esac
++          ;;
++      esac
++changequote([,])dnl
++      if test -z "$gt_cv_int_divbyzero_sigfpe"; then
++        AC_TRY_RUN([
++#include <stdlib.h>
++#include <signal.h>
++
++static void
++sigfpe_handler (int sig)
++{
++  /* Exit with code 0 if SIGFPE, with code 1 if any other signal.  */
++  exit (sig != SIGFPE);
++}
++
++int x = 1;
++int y = 0;
++int z;
++int nan;
++
++int main ()
++{
++  signal (SIGFPE, sigfpe_handler);
++/* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP.  */
++#if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP)
++  signal (SIGTRAP, sigfpe_handler);
++#endif
++/* Linux/SPARC yields signal SIGILL.  */
++#if defined (__sparc__) && defined (__linux__)
++  signal (SIGILL, sigfpe_handler);
++#endif
++
++  z = x / y;
++  nan = y / y;
++  exit (1);
++}
++], [gt_cv_int_divbyzero_sigfpe=yes], [gt_cv_int_divbyzero_sigfpe=no],
++          [
++            # Guess based on the CPU.
++changequote(,)dnl
++            case "$host_cpu" in
++              alpha* | i[34567]86 | x86_64 | m68k | s390*)
++                gt_cv_int_divbyzero_sigfpe="guessing yes";;
++              *)
++                gt_cv_int_divbyzero_sigfpe="guessing no";;
++            esac
++changequote([,])dnl
++          ])
++      fi
++    ])
++  case "$gt_cv_int_divbyzero_sigfpe" in
++    *yes) value=1;;
++    *) value=0;;
++  esac
++  AC_DEFINE_UNQUOTED([INTDIV0_RAISES_SIGFPE], [$value],
++    [Define if integer division by zero raises signal SIGFPE.])
++])
+diff --git a/m4/intl.m4 b/m4/intl.m4
+new file mode 100644
+index 0000000..335b23c
+--- /dev/null
++++ b/m4/intl.m4
+@@ -0,0 +1,294 @@
++# intl.m4 serial 17 (gettext-0.18)
++dnl Copyright (C) 1995-2009 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Authors:
++dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
++dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2009.
++
++AC_PREREQ([2.52])
++
++dnl Checks for all prerequisites of the intl subdirectory,
++dnl except for INTL_LIBTOOL_SUFFIX_PREFIX (and possibly LIBTOOL), INTLOBJS,
++dnl            USE_INCLUDED_LIBINTL, BUILD_INCLUDED_LIBINTL.
++AC_DEFUN([AM_INTL_SUBDIR],
++[
++  AC_REQUIRE([AC_PROG_INSTALL])dnl
++  AC_REQUIRE([AM_PROG_MKDIR_P])dnl defined by automake
++  AC_REQUIRE([AC_PROG_CC])dnl
++  AC_REQUIRE([AC_CANONICAL_HOST])dnl
++  AC_REQUIRE([gt_GLIBC2])dnl
++  AC_REQUIRE([AC_PROG_RANLIB])dnl
++  AC_REQUIRE([gl_VISIBILITY])dnl
++  AC_REQUIRE([gt_INTL_SUBDIR_CORE])dnl
++  AC_REQUIRE([AC_TYPE_LONG_LONG_INT])dnl
++  AC_REQUIRE([gt_TYPE_WCHAR_T])dnl
++  AC_REQUIRE([gt_TYPE_WINT_T])dnl
++  AC_REQUIRE([gl_AC_HEADER_INTTYPES_H])
++  AC_REQUIRE([gt_TYPE_INTMAX_T])
++  AC_REQUIRE([gt_PRINTF_POSIX])
++  AC_REQUIRE([gl_GLIBC21])dnl
++  AC_REQUIRE([gl_XSIZE])dnl
++  AC_REQUIRE([gl_FCNTL_O_FLAGS])dnl
++  AC_REQUIRE([gt_INTL_MACOSX])dnl
++
++  dnl Support for automake's --enable-silent-rules.
++  case "$enable_silent_rules" in
++    yes) INTL_DEFAULT_VERBOSITY=0;;
++    no)  INTL_DEFAULT_VERBOSITY=1;;
++    *)   INTL_DEFAULT_VERBOSITY=1;;
++  esac
++  AC_SUBST([INTL_DEFAULT_VERBOSITY])
++
++  AC_CHECK_TYPE([ptrdiff_t], ,
++    [AC_DEFINE([ptrdiff_t], [long],
++       [Define as the type of the result of subtracting two pointers, if the system doesn't define it.])
++    ])
++  AC_CHECK_HEADERS([stddef.h stdlib.h string.h])
++  AC_CHECK_FUNCS([asprintf fwprintf newlocale putenv setenv setlocale \
++    snprintf strnlen wcslen wcsnlen mbrtowc wcrtomb])
++
++  dnl Use the _snprintf function only if it is declared (because on NetBSD it
++  dnl is defined as a weak alias of snprintf; we prefer to use the latter).
++  gt_CHECK_DECL(_snprintf, [#include <stdio.h>])
++  gt_CHECK_DECL(_snwprintf, [#include <stdio.h>])
++
++  dnl Use the *_unlocked functions only if they are declared.
++  dnl (because some of them were defined without being declared in Solaris
++  dnl 2.5.1 but were removed in Solaris 2.6, whereas we want binaries built
++  dnl on Solaris 2.5.1 to run on Solaris 2.6).
++  dnl Don't use AC_CHECK_DECLS because it isn't supported in autoconf-2.13.
++  gt_CHECK_DECL(getc_unlocked, [#include <stdio.h>])
++
++  case $gt_cv_func_printf_posix in
++    *yes) HAVE_POSIX_PRINTF=1 ;;
++    *) HAVE_POSIX_PRINTF=0 ;;
++  esac
++  AC_SUBST([HAVE_POSIX_PRINTF])
++  if test "$ac_cv_func_asprintf" = yes; then
++    HAVE_ASPRINTF=1
++  else
++    HAVE_ASPRINTF=0
++  fi
++  AC_SUBST([HAVE_ASPRINTF])
++  if test "$ac_cv_func_snprintf" = yes; then
++    HAVE_SNPRINTF=1
++  else
++    HAVE_SNPRINTF=0
++  fi
++  AC_SUBST([HAVE_SNPRINTF])
++  if test "$ac_cv_func_newlocale" = yes; then
++    HAVE_NEWLOCALE=1
++  else
++    HAVE_NEWLOCALE=0
++  fi
++  AC_SUBST([HAVE_NEWLOCALE])
++  if test "$ac_cv_func_wprintf" = yes; then
++    HAVE_WPRINTF=1
++  else
++    HAVE_WPRINTF=0
++  fi
++  AC_SUBST([HAVE_WPRINTF])
++
++  AM_LANGINFO_CODESET
++  gt_LC_MESSAGES
++
++  dnl Compilation on mingw and Cygwin needs special Makefile rules, because
++  dnl 1. when we install a shared library, we must arrange to export
++  dnl    auxiliary pointer variables for every exported variable,
++  dnl 2. when we install a shared library and a static library simultaneously,
++  dnl    the include file specifies __declspec(dllimport) and therefore we
++  dnl    must arrange to define the auxiliary pointer variables for the
++  dnl    exported variables _also_ in the static library.
++  if test "$enable_shared" = yes; then
++    case "$host_os" in
++      mingw* | cygwin*) is_woe32dll=yes ;;
++      *) is_woe32dll=no ;;
++    esac
++  else
++    is_woe32dll=no
++  fi
++  WOE32DLL=$is_woe32dll
++  AC_SUBST([WOE32DLL])
++
++  dnl On mingw and Cygwin, we can activate special Makefile rules which add
++  dnl version information to the shared libraries and executables.
++  case "$host_os" in
++    mingw* | cygwin*) is_woe32=yes ;;
++    *) is_woe32=no ;;
++  esac
++  WOE32=$is_woe32
++  AC_SUBST([WOE32])
++  if test $WOE32 = yes; then
++    dnl Check for a program that compiles Windows resource files.
++    AC_CHECK_TOOL([WINDRES], [windres])
++  fi
++
++  dnl Determine whether when creating a library, "-lc" should be passed to
++  dnl libtool or not. On many platforms, it is required for the libtool option
++  dnl -no-undefined to work. On HP-UX, however, the -lc - stored by libtool
++  dnl in the *.la files - makes it impossible to create multithreaded programs,
++  dnl because libtool also reorders the -lc to come before the -pthread, and
++  dnl this disables pthread_create() <http://docs.hp.com/en/1896/pthreads.html>.
++  case "$host_os" in
++    hpux*) LTLIBC="" ;;
++    *)     LTLIBC="-lc" ;;
++  esac
++  AC_SUBST([LTLIBC])
++
++  dnl Rename some macros and functions used for locking.
++  AH_BOTTOM([
++#define __libc_lock_t                   gl_lock_t
++#define __libc_lock_define              gl_lock_define
++#define __libc_lock_define_initialized  gl_lock_define_initialized
++#define __libc_lock_init                gl_lock_init
++#define __libc_lock_lock                gl_lock_lock
++#define __libc_lock_unlock              gl_lock_unlock
++#define __libc_lock_recursive_t                   gl_recursive_lock_t
++#define __libc_lock_define_recursive              gl_recursive_lock_define
++#define __libc_lock_define_initialized_recursive  gl_recursive_lock_define_initialized
++#define __libc_lock_init_recursive                gl_recursive_lock_init
++#define __libc_lock_lock_recursive                gl_recursive_lock_lock
++#define __libc_lock_unlock_recursive              gl_recursive_lock_unlock
++#define glthread_in_use  libintl_thread_in_use
++#define glthread_lock_init_func     libintl_lock_init_func
++#define glthread_lock_lock_func     libintl_lock_lock_func
++#define glthread_lock_unlock_func   libintl_lock_unlock_func
++#define glthread_lock_destroy_func  libintl_lock_destroy_func
++#define glthread_rwlock_init_multithreaded     libintl_rwlock_init_multithreaded
++#define glthread_rwlock_init_func              libintl_rwlock_init_func
++#define glthread_rwlock_rdlock_multithreaded   libintl_rwlock_rdlock_multithreaded
++#define glthread_rwlock_rdlock_func            libintl_rwlock_rdlock_func
++#define glthread_rwlock_wrlock_multithreaded   libintl_rwlock_wrlock_multithreaded
++#define glthread_rwlock_wrlock_func            libintl_rwlock_wrlock_func
++#define glthread_rwlock_unlock_multithreaded   libintl_rwlock_unlock_multithreaded
++#define glthread_rwlock_unlock_func            libintl_rwlock_unlock_func
++#define glthread_rwlock_destroy_multithreaded  libintl_rwlock_destroy_multithreaded
++#define glthread_rwlock_destroy_func           libintl_rwlock_destroy_func
++#define glthread_recursive_lock_init_multithreaded     libintl_recursive_lock_init_multithreaded
++#define glthread_recursive_lock_init_func              libintl_recursive_lock_init_func
++#define glthread_recursive_lock_lock_multithreaded     libintl_recursive_lock_lock_multithreaded
++#define glthread_recursive_lock_lock_func              libintl_recursive_lock_lock_func
++#define glthread_recursive_lock_unlock_multithreaded   libintl_recursive_lock_unlock_multithreaded
++#define glthread_recursive_lock_unlock_func            libintl_recursive_lock_unlock_func
++#define glthread_recursive_lock_destroy_multithreaded  libintl_recursive_lock_destroy_multithreaded
++#define glthread_recursive_lock_destroy_func           libintl_recursive_lock_destroy_func
++#define glthread_once_func            libintl_once_func
++#define glthread_once_singlethreaded  libintl_once_singlethreaded
++#define glthread_once_multithreaded   libintl_once_multithreaded
++])
++])
++
++
++dnl Checks for the core files of the intl subdirectory:
++dnl   dcigettext.c
++dnl   eval-plural.h
++dnl   explodename.c
++dnl   finddomain.c
++dnl   gettextP.h
++dnl   gmo.h
++dnl   hash-string.h hash-string.c
++dnl   l10nflist.c
++dnl   libgnuintl.h.in (except the *printf stuff)
++dnl   loadinfo.h
++dnl   loadmsgcat.c
++dnl   localealias.c
++dnl   log.c
++dnl   plural-exp.h plural-exp.c
++dnl   plural.y
++dnl Used by libglocale.
++AC_DEFUN([gt_INTL_SUBDIR_CORE],
++[
++  AC_REQUIRE([AC_C_INLINE])dnl
++  AC_REQUIRE([AC_TYPE_SIZE_T])dnl
++  AC_REQUIRE([gl_AC_HEADER_STDINT_H])
++  AC_REQUIRE([AC_FUNC_ALLOCA])dnl
++  AC_REQUIRE([AC_FUNC_MMAP])dnl
++  AC_REQUIRE([gt_INTDIV0])dnl
++  AC_REQUIRE([gl_AC_TYPE_UINTMAX_T])dnl
++  AC_REQUIRE([gt_INTTYPES_PRI])dnl
++  AC_REQUIRE([gl_LOCK])dnl
++
++  AC_TRY_LINK(
++    [int foo (int a) { a = __builtin_expect (a, 10); return a == 10 ? 0 : 1; }],
++    [],
++    [AC_DEFINE([HAVE_BUILTIN_EXPECT], [1],
++       [Define to 1 if the compiler understands __builtin_expect.])])
++
++  AC_CHECK_HEADERS([argz.h inttypes.h limits.h unistd.h sys/param.h])
++  AC_CHECK_FUNCS([getcwd getegid geteuid getgid getuid mempcpy munmap \
++    stpcpy strcasecmp strdup strtoul tsearch uselocale argz_count \
++    argz_stringify argz_next __fsetlocking])
++
++  dnl Use the *_unlocked functions only if they are declared.
++  dnl (because some of them were defined without being declared in Solaris
++  dnl 2.5.1 but were removed in Solaris 2.6, whereas we want binaries built
++  dnl on Solaris 2.5.1 to run on Solaris 2.6).
++  dnl Don't use AC_CHECK_DECLS because it isn't supported in autoconf-2.13.
++  gt_CHECK_DECL([feof_unlocked], [#include <stdio.h>])
++  gt_CHECK_DECL([fgets_unlocked], [#include <stdio.h>])
++
++  AM_ICONV
++
++  dnl intl/plural.c is generated from intl/plural.y. It requires bison,
++  dnl because plural.y uses bison specific features. It requires at least
++  dnl bison-1.26 because earlier versions generate a plural.c that doesn't
++  dnl compile.
++  dnl bison is only needed for the maintainer (who touches plural.y). But in
++  dnl order to avoid separate Makefiles or --enable-maintainer-mode, we put
++  dnl the rule in general Makefile. Now, some people carelessly touch the
++  dnl files or have a broken "make" program, hence the plural.c rule will
++  dnl sometimes fire. To avoid an error, defines BISON to ":" if it is not
++  dnl present or too old.
++  AC_CHECK_PROGS([INTLBISON], [bison])
++  if test -z "$INTLBISON"; then
++    ac_verc_fail=yes
++  else
++    dnl Found it, now check the version.
++    AC_MSG_CHECKING([version of bison])
++changequote(<<,>>)dnl
++    ac_prog_version=`$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p'`
++    case $ac_prog_version in
++      '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;;
++      1.2[6-9]* | 1.[3-9][0-9]* | [2-9].*)
++changequote([,])dnl
++         ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;;
++      *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;;
++    esac
++    AC_MSG_RESULT([$ac_prog_version])
++  fi
++  if test $ac_verc_fail = yes; then
++    INTLBISON=:
++  fi
++])
++
++
++dnl gt_CHECK_DECL(FUNC, INCLUDES)
++dnl Check whether a function is declared.
++AC_DEFUN([gt_CHECK_DECL],
++[
++  AC_CACHE_CHECK([whether $1 is declared], [ac_cv_have_decl_$1],
++    [AC_TRY_COMPILE([$2], [
++#ifndef $1
++  char *p = (char *) $1;
++#endif
++], ac_cv_have_decl_$1=yes, ac_cv_have_decl_$1=no)])
++  if test $ac_cv_have_decl_$1 = yes; then
++    gt_value=1
++  else
++    gt_value=0
++  fi
++  AC_DEFINE_UNQUOTED([HAVE_DECL_]translit($1, [a-z], [A-Z]), [$gt_value],
++    [Define to 1 if you have the declaration of `$1', and to 0 if you don't.])
++])
+diff --git a/m4/intldir.m4 b/m4/intldir.m4
+new file mode 100644
+index 0000000..ebae76d
+--- /dev/null
++++ b/m4/intldir.m4
+@@ -0,0 +1,19 @@
++# intldir.m4 serial 2 (gettext-0.18)
++dnl Copyright (C) 2006, 2009-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++AC_PREREQ([2.52])
++
++dnl Tells the AM_GNU_GETTEXT macro to consider an intl/ directory.
++AC_DEFUN([AM_GNU_GETTEXT_INTL_SUBDIR], [])
+diff --git a/m4/intlmacosx.m4 b/m4/intlmacosx.m4
+new file mode 100644
+index 0000000..dd91025
+--- /dev/null
++++ b/m4/intlmacosx.m4
+@@ -0,0 +1,51 @@
++# intlmacosx.m4 serial 3 (gettext-0.18)
++dnl Copyright (C) 2004-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Checks for special options needed on MacOS X.
++dnl Defines INTL_MACOSX_LIBS.
++AC_DEFUN([gt_INTL_MACOSX],
++[
++  dnl Check for API introduced in MacOS X 10.2.
++  AC_CACHE_CHECK([for CFPreferencesCopyAppValue],
++    [gt_cv_func_CFPreferencesCopyAppValue],
++    [gt_save_LIBS="$LIBS"
++     LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation"
++     AC_TRY_LINK([#include <CoreFoundation/CFPreferences.h>],
++       [CFPreferencesCopyAppValue(NULL, NULL)],
++       [gt_cv_func_CFPreferencesCopyAppValue=yes],
++       [gt_cv_func_CFPreferencesCopyAppValue=no])
++     LIBS="$gt_save_LIBS"])
++  if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then
++    AC_DEFINE([HAVE_CFPREFERENCESCOPYAPPVALUE], [1],
++      [Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in the CoreFoundation framework.])
++  fi
++  dnl Check for API introduced in MacOS X 10.3.
++  AC_CACHE_CHECK([for CFLocaleCopyCurrent], [gt_cv_func_CFLocaleCopyCurrent],
++    [gt_save_LIBS="$LIBS"
++     LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation"
++     AC_TRY_LINK([#include <CoreFoundation/CFLocale.h>], [CFLocaleCopyCurrent();],
++       [gt_cv_func_CFLocaleCopyCurrent=yes],
++       [gt_cv_func_CFLocaleCopyCurrent=no])
++     LIBS="$gt_save_LIBS"])
++  if test $gt_cv_func_CFLocaleCopyCurrent = yes; then
++    AC_DEFINE([HAVE_CFLOCALECOPYCURRENT], [1],
++      [Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the CoreFoundation framework.])
++  fi
++  INTL_MACOSX_LIBS=
++  if test $gt_cv_func_CFPreferencesCopyAppValue = yes || test $gt_cv_func_CFLocaleCopyCurrent = yes; then
++    INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation"
++  fi
++  AC_SUBST([INTL_MACOSX_LIBS])
++])
+diff --git a/m4/intmax.m4 b/m4/intmax.m4
+new file mode 100644
+index 0000000..74aaaf5
+--- /dev/null
++++ b/m4/intmax.m4
+@@ -0,0 +1,33 @@
++# intmax.m4 serial 5 (gettext-0.18)
++dnl Copyright (C) 2002-2005, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++dnl Test whether the system has the 'intmax_t' type, but don't attempt to
++dnl find a replacement if it is lacking.
++
++AC_DEFUN([gt_TYPE_INTMAX_T],
++[
++  AC_REQUIRE([gl_AC_HEADER_INTTYPES_H])
++  AC_REQUIRE([gl_AC_HEADER_STDINT_H])
++  AC_CACHE_CHECK([for intmax_t], [gt_cv_c_intmax_t],
++    [AC_TRY_COMPILE([
++#include <stddef.h>
++#include <stdlib.h>
++#if HAVE_STDINT_H_WITH_UINTMAX
++#include <stdint.h>
++#endif
++#if HAVE_INTTYPES_H_WITH_UINTMAX
++#include <inttypes.h>
++#endif
++],     [intmax_t x = -1;
++        return !x;],
++       [gt_cv_c_intmax_t=yes],
++       [gt_cv_c_intmax_t=no])])
++  if test $gt_cv_c_intmax_t = yes; then
++    AC_DEFINE([HAVE_INTMAX_T], [1],
++      [Define if you have the 'intmax_t' type in <stdint.h> or <inttypes.h>.])
++  fi
++])
+diff --git a/m4/inttypes-pri.m4 b/m4/inttypes-pri.m4
+new file mode 100644
+index 0000000..718a4f4
+--- /dev/null
++++ b/m4/inttypes-pri.m4
+@@ -0,0 +1,36 @@
++# inttypes-pri.m4 serial 6 (gettext-0.18)
++dnl Copyright (C) 1997-2002, 2006, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_PREREQ([2.52])
++
++# Define PRI_MACROS_BROKEN if <inttypes.h> exists and defines the PRI*
++# macros to non-string values.  This is the case on AIX 4.3.3.
++
++AC_DEFUN([gt_INTTYPES_PRI],
++[
++  AC_CHECK_HEADERS([inttypes.h])
++  if test $ac_cv_header_inttypes_h = yes; then
++    AC_CACHE_CHECK([whether the inttypes.h PRIxNN macros are broken],
++      [gt_cv_inttypes_pri_broken],
++      [
++        AC_TRY_COMPILE([#include <inttypes.h>
++#ifdef PRId32
++char *p = PRId32;
++#endif
++], [], [gt_cv_inttypes_pri_broken=no], [gt_cv_inttypes_pri_broken=yes])
++      ])
++  fi
++  if test "$gt_cv_inttypes_pri_broken" = yes; then
++    AC_DEFINE_UNQUOTED([PRI_MACROS_BROKEN], [1],
++      [Define if <inttypes.h> exists and defines unusable PRI* macros.])
++    PRI_MACROS_BROKEN=1
++  else
++    PRI_MACROS_BROKEN=0
++  fi
++  AC_SUBST([PRI_MACROS_BROKEN])
++])
+diff --git a/m4/inttypes_h.m4 b/m4/inttypes_h.m4
+new file mode 100644
+index 0000000..782d77e
+--- /dev/null
++++ b/m4/inttypes_h.m4
+@@ -0,0 +1,26 @@
++# inttypes_h.m4 serial 9
++dnl Copyright (C) 1997-2004, 2006, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Paul Eggert.
++
++# Define HAVE_INTTYPES_H_WITH_UINTMAX if <inttypes.h> exists,
++# doesn't clash with <sys/types.h>, and declares uintmax_t.
++
++AC_DEFUN([gl_AC_HEADER_INTTYPES_H],
++[
++  AC_CACHE_CHECK([for inttypes.h], [gl_cv_header_inttypes_h],
++  [AC_TRY_COMPILE(
++    [#include <sys/types.h>
++#include <inttypes.h>],
++    [uintmax_t i = (uintmax_t) -1; return !i;],
++    [gl_cv_header_inttypes_h=yes],
++    [gl_cv_header_inttypes_h=no])])
++  if test $gl_cv_header_inttypes_h = yes; then
++    AC_DEFINE_UNQUOTED([HAVE_INTTYPES_H_WITH_UINTMAX], [1],
++      [Define if <inttypes.h> exists, doesn't clash with <sys/types.h>,
++       and declares uintmax_t. ])
++  fi
++])
+diff --git a/m4/lcmessage.m4 b/m4/lcmessage.m4
+new file mode 100644
+index 0000000..1a70543
+--- /dev/null
++++ b/m4/lcmessage.m4
+@@ -0,0 +1,31 @@
++# lcmessage.m4 serial 6 (gettext-0.18)
++dnl Copyright (C) 1995-2002, 2004-2005, 2008-2010 Free Software Foundation,
++dnl Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Authors:
++dnl   Ulrich Drepper <drepper@cygnus.com>, 1995.
++
++# Check whether LC_MESSAGES is available in <locale.h>.
++
++AC_DEFUN([gt_LC_MESSAGES],
++[
++  AC_CACHE_CHECK([for LC_MESSAGES], [gt_cv_val_LC_MESSAGES],
++    [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
++       [gt_cv_val_LC_MESSAGES=yes], [gt_cv_val_LC_MESSAGES=no])])
++  if test $gt_cv_val_LC_MESSAGES = yes; then
++    AC_DEFINE([HAVE_LC_MESSAGES], [1],
++      [Define if your <locale.h> file defines LC_MESSAGES.])
++  fi
++])
+diff --git a/m4/lib-ld.m4 b/m4/lib-ld.m4
+new file mode 100644
+index 0000000..ebb3052
+--- /dev/null
++++ b/m4/lib-ld.m4
+@@ -0,0 +1,110 @@
++# lib-ld.m4 serial 4 (gettext-0.18)
++dnl Copyright (C) 1996-2003, 2009-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl Subroutines of libtool.m4,
++dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision
++dnl with libtool.m4.
++
++dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no.
++AC_DEFUN([AC_LIB_PROG_LD_GNU],
++[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld],
++[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
++case `$LD -v 2>&1 </dev/null` in
++*GNU* | *'with BFD'*)
++  acl_cv_prog_gnu_ld=yes ;;
++*)
++  acl_cv_prog_gnu_ld=no ;;
++esac])
++with_gnu_ld=$acl_cv_prog_gnu_ld
++])
++
++dnl From libtool-1.4. Sets the variable LD.
++AC_DEFUN([AC_LIB_PROG_LD],
++[AC_ARG_WITH([gnu-ld],
++[  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
++test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
++AC_REQUIRE([AC_PROG_CC])dnl
++AC_REQUIRE([AC_CANONICAL_HOST])dnl
++# Prepare PATH_SEPARATOR.
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
++fi
++ac_prog=ld
++if test "$GCC" = yes; then
++  # Check if gcc -print-prog-name=ld gives a path.
++  AC_MSG_CHECKING([for ld used by GCC])
++  case $host in
++  *-*-mingw*)
++    # gcc leaves a trailing carriage return which upsets mingw
++    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
++  *)
++    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
++  esac
++  case $ac_prog in
++    # Accept absolute paths.
++    [[\\/]* | [A-Za-z]:[\\/]*)]
++      [re_direlt='/[^/][^/]*/\.\./']
++      # Canonicalize the path of ld
++      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
++      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
++        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
++      done
++      test -z "$LD" && LD="$ac_prog"
++      ;;
++  "")
++    # If it fails, then pretend we aren't using GCC.
++    ac_prog=ld
++    ;;
++  *)
++    # If it is relative, then search for the first ld in PATH.
++    with_gnu_ld=unknown
++    ;;
++  esac
++elif test "$with_gnu_ld" = yes; then
++  AC_MSG_CHECKING([for GNU ld])
++else
++  AC_MSG_CHECKING([for non-GNU ld])
++fi
++AC_CACHE_VAL([acl_cv_path_LD],
++[if test -z "$LD"; then
++  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
++  for ac_dir in $PATH; do
++    test -z "$ac_dir" && ac_dir=.
++    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
++      acl_cv_path_LD="$ac_dir/$ac_prog"
++      # Check to see if the program is GNU ld.  I'd rather use --version,
++      # but apparently some GNU ld's only accept -v.
++      # Break only if it was the GNU/non-GNU ld that we prefer.
++      case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in
++      *GNU* | *'with BFD'*)
++        test "$with_gnu_ld" != no && break ;;
++      *)
++        test "$with_gnu_ld" != yes && break ;;
++      esac
++    fi
++  done
++  IFS="$ac_save_ifs"
++else
++  acl_cv_path_LD="$LD" # Let the user override the test with a path.
++fi])
++LD="$acl_cv_path_LD"
++if test -n "$LD"; then
++  AC_MSG_RESULT([$LD])
++else
++  AC_MSG_RESULT([no])
++fi
++test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
++AC_LIB_PROG_LD_GNU
++])
+diff --git a/m4/lib-link.m4 b/m4/lib-link.m4
+new file mode 100644
+index 0000000..c73bd8e
+--- /dev/null
++++ b/m4/lib-link.m4
+@@ -0,0 +1,774 @@
++# lib-link.m4 serial 21 (gettext-0.18)
++dnl Copyright (C) 2001-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_PREREQ([2.54])
++
++dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
++dnl the libraries corresponding to explicit and implicit dependencies.
++dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
++dnl augments the CPPFLAGS variable.
++dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
++dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
++AC_DEFUN([AC_LIB_LINKFLAGS],
++[
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  AC_REQUIRE([AC_LIB_RPATH])
++  pushdef([Name],[translit([$1],[./-], [___])])
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
++    AC_LIB_LINKFLAGS_BODY([$1], [$2])
++    ac_cv_lib[]Name[]_libs="$LIB[]NAME"
++    ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
++    ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
++    ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"
++  ])
++  LIB[]NAME="$ac_cv_lib[]Name[]_libs"
++  LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
++  INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
++  LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"
++  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
++  AC_SUBST([LIB]NAME)
++  AC_SUBST([LTLIB]NAME)
++  AC_SUBST([LIB]NAME[_PREFIX])
++  dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
++  dnl results of this search when this library appears as a dependency.
++  HAVE_LIB[]NAME=yes
++  popdef([NAME])
++  popdef([Name])
++])
++
++dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode, [missing-message])
++dnl searches for libname and the libraries corresponding to explicit and
++dnl implicit dependencies, together with the specified include files and
++dnl the ability to compile and link the specified testcode. The missing-message
++dnl defaults to 'no' and may contain additional hints for the user.
++dnl If found, it sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME}
++dnl and LTLIB${NAME} variables and augments the CPPFLAGS variable, and
++dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
++dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
++dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
++dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
++AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
++[
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  AC_REQUIRE([AC_LIB_RPATH])
++  pushdef([Name],[translit([$1],[./-], [___])])
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++
++  dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
++  dnl accordingly.
++  AC_LIB_LINKFLAGS_BODY([$1], [$2])
++
++  dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
++  dnl because if the user has installed lib[]Name and not disabled its use
++  dnl via --without-lib[]Name-prefix, he wants to use it.
++  ac_save_CPPFLAGS="$CPPFLAGS"
++  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
++
++  AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
++    ac_save_LIBS="$LIBS"
++    dnl If $LIB[]NAME contains some -l options, add it to the end of LIBS,
++    dnl because these -l options might require -L options that are present in
++    dnl LIBS. -l options benefit only from the -L options listed before it.
++    dnl Otherwise, add it to the front of LIBS, because it may be a static
++    dnl library that depends on another static library that is present in LIBS.
++    dnl Static libraries benefit only from the static libraries listed after
++    dnl it.
++    case " $LIB[]NAME" in
++      *" -l"*) LIBS="$LIBS $LIB[]NAME" ;;
++      *)       LIBS="$LIB[]NAME $LIBS" ;;
++    esac
++    AC_TRY_LINK([$3], [$4],
++      [ac_cv_lib[]Name=yes],
++      [ac_cv_lib[]Name='m4_if([$5], [], [no], [[$5]])'])
++    LIBS="$ac_save_LIBS"
++  ])
++  if test "$ac_cv_lib[]Name" = yes; then
++    HAVE_LIB[]NAME=yes
++    AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the lib][$1 library.])
++    AC_MSG_CHECKING([how to link with lib[]$1])
++    AC_MSG_RESULT([$LIB[]NAME])
++  else
++    HAVE_LIB[]NAME=no
++    dnl If $LIB[]NAME didn't lead to a usable library, we don't need
++    dnl $INC[]NAME either.
++    CPPFLAGS="$ac_save_CPPFLAGS"
++    LIB[]NAME=
++    LTLIB[]NAME=
++    LIB[]NAME[]_PREFIX=
++  fi
++  AC_SUBST([HAVE_LIB]NAME)
++  AC_SUBST([LIB]NAME)
++  AC_SUBST([LTLIB]NAME)
++  AC_SUBST([LIB]NAME[_PREFIX])
++  popdef([NAME])
++  popdef([Name])
++])
++
++dnl Determine the platform dependent parameters needed to use rpath:
++dnl   acl_libext,
++dnl   acl_shlibext,
++dnl   acl_hardcode_libdir_flag_spec,
++dnl   acl_hardcode_libdir_separator,
++dnl   acl_hardcode_direct,
++dnl   acl_hardcode_minus_L.
++AC_DEFUN([AC_LIB_RPATH],
++[
++  dnl Tell automake >= 1.10 to complain if config.rpath is missing.
++  m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])])
++  AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
++  AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
++  AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
++  AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
++  AC_CACHE_CHECK([for shared library run path origin], [acl_cv_rpath], [
++    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
++    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
++    . ./conftest.sh
++    rm -f ./conftest.sh
++    acl_cv_rpath=done
++  ])
++  wl="$acl_cv_wl"
++  acl_libext="$acl_cv_libext"
++  acl_shlibext="$acl_cv_shlibext"
++  acl_libname_spec="$acl_cv_libname_spec"
++  acl_library_names_spec="$acl_cv_library_names_spec"
++  acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
++  acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
++  acl_hardcode_direct="$acl_cv_hardcode_direct"
++  acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
++  dnl Determine whether the user wants rpath handling at all.
++  AC_ARG_ENABLE([rpath],
++    [  --disable-rpath         do not hardcode runtime library paths],
++    :, enable_rpath=yes)
++])
++
++dnl AC_LIB_FROMPACKAGE(name, package)
++dnl declares that libname comes from the given package. The configure file
++dnl will then not have a --with-libname-prefix option but a
++dnl --with-package-prefix option. Several libraries can come from the same
++dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar
++dnl macro call that searches for libname.
++AC_DEFUN([AC_LIB_FROMPACKAGE],
++[
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  define([acl_frompackage_]NAME, [$2])
++  popdef([NAME])
++  pushdef([PACK],[$2])
++  pushdef([PACKUP],[translit(PACK,[abcdefghijklmnopqrstuvwxyz./-],
++                                  [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  define([acl_libsinpackage_]PACKUP,
++    m4_ifdef([acl_libsinpackage_]PACKUP, [acl_libsinpackage_]PACKUP[[, ]],)[lib$1])
++  popdef([PACKUP])
++  popdef([PACK])
++])
++
++dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
++dnl the libraries corresponding to explicit and implicit dependencies.
++dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
++dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found
++dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
++AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
++[
++  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])])
++  pushdef([PACKUP],[translit(PACK,[abcdefghijklmnopqrstuvwxyz./-],
++                                  [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])])
++  dnl Autoconf >= 2.61 supports dots in --with options.
++  pushdef([P_A_C_K],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[translit(PACK,[.],[_])],PACK)])
++  dnl By default, look in $includedir and $libdir.
++  use_additional=yes
++  AC_LIB_WITH_FINAL_PREFIX([
++    eval additional_includedir=\"$includedir\"
++    eval additional_libdir=\"$libdir\"
++  ])
++  AC_ARG_WITH(P_A_C_K[-prefix],
++[[  --with-]]P_A_C_K[[-prefix[=DIR]  search for ]PACKLIBS[ in DIR/include and DIR/lib
++  --without-]]P_A_C_K[[-prefix     don't search for ]PACKLIBS[ in includedir and libdir]],
++[
++    if test "X$withval" = "Xno"; then
++      use_additional=no
++    else
++      if test "X$withval" = "X"; then
++        AC_LIB_WITH_FINAL_PREFIX([
++          eval additional_includedir=\"$includedir\"
++          eval additional_libdir=\"$libdir\"
++        ])
++      else
++        additional_includedir="$withval/include"
++        additional_libdir="$withval/$acl_libdirstem"
++        if test "$acl_libdirstem2" != "$acl_libdirstem" \
++           && ! test -d "$withval/$acl_libdirstem"; then
++          additional_libdir="$withval/$acl_libdirstem2"
++        fi
++      fi
++    fi
++])
++  dnl Search the library and its dependencies in $additional_libdir and
++  dnl $LDFLAGS. Using breadth-first-seach.
++  LIB[]NAME=
++  LTLIB[]NAME=
++  INC[]NAME=
++  LIB[]NAME[]_PREFIX=
++  dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been
++  dnl computed. So it has to be reset here.
++  HAVE_LIB[]NAME=
++  rpathdirs=
++  ltrpathdirs=
++  names_already_handled=
++  names_next_round='$1 $2'
++  while test -n "$names_next_round"; do
++    names_this_round="$names_next_round"
++    names_next_round=
++    for name in $names_this_round; do
++      already_handled=
++      for n in $names_already_handled; do
++        if test "$n" = "$name"; then
++          already_handled=yes
++          break
++        fi
++      done
++      if test -z "$already_handled"; then
++        names_already_handled="$names_already_handled $name"
++        dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
++        dnl or AC_LIB_HAVE_LINKFLAGS call.
++        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
++        eval value=\"\$HAVE_LIB$uppername\"
++        if test -n "$value"; then
++          if test "$value" = yes; then
++            eval value=\"\$LIB$uppername\"
++            test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
++            eval value=\"\$LTLIB$uppername\"
++            test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
++          else
++            dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
++            dnl that this library doesn't exist. So just drop it.
++            :
++          fi
++        else
++          dnl Search the library lib$name in $additional_libdir and $LDFLAGS
++          dnl and the already constructed $LIBNAME/$LTLIBNAME.
++          found_dir=
++          found_la=
++          found_so=
++          found_a=
++          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
++          if test -n "$acl_shlibext"; then
++            shrext=".$acl_shlibext"             # typically: shrext=.so
++          else
++            shrext=
++          fi
++          if test $use_additional = yes; then
++            dir="$additional_libdir"
++            dnl The same code as in the loop below:
++            dnl First look for a shared library.
++            if test -n "$acl_shlibext"; then
++              if test -f "$dir/$libname$shrext"; then
++                found_dir="$dir"
++                found_so="$dir/$libname$shrext"
++              else
++                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
++                  ver=`(cd "$dir" && \
++                        for f in "$libname$shrext".*; do echo "$f"; done \
++                        | sed -e "s,^$libname$shrext\\\\.,," \
++                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
++                        | sed 1q ) 2>/dev/null`
++                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
++                    found_dir="$dir"
++                    found_so="$dir/$libname$shrext.$ver"
++                  fi
++                else
++                  eval library_names=\"$acl_library_names_spec\"
++                  for f in $library_names; do
++                    if test -f "$dir/$f"; then
++                      found_dir="$dir"
++                      found_so="$dir/$f"
++                      break
++                    fi
++                  done
++                fi
++              fi
++            fi
++            dnl Then look for a static library.
++            if test "X$found_dir" = "X"; then
++              if test -f "$dir/$libname.$acl_libext"; then
++                found_dir="$dir"
++                found_a="$dir/$libname.$acl_libext"
++              fi
++            fi
++            if test "X$found_dir" != "X"; then
++              if test -f "$dir/$libname.la"; then
++                found_la="$dir/$libname.la"
++              fi
++            fi
++          fi
++          if test "X$found_dir" = "X"; then
++            for x in $LDFLAGS $LTLIB[]NAME; do
++              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++              case "$x" in
++                -L*)
++                  dir=`echo "X$x" | sed -e 's/^X-L//'`
++                  dnl First look for a shared library.
++                  if test -n "$acl_shlibext"; then
++                    if test -f "$dir/$libname$shrext"; then
++                      found_dir="$dir"
++                      found_so="$dir/$libname$shrext"
++                    else
++                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
++                        ver=`(cd "$dir" && \
++                              for f in "$libname$shrext".*; do echo "$f"; done \
++                              | sed -e "s,^$libname$shrext\\\\.,," \
++                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
++                              | sed 1q ) 2>/dev/null`
++                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
++                          found_dir="$dir"
++                          found_so="$dir/$libname$shrext.$ver"
++                        fi
++                      else
++                        eval library_names=\"$acl_library_names_spec\"
++                        for f in $library_names; do
++                          if test -f "$dir/$f"; then
++                            found_dir="$dir"
++                            found_so="$dir/$f"
++                            break
++                          fi
++                        done
++                      fi
++                    fi
++                  fi
++                  dnl Then look for a static library.
++                  if test "X$found_dir" = "X"; then
++                    if test -f "$dir/$libname.$acl_libext"; then
++                      found_dir="$dir"
++                      found_a="$dir/$libname.$acl_libext"
++                    fi
++                  fi
++                  if test "X$found_dir" != "X"; then
++                    if test -f "$dir/$libname.la"; then
++                      found_la="$dir/$libname.la"
++                    fi
++                  fi
++                  ;;
++              esac
++              if test "X$found_dir" != "X"; then
++                break
++              fi
++            done
++          fi
++          if test "X$found_dir" != "X"; then
++            dnl Found the library.
++            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
++            if test "X$found_so" != "X"; then
++              dnl Linking with a shared library. We attempt to hardcode its
++              dnl directory into the executable's runpath, unless it's the
++              dnl standard /usr/lib.
++              if test "$enable_rpath" = no \
++                 || test "X$found_dir" = "X/usr/$acl_libdirstem" \
++                 || test "X$found_dir" = "X/usr/$acl_libdirstem2"; then
++                dnl No hardcoding is needed.
++                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++              else
++                dnl Use an explicit option to hardcode DIR into the resulting
++                dnl binary.
++                dnl Potentially add DIR to ltrpathdirs.
++                dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
++                haveit=
++                for x in $ltrpathdirs; do
++                  if test "X$x" = "X$found_dir"; then
++                    haveit=yes
++                    break
++                  fi
++                done
++                if test -z "$haveit"; then
++                  ltrpathdirs="$ltrpathdirs $found_dir"
++                fi
++                dnl The hardcoding into $LIBNAME is system dependent.
++                if test "$acl_hardcode_direct" = yes; then
++                  dnl Using DIR/libNAME.so during linking hardcodes DIR into the
++                  dnl resulting binary.
++                  LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++                else
++                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
++                    dnl Use an explicit option to hardcode DIR into the resulting
++                    dnl binary.
++                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++                    dnl Potentially add DIR to rpathdirs.
++                    dnl The rpathdirs will be appended to $LIBNAME at the end.
++                    haveit=
++                    for x in $rpathdirs; do
++                      if test "X$x" = "X$found_dir"; then
++                        haveit=yes
++                        break
++                      fi
++                    done
++                    if test -z "$haveit"; then
++                      rpathdirs="$rpathdirs $found_dir"
++                    fi
++                  else
++                    dnl Rely on "-L$found_dir".
++                    dnl But don't add it if it's already contained in the LDFLAGS
++                    dnl or the already constructed $LIBNAME
++                    haveit=
++                    for x in $LDFLAGS $LIB[]NAME; do
++                      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                      if test "X$x" = "X-L$found_dir"; then
++                        haveit=yes
++                        break
++                      fi
++                    done
++                    if test -z "$haveit"; then
++                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
++                    fi
++                    if test "$acl_hardcode_minus_L" != no; then
++                      dnl FIXME: Not sure whether we should use
++                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
++                      dnl here.
++                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++                    else
++                      dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH
++                      dnl here, because this doesn't fit in flags passed to the
++                      dnl compiler. So give up. No hardcoding. This affects only
++                      dnl very old systems.
++                      dnl FIXME: Not sure whether we should use
++                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
++                      dnl here.
++                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
++                    fi
++                  fi
++                fi
++              fi
++            else
++              if test "X$found_a" != "X"; then
++                dnl Linking with a static library.
++                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
++              else
++                dnl We shouldn't come here, but anyway it's good to have a
++                dnl fallback.
++                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
++              fi
++            fi
++            dnl Assume the include files are nearby.
++            additional_includedir=
++            case "$found_dir" in
++              */$acl_libdirstem | */$acl_libdirstem/)
++                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
++                if test "$name" = '$1'; then
++                  LIB[]NAME[]_PREFIX="$basedir"
++                fi
++                additional_includedir="$basedir/include"
++                ;;
++              */$acl_libdirstem2 | */$acl_libdirstem2/)
++                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'`
++                if test "$name" = '$1'; then
++                  LIB[]NAME[]_PREFIX="$basedir"
++                fi
++                additional_includedir="$basedir/include"
++                ;;
++            esac
++            if test "X$additional_includedir" != "X"; then
++              dnl Potentially add $additional_includedir to $INCNAME.
++              dnl But don't add it
++              dnl   1. if it's the standard /usr/include,
++              dnl   2. if it's /usr/local/include and we are using GCC on Linux,
++              dnl   3. if it's already present in $CPPFLAGS or the already
++              dnl      constructed $INCNAME,
++              dnl   4. if it doesn't exist as a directory.
++              if test "X$additional_includedir" != "X/usr/include"; then
++                haveit=
++                if test "X$additional_includedir" = "X/usr/local/include"; then
++                  if test -n "$GCC"; then
++                    case $host_os in
++                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
++                    esac
++                  fi
++                fi
++                if test -z "$haveit"; then
++                  for x in $CPPFLAGS $INC[]NAME; do
++                    AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                    if test "X$x" = "X-I$additional_includedir"; then
++                      haveit=yes
++                      break
++                    fi
++                  done
++                  if test -z "$haveit"; then
++                    if test -d "$additional_includedir"; then
++                      dnl Really add $additional_includedir to $INCNAME.
++                      INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
++                    fi
++                  fi
++                fi
++              fi
++            fi
++            dnl Look for dependencies.
++            if test -n "$found_la"; then
++              dnl Read the .la file. It defines the variables
++              dnl dlname, library_names, old_library, dependency_libs, current,
++              dnl age, revision, installed, dlopen, dlpreopen, libdir.
++              save_libdir="$libdir"
++              case "$found_la" in
++                */* | *\\*) . "$found_la" ;;
++                *) . "./$found_la" ;;
++              esac
++              libdir="$save_libdir"
++              dnl We use only dependency_libs.
++              for dep in $dependency_libs; do
++                case "$dep" in
++                  -L*)
++                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
++                    dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
++                    dnl But don't add it
++                    dnl   1. if it's the standard /usr/lib,
++                    dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
++                    dnl   3. if it's already present in $LDFLAGS or the already
++                    dnl      constructed $LIBNAME,
++                    dnl   4. if it doesn't exist as a directory.
++                    if test "X$additional_libdir" != "X/usr/$acl_libdirstem" \
++                       && test "X$additional_libdir" != "X/usr/$acl_libdirstem2"; then
++                      haveit=
++                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem" \
++                         || test "X$additional_libdir" = "X/usr/local/$acl_libdirstem2"; then
++                        if test -n "$GCC"; then
++                          case $host_os in
++                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
++                          esac
++                        fi
++                      fi
++                      if test -z "$haveit"; then
++                        haveit=
++                        for x in $LDFLAGS $LIB[]NAME; do
++                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                          if test "X$x" = "X-L$additional_libdir"; then
++                            haveit=yes
++                            break
++                          fi
++                        done
++                        if test -z "$haveit"; then
++                          if test -d "$additional_libdir"; then
++                            dnl Really add $additional_libdir to $LIBNAME.
++                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
++                          fi
++                        fi
++                        haveit=
++                        for x in $LDFLAGS $LTLIB[]NAME; do
++                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                          if test "X$x" = "X-L$additional_libdir"; then
++                            haveit=yes
++                            break
++                          fi
++                        done
++                        if test -z "$haveit"; then
++                          if test -d "$additional_libdir"; then
++                            dnl Really add $additional_libdir to $LTLIBNAME.
++                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
++                          fi
++                        fi
++                      fi
++                    fi
++                    ;;
++                  -R*)
++                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
++                    if test "$enable_rpath" != no; then
++                      dnl Potentially add DIR to rpathdirs.
++                      dnl The rpathdirs will be appended to $LIBNAME at the end.
++                      haveit=
++                      for x in $rpathdirs; do
++                        if test "X$x" = "X$dir"; then
++                          haveit=yes
++                          break
++                        fi
++                      done
++                      if test -z "$haveit"; then
++                        rpathdirs="$rpathdirs $dir"
++                      fi
++                      dnl Potentially add DIR to ltrpathdirs.
++                      dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
++                      haveit=
++                      for x in $ltrpathdirs; do
++                        if test "X$x" = "X$dir"; then
++                          haveit=yes
++                          break
++                        fi
++                      done
++                      if test -z "$haveit"; then
++                        ltrpathdirs="$ltrpathdirs $dir"
++                      fi
++                    fi
++                    ;;
++                  -l*)
++                    dnl Handle this in the next round.
++                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
++                    ;;
++                  *.la)
++                    dnl Handle this in the next round. Throw away the .la's
++                    dnl directory; it is already contained in a preceding -L
++                    dnl option.
++                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
++                    ;;
++                  *)
++                    dnl Most likely an immediate library name.
++                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
++                    LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
++                    ;;
++                esac
++              done
++            fi
++          else
++            dnl Didn't find the library; assume it is in the system directories
++            dnl known to the linker and runtime loader. (All the system
++            dnl directories known to the linker should also be known to the
++            dnl runtime loader, otherwise the system is severely misconfigured.)
++            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
++            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
++          fi
++        fi
++      fi
++    done
++  done
++  if test "X$rpathdirs" != "X"; then
++    if test -n "$acl_hardcode_libdir_separator"; then
++      dnl Weird platform: only the last -rpath option counts, the user must
++      dnl pass all path elements in one option. We can arrange that for a
++      dnl single library, but not when more than one $LIBNAMEs are used.
++      alldirs=
++      for found_dir in $rpathdirs; do
++        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
++      done
++      dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.
++      acl_save_libdir="$libdir"
++      libdir="$alldirs"
++      eval flag=\"$acl_hardcode_libdir_flag_spec\"
++      libdir="$acl_save_libdir"
++      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
++    else
++      dnl The -rpath options are cumulative.
++      for found_dir in $rpathdirs; do
++        acl_save_libdir="$libdir"
++        libdir="$found_dir"
++        eval flag=\"$acl_hardcode_libdir_flag_spec\"
++        libdir="$acl_save_libdir"
++        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
++      done
++    fi
++  fi
++  if test "X$ltrpathdirs" != "X"; then
++    dnl When using libtool, the option that works for both libraries and
++    dnl executables is -R. The -R options are cumulative.
++    for found_dir in $ltrpathdirs; do
++      LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
++    done
++  fi
++  popdef([P_A_C_K])
++  popdef([PACKLIBS])
++  popdef([PACKUP])
++  popdef([PACK])
++  popdef([NAME])
++])
++
++dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
++dnl unless already present in VAR.
++dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
++dnl contains two or three consecutive elements that belong together.
++AC_DEFUN([AC_LIB_APPENDTOVAR],
++[
++  for element in [$2]; do
++    haveit=
++    for x in $[$1]; do
++      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++      if test "X$x" = "X$element"; then
++        haveit=yes
++        break
++      fi
++    done
++    if test -z "$haveit"; then
++      [$1]="${[$1]}${[$1]:+ }$element"
++    fi
++  done
++])
++
++dnl For those cases where a variable contains several -L and -l options
++dnl referring to unknown libraries and directories, this macro determines the
++dnl necessary additional linker options for the runtime path.
++dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])
++dnl sets LDADDVAR to linker options needed together with LIBSVALUE.
++dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,
++dnl otherwise linking without libtool is assumed.
++AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],
++[
++  AC_REQUIRE([AC_LIB_RPATH])
++  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
++  $1=
++  if test "$enable_rpath" != no; then
++    if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
++      dnl Use an explicit option to hardcode directories into the resulting
++      dnl binary.
++      rpathdirs=
++      next=
++      for opt in $2; do
++        if test -n "$next"; then
++          dir="$next"
++          dnl No need to hardcode the standard /usr/lib.
++          if test "X$dir" != "X/usr/$acl_libdirstem" \
++             && test "X$dir" != "X/usr/$acl_libdirstem2"; then
++            rpathdirs="$rpathdirs $dir"
++          fi
++          next=
++        else
++          case $opt in
++            -L) next=yes ;;
++            -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
++                 dnl No need to hardcode the standard /usr/lib.
++                 if test "X$dir" != "X/usr/$acl_libdirstem" \
++                    && test "X$dir" != "X/usr/$acl_libdirstem2"; then
++                   rpathdirs="$rpathdirs $dir"
++                 fi
++                 next= ;;
++            *) next= ;;
++          esac
++        fi
++      done
++      if test "X$rpathdirs" != "X"; then
++        if test -n ""$3""; then
++          dnl libtool is used for linking. Use -R options.
++          for dir in $rpathdirs; do
++            $1="${$1}${$1:+ }-R$dir"
++          done
++        else
++          dnl The linker is used for linking directly.
++          if test -n "$acl_hardcode_libdir_separator"; then
++            dnl Weird platform: only the last -rpath option counts, the user
++            dnl must pass all path elements in one option.
++            alldirs=
++            for dir in $rpathdirs; do
++              alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"
++            done
++            acl_save_libdir="$libdir"
++            libdir="$alldirs"
++            eval flag=\"$acl_hardcode_libdir_flag_spec\"
++            libdir="$acl_save_libdir"
++            $1="$flag"
++          else
++            dnl The -rpath options are cumulative.
++            for dir in $rpathdirs; do
++              acl_save_libdir="$libdir"
++              libdir="$dir"
++              eval flag=\"$acl_hardcode_libdir_flag_spec\"
++              libdir="$acl_save_libdir"
++              $1="${$1}${$1:+ }$flag"
++            done
++          fi
++        fi
++      fi
++    fi
++  fi
++  AC_SUBST([$1])
++])
+diff --git a/m4/lib-prefix.m4 b/m4/lib-prefix.m4
+new file mode 100644
+index 0000000..1601cea
+--- /dev/null
++++ b/m4/lib-prefix.m4
+@@ -0,0 +1,224 @@
++# lib-prefix.m4 serial 7 (gettext-0.18)
++dnl Copyright (C) 2001-2005, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and
++dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't
++dnl require excessive bracketing.
++ifdef([AC_HELP_STRING],
++[AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],
++[AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])
++
++dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
++dnl to access previously installed libraries. The basic assumption is that
++dnl a user will want packages to use other packages he previously installed
++dnl with the same --prefix option.
++dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
++dnl libraries, but is otherwise very convenient.
++AC_DEFUN([AC_LIB_PREFIX],
++[
++  AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
++  AC_REQUIRE([AC_PROG_CC])
++  AC_REQUIRE([AC_CANONICAL_HOST])
++  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  dnl By default, look in $includedir and $libdir.
++  use_additional=yes
++  AC_LIB_WITH_FINAL_PREFIX([
++    eval additional_includedir=\"$includedir\"
++    eval additional_libdir=\"$libdir\"
++  ])
++  AC_LIB_ARG_WITH([lib-prefix],
++[  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
++  --without-lib-prefix    don't search for libraries in includedir and libdir],
++[
++    if test "X$withval" = "Xno"; then
++      use_additional=no
++    else
++      if test "X$withval" = "X"; then
++        AC_LIB_WITH_FINAL_PREFIX([
++          eval additional_includedir=\"$includedir\"
++          eval additional_libdir=\"$libdir\"
++        ])
++      else
++        additional_includedir="$withval/include"
++        additional_libdir="$withval/$acl_libdirstem"
++      fi
++    fi
++])
++  if test $use_additional = yes; then
++    dnl Potentially add $additional_includedir to $CPPFLAGS.
++    dnl But don't add it
++    dnl   1. if it's the standard /usr/include,
++    dnl   2. if it's already present in $CPPFLAGS,
++    dnl   3. if it's /usr/local/include and we are using GCC on Linux,
++    dnl   4. if it doesn't exist as a directory.
++    if test "X$additional_includedir" != "X/usr/include"; then
++      haveit=
++      for x in $CPPFLAGS; do
++        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++        if test "X$x" = "X-I$additional_includedir"; then
++          haveit=yes
++          break
++        fi
++      done
++      if test -z "$haveit"; then
++        if test "X$additional_includedir" = "X/usr/local/include"; then
++          if test -n "$GCC"; then
++            case $host_os in
++              linux* | gnu* | k*bsd*-gnu) haveit=yes;;
++            esac
++          fi
++        fi
++        if test -z "$haveit"; then
++          if test -d "$additional_includedir"; then
++            dnl Really add $additional_includedir to $CPPFLAGS.
++            CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
++          fi
++        fi
++      fi
++    fi
++    dnl Potentially add $additional_libdir to $LDFLAGS.
++    dnl But don't add it
++    dnl   1. if it's the standard /usr/lib,
++    dnl   2. if it's already present in $LDFLAGS,
++    dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
++    dnl   4. if it doesn't exist as a directory.
++    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
++      haveit=
++      for x in $LDFLAGS; do
++        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++        if test "X$x" = "X-L$additional_libdir"; then
++          haveit=yes
++          break
++        fi
++      done
++      if test -z "$haveit"; then
++        if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
++          if test -n "$GCC"; then
++            case $host_os in
++              linux*) haveit=yes;;
++            esac
++          fi
++        fi
++        if test -z "$haveit"; then
++          if test -d "$additional_libdir"; then
++            dnl Really add $additional_libdir to $LDFLAGS.
++            LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
++          fi
++        fi
++      fi
++    fi
++  fi
++])
++
++dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
++dnl acl_final_exec_prefix, containing the values to which $prefix and
++dnl $exec_prefix will expand at the end of the configure script.
++AC_DEFUN([AC_LIB_PREPARE_PREFIX],
++[
++  dnl Unfortunately, prefix and exec_prefix get only finally determined
++  dnl at the end of configure.
++  if test "X$prefix" = "XNONE"; then
++    acl_final_prefix="$ac_default_prefix"
++  else
++    acl_final_prefix="$prefix"
++  fi
++  if test "X$exec_prefix" = "XNONE"; then
++    acl_final_exec_prefix='${prefix}'
++  else
++    acl_final_exec_prefix="$exec_prefix"
++  fi
++  acl_save_prefix="$prefix"
++  prefix="$acl_final_prefix"
++  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
++  prefix="$acl_save_prefix"
++])
++
++dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
++dnl variables prefix and exec_prefix bound to the values they will have
++dnl at the end of the configure script.
++AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
++[
++  acl_save_prefix="$prefix"
++  prefix="$acl_final_prefix"
++  acl_save_exec_prefix="$exec_prefix"
++  exec_prefix="$acl_final_exec_prefix"
++  $1
++  exec_prefix="$acl_save_exec_prefix"
++  prefix="$acl_save_prefix"
++])
++
++dnl AC_LIB_PREPARE_MULTILIB creates
++dnl - a variable acl_libdirstem, containing the basename of the libdir, either
++dnl   "lib" or "lib64" or "lib/64",
++dnl - a variable acl_libdirstem2, as a secondary possible value for
++dnl   acl_libdirstem, either the same as acl_libdirstem or "lib/sparcv9" or
++dnl   "lib/amd64".
++AC_DEFUN([AC_LIB_PREPARE_MULTILIB],
++[
++  dnl There is no formal standard regarding lib and lib64.
++  dnl On glibc systems, the current practice is that on a system supporting
++  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
++  dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. We determine
++  dnl the compiler's default mode by looking at the compiler's library search
++  dnl path. If at least one of its elements ends in /lib64 or points to a
++  dnl directory whose absolute pathname ends in /lib64, we assume a 64-bit ABI.
++  dnl Otherwise we use the default, namely "lib".
++  dnl On Solaris systems, the current practice is that on a system supporting
++  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
++  dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or
++  dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib.
++  AC_REQUIRE([AC_CANONICAL_HOST])
++  acl_libdirstem=lib
++  acl_libdirstem2=
++  case "$host_os" in
++    solaris*)
++      dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment
++      dnl <http://docs.sun.com/app/docs/doc/816-5138/dev-env?l=en&a=view>.
++      dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link."
++      dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the
++      dnl symlink is missing, so we set acl_libdirstem2 too.
++      AC_CACHE_CHECK([for 64-bit host], [gl_cv_solaris_64bit],
++        [AC_EGREP_CPP([sixtyfour bits], [
++#ifdef _LP64
++sixtyfour bits
++#endif
++           ], [gl_cv_solaris_64bit=yes], [gl_cv_solaris_64bit=no])
++        ])
++      if test $gl_cv_solaris_64bit = yes; then
++        acl_libdirstem=lib/64
++        case "$host_cpu" in
++          sparc*)        acl_libdirstem2=lib/sparcv9 ;;
++          i*86 | x86_64) acl_libdirstem2=lib/amd64 ;;
++        esac
++      fi
++      ;;
++    *)
++      searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
++      if test -n "$searchpath"; then
++        acl_save_IFS="${IFS= 	}"; IFS=":"
++        for searchdir in $searchpath; do
++          if test -d "$searchdir"; then
++            case "$searchdir" in
++              */lib64/ | */lib64 ) acl_libdirstem=lib64 ;;
++              */../ | */.. )
++                # Better ignore directories of this form. They are misleading.
++                ;;
++              *) searchdir=`cd "$searchdir" && pwd`
++                 case "$searchdir" in
++                   */lib64 ) acl_libdirstem=lib64 ;;
++                 esac ;;
++            esac
++          fi
++        done
++        IFS="$acl_save_IFS"
++      fi
++      ;;
++  esac
++  test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem"
++])
+diff --git a/m4/lock.m4 b/m4/lock.m4
+new file mode 100644
+index 0000000..9da8465
+--- /dev/null
++++ b/m4/lock.m4
+@@ -0,0 +1,37 @@
++# lock.m4 serial 10 (gettext-0.18)
++dnl Copyright (C) 2005-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_DEFUN([gl_LOCK],
++[
++  AC_REQUIRE([gl_THREADLIB])
++  if test "$gl_threads_api" = posix; then
++    # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
++    # pthread_rwlock_* functions.
++    AC_CHECK_TYPE([pthread_rwlock_t],
++      [AC_DEFINE([HAVE_PTHREAD_RWLOCK], [1],
++         [Define if the POSIX multithreading library has read/write locks.])],
++      [],
++      [#include <pthread.h>])
++    # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
++    AC_TRY_COMPILE([#include <pthread.h>],
++      [#if __FreeBSD__ == 4
++error "No, in FreeBSD 4.0 recursive mutexes actually don't work."
++#else
++int x = (int)PTHREAD_MUTEX_RECURSIVE;
++return !x;
++#endif],
++      [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], [1],
++         [Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE.])])
++  fi
++  gl_PREREQ_LOCK
++])
++
++# Prerequisites of lib/lock.c.
++AC_DEFUN([gl_PREREQ_LOCK], [
++  AC_REQUIRE([AC_C_INLINE])
++])
+diff --git a/m4/longlong.m4 b/m4/longlong.m4
+new file mode 100644
+index 0000000..cca3c1a
+--- /dev/null
++++ b/m4/longlong.m4
+@@ -0,0 +1,106 @@
++# longlong.m4 serial 14
++dnl Copyright (C) 1999-2007, 2009-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Paul Eggert.
++
++# Define HAVE_LONG_LONG_INT if 'long long int' works.
++# This fixes a bug in Autoconf 2.61, but can be removed once we
++# assume 2.62 everywhere.
++
++# Note: If the type 'long long int' exists but is only 32 bits large
++# (as on some very old compilers), HAVE_LONG_LONG_INT will not be
++# defined. In this case you can treat 'long long int' like 'long int'.
++
++AC_DEFUN([AC_TYPE_LONG_LONG_INT],
++[
++  AC_CACHE_CHECK([for long long int], [ac_cv_type_long_long_int],
++    [AC_LINK_IFELSE(
++       [_AC_TYPE_LONG_LONG_SNIPPET],
++       [dnl This catches a bug in Tandem NonStop Kernel (OSS) cc -O circa 2004.
++        dnl If cross compiling, assume the bug isn't important, since
++        dnl nobody cross compiles for this platform as far as we know.
++        AC_RUN_IFELSE(
++          [AC_LANG_PROGRAM(
++             [[@%:@include <limits.h>
++               @%:@ifndef LLONG_MAX
++               @%:@ define HALF \
++                        (1LL << (sizeof (long long int) * CHAR_BIT - 2))
++               @%:@ define LLONG_MAX (HALF - 1 + HALF)
++               @%:@endif]],
++             [[long long int n = 1;
++               int i;
++               for (i = 0; ; i++)
++                 {
++                   long long int m = n << i;
++                   if (m >> i != n)
++                     return 1;
++                   if (LLONG_MAX / 2 < m)
++                     break;
++                 }
++               return 0;]])],
++          [ac_cv_type_long_long_int=yes],
++          [ac_cv_type_long_long_int=no],
++          [ac_cv_type_long_long_int=yes])],
++       [ac_cv_type_long_long_int=no])])
++  if test $ac_cv_type_long_long_int = yes; then
++    AC_DEFINE([HAVE_LONG_LONG_INT], [1],
++      [Define to 1 if the system has the type `long long int'.])
++  fi
++])
++
++# Define HAVE_UNSIGNED_LONG_LONG_INT if 'unsigned long long int' works.
++# This fixes a bug in Autoconf 2.61, but can be removed once we
++# assume 2.62 everywhere.
++
++# Note: If the type 'unsigned long long int' exists but is only 32 bits
++# large (as on some very old compilers), AC_TYPE_UNSIGNED_LONG_LONG_INT
++# will not be defined. In this case you can treat 'unsigned long long int'
++# like 'unsigned long int'.
++
++AC_DEFUN([AC_TYPE_UNSIGNED_LONG_LONG_INT],
++[
++  AC_CACHE_CHECK([for unsigned long long int],
++    [ac_cv_type_unsigned_long_long_int],
++    [AC_LINK_IFELSE(
++       [_AC_TYPE_LONG_LONG_SNIPPET],
++       [ac_cv_type_unsigned_long_long_int=yes],
++       [ac_cv_type_unsigned_long_long_int=no])])
++  if test $ac_cv_type_unsigned_long_long_int = yes; then
++    AC_DEFINE([HAVE_UNSIGNED_LONG_LONG_INT], [1],
++      [Define to 1 if the system has the type `unsigned long long int'.])
++  fi
++])
++
++# Expands to a C program that can be used to test for simultaneous support
++# of 'long long' and 'unsigned long long'. We don't want to say that
++# 'long long' is available if 'unsigned long long' is not, or vice versa,
++# because too many programs rely on the symmetry between signed and unsigned
++# integer types (excluding 'bool').
++AC_DEFUN([_AC_TYPE_LONG_LONG_SNIPPET],
++[
++  AC_LANG_PROGRAM(
++    [[/* For now, do not test the preprocessor; as of 2007 there are too many
++         implementations with broken preprocessors.  Perhaps this can
++         be revisited in 2012.  In the meantime, code should not expect
++         #if to work with literals wider than 32 bits.  */
++      /* Test literals.  */
++      long long int ll = 9223372036854775807ll;
++      long long int nll = -9223372036854775807LL;
++      unsigned long long int ull = 18446744073709551615ULL;
++      /* Test constant expressions.   */
++      typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll)
++                     ? 1 : -1)];
++      typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1
++                     ? 1 : -1)];
++      int i = 63;]],
++    [[/* Test availability of runtime routines for shift and division.  */
++      long long int llmax = 9223372036854775807ll;
++      unsigned long long int ullmax = 18446744073709551615ull;
++      return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i)
++              | (llmax / ll) | (llmax % ll)
++              | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i)
++              | (ullmax / ull) | (ullmax % ull));]])
++])
+diff --git a/m4/nls.m4 b/m4/nls.m4
+new file mode 100644
+index 0000000..003704c
+--- /dev/null
++++ b/m4/nls.m4
+@@ -0,0 +1,32 @@
++# nls.m4 serial 5 (gettext-0.18)
++dnl Copyright (C) 1995-2003, 2005-2006, 2008-2010 Free Software Foundation,
++dnl Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Authors:
++dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
++dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2003.
++
++AC_PREREQ([2.50])
++
++AC_DEFUN([AM_NLS],
++[
++  AC_MSG_CHECKING([whether NLS is requested])
++  dnl Default is enabled NLS
++  AC_ARG_ENABLE([nls],
++    [  --disable-nls           do not use Native Language Support],
++    USE_NLS=$enableval, USE_NLS=yes)
++  AC_MSG_RESULT([$USE_NLS])
++  AC_SUBST([USE_NLS])
++])
+diff --git a/m4/po.m4 b/m4/po.m4
+new file mode 100644
+index 0000000..47f36a4
+--- /dev/null
++++ b/m4/po.m4
+@@ -0,0 +1,449 @@
++# po.m4 serial 17 (gettext-0.18)
++dnl Copyright (C) 1995-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Authors:
++dnl   Ulrich Drepper <drepper@cygnus.com>, 1995-2000.
++dnl   Bruno Haible <haible@clisp.cons.org>, 2000-2003.
++
++AC_PREREQ([2.50])
++
++dnl Checks for all prerequisites of the po subdirectory.
++AC_DEFUN([AM_PO_SUBDIRS],
++[
++  AC_REQUIRE([AC_PROG_MAKE_SET])dnl
++  AC_REQUIRE([AC_PROG_INSTALL])dnl
++  AC_REQUIRE([AM_PROG_MKDIR_P])dnl defined by automake
++  AC_REQUIRE([AM_NLS])dnl
++
++  dnl Release version of the gettext macros. This is used to ensure that
++  dnl the gettext macros and po/Makefile.in.in are in sync.
++  AC_SUBST([GETTEXT_MACRO_VERSION], [0.18])
++
++  dnl Perform the following tests also if --disable-nls has been given,
++  dnl because they are needed for "make dist" to work.
++
++  dnl Search for GNU msgfmt in the PATH.
++  dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions.
++  dnl The second test excludes FreeBSD msgfmt.
++  AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt,
++    [$ac_dir/$ac_word --statistics /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 &&
++     (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)],
++    :)
++  AC_PATH_PROG([GMSGFMT], [gmsgfmt], [$MSGFMT])
++
++  dnl Test whether it is GNU msgfmt >= 0.15.
++changequote(,)dnl
++  case `$MSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in
++    '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) MSGFMT_015=: ;;
++    *) MSGFMT_015=$MSGFMT ;;
++  esac
++changequote([,])dnl
++  AC_SUBST([MSGFMT_015])
++changequote(,)dnl
++  case `$GMSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in
++    '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) GMSGFMT_015=: ;;
++    *) GMSGFMT_015=$GMSGFMT ;;
++  esac
++changequote([,])dnl
++  AC_SUBST([GMSGFMT_015])
++
++  dnl Search for GNU xgettext 0.12 or newer in the PATH.
++  dnl The first test excludes Solaris xgettext and early GNU xgettext versions.
++  dnl The second test excludes FreeBSD xgettext.
++  AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext,
++    [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 &&
++     (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)],
++    :)
++  dnl Remove leftover from FreeBSD xgettext call.
++  rm -f messages.po
++
++  dnl Test whether it is GNU xgettext >= 0.15.
++changequote(,)dnl
++  case `$XGETTEXT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in
++    '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) XGETTEXT_015=: ;;
++    *) XGETTEXT_015=$XGETTEXT ;;
++  esac
++changequote([,])dnl
++  AC_SUBST([XGETTEXT_015])
++
++  dnl Search for GNU msgmerge 0.11 or newer in the PATH.
++  AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge,
++    [$ac_dir/$ac_word --update -q /dev/null /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1], :)
++
++  dnl Installation directories.
++  dnl Autoconf >= 2.60 defines localedir. For older versions of autoconf, we
++  dnl have to define it here, so that it can be used in po/Makefile.
++  test -n "$localedir" || localedir='${datadir}/locale'
++  AC_SUBST([localedir])
++
++  dnl Support for AM_XGETTEXT_OPTION.
++  test -n "${XGETTEXT_EXTRA_OPTIONS+set}" || XGETTEXT_EXTRA_OPTIONS=
++  AC_SUBST([XGETTEXT_EXTRA_OPTIONS])
++
++  AC_CONFIG_COMMANDS([po-directories], [[
++    for ac_file in $CONFIG_FILES; do
++      # Support "outfile[:infile[:infile...]]"
++      case "$ac_file" in
++        *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
++      esac
++      # PO directories have a Makefile.in generated from Makefile.in.in.
++      case "$ac_file" in */Makefile.in)
++        # Adjust a relative srcdir.
++        ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'`
++        ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`"
++        ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'`
++        # In autoconf-2.13 it is called $ac_given_srcdir.
++        # In autoconf-2.50 it is called $srcdir.
++        test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir"
++        case "$ac_given_srcdir" in
++          .)  top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;;
++          /*) top_srcdir="$ac_given_srcdir" ;;
++          *)  top_srcdir="$ac_dots$ac_given_srcdir" ;;
++        esac
++        # Treat a directory as a PO directory if and only if it has a
++        # POTFILES.in file. This allows packages to have multiple PO
++        # directories under different names or in different locations.
++        if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then
++          rm -f "$ac_dir/POTFILES"
++          test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES"
++          cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ 	]*\$/d" -e "s,.*,     $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES"
++          POMAKEFILEDEPS="POTFILES.in"
++          # ALL_LINGUAS, POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES depend
++          # on $ac_dir but don't depend on user-specified configuration
++          # parameters.
++          if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then
++            # The LINGUAS file contains the set of available languages.
++            if test -n "$OBSOLETE_ALL_LINGUAS"; then
++              test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete"
++            fi
++            ALL_LINGUAS_=`sed -e "/^#/d" -e "s/#.*//" "$ac_given_srcdir/$ac_dir/LINGUAS"`
++            # Hide the ALL_LINGUAS assigment from automake < 1.5.
++            eval 'ALL_LINGUAS''=$ALL_LINGUAS_'
++            POMAKEFILEDEPS="$POMAKEFILEDEPS LINGUAS"
++          else
++            # The set of available languages was given in configure.in.
++            # Hide the ALL_LINGUAS assigment from automake < 1.5.
++            eval 'ALL_LINGUAS''=$OBSOLETE_ALL_LINGUAS'
++          fi
++          # Compute POFILES
++          # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).po)
++          # Compute UPDATEPOFILES
++          # as      $(foreach lang, $(ALL_LINGUAS), $(lang).po-update)
++          # Compute DUMMYPOFILES
++          # as      $(foreach lang, $(ALL_LINGUAS), $(lang).nop)
++          # Compute GMOFILES
++          # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).gmo)
++          case "$ac_given_srcdir" in
++            .) srcdirpre= ;;
++            *) srcdirpre='$(srcdir)/' ;;
++          esac
++          POFILES=
++          UPDATEPOFILES=
++          DUMMYPOFILES=
++          GMOFILES=
++          for lang in $ALL_LINGUAS; do
++            POFILES="$POFILES $srcdirpre$lang.po"
++            UPDATEPOFILES="$UPDATEPOFILES $lang.po-update"
++            DUMMYPOFILES="$DUMMYPOFILES $lang.nop"
++            GMOFILES="$GMOFILES $srcdirpre$lang.gmo"
++          done
++          # CATALOGS depends on both $ac_dir and the user's LINGUAS
++          # environment variable.
++          INST_LINGUAS=
++          if test -n "$ALL_LINGUAS"; then
++            for presentlang in $ALL_LINGUAS; do
++              useit=no
++              if test "%UNSET%" != "$LINGUAS"; then
++                desiredlanguages="$LINGUAS"
++              else
++                desiredlanguages="$ALL_LINGUAS"
++              fi
++              for desiredlang in $desiredlanguages; do
++                # Use the presentlang catalog if desiredlang is
++                #   a. equal to presentlang, or
++                #   b. a variant of presentlang (because in this case,
++                #      presentlang can be used as a fallback for messages
++                #      which are not translated in the desiredlang catalog).
++                case "$desiredlang" in
++                  "$presentlang"*) useit=yes;;
++                esac
++              done
++              if test $useit = yes; then
++                INST_LINGUAS="$INST_LINGUAS $presentlang"
++              fi
++            done
++          fi
++          CATALOGS=
++          if test -n "$INST_LINGUAS"; then
++            for lang in $INST_LINGUAS; do
++              CATALOGS="$CATALOGS $lang.gmo"
++            done
++          fi
++          test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile"
++          sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" -e "s|@POMAKEFILEDEPS@|$POMAKEFILEDEPS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile"
++          for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do
++            if test -f "$f"; then
++              case "$f" in
++                *.orig | *.bak | *~) ;;
++                *) cat "$f" >> "$ac_dir/Makefile" ;;
++              esac
++            fi
++          done
++        fi
++        ;;
++      esac
++    done]],
++   [# Capture the value of obsolete ALL_LINGUAS because we need it to compute
++    # POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES, CATALOGS. But hide it
++    # from automake < 1.5.
++    eval 'OBSOLETE_ALL_LINGUAS''="$ALL_LINGUAS"'
++    # Capture the value of LINGUAS because we need it to compute CATALOGS.
++    LINGUAS="${LINGUAS-%UNSET%}"
++   ])
++])
++
++dnl Postprocesses a Makefile in a directory containing PO files.
++AC_DEFUN([AM_POSTPROCESS_PO_MAKEFILE],
++[
++  # When this code is run, in config.status, two variables have already been
++  # set:
++  # - OBSOLETE_ALL_LINGUAS is the value of LINGUAS set in configure.in,
++  # - LINGUAS is the value of the environment variable LINGUAS at configure
++  #   time.
++
++changequote(,)dnl
++  # Adjust a relative srcdir.
++  ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'`
++  ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`"
++  ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'`
++  # In autoconf-2.13 it is called $ac_given_srcdir.
++  # In autoconf-2.50 it is called $srcdir.
++  test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir"
++  case "$ac_given_srcdir" in
++    .)  top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;;
++    /*) top_srcdir="$ac_given_srcdir" ;;
++    *)  top_srcdir="$ac_dots$ac_given_srcdir" ;;
++  esac
++
++  # Find a way to echo strings without interpreting backslash.
++  if test "X`(echo '\t') 2>/dev/null`" = 'X\t'; then
++    gt_echo='echo'
++  else
++    if test "X`(printf '%s\n' '\t') 2>/dev/null`" = 'X\t'; then
++      gt_echo='printf %s\n'
++    else
++      echo_func () {
++        cat <<EOT
++$*
++EOT
++      }
++      gt_echo='echo_func'
++    fi
++  fi
++
++  # A sed script that extracts the value of VARIABLE from a Makefile.
++  sed_x_variable='
++# Test if the hold space is empty.
++x
++s/P/P/
++x
++ta
++# Yes it was empty. Look if we have the expected variable definition.
++/^[	 ]*VARIABLE[	 ]*=/{
++  # Seen the first line of the variable definition.
++  s/^[	 ]*VARIABLE[	 ]*=//
++  ba
++}
++bd
++:a
++# Here we are processing a line from the variable definition.
++# Remove comment, more precisely replace it with a space.
++s/#.*$/ /
++# See if the line ends in a backslash.
++tb
++:b
++s/\\$//
++# Print the line, without the trailing backslash.
++p
++tc
++# There was no trailing backslash. The end of the variable definition is
++# reached. Clear the hold space.
++s/^.*$//
++x
++bd
++:c
++# A trailing backslash means that the variable definition continues in the
++# next line. Put a nonempty string into the hold space to indicate this.
++s/^.*$/P/
++x
++:d
++'
++changequote([,])dnl
++
++  # Set POTFILES to the value of the Makefile variable POTFILES.
++  sed_x_POTFILES=`$gt_echo "$sed_x_variable" | sed -e '/^ *#/d' -e 's/VARIABLE/POTFILES/g'`
++  POTFILES=`sed -n -e "$sed_x_POTFILES" < "$ac_file"`
++  # Compute POTFILES_DEPS as
++  #   $(foreach file, $(POTFILES), $(top_srcdir)/$(file))
++  POTFILES_DEPS=
++  for file in $POTFILES; do
++    POTFILES_DEPS="$POTFILES_DEPS "'$(top_srcdir)/'"$file"
++  done
++  POMAKEFILEDEPS=""
++
++  if test -n "$OBSOLETE_ALL_LINGUAS"; then
++    test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete"
++  fi
++  if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then
++    # The LINGUAS file contains the set of available languages.
++    ALL_LINGUAS_=`sed -e "/^#/d" -e "s/#.*//" "$ac_given_srcdir/$ac_dir/LINGUAS"`
++    POMAKEFILEDEPS="$POMAKEFILEDEPS LINGUAS"
++  else
++    # Set ALL_LINGUAS to the value of the Makefile variable LINGUAS.
++    sed_x_LINGUAS=`$gt_echo "$sed_x_variable" | sed -e '/^ *#/d' -e 's/VARIABLE/LINGUAS/g'`
++    ALL_LINGUAS_=`sed -n -e "$sed_x_LINGUAS" < "$ac_file"`
++  fi
++  # Hide the ALL_LINGUAS assigment from automake < 1.5.
++  eval 'ALL_LINGUAS''=$ALL_LINGUAS_'
++  # Compute POFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).po)
++  # Compute UPDATEPOFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(lang).po-update)
++  # Compute DUMMYPOFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(lang).nop)
++  # Compute GMOFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).gmo)
++  # Compute PROPERTIESFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(top_srcdir)/$(DOMAIN)_$(lang).properties)
++  # Compute CLASSFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(top_srcdir)/$(DOMAIN)_$(lang).class)
++  # Compute QMFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).qm)
++  # Compute MSGFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(frob $(lang)).msg)
++  # Compute RESOURCESDLLFILES
++  # as      $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(frob $(lang))/$(DOMAIN).resources.dll)
++  case "$ac_given_srcdir" in
++    .) srcdirpre= ;;
++    *) srcdirpre='$(srcdir)/' ;;
++  esac
++  POFILES=
++  UPDATEPOFILES=
++  DUMMYPOFILES=
++  GMOFILES=
++  PROPERTIESFILES=
++  CLASSFILES=
++  QMFILES=
++  MSGFILES=
++  RESOURCESDLLFILES=
++  for lang in $ALL_LINGUAS; do
++    POFILES="$POFILES $srcdirpre$lang.po"
++    UPDATEPOFILES="$UPDATEPOFILES $lang.po-update"
++    DUMMYPOFILES="$DUMMYPOFILES $lang.nop"
++    GMOFILES="$GMOFILES $srcdirpre$lang.gmo"
++    PROPERTIESFILES="$PROPERTIESFILES \$(top_srcdir)/\$(DOMAIN)_$lang.properties"
++    CLASSFILES="$CLASSFILES \$(top_srcdir)/\$(DOMAIN)_$lang.class"
++    QMFILES="$QMFILES $srcdirpre$lang.qm"
++    frobbedlang=`echo $lang | sed -e 's/\..*$//' -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'`
++    MSGFILES="$MSGFILES $srcdirpre$frobbedlang.msg"
++    frobbedlang=`echo $lang | sed -e 's/_/-/g' -e 's/^sr-CS/sr-SP/' -e 's/@latin$/-Latn/' -e 's/@cyrillic$/-Cyrl/' -e 's/^sr-SP$/sr-SP-Latn/' -e 's/^uz-UZ$/uz-UZ-Latn/'`
++    RESOURCESDLLFILES="$RESOURCESDLLFILES $srcdirpre$frobbedlang/\$(DOMAIN).resources.dll"
++  done
++  # CATALOGS depends on both $ac_dir and the user's LINGUAS
++  # environment variable.
++  INST_LINGUAS=
++  if test -n "$ALL_LINGUAS"; then
++    for presentlang in $ALL_LINGUAS; do
++      useit=no
++      if test "%UNSET%" != "$LINGUAS"; then
++        desiredlanguages="$LINGUAS"
++      else
++        desiredlanguages="$ALL_LINGUAS"
++      fi
++      for desiredlang in $desiredlanguages; do
++        # Use the presentlang catalog if desiredlang is
++        #   a. equal to presentlang, or
++        #   b. a variant of presentlang (because in this case,
++        #      presentlang can be used as a fallback for messages
++        #      which are not translated in the desiredlang catalog).
++        case "$desiredlang" in
++          "$presentlang"*) useit=yes;;
++        esac
++      done
++      if test $useit = yes; then
++        INST_LINGUAS="$INST_LINGUAS $presentlang"
++      fi
++    done
++  fi
++  CATALOGS=
++  JAVACATALOGS=
++  QTCATALOGS=
++  TCLCATALOGS=
++  CSHARPCATALOGS=
++  if test -n "$INST_LINGUAS"; then
++    for lang in $INST_LINGUAS; do
++      CATALOGS="$CATALOGS $lang.gmo"
++      JAVACATALOGS="$JAVACATALOGS \$(DOMAIN)_$lang.properties"
++      QTCATALOGS="$QTCATALOGS $lang.qm"
++      frobbedlang=`echo $lang | sed -e 's/\..*$//' -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'`
++      TCLCATALOGS="$TCLCATALOGS $frobbedlang.msg"
++      frobbedlang=`echo $lang | sed -e 's/_/-/g' -e 's/^sr-CS/sr-SP/' -e 's/@latin$/-Latn/' -e 's/@cyrillic$/-Cyrl/' -e 's/^sr-SP$/sr-SP-Latn/' -e 's/^uz-UZ$/uz-UZ-Latn/'`
++      CSHARPCATALOGS="$CSHARPCATALOGS $frobbedlang/\$(DOMAIN).resources.dll"
++    done
++  fi
++
++  sed -e "s|@POTFILES_DEPS@|$POTFILES_DEPS|g" -e "s|@POFILES@|$POFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@PROPERTIESFILES@|$PROPERTIESFILES|g" -e "s|@CLASSFILES@|$CLASSFILES|g" -e "s|@QMFILES@|$QMFILES|g" -e "s|@MSGFILES@|$MSGFILES|g" -e "s|@RESOURCESDLLFILES@|$RESOURCESDLLFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" -e "s|@JAVACATALOGS@|$JAVACATALOGS|g" -e "s|@QTCATALOGS@|$QTCATALOGS|g" -e "s|@TCLCATALOGS@|$TCLCATALOGS|g" -e "s|@CSHARPCATALOGS@|$CSHARPCATALOGS|g" -e 's,^#distdir:,distdir:,' < "$ac_file" > "$ac_file.tmp"
++  if grep -l '@TCLCATALOGS@' "$ac_file" > /dev/null; then
++    # Add dependencies that cannot be formulated as a simple suffix rule.
++    for lang in $ALL_LINGUAS; do
++      frobbedlang=`echo $lang | sed -e 's/\..*$//' -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'`
++      cat >> "$ac_file.tmp" <<EOF
++$frobbedlang.msg: $lang.po
++	@echo "\$(MSGFMT) -c --tcl -d \$(srcdir) -l $lang $srcdirpre$lang.po"; \
++	\$(MSGFMT) -c --tcl -d "\$(srcdir)" -l $lang $srcdirpre$lang.po || { rm -f "\$(srcdir)/$frobbedlang.msg"; exit 1; }
++EOF
++    done
++  fi
++  if grep -l '@CSHARPCATALOGS@' "$ac_file" > /dev/null; then
++    # Add dependencies that cannot be formulated as a simple suffix rule.
++    for lang in $ALL_LINGUAS; do
++      frobbedlang=`echo $lang | sed -e 's/_/-/g' -e 's/^sr-CS/sr-SP/' -e 's/@latin$/-Latn/' -e 's/@cyrillic$/-Cyrl/' -e 's/^sr-SP$/sr-SP-Latn/' -e 's/^uz-UZ$/uz-UZ-Latn/'`
++      cat >> "$ac_file.tmp" <<EOF
++$frobbedlang/\$(DOMAIN).resources.dll: $lang.po
++	@echo "\$(MSGFMT) -c --csharp -d \$(srcdir) -l $lang $srcdirpre$lang.po -r \$(DOMAIN)"; \
++	\$(MSGFMT) -c --csharp -d "\$(srcdir)" -l $lang $srcdirpre$lang.po -r "\$(DOMAIN)" || { rm -f "\$(srcdir)/$frobbedlang.msg"; exit 1; }
++EOF
++    done
++  fi
++  if test -n "$POMAKEFILEDEPS"; then
++    cat >> "$ac_file.tmp" <<EOF
++Makefile: $POMAKEFILEDEPS
++EOF
++  fi
++  mv "$ac_file.tmp" "$ac_file"
++])
++
++dnl Initializes the accumulator used by AM_XGETTEXT_OPTION.
++AC_DEFUN([AM_XGETTEXT_OPTION_INIT],
++[
++  XGETTEXT_EXTRA_OPTIONS=
++])
++
++dnl Registers an option to be passed to xgettext in the po subdirectory.
++AC_DEFUN([AM_XGETTEXT_OPTION],
++[
++  AC_REQUIRE([AM_XGETTEXT_OPTION_INIT])
++  XGETTEXT_EXTRA_OPTIONS="$XGETTEXT_EXTRA_OPTIONS $1"
++])
+diff --git a/m4/printf-posix.m4 b/m4/printf-posix.m4
+new file mode 100644
+index 0000000..1eacf95
+--- /dev/null
++++ b/m4/printf-posix.m4
+@@ -0,0 +1,45 @@
++# printf-posix.m4 serial 5 (gettext-0.18)
++dnl Copyright (C) 2003, 2007, 2009-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++dnl Test whether the printf() function supports POSIX/XSI format strings with
++dnl positions.
++
++AC_DEFUN([gt_PRINTF_POSIX],
++[
++  AC_REQUIRE([AC_PROG_CC])
++  AC_CACHE_CHECK([whether printf() supports POSIX/XSI format strings],
++    gt_cv_func_printf_posix,
++    [
++      AC_TRY_RUN([
++#include <stdio.h>
++#include <string.h>
++/* The string "%2$d %1$d", with dollar characters protected from the shell's
++   dollar expansion (possibly an autoconf bug).  */
++static char format[] = { '%', '2', '$', 'd', ' ', '%', '1', '$', 'd', '\0' };
++static char buf[100];
++int main ()
++{
++  sprintf (buf, format, 33, 55);
++  return (strcmp (buf, "55 33") != 0);
++}], gt_cv_func_printf_posix=yes, gt_cv_func_printf_posix=no,
++      [
++        AC_EGREP_CPP([notposix], [
++#if defined __NetBSD__ || defined __BEOS__ || defined _MSC_VER || defined __MINGW32__ || defined __CYGWIN__
++  notposix
++#endif
++          ],
++          [gt_cv_func_printf_posix="guessing no"],
++          [gt_cv_func_printf_posix="guessing yes"])
++      ])
++    ])
++  case $gt_cv_func_printf_posix in
++    *yes)
++      AC_DEFINE([HAVE_POSIX_PRINTF], [1],
++        [Define if your printf() function supports format strings with positions.])
++      ;;
++  esac
++])
+diff --git a/m4/progtest.m4 b/m4/progtest.m4
+new file mode 100644
+index 0000000..2d804ac
+--- /dev/null
++++ b/m4/progtest.m4
+@@ -0,0 +1,92 @@
++# progtest.m4 serial 6 (gettext-0.18)
++dnl Copyright (C) 1996-2003, 2005, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++dnl
++dnl This file can can be used in projects which are not available under
++dnl the GNU General Public License or the GNU Library General Public
++dnl License but which still want to provide support for the GNU gettext
++dnl functionality.
++dnl Please note that the actual code of the GNU gettext library is covered
++dnl by the GNU Library General Public License, and the rest of the GNU
++dnl gettext package package is covered by the GNU General Public License.
++dnl They are *not* in the public domain.
++
++dnl Authors:
++dnl   Ulrich Drepper <drepper@cygnus.com>, 1996.
++
++AC_PREREQ([2.50])
++
++# Search path for a program which passes the given test.
++
++dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR,
++dnl   TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]])
++AC_DEFUN([AM_PATH_PROG_WITH_TEST],
++[
++# Prepare PATH_SEPARATOR.
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
++fi
++
++# Find out how to test for executable files. Don't use a zero-byte file,
++# as systems may use methods other than mode bits to determine executability.
++cat >conf$$.file <<_ASEOF
++#! /bin/sh
++exit 0
++_ASEOF
++chmod +x conf$$.file
++if test -x conf$$.file >/dev/null 2>&1; then
++  ac_executable_p="test -x"
++else
++  ac_executable_p="test -f"
++fi
++rm -f conf$$.file
++
++# Extract the first word of "$2", so it can be a program name with args.
++set dummy $2; ac_word=[$]2
++AC_MSG_CHECKING([for $ac_word])
++AC_CACHE_VAL([ac_cv_path_$1],
++[case "[$]$1" in
++  [[\\/]]* | ?:[[\\/]]*)
++    ac_cv_path_$1="[$]$1" # Let the user override the test with a path.
++    ;;
++  *)
++    ac_save_IFS="$IFS"; IFS=$PATH_SEPARATOR
++    for ac_dir in ifelse([$5], , $PATH, [$5]); do
++      IFS="$ac_save_IFS"
++      test -z "$ac_dir" && ac_dir=.
++      for ac_exec_ext in '' $ac_executable_extensions; do
++        if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then
++          echo "$as_me: trying $ac_dir/$ac_word..." >&AS_MESSAGE_LOG_FD
++          if [$3]; then
++            ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext"
++            break 2
++          fi
++        fi
++      done
++    done
++    IFS="$ac_save_IFS"
++dnl If no 4th arg is given, leave the cache variable unset,
++dnl so AC_PATH_PROGS will keep looking.
++ifelse([$4], , , [  test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4"
++])dnl
++    ;;
++esac])dnl
++$1="$ac_cv_path_$1"
++if test ifelse([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then
++  AC_MSG_RESULT([$][$1])
++else
++  AC_MSG_RESULT([no])
++fi
++AC_SUBST([$1])dnl
++])
+diff --git a/m4/size_max.m4 b/m4/size_max.m4
+new file mode 100644
+index 0000000..ce992db
+--- /dev/null
++++ b/m4/size_max.m4
+@@ -0,0 +1,75 @@
++# size_max.m4 serial 9
++dnl Copyright (C) 2003, 2005-2006, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_DEFUN([gl_SIZE_MAX],
++[
++  AC_CHECK_HEADERS([stdint.h])
++  dnl First test whether the system already has SIZE_MAX.
++  AC_CACHE_CHECK([for SIZE_MAX], [gl_cv_size_max], [
++    gl_cv_size_max=
++    AC_EGREP_CPP([Found it], [
++#include <limits.h>
++#if HAVE_STDINT_H
++#include <stdint.h>
++#endif
++#ifdef SIZE_MAX
++Found it
++#endif
++], [gl_cv_size_max=yes])
++    if test -z "$gl_cv_size_max"; then
++      dnl Define it ourselves. Here we assume that the type 'size_t' is not wider
++      dnl than the type 'unsigned long'. Try hard to find a definition that can
++      dnl be used in a preprocessor #if, i.e. doesn't contain a cast.
++      AC_COMPUTE_INT([size_t_bits_minus_1], [sizeof (size_t) * CHAR_BIT - 1],
++        [#include <stddef.h>
++#include <limits.h>], [size_t_bits_minus_1=])
++      AC_COMPUTE_INT([fits_in_uint], [sizeof (size_t) <= sizeof (unsigned int)],
++        [#include <stddef.h>], [fits_in_uint=])
++      if test -n "$size_t_bits_minus_1" && test -n "$fits_in_uint"; then
++        if test $fits_in_uint = 1; then
++          dnl Even though SIZE_MAX fits in an unsigned int, it must be of type
++          dnl 'unsigned long' if the type 'size_t' is the same as 'unsigned long'.
++          AC_TRY_COMPILE([#include <stddef.h>
++            extern size_t foo;
++            extern unsigned long foo;
++            ], [], [fits_in_uint=0])
++        fi
++        dnl We cannot use 'expr' to simplify this expression, because 'expr'
++        dnl works only with 'long' integers in the host environment, while we
++        dnl might be cross-compiling from a 32-bit platform to a 64-bit platform.
++        if test $fits_in_uint = 1; then
++          gl_cv_size_max="(((1U << $size_t_bits_minus_1) - 1) * 2 + 1)"
++        else
++          gl_cv_size_max="(((1UL << $size_t_bits_minus_1) - 1) * 2 + 1)"
++        fi
++      else
++        dnl Shouldn't happen, but who knows...
++        gl_cv_size_max='((size_t)~(size_t)0)'
++      fi
++    fi
++  ])
++  if test "$gl_cv_size_max" != yes; then
++    AC_DEFINE_UNQUOTED([SIZE_MAX], [$gl_cv_size_max],
++      [Define as the maximum value of type 'size_t', if the system doesn't define it.])
++  fi
++  dnl Don't redefine SIZE_MAX in config.h if config.h is re-included after
++  dnl <stdint.h>. Remember that the #undef in AH_VERBATIM gets replaced with
++  dnl #define by AC_DEFINE_UNQUOTED.
++  AH_VERBATIM([SIZE_MAX],
++[/* Define as the maximum value of type 'size_t', if the system doesn't define
++   it. */
++#ifndef SIZE_MAX
++# undef SIZE_MAX
++#endif])
++])
++
++dnl Autoconf >= 2.61 has AC_COMPUTE_INT built-in.
++dnl Remove this when we can assume autoconf >= 2.61.
++m4_ifdef([AC_COMPUTE_INT], [], [
++  AC_DEFUN([AC_COMPUTE_INT], [_AC_COMPUTE_INT([$2],[$1],[$3],[$4])])
++])
+diff --git a/m4/stdint_h.m4 b/m4/stdint_h.m4
+new file mode 100644
+index 0000000..b8e3c6c
+--- /dev/null
++++ b/m4/stdint_h.m4
+@@ -0,0 +1,26 @@
++# stdint_h.m4 serial 8
++dnl Copyright (C) 1997-2004, 2006, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Paul Eggert.
++
++# Define HAVE_STDINT_H_WITH_UINTMAX if <stdint.h> exists,
++# doesn't clash with <sys/types.h>, and declares uintmax_t.
++
++AC_DEFUN([gl_AC_HEADER_STDINT_H],
++[
++  AC_CACHE_CHECK([for stdint.h], [gl_cv_header_stdint_h],
++  [AC_TRY_COMPILE(
++    [#include <sys/types.h>
++#include <stdint.h>],
++    [uintmax_t i = (uintmax_t) -1; return !i;],
++    [gl_cv_header_stdint_h=yes],
++    [gl_cv_header_stdint_h=no])])
++  if test $gl_cv_header_stdint_h = yes; then
++    AC_DEFINE_UNQUOTED([HAVE_STDINT_H_WITH_UINTMAX], [1],
++      [Define if <stdint.h> exists, doesn't clash with <sys/types.h>,
++       and declares uintmax_t. ])
++  fi
++])
+diff --git a/m4/threadlib.m4 b/m4/threadlib.m4
+new file mode 100644
+index 0000000..05cc4ff
+--- /dev/null
++++ b/m4/threadlib.m4
+@@ -0,0 +1,347 @@
++# threadlib.m4 serial 5 (gettext-0.18)
++dnl Copyright (C) 2005-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++dnl gl_THREADLIB
++dnl ------------
++dnl Tests for a multithreading library to be used.
++dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
++dnl USE_PTH_THREADS, USE_WIN32_THREADS
++dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
++dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
++dnl libtool).
++dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
++dnl programs that really need multithread functionality. The difference
++dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
++dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
++dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
++dnl multithread-safe programs.
++
++AC_DEFUN([gl_THREADLIB_EARLY],
++[
++  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
++])
++
++dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
++
++AC_DEFUN([gl_THREADLIB_EARLY_BODY],
++[
++  dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
++  dnl influences the result of the autoconf tests that test for *_unlocked
++  dnl declarations, on AIX 5 at least. Therefore it must come early.
++  AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
++  AC_BEFORE([$0], [gl_ARGP])dnl
++
++  AC_REQUIRE([AC_CANONICAL_HOST])
++  dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
++  dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
++  dnl AC_GNU_SOURCE.
++  m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
++    [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
++    [AC_REQUIRE([AC_GNU_SOURCE])])
++  dnl Check for multithreading.
++  m4_divert_text([DEFAULTS], [gl_use_threads_default=])
++  AC_ARG_ENABLE([threads],
++AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
++AC_HELP_STRING([--disable-threads], [build without multithread safety]),
++    [gl_use_threads=$enableval],
++    [if test -n "$gl_use_threads_default"; then
++       gl_use_threads="$gl_use_threads_default"
++     else
++changequote(,)dnl
++       case "$host_os" in
++         dnl Disable multithreading by default on OSF/1, because it interferes
++         dnl with fork()/exec(): When msgexec is linked with -lpthread, its
++         dnl child process gets an endless segmentation fault inside execvp().
++         dnl Disable multithreading by default on Cygwin 1.5.x, because it has
++         dnl bugs that lead to endless loops or crashes. See
++         dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
++         osf*) gl_use_threads=no ;;
++         cygwin*)
++               case `uname -r` in
++                 1.[0-5].*) gl_use_threads=no ;;
++                 *)         gl_use_threads=yes ;;
++               esac
++               ;;
++         *)    gl_use_threads=yes ;;
++       esac
++changequote([,])dnl
++     fi
++    ])
++  if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
++    # For using <pthread.h>:
++    case "$host_os" in
++      osf*)
++        # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
++        # groks <pthread.h>. cc also understands the flag -pthread, but
++        # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
++        # 2. putting a flag into CPPFLAGS that has an effect on the linker
++        # causes the AC_TRY_LINK test below to succeed unexpectedly,
++        # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
++        CPPFLAGS="$CPPFLAGS -D_REENTRANT"
++        ;;
++    esac
++    # Some systems optimize for single-threaded programs by default, and
++    # need special flags to disable these optimizations. For example, the
++    # definition of 'errno' in <errno.h>.
++    case "$host_os" in
++      aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
++      solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
++    esac
++  fi
++])
++
++dnl The guts of gl_THREADLIB. Needs to be expanded only once.
++
++AC_DEFUN([gl_THREADLIB_BODY],
++[
++  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
++  gl_threads_api=none
++  LIBTHREAD=
++  LTLIBTHREAD=
++  LIBMULTITHREAD=
++  LTLIBMULTITHREAD=
++  if test "$gl_use_threads" != no; then
++    dnl Check whether the compiler and linker support weak declarations.
++    AC_CACHE_CHECK([whether imported symbols can be declared weak],
++      [gl_cv_have_weak],
++      [gl_cv_have_weak=no
++       dnl First, test whether the compiler accepts it syntactically.
++       AC_TRY_LINK([extern void xyzzy ();
++#pragma weak xyzzy], [xyzzy();], [gl_cv_have_weak=maybe])
++       if test $gl_cv_have_weak = maybe; then
++         dnl Second, test whether it actually works. On Cygwin 1.7.2, with
++         dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
++         AC_TRY_RUN([
++#include <stdio.h>
++#pragma weak fputs
++int main ()
++{
++  return (fputs == NULL);
++}], [gl_cv_have_weak=yes], [gl_cv_have_weak=no],
++           [dnl When cross-compiling, assume that only ELF platforms support
++            dnl weak symbols.
++            AC_EGREP_CPP([Extensible Linking Format],
++              [#ifdef __ELF__
++               Extensible Linking Format
++               #endif
++              ],
++              [gl_cv_have_weak="guessing yes"],
++              [gl_cv_have_weak="guessing no"])
++           ])
++       fi
++      ])
++    if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
++      # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
++      # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
++      AC_CHECK_HEADER([pthread.h],
++        [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
++      if test "$gl_have_pthread_h" = yes; then
++        # Other possible tests:
++        #   -lpthreads (FSU threads, PCthreads)
++        #   -lgthreads
++        gl_have_pthread=
++        # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
++        # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
++        # the second one only in libpthread, and lock.c needs it.
++        AC_TRY_LINK([#include <pthread.h>],
++          [pthread_mutex_lock((pthread_mutex_t*)0);
++           pthread_mutexattr_init((pthread_mutexattr_t*)0);],
++          [gl_have_pthread=yes])
++        # Test for libpthread by looking for pthread_kill. (Not pthread_self,
++        # since it is defined as a macro on OSF/1.)
++        if test -n "$gl_have_pthread"; then
++          # The program links fine without libpthread. But it may actually
++          # need to link with libpthread in order to create multiple threads.
++          AC_CHECK_LIB([pthread], [pthread_kill],
++            [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
++             # On Solaris and HP-UX, most pthread functions exist also in libc.
++             # Therefore pthread_in_use() needs to actually try to create a
++             # thread: pthread_create from libc will fail, whereas
++             # pthread_create will actually create a thread.
++             case "$host_os" in
++               solaris* | hpux*)
++                 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
++                   [Define if the pthread_in_use() detection is hard.])
++             esac
++            ])
++        else
++          # Some library is needed. Try libpthread and libc_r.
++          AC_CHECK_LIB([pthread], [pthread_kill],
++            [gl_have_pthread=yes
++             LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
++             LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
++          if test -z "$gl_have_pthread"; then
++            # For FreeBSD 4.
++            AC_CHECK_LIB([c_r], [pthread_kill],
++              [gl_have_pthread=yes
++               LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
++               LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
++          fi
++        fi
++        if test -n "$gl_have_pthread"; then
++          gl_threads_api=posix
++          AC_DEFINE([USE_POSIX_THREADS], [1],
++            [Define if the POSIX multithreading library can be used.])
++          if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
++            if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
++              AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
++                [Define if references to the POSIX multithreading library should be made weak.])
++              LIBTHREAD=
++              LTLIBTHREAD=
++            fi
++          fi
++        fi
++      fi
++    fi
++    if test -z "$gl_have_pthread"; then
++      if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
++        gl_have_solaristhread=
++        gl_save_LIBS="$LIBS"
++        LIBS="$LIBS -lthread"
++        AC_TRY_LINK([#include <thread.h>
++#include <synch.h>],
++          [thr_self();],
++          [gl_have_solaristhread=yes])
++        LIBS="$gl_save_LIBS"
++        if test -n "$gl_have_solaristhread"; then
++          gl_threads_api=solaris
++          LIBTHREAD=-lthread
++          LTLIBTHREAD=-lthread
++          LIBMULTITHREAD="$LIBTHREAD"
++          LTLIBMULTITHREAD="$LTLIBTHREAD"
++          AC_DEFINE([USE_SOLARIS_THREADS], [1],
++            [Define if the old Solaris multithreading library can be used.])
++          if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
++            AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
++              [Define if references to the old Solaris multithreading library should be made weak.])
++            LIBTHREAD=
++            LTLIBTHREAD=
++          fi
++        fi
++      fi
++    fi
++    if test "$gl_use_threads" = pth; then
++      gl_save_CPPFLAGS="$CPPFLAGS"
++      AC_LIB_LINKFLAGS([pth])
++      gl_have_pth=
++      gl_save_LIBS="$LIBS"
++      LIBS="$LIBS -lpth"
++      AC_TRY_LINK([#include <pth.h>], [pth_self();], [gl_have_pth=yes])
++      LIBS="$gl_save_LIBS"
++      if test -n "$gl_have_pth"; then
++        gl_threads_api=pth
++        LIBTHREAD="$LIBPTH"
++        LTLIBTHREAD="$LTLIBPTH"
++        LIBMULTITHREAD="$LIBTHREAD"
++        LTLIBMULTITHREAD="$LTLIBTHREAD"
++        AC_DEFINE([USE_PTH_THREADS], [1],
++          [Define if the GNU Pth multithreading library can be used.])
++        if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
++          if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
++            AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
++              [Define if references to the GNU Pth multithreading library should be made weak.])
++            LIBTHREAD=
++            LTLIBTHREAD=
++          fi
++        fi
++      else
++        CPPFLAGS="$gl_save_CPPFLAGS"
++      fi
++    fi
++    if test -z "$gl_have_pthread"; then
++      if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
++        if { case "$host_os" in
++               mingw*) true;;
++               *) false;;
++             esac
++           }; then
++          gl_threads_api=win32
++          AC_DEFINE([USE_WIN32_THREADS], [1],
++            [Define if the Win32 multithreading API can be used.])
++        fi
++      fi
++    fi
++  fi
++  AC_MSG_CHECKING([for multithread API to use])
++  AC_MSG_RESULT([$gl_threads_api])
++  AC_SUBST([LIBTHREAD])
++  AC_SUBST([LTLIBTHREAD])
++  AC_SUBST([LIBMULTITHREAD])
++  AC_SUBST([LTLIBMULTITHREAD])
++])
++
++AC_DEFUN([gl_THREADLIB],
++[
++  AC_REQUIRE([gl_THREADLIB_EARLY])
++  AC_REQUIRE([gl_THREADLIB_BODY])
++])
++
++
++dnl gl_DISABLE_THREADS
++dnl ------------------
++dnl Sets the gl_THREADLIB default so that threads are not used by default.
++dnl The user can still override it at installation time, by using the
++dnl configure option '--enable-threads'.
++
++AC_DEFUN([gl_DISABLE_THREADS], [
++  m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
++])
++
++
++dnl Survey of platforms:
++dnl
++dnl Platform          Available   Compiler    Supports   test-lock
++dnl                   flavours    option      weak       result
++dnl ---------------   ---------   ---------   --------   ---------
++dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
++dnl
++dnl GNU Hurd/glibc    posix
++dnl
++dnl FreeBSD 5.3       posix       -lc_r           Y
++dnl                   posix       -lkse ?         Y
++dnl                   posix       -lpthread ?     Y
++dnl                   posix       -lthr           Y
++dnl
++dnl FreeBSD 5.2       posix       -lc_r           Y
++dnl                   posix       -lkse           Y
++dnl                   posix       -lthr           Y
++dnl
++dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
++dnl
++dnl NetBSD 1.6        --
++dnl
++dnl OpenBSD 3.4       posix       -lpthread       Y      OK
++dnl
++dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
++dnl
++dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
++dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
++dnl
++dnl HP-UX 11          posix       -lpthread       N (cc) OK
++dnl                                               Y (gcc)
++dnl
++dnl IRIX 6.5          posix       -lpthread       Y      0.5
++dnl
++dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
++dnl
++dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
++dnl                               -lpthread (gcc) Y
++dnl
++dnl Cygwin            posix       -lpthread       Y      OK
++dnl
++dnl Any of the above  pth         -lpth                  0.0
++dnl
++dnl Mingw             win32                       N      OK
++dnl
++dnl BeOS 5            --
++dnl
++dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
++dnl turned off:
++dnl   OK if all three tests terminate OK,
++dnl   0.5 if the first test terminates OK but the second one loops endlessly,
++dnl   0.0 if the first test already loops endlessly.
+diff --git a/m4/uintmax_t.m4 b/m4/uintmax_t.m4
+new file mode 100644
+index 0000000..03b51bc
+--- /dev/null
++++ b/m4/uintmax_t.m4
+@@ -0,0 +1,30 @@
++# uintmax_t.m4 serial 12
++dnl Copyright (C) 1997-2004, 2007-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Paul Eggert.
++
++AC_PREREQ([2.13])
++
++# Define uintmax_t to 'unsigned long' or 'unsigned long long'
++# if it is not already defined in <stdint.h> or <inttypes.h>.
++
++AC_DEFUN([gl_AC_TYPE_UINTMAX_T],
++[
++  AC_REQUIRE([gl_AC_HEADER_INTTYPES_H])
++  AC_REQUIRE([gl_AC_HEADER_STDINT_H])
++  if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then
++    AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT])
++    test $ac_cv_type_unsigned_long_long_int = yes \
++      && ac_type='unsigned long long' \
++      || ac_type='unsigned long'
++    AC_DEFINE_UNQUOTED([uintmax_t], [$ac_type],
++      [Define to unsigned long or unsigned long long
++       if <stdint.h> and <inttypes.h> don't define.])
++  else
++    AC_DEFINE([HAVE_UINTMAX_T], [1],
++      [Define if you have the 'uintmax_t' type in <stdint.h> or <inttypes.h>.])
++  fi
++])
+diff --git a/m4/visibility.m4 b/m4/visibility.m4
+new file mode 100644
+index 0000000..077c476
+--- /dev/null
++++ b/m4/visibility.m4
+@@ -0,0 +1,74 @@
++# visibility.m4 serial 3 (gettext-0.18)
++dnl Copyright (C) 2005, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++dnl Tests whether the compiler supports the command-line option
++dnl -fvisibility=hidden and the function and variable attributes
++dnl __attribute__((__visibility__("hidden"))) and
++dnl __attribute__((__visibility__("default"))).
++dnl Does *not* test for __visibility__("protected") - which has tricky
++dnl semantics (see the 'vismain' test in glibc) and does not exist e.g. on
++dnl MacOS X.
++dnl Does *not* test for __visibility__("internal") - which has processor
++dnl dependent semantics.
++dnl Does *not* test for #pragma GCC visibility push(hidden) - which is
++dnl "really only recommended for legacy code".
++dnl Set the variable CFLAG_VISIBILITY.
++dnl Defines and sets the variable HAVE_VISIBILITY.
++
++AC_DEFUN([gl_VISIBILITY],
++[
++  AC_REQUIRE([AC_PROG_CC])
++  CFLAG_VISIBILITY=
++  HAVE_VISIBILITY=0
++  if test -n "$GCC"; then
++    dnl First, check whether -Werror can be added to the command line, or
++    dnl whether it leads to an error because of some other option that the
++    dnl user has put into $CC $CFLAGS $CPPFLAGS.
++    AC_MSG_CHECKING([whether the -Werror option is usable])
++    AC_CACHE_VAL([gl_cv_cc_vis_werror], [
++      gl_save_CFLAGS="$CFLAGS"
++      CFLAGS="$CFLAGS -Werror"
++      AC_TRY_COMPILE([], [],
++        [gl_cv_cc_vis_werror=yes],
++        [gl_cv_cc_vis_werror=no])
++      CFLAGS="$gl_save_CFLAGS"])
++    AC_MSG_RESULT([$gl_cv_cc_vis_werror])
++    dnl Now check whether visibility declarations are supported.
++    AC_MSG_CHECKING([for simple visibility declarations])
++    AC_CACHE_VAL([gl_cv_cc_visibility], [
++      gl_save_CFLAGS="$CFLAGS"
++      CFLAGS="$CFLAGS -fvisibility=hidden"
++      dnl We use the option -Werror and a function dummyfunc, because on some
++      dnl platforms (Cygwin 1.7) the use of -fvisibility triggers a warning
++      dnl "visibility attribute not supported in this configuration; ignored"
++      dnl at the first function definition in every compilation unit, and we
++      dnl don't want to use the option in this case.
++      if test $gl_cv_cc_vis_werror = yes; then
++        CFLAGS="$CFLAGS -Werror"
++      fi
++      AC_TRY_COMPILE(
++        [extern __attribute__((__visibility__("hidden"))) int hiddenvar;
++         extern __attribute__((__visibility__("default"))) int exportedvar;
++         extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void);
++         extern __attribute__((__visibility__("default"))) int exportedfunc (void);
++         void dummyfunc (void) {}],
++        [],
++        [gl_cv_cc_visibility=yes],
++        [gl_cv_cc_visibility=no])
++      CFLAGS="$gl_save_CFLAGS"])
++    AC_MSG_RESULT([$gl_cv_cc_visibility])
++    if test $gl_cv_cc_visibility = yes; then
++      CFLAG_VISIBILITY="-fvisibility=hidden"
++      HAVE_VISIBILITY=1
++    fi
++  fi
++  AC_SUBST([CFLAG_VISIBILITY])
++  AC_SUBST([HAVE_VISIBILITY])
++  AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY],
++    [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.])
++])
+diff --git a/m4/wchar_t.m4 b/m4/wchar_t.m4
+new file mode 100644
+index 0000000..ed804e6
+--- /dev/null
++++ b/m4/wchar_t.m4
+@@ -0,0 +1,20 @@
++# wchar_t.m4 serial 3 (gettext-0.18)
++dnl Copyright (C) 2002-2003, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++dnl Test whether <stddef.h> has the 'wchar_t' type.
++dnl Prerequisite: AC_PROG_CC
++
++AC_DEFUN([gt_TYPE_WCHAR_T],
++[
++  AC_CACHE_CHECK([for wchar_t], [gt_cv_c_wchar_t],
++    [AC_TRY_COMPILE([#include <stddef.h>
++       wchar_t foo = (wchar_t)'\0';], ,
++       [gt_cv_c_wchar_t=yes], [gt_cv_c_wchar_t=no])])
++  if test $gt_cv_c_wchar_t = yes; then
++    AC_DEFINE([HAVE_WCHAR_T], [1], [Define if you have the 'wchar_t' type.])
++  fi
++])
+diff --git a/m4/wint_t.m4 b/m4/wint_t.m4
+new file mode 100644
+index 0000000..a6c7d15
+--- /dev/null
++++ b/m4/wint_t.m4
+@@ -0,0 +1,28 @@
++# wint_t.m4 serial 4 (gettext-0.18)
++dnl Copyright (C) 2003, 2007-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++dnl Test whether <wchar.h> has the 'wint_t' type.
++dnl Prerequisite: AC_PROG_CC
++
++AC_DEFUN([gt_TYPE_WINT_T],
++[
++  AC_CACHE_CHECK([for wint_t], [gt_cv_c_wint_t],
++    [AC_TRY_COMPILE([
++/* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before
++   <wchar.h>.
++   BSD/OS 4.0.1 has a bug: <stddef.h>, <stdio.h> and <time.h> must be included
++   before <wchar.h>.  */
++#include <stddef.h>
++#include <stdio.h>
++#include <time.h>
++#include <wchar.h>
++       wint_t foo = (wchar_t)'\0';], ,
++       [gt_cv_c_wint_t=yes], [gt_cv_c_wint_t=no])])
++  if test $gt_cv_c_wint_t = yes; then
++    AC_DEFINE([HAVE_WINT_T], [1], [Define if you have the 'wint_t' type.])
++  fi
++])
+diff --git a/m4/xsize.m4 b/m4/xsize.m4
+new file mode 100644
+index 0000000..b653693
+--- /dev/null
++++ b/m4/xsize.m4
+@@ -0,0 +1,13 @@
++# xsize.m4 serial 4
++dnl Copyright (C) 2003-2004, 2008-2010 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++AC_DEFUN([gl_XSIZE],
++[
++  dnl Prerequisites of lib/xsize.h.
++  AC_REQUIRE([gl_SIZE_MAX])
++  AC_REQUIRE([AC_C_INLINE])
++  AC_CHECK_HEADERS([stdint.h])
++])
+diff --git a/po/Makefile.in.in b/po/Makefile.in.in
+new file mode 100644
+index 0000000..83d8838
+--- /dev/null
++++ b/po/Makefile.in.in
+@@ -0,0 +1,444 @@
++# Makefile for PO directory in any package using GNU gettext.
++# Copyright (C) 1995-1997, 2000-2007, 2009-2010 by Ulrich Drepper <drepper@gnu.ai.mit.edu>
++#
++# This file can be copied and used freely without restrictions.  It can
++# be used in projects which are not available under the GNU General Public
++# License but which still want to provide support for the GNU gettext
++# functionality.
++# Please note that the actual code of GNU gettext is covered by the GNU
++# General Public License and is *not* in the public domain.
++#
++# Origin: gettext-0.18
++GETTEXT_MACRO_VERSION = 0.18
++
++PACKAGE = @PACKAGE@
++VERSION = @VERSION@
++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
++
++SHELL = /bin/sh
++@SET_MAKE@
++
++srcdir = @srcdir@
++top_srcdir = @top_srcdir@
++VPATH = @srcdir@
++
++prefix = @prefix@
++exec_prefix = @exec_prefix@
++datarootdir = @datarootdir@
++datadir = @datadir@
++localedir = @localedir@
++gettextsrcdir = $(datadir)/gettext/po
++
++INSTALL = @INSTALL@
++INSTALL_DATA = @INSTALL_DATA@
++
++# We use $(mkdir_p).
++# In automake <= 1.9.x, $(mkdir_p) is defined either as "mkdir -p --" or as
++# "$(mkinstalldirs)" or as "$(install_sh) -d". For these automake versions,
++# @install_sh@ does not start with $(SHELL), so we add it.
++# In automake >= 1.10, @mkdir_p@ is derived from ${MKDIR_P}, which is defined
++# either as "/path/to/mkdir -p" or ".../install-sh -c -d". For these automake
++# versions, $(mkinstalldirs) and $(install_sh) are unused.
++mkinstalldirs = $(SHELL) @install_sh@ -d
++install_sh = $(SHELL) @install_sh@
++MKDIR_P = @MKDIR_P@
++mkdir_p = @mkdir_p@
++
++GMSGFMT_ = @GMSGFMT@
++GMSGFMT_no = @GMSGFMT@
++GMSGFMT_yes = @GMSGFMT_015@
++GMSGFMT = $(GMSGFMT_$(USE_MSGCTXT))
++MSGFMT_ = @MSGFMT@
++MSGFMT_no = @MSGFMT@
++MSGFMT_yes = @MSGFMT_015@
++MSGFMT = $(MSGFMT_$(USE_MSGCTXT))
++XGETTEXT_ = @XGETTEXT@
++XGETTEXT_no = @XGETTEXT@
++XGETTEXT_yes = @XGETTEXT_015@
++XGETTEXT = $(XGETTEXT_$(USE_MSGCTXT))
++MSGMERGE = msgmerge
++MSGMERGE_UPDATE = @MSGMERGE@ --update
++MSGINIT = msginit
++MSGCONV = msgconv
++MSGFILTER = msgfilter
++
++POFILES = @POFILES@
++GMOFILES = @GMOFILES@
++UPDATEPOFILES = @UPDATEPOFILES@
++DUMMYPOFILES = @DUMMYPOFILES@
++DISTFILES.common = Makefile.in.in remove-potcdate.sin \
++$(DISTFILES.common.extra1) $(DISTFILES.common.extra2) $(DISTFILES.common.extra3)
++DISTFILES = $(DISTFILES.common) Makevars POTFILES.in \
++$(POFILES) $(GMOFILES) \
++$(DISTFILES.extra1) $(DISTFILES.extra2) $(DISTFILES.extra3)
++
++POTFILES = \
++
++CATALOGS = @CATALOGS@
++
++# Makevars gets inserted here. (Don't remove this line!)
++
++.SUFFIXES:
++.SUFFIXES: .po .gmo .mo .sed .sin .nop .po-create .po-update
++
++.po.mo:
++	@echo "$(MSGFMT) -c -o $@ $<"; \
++	$(MSGFMT) -c -o t-$@ $< && mv t-$@ $@
++
++.po.gmo:
++	@lang=`echo $* | sed -e 's,.*/,,'`; \
++	test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \
++	echo "$${cdcmd}rm -f $${lang}.gmo && $(GMSGFMT) -c --statistics --verbose -o $${lang}.gmo $${lang}.po"; \
++	cd $(srcdir) && rm -f $${lang}.gmo && $(GMSGFMT) -c --statistics --verbose -o t-$${lang}.gmo $${lang}.po && mv t-$${lang}.gmo $${lang}.gmo
++
++.sin.sed:
++	sed -e '/^#/d' $< > t-$@
++	mv t-$@ $@
++
++
++all: check-macro-version all-@USE_NLS@
++
++all-yes: stamp-po
++all-no:
++
++# Ensure that the gettext macros and this Makefile.in.in are in sync.
++check-macro-version:
++	@test "$(GETTEXT_MACRO_VERSION)" = "@GETTEXT_MACRO_VERSION@" \
++	  || { echo "*** error: gettext infrastructure mismatch: using a Makefile.in.in from gettext version $(GETTEXT_MACRO_VERSION) but the autoconf macros are from gettext version @GETTEXT_MACRO_VERSION@" 1>&2; \
++	       exit 1; \
++	     }
++
++# $(srcdir)/$(DOMAIN).pot is only created when needed. When xgettext finds no
++# internationalized messages, no $(srcdir)/$(DOMAIN).pot is created (because
++# we don't want to bother translators with empty POT files). We assume that
++# LINGUAS is empty in this case, i.e. $(POFILES) and $(GMOFILES) are empty.
++# In this case, stamp-po is a nop (i.e. a phony target).
++
++# stamp-po is a timestamp denoting the last time at which the CATALOGS have
++# been loosely updated. Its purpose is that when a developer or translator
++# checks out the package via CVS, and the $(DOMAIN).pot file is not in CVS,
++# "make" will update the $(DOMAIN).pot and the $(CATALOGS), but subsequent
++# invocations of "make" will do nothing. This timestamp would not be necessary
++# if updating the $(CATALOGS) would always touch them; however, the rule for
++# $(POFILES) has been designed to not touch files that don't need to be
++# changed.
++stamp-po: $(srcdir)/$(DOMAIN).pot
++	test ! -f $(srcdir)/$(DOMAIN).pot || \
++	  test -z "$(GMOFILES)" || $(MAKE) $(GMOFILES)
++	@test ! -f $(srcdir)/$(DOMAIN).pot || { \
++	  echo "touch stamp-po" && \
++	  echo timestamp > stamp-poT && \
++	  mv stamp-poT stamp-po; \
++	}
++
++# Note: Target 'all' must not depend on target '$(DOMAIN).pot-update',
++# otherwise packages like GCC can not be built if only parts of the source
++# have been downloaded.
++
++# This target rebuilds $(DOMAIN).pot; it is an expensive operation.
++# Note that $(DOMAIN).pot is not touched if it doesn't need to be changed.
++$(DOMAIN).pot-update: $(POTFILES) $(srcdir)/POTFILES.in remove-potcdate.sed
++	if LC_ALL=C grep 'GNU @PACKAGE@' $(top_srcdir)/* 2>/dev/null | grep -v 'libtool:' >/dev/null; then \
++	  package_gnu='GNU '; \
++	else \
++	  package_gnu=''; \
++	fi; \
++	if test -n '$(MSGID_BUGS_ADDRESS)' || test '$(PACKAGE_BUGREPORT)' = '@'PACKAGE_BUGREPORT'@'; then \
++	  msgid_bugs_address='$(MSGID_BUGS_ADDRESS)'; \
++	else \
++	  msgid_bugs_address='$(PACKAGE_BUGREPORT)'; \
++	fi; \
++	case `$(XGETTEXT) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \
++	  '' | 0.[0-9] | 0.[0-9].* | 0.1[0-5] | 0.1[0-5].* | 0.16 | 0.16.[0-1]*) \
++	    $(XGETTEXT) --default-domain=$(DOMAIN) --directory=$(top_srcdir) \
++	      --add-comments=TRANSLATORS: $(XGETTEXT_OPTIONS) @XGETTEXT_EXTRA_OPTIONS@ \
++	      --files-from=$(srcdir)/POTFILES.in \
++	      --copyright-holder='$(COPYRIGHT_HOLDER)' \
++	      --msgid-bugs-address="$$msgid_bugs_address" \
++	    ;; \
++	  *) \
++	    $(XGETTEXT) --default-domain=$(DOMAIN) --directory=$(top_srcdir) \
++	      --add-comments=TRANSLATORS: $(XGETTEXT_OPTIONS) @XGETTEXT_EXTRA_OPTIONS@ \
++	      --files-from=$(srcdir)/POTFILES.in \
++	      --copyright-holder='$(COPYRIGHT_HOLDER)' \
++	      --package-name="$${package_gnu}@PACKAGE@" \
++	      --package-version='@VERSION@' \
++	      --msgid-bugs-address="$$msgid_bugs_address" \
++	    ;; \
++	esac
++	test ! -f $(DOMAIN).po || { \
++	  if test -f $(srcdir)/$(DOMAIN).pot; then \
++	    sed -f remove-potcdate.sed < $(srcdir)/$(DOMAIN).pot > $(DOMAIN).1po && \
++	    sed -f remove-potcdate.sed < $(DOMAIN).po > $(DOMAIN).2po && \
++	    if cmp $(DOMAIN).1po $(DOMAIN).2po >/dev/null 2>&1; then \
++	      rm -f $(DOMAIN).1po $(DOMAIN).2po $(DOMAIN).po; \
++	    else \
++	      rm -f $(DOMAIN).1po $(DOMAIN).2po $(srcdir)/$(DOMAIN).pot && \
++	      mv $(DOMAIN).po $(srcdir)/$(DOMAIN).pot; \
++	    fi; \
++	  else \
++	    mv $(DOMAIN).po $(srcdir)/$(DOMAIN).pot; \
++	  fi; \
++	}
++
++# This rule has no dependencies: we don't need to update $(DOMAIN).pot at
++# every "make" invocation, only create it when it is missing.
++# Only "make $(DOMAIN).pot-update" or "make dist" will force an update.
++$(srcdir)/$(DOMAIN).pot:
++	$(MAKE) $(DOMAIN).pot-update
++
++# This target rebuilds a PO file if $(DOMAIN).pot has changed.
++# Note that a PO file is not touched if it doesn't need to be changed.
++$(POFILES): $(srcdir)/$(DOMAIN).pot
++	@lang=`echo $@ | sed -e 's,.*/,,' -e 's/\.po$$//'`; \
++	if test -f "$(srcdir)/$${lang}.po"; then \
++	  test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \
++	  echo "$${cdcmd}$(MSGMERGE_UPDATE) $(MSGMERGE_OPTIONS) --lang=$${lang} $${lang}.po $(DOMAIN).pot"; \
++	  cd $(srcdir) \
++	    && { case `$(MSGMERGE_UPDATE) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \
++	           '' | 0.[0-9] | 0.[0-9].* | 0.1[0-7] | 0.1[0-7].*) \
++	             $(MSGMERGE_UPDATE) $(MSGMERGE_OPTIONS) $${lang}.po $(DOMAIN).pot;; \
++	           *) \
++	             $(MSGMERGE_UPDATE) $(MSGMERGE_OPTIONS) --lang=$${lang} $${lang}.po $(DOMAIN).pot;; \
++	         esac; \
++	       }; \
++	else \
++	  $(MAKE) $${lang}.po-create; \
++	fi
++
++
++install: install-exec install-data
++install-exec:
++install-data: install-data-@USE_NLS@
++	if test "$(PACKAGE)" = "gettext-tools"; then \
++	  $(mkdir_p) $(DESTDIR)$(gettextsrcdir); \
++	  for file in $(DISTFILES.common) Makevars.template; do \
++	    $(INSTALL_DATA) $(srcdir)/$$file \
++			    $(DESTDIR)$(gettextsrcdir)/$$file; \
++	  done; \
++	  for file in Makevars; do \
++	    rm -f $(DESTDIR)$(gettextsrcdir)/$$file; \
++	  done; \
++	else \
++	  : ; \
++	fi
++install-data-no: all
++install-data-yes: all
++	@catalogs='$(CATALOGS)'; \
++	for cat in $$catalogs; do \
++	  cat=`basename $$cat`; \
++	  lang=`echo $$cat | sed -e 's/\.gmo$$//'`; \
++	  dir=$(localedir)/$$lang/LC_MESSAGES; \
++	  $(mkdir_p) $(DESTDIR)$$dir; \
++	  if test -r $$cat; then realcat=$$cat; else realcat=$(srcdir)/$$cat; fi; \
++	  $(INSTALL_DATA) $$realcat $(DESTDIR)$$dir/$(DOMAIN).mo; \
++	  echo "installing $$realcat as $(DESTDIR)$$dir/$(DOMAIN).mo"; \
++	  for lc in '' $(EXTRA_LOCALE_CATEGORIES); do \
++	    if test -n "$$lc"; then \
++	      if (cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc 2>/dev/null) | grep ' -> ' >/dev/null; then \
++	        link=`cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc | sed -e 's/^.* -> //'`; \
++	        mv $(DESTDIR)$(localedir)/$$lang/$$lc $(DESTDIR)$(localedir)/$$lang/$$lc.old; \
++	        mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \
++	        (cd $(DESTDIR)$(localedir)/$$lang/$$lc.old && \
++	         for file in *; do \
++	           if test -f $$file; then \
++	             ln -s ../$$link/$$file $(DESTDIR)$(localedir)/$$lang/$$lc/$$file; \
++	           fi; \
++	         done); \
++	        rm -f $(DESTDIR)$(localedir)/$$lang/$$lc.old; \
++	      else \
++	        if test -d $(DESTDIR)$(localedir)/$$lang/$$lc; then \
++	          :; \
++	        else \
++	          rm -f $(DESTDIR)$(localedir)/$$lang/$$lc; \
++	          mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \
++	        fi; \
++	      fi; \
++	      rm -f $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo; \
++	      ln -s ../LC_MESSAGES/$(DOMAIN).mo $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo 2>/dev/null || \
++	      ln $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(DOMAIN).mo $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo 2>/dev/null || \
++	      cp -p $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(DOMAIN).mo $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo; \
++	      echo "installing $$realcat link as $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo"; \
++	    fi; \
++	  done; \
++	done
++
++install-strip: install
++
++installdirs: installdirs-exec installdirs-data
++installdirs-exec:
++installdirs-data: installdirs-data-@USE_NLS@
++	if test "$(PACKAGE)" = "gettext-tools"; then \
++	  $(mkdir_p) $(DESTDIR)$(gettextsrcdir); \
++	else \
++	  : ; \
++	fi
++installdirs-data-no:
++installdirs-data-yes:
++	@catalogs='$(CATALOGS)'; \
++	for cat in $$catalogs; do \
++	  cat=`basename $$cat`; \
++	  lang=`echo $$cat | sed -e 's/\.gmo$$//'`; \
++	  dir=$(localedir)/$$lang/LC_MESSAGES; \
++	  $(mkdir_p) $(DESTDIR)$$dir; \
++	  for lc in '' $(EXTRA_LOCALE_CATEGORIES); do \
++	    if test -n "$$lc"; then \
++	      if (cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc 2>/dev/null) | grep ' -> ' >/dev/null; then \
++	        link=`cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc | sed -e 's/^.* -> //'`; \
++	        mv $(DESTDIR)$(localedir)/$$lang/$$lc $(DESTDIR)$(localedir)/$$lang/$$lc.old; \
++	        mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \
++	        (cd $(DESTDIR)$(localedir)/$$lang/$$lc.old && \
++	         for file in *; do \
++	           if test -f $$file; then \
++	             ln -s ../$$link/$$file $(DESTDIR)$(localedir)/$$lang/$$lc/$$file; \
++	           fi; \
++	         done); \
++	        rm -f $(DESTDIR)$(localedir)/$$lang/$$lc.old; \
++	      else \
++	        if test -d $(DESTDIR)$(localedir)/$$lang/$$lc; then \
++	          :; \
++	        else \
++	          rm -f $(DESTDIR)$(localedir)/$$lang/$$lc; \
++	          mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \
++	        fi; \
++	      fi; \
++	    fi; \
++	  done; \
++	done
++
++# Define this as empty until I found a useful application.
++installcheck:
++
++uninstall: uninstall-exec uninstall-data
++uninstall-exec:
++uninstall-data: uninstall-data-@USE_NLS@
++	if test "$(PACKAGE)" = "gettext-tools"; then \
++	  for file in $(DISTFILES.common) Makevars.template; do \
++	    rm -f $(DESTDIR)$(gettextsrcdir)/$$file; \
++	  done; \
++	else \
++	  : ; \
++	fi
++uninstall-data-no:
++uninstall-data-yes:
++	catalogs='$(CATALOGS)'; \
++	for cat in $$catalogs; do \
++	  cat=`basename $$cat`; \
++	  lang=`echo $$cat | sed -e 's/\.gmo$$//'`; \
++	  for lc in LC_MESSAGES $(EXTRA_LOCALE_CATEGORIES); do \
++	    rm -f $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo; \
++	  done; \
++	done
++
++check: all
++
++info dvi ps pdf html tags TAGS ctags CTAGS ID:
++
++mostlyclean:
++	rm -f remove-potcdate.sed
++	rm -f stamp-poT
++	rm -f core core.* $(DOMAIN).po $(DOMAIN).1po $(DOMAIN).2po *.new.po
++	rm -fr *.o
++
++clean: mostlyclean
++
++distclean: clean
++	rm -f Makefile Makefile.in POTFILES *.mo
++
++maintainer-clean: distclean
++	@echo "This command is intended for maintainers to use;"
++	@echo "it deletes files that may require special tools to rebuild."
++	rm -f stamp-po $(GMOFILES)
++
++distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
++dist distdir:
++	$(MAKE) update-po
++	@$(MAKE) dist2
++# This is a separate target because 'update-po' must be executed before.
++dist2: stamp-po $(DISTFILES)
++	dists="$(DISTFILES)"; \
++	if test "$(PACKAGE)" = "gettext-tools"; then \
++	  dists="$$dists Makevars.template"; \
++	fi; \
++	if test -f $(srcdir)/$(DOMAIN).pot; then \
++	  dists="$$dists $(DOMAIN).pot stamp-po"; \
++	fi; \
++	if test -f $(srcdir)/ChangeLog; then \
++	  dists="$$dists ChangeLog"; \
++	fi; \
++	for i in 0 1 2 3 4 5 6 7 8 9; do \
++	  if test -f $(srcdir)/ChangeLog.$$i; then \
++	    dists="$$dists ChangeLog.$$i"; \
++	  fi; \
++	done; \
++	if test -f $(srcdir)/LINGUAS; then dists="$$dists LINGUAS"; fi; \
++	for file in $$dists; do \
++	  if test -f $$file; then \
++	    cp -p $$file $(distdir) || exit 1; \
++	  else \
++	    cp -p $(srcdir)/$$file $(distdir) || exit 1; \
++	  fi; \
++	done
++
++update-po: Makefile
++	$(MAKE) $(DOMAIN).pot-update
++	test -z "$(UPDATEPOFILES)" || $(MAKE) $(UPDATEPOFILES)
++	$(MAKE) update-gmo
++
++# General rule for creating PO files.
++
++.nop.po-create:
++	@lang=`echo $@ | sed -e 's/\.po-create$$//'`; \
++	echo "File $$lang.po does not exist. If you are a translator, you can create it through 'msginit'." 1>&2; \
++	exit 1
++
++# General rule for updating PO files.
++
++.nop.po-update:
++	@lang=`echo $@ | sed -e 's/\.po-update$$//'`; \
++	if test "$(PACKAGE)" = "gettext-tools"; then PATH=`pwd`/../src:$$PATH; fi; \
++	tmpdir=`pwd`; \
++	echo "$$lang:"; \
++	test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \
++	echo "$${cdcmd}$(MSGMERGE) $(MSGMERGE_OPTIONS) --lang=$$lang $$lang.po $(DOMAIN).pot -o $$lang.new.po"; \
++	cd $(srcdir); \
++	if { case `$(MSGMERGE) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \
++	       '' | 0.[0-9] | 0.[0-9].* | 0.1[0-7] | 0.1[0-7].*) \
++	         $(MSGMERGE) $(MSGMERGE_OPTIONS) -o $$tmpdir/$$lang.new.po $$lang.po $(DOMAIN).pot;; \
++	       *) \
++	         $(MSGMERGE) $(MSGMERGE_OPTIONS) --lang=$$lang -o $$tmpdir/$$lang.new.po $$lang.po $(DOMAIN).pot;; \
++	     esac; \
++	   }; then \
++	  if cmp $$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \
++	    rm -f $$tmpdir/$$lang.new.po; \
++	  else \
++	    if mv -f $$tmpdir/$$lang.new.po $$lang.po; then \
++	      :; \
++	    else \
++	      echo "msgmerge for $$lang.po failed: cannot move $$tmpdir/$$lang.new.po to $$lang.po" 1>&2; \
++	      exit 1; \
++	    fi; \
++	  fi; \
++	else \
++	  echo "msgmerge for $$lang.po failed!" 1>&2; \
++	  rm -f $$tmpdir/$$lang.new.po; \
++	fi
++
++$(DUMMYPOFILES):
++
++update-gmo: Makefile $(GMOFILES)
++	@:
++
++# Recreate Makefile by invoking config.status. Explicitly invoke the shell,
++# because execution permission bits may not work on the current file system.
++# Use @SHELL@, which is the shell determined by autoconf for the use by its
++# scripts, not $(SHELL) which is hardwired to /bin/sh and may be deficient.
++Makefile: Makefile.in.in Makevars $(top_builddir)/config.status @POMAKEFILEDEPS@
++	cd $(top_builddir) \
++	  && @SHELL@ ./config.status $(subdir)/$@.in po-directories
++
++force:
++
++# Tell versions [3.59,3.63) of GNU make not to export all variables.
++# Otherwise a system limit (for SysV at least) may be exceeded.
++.NOEXPORT:
+diff --git a/po/Makevars.template b/po/Makevars.template
+new file mode 100644
+index 0000000..32692ab
+--- /dev/null
++++ b/po/Makevars.template
+@@ -0,0 +1,41 @@
++# Makefile variables for PO directory in any package using GNU gettext.
++
++# Usually the message domain is the same as the package name.
++DOMAIN = $(PACKAGE)
++
++# These two variables depend on the location of this directory.
++subdir = po
++top_builddir = ..
++
++# These options get passed to xgettext.
++XGETTEXT_OPTIONS = --keyword=_ --keyword=N_
++
++# This is the copyright holder that gets inserted into the header of the
++# $(DOMAIN).pot file.  Set this to the copyright holder of the surrounding
++# package.  (Note that the msgstr strings, extracted from the package's
++# sources, belong to the copyright holder of the package.)  Translators are
++# expected to transfer the copyright for their translations to this person
++# or entity, or to disclaim their copyright.  The empty string stands for
++# the public domain; in this case the translators are expected to disclaim
++# their copyright.
++COPYRIGHT_HOLDER = Free Software Foundation, Inc.
++
++# This is the email address or URL to which the translators shall report
++# bugs in the untranslated strings:
++# - Strings which are not entire sentences, see the maintainer guidelines
++#   in the GNU gettext documentation, section 'Preparing Strings'.
++# - Strings which use unclear terms or require additional context to be
++#   understood.
++# - Strings which make invalid assumptions about notation of date, time or
++#   money.
++# - Pluralisation problems.
++# - Incorrect English spelling.
++# - Incorrect formatting.
++# It can be your email address, or a mailing list address where translators
++# can write to without being subscribed, or the URL of a web page through
++# which the translators can contact you.
++MSGID_BUGS_ADDRESS =
++
++# This is the list of locale categories, beyond LC_MESSAGES, for which the
++# message catalogs shall be used.  It is usually empty.
++EXTRA_LOCALE_CATEGORIES =
+diff --git a/po/Rules-quot b/po/Rules-quot
+new file mode 100644
+index 0000000..af52487
+--- /dev/null
++++ b/po/Rules-quot
+@@ -0,0 +1,47 @@
++# Special Makefile rules for English message catalogs with quotation marks.
++
++DISTFILES.common.extra1 = quot.sed boldquot.sed en@quot.header en@boldquot.header insert-header.sin Rules-quot
++
++.SUFFIXES: .insert-header .po-update-en
++
++en@quot.po-create:
++	$(MAKE) en@quot.po-update
++en@boldquot.po-create:
++	$(MAKE) en@boldquot.po-update
++
++en@quot.po-update: en@quot.po-update-en
++en@boldquot.po-update: en@boldquot.po-update-en
++
++.insert-header.po-update-en:
++	@lang=`echo $@ | sed -e 's/\.po-update-en$$//'`; \
++	if test "$(PACKAGE)" = "gettext"; then PATH=`pwd`/../src:$$PATH; GETTEXTLIBDIR=`cd $(top_srcdir)/src && pwd`; export GETTEXTLIBDIR; fi; \
++	tmpdir=`pwd`; \
++	echo "$$lang:"; \
++	ll=`echo $$lang | sed -e 's/@.*//'`; \
++	LC_ALL=C; export LC_ALL; \
++	cd $(srcdir); \
++	if $(MSGINIT) -i $(DOMAIN).pot --no-translator -l $$lang -o - 2>/dev/null | sed -f $$tmpdir/$$lang.insert-header | $(MSGCONV) -t UTF-8 | $(MSGFILTER) sed -f `echo $$lang | sed -e 's/.*@//'`.sed 2>/dev/null > $$tmpdir/$$lang.new.po; then \
++	  if cmp $$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \
++	    rm -f $$tmpdir/$$lang.new.po; \
++	  else \
++	    if mv -f $$tmpdir/$$lang.new.po $$lang.po; then \
++	      :; \
++	    else \
++	      echo "creation of $$lang.po failed: cannot move $$tmpdir/$$lang.new.po to $$lang.po" 1>&2; \
++	      exit 1; \
++	    fi; \
++	  fi; \
++	else \
++	  echo "creation of $$lang.po failed!" 1>&2; \
++	  rm -f $$tmpdir/$$lang.new.po; \
++	fi
++
++en@quot.insert-header: insert-header.sin
++	sed -e '/^#/d' -e 's/HEADER/en@quot.header/g' $(srcdir)/insert-header.sin > en@quot.insert-header
++
++en@boldquot.insert-header: insert-header.sin
++	sed -e '/^#/d' -e 's/HEADER/en@boldquot.header/g' $(srcdir)/insert-header.sin > en@boldquot.insert-header
++
++mostlyclean: mostlyclean-quot
++mostlyclean-quot:
++	rm -f *.insert-header
+diff --git a/po/boldquot.sed b/po/boldquot.sed
+new file mode 100644
+index 0000000..4b937aa
+--- /dev/null
++++ b/po/boldquot.sed
+@@ -0,0 +1,10 @@
++s/"\([^"]*\)"/“\1”/g
++s/`\([^`']*\)'/‘\1’/g
++s/ '\([^`']*\)' / ‘\1’ /g
++s/ '\([^`']*\)'$/ ‘\1’/g
++s/^'\([^`']*\)' /‘\1’ /g
++s/“”/""/g
++s/“/“[1m/g
++s/”/[0m”/g
++s/‘/‘[1m/g
++s/’/[0m’/g
+diff --git a/po/en@boldquot.header b/po/en@boldquot.header
+new file mode 100644
+index 0000000..fedb6a0
+--- /dev/null
++++ b/po/en@boldquot.header
+@@ -0,0 +1,25 @@
++# All this catalog "translates" are quotation characters.
++# The msgids must be ASCII and therefore cannot contain real quotation
++# characters, only substitutes like grave accent (0x60), apostrophe (0x27)
++# and double quote (0x22). These substitutes look strange; see
++# http://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html
++#
++# This catalog translates grave accent (0x60) and apostrophe (0x27) to
++# left single quotation mark (U+2018) and right single quotation mark (U+2019).
++# It also translates pairs of apostrophe (0x27) to
++# left single quotation mark (U+2018) and right single quotation mark (U+2019)
++# and pairs of quotation mark (0x22) to
++# left double quotation mark (U+201C) and right double quotation mark (U+201D).
++#
++# When output to an UTF-8 terminal, the quotation characters appear perfectly.
++# When output to an ISO-8859-1 terminal, the single quotation marks are
++# transliterated to apostrophes (by iconv in glibc 2.2 or newer) or to
++# grave/acute accent (by libiconv), and the double quotation marks are
++# transliterated to 0x22.
++# When output to an ASCII terminal, the single quotation marks are
++# transliterated to apostrophes, and the double quotation marks are
++# transliterated to 0x22.
++#
++# This catalog furthermore displays the text between the quotation marks in
++# bold face, assuming the VT100/XTerm escape sequences.
++#
+diff --git a/po/en@quot.header b/po/en@quot.header
+new file mode 100644
+index 0000000..a9647fc
+--- /dev/null
++++ b/po/en@quot.header
+@@ -0,0 +1,22 @@
++# All this catalog "translates" are quotation characters.
++# The msgids must be ASCII and therefore cannot contain real quotation
++# characters, only substitutes like grave accent (0x60), apostrophe (0x27)
++# and double quote (0x22). These substitutes look strange; see
++# http://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html
++#
++# This catalog translates grave accent (0x60) and apostrophe (0x27) to
++# left single quotation mark (U+2018) and right single quotation mark (U+2019).
++# It also translates pairs of apostrophe (0x27) to
++# left single quotation mark (U+2018) and right single quotation mark (U+2019)
++# and pairs of quotation mark (0x22) to
++# left double quotation mark (U+201C) and right double quotation mark (U+201D).
++#
++# When output to an UTF-8 terminal, the quotation characters appear perfectly.
++# When output to an ISO-8859-1 terminal, the single quotation marks are
++# transliterated to apostrophes (by iconv in glibc 2.2 or newer) or to
++# grave/acute accent (by libiconv), and the double quotation marks are
++# transliterated to 0x22.
++# When output to an ASCII terminal, the single quotation marks are
++# transliterated to apostrophes, and the double quotation marks are
++# transliterated to 0x22.
++#
+diff --git a/po/insert-header.sin b/po/insert-header.sin
+new file mode 100644
+index 0000000..b26de01
+--- /dev/null
++++ b/po/insert-header.sin
+@@ -0,0 +1,23 @@
++# Sed script that inserts the file called HEADER before the header entry.
++#
++# At each occurrence of a line starting with "msgid ", we execute the following
++# commands. At the first occurrence, insert the file. At the following
++# occurrences, do nothing. The distinction between the first and the following
++# occurrences is achieved by looking at the hold space.
++/^msgid /{
++x
++# Test if the hold space is empty.
++s/m/m/
++ta
++# Yes it was empty. First occurrence. Read the file.
++r HEADER
++# Output the file's contents by reading the next line. But don't lose the
++# current line while doing this.
++g
++N
++bb
++:a
++# The hold space was nonempty. Following occurrences. Do nothing.
++x
++:b
++}
+diff --git a/po/quot.sed b/po/quot.sed
+new file mode 100644
+index 0000000..0122c46
+--- /dev/null
++++ b/po/quot.sed
+@@ -0,0 +1,6 @@
++s/"\([^"]*\)"/“\1”/g
++s/`\([^`']*\)'/‘\1’/g
++s/ '\([^`']*\)' / ‘\1’ /g
++s/ '\([^`']*\)'$/ ‘\1’/g
++s/^'\([^`']*\)' /‘\1’ /g
++s/“”/""/g
+diff --git a/po/remove-potcdate.sin b/po/remove-potcdate.sin
+new file mode 100644
+index 0000000..2436c49
+--- /dev/null
++++ b/po/remove-potcdate.sin
+@@ -0,0 +1,19 @@
++# Sed script that remove the POT-Creation-Date line in the header entry
++# from a POT file.
++#
++# The distinction between the first and the following occurrences of the
++# pattern is achieved by looking at the hold space.
++/^"POT-Creation-Date: .*"$/{
++x
++# Test if the hold space is empty.
++s/P/P/
++ta
++# Yes it was empty. First occurrence. Remove the line.
++g
++d
++bb
++:a
++# The hold space was nonempty. Following occurrences. Do nothing.
++x
++:b
++}
+-- 
+1.9.1
+
diff --git a/openpower/package/petitboot/petitboot-console-ui.rules b/openpower/package/petitboot/petitboot-console-ui.rules
new file mode 100644
index 0000000..7464856
--- /dev/null
+++ b/openpower/package/petitboot/petitboot-console-ui.rules
@@ -0,0 +1,5 @@
+
+# spawn a petitboot UI on common user-visible interface devices
+SUBSYSTEM=="tty", KERNEL=="hvc*", RUN+="/usr/libexec/petitboot/pb-console --getty --detach -- -n -i 0 $name vt100"
+SUBSYSTEM=="tty", KERNEL=="tty0", RUN+="/usr/libexec/petitboot/pb-console --getty --detach -- -n -i 0 $name vt100"
+SUBSYSTEM=="tty", KERNEL=="ttyS*", RUN+="/usr/libexec/petitboot/pb-console --getty --detach -- -n -i 0 $name vt100"
diff --git a/openpower/package/petitboot/petitboot.mk b/openpower/package/petitboot/petitboot.mk
new file mode 100644
index 0000000..eec280d
--- /dev/null
+++ b/openpower/package/petitboot/petitboot.mk
@@ -0,0 +1,64 @@
+################################################################################
+#
+# petitboot
+#
+################################################################################
+
+PETITBOOT_VERSION = d171258160f7ed4756531f51e66fb116753bc990
+PETITBOOT_SITE = git://github.com/open-power/petitboot.git
+PETITBOOT_DEPENDENCIES = ncurses udev host-bison host-flex lvm2
+PETITBOOT_LICENSE = GPLv2
+PETITBOOT_LICENSE_FILES = COPYING
+
+PETITBOOT_AUTORECONF = YES
+PETITBOOT_AUTORECONF_OPTS = -i
+PETITBOOT_GETTEXTIZE = YES
+PETITBOOT_CONF_OPTS += --with-ncurses --without-twin-x11 --without-twin-fbdev \
+	      --localstatedir=/var \
+	      HOST_PROG_KEXEC=/usr/sbin/kexec \
+	      HOST_PROG_SHUTDOWN=/usr/libexec/petitboot/bb-kexec-reboot \
+	      $(if $(BR2_PACKAGE_BUSYBOX),--with-tftp=busybox)
+
+ifdef PETITBOOT_DEBUG
+PETITBOOT_CONF_OPTS += --enable-debug
+endif
+
+ifeq ($(BR2_PACKAGE_NCURSES_WCHAR),y)
+PETITBOOT_CONF_OPTS += --with-ncursesw MENU_LIB=-lmenuw FORM_LIB=-lformw
+endif
+
+PETITBOOT_PRE_CONFIGURE_HOOKS += PETITBOOT_PRE_CONFIGURE_BOOTSTRAP
+
+define PETITBOOT_POST_INSTALL
+	$(INSTALL) -D -m 0755 $(@D)/utils/bb-kexec-reboot \
+		$(TARGET_DIR)/usr/libexec/petitboot
+	$(INSTALL) -d -m 0755 $(TARGET_DIR)/etc/petitboot/boot.d
+	$(INSTALL) -D -m 0755 $(@D)/utils/hooks/01-create-default-dtb \
+		$(TARGET_DIR)/etc/petitboot/boot.d/
+	$(INSTALL) -D -m 0755 $(@D)/utils/hooks/20-set-stdout \
+		$(TARGET_DIR)/etc/petitboot/boot.d/
+
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/S14silence-console \
+		$(TARGET_DIR)/etc/init.d/
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/S15pb-discover \
+		$(TARGET_DIR)/etc/init.d/
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/kexec-restart \
+		$(TARGET_DIR)/usr/sbin/
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/petitboot-console-ui.rules \
+		$(TARGET_DIR)/etc/udev/rules.d/
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/removable-event-poll.rules \
+		$(TARGET_DIR)/etc/udev/rules.d/
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/63-md-raid-arrays.rules \
+		$(TARGET_DIR)/etc/udev/rules.d/
+	$(INSTALL) -D -m 0755 $(BR2_EXTERNAL)/package/petitboot/65-md-incremental.rules \
+		$(TARGET_DIR)/etc/udev/rules.d/
+
+	ln -sf /usr/sbin/pb-udhcpc \
+		$(TARGET_DIR)/usr/share/udhcpc/default.script.d/
+
+	$(MAKE) -C $(@D)/po DESTDIR=$(TARGET_DIR) install
+endef
+
+PETITBOOT_POST_INSTALL_TARGET_HOOKS += PETITBOOT_POST_INSTALL
+
+$(eval $(autotools-package))
diff --git a/openpower/package/petitboot/removable-event-poll.rules b/openpower/package/petitboot/removable-event-poll.rules
new file mode 100644
index 0000000..b736aef
--- /dev/null
+++ b/openpower/package/petitboot/removable-event-poll.rules
@@ -0,0 +1,4 @@
+
+# petitboot needs notification for media change events on removable devices,
+# which we only get if we've set the poll_msecs sysfs attribute.
+ACTION!="remove", ATTR{removable}=="1", ATTR{events_poll_msecs}="2000"
diff --git a/openpower/package/skiboot/Config.in b/openpower/package/skiboot/Config.in
index e1f571d..6b5ae0b 100644
--- a/openpower/package/skiboot/Config.in
+++ b/openpower/package/skiboot/Config.in
@@ -1,3 +1,4 @@
+menu "Skiboot"
 
 config BR2_TARGET_SKIBOOT
 	bool "skiboot"
@@ -12,4 +13,28 @@
 	bool "Embed kernel payload in skiboot image"
 	depends on BR2_LINUX_KERNEL_ZIMAGE_EPAPR
 
+choice
+	prompt "Skiboot version"
+	default BR2_SKIBOOT_LATEST_VERSION
+
+config BR2_SKIBOOT_LATEST_VERSION
+	bool "Use skiboot stable"
+
+config BR2_SKIBOOT_CUSTOM_VERSION
+	bool "Custom version"
+
+endchoice
+
+config BR2_SKIBOOT_CUSTOM_VERSION_VALUE
+	string "skiboot version"
+	depends on BR2_SKIBOOT_CUSTOM_VERSION
+
+config BR2_SKIBOOT_VERSION
+	string
+	default "skiboot-5.1.8" if BR2_SKIBOOT_LATEST_VERSION
+	default BR2_SKIBOOT_CUSTOM_VERSION_VALUE \
+		if BR2_SKIBOOT_CUSTOM_VERSION
+
 endif
+
+endmenu
diff --git a/openpower/package/skiboot/skiboot.mk b/openpower/package/skiboot/skiboot.mk
index f2affe8..90b2110 100644
--- a/openpower/package/skiboot/skiboot.mk
+++ b/openpower/package/skiboot/skiboot.mk
@@ -4,7 +4,8 @@
 #
 ################################################################################
 
-SKIBOOT_VERSION = skiboot-5.1.1
+SKIBOOT_VERSION = $(call qstrip,$(BR2_SKIBOOT_VERSION))
+
 SKIBOOT_SITE = $(call github,open-power,skiboot,$(SKIBOOT_VERSION))
 SKIBOOT_INSTALL_IMAGES = YES
 SKIBOOT_INSTALL_TARGET = NO
@@ -18,7 +19,7 @@
 SKIBOOT_MAKE_OPTS += KERNEL="$(BINARIES_DIR)/$(LINUX_IMAGE_NAME)"
 
 ifeq ($(BR2_TARGET_ROOTFS_INITRAMFS),y)
-SKIBOOT_DEPENDENCIES += linux26-rebuild-with-initramfs
+SKIBOOT_DEPENDENCIES += linux-rebuild-with-initramfs
 else
 SKIBOOT_DEPENDENCIES += linux
 endif
diff --git a/openpower/scripts/fixup-target-var b/openpower/scripts/fixup-target-var
new file mode 100755
index 0000000..9c9bc5b
--- /dev/null
+++ b/openpower/scripts/fixup-target-var
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+# replace /var/* symlinks with actual directories
+
+find $TARGET_DIR/var/ -type l |
+while read path
+do
+    [ -d "$path" ] || continue
+    rm -v $path
+    mkdir -v $path
+done
