64 files changed, 2759 insertions, 1693 deletions

diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 6729c98b66f9..75ba0ec49e54 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -45,6 +45,10 @@ config GENERIC_CALIBRATE_DELAY
         bool
         default y
 
+config GENERIC_FIND_NEXT_BIT
+        bool
+        default y
+
 config PPC
         bool
         default y
diff --git a/arch/powerpc/Kconfig.debug b/arch/powerpc/Kconfig.debug
index 8d48e9e7162a..c69006ae8246 100644
--- a/arch/powerpc/Kconfig.debug
+++ b/arch/powerpc/Kconfig.debug
@@ -110,13 +110,16 @@ config SERIAL_TEXT_DEBUG
         depends on 4xx || LOPEC || MV64X60 || PPLUS || PRPMC800 || \
                 PPC_GEN550 || PPC_MPC52xx
 
+config PPC_EARLY_DEBUG
+        bool "Early debugging (dangerous)"
+
 choice
-        prompt "Early debugging (dangerous)"
-        bool
-        optional
+        prompt "Early debugging console"
+        depends on PPC_EARLY_DEBUG
         help
-          Enable early debugging. Careful, if you enable debugging for the
-          wrong type of machine your kernel _will not boot_.
+          Use the selected console for early debugging. Careful, if you
+          enable debugging for the wrong type of machine your kernel
+          _will not boot_.
 
 config PPC_EARLY_DEBUG_LPAR
         bool "LPAR HV Console"
diff --git a/arch/powerpc/configs/mpc85xx_cds_defconfig b/arch/powerpc/configs/mpc85xx_cds_defconfig
new file mode 100644
index 000000000000..9bb022a523fe
--- /dev/null
+++ b/arch/powerpc/configs/mpc85xx_cds_defconfig
@@ -0,0 +1,846 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.16
+# Sun Apr  2 11:23:42 2006
+#
+# CONFIG_PPC64 is not set
+CONFIG_PPC32=y
+CONFIG_PPC_MERGE=y
+CONFIG_MMU=y
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_PPC=y
+CONFIG_EARLY_PRINTK=y
+CONFIG_GENERIC_NVRAM=y
+CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
+CONFIG_ARCH_MAY_HAVE_PC_FDC=y
+CONFIG_PPC_OF=y
+CONFIG_PPC_UDBG_16550=y
+# CONFIG_GENERIC_TBSYNC is not set
+# CONFIG_DEFAULT_UIMAGE is not set
+
+#
+# Processor support
+#
+# CONFIG_CLASSIC32 is not set
+# CONFIG_PPC_52xx is not set
+# CONFIG_PPC_82xx is not set
+# CONFIG_PPC_83xx is not set
+CONFIG_PPC_85xx=y
+# CONFIG_40x is not set
+# CONFIG_44x is not set
+# CONFIG_8xx is not set
+# CONFIG_E200 is not set
+CONFIG_85xx=y
+CONFIG_E500=y
+CONFIG_BOOKE=y
+CONFIG_FSL_BOOKE=y
+# CONFIG_PHYS_64BIT is not set
+CONFIG_SPE=y
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+# CONFIG_POSIX_MQUEUE is not set
+# CONFIG_BSD_PROCESS_ACCT is not set
+CONFIG_SYSCTL=y
+# CONFIG_AUDIT is not set
+# CONFIG_IKCONFIG is not set
+# CONFIG_RELAY is not set
+CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
+CONFIG_EMBEDDED=y
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_ALL is not set
+# CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SHMEM=y
+CONFIG_SLAB=y
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
+
+#
+# Loadable module support
+#
+# CONFIG_MODULES is not set
+
+#
+# Block layer
+#
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_LSF is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_DEFAULT_AS=y
+# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="anticipatory"
+CONFIG_MPIC=y
+# CONFIG_WANT_EARLY_SERIAL is not set
+
+#
+# Platform support
+#
+# CONFIG_MPC8540_ADS is not set
+CONFIG_MPC85xx_CDS=y
+CONFIG_MPC8540=y
+CONFIG_PPC_INDIRECT_PCI_BE=y
+
+#
+# Kernel options
+#
+# CONFIG_HIGHMEM is not set
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
+CONFIG_PREEMPT_NONE=y
+# CONFIG_PREEMPT_VOLUNTARY is not set
+# CONFIG_PREEMPT is not set
+CONFIG_BINFMT_ELF=y
+CONFIG_BINFMT_MISC=y
+CONFIG_MATH_EMULATION=y
+CONFIG_ARCH_FLATMEM_ENABLE=y
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4
+CONFIG_PROC_DEVICETREE=y
+# CONFIG_CMDLINE_BOOL is not set
+# CONFIG_PM is not set
+# CONFIG_SOFTWARE_SUSPEND is not set
+# CONFIG_SECCOMP is not set
+CONFIG_ISA_DMA_API=y
+
+#
+# Bus options
+#
+CONFIG_PPC_I8259=y
+CONFIG_PPC_INDIRECT_PCI=y
+CONFIG_FSL_SOC=y
+CONFIG_PCI=y
+CONFIG_PCI_DOMAINS=y
+# CONFIG_PCI_DEBUG is not set
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+# CONFIG_PCCARD is not set
+
+#
+# PCI Hotplug Support
+#
+# CONFIG_HOTPLUG_PCI is not set
+
+#
+# Advanced setup
+#
+# CONFIG_ADVANCED_OPTIONS is not set
+
+#
+# Default settings for advanced configuration options are used
+#
+CONFIG_HIGHMEM_START=0xfe000000
+CONFIG_LOWMEM_SIZE=0x30000000
+CONFIG_KERNEL_START=0xc0000000
+CONFIG_TASK_SIZE=0x80000000
+CONFIG_BOOT_LOAD=0x00800000
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+# CONFIG_NETDEBUG is not set
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+CONFIG_IP_PNP_DHCP=y
+CONFIG_IP_PNP_BOOTP=y
+# CONFIG_IP_PNP_RARP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_IP_MROUTE is not set
+# CONFIG_ARPD is not set
+CONFIG_SYN_COOKIES=y
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_XFRM_TUNNEL is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_INET6_XFRM_TUNNEL is not set
+# CONFIG_INET6_TUNNEL is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+# CONFIG_FW_LOADER is not set
+# CONFIG_DEBUG_DRIVER is not set
+
+#
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
+# Memory Technology Devices (MTD)
+#
+# CONFIG_MTD is not set
+
+#
+# Parallel port support
+#
+# CONFIG_PARPORT is not set
+
+#
+# Plug and Play support
+#
+
+#
+# Block devices
+#
+# CONFIG_BLK_DEV_FD is not set
+# CONFIG_BLK_CPQ_DA is not set
+# CONFIG_BLK_CPQ_CISS_DA is not set
+# CONFIG_BLK_DEV_DAC960 is not set
+# CONFIG_BLK_DEV_UMEM is not set
+# CONFIG_BLK_DEV_COW_COMMON is not set
+CONFIG_BLK_DEV_LOOP=y
+# CONFIG_BLK_DEV_CRYPTOLOOP is not set
+# CONFIG_BLK_DEV_NBD is not set
+# CONFIG_BLK_DEV_SX8 is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=32768
+CONFIG_BLK_DEV_INITRD=y
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_ATA_OVER_ETH is not set
+
+#
+# ATA/ATAPI/MFM/RLL support
+#
+CONFIG_IDE=y
+CONFIG_BLK_DEV_IDE=y
+
+#
+# Please see Documentation/ide.txt for help/info on IDE drives
+#
+# CONFIG_BLK_DEV_IDE_SATA is not set
+# CONFIG_BLK_DEV_IDEDISK is not set
+# CONFIG_IDEDISK_MULTI_MODE is not set
+# CONFIG_BLK_DEV_IDECD is not set
+# CONFIG_BLK_DEV_IDETAPE is not set
+# CONFIG_BLK_DEV_IDEFLOPPY is not set
+# CONFIG_IDE_TASK_IOCTL is not set
+
+#
+# IDE chipset support/bugfixes
+#
+CONFIG_IDE_GENERIC=y
+CONFIG_BLK_DEV_IDEPCI=y
+CONFIG_IDEPCI_SHARE_IRQ=y
+# CONFIG_BLK_DEV_OFFBOARD is not set
+CONFIG_BLK_DEV_GENERIC=y
+# CONFIG_BLK_DEV_OPTI621 is not set
+# CONFIG_BLK_DEV_SL82C105 is not set
+CONFIG_BLK_DEV_IDEDMA_PCI=y
+# CONFIG_BLK_DEV_IDEDMA_FORCED is not set
+# CONFIG_IDEDMA_PCI_AUTO is not set
+# CONFIG_BLK_DEV_AEC62XX is not set
+# CONFIG_BLK_DEV_ALI15X3 is not set
+# CONFIG_BLK_DEV_AMD74XX is not set
+# CONFIG_BLK_DEV_CMD64X is not set
+# CONFIG_BLK_DEV_TRIFLEX is not set
+# CONFIG_BLK_DEV_CY82C693 is not set
+# CONFIG_BLK_DEV_CS5520 is not set
+# CONFIG_BLK_DEV_CS5530 is not set
+# CONFIG_BLK_DEV_HPT34X is not set
+# CONFIG_BLK_DEV_HPT366 is not set
+# CONFIG_BLK_DEV_SC1200 is not set
+# CONFIG_BLK_DEV_PIIX is not set
+# CONFIG_BLK_DEV_IT821X is not set
+# CONFIG_BLK_DEV_NS87415 is not set
+# CONFIG_BLK_DEV_PDC202XX_OLD is not set
+# CONFIG_BLK_DEV_PDC202XX_NEW is not set
+# CONFIG_BLK_DEV_SVWKS is not set
+# CONFIG_BLK_DEV_SIIMAGE is not set
+# CONFIG_BLK_DEV_SLC90E66 is not set
+# CONFIG_BLK_DEV_TRM290 is not set
+CONFIG_BLK_DEV_VIA82CXXX=y
+# CONFIG_IDE_ARM is not set
+CONFIG_BLK_DEV_IDEDMA=y
+# CONFIG_IDEDMA_IVB is not set
+# CONFIG_IDEDMA_AUTO is not set
+# CONFIG_BLK_DEV_HD is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+# CONFIG_SCSI is not set
+
+#
+# Multi-device support (RAID and LVM)
+#
+# CONFIG_MD is not set
+
+#
+# Fusion MPT device support
+#
+# CONFIG_FUSION is not set
+
+#
+# IEEE 1394 (FireWire) support
+#
+# CONFIG_IEEE1394 is not set
+
+#
+# I2O device support
+#
+# CONFIG_I2O is not set
+
+#
+# Macintosh device drivers
+#
+# CONFIG_WINDFARM is not set
+
+#
+# Network device support
+#
+CONFIG_NETDEVICES=y
+# CONFIG_DUMMY is not set
+# CONFIG_BONDING is not set
+# CONFIG_EQUALIZER is not set
+# CONFIG_TUN is not set
+
+#
+# ARCnet devices
+#
+# CONFIG_ARCNET is not set
+
+#
+# PHY device support
+#
+CONFIG_PHYLIB=y
+
+#
+# MII PHY device drivers
+#
+# CONFIG_MARVELL_PHY is not set
+# CONFIG_DAVICOM_PHY is not set
+# CONFIG_QSEMI_PHY is not set
+# CONFIG_LXT_PHY is not set
+# CONFIG_CICADA_PHY is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=y
+# CONFIG_HAPPYMEAL is not set
+# CONFIG_SUNGEM is not set
+# CONFIG_CASSINI is not set
+# CONFIG_NET_VENDOR_3COM is not set
+
+#
+# Tulip family network device support
+#
+# CONFIG_NET_TULIP is not set
+# CONFIG_HP100 is not set
+# CONFIG_NET_PCI is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+# CONFIG_ACENIC is not set
+# CONFIG_DL2K is not set
+CONFIG_E1000=y
+CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
+# CONFIG_NS83820 is not set
+# CONFIG_HAMACHI is not set
+# CONFIG_YELLOWFIN is not set
+# CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
+# CONFIG_SKGE is not set
+# CONFIG_SKY2 is not set
+# CONFIG_SK98LIN is not set
+# CONFIG_TIGON3 is not set
+# CONFIG_BNX2 is not set
+CONFIG_GIANFAR=y
+CONFIG_GFAR_NAPI=y
+
+#
+# Ethernet (10000 Mbit)
+#
+# CONFIG_CHELSIO_T1 is not set
+# CONFIG_IXGB is not set
+# CONFIG_S2IO is not set
+
+#
+# Token Ring devices
+#
+# CONFIG_TR is not set
+
+#
+# Wireless LAN (non-hamradio)
+#
+# CONFIG_NET_RADIO is not set
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN is not set
+# CONFIG_FDDI is not set
+# CONFIG_HIPPI is not set
+# CONFIG_PPP is not set
+# CONFIG_SLIP is not set
+# CONFIG_SHAPER is not set
+# CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
+
+#
+# ISDN subsystem
+#
+# CONFIG_ISDN is not set
+
+#
+# Telephony Support
+#
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+
+#
+# Userland interfaces
+#
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_JOYDEV is not set
+# CONFIG_INPUT_TSDEV is not set
+# CONFIG_INPUT_EVDEV is not set
+# CONFIG_INPUT_EVBUG is not set
+
+#
+# Input Device Drivers
+#
+# CONFIG_INPUT_KEYBOARD is not set
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TOUCHSCREEN is not set
+# CONFIG_INPUT_MISC is not set
+
+#
+# Hardware I/O ports
+#
+# CONFIG_SERIO is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+# CONFIG_VT is not set
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_PCI=y
+CONFIG_SERIAL_8250_NR_UARTS=4
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
+# CONFIG_SERIAL_8250_EXTENDED is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_SERIAL_JSM is not set
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+
+#
+# IPMI
+#
+# CONFIG_IPMI_HANDLER is not set
+
+#
+# Watchdog Cards
+#
+# CONFIG_WATCHDOG is not set
+# CONFIG_NVRAM is not set
+CONFIG_GEN_RTC=y
+# CONFIG_GEN_RTC_X is not set
+# CONFIG_DTLK is not set
+# CONFIG_R3964 is not set
+# CONFIG_APPLICOM is not set
+
+#
+# Ftape, the floppy tape device driver
+#
+# CONFIG_AGP is not set
+# CONFIG_DRM is not set
+# CONFIG_RAW_DRIVER is not set
+
+#
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
+# CONFIG_TELCLOCK is not set
+
+#
+# I2C support
+#
+# CONFIG_I2C is not set
+
+#
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
+# Dallas's 1-wire bus
+#
+# CONFIG_W1 is not set
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_SENSORS_F71805F is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+
+#
+# Digital Video Broadcasting Devices
+#
+# CONFIG_DVB is not set
+
+#
+# Graphics support
+#
+# CONFIG_FB is not set
+
+#
+# Sound
+#
+# CONFIG_SOUND is not set
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB_ARCH_HAS_EHCI=y
+# CONFIG_USB is not set
+
+#
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+#
+
+#
+# USB Gadget Support
+#
+# CONFIG_USB_GADGET is not set
+
+#
+# MMC/SD Card support
+#
+# CONFIG_MMC is not set
+
+#
+# LED devices
+#
+# CONFIG_NEW_LEDS is not set
+
+#
+# InfiniBand support
+#
+# CONFIG_INFINIBAND is not set
+
+#
+# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
+#
+
+#
+# Real Time Clock
+#
+# CONFIG_RTC_CLASS is not set
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+# CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=y
+CONFIG_EXT3_FS_XATTR=y
+# CONFIG_EXT3_FS_POSIX_ACL is not set
+# CONFIG_EXT3_FS_SECURITY is not set
+CONFIG_JBD=y
+# CONFIG_JBD_DEBUG is not set
+CONFIG_FS_MBCACHE=y
+# CONFIG_REISERFS_FS is not set
+# CONFIG_JFS_FS is not set
+# CONFIG_FS_POSIX_ACL is not set
+# CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
+# CONFIG_QUOTA is not set
+CONFIG_DNOTIFY=y
+# CONFIG_AUTOFS_FS is not set
+# CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+# CONFIG_ISO9660_FS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+# CONFIG_MSDOS_FS is not set
+# CONFIG_VFAT_FS is not set
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_PROC_KCORE=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+# CONFIG_HUGETLB_PAGE is not set
+CONFIG_RAMFS=y
+# CONFIG_CONFIGFS_FS is not set
+
+#
+# Miscellaneous filesystems
+#
+# CONFIG_ADFS_FS is not set
+# CONFIG_AFFS_FS is not set
+# CONFIG_HFS_FS is not set
+# CONFIG_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+
+#
+# Network File Systems
+#
+CONFIG_NFS_FS=y
+# CONFIG_NFS_V3 is not set
+# CONFIG_NFS_V4 is not set
+# CONFIG_NFS_DIRECTIO is not set
+# CONFIG_NFSD is not set
+CONFIG_ROOT_NFS=y
+CONFIG_LOCKD=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+# CONFIG_RPCSEC_GSS_KRB5 is not set
+# CONFIG_RPCSEC_GSS_SPKM3 is not set
+# CONFIG_SMB_FS is not set
+# CONFIG_CIFS is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_CODA_FS is not set
+# CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
+
+#
+# Partition Types
+#
+CONFIG_PARTITION_ADVANCED=y
+# CONFIG_ACORN_PARTITION is not set
+# CONFIG_OSF_PARTITION is not set
+# CONFIG_AMIGA_PARTITION is not set
+# CONFIG_ATARI_PARTITION is not set
+# CONFIG_MAC_PARTITION is not set
+# CONFIG_MSDOS_PARTITION is not set
+# CONFIG_LDM_PARTITION is not set
+# CONFIG_SGI_PARTITION is not set
+# CONFIG_ULTRIX_PARTITION is not set
+# CONFIG_SUN_PARTITION is not set
+# CONFIG_KARMA_PARTITION is not set
+# CONFIG_EFI_PARTITION is not set
+
+#
+# Native Language Support
+#
+# CONFIG_NLS is not set
+
+#
+# Library routines
+#
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+CONFIG_CRC32=y
+# CONFIG_LIBCRC32C is not set
+
+#
+# Instrumentation Support
+#
+# CONFIG_PROFILING is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_MAGIC_SYSRQ is not set
+CONFIG_DEBUG_KERNEL=y
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHEDSTATS is not set
+# CONFIG_DEBUG_SLAB is not set
+CONFIG_DEBUG_MUTEXES=y
+# CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_KOBJECT is not set
+# CONFIG_DEBUG_INFO is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
+# CONFIG_UNWIND_INFO is not set
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_DEBUGGER is not set
+# CONFIG_BDI_SWITCH is not set
+# CONFIG_BOOTX_TEXT is not set
+# CONFIG_PPC_EARLY_DEBUG_LPAR is not set
+# CONFIG_PPC_EARLY_DEBUG_G5 is not set
+# CONFIG_PPC_EARLY_DEBUG_RTAS is not set
+# CONFIG_PPC_EARLY_DEBUG_MAPLE is not set
+# CONFIG_PPC_EARLY_DEBUG_ISERIES is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+
+#
+# Cryptographic options
+#
+# CONFIG_CRYPTO is not set
+
+#
+# Hardware crypto devices
+#
diff --git a/arch/powerpc/kernel/cpu_setup_power4.S b/arch/powerpc/kernel/cpu_setup_power4.S
index b61d86e7ceb6..271418308d53 100644
--- a/arch/powerpc/kernel/cpu_setup_power4.S
+++ b/arch/powerpc/kernel/cpu_setup_power4.S
@@ -73,23 +73,6 @@ _GLOBAL(__970_cpu_preinit)
         isync
         blr
 
-_GLOBAL(__setup_cpu_power4)
-        blr
-
-_GLOBAL(__setup_cpu_be)
-        /* Set large page sizes LP=0: 16MB, LP=1: 64KB */
-        addi    r3, 0,  0
-        ori     r3, r3, HID6_LB
-        sldi    r3, r3, 32
-        nor     r3, r3, r3
-        mfspr   r4, SPRN_HID6
-        and     r4, r4, r3
-        addi    r3, 0, 0x02000
-        sldi    r3, r3, 32
-        or      r4, r4, r3
-        mtspr   SPRN_HID6, r4
-        blr
-
 _GLOBAL(__setup_cpu_ppc970)
         mfspr   r0,SPRN_HID0
         li      r11,5                   /* clear DOZE and SLEEP */
diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
index 3f7182db9ed5..0c487ee4d483 100644
--- a/arch/powerpc/kernel/cputable.c
+++ b/arch/powerpc/kernel/cputable.c
@@ -30,11 +30,7 @@ EXPORT_SYMBOL(cur_cpu_spec);
  * part of the cputable though. That has to be fixed for both ppc32
  * and ppc64
  */
-#ifdef CONFIG_PPC64
-extern void __setup_cpu_power3(unsigned long offset, struct cpu_spec* spec);
-extern void __setup_cpu_power4(unsigned long offset, struct cpu_spec* spec);
-extern void __setup_cpu_be(unsigned long offset, struct cpu_spec* spec);
-#else
+#ifdef CONFIG_PPC32
 extern void __setup_cpu_603(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_604(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_750(unsigned long offset, struct cpu_spec* spec);
@@ -82,7 +78,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/power3",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "power3",
@@ -96,7 +91,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/power3",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "power3",
@@ -110,7 +104,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -124,7 +117,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -138,7 +130,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -152,7 +143,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
                 .oprofile_type          = PPC_OPROFILE_RS64,
                 .platform               = "rs64",
@@ -166,7 +156,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power4",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power4",
@@ -180,7 +169,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power4",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power4",
@@ -246,7 +234,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power5",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power5",
@@ -260,7 +247,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power5+",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power5+",
@@ -274,7 +260,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power6",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "power6",
@@ -289,7 +274,6 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_SMT,
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
-                .cpu_setup              = __setup_cpu_be,
                 .platform               = "ppc-cell-be",
         },
         {       /* default match */
@@ -301,7 +285,6 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
-                .cpu_setup              = __setup_cpu_power4,
                 .platform               = "power4",
         }
 #endif  /* CONFIG_PPC64 */
diff --git a/arch/powerpc/kernel/crash.c b/arch/powerpc/kernel/crash.c
index 778f22fd85d2..dbcb85994f46 100644
--- a/arch/powerpc/kernel/crash.c
+++ b/arch/powerpc/kernel/crash.c
@@ -22,6 +22,7 @@
 #include <linux/elf.h>
 #include <linux/elfcore.h>
 #include <linux/init.h>
+#include <linux/irq.h>
 #include <linux/types.h>
 
 #include <asm/processor.h>
@@ -174,6 +175,8 @@ static void crash_kexec_prepare_cpus(void)
 
 void default_machine_crash_shutdown(struct pt_regs *regs)
 {
+        unsigned int irq;
+
         /*
          * This function is only called after the system
          * has paniced or is otherwise in a critical state.
@@ -186,6 +189,16 @@ void default_machine_crash_shutdown(struct pt_regs *regs)
          */
         local_irq_disable();
 
+        for_each_irq(irq) {
+                struct irq_desc *desc = irq_descp(irq);
+
+                if (desc->status & IRQ_INPROGRESS)
+                        desc->handler->end(irq);
+
+                if (!(desc->status & IRQ_DISABLED))
+                        desc->handler->disable(irq);
+        }
+
         if (ppc_md.kexec_cpu_down)
                 ppc_md.kexec_cpu_down(1, 0);
 
diff --git a/arch/powerpc/kernel/crash_dump.c b/arch/powerpc/kernel/crash_dump.c
index 764d07329716..371973be8d71 100644
--- a/arch/powerpc/kernel/crash_dump.c
+++ b/arch/powerpc/kernel/crash_dump.c
@@ -25,6 +25,11 @@
 #define DBG(fmt...)
 #endif
 
+void reserve_kdump_trampoline(void)
+{
+        lmb_reserve(0, KDUMP_RESERVE_LIMIT);
+}
+
 static void __init create_trampoline(unsigned long addr)
 {
         /* The maximum range of a single instruction branch, is the current
@@ -39,11 +44,11 @@ static void __init create_trampoline(unsigned long addr)
         create_branch(addr + 4, addr + PHYSICAL_START, 0);
 }
 
-void __init kdump_setup(void)
+void __init setup_kdump_trampoline(void)
 {
         unsigned long i;
 
-        DBG(" -> kdump_setup()\n");
+        DBG(" -> setup_kdump_trampoline()\n");
 
         for (i = KDUMP_TRAMPOLINE_START; i < KDUMP_TRAMPOLINE_END; i += 8) {
                 create_trampoline(i);
@@ -52,7 +57,7 @@ void __init kdump_setup(void)
         create_trampoline(__pa(system_reset_fwnmi) - PHYSICAL_START);
         create_trampoline(__pa(machine_check_fwnmi) - PHYSICAL_START);
 
-        DBG(" <- kdump_setup()\n");
+        DBG(" <- setup_kdump_trampoline()\n");
 }
 
 #ifdef CONFIG_PROC_VMCORE
diff --git a/arch/powerpc/kernel/iomap.c b/arch/powerpc/kernel/iomap.c
index fd8214caedee..a13a93dfc655 100644
--- a/arch/powerpc/kernel/iomap.c
+++ b/arch/powerpc/kernel/iomap.c
@@ -106,8 +106,6 @@ EXPORT_SYMBOL(iowrite32_rep);
 
 void __iomem *ioport_map(unsigned long port, unsigned int len)
 {
-        if (!_IO_IS_VALID(port))
-                return NULL;
         return (void __iomem *) (port+pci_io_base);
 }
 
diff --git a/arch/powerpc/kernel/lparcfg.c b/arch/powerpc/kernel/lparcfg.c
index 2cbde865d4f5..c02deaab26c7 100644
--- a/arch/powerpc/kernel/lparcfg.c
+++ b/arch/powerpc/kernel/lparcfg.c
@@ -521,10 +521,10 @@ static ssize_t lparcfg_write(struct file *file, const char __user * buf,
 
         current_weight = (resource >> 5 * 8) & 0xFF;
 
-        pr_debug("%s: current_entitled = %lu, current_weight = %lu\n",
+        pr_debug("%s: current_entitled = %lu, current_weight = %u\n",
                  __FUNCTION__, current_entitled, current_weight);
 
-        pr_debug("%s: new_entitled = %lu, new_weight = %lu\n",
+        pr_debug("%s: new_entitled = %lu, new_weight = %u\n",
                  __FUNCTION__, *new_entitled_ptr, *new_weight_ptr);
 
         retval = plpar_hcall_norets(H_SET_PPP, *new_entitled_ptr,
diff --git a/arch/powerpc/kernel/machine_kexec_64.c b/arch/powerpc/kernel/machine_kexec_64.c
index ee166c586642..a8fa04ef27cd 100644
--- a/arch/powerpc/kernel/machine_kexec_64.c
+++ b/arch/powerpc/kernel/machine_kexec_64.c
@@ -21,6 +21,7 @@
 #include <asm/machdep.h>
 #include <asm/cacheflush.h>
 #include <asm/paca.h>
+#include <asm/lmb.h>
 #include <asm/mmu.h>
 #include <asm/sections.h>       /* _end */
 #include <asm/prom.h>
@@ -335,7 +336,105 @@ static void __init export_htab_values(void)
         of_node_put(node);
 }
 
+static struct property crashk_base_prop = {
+        .name = "linux,crashkernel-base",
+        .length = sizeof(unsigned long),
+        .value = (unsigned char *)&crashk_res.start,
+};
+
+static unsigned long crashk_size;
+
+static struct property crashk_size_prop = {
+        .name = "linux,crashkernel-size",
+        .length = sizeof(unsigned long),
+        .value = (unsigned char *)&crashk_size,
+};
+
+static void __init export_crashk_values(void)
+{
+        struct device_node *node;
+        struct property *prop;
+
+        node = of_find_node_by_path("/chosen");
+        if (!node)
+                return;
+
+        /* There might be existing crash kernel properties, but we can't
+         * be sure what's in them, so remove them. */
+        prop = of_find_property(node, "linux,crashkernel-base", NULL);
+        if (prop)
+                prom_remove_property(node, prop);
+
+        prop = of_find_property(node, "linux,crashkernel-size", NULL);
+        if (prop)
+                prom_remove_property(node, prop);
+
+        if (crashk_res.start != 0) {
+                prom_add_property(node, &crashk_base_prop);
+                crashk_size = crashk_res.end - crashk_res.start + 1;
+                prom_add_property(node, &crashk_size_prop);
+        }
+
+        of_node_put(node);
+}
+
 void __init kexec_setup(void)
 {
         export_htab_values();
+        export_crashk_values();
+}
+
+static int __init early_parse_crashk(char *p)
+{
+        unsigned long size;
+
+        if (!p)
+                return 1;
+
+        size = memparse(p, &p);
+
+        if (*p == '@')
+                crashk_res.start = memparse(p + 1, &p);
+        else
+                crashk_res.start = KDUMP_KERNELBASE;
+
+        crashk_res.end = crashk_res.start + size - 1;
+
+        return 0;
+}
+early_param("crashkernel", early_parse_crashk);
+
+void __init reserve_crashkernel(void)
+{
+        unsigned long size;
+
+        if (crashk_res.start == 0)
+                return;
+
+        /* We might have got these values via the command line or the
+         * device tree, either way sanitise them now. */
+
+        size = crashk_res.end - crashk_res.start + 1;
+
+        if (crashk_res.start != KDUMP_KERNELBASE)
+                printk("Crash kernel location must be 0x%x\n",
+                                KDUMP_KERNELBASE);
+
+        crashk_res.start = KDUMP_KERNELBASE;
+        size = PAGE_ALIGN(size);
+        crashk_res.end = crashk_res.start + size - 1;
+
+        /* Crash kernel trumps memory limit */
+        if (memory_limit && memory_limit <= crashk_res.end) {
+                memory_limit = crashk_res.end + 1;
+                printk("Adjusted memory limit for crashkernel, now 0x%lx\n",
+                                memory_limit);
+        }
+
+        lmb_reserve(crashk_res.start, size);
+}
+
+int overlaps_crashkernel(unsigned long start, unsigned long size)
+{
+        return (start + size) > crashk_res.start && start <= crashk_res.end;
 }
diff --git a/arch/powerpc/kernel/misc_32.S b/arch/powerpc/kernel/misc_32.S
index be982023409e..01d3916c4cb1 100644
--- a/arch/powerpc/kernel/misc_32.S
+++ b/arch/powerpc/kernel/misc_32.S
@@ -216,7 +216,7 @@ _GLOBAL(call_setup_cpu)
         lwz     r4,0(r4)
         add     r4,r4,r3
         lwz     r5,CPU_SPEC_SETUP(r4)
-        cmpi    0,r5,0
+        cmpwi   0,r5,0
         add     r5,r5,r3
         beqlr
         mtctr   r5
diff --git a/arch/powerpc/kernel/misc_64.S b/arch/powerpc/kernel/misc_64.S
index 2778cce058e2..e8883d42c43c 100644
--- a/arch/powerpc/kernel/misc_64.S
+++ b/arch/powerpc/kernel/misc_64.S
@@ -482,7 +482,9 @@ _GLOBAL(identify_cpu)
         sub     r0,r3,r5
         std     r0,0(r4)
         ld      r4,CPU_SPEC_SETUP(r3)
+        cmpdi   0,r4,0
         add     r4,r4,r5
+        beqlr
         ld      r4,0(r4)
         add     r4,r4,r5
         mtctr   r4
@@ -768,9 +770,6 @@ _GLOBAL(giveup_altivec)
 
 #endif /* CONFIG_ALTIVEC */
 
-_GLOBAL(__setup_cpu_power3)
-        blr
-
 _GLOBAL(execve)
         li      r0,__NR_execve
         sc
diff --git a/arch/powerpc/kernel/nvram_64.c b/arch/powerpc/kernel/nvram_64.c
index ada50aa5b600..6960f090991e 100644
--- a/arch/powerpc/kernel/nvram_64.c
+++ b/arch/powerpc/kernel/nvram_64.c
@@ -204,7 +204,7 @@ static void nvram_print_partitions(char * label)
         printk(KERN_WARNING "indx\t\tsig\tchks\tlen\tname\n");
         list_for_each(p, &nvram_part->partition) {
                 tmp_part = list_entry(p, struct nvram_partition, partition);
-                printk(KERN_WARNING "%d    \t%02x\t%02x\t%d\t%s\n",
+                printk(KERN_WARNING "%4d    \t%02x\t%02x\t%d\t%s\n",
                        tmp_part->index, tmp_part->header.signature,
                        tmp_part->header.checksum, tmp_part->header.length,
                        tmp_part->header.name);
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 4c4449be81ce..30a4e6a1368a 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -42,14 +42,6 @@
 unsigned long pci_probe_only = 1;
 int pci_assign_all_buses = 0;
 
-/*
- * legal IO pages under MAX_ISA_PORT.  This is to ensure we don't touch
- * devices we don't have access to.
- */
-unsigned long io_page_mask;
-
-EXPORT_SYMBOL(io_page_mask);
-
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static void fixup_resource(struct resource *res, struct pci_dev *dev);
 static void do_bus_setup(struct pci_bus *bus);
@@ -605,7 +597,7 @@ static int __init pcibios_init(void)
         iSeries_pcibios_init(); 
 #endif
 
-        printk("PCI: Probing PCI hardware\n");
+        printk(KERN_DEBUG "PCI: Probing PCI hardware\n");
 
         /* Scan all of the recorded PCI controllers.  */
         list_for_each_entry_safe(hose, tmp, &hose_list, list_node) {
@@ -630,14 +622,14 @@ static int __init pcibios_init(void)
         /* Cache the location of the ISA bridge (if we have one) */
         ppc64_isabridge_dev = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, NULL);
         if (ppc64_isabridge_dev != NULL)
-                printk("ISA bridge at %s\n", pci_name(ppc64_isabridge_dev));
+                printk(KERN_DEBUG "ISA bridge at %s\n", pci_name(ppc64_isabridge_dev));
 
 #ifdef CONFIG_PPC_MULTIPLATFORM
         /* map in PCI I/O space */
         phbs_remap_io();
 #endif
 
-        printk("PCI: Probing PCI hardware done\n");
+        printk(KERN_DEBUG "PCI: Probing PCI hardware done\n");
 
         return 0;
 }
@@ -804,7 +796,7 @@ static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
         else
                 prot |= _PAGE_GUARDED;
 
-        printk("PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
+        printk(KERN_DEBUG "PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
                prot);
 
         return __pgprot(prot);
@@ -894,8 +886,8 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
         return ret;
 }
 
-#ifdef CONFIG_PPC_MULTIPLATFORM
-static ssize_t pci_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t pci_show_devspec(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
         struct pci_dev *pdev;
         struct device_node *np;
@@ -907,13 +899,10 @@ static ssize_t pci_show_devspec(struct device *dev, struct device_attribute *att
         return sprintf(buf, "%s", np->full_name);
 }
 static DEVICE_ATTR(devspec, S_IRUGO, pci_show_devspec, NULL);
-#endif /* CONFIG_PPC_MULTIPLATFORM */
 
 void pcibios_add_platform_entries(struct pci_dev *pdev)
 {
-#ifdef CONFIG_PPC_MULTIPLATFORM
         device_create_file(&pdev->dev, &dev_attr_devspec);
-#endif /* CONFIG_PPC_MULTIPLATFORM */
 }
 
 #ifdef CONFIG_PPC_MULTIPLATFORM
@@ -1104,8 +1093,6 @@ void __init pci_setup_phb_io(struct pci_controller *hose, int primary)
                         pci_process_ISA_OF_ranges(isa_dn, hose->io_base_phys,
                                                 hose->io_base_virt);
                         of_node_put(isa_dn);
-                        /* Allow all IO */
-                        io_page_mask = -1;
                 }
         }
 
@@ -1212,7 +1199,7 @@ int remap_bus_range(struct pci_bus *bus)
                 return 1;
         if (start_phys == 0)
                 return 1;
-        printk("mapping IO %lx -> %lx, size: %lx\n", start_phys, start_virt, size);
+        printk(KERN_DEBUG "mapping IO %lx -> %lx, size: %lx\n", start_phys, start_virt, size);
         if (__ioremap_explicit(start_phys, start_virt, size,
                                _PAGE_NO_CACHE | _PAGE_GUARDED))
                 return 1;
@@ -1232,27 +1219,13 @@ static void phbs_remap_io(void)
 static void __devinit fixup_resource(struct resource *res, struct pci_dev *dev)
 {
         struct pci_controller *hose = pci_bus_to_host(dev->bus);
-        unsigned long start, end, mask, offset;
+        unsigned long offset;
 
         if (res->flags & IORESOURCE_IO) {
                 offset = (unsigned long)hose->io_base_virt - pci_io_base;
 
-                start = res->start += offset;
-                end = res->end += offset;
-
-                /* Need to allow IO access to pages that are in the
-                   ISA range */
-                if (start < MAX_ISA_PORT) {
-                        if (end > MAX_ISA_PORT)
-                                end = MAX_ISA_PORT;
-
-                        start >>= PAGE_SHIFT;
-                        end >>= PAGE_SHIFT;
-
-                        /* get the range of pages for the map */
-                        mask = ((1 << (end+1)) - 1) ^ ((1 << start) - 1);
-                        io_page_mask |= mask;
-                }
+                res->start += offset;
+                res->end += offset;
         } else if (res->flags & IORESOURCE_MEM) {
                 res->start += hose->pci_mem_offset;
                 res->end += hose->pci_mem_offset;
diff --git a/arch/powerpc/kernel/pci_dn.c b/arch/powerpc/kernel/pci_dn.c
index 12c4c9e9bbc7..1c18953514c3 100644
--- a/arch/powerpc/kernel/pci_dn.c
+++ b/arch/powerpc/kernel/pci_dn.c
@@ -31,6 +31,7 @@
 #include <asm/pci-bridge.h>
 #include <asm/pSeries_reconfig.h>
 #include <asm/ppc-pci.h>
+#include <asm/firmware.h>
 
 /*
  * Traverse_func that inits the PCI fields of the device node.
@@ -59,6 +60,11 @@ static void * __devinit update_dn_pci_info(struct device_node *dn, void *data)
                 pdn->busno = (regs[0] >> 16) & 0xff;
                 pdn->devfn = (regs[0] >> 8) & 0xff;
         }
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                u32 *busp = (u32 *)get_property(dn, "linux,subbus", NULL);
+                if (busp)
+                        pdn->bussubno = *busp;
+        }
 
         pdn->pci_ext_config_space = (type && *type == 1);
         return NULL;
diff --git a/arch/powerpc/kernel/pci_iommu.c b/arch/powerpc/kernel/pci_iommu.c
index c1d95e14bbed..48aa82d01624 100644
--- a/arch/powerpc/kernel/pci_iommu.c
+++ b/arch/powerpc/kernel/pci_iommu.c
@@ -44,16 +44,16 @@
  */
 #define PCI_GET_DN(dev) ((struct device_node *)((dev)->sysdata))
 
-static inline struct iommu_table *devnode_table(struct device *dev)
+static inline struct iommu_table *device_to_table(struct device *hwdev)
 {
         struct pci_dev *pdev;
 
-        if (!dev) {
+        if (!hwdev) {
                 pdev = ppc64_isabridge_dev;
                 if (!pdev)
                         return NULL;
         } else
-                pdev = to_pci_dev(dev);
+                pdev = to_pci_dev(hwdev);
 
         return PCI_DN(PCI_GET_DN(pdev))->iommu_table;
 }
@@ -85,14 +85,14 @@ static inline unsigned long device_to_mask(struct device *hwdev)
 static void *pci_iommu_alloc_coherent(struct device *hwdev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flag)
 {
-        return iommu_alloc_coherent(devnode_table(hwdev), size, dma_handle,
+        return iommu_alloc_coherent(device_to_table(hwdev), size, dma_handle,
                         device_to_mask(hwdev), flag);
 }
 
 static void pci_iommu_free_coherent(struct device *hwdev, size_t size,
                          void *vaddr, dma_addr_t dma_handle)
 {
-        iommu_free_coherent(devnode_table(hwdev), size, vaddr, dma_handle);
+        iommu_free_coherent(device_to_table(hwdev), size, vaddr, dma_handle);
 }
 
 /* Creates TCEs for a user provided buffer.  The user buffer must be 
@@ -104,7 +104,7 @@ static void pci_iommu_free_coherent(struct device *hwdev, size_t size,
 static dma_addr_t pci_iommu_map_single(struct device *hwdev, void *vaddr,
                 size_t size, enum dma_data_direction direction)
 {
-        return iommu_map_single(devnode_table(hwdev), vaddr, size,
+        return iommu_map_single(device_to_table(hwdev), vaddr, size,
                                 device_to_mask(hwdev), direction);
 }
 
@@ -112,27 +112,27 @@ static dma_addr_t pci_iommu_map_single(struct device *hwdev, void *vaddr,
 static void pci_iommu_unmap_single(struct device *hwdev, dma_addr_t dma_handle,
                 size_t size, enum dma_data_direction direction)
 {
-        iommu_unmap_single(devnode_table(hwdev), dma_handle, size, direction);
+        iommu_unmap_single(device_to_table(hwdev), dma_handle, size, direction);
 }
 
 
 static int pci_iommu_map_sg(struct device *pdev, struct scatterlist *sglist,
                 int nelems, enum dma_data_direction direction)
 {
-        return iommu_map_sg(pdev, devnode_table(pdev), sglist,
+        return iommu_map_sg(pdev, device_to_table(pdev), sglist,
                         nelems, device_to_mask(pdev), direction);
 }
 
 static void pci_iommu_unmap_sg(struct device *pdev, struct scatterlist *sglist,
                 int nelems, enum dma_data_direction direction)
 {
-        iommu_unmap_sg(devnode_table(pdev), sglist, nelems, direction);
+        iommu_unmap_sg(device_to_table(pdev), sglist, nelems, direction);
 }
 
 /* We support DMA to/from any memory page via the iommu */
 static int pci_iommu_dma_supported(struct device *dev, u64 mask)
 {
-        struct iommu_table *tbl = devnode_table(dev);
+        struct iommu_table *tbl = device_to_table(dev);
 
         if (!tbl || tbl->it_offset > mask) {
                 printk(KERN_INFO "Warning: IOMMU table offset too big for device mask\n");
diff --git a/arch/powerpc/kernel/proc_ppc64.c b/arch/powerpc/kernel/proc_ppc64.c
index 3c2cf661f6d9..2b87f82df135 100644
--- a/arch/powerpc/kernel/proc_ppc64.c
+++ b/arch/powerpc/kernel/proc_ppc64.c
@@ -52,7 +52,7 @@ static int __init proc_ppc64_create(void)
         if (!root)
                 return 1;
 
-        if (!machine_is(pseries) && !machine_is(cell))
+        if (!of_find_node_by_path("/rtas"))
                 return 0;
 
         if (!proc_mkdir("rtas", root))
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index 9a07f97f0712..969f4abcc0be 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -50,6 +50,7 @@
 #include <asm/machdep.h>
 #include <asm/pSeries_reconfig.h>
 #include <asm/pci-bridge.h>
+#include <asm/kexec.h>
 
 #ifdef DEBUG
 #define DBG(fmt...) printk(KERN_ERR fmt)
@@ -836,6 +837,42 @@ static unsigned long __init unflatten_dt_node(unsigned long mem,
         return mem;
 }
 
+static int __init early_parse_mem(char *p)
+{
+        if (!p)
+                return 1;
+
+        memory_limit = PAGE_ALIGN(memparse(p, &p));
+        DBG("memory limit = 0x%lx\n", memory_limit);
+
+        return 0;
+}
+early_param("mem", early_parse_mem);
+
+/*
+ * The device tree may be allocated below our memory limit, or inside the
+ * crash kernel region for kdump. If so, move it out now.
+ */
+static void move_device_tree(void)
+{
+        unsigned long start, size;
+        void *p;
+
+        DBG("-> move_device_tree\n");
+
+        start = __pa(initial_boot_params);
+        size = initial_boot_params->totalsize;
+
+        if ((memory_limit && (start + size) > memory_limit) ||
+                        overlaps_crashkernel(start, size)) {
+                p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size));
+                memcpy(p, initial_boot_params, size);
+                initial_boot_params = (struct boot_param_header *)p;
+                DBG("Moved device tree to 0x%p\n", p);
+        }
+
+        DBG("<- move_device_tree\n");
+}
 
 /**
  * unflattens the device-tree passed by the firmware, creating the
@@ -1070,6 +1107,7 @@ static int __init early_init_dt_scan_chosen(unsigned long node,
                 iommu_force_on = 1;
 #endif
 
+        /* mem=x on the command line is the preferred mechanism */
         lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
         if (lprop)
                 memory_limit = *lprop;
@@ -1123,17 +1161,6 @@ static int __init early_init_dt_scan_chosen(unsigned long node,
 
         DBG("Command line is: %s\n", cmd_line);
 
-        if (strstr(cmd_line, "mem=")) {
-                char *p, *q;
-
-                for (q = cmd_line; (p = strstr(q, "mem=")) != 0; ) {
-                        q = p + 4;
-                        if (p > cmd_line && p[-1] != ' ')
-                                continue;
-                        memory_limit = memparse(q, &q);
-                }
-        }
-
         /* break now */
         return 1;
 }
@@ -1240,6 +1267,11 @@ static void __init early_reserve_mem(void)
 
         reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
                                         initial_boot_params->off_mem_rsvmap);
+
+        /* before we do anything, lets reserve the dt blob */
+        lmb_reserve(__pa((unsigned long)initial_boot_params),
+                    initial_boot_params->totalsize);
+
 #ifdef CONFIG_PPC32
         /* 
          * Handle the case where we might be booting from an old kexec
@@ -1292,18 +1324,26 @@ void __init early_init_devtree(void *params)
         lmb_init();
         of_scan_flat_dt(early_init_dt_scan_root, NULL);
         of_scan_flat_dt(early_init_dt_scan_memory, NULL);
-        lmb_enforce_memory_limit(memory_limit);
-        lmb_analyze();
 
-        DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
+        /* Save command line for /proc/cmdline and then parse parameters */
+        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
+        parse_early_param();
 
         /* Reserve LMB regions used by kernel, initrd, dt, etc... */
         lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
-#ifdef CONFIG_CRASH_DUMP
-        lmb_reserve(0, KDUMP_RESERVE_LIMIT);
-#endif
+        reserve_kdump_trampoline();
+        reserve_crashkernel();
         early_reserve_mem();
 
+        lmb_enforce_memory_limit(memory_limit);
+        lmb_analyze();
+
+        DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
+
+        /* We may need to relocate the flat tree, do it now.
+         * FIXME .. and the initrd too? */
+        move_device_tree();
+
         DBG("Scanning CPUs ...\n");
 
         /* Retreive CPU related informations from the flat tree
@@ -2053,29 +2093,3 @@ int prom_update_property(struct device_node *np,
         return 0;
 }
 
-#ifdef CONFIG_KEXEC
-/* We may have allocated the flat device tree inside the crash kernel region
- * in prom_init. If so we need to move it out into regular memory. */
-void kdump_move_device_tree(void)
-{
-        unsigned long start, end;
-        struct boot_param_header *new;
-
-        start = __pa((unsigned long)initial_boot_params);
-        end = start + initial_boot_params->totalsize;
-
-        if (end < crashk_res.start || start > crashk_res.end)
-                return;
-
-        new = (struct boot_param_header*)
-                __va(lmb_alloc(initial_boot_params->totalsize, PAGE_SIZE));
-
-        memcpy(new, initial_boot_params, initial_boot_params->totalsize);
-
-        initial_boot_params = new;
-
-        DBG("Flat device tree blob moved to %p\n", initial_boot_params);
-
-        /* XXX should we unreserve the old DT? */
-}
-#endif /* CONFIG_KEXEC */
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index 41e9ab40cd54..5908690d0868 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -194,19 +194,12 @@ static int __initdata of_platform;
 
 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
 
-static unsigned long __initdata prom_memory_limit;
-
 static unsigned long __initdata alloc_top;
 static unsigned long __initdata alloc_top_high;
 static unsigned long __initdata alloc_bottom;
 static unsigned long __initdata rmo_top;
 static unsigned long __initdata ram_top;
 
-#ifdef CONFIG_KEXEC
-static unsigned long __initdata prom_crashk_base;
-static unsigned long __initdata prom_crashk_size;
-#endif
-
 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
 static int __initdata mem_reserve_cnt;
 
@@ -593,45 +586,6 @@ static void __init early_cmdline_parse(void)
                         RELOC(iommu_force_on) = 1;
         }
 #endif
-
-        opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
-        if (opt) {
-                opt += 4;
-                RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
-#ifdef CONFIG_PPC64
-                /* Align to 16 MB == size of ppc64 large page */
-                RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
-#endif
-        }
-
-#ifdef CONFIG_KEXEC
-        /*
-         * crashkernel=size@addr specifies the location to reserve for
-         * crash kernel.
-         */
-        opt = strstr(RELOC(prom_cmd_line), RELOC("crashkernel="));
-        if (opt) {
-                opt += 12;
-                RELOC(prom_crashk_size) = 
-                        prom_memparse(opt, (const char **)&opt);
-
-                if (ALIGN(RELOC(prom_crashk_size), 0x1000000) !=
-                        RELOC(prom_crashk_size)) {
-                        prom_printf("Warning: crashkernel size is not "
-                                        "aligned to 16MB\n");
-                }
-
-                /*
-                 * At present, the crash kernel always run at 32MB.
-                 * Just ignore whatever user passed.
-                 */
-                RELOC(prom_crashk_base) = 0x2000000;
-                if (*opt == '@') {
-                        prom_printf("Warning: PPC64 kdump kernel always runs "
-                                        "at 32 MB\n");
-                }
-        }
-#endif
 }
 
 #ifdef CONFIG_PPC_PSERIES
@@ -1115,29 +1069,6 @@ static void __init prom_init_mem(void)
         }
 
         /*
-         * If prom_memory_limit is set we reduce the upper limits *except* for
-         * alloc_top_high. This must be the real top of RAM so we can put
-         * TCE's up there.
-         */
-
-        RELOC(alloc_top_high) = RELOC(ram_top);
-
-        if (RELOC(prom_memory_limit)) {
-                if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
-                        prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
-                                RELOC(prom_memory_limit));
-                        RELOC(prom_memory_limit) = 0;
-                } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
-                        prom_printf("Ignoring mem=%x >= ram_top.\n",
-                                RELOC(prom_memory_limit));
-                        RELOC(prom_memory_limit) = 0;
-                } else {
-                        RELOC(ram_top) = RELOC(prom_memory_limit);
-                        RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
-                }
-        }
-
-        /*
          * Setup our top alloc point, that is top of RMO or top of
          * segment 0 when running non-LPAR.
          * Some RS64 machines have buggy firmware where claims up at
@@ -1149,20 +1080,14 @@ static void __init prom_init_mem(void)
                 RELOC(rmo_top) = RELOC(ram_top);
         RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
         RELOC(alloc_top) = RELOC(rmo_top);
+        RELOC(alloc_top_high) = RELOC(ram_top);
 
         prom_printf("memory layout at init:\n");
-        prom_printf("  memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
         prom_printf("  alloc_bottom : %x\n", RELOC(alloc_bottom));
         prom_printf("  alloc_top    : %x\n", RELOC(alloc_top));
         prom_printf("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
         prom_printf("  rmo_top      : %x\n", RELOC(rmo_top));
         prom_printf("  ram_top      : %x\n", RELOC(ram_top));
-#ifdef CONFIG_KEXEC
-        if (RELOC(prom_crashk_base)) {
-                prom_printf("  crashk_base  : %x\n",  RELOC(prom_crashk_base));
-                prom_printf("  crashk_size  : %x\n", RELOC(prom_crashk_size));
-        }
-#endif
 }
 
 
@@ -1348,16 +1273,10 @@ static void __init prom_initialize_tce_table(void)
 
         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
 
-        if (RELOC(prom_memory_limit)) {
-                /*
-                 * We align the start to a 16MB boundary so we can map
-                 * the TCE area using large pages if possible.
-                 * The end should be the top of RAM so no need to align it.
-                 */
-                RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom,
-                                                          0x1000000);
-                RELOC(prom_tce_alloc_end) = local_alloc_top;
-        }
+        /* These are only really needed if there is a memory limit in
+         * effect, but we don't know so export them always. */
+        RELOC(prom_tce_alloc_start) = local_alloc_bottom;
+        RELOC(prom_tce_alloc_end) = local_alloc_top;
 
         /* Flag the first invalid entry */
         prom_debug("ending prom_initialize_tce_table\n");
@@ -2031,11 +1950,7 @@ static void __init flatten_device_tree(void)
         /* Version 16 is not backward compatible */
         hdr->last_comp_version = 0x10;
 
-        /* Reserve the whole thing and copy the reserve map in, we
-         * also bump mem_reserve_cnt to cause further reservations to
-         * fail since it's too late.
-         */
-        reserve_mem(RELOC(dt_header_start), hdr->totalsize);
+        /* Copy the reserve map in */
         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
 
 #ifdef DEBUG_PROM
@@ -2048,6 +1963,9 @@ static void __init flatten_device_tree(void)
                                     RELOC(mem_reserve_map)[i].size);
         }
 #endif
+        /* Bump mem_reserve_cnt to cause further reservations to fail
+         * since it's too late.
+         */
         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
 
         prom_printf("Device tree strings 0x%x -> 0x%x\n",
@@ -2270,10 +2188,6 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
          */
         prom_init_mem();
 
-#ifdef CONFIG_KEXEC
-        if (RELOC(prom_crashk_base))
-                reserve_mem(RELOC(prom_crashk_base), RELOC(prom_crashk_size));
-#endif
         /*
          * Determine which cpu is actually running right _now_
          */
@@ -2307,10 +2221,6 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         /*
          * Fill in some infos for use by the kernel later on
          */
-        if (RELOC(prom_memory_limit))
-                prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
-                             &RELOC(prom_memory_limit),
-                             sizeof(prom_memory_limit));
 #ifdef CONFIG_PPC64
         if (RELOC(ppc64_iommu_off))
                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
@@ -2330,16 +2240,6 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         }
 #endif
 
-#ifdef CONFIG_KEXEC
-        if (RELOC(prom_crashk_base)) {
-                prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-base",
-                        PTRRELOC(&prom_crashk_base),
-                        sizeof(RELOC(prom_crashk_base)));
-                prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-size",
-                        PTRRELOC(&prom_crashk_size),
-                        sizeof(RELOC(prom_crashk_size)));
-        }
-#endif
         /*
          * Fixup any known bugs in the device-tree
          */
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c
index 3934c227549b..23bb060330ef 100644
--- a/arch/powerpc/kernel/prom_parse.c
+++ b/arch/powerpc/kernel/prom_parse.c
@@ -548,3 +548,25 @@ int of_pci_address_to_resource(struct device_node *dev, int bar,
         return __of_address_to_resource(dev, addrp, size, flags, r);
 }
 EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
+
+void of_parse_dma_window(struct device_node *dn, unsigned char *dma_window_prop,
+                unsigned long *busno, unsigned long *phys, unsigned long *size)
+{
+        u32 *dma_window, cells;
+        unsigned char *prop;
+
+        dma_window = (u32 *)dma_window_prop;
+
+        /* busno is always one cell */
+        *busno = *(dma_window++);
+
+        prop = get_property(dn, "ibm,#dma-address-cells", NULL);
+        cells = prop ? *(u32 *)prop : prom_n_addr_cells(dn);
+        *phys = of_read_addr(dma_window, cells);
+
+        dma_window += cells;
+
+        prop = get_property(dn, "ibm,#dma-size-cells", NULL);
+        cells = prop ? *(u32 *)prop : prom_n_size_cells(dn);
+        *size = of_read_addr(dma_window, cells);
+}
diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
index 684ab1d49c65..bd328123af75 100644
--- a/arch/powerpc/kernel/setup-common.c
+++ b/arch/powerpc/kernel/setup-common.c
@@ -443,6 +443,7 @@ void __init smp_setup_cpu_maps(void)
 }
 #endif /* CONFIG_SMP */
 
+int __initdata do_early_xmon;
 #ifdef CONFIG_XMON
 static int __init early_xmon(char *p)
 {
@@ -456,7 +457,7 @@ static int __init early_xmon(char *p)
                         return 0;
         }
         xmon_init(1);
-        debugger(NULL);
+        do_early_xmon = 1;
 
         return 0;
 }
@@ -524,3 +525,20 @@ int check_legacy_ioport(unsigned long base_port)
         return ppc_md.check_legacy_ioport(base_port);
 }
 EXPORT_SYMBOL(check_legacy_ioport);
+
+static int ppc_panic_event(struct notifier_block *this,
+                             unsigned long event, void *ptr)
+{
+        ppc_md.panic(ptr);  /* May not return */
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block ppc_panic_block = {
+        .notifier_call = ppc_panic_event,
+        .priority = INT_MIN /* may not return; must be done last */
+};
+
+void __init setup_panic(void)
+{
+        atomic_notifier_chain_register(&panic_notifier_list, &ppc_panic_block);
+}
diff --git a/arch/powerpc/kernel/setup.h b/arch/powerpc/kernel/setup.h
index 2ebba755272e..4c67ad7fae08 100644
--- a/arch/powerpc/kernel/setup.h
+++ b/arch/powerpc/kernel/setup.h
@@ -2,5 +2,8 @@
 #define _POWERPC_KERNEL_SETUP_H
 
 void check_for_initrd(void);
+void do_init_bootmem(void);
+void setup_panic(void);
+extern int do_early_xmon;
 
 #endif /* _POWERPC_KERNEL_SETUP_H */
diff --git a/arch/powerpc/kernel/setup_32.c b/arch/powerpc/kernel/setup_32.c
index 69ac25701344..e5a44812441a 100644
--- a/arch/powerpc/kernel/setup_32.c
+++ b/arch/powerpc/kernel/setup_32.c
@@ -131,12 +131,6 @@ void __init machine_init(unsigned long dt_ptr, unsigned long phys)
         /* Do some early initialization based on the flat device tree */
         early_init_devtree(__va(dt_ptr));
 
-        /* Check default command line */
-#ifdef CONFIG_CMDLINE
-        if (cmd_line[0] == 0)
-                strlcpy(cmd_line, CONFIG_CMDLINE, sizeof(cmd_line));
-#endif /* CONFIG_CMDLINE */
-
         probe_machine();
 
 #ifdef CONFIG_6xx
@@ -235,7 +229,7 @@ arch_initcall(ppc_init);
 /* Warning, IO base is not yet inited */
 void __init setup_arch(char **cmdline_p)
 {
-        extern void do_init_bootmem(void);
+        *cmdline_p = cmd_line;
 
         /* so udelay does something sensible, assume <= 1000 bogomips */
         loops_per_jiffy = 500000000 / HZ;
@@ -285,16 +279,16 @@ void __init setup_arch(char **cmdline_p)
         /* reboot on panic */
         panic_timeout = 180;
 
+        if (ppc_md.panic)
+                setup_panic();
+
         init_mm.start_code = PAGE_OFFSET;
         init_mm.end_code = (unsigned long) _etext;
         init_mm.end_data = (unsigned long) _edata;
         init_mm.brk = klimit;
 
-        /* Save unparsed command line copy for /proc/cmdline */
-        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-        *cmdline_p = cmd_line;
-
-        parse_early_param();
+        if (do_early_xmon)
+                debugger(NULL);
 
         /* set up the bootmem stuff with available memory */
         do_init_bootmem();
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index 4467c49903b6..78f3a5fd43f6 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -100,12 +100,6 @@ unsigned long SYSRQ_KEY;
 #endif /* CONFIG_MAGIC_SYSRQ */
 
 
-static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);
-static struct notifier_block ppc64_panic_block = {
-        .notifier_call = ppc64_panic_event,
-        .priority = INT_MIN /* may not return; must be done last */
-};
-
 #ifdef CONFIG_SMP
 
 static int smt_enabled_cmdline;
@@ -199,9 +193,7 @@ void __init early_setup(unsigned long dt_ptr)
         /* Probe the machine type */
         probe_machine();
 
-#ifdef CONFIG_CRASH_DUMP
-        kdump_setup();
-#endif
+        setup_kdump_trampoline();
 
         DBG("Found, Initializing memory management...\n");
 
@@ -353,9 +345,6 @@ void __init setup_system(void)
 {
         DBG(" -> setup_system()\n");
 
-#ifdef CONFIG_KEXEC
-        kdump_move_device_tree();
-#endif
         /*
          * Unflatten the device-tree passed by prom_init or kexec
          */
@@ -420,10 +409,8 @@ void __init setup_system(void)
          */
         register_early_udbg_console();
 
-        /* Save unparsed command line copy for /proc/cmdline */
-        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-
-        parse_early_param();
+        if (do_early_xmon)
+                debugger(NULL);
 
         check_smt_enabled();
         smp_setup_cpu_maps();
@@ -456,13 +443,6 @@ void __init setup_system(void)
         DBG(" <- setup_system()\n");
 }
 
-static int ppc64_panic_event(struct notifier_block *this,
-                             unsigned long event, void *ptr)
-{
-        ppc_md.panic((char *)ptr);  /* May not return */
-        return NOTIFY_DONE;
-}
-
 #ifdef CONFIG_IRQSTACKS
 static void __init irqstack_early_init(void)
 {
@@ -517,8 +497,6 @@ static void __init emergency_stack_init(void)
  */
 void __init setup_arch(char **cmdline_p)
 {
-        extern void do_init_bootmem(void);
-
         ppc64_boot_msg(0x12, "Setup Arch");
 
         *cmdline_p = cmd_line;
@@ -535,8 +513,7 @@ void __init setup_arch(char **cmdline_p)
         panic_timeout = 180;
 
         if (ppc_md.panic)
-                atomic_notifier_chain_register(&panic_notifier_list,
-                                &ppc64_panic_block);
+                setup_panic();
 
         init_mm.start_code = PAGE_OFFSET;
         init_mm.end_code = (unsigned long) _etext;
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 24e3ad756de0..528e7f84cb67 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -76,7 +76,6 @@
 
 /* keep track of when we need to update the rtc */
 time_t last_rtc_update;
-extern int piranha_simulator;
 #ifdef CONFIG_PPC_ISERIES
 unsigned long iSeries_recal_titan = 0;
 unsigned long iSeries_recal_tb = 0; 
@@ -945,9 +944,9 @@ void __init time_init(void)
         } else {
                 /* Normal PowerPC with timebase register */
                 ppc_md.calibrate_decr();
-                printk(KERN_INFO "time_init: decrementer frequency = %lu.%.6lu MHz\n",
+                printk(KERN_DEBUG "time_init: decrementer frequency = %lu.%.6lu MHz\n",
                        ppc_tb_freq / 1000000, ppc_tb_freq % 1000000);
-                printk(KERN_INFO "time_init: processor frequency   = %lu.%.6lu MHz\n",
+                printk(KERN_DEBUG "time_init: processor frequency   = %lu.%.6lu MHz\n",
                        ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
                 tb_last_stamp = tb_last_jiffy = get_tb();
         }
@@ -1010,10 +1009,7 @@ void __init time_init(void)
         tb_to_ns_scale = scale;
         tb_to_ns_shift = shift;
 
-#ifdef CONFIG_PPC_ISERIES
-        if (!piranha_simulator)
-#endif
-                tm = get_boot_time();
+        tm = get_boot_time();
 
         write_seqlock_irqsave(&xtime_lock, flags);
 
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index 971020cf3f7d..fe92727aca30 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -13,27 +13,116 @@
  *      2 of the License, or (at your option) any later version.
  */
 
+#include <linux/types.h>
+#include <linux/device.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/dma-mapping.h>
+#include <linux/kobject.h>
+
 #include <asm/iommu.h>
 #include <asm/dma.h>
 #include <asm/vio.h>
 #include <asm/prom.h>
-
-static const struct vio_device_id *vio_match_device(
-                const struct vio_device_id *, const struct vio_dev *);
-
-struct vio_dev vio_bus_device  = { /* fake "parent" device */
+#include <asm/firmware.h>
+#include <asm/tce.h>
+#include <asm/abs_addr.h>
+#include <asm/page.h>
+#include <asm/hvcall.h>
+#include <asm/iseries/vio.h>
+#include <asm/iseries/hv_types.h>
+#include <asm/iseries/hv_lp_config.h>
+#include <asm/iseries/hv_call_xm.h>
+#include <asm/iseries/iommu.h>
+
+extern struct subsystem devices_subsys; /* needed for vio_find_name() */
+
+static struct vio_dev vio_bus_device  = { /* fake "parent" device */
         .name = vio_bus_device.dev.bus_id,
         .type = "",
         .dev.bus_id = "vio",
         .dev.bus = &vio_bus_type,
 };
 
-static struct vio_bus_ops vio_bus_ops;
+#ifdef CONFIG_PPC_ISERIES
+struct device *iSeries_vio_dev = &vio_bus_device.dev;
+EXPORT_SYMBOL(iSeries_vio_dev);
+
+static struct iommu_table veth_iommu_table;
+static struct iommu_table vio_iommu_table;
+
+static void __init iommu_vio_init(void)
+{
+        iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table);
+        veth_iommu_table.it_size /= 2;
+        vio_iommu_table = veth_iommu_table;
+        vio_iommu_table.it_offset += veth_iommu_table.it_size;
+
+        if (!iommu_init_table(&veth_iommu_table))
+                printk("Virtual Bus VETH TCE table failed.\n");
+        if (!iommu_init_table(&vio_iommu_table))
+                printk("Virtual Bus VIO TCE table failed.\n");
+}
+#endif
+
+static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
+{
+#ifdef CONFIG_PPC_ISERIES
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                if (strcmp(dev->type, "network") == 0)
+                        return &veth_iommu_table;
+                return &vio_iommu_table;
+        } else
+#endif
+        {
+                unsigned char *dma_window;
+                struct iommu_table *tbl;
+                unsigned long offset, size;
+
+                dma_window = get_property(dev->dev.platform_data,
+                                "ibm,my-dma-window", NULL);
+                if (!dma_window)
+                        return NULL;
+
+                tbl = kmalloc(sizeof(*tbl), GFP_KERNEL);
+
+                of_parse_dma_window(dev->dev.platform_data, dma_window,
+                                &tbl->it_index, &offset, &size);
+
+                /* TCE table size - measured in tce entries */
+                tbl->it_size = size >> PAGE_SHIFT;
+                /* offset for VIO should always be 0 */
+                tbl->it_offset = offset >> PAGE_SHIFT;
+                tbl->it_busno = 0;
+                tbl->it_type = TCE_VB;
+
+                return iommu_init_table(tbl);
+        }
+}
+
+/**
+ * vio_match_device: - Tell if a VIO device has a matching
+ *                      VIO device id structure.
+ * @ids:        array of VIO device id structures to search in
+ * @dev:        the VIO device structure to match against
+ *
+ * Used by a driver to check whether a VIO device present in the
+ * system is in its list of supported devices. Returns the matching
+ * vio_device_id structure or NULL if there is no match.
+ */
+static const struct vio_device_id *vio_match_device(
+                const struct vio_device_id *ids, const struct vio_dev *dev)
+{
+        while (ids->type[0] != '\0') {
+                if ((strncmp(dev->type, ids->type, strlen(ids->type)) == 0) &&
+                    device_is_compatible(dev->dev.platform_data, ids->compat))
+                        return ids;
+                ids++;
+        }
+        return NULL;
+}
 
 /*
  * Convert from struct device to struct vio_dev and pass to driver.
@@ -106,35 +195,110 @@ void vio_unregister_driver(struct vio_driver *viodrv)
 }
 EXPORT_SYMBOL(vio_unregister_driver);
 
+/* vio_dev refcount hit 0 */
+static void __devinit vio_dev_release(struct device *dev)
+{
+        if (dev->platform_data) {
+                /* XXX free TCE table */
+                of_node_put(dev->platform_data);
+        }
+        kfree(to_vio_dev(dev));
+}
+
 /**
- * vio_match_device: - Tell if a VIO device has a matching
- *                      VIO device id structure.
- * @ids:        array of VIO device id structures to search in
- * @dev:        the VIO device structure to match against
+ * vio_register_device_node: - Register a new vio device.
+ * @of_node:    The OF node for this device.
  *
- * Used by a driver to check whether a VIO device present in the
- * system is in its list of supported devices. Returns the matching
- * vio_device_id structure or NULL if there is no match.
+ * Creates and initializes a vio_dev structure from the data in
+ * of_node (dev.platform_data) and adds it to the list of virtual devices.
+ * Returns a pointer to the created vio_dev or NULL if node has
+ * NULL device_type or compatible fields.
  */
-static const struct vio_device_id *vio_match_device(
-                const struct vio_device_id *ids, const struct vio_dev *dev)
+struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
 {
-        while (ids->type[0] != '\0') {
-                if (vio_bus_ops.match(ids, dev))
-                        return ids;
-                ids++;
+        struct vio_dev *viodev;
+        unsigned int *unit_address;
+        unsigned int *irq_p;
+
+        /* we need the 'device_type' property, in order to match with drivers */
+        if (of_node->type == NULL) {
+                printk(KERN_WARNING "%s: node %s missing 'device_type'\n",
+                                __FUNCTION__,
+                                of_node->name ? of_node->name : "<unknown>");
+                return NULL;
         }
-        return NULL;
+
+        unit_address = (unsigned int *)get_property(of_node, "reg", NULL);
+        if (unit_address == NULL) {
+                printk(KERN_WARNING "%s: node %s missing 'reg'\n",
+                                __FUNCTION__,
+                                of_node->name ? of_node->name : "<unknown>");
+                return NULL;
+        }
+
+        /* allocate a vio_dev for this node */
+        viodev = kzalloc(sizeof(struct vio_dev), GFP_KERNEL);
+        if (viodev == NULL)
+                return NULL;
+
+        viodev->dev.platform_data = of_node_get(of_node);
+
+        viodev->irq = NO_IRQ;
+        irq_p = (unsigned int *)get_property(of_node, "interrupts", NULL);
+        if (irq_p) {
+                int virq = virt_irq_create_mapping(*irq_p);
+                if (virq == NO_IRQ) {
+                        printk(KERN_ERR "Unable to allocate interrupt "
+                               "number for %s\n", of_node->full_name);
+                } else
+                        viodev->irq = irq_offset_up(virq);
+        }
+
+        snprintf(viodev->dev.bus_id, BUS_ID_SIZE, "%x", *unit_address);
+        viodev->name = of_node->name;
+        viodev->type = of_node->type;
+        viodev->unit_address = *unit_address;
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                unit_address = (unsigned int *)get_property(of_node,
+                                "linux,unit_address", NULL);
+                if (unit_address != NULL)
+                        viodev->unit_address = *unit_address;
+        }
+        viodev->iommu_table = vio_build_iommu_table(viodev);
+
+        /* init generic 'struct device' fields: */
+        viodev->dev.parent = &vio_bus_device.dev;
+        viodev->dev.bus = &vio_bus_type;
+        viodev->dev.release = vio_dev_release;
+
+        /* register with generic device framework */
+        if (device_register(&viodev->dev)) {
+                printk(KERN_ERR "%s: failed to register device %s\n",
+                                __FUNCTION__, viodev->dev.bus_id);
+                /* XXX free TCE table */
+                kfree(viodev);
+                return NULL;
+        }
+
+        return viodev;
 }
+EXPORT_SYMBOL(vio_register_device_node);
 
 /**
  * vio_bus_init: - Initialize the virtual IO bus
  */
-int __init vio_bus_init(struct vio_bus_ops *ops)
+static int __init vio_bus_init(void)
 {
         int err;
+        struct device_node *node_vroot;
 
-        vio_bus_ops = *ops;
+#ifdef CONFIG_PPC_ISERIES
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                iommu_vio_init();
+                vio_bus_device.iommu_table = &vio_iommu_table;
+                iSeries_vio_dev = &vio_bus_device.dev;
+        }
+#endif
 
         err = bus_register(&vio_bus_type);
         if (err) {
@@ -153,47 +317,48 @@ int __init vio_bus_init(struct vio_bus_ops *ops)
                 return err;
         }
 
-        return 0;
-}
+        node_vroot = find_devices("vdevice");
+        if (node_vroot) {
+                struct device_node *of_node;
+
+                /*
+                 * Create struct vio_devices for each virtual device in
+                 * the device tree. Drivers will associate with them later.
+                 */
+                for (of_node = node_vroot->child; of_node != NULL;
+                                of_node = of_node->sibling) {
+                        printk(KERN_DEBUG "%s: processing %p\n",
+                                        __FUNCTION__, of_node);
+                        vio_register_device_node(of_node);
+                }
+        }
 
-/* vio_dev refcount hit 0 */
-static void __devinit vio_dev_release(struct device *dev)
-{
-        if (vio_bus_ops.release_device)
-                vio_bus_ops.release_device(dev);
-        kfree(to_vio_dev(dev));
+        return 0;
 }
+__initcall(vio_bus_init);
 
-static ssize_t viodev_show_name(struct device *dev,
+static ssize_t name_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
         return sprintf(buf, "%s\n", to_vio_dev(dev)->name);
 }
-DEVICE_ATTR(name, S_IRUSR | S_IRGRP | S_IROTH, viodev_show_name, NULL);
 
-struct vio_dev * __devinit vio_register_device(struct vio_dev *viodev)
+static ssize_t devspec_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
-        /* init generic 'struct device' fields: */
-        viodev->dev.parent = &vio_bus_device.dev;
-        viodev->dev.bus = &vio_bus_type;
-        viodev->dev.release = vio_dev_release;
-
-        /* register with generic device framework */
-        if (device_register(&viodev->dev)) {
-                printk(KERN_ERR "%s: failed to register device %s\n",
-                                __FUNCTION__, viodev->dev.bus_id);
-                return NULL;
-        }
-        device_create_file(&viodev->dev, &dev_attr_name);
+        struct device_node *of_node = dev->platform_data;
 
-        return viodev;
+        return sprintf(buf, "%s\n", of_node ? of_node->full_name : "none");
 }
 
+static struct device_attribute vio_dev_attrs[] = {
+        __ATTR_RO(name),
+        __ATTR_RO(devspec),
+        __ATTR_NULL
+};
+
 void __devinit vio_unregister_device(struct vio_dev *viodev)
 {
-        if (vio_bus_ops.unregister_device)
-                vio_bus_ops.unregister_device(viodev);
-        device_remove_file(&viodev->dev, &dev_attr_name);
         device_unregister(&viodev->dev);
 }
 EXPORT_SYMBOL(vio_unregister_device);
@@ -267,22 +432,23 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp,
                         char *buffer, int buffer_size)
 {
         const struct vio_dev *vio_dev = to_vio_dev(dev);
+        struct device_node *dn = dev->platform_data;
         char *cp;
         int length;
 
         if (!num_envp)
                 return -ENOMEM;
 
-        if (!vio_dev->dev.platform_data)
+        if (!dn)
                 return -ENODEV;
-        cp = (char *)get_property(vio_dev->dev.platform_data, "compatible", &length);
+        cp = (char *)get_property(dn, "compatible", &length);
         if (!cp)
                 return -ENODEV;
 
         envp[0] = buffer;
         length = scnprintf(buffer, buffer_size, "MODALIAS=vio:T%sS%s",
                                 vio_dev->type, cp);
-        if (buffer_size - length <= 0)
+        if ((buffer_size - length) <= 0)
                 return -ENOMEM;
         envp[1] = NULL;
         return 0;
@@ -290,9 +456,81 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp,
 
 struct bus_type vio_bus_type = {
         .name = "vio",
+        .dev_attrs = vio_dev_attrs,
         .uevent = vio_hotplug,
         .match = vio_bus_match,
         .probe = vio_bus_probe,
         .remove = vio_bus_remove,
         .shutdown = vio_bus_shutdown,
 };
+
+/**
+ * vio_get_attribute: - get attribute for virtual device
+ * @vdev:       The vio device to get property.
+ * @which:      The property/attribute to be extracted.
+ * @length:     Pointer to length of returned data size (unused if NULL).
+ *
+ * Calls prom.c's get_property() to return the value of the
+ * attribute specified by @which
+*/
+const void *vio_get_attribute(struct vio_dev *vdev, char *which, int *length)
+{
+        return get_property(vdev->dev.platform_data, which, length);
+}
+EXPORT_SYMBOL(vio_get_attribute);
+
+#ifdef CONFIG_PPC_PSERIES
+/* vio_find_name() - internal because only vio.c knows how we formatted the
+ * kobject name
+ * XXX once vio_bus_type.devices is actually used as a kset in
+ * drivers/base/bus.c, this function should be removed in favor of
+ * "device_find(kobj_name, &vio_bus_type)"
+ */
+static struct vio_dev *vio_find_name(const char *kobj_name)
+{
+        struct kobject *found;
+
+        found = kset_find_obj(&devices_subsys.kset, kobj_name);
+        if (!found)
+                return NULL;
+
+        return to_vio_dev(container_of(found, struct device, kobj));
+}
+
+/**
+ * vio_find_node - find an already-registered vio_dev
+ * @vnode: device_node of the virtual device we're looking for
+ */
+struct vio_dev *vio_find_node(struct device_node *vnode)
+{
+        uint32_t *unit_address;
+        char kobj_name[BUS_ID_SIZE];
+
+        /* construct the kobject name from the device node */
+        unit_address = (uint32_t *)get_property(vnode, "reg", NULL);
+        if (!unit_address)
+                return NULL;
+        snprintf(kobj_name, BUS_ID_SIZE, "%x", *unit_address);
+
+        return vio_find_name(kobj_name);
+}
+EXPORT_SYMBOL(vio_find_node);
+
+int vio_enable_interrupts(struct vio_dev *dev)
+{
+        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_ENABLE);
+        if (rc != H_SUCCESS)
+                printk(KERN_ERR "vio: Error 0x%x enabling interrupts\n", rc);
+        return rc;
+}
+EXPORT_SYMBOL(vio_enable_interrupts);
+
+int vio_disable_interrupts(struct vio_dev *dev)
+{
+        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_DISABLE);
+        if (rc != H_SUCCESS)
+                printk(KERN_ERR "vio: Error 0x%x disabling interrupts\n", rc);
+        return rc;
+}
+EXPORT_SYMBOL(vio_disable_interrupts);
+#endif /* CONFIG_PPC_PSERIES */
diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S
index fe79c2584cb0..8b25953dc4f0 100644
--- a/arch/powerpc/kernel/vmlinux.lds.S
+++ b/arch/powerpc/kernel/vmlinux.lds.S
@@ -93,6 +93,11 @@ SECTIONS
                 __ptov_table_begin = .;
                 *(.ptov_fixup);
                 __ptov_table_end = .;
+#ifdef CONFIG_PPC_ISERIES
+                __dt_strings_start = .;
+                *(.dt_strings);
+                __dt_strings_end = .;
+#endif
         }
 
         . = ALIGN(16);
diff --git a/arch/powerpc/lib/Makefile b/arch/powerpc/lib/Makefile
index 34f5c2e074c9..ae354d65b82c 100644
--- a/arch/powerpc/lib/Makefile
+++ b/arch/powerpc/lib/Makefile
@@ -7,7 +7,6 @@ obj-y			:= string.o strcase.o
 obj-$(CONFIG_PPC32)     += div64.o copy_32.o checksum_32.o
 endif
 
-obj-y                   += bitops.o
 obj-$(CONFIG_PPC64)     += checksum_64.o copypage_64.o copyuser_64.o \
                            memcpy_64.o usercopy_64.o mem_64.o string.o \
                            strcase.o
diff --git a/arch/powerpc/lib/bitops.c b/arch/powerpc/lib/bitops.c
deleted file mode 100644
index f68ad71a0187..000000000000
--- a/arch/powerpc/lib/bitops.c
+++ /dev/null
@@ -1,150 +0,0 @@
-#include <linux/types.h>
-#include <linux/module.h>
-#include <asm/byteorder.h>
-#include <asm/bitops.h>
-
-/**
- * find_next_bit - find the next set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bitnumber to start searching at
- * @size: The maximum size to search
- */
-unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
-                            unsigned long offset)
-{
-        const unsigned long *p = addr + BITOP_WORD(offset);
-        unsigned long result = offset & ~(BITS_PER_LONG-1);
-        unsigned long tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset %= BITS_PER_LONG;
-        if (offset) {
-                tmp = *(p++);
-                tmp &= (~0UL << offset);
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG-1)) {
-                if ((tmp = *(p++)))
-                        goto found_middle;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-
-found_first:
-        tmp &= (~0UL >> (BITS_PER_LONG - size));
-        if (tmp == 0UL)         /* Are any bits set? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + __ffs(tmp);
-}
-EXPORT_SYMBOL(find_next_bit);
-
-/*
- * This implementation of find_{first,next}_zero_bit was stolen from
- * Linus' asm-alpha/bitops.h.
- */
-unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
-                                 unsigned long offset)
-{
-        const unsigned long *p = addr + BITOP_WORD(offset);
-        unsigned long result = offset & ~(BITS_PER_LONG-1);
-        unsigned long tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset %= BITS_PER_LONG;
-        if (offset) {
-                tmp = *(p++);
-                tmp |= ~0UL >> (BITS_PER_LONG - offset);
-                if (size < BITS_PER_LONG)
-                        goto found_first;
-                if (~tmp)
-                        goto found_middle;
-                size -= BITS_PER_LONG;
-                result += BITS_PER_LONG;
-        }
-        while (size & ~(BITS_PER_LONG-1)) {
-                if (~(tmp = *(p++)))
-                        goto found_middle;
-                result += BITS_PER_LONG;
-                size -= BITS_PER_LONG;
-        }
-        if (!size)
-                return result;
-        tmp = *p;
-
-found_first:
-        tmp |= ~0UL << size;
-        if (tmp == ~0UL)        /* Are any bits zero? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + ffz(tmp);
-}
-EXPORT_SYMBOL(find_next_zero_bit);
-
-static inline unsigned int ext2_ilog2(unsigned int x)
-{
-        int lz;
-
-        asm("cntlzw %0,%1": "=r"(lz):"r"(x));
-        return 31 - lz;
-}
-
-static inline unsigned int ext2_ffz(unsigned int x)
-{
-        u32 rc;
-        if ((x = ~x) == 0)
-                return 32;
-        rc = ext2_ilog2(x & -x);
-        return rc;
-}
-
-unsigned long find_next_zero_le_bit(const unsigned long *addr,
-                                    unsigned long size, unsigned long offset)
-{
-        const unsigned int *p = ((const unsigned int *)addr) + (offset >> 5);
-        unsigned int result = offset & ~31;
-        unsigned int tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31;
-        if (offset) {
-                tmp = cpu_to_le32p(p++);
-                tmp |= ~0U >> (32 - offset);    /* bug or feature ? */
-                if (size < 32)
-                        goto found_first;
-                if (tmp != ~0)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = cpu_to_le32p(p++)) != ~0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = cpu_to_le32p(p);
-found_first:
-        tmp |= ~0 << size;
-        if (tmp == ~0)          /* Are any bits zero? */
-                return result + size;   /* Nope. */
-found_middle:
-        return result + ext2_ffz(tmp);
-}
-EXPORT_SYMBOL(find_next_zero_le_bit);
diff --git a/arch/powerpc/mm/hash_utils_64.c b/arch/powerpc/mm/hash_utils_64.c
index c006d9039633..b43ed92ef471 100644
--- a/arch/powerpc/mm/hash_utils_64.c
+++ b/arch/powerpc/mm/hash_utils_64.c
@@ -319,7 +319,7 @@ static void __init htab_init_page_sizes(void)
                 mmu_virtual_psize = MMU_PAGE_64K;
 #endif
 
-        printk(KERN_INFO "Page orders: linear mapping = %d, others = %d\n",
+        printk(KERN_DEBUG "Page orders: linear mapping = %d, others = %d\n",
                mmu_psize_defs[mmu_linear_psize].shift,
                mmu_psize_defs[mmu_virtual_psize].shift);
 
diff --git a/arch/powerpc/mm/lmb.c b/arch/powerpc/mm/lmb.c
index 417d58518558..8b6f522655a6 100644
--- a/arch/powerpc/mm/lmb.c
+++ b/arch/powerpc/mm/lmb.c
@@ -89,20 +89,25 @@ static long __init lmb_regions_adjacent(struct lmb_region *rgn,
         return lmb_addrs_adjacent(base1, size1, base2, size2);
 }
 
-/* Assumption: base addr of region 1 < base addr of region 2 */
-static void __init lmb_coalesce_regions(struct lmb_region *rgn,
-                unsigned long r1, unsigned long r2)
+static void __init lmb_remove_region(struct lmb_region *rgn, unsigned long r)
 {
         unsigned long i;
 
-        rgn->region[r1].size += rgn->region[r2].size;
-        for (i=r2; i < rgn->cnt-1; i++) {
-                rgn->region[i].base = rgn->region[i+1].base;
-                rgn->region[i].size = rgn->region[i+1].size;
+        for (i = r; i < rgn->cnt - 1; i++) {
+                rgn->region[i].base = rgn->region[i + 1].base;
+                rgn->region[i].size = rgn->region[i + 1].size;
         }
         rgn->cnt--;
 }
 
+/* Assumption: base addr of region 1 < base addr of region 2 */
+static void __init lmb_coalesce_regions(struct lmb_region *rgn,
+                unsigned long r1, unsigned long r2)
+{
+        rgn->region[r1].size += rgn->region[r2].size;
+        lmb_remove_region(rgn, r2);
+}
+
 /* This routine called with relocation disabled. */
 void __init lmb_init(void)
 {
@@ -294,17 +299,16 @@ unsigned long __init lmb_end_of_DRAM(void)
         return (lmb.memory.region[idx].base + lmb.memory.region[idx].size);
 }
 
-/*
- * Truncate the lmb list to memory_limit if it's set
- * You must call lmb_analyze() after this.
- */
+/* You must call lmb_analyze() after this. */
 void __init lmb_enforce_memory_limit(unsigned long memory_limit)
 {
         unsigned long i, limit;
+        struct lmb_property *p;
 
         if (! memory_limit)
                 return;
 
+        /* Truncate the lmb regions to satisfy the memory limit. */
         limit = memory_limit;
         for (i = 0; i < lmb.memory.cnt; i++) {
                 if (limit > lmb.memory.region[i].size) {
@@ -316,4 +320,21 @@ void __init lmb_enforce_memory_limit(unsigned long memory_limit)
                 lmb.memory.cnt = i + 1;
                 break;
         }
+
+        lmb.rmo_size = lmb.memory.region[0].size;
+
+        /* And truncate any reserves above the limit also. */
+        for (i = 0; i < lmb.reserved.cnt; i++) {
+                p = &lmb.reserved.region[i];
+
+                if (p->base > memory_limit)
+                        p->size = 0;
+                else if ((p->base + p->size) > memory_limit)
+                        p->size = memory_limit - p->base;
+
+                if (p->size == 0) {
+                        lmb_remove_region(&lmb.reserved, i);
+                        i--;
+                }
+        }
 }
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index 741dd8802d49..69f3b9a20beb 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -299,9 +299,9 @@ void __init paging_init(void)
         kmap_prot = PAGE_KERNEL;
 #endif /* CONFIG_HIGHMEM */
 
-        printk(KERN_INFO "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
+        printk(KERN_DEBUG "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
                top_of_ram, total_ram);
-        printk(KERN_INFO "Memory hole size: %ldMB\n",
+        printk(KERN_DEBUG "Memory hole size: %ldMB\n",
                (top_of_ram - total_ram) >> 20);
         /*
          * All pages are DMA-able so we put them all in the DMA zone.
@@ -380,7 +380,7 @@ void __init mem_init(void)
                         totalhigh_pages++;
                 }
                 totalram_pages += totalhigh_pages;
-                printk(KERN_INFO "High memory: %luk\n",
+                printk(KERN_DEBUG "High memory: %luk\n",
                        totalhigh_pages << (PAGE_SHIFT-10));
         }
 #endif /* CONFIG_HIGHMEM */
diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
index 092355f37399..aa98cb3b59d8 100644
--- a/arch/powerpc/mm/numa.c
+++ b/arch/powerpc/mm/numa.c
@@ -487,9 +487,9 @@ static void __init setup_nonnuma(void)
         unsigned long total_ram = lmb_phys_mem_size();
         unsigned int i;
 
-        printk(KERN_INFO "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
+        printk(KERN_DEBUG "Top of RAM: 0x%lx, Total RAM: 0x%lx\n",
                top_of_ram, total_ram);
-        printk(KERN_INFO "Memory hole size: %ldMB\n",
+        printk(KERN_DEBUG "Memory hole size: %ldMB\n",
                (top_of_ram - total_ram) >> 20);
 
         for (i = 0; i < lmb.memory.cnt; ++i)
@@ -507,7 +507,7 @@ void __init dump_numa_cpu_topology(void)
                 return;
 
         for_each_online_node(node) {
-                printk(KERN_INFO "Node %d CPUs:", node);
+                printk(KERN_DEBUG "Node %d CPUs:", node);
 
                 count = 0;
                 /*
@@ -543,7 +543,7 @@ static void __init dump_numa_memory_topology(void)
         for_each_online_node(node) {
                 unsigned long i;
 
-                printk(KERN_INFO "Node %d Memory:", node);
+                printk(KERN_DEBUG "Node %d Memory:", node);
 
                 count = 0;
 
diff --git a/arch/powerpc/oprofile/common.c b/arch/powerpc/oprofile/common.c
index 5b1de7e8041e..38a2f9c17187 100644
--- a/arch/powerpc/oprofile/common.c
+++ b/arch/powerpc/oprofile/common.c
@@ -162,7 +162,7 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
         ops->stop = op_powerpc_stop;
         ops->backtrace = op_powerpc_backtrace;
 
-        printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
+        printk(KERN_DEBUG "oprofile: using %s performance monitoring.\n",
                ops->cpu_type);
 
         return 0;
diff --git a/arch/powerpc/platforms/85xx/Kconfig b/arch/powerpc/platforms/85xx/Kconfig
index 06e371282f57..454fc53289ab 100644
--- a/arch/powerpc/platforms/85xx/Kconfig
+++ b/arch/powerpc/platforms/85xx/Kconfig
@@ -11,13 +11,20 @@ config MPC8540_ADS
         help
           This option enables support for the MPC 8540 ADS board
 
+config MPC85xx_CDS
+        bool "Freescale MPC85xx CDS"
+        select DEFAULT_UIMAGE
+        select PPC_I8259 if PCI
+        help
+          This option enables support for the MPC85xx CDS board
+
 endchoice
 
 config MPC8540
         bool
         select PPC_UDBG_16550
         select PPC_INDIRECT_PCI
-        default y if MPC8540_ADS
+        default y if MPC8540_ADS || MPC85xx_CDS
 
 config PPC_INDIRECT_PCI_BE
         bool
diff --git a/arch/powerpc/platforms/85xx/Makefile b/arch/powerpc/platforms/85xx/Makefile
index ffc4139cb214..7615aa59c78b 100644
--- a/arch/powerpc/platforms/85xx/Makefile
+++ b/arch/powerpc/platforms/85xx/Makefile
@@ -3,3 +3,4 @@
 #
 obj-$(CONFIG_PPC_85xx)  += misc.o pci.o
 obj-$(CONFIG_MPC8540_ADS) += mpc85xx_ads.o
+obj-$(CONFIG_MPC85xx_CDS) += mpc85xx_cds.o
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_cds.c b/arch/powerpc/platforms/85xx/mpc85xx_cds.c
new file mode 100644
index 000000000000..18e6e11f7020
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/mpc85xx_cds.c
@@ -0,0 +1,359 @@
+/*
+ * MPC85xx setup and early boot code plus other random bits.
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * Copyright 2005 Freescale Semiconductor Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/config.h>
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/reboot.h>
+#include <linux/pci.h>
+#include <linux/kdev_t.h>
+#include <linux/major.h>
+#include <linux/console.h>
+#include <linux/delay.h>
+#include <linux/seq_file.h>
+#include <linux/root_dev.h>
+#include <linux/initrd.h>
+#include <linux/module.h>
+#include <linux/fsl_devices.h>
+
+#include <asm/system.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <asm/atomic.h>
+#include <asm/time.h>
+#include <asm/io.h>
+#include <asm/machdep.h>
+#include <asm/ipic.h>
+#include <asm/bootinfo.h>
+#include <asm/pci-bridge.h>
+#include <asm/mpc85xx.h>
+#include <asm/irq.h>
+#include <mm/mmu_decl.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <asm/mpic.h>
+#include <asm/i8259.h>
+
+#include <sysdev/fsl_soc.h>
+#include "mpc85xx.h"
+
+#ifndef CONFIG_PCI
+unsigned long isa_io_base = 0;
+unsigned long isa_mem_base = 0;
+#endif
+
+static int cds_pci_slot = 2;
+static volatile u8 *cadmus;
+
+/*
+ * Internal interrupts are all Level Sensitive, and Positive Polarity
+ *
+ * Note:  Likely, this table and the following function should be
+ *        obtained and derived from the OF Device Tree.
+ */
+static u_char mpc85xx_cds_openpic_initsenses[] __initdata = {
+        MPC85XX_INTERNAL_IRQ_SENSES,
+#if defined(CONFIG_PCI)
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE),      /* Ext 0: PCI slot 0 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* Ext 1: PCI slot 1 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* Ext 2: PCI slot 2 */
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* Ext 3: PCI slot 3 */
+#else
+        0x0,                            /* External  0: */
+        0x0,                            /* External  1: */
+        0x0,                            /* External  2: */
+        0x0,                            /* External  3: */
+#endif
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),      /* External 5: PHY */
+        0x0,                            /* External  6: */
+        0x0,                            /* External  7: */
+        0x0,                            /* External  8: */
+        0x0,                            /* External  9: */
+        0x0,                            /* External 10: */
+#ifdef CONFIG_PCI
+        (IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE),    /* Ext 11: PCI2 slot 0 */
+#else
+        0x0,                            /* External 11: */
+#endif
+};
+
+
+#ifdef CONFIG_PCI
+/*
+ * interrupt routing
+ */
+int
+mpc85xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
+{
+        struct pci_controller *hose = pci_bus_to_hose(dev->bus->number);
+
+        if (!hose->index)
+        {
+                /* Handle PCI1 interrupts */
+                char pci_irq_table[][4] =
+                        /*
+                         *      PCI IDSEL/INTPIN->INTLINE
+                         *        A      B      C      D
+                         */
+
+                        /* Note IRQ assignment for slots is based on which slot the elysium is
+                         * in -- in this setup elysium is in slot #2 (this PIRQA as first
+                         * interrupt on slot */
+                {
+                        { 0, 1, 2, 3 }, /* 16 - PMC */
+                        { 0, 1, 2, 3 }, /* 17 P2P (Tsi320) */
+                        { 0, 1, 2, 3 }, /* 18 - Slot 1 */
+                        { 1, 2, 3, 0 }, /* 19 - Slot 2 */
+                        { 2, 3, 0, 1 }, /* 20 - Slot 3 */
+                        { 3, 0, 1, 2 }, /* 21 - Slot 4 */
+                };
+
+                const long min_idsel = 16, max_idsel = 21, irqs_per_slot = 4;
+                int i, j;
+
+                for (i = 0; i < 6; i++)
+                        for (j = 0; j < 4; j++)
+                                pci_irq_table[i][j] =
+                                        ((pci_irq_table[i][j] + 5 -
+                                          cds_pci_slot) & 0x3) + PIRQ0A;
+
+                return PCI_IRQ_TABLE_LOOKUP;
+        } else {
+                /* Handle PCI2 interrupts (if we have one) */
+                char pci_irq_table[][4] =
+                {
+                        /*
+                         * We only have one slot and one interrupt
+                         * going to PIRQA - PIRQD */
+                        { PIRQ1A, PIRQ1A, PIRQ1A, PIRQ1A }, /* 21 - slot 0 */
+                };
+
+                const long min_idsel = 21, max_idsel = 21, irqs_per_slot = 4;
+
+                return PCI_IRQ_TABLE_LOOKUP;
+        }
+}
+
+#define ARCADIA_HOST_BRIDGE_IDSEL       17
+#define ARCADIA_2ND_BRIDGE_IDSEL        3
+
+extern int mpc85xx_pci2_busno;
+
+int
+mpc85xx_exclude_device(u_char bus, u_char devfn)
+{
+        if (bus == 0 && PCI_SLOT(devfn) == 0)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if (mpc85xx_pci2_busno)
+                if (bus == (mpc85xx_pci2_busno) && PCI_SLOT(devfn) == 0)
+                        return PCIBIOS_DEVICE_NOT_FOUND;
+        /* We explicitly do not go past the Tundra 320 Bridge */
+        if ((bus == 1) && (PCI_SLOT(devfn) == ARCADIA_2ND_BRIDGE_IDSEL))
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if ((bus == 0) && (PCI_SLOT(devfn) == ARCADIA_2ND_BRIDGE_IDSEL))
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        else
+                return PCIBIOS_SUCCESSFUL;
+}
+
+void __init
+mpc85xx_cds_pcibios_fixup(void)
+{
+        struct pci_dev *dev;
+        u_char          c;
+
+        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                                        PCI_DEVICE_ID_VIA_82C586_1, NULL))) {
+                /*
+                 * U-Boot does not set the enable bits
+                 * for the IDE device. Force them on here.
+                 */
+                pci_read_config_byte(dev, 0x40, &c);
+                c |= 0x03; /* IDE: Chip Enable Bits */
+                pci_write_config_byte(dev, 0x40, c);
+
+                /*
+                 * Since only primary interface works, force the
+                 * IDE function to standard primary IDE interrupt
+                 * w/ 8259 offset
+                 */
+                dev->irq = 14;
+                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
+                pci_dev_put(dev);
+        }
+
+        /*
+         * Force legacy USB interrupt routing
+         */
+        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                                        PCI_DEVICE_ID_VIA_82C586_2, NULL))) {
+                dev->irq = 10;
+                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 10);
+                pci_dev_put(dev);
+        }
+
+        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                                        PCI_DEVICE_ID_VIA_82C586_2, dev))) {
+                dev->irq = 11;
+                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                pci_dev_put(dev);
+        }
+}
+#endif /* CONFIG_PCI */
+
+void __init mpc85xx_cds_pic_init(void)
+{
+        struct mpic *mpic1;
+        phys_addr_t OpenPIC_PAddr;
+
+        /* Determine the Physical Address of the OpenPIC regs */
+        OpenPIC_PAddr = get_immrbase() + MPC85xx_OPENPIC_OFFSET;
+
+        mpic1 = mpic_alloc(OpenPIC_PAddr,
+                        MPIC_PRIMARY | MPIC_WANTS_RESET | MPIC_BIG_ENDIAN,
+                        4, MPC85xx_OPENPIC_IRQ_OFFSET, 0, 250,
+                        mpc85xx_cds_openpic_initsenses,
+                        sizeof(mpc85xx_cds_openpic_initsenses), " OpenPIC  ");
+        BUG_ON(mpic1 == NULL);
+        mpic_assign_isu(mpic1, 0, OpenPIC_PAddr + 0x10200);
+        mpic_assign_isu(mpic1, 1, OpenPIC_PAddr + 0x10280);
+        mpic_assign_isu(mpic1, 2, OpenPIC_PAddr + 0x10300);
+        mpic_assign_isu(mpic1, 3, OpenPIC_PAddr + 0x10380);
+        mpic_assign_isu(mpic1, 4, OpenPIC_PAddr + 0x10400);
+        mpic_assign_isu(mpic1, 5, OpenPIC_PAddr + 0x10480);
+        mpic_assign_isu(mpic1, 6, OpenPIC_PAddr + 0x10500);
+        mpic_assign_isu(mpic1, 7, OpenPIC_PAddr + 0x10580);
+
+        /* dummy mappings to get to 48 */
+        mpic_assign_isu(mpic1, 8, OpenPIC_PAddr + 0x10600);
+        mpic_assign_isu(mpic1, 9, OpenPIC_PAddr + 0x10680);
+        mpic_assign_isu(mpic1, 10, OpenPIC_PAddr + 0x10700);
+        mpic_assign_isu(mpic1, 11, OpenPIC_PAddr + 0x10780);
+
+        /* External ints */
+        mpic_assign_isu(mpic1, 12, OpenPIC_PAddr + 0x10000);
+        mpic_assign_isu(mpic1, 13, OpenPIC_PAddr + 0x10080);
+        mpic_assign_isu(mpic1, 14, OpenPIC_PAddr + 0x10100);
+
+        mpic_init(mpic1);
+
+#ifdef CONFIG_PCI
+        mpic_setup_cascade(PIRQ0A, i8259_irq_cascade, NULL);
+
+        i8259_init(0,0);
+#endif
+}
+
+
+/*
+ * Setup the architecture
+ */
+static void __init
+mpc85xx_cds_setup_arch(void)
+{
+        struct device_node *cpu;
+#ifdef CONFIG_PCI
+        struct device_node *np;
+#endif
+
+        if (ppc_md.progress)
+                ppc_md.progress("mpc85xx_cds_setup_arch()", 0);
+
+        cpu = of_find_node_by_type(NULL, "cpu");
+        if (cpu != 0) {
+                unsigned int *fp;
+
+                fp = (int *)get_property(cpu, "clock-frequency", NULL);
+                if (fp != 0)
+                        loops_per_jiffy = *fp / HZ;
+                else
+                        loops_per_jiffy = 500000000 / HZ;
+                of_node_put(cpu);
+        }
+
+        cadmus = ioremap(CADMUS_BASE, CADMUS_SIZE);
+        cds_pci_slot = ((cadmus[CM_CSR] >> 6) & 0x3) + 1;
+
+        if (ppc_md.progress) {
+                char buf[40];
+                snprintf(buf, 40, "CDS Version = 0x%x in slot %d\n",
+                                cadmus[CM_VER], cds_pci_slot);
+                ppc_md.progress(buf, 0);
+        }
+
+#ifdef CONFIG_PCI
+        for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
+                add_bridge(np);
+
+        ppc_md.pcibios_fixup = mpc85xx_cds_pcibios_fixup;
+        ppc_md.pci_swizzle = common_swizzle;
+        ppc_md.pci_map_irq = mpc85xx_map_irq;
+        ppc_md.pci_exclude_device = mpc85xx_exclude_device;
+#endif
+
+#ifdef  CONFIG_ROOT_NFS
+        ROOT_DEV = Root_NFS;
+#else
+        ROOT_DEV = Root_HDA1;
+#endif
+}
+
+
+void
+mpc85xx_cds_show_cpuinfo(struct seq_file *m)
+{
+        uint pvid, svid, phid1;
+        uint memsize = total_memory;
+
+        pvid = mfspr(SPRN_PVR);
+        svid = mfspr(SPRN_SVR);
+
+        seq_printf(m, "Vendor\t\t: Freescale Semiconductor\n");
+        seq_printf(m, "Machine\t\t: MPC85xx CDS (0x%x)\n", cadmus[CM_VER]);
+        seq_printf(m, "PVR\t\t: 0x%x\n", pvid);
+        seq_printf(m, "SVR\t\t: 0x%x\n", svid);
+
+        /* Display cpu Pll setting */
+        phid1 = mfspr(SPRN_HID1);
+        seq_printf(m, "PLL setting\t: 0x%x\n", ((phid1 >> 24) & 0x3f));
+
+        /* Display the amount of memory */
+        seq_printf(m, "Memory\t\t: %d MB\n", memsize / (1024 * 1024));
+}
+
+
+/*
+ * Called very early, device-tree isn't unflattened
+ */
+static int __init mpc85xx_cds_probe(void)
+{
+        /* We always match for now, eventually we should look at
+         * the flat dev tree to ensure this is the board we are
+         * supposed to run on
+         */
+        return 1;
+}
+
+define_machine(mpc85xx_cds) {
+        .name           = "MPC85xx CDS",
+        .probe          = mpc85xx_cds_probe,
+        .setup_arch     = mpc85xx_cds_setup_arch,
+        .init_IRQ       = mpc85xx_cds_pic_init,
+        .show_cpuinfo   = mpc85xx_cds_show_cpuinfo,
+        .get_irq        = mpic_get_irq,
+        .restart        = mpc85xx_restart,
+        .calibrate_decr = generic_calibrate_decr,
+        .progress       = udbg_progress,
+};
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_cds.h b/arch/powerpc/platforms/85xx/mpc85xx_cds.h
new file mode 100644
index 000000000000..671f54ff185a
--- /dev/null
+++ b/arch/powerpc/platforms/85xx/mpc85xx_cds.h
@@ -0,0 +1,43 @@
+/*
+ * arch/ppc/platforms/85xx/mpc85xx_cds_common.h
+ *
+ * MPC85xx CDS board definitions
+ *
+ * Maintainer: Kumar Gala <galak@kernel.crashing.org>
+ *
+ * Copyright 2004 Freescale Semiconductor, Inc
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#ifndef __MACH_MPC85XX_CDS_H__
+#define __MACH_MPC85XX_CDS_H__
+
+/* CADMUS info */
+#define CADMUS_BASE (0xf8004000)
+#define CADMUS_SIZE (256)
+#define CM_VER  (0)
+#define CM_CSR  (1)
+#define CM_RST  (2)
+
+/* CDS NVRAM/RTC */
+#define CDS_RTC_ADDR    (0xf8000000)
+#define CDS_RTC_SIZE    (8 * 1024)
+
+/* PCI interrupt controller */
+#define PIRQ0A                  MPC85xx_IRQ_EXT0
+#define PIRQ0B                  MPC85xx_IRQ_EXT1
+#define PIRQ0C                  MPC85xx_IRQ_EXT2
+#define PIRQ0D                  MPC85xx_IRQ_EXT3
+#define PIRQ1A                  MPC85xx_IRQ_EXT11
+
+#define NR_8259_INTS            16
+#define CPM_IRQ_OFFSET          NR_8259_INTS
+
+#define MPC85xx_OPENPIC_IRQ_OFFSET      80
+
+#endif /* __MACH_MPC85XX_CDS_H__ */
diff --git a/arch/powerpc/platforms/cell/spufs/context.c b/arch/powerpc/platforms/cell/spufs/context.c
index 8bb33abfad17..36439c5e9f2d 100644
--- a/arch/powerpc/platforms/cell/spufs/context.c
+++ b/arch/powerpc/platforms/cell/spufs/context.c
@@ -30,7 +30,7 @@
 struct spu_context *alloc_spu_context(void)
 {
         struct spu_context *ctx;
-        ctx = kmalloc(sizeof *ctx, GFP_KERNEL);
+        ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
         if (!ctx)
                 goto out;
         /* Binding to physical processor deferred
@@ -48,17 +48,7 @@ struct spu_context *alloc_spu_context(void)
         init_waitqueue_head(&ctx->wbox_wq);
         init_waitqueue_head(&ctx->stop_wq);
         init_waitqueue_head(&ctx->mfc_wq);
-        ctx->ibox_fasync = NULL;
-        ctx->wbox_fasync = NULL;
-        ctx->mfc_fasync = NULL;
-        ctx->mfc = NULL;
-        ctx->tagwait = 0;
         ctx->state = SPU_STATE_SAVED;
-        ctx->local_store = NULL;
-        ctx->cntl = NULL;
-        ctx->signal1 = NULL;
-        ctx->signal2 = NULL;
-        ctx->spu = NULL;
         ctx->ops = &spu_backing_ops;
         ctx->owner = get_task_mm(current);
         goto out;
diff --git a/arch/powerpc/platforms/iseries/Makefile b/arch/powerpc/platforms/iseries/Makefile
index ce8c0b943fa0..dee4eb4d8bec 100644
--- a/arch/powerpc/platforms/iseries/Makefile
+++ b/arch/powerpc/platforms/iseries/Makefile
@@ -1,9 +1,11 @@
 EXTRA_CFLAGS    += -mno-minimal-toc
 
-obj-y += hvlog.o hvlpconfig.o lpardata.o setup.o mf.o lpevents.o \
+obj-y += hvlog.o hvlpconfig.o lpardata.o setup.o dt_mod.o mf.o lpevents.o \
         hvcall.o proc.o htab.o iommu.o misc.o irq.o
 obj-$(CONFIG_PCI) += pci.o vpdinfo.o
-obj-$(CONFIG_IBMVIO) += vio.o
 obj-$(CONFIG_SMP) += smp.o
 obj-$(CONFIG_VIOPATH) += viopath.o
 obj-$(CONFIG_MODULES) += ksyms.o
+
+$(obj)/dt_mod.o:        $(obj)/dt.o
+        @$(OBJCOPY) --rename-section .rodata.str1.8=.dt_strings $(obj)/dt.o $(obj)/dt_mod.o
diff --git a/arch/powerpc/platforms/iseries/call_pci.h b/arch/powerpc/platforms/iseries/call_pci.h
index 59d4e0ad5cf3..dbdf69850ed9 100644
--- a/arch/powerpc/platforms/iseries/call_pci.h
+++ b/arch/powerpc/platforms/iseries/call_pci.h
@@ -145,6 +145,25 @@ static inline u64 HvCallPci_configLoad16(u16 busNumber, u8 subBusNumber,
         return retVal.rc;
 }
 
+static inline u64 HvCallPci_configLoad32(u16 busNumber, u8 subBusNumber,
+                u8 deviceId, u32 offset, u32 *value)
+{
+        struct HvCallPci_DsaAddr dsa;
+        struct HvCallPci_LoadReturn retVal;
+
+        *((u64*)&dsa) = 0;
+
+        dsa.busNumber = busNumber;
+        dsa.subBusNumber = subBusNumber;
+        dsa.deviceId = deviceId;
+
+        HvCall3Ret16(HvCallPciConfigLoad32, &retVal, *(u64 *)&dsa, offset, 0);
+
+        *value = retVal.value;
+
+        return retVal.rc;
+}
+
 static inline u64 HvCallPci_configStore8(u16 busNumber, u8 subBusNumber,
                 u8 deviceId, u32 offset, u8 value)
 {
diff --git a/arch/powerpc/platforms/iseries/dt.c b/arch/powerpc/platforms/iseries/dt.c
new file mode 100644
index 000000000000..d3444aabe76e
--- /dev/null
+++ b/arch/powerpc/platforms/iseries/dt.c
@@ -0,0 +1,615 @@
+/*
+ *    Copyright (c) 2005-2006 Michael Ellerman, IBM Corporation
+ *
+ *    Description:
+ *      This file contains all the routines to build a flattened device
+ *      tree for a legacy iSeries machine.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#undef DEBUG
+
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/pci_regs.h>
+#include <linux/pci_ids.h>
+#include <linux/threads.h>
+#include <linux/bitops.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/if_ether.h>     /* ETH_ALEN */
+
+#include <asm/machdep.h>
+#include <asm/prom.h>
+#include <asm/lppaca.h>
+#include <asm/cputable.h>
+#include <asm/abs_addr.h>
+#include <asm/system.h>
+#include <asm/iseries/hv_types.h>
+#include <asm/iseries/hv_lp_config.h>
+#include <asm/iseries/hv_call_xm.h>
+#include <asm/iseries/it_exp_vpd_panel.h>
+#include <asm/udbg.h>
+
+#include "processor_vpd.h"
+#include "call_hpt.h"
+#include "call_pci.h"
+#include "pci.h"
+
+#ifdef DEBUG
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...)
+#endif
+
+/*
+ * These are created by the linker script at the start and end
+ * of the section containing all the strings from this file.
+ */
+extern char __dt_strings_start[];
+extern char __dt_strings_end[];
+
+struct iseries_flat_dt {
+        struct boot_param_header header;
+        u64 reserve_map[2];
+};
+
+static void * __initdata dt_data;
+
+/*
+ * Putting these strings here keeps them out of the section
+ * that we rename to .dt_strings using objcopy and capture
+ * for the strings blob of the flattened device tree.
+ */
+static char __initdata device_type_cpu[] = "cpu";
+static char __initdata device_type_memory[] = "memory";
+static char __initdata device_type_serial[] = "serial";
+static char __initdata device_type_network[] = "network";
+static char __initdata device_type_block[] = "block";
+static char __initdata device_type_byte[] = "byte";
+static char __initdata device_type_pci[] = "pci";
+static char __initdata device_type_vdevice[] = "vdevice";
+static char __initdata device_type_vscsi[] = "vscsi";
+
+static struct iseries_flat_dt * __init dt_init(void)
+{
+        struct iseries_flat_dt *dt;
+        unsigned long str_len;
+
+        str_len = __dt_strings_end - __dt_strings_start;
+        dt = (struct iseries_flat_dt *)ALIGN(klimit, 8);
+        dt->header.off_mem_rsvmap =
+                offsetof(struct iseries_flat_dt, reserve_map);
+        dt->header.off_dt_strings = ALIGN(sizeof(*dt), 8);
+        dt->header.off_dt_struct = dt->header.off_dt_strings
+                + ALIGN(str_len, 8);
+        dt_data = (void *)((unsigned long)dt + dt->header.off_dt_struct);
+        dt->header.dt_strings_size = str_len;
+
+        /* There is no notion of hardware cpu id on iSeries */
+        dt->header.boot_cpuid_phys = smp_processor_id();
+
+        memcpy((char *)dt + dt->header.off_dt_strings, __dt_strings_start,
+                        str_len);
+
+        dt->header.magic = OF_DT_HEADER;
+        dt->header.version = 0x10;
+        dt->header.last_comp_version = 0x10;
+
+        dt->reserve_map[0] = 0;
+        dt->reserve_map[1] = 0;
+
+        return dt;
+}
+
+static void __init dt_push_u32(struct iseries_flat_dt *dt, u32 value)
+{
+        *((u32 *)dt_data) = value;
+        dt_data += sizeof(u32);
+}
+
+#ifdef notyet
+static void __init dt_push_u64(struct iseries_flat_dt *dt, u64 value)
+{
+        *((u64 *)dt_data) = value;
+        dt_data += sizeof(u64);
+}
+#endif
+
+static void __init dt_push_bytes(struct iseries_flat_dt *dt, const char *data,
+                int len)
+{
+        memcpy(dt_data, data, len);
+        dt_data += ALIGN(len, 4);
+}
+
+static void __init dt_start_node(struct iseries_flat_dt *dt, const char *name)
+{
+        dt_push_u32(dt, OF_DT_BEGIN_NODE);
+        dt_push_bytes(dt, name, strlen(name) + 1);
+}
+
+#define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
+
+static void __init dt_prop(struct iseries_flat_dt *dt, const char *name,
+                const void *data, int len)
+{
+        unsigned long offset;
+
+        dt_push_u32(dt, OF_DT_PROP);
+
+        /* Length of the data */
+        dt_push_u32(dt, len);
+
+        offset = name - __dt_strings_start;
+
+        /* The offset of the properties name in the string blob. */
+        dt_push_u32(dt, (u32)offset);
+
+        /* The actual data. */
+        dt_push_bytes(dt, data, len);
+}
+
+static void __init dt_prop_str(struct iseries_flat_dt *dt, const char *name,
+                const char *data)
+{
+        dt_prop(dt, name, data, strlen(data) + 1); /* + 1 for NULL */
+}
+
+static void __init dt_prop_u32(struct iseries_flat_dt *dt, const char *name,
+                u32 data)
+{
+        dt_prop(dt, name, &data, sizeof(u32));
+}
+
+#ifdef notyet
+static void __init dt_prop_u64(struct iseries_flat_dt *dt, const char *name,
+                u64 data)
+{
+        dt_prop(dt, name, &data, sizeof(u64));
+}
+#endif
+
+static void __init dt_prop_u64_list(struct iseries_flat_dt *dt,
+                const char *name, u64 *data, int n)
+{
+        dt_prop(dt, name, data, sizeof(u64) * n);
+}
+
+static void __init dt_prop_u32_list(struct iseries_flat_dt *dt,
+                const char *name, u32 *data, int n)
+{
+        dt_prop(dt, name, data, sizeof(u32) * n);
+}
+
+#ifdef notyet
+static void __init dt_prop_empty(struct iseries_flat_dt *dt, const char *name)
+{
+        dt_prop(dt, name, NULL, 0);
+}
+#endif
+
+static void __init dt_cpus(struct iseries_flat_dt *dt)
+{
+        unsigned char buf[32];
+        unsigned char *p;
+        unsigned int i, index;
+        struct IoHriProcessorVpd *d;
+        u32 pft_size[2];
+
+        /* yuck */
+        snprintf(buf, 32, "PowerPC,%s", cur_cpu_spec->cpu_name);
+        p = strchr(buf, ' ');
+        if (!p) p = buf + strlen(buf);
+
+        dt_start_node(dt, "cpus");
+        dt_prop_u32(dt, "#address-cells", 1);
+        dt_prop_u32(dt, "#size-cells", 0);
+
+        pft_size[0] = 0; /* NUMA CEC cookie, 0 for non NUMA  */
+        pft_size[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE);
+
+        for (i = 0; i < NR_CPUS; i++) {
+                if (lppaca[i].dyn_proc_status >= 2)
+                        continue;
+
+                snprintf(p, 32 - (p - buf), "@%d", i);
+                dt_start_node(dt, buf);
+
+                dt_prop_str(dt, "device_type", device_type_cpu);
+
+                index = lppaca[i].dyn_hv_phys_proc_index;
+                d = &xIoHriProcessorVpd[index];
+
+                dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
+                dt_prop_u32(dt, "i-cache-line-size", d->xInstCacheOperandSize);
+
+                dt_prop_u32(dt, "d-cache-size", d->xDataL1CacheSizeKB * 1024);
+                dt_prop_u32(dt, "d-cache-line-size", d->xDataCacheOperandSize);
+
+                /* magic conversions to Hz copied from old code */
+                dt_prop_u32(dt, "clock-frequency",
+                        ((1UL << 34) * 1000000) / d->xProcFreq);
+                dt_prop_u32(dt, "timebase-frequency",
+                        ((1UL << 32) * 1000000) / d->xTimeBaseFreq);
+
+                dt_prop_u32(dt, "reg", i);
+
+                dt_prop_u32_list(dt, "ibm,pft-size", pft_size, 2);
+
+                dt_end_node(dt);
+        }
+
+        dt_end_node(dt);
+}
+
+static void __init dt_model(struct iseries_flat_dt *dt)
+{
+        char buf[16] = "IBM,";
+
+        /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
+        strne2a(buf + 4, xItExtVpdPanel.mfgID + 2, 2);
+        strne2a(buf + 6, xItExtVpdPanel.systemSerial + 1, 5);
+        buf[11] = '\0';
+        dt_prop_str(dt, "system-id", buf);
+
+        /* "IBM," + machineType[0:4] */
+        strne2a(buf + 4, xItExtVpdPanel.machineType, 4);
+        buf[8] = '\0';
+        dt_prop_str(dt, "model", buf);
+
+        dt_prop_str(dt, "compatible", "IBM,iSeries");
+}
+
+static void __init dt_do_vdevice(struct iseries_flat_dt *dt,
+                const char *name, u32 reg, int unit,
+                const char *type, const char *compat, int end)
+{
+        char buf[32];
+
+        snprintf(buf, 32, "%s@%08x", name, reg + ((unit >= 0) ? unit : 0));
+        dt_start_node(dt, buf);
+        dt_prop_str(dt, "device_type", type);
+        if (compat)
+                dt_prop_str(dt, "compatible", compat);
+        dt_prop_u32(dt, "reg", reg + ((unit >= 0) ? unit : 0));
+        if (unit >= 0)
+                dt_prop_u32(dt, "linux,unit_address", unit);
+        if (end)
+                dt_end_node(dt);
+}
+
+static void __init dt_vdevices(struct iseries_flat_dt *dt)
+{
+        u32 reg = 0;
+        HvLpIndexMap vlan_map;
+        int i;
+
+        dt_start_node(dt, "vdevice");
+        dt_prop_str(dt, "device_type", device_type_vdevice);
+        dt_prop_str(dt, "compatible", "IBM,iSeries-vdevice");
+        dt_prop_u32(dt, "#address-cells", 1);
+        dt_prop_u32(dt, "#size-cells", 0);
+
+        dt_do_vdevice(dt, "vty", reg, -1, device_type_serial, NULL, 1);
+        reg++;
+
+        dt_do_vdevice(dt, "v-scsi", reg, -1, device_type_vscsi,
+                        "IBM,v-scsi", 1);
+        reg++;
+
+        vlan_map = HvLpConfig_getVirtualLanIndexMap();
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALLANS; i++) {
+                unsigned char mac_addr[ETH_ALEN];
+
+                if ((vlan_map & (0x8000 >> i)) == 0)
+                        continue;
+                dt_do_vdevice(dt, "l-lan", reg, i, device_type_network,
+                                "IBM,iSeries-l-lan", 0);
+                mac_addr[0] = 0x02;
+                mac_addr[1] = 0x01;
+                mac_addr[2] = 0xff;
+                mac_addr[3] = i;
+                mac_addr[4] = 0xff;
+                mac_addr[5] = HvLpConfig_getLpIndex_outline();
+                dt_prop(dt, "local-mac-address", (char *)mac_addr, ETH_ALEN);
+                dt_prop(dt, "mac-address", (char *)mac_addr, ETH_ALEN);
+                dt_prop_u32(dt, "max-frame-size", 9000);
+                dt_prop_u32(dt, "address-bits", 48);
+
+                dt_end_node(dt);
+        }
+        reg += HVMAXARCHITECTEDVIRTUALLANS;
+
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALDISKS; i++)
+                dt_do_vdevice(dt, "viodasd", reg, i, device_type_block,
+                                "IBM,iSeries-viodasd", 1);
+        reg += HVMAXARCHITECTEDVIRTUALDISKS;
+
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALCDROMS; i++)
+                dt_do_vdevice(dt, "viocd", reg, i, device_type_block,
+                                "IBM,iSeries-viocd", 1);
+        reg += HVMAXARCHITECTEDVIRTUALCDROMS;
+
+        for (i = 0; i < HVMAXARCHITECTEDVIRTUALTAPES; i++)
+                dt_do_vdevice(dt, "viotape", reg, i, device_type_byte,
+                                "IBM,iSeries-viotape", 1);
+
+        dt_end_node(dt);
+}
+
+struct pci_class_name {
+        u16 code;
+        const char *name;
+        const char *type;
+};
+
+static struct pci_class_name __initdata pci_class_name[] = {
+        { PCI_CLASS_NETWORK_ETHERNET, "ethernet", device_type_network },
+};
+
+static struct pci_class_name * __init dt_find_pci_class_name(u16 class_code)
+{
+        struct pci_class_name *cp;
+
+        for (cp = pci_class_name;
+                        cp < &pci_class_name[ARRAY_SIZE(pci_class_name)]; cp++)
+                if (cp->code == class_code)
+                        return cp;
+        return NULL;
+}
+
+/*
+ * This assumes that the node slot is always on the primary bus!
+ */
+static void __init scan_bridge_slot(struct iseries_flat_dt *dt,
+                HvBusNumber bus, struct HvCallPci_BridgeInfo *bridge_info)
+{
+        HvSubBusNumber sub_bus = bridge_info->subBusNumber;
+        u16 vendor_id;
+        u16 device_id;
+        u32 class_id;
+        int err;
+        char buf[32];
+        u32 reg[5];
+        int id_sel = ISERIES_GET_DEVICE_FROM_SUBBUS(sub_bus);
+        int function = ISERIES_GET_FUNCTION_FROM_SUBBUS(sub_bus);
+        HvAgentId eads_id_sel = ISERIES_PCI_AGENTID(id_sel, function);
+        u8 devfn;
+        struct pci_class_name *cp;
+
+        /*
+         * Connect all functions of any device found.
+         */
+        for (id_sel = 1; id_sel <= bridge_info->maxAgents; id_sel++) {
+                for (function = 0; function < 8; function++) {
+                        HvAgentId agent_id = ISERIES_PCI_AGENTID(id_sel,
+                                        function);
+                        err = HvCallXm_connectBusUnit(bus, sub_bus,
+                                        agent_id, 0);
+                        if (err) {
+                                if (err != 0x302)
+                                        DBG("connectBusUnit(%x, %x, %x) %x\n",
+                                                bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+
+                        err = HvCallPci_configLoad16(bus, sub_bus, agent_id,
+                                        PCI_VENDOR_ID, &vendor_id);
+                        if (err) {
+                                DBG("ReadVendor(%x, %x, %x) %x\n",
+                                        bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+                        err = HvCallPci_configLoad16(bus, sub_bus, agent_id,
+                                        PCI_DEVICE_ID, &device_id);
+                        if (err) {
+                                DBG("ReadDevice(%x, %x, %x) %x\n",
+                                        bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+                        err = HvCallPci_configLoad32(bus, sub_bus, agent_id,
+                                        PCI_CLASS_REVISION , &class_id);
+                        if (err) {
+                                DBG("ReadClass(%x, %x, %x) %x\n",
+                                        bus, sub_bus, agent_id, err);
+                                continue;
+                        }
+
+                        devfn = PCI_DEVFN(ISERIES_ENCODE_DEVICE(eads_id_sel),
+                                        function);
+                        cp = dt_find_pci_class_name(class_id >> 16);
+                        if (cp && cp->name)
+                                strncpy(buf, cp->name, sizeof(buf) - 1);
+                        else
+                                snprintf(buf, sizeof(buf), "pci%x,%x",
+                                                vendor_id, device_id);
+                        buf[sizeof(buf) - 1] = '\0';
+                        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
+                                        "@%x", PCI_SLOT(devfn));
+                        buf[sizeof(buf) - 1] = '\0';
+                        if (function != 0)
+                                snprintf(buf + strlen(buf),
+                                        sizeof(buf) - strlen(buf),
+                                        ",%x", function);
+                        dt_start_node(dt, buf);
+                        reg[0] = (bus << 16) | (devfn << 8);
+                        reg[1] = 0;
+                        reg[2] = 0;
+                        reg[3] = 0;
+                        reg[4] = 0;
+                        dt_prop_u32_list(dt, "reg", reg, 5);
+                        if (cp && (cp->type || cp->name))
+                                dt_prop_str(dt, "device_type",
+                                        cp->type ? cp->type : cp->name);
+                        dt_prop_u32(dt, "vendor-id", vendor_id);
+                        dt_prop_u32(dt, "device-id", device_id);
+                        dt_prop_u32(dt, "class-code", class_id >> 8);
+                        dt_prop_u32(dt, "revision-id", class_id & 0xff);
+                        dt_prop_u32(dt, "linux,subbus", sub_bus);
+                        dt_prop_u32(dt, "linux,agent-id", agent_id);
+                        dt_prop_u32(dt, "linux,logical-slot-number",
+                                        bridge_info->logicalSlotNumber);
+                        dt_end_node(dt);
+
+                }
+        }
+}
+
+static void __init scan_bridge(struct iseries_flat_dt *dt, HvBusNumber bus,
+                HvSubBusNumber sub_bus, int id_sel)
+{
+        struct HvCallPci_BridgeInfo bridge_info;
+        HvAgentId agent_id;
+        int function;
+        int ret;
+
+        /* Note: hvSubBus and irq is always be 0 at this level! */
+        for (function = 0; function < 8; ++function) {
+                agent_id = ISERIES_PCI_AGENTID(id_sel, function);
+                ret = HvCallXm_connectBusUnit(bus, sub_bus, agent_id, 0);
+                if (ret != 0) {
+                        if (ret != 0xb)
+                                DBG("connectBusUnit(%x, %x, %x) %x\n",
+                                                bus, sub_bus, agent_id, ret);
+                        continue;
+                }
+                DBG("found device at bus %d idsel %d func %d (AgentId %x)\n",
+                                bus, id_sel, function, agent_id);
+                ret = HvCallPci_getBusUnitInfo(bus, sub_bus, agent_id,
+                                iseries_hv_addr(&bridge_info),
+                                sizeof(struct HvCallPci_BridgeInfo));
+                if (ret != 0)
+                        continue;
+                DBG("bridge info: type %x subbus %x "
+                        "maxAgents %x maxsubbus %x logslot %x\n",
+                        bridge_info.busUnitInfo.deviceType,
+                        bridge_info.subBusNumber,
+                        bridge_info.maxAgents,
+                        bridge_info.maxSubBusNumber,
+                        bridge_info.logicalSlotNumber);
+                if (bridge_info.busUnitInfo.deviceType ==
+                                HvCallPci_BridgeDevice)
+                        scan_bridge_slot(dt, bus, &bridge_info);
+                else
+                        DBG("PCI: Invalid Bridge Configuration(0x%02X)",
+                                bridge_info.busUnitInfo.deviceType);
+        }
+}
+
+static void __init scan_phb(struct iseries_flat_dt *dt, HvBusNumber bus)
+{
+        struct HvCallPci_DeviceInfo dev_info;
+        const HvSubBusNumber sub_bus = 0;       /* EADs is always 0. */
+        int err;
+        int id_sel;
+        const int max_agents = 8;
+
+        /*
+         * Probe for EADs Bridges
+         */
+        for (id_sel = 1; id_sel < max_agents; ++id_sel) {
+                err = HvCallPci_getDeviceInfo(bus, sub_bus, id_sel,
+                                iseries_hv_addr(&dev_info),
+                                sizeof(struct HvCallPci_DeviceInfo));
+                if (err) {
+                        if (err != 0x302)
+                                DBG("getDeviceInfo(%x, %x, %x) %x\n",
+                                                bus, sub_bus, id_sel, err);
+                        continue;
+                }
+                if (dev_info.deviceType != HvCallPci_NodeDevice) {
+                        DBG("PCI: Invalid System Configuration"
+                                        "(0x%02X) for bus 0x%02x id 0x%02x.\n",
+                                        dev_info.deviceType, bus, id_sel);
+                        continue;
+                }
+                scan_bridge(dt, bus, sub_bus, id_sel);
+        }
+}
+
+static void __init dt_pci_devices(struct iseries_flat_dt *dt)
+{
+        HvBusNumber bus;
+        char buf[32];
+        u32 buses[2];
+        int phb_num = 0;
+
+        /* Check all possible buses. */
+        for (bus = 0; bus < 256; bus++) {
+                int err = HvCallXm_testBus(bus);
+
+                if (err) {
+                        /*
+                         * Check for Unexpected Return code, a clue that
+                         * something has gone wrong.
+                         */
+                        if (err != 0x0301)
+                                DBG("Unexpected Return on Probe(0x%02X) "
+                                                "0x%04X\n", bus, err);
+                        continue;
+                }
+                DBG("bus %d appears to exist\n", bus);
+                snprintf(buf, 32, "pci@%d", phb_num);
+                dt_start_node(dt, buf);
+                dt_prop_str(dt, "device_type", device_type_pci);
+                dt_prop_str(dt, "compatible", "IBM,iSeries-Logical-PHB");
+                dt_prop_u32(dt, "#address-cells", 3);
+                dt_prop_u32(dt, "#size-cells", 2);
+                buses[0] = buses[1] = bus;
+                dt_prop_u32_list(dt, "bus-range", buses, 2);
+                scan_phb(dt, bus);
+                dt_end_node(dt);
+                phb_num++;
+        }
+}
+
+static void dt_finish(struct iseries_flat_dt *dt)
+{
+        dt_push_u32(dt, OF_DT_END);
+        dt->header.totalsize = (unsigned long)dt_data - (unsigned long)dt;
+        klimit = ALIGN((unsigned long)dt_data, 8);
+}
+
+void * __init build_flat_dt(unsigned long phys_mem_size)
+{
+        struct iseries_flat_dt *iseries_dt;
+        u64 tmp[2];
+
+        iseries_dt = dt_init();
+
+        dt_start_node(iseries_dt, "");
+
+        dt_prop_u32(iseries_dt, "#address-cells", 2);
+        dt_prop_u32(iseries_dt, "#size-cells", 2);
+        dt_model(iseries_dt);
+
+        /* /memory */
+        dt_start_node(iseries_dt, "memory@0");
+        dt_prop_str(iseries_dt, "device_type", device_type_memory);
+        tmp[0] = 0;
+        tmp[1] = phys_mem_size;
+        dt_prop_u64_list(iseries_dt, "reg", tmp, 2);
+        dt_end_node(iseries_dt);
+
+        /* /chosen */
+        dt_start_node(iseries_dt, "chosen");
+        dt_prop_str(iseries_dt, "bootargs", cmd_line);
+        dt_end_node(iseries_dt);
+
+        dt_cpus(iseries_dt);
+
+        dt_vdevices(iseries_dt);
+        dt_pci_devices(iseries_dt);
+
+        dt_end_node(iseries_dt);
+
+        dt_finish(iseries_dt);
+
+        return iseries_dt;
+}
diff --git a/arch/powerpc/platforms/iseries/iommu.c b/arch/powerpc/platforms/iseries/iommu.c
index bea0b703f409..a992f6af249f 100644
--- a/arch/powerpc/platforms/iseries/iommu.c
+++ b/arch/powerpc/platforms/iseries/iommu.c
@@ -4,6 +4,7 @@
  * Rewrite, cleanup:
  *
  * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
+ * Copyright (C) 2006 Olof Johansson <olof@lixom.net>
  *
  * Dynamic DMA mapping support, iSeries-specific parts.
  *
@@ -31,42 +32,37 @@
 #include <asm/tce.h>
 #include <asm/machdep.h>
 #include <asm/abs_addr.h>
+#include <asm/prom.h>
 #include <asm/pci-bridge.h>
 #include <asm/iseries/hv_call_xm.h>
-
-#include "iommu.h"
-
-extern struct list_head iSeries_Global_Device_List;
-
+#include <asm/iseries/iommu.h>
 
 static void tce_build_iSeries(struct iommu_table *tbl, long index, long npages,
                 unsigned long uaddr, enum dma_data_direction direction)
 {
         u64 rc;
-        union tce_entry tce;
+        u64 tce, rpn;
 
         index <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
         while (npages--) {
-                tce.te_word = 0;
-                tce.te_bits.tb_rpn = virt_to_abs(uaddr) >> TCE_SHIFT;
+                rpn = virt_to_abs(uaddr) >> TCE_SHIFT;
+                tce = (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
 
                 if (tbl->it_type == TCE_VB) {
                         /* Virtual Bus */
-                        tce.te_bits.tb_valid = 1;
-                        tce.te_bits.tb_allio = 1;
+                        tce |= TCE_VALID|TCE_ALLIO;
                         if (direction != DMA_TO_DEVICE)
-                                tce.te_bits.tb_rdwr = 1;
+                                tce |= TCE_VB_WRITE;
                 } else {
                         /* PCI Bus */
-                        tce.te_bits.tb_rdwr = 1; /* Read allowed */
+                        tce |= TCE_PCI_READ; /* Read allowed */
                         if (direction != DMA_TO_DEVICE)
-                                tce.te_bits.tb_pciwr = 1;
+                                tce |= TCE_PCI_WRITE;
                 }
 
-                rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index,
-                                tce.te_word);
+                rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, tce);
                 if (rc)
                         panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n",
                                         rc);
@@ -124,7 +120,7 @@ void iommu_table_getparms_iSeries(unsigned long busno,
 
         /* itc_size is in pages worth of table, it_size is in # of entries */
         tbl->it_size = ((parms->itc_size * TCE_PAGE_SIZE) /
-                        sizeof(union tce_entry)) >> TCE_PAGE_FACTOR;
+                        TCE_ENTRY_SIZE) >> TCE_PAGE_FACTOR;
         tbl->it_busno = parms->itc_busno;
         tbl->it_offset = parms->itc_offset >> TCE_PAGE_FACTOR;
         tbl->it_index = parms->itc_index;
@@ -142,10 +138,15 @@ void iommu_table_getparms_iSeries(unsigned long busno,
  */
 static struct iommu_table *iommu_table_find(struct iommu_table * tbl)
 {
-        struct pci_dn *pdn;
+        struct device_node *node;
 
-        list_for_each_entry(pdn, &iSeries_Global_Device_List, Device_List) {
-                struct iommu_table *it = pdn->iommu_table;
+        for (node = NULL; (node = of_find_all_nodes(node)); ) {
+                struct pci_dn *pdn = PCI_DN(node);
+                struct iommu_table *it;
+
+                if (pdn == NULL)
+                        continue;
+                it = pdn->iommu_table;
                 if ((it != NULL) &&
                     (it->it_type == TCE_PCI) &&
                     (it->it_offset == tbl->it_offset) &&
@@ -161,10 +162,13 @@ void iommu_devnode_init_iSeries(struct device_node *dn)
 {
         struct iommu_table *tbl;
         struct pci_dn *pdn = PCI_DN(dn);
+        u32 *lsn = (u32 *)get_property(dn, "linux,logical-slot-number", NULL);
+
+        BUG_ON(lsn == NULL);
 
         tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
 
-        iommu_table_getparms_iSeries(pdn->busno, pdn->LogicalSlot, 0, tbl);
+        iommu_table_getparms_iSeries(pdn->busno, *lsn, 0, tbl);
 
         /* Look for existing tce table */
         pdn->iommu_table = iommu_table_find(tbl);
diff --git a/arch/powerpc/platforms/iseries/iommu.h b/arch/powerpc/platforms/iseries/iommu.h
deleted file mode 100644
index cb5658fbe657..000000000000
--- a/arch/powerpc/platforms/iseries/iommu.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef _PLATFORMS_ISERIES_IOMMU_H
-#define _PLATFORMS_ISERIES_IOMMU_H
-
-/*
- * Copyright (C) 2005  Stephen Rothwell, IBM Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the:
- * Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330,
- * Boston, MA  02111-1307  USA
- */
-
-struct device_node;
-struct iommu_table;
-
-/* Creates table for an individual device node */
-extern void iommu_devnode_init_iSeries(struct device_node *dn);
-
-/* Get table parameters from HV */
-extern void iommu_table_getparms_iSeries(unsigned long busno,
-                unsigned char slotno, unsigned char virtbus,
-                struct iommu_table *tbl);
-
-#endif /* _PLATFORMS_ISERIES_IOMMU_H */
diff --git a/arch/powerpc/platforms/iseries/irq.c b/arch/powerpc/platforms/iseries/irq.c
index be3fbfc24e6c..62bbbcf5ded3 100644
--- a/arch/powerpc/platforms/iseries/irq.c
+++ b/arch/powerpc/platforms/iseries/irq.c
@@ -42,6 +42,7 @@
 #include <asm/iseries/it_lp_queue.h>
 
 #include "irq.h"
+#include "pci.h"
 #include "call_pci.h"
 
 #if defined(CONFIG_SMP)
@@ -312,12 +313,12 @@ static hw_irq_controller iSeries_IRQ_handler = {
  * Note that sub_bus is always 0 (at the moment at least).
  */
 int __init iSeries_allocate_IRQ(HvBusNumber bus,
-                HvSubBusNumber sub_bus, HvAgentId dev_id)
+                HvSubBusNumber sub_bus, u32 bsubbus)
 {
         int virtirq;
         unsigned int realirq;
-        u8 idsel = (dev_id >> 4);
-        u8 function = dev_id & 7;
+        u8 idsel = ISERIES_GET_DEVICE_FROM_SUBBUS(bsubbus);
+        u8 function = ISERIES_GET_FUNCTION_FROM_SUBBUS(bsubbus);
 
         realirq = (((((sub_bus << 8) + (bus - 1)) << 3) + (idsel - 1)) << 3)
                 + function;
diff --git a/arch/powerpc/platforms/iseries/irq.h b/arch/powerpc/platforms/iseries/irq.h
index b9c801ba5a47..188aa808abd7 100644
--- a/arch/powerpc/platforms/iseries/irq.h
+++ b/arch/powerpc/platforms/iseries/irq.h
@@ -2,7 +2,7 @@
 #define _ISERIES_IRQ_H
 
 extern void iSeries_init_IRQ(void);
-extern int  iSeries_allocate_IRQ(HvBusNumber, HvSubBusNumber, HvAgentId);
+extern int  iSeries_allocate_IRQ(HvBusNumber, HvSubBusNumber, u32);
 extern void iSeries_activate_IRQs(void);
 extern int iSeries_get_irq(struct pt_regs *);
 
diff --git a/arch/powerpc/platforms/iseries/mf.c b/arch/powerpc/platforms/iseries/mf.c
index d771b8ee857d..1a2c2a50f922 100644
--- a/arch/powerpc/platforms/iseries/mf.c
+++ b/arch/powerpc/platforms/iseries/mf.c
@@ -45,7 +45,6 @@
 
 #include "setup.h"
 
-extern int piranha_simulator;
 static int mf_initialized;
 
 /*
@@ -658,7 +657,7 @@ static void mf_clear_src(void)
 
 void __init mf_display_progress(u16 value)
 {
-        if (piranha_simulator || !mf_initialized)
+        if (!mf_initialized)
                 return;
 
         if (0xFFFF == value)
@@ -1295,9 +1294,6 @@ __initcall(mf_proc_init);
  */
 void iSeries_get_rtc_time(struct rtc_time *rtc_tm)
 {
-        if (piranha_simulator)
-                return;
-
         mf_get_rtc(rtc_tm);
         rtc_tm->tm_mon--;
 }
@@ -1316,9 +1312,6 @@ unsigned long iSeries_get_boot_time(void)
 {
         struct rtc_time tm;
 
-        if (piranha_simulator)
-                return 0;
-
         mf_get_boot_rtc(&tm);
         return mktime(tm.tm_year + 1900, tm.tm_mon, tm.tm_mday,
                       tm.tm_hour, tm.tm_min, tm.tm_sec);
diff --git a/arch/powerpc/platforms/iseries/pci.c b/arch/powerpc/platforms/iseries/pci.c
index a19833b880e4..35bcc98111f5 100644
--- a/arch/powerpc/platforms/iseries/pci.c
+++ b/arch/powerpc/platforms/iseries/pci.c
@@ -37,36 +37,18 @@
 
 #include <asm/iseries/hv_call_xm.h>
 #include <asm/iseries/mf.h>
+#include <asm/iseries/iommu.h>
 
 #include <asm/ppc-pci.h>
 
 #include "irq.h"
 #include "pci.h"
 #include "call_pci.h"
-#include "iommu.h"
-
-extern unsigned long io_page_mask;
 
 /*
  * Forward declares of prototypes.
  */
 static struct device_node *find_Device_Node(int bus, int devfn);
-static void scan_PHB_slots(struct pci_controller *Phb);
-static void scan_EADS_bridge(HvBusNumber Bus, HvSubBusNumber SubBus, int IdSel);
-static int scan_bridge_slot(HvBusNumber Bus, struct HvCallPci_BridgeInfo *Info);
-
-LIST_HEAD(iSeries_Global_Device_List);
-
-static int DeviceCount;
-
-/* Counters and control flags. */
-static long Pci_Io_Read_Count;
-static long Pci_Io_Write_Count;
-#if 0
-static long Pci_Cfg_Read_Count;
-static long Pci_Cfg_Write_Count;
-#endif
-static long Pci_Error_Count;
 
 static int Pci_Retry_Max = 3;   /* Only retry 3 times  */
 static int Pci_Error_Flag = 1;  /* Set Retry Error on. */
@@ -81,41 +63,19 @@ static struct pci_ops iSeries_pci_ops;
 #define IOMM_TABLE_ENTRY_SIZE   0x0000000000400000UL
 #define BASE_IO_MEMORY          0xE000000000000000UL
 
-static unsigned long max_io_memory = 0xE000000000000000UL;
+static unsigned long max_io_memory = BASE_IO_MEMORY;
 static long current_iomm_table_entry;
 
 /*
  * Lookup Tables.
  */
-static struct device_node **iomm_table;
-static u8 *iobar_table;
+static struct device_node *iomm_table[IOMM_TABLE_MAX_ENTRIES];
+static u8 iobar_table[IOMM_TABLE_MAX_ENTRIES];
 
-/*
- * Static and Global variables
- */
-static char *pci_io_text = "iSeries PCI I/O";
+static const char pci_io_text[] = "iSeries PCI I/O";
 static DEFINE_SPINLOCK(iomm_table_lock);
 
 /*
- * iomm_table_initialize
- *
- * Allocates and initalizes the Address Translation Table and Bar
- * Tables to get them ready for use.  Must be called before any
- * I/O space is handed out to the device BARs.
- */
-static void iomm_table_initialize(void)
-{
-        spin_lock(&iomm_table_lock);
-        iomm_table = kmalloc(sizeof(*iomm_table) * IOMM_TABLE_MAX_ENTRIES,
-                        GFP_KERNEL);
-        iobar_table = kmalloc(sizeof(*iobar_table) * IOMM_TABLE_MAX_ENTRIES,
-                        GFP_KERNEL);
-        spin_unlock(&iomm_table_lock);
-        if ((iomm_table == NULL) || (iobar_table == NULL))
-                panic("PCI: I/O tables allocation failed.\n");
-}
-
-/*
  * iomm_table_allocate_entry
  *
  * Adds pci_dev entry in address translation table
@@ -142,9 +102,8 @@ static void iomm_table_allocate_entry(struct pci_dev *dev, int bar_num)
          */
         spin_lock(&iomm_table_lock);
         bar_res->name = pci_io_text;
-        bar_res->start =
+        bar_res->start = BASE_IO_MEMORY +
                 IOMM_TABLE_ENTRY_SIZE * current_iomm_table_entry;
-        bar_res->start += BASE_IO_MEMORY;
         bar_res->end = bar_res->start + bar_size - 1;
         /*
          * Allocate the number of table entries needed for BAR.
@@ -156,7 +115,7 @@ static void iomm_table_allocate_entry(struct pci_dev *dev, int bar_num)
                 ++current_iomm_table_entry;
         }
         max_io_memory = BASE_IO_MEMORY +
-                (IOMM_TABLE_ENTRY_SIZE * current_iomm_table_entry);
+                IOMM_TABLE_ENTRY_SIZE * current_iomm_table_entry;
         spin_unlock(&iomm_table_lock);
 }
 
@@ -173,13 +132,10 @@ static void iomm_table_allocate_entry(struct pci_dev *dev, int bar_num)
  */
 static void allocate_device_bars(struct pci_dev *dev)
 {
-        struct resource *bar_res;
         int bar_num;
 
-        for (bar_num = 0; bar_num <= PCI_ROM_RESOURCE; ++bar_num) {
-                bar_res = &dev->resource[bar_num];
+        for (bar_num = 0; bar_num <= PCI_ROM_RESOURCE; ++bar_num)
                 iomm_table_allocate_entry(dev, bar_num);
-        }
 }
 
 /*
@@ -199,34 +155,7 @@ static void pci_Log_Error(char *Error_Text, int Bus, int SubBus,
 }
 
 /*
- * build_device_node(u16 Bus, int SubBus, u8 DevFn)
- */
-static struct device_node *build_device_node(HvBusNumber Bus,
-                HvSubBusNumber SubBus, int AgentId, int Function)
-{
-        struct device_node *node;
-        struct pci_dn *pdn;
-
-        node = kmalloc(sizeof(struct device_node), GFP_KERNEL);
-        if (node == NULL)
-                return NULL;
-        memset(node, 0, sizeof(struct device_node));
-        pdn = kzalloc(sizeof(*pdn), GFP_KERNEL);
-        if (pdn == NULL) {
-                kfree(node);
-                return NULL;
-        }
-        node->data = pdn;
-        pdn->node = node;
-        list_add_tail(&pdn->Device_List, &iSeries_Global_Device_List);
-        pdn->busno = Bus;
-        pdn->bussubno = SubBus;
-        pdn->devfn = PCI_DEVFN(ISERIES_ENCODE_DEVICE(AgentId), Function);
-        return node;
-}
-
-/*
- * unsigned long __init find_and_init_phbs(void)
+ * iSeries_pcibios_init
  *
  * Description:
  *   This function checks for all possible system PCI host bridges that connect
@@ -234,50 +163,42 @@ static struct device_node *build_device_node(HvBusNumber Bus,
  *   ownership status.  A pci_controller is built for any bus which is partially
  *   owned or fully owned by this guest partition.
  */
-unsigned long __init find_and_init_phbs(void)
+void iSeries_pcibios_init(void)
 {
         struct pci_controller *phb;
-        HvBusNumber bus;
-
-        /* Check all possible buses. */
-        for (bus = 0; bus < 256; bus++) {
-                int ret = HvCallXm_testBus(bus);
-                if (ret == 0) {
-                        printk("bus %d appears to exist\n", bus);
+        struct device_node *root = of_find_node_by_path("/");
+        struct device_node *node = NULL;
 
-                        phb = pcibios_alloc_controller(NULL);
-                        if (phb == NULL)
-                                return -ENOMEM;
-
-                        phb->pci_mem_offset = phb->local_number = bus;
-                        phb->first_busno = bus;
-                        phb->last_busno = bus;
-                        phb->ops = &iSeries_pci_ops;
-
-                        /* Find and connect the devices. */
-                        scan_PHB_slots(phb);
-                }
-                /*
-                 * Check for Unexpected Return code, a clue that something
-                 * has gone wrong.
-                 */
-                else if (ret != 0x0301)
-                        printk(KERN_ERR "Unexpected Return on Probe(0x%04X): 0x%04X",
-                               bus, ret);
+        if (root == NULL) {
+                printk(KERN_CRIT "iSeries_pcibios_init: can't find root "
+                                "of device tree\n");
+                return;
+        }
+        while ((node = of_get_next_child(root, node)) != NULL) {
+                HvBusNumber bus;
+                u32 *busp;
+
+                if ((node->type == NULL) || (strcmp(node->type, "pci") != 0))
+                        continue;
+
+                busp = (u32 *)get_property(node, "bus-range", NULL);
+                if (busp == NULL)
+                        continue;
+                bus = *busp;
+                printk("bus %d appears to exist\n", bus);
+                phb = pcibios_alloc_controller(node);
+                if (phb == NULL)
+                        continue;
+
+                phb->pci_mem_offset = phb->local_number = bus;
+                phb->first_busno = bus;
+                phb->last_busno = bus;
+                phb->ops = &iSeries_pci_ops;
         }
-        return 0;
-}
 
-/*
- * iSeries_pcibios_init
- *
- * Chance to initialize and structures or variable before PCI Bus walk.
- */
-void iSeries_pcibios_init(void)
-{
-        iomm_table_initialize();
-        find_and_init_phbs();
-        io_page_mask = -1;
+        of_node_put(root);
+
+        pci_devs_phb_init();
 }
 
 /*
@@ -299,6 +220,34 @@ void __init iSeries_pci_final_fixup(void)
                        pdev->bus->number, pdev->devfn, node);
 
                 if (node != NULL) {
+                        struct pci_dn *pdn = PCI_DN(node);
+                        u32 *agent;
+
+                        agent = (u32 *)get_property(node, "linux,agent-id",
+                                        NULL);
+                        if ((pdn != NULL) && (agent != NULL)) {
+                                u8 irq = iSeries_allocate_IRQ(pdn->busno, 0,
+                                                pdn->bussubno);
+                                int err;
+
+                                err = HvCallXm_connectBusUnit(pdn->busno, pdn->bussubno,
+                                                *agent, irq);
+                                if (err)
+                                        pci_Log_Error("Connect Bus Unit",
+                                                pdn->busno, pdn->bussubno, *agent, err);
+                                else {
+                                        err = HvCallPci_configStore8(pdn->busno, pdn->bussubno,
+                                                        *agent,
+                                                        PCI_INTERRUPT_LINE,
+                                                        irq);
+                                        if (err)
+                                                pci_Log_Error("PciCfgStore Irq Failed!",
+                                                        pdn->busno, pdn->bussubno, *agent, err);
+                                }
+                                if (!err)
+                                        pdev->irq = irq;
+                        }
+
                         ++DeviceCount;
                         pdev->sysdata = (void *)node;
                         PCI_DN(node)->pcidev = pdev;
@@ -308,7 +257,6 @@ void __init iSeries_pci_final_fixup(void)
                 } else
                         printk("PCI: Device Tree not found for 0x%016lX\n",
                                         (unsigned long)pdev);
-                pdev->irq = PCI_DN(node)->Irq;
         }
         iSeries_activate_IRQs();
         mf_display_src(0xC9000200);
@@ -323,148 +271,6 @@ void pcibios_fixup_resources(struct pci_dev *pdev)
 }
 
 /*
- * Loop through each node function to find usable EADs bridges.
- */
-static void scan_PHB_slots(struct pci_controller *Phb)
-{
-        struct HvCallPci_DeviceInfo *DevInfo;
-        HvBusNumber bus = Phb->local_number;    /* System Bus */
-        const HvSubBusNumber SubBus = 0;        /* EADs is always 0. */
-        int HvRc = 0;
-        int IdSel;
-        const int MaxAgents = 8;
-
-        DevInfo = (struct HvCallPci_DeviceInfo*)
-                kmalloc(sizeof(struct HvCallPci_DeviceInfo), GFP_KERNEL);
-        if (DevInfo == NULL)
-                return;
-
-        /*
-         * Probe for EADs Bridges
-         */
-        for (IdSel = 1; IdSel < MaxAgents; ++IdSel) {
-                HvRc = HvCallPci_getDeviceInfo(bus, SubBus, IdSel,
-                                iseries_hv_addr(DevInfo),
-                                sizeof(struct HvCallPci_DeviceInfo));
-                if (HvRc == 0) {
-                        if (DevInfo->deviceType == HvCallPci_NodeDevice)
-                                scan_EADS_bridge(bus, SubBus, IdSel);
-                        else
-                                printk("PCI: Invalid System Configuration(0x%02X)"
-                                       " for bus 0x%02x id 0x%02x.\n",
-                                       DevInfo->deviceType, bus, IdSel);
-                }
-                else
-                        pci_Log_Error("getDeviceInfo", bus, SubBus, IdSel, HvRc);
-        }
-        kfree(DevInfo);
-}
-
-static void scan_EADS_bridge(HvBusNumber bus, HvSubBusNumber SubBus,
-                int IdSel)
-{
-        struct HvCallPci_BridgeInfo *BridgeInfo;
-        HvAgentId AgentId;
-        int Function;
-        int HvRc;
-
-        BridgeInfo = (struct HvCallPci_BridgeInfo *)
-                kmalloc(sizeof(struct HvCallPci_BridgeInfo), GFP_KERNEL);
-        if (BridgeInfo == NULL)
-                return;
-
-        /* Note: hvSubBus and irq is always be 0 at this level! */
-        for (Function = 0; Function < 8; ++Function) {
-                AgentId = ISERIES_PCI_AGENTID(IdSel, Function);
-                HvRc = HvCallXm_connectBusUnit(bus, SubBus, AgentId, 0);
-                if (HvRc == 0) {
-                        printk("found device at bus %d idsel %d func %d (AgentId %x)\n",
-                               bus, IdSel, Function, AgentId);
-                        /*  Connect EADs: 0x18.00.12 = 0x00 */
-                        HvRc = HvCallPci_getBusUnitInfo(bus, SubBus, AgentId,
-                                        iseries_hv_addr(BridgeInfo),
-                                        sizeof(struct HvCallPci_BridgeInfo));
-                        if (HvRc == 0) {
-                                printk("bridge info: type %x subbus %x maxAgents %x maxsubbus %x logslot %x\n",
-                                        BridgeInfo->busUnitInfo.deviceType,
-                                        BridgeInfo->subBusNumber,
-                                        BridgeInfo->maxAgents,
-                                        BridgeInfo->maxSubBusNumber,
-                                        BridgeInfo->logicalSlotNumber);
-                                if (BridgeInfo->busUnitInfo.deviceType ==
-                                                HvCallPci_BridgeDevice)  {
-                                        /* Scan_Bridge_Slot...: 0x18.00.12 */
-                                        scan_bridge_slot(bus, BridgeInfo);
-                                } else
-                                        printk("PCI: Invalid Bridge Configuration(0x%02X)",
-                                                BridgeInfo->busUnitInfo.deviceType);
-                        }
-                } else if (HvRc != 0x000B)
-                        pci_Log_Error("EADs Connect",
-                                        bus, SubBus, AgentId, HvRc);
-        }
-        kfree(BridgeInfo);
-}
-
-/*
- * This assumes that the node slot is always on the primary bus!
- */
-static int scan_bridge_slot(HvBusNumber Bus,
-                struct HvCallPci_BridgeInfo *BridgeInfo)
-{
-        struct device_node *node;
-        HvSubBusNumber SubBus = BridgeInfo->subBusNumber;
-        u16 VendorId = 0;
-        int HvRc = 0;
-        u8 Irq = 0;
-        int IdSel = ISERIES_GET_DEVICE_FROM_SUBBUS(SubBus);
-        int Function = ISERIES_GET_FUNCTION_FROM_SUBBUS(SubBus);
-        HvAgentId EADsIdSel = ISERIES_PCI_AGENTID(IdSel, Function);
-
-        /* iSeries_allocate_IRQ.: 0x18.00.12(0xA3) */
-        Irq = iSeries_allocate_IRQ(Bus, 0, EADsIdSel);
-
-        /*
-         * Connect all functions of any device found.
-         */
-        for (IdSel = 1; IdSel <= BridgeInfo->maxAgents; ++IdSel) {
-                for (Function = 0; Function < 8; ++Function) {
-                        HvAgentId AgentId = ISERIES_PCI_AGENTID(IdSel, Function);
-                        HvRc = HvCallXm_connectBusUnit(Bus, SubBus,
-                                        AgentId, Irq);
-                        if (HvRc != 0) {
-                                pci_Log_Error("Connect Bus Unit",
-                                              Bus, SubBus, AgentId, HvRc);
-                                continue;
-                        }
-
-                        HvRc = HvCallPci_configLoad16(Bus, SubBus, AgentId,
-                                                      PCI_VENDOR_ID, &VendorId);
-                        if (HvRc != 0) {
-                                pci_Log_Error("Read Vendor",
-                                              Bus, SubBus, AgentId, HvRc);
-                                continue;
-                        }
-                        printk("read vendor ID: %x\n", VendorId);
-
-                        /* FoundDevice: 0x18.28.10 = 0x12AE */
-                        HvRc = HvCallPci_configStore8(Bus, SubBus, AgentId,
-                                                      PCI_INTERRUPT_LINE, Irq);
-                        if (HvRc != 0)
-                                pci_Log_Error("PciCfgStore Irq Failed!",
-                                              Bus, SubBus, AgentId, HvRc);
-
-                        ++DeviceCount;
-                        node = build_device_node(Bus, SubBus, EADsIdSel, Function);
-                        PCI_DN(node)->Irq = Irq;
-                        PCI_DN(node)->LogicalSlot = BridgeInfo->logicalSlotNumber;
-
-                } /* for (Function = 0; Function < 8; ++Function) */
-        } /* for (IdSel = 1; IdSel <= MaxAgents; ++IdSel) */
-        return HvRc;
-}
-
-/*
  * I/0 Memory copy MUST use mmio commands on iSeries
  * To do; For performance, include the hv call directly
  */
@@ -509,11 +315,13 @@ EXPORT_SYMBOL(iSeries_memcpy_fromio);
  */
 static struct device_node *find_Device_Node(int bus, int devfn)
 {
-        struct pci_dn *pdn;
+        struct device_node *node;
+
+        for (node = NULL; (node = of_find_all_nodes(node)); ) {
+                struct pci_dn *pdn = PCI_DN(node);
 
-        list_for_each_entry(pdn, &iSeries_Global_Device_List, Device_List) {
-                if ((bus == pdn->busno) && (devfn == pdn->devfn))
-                        return pdn->node;
+                if (pdn && (bus == pdn->busno) && (devfn == pdn->devfn))
+                        return node;
         }
         return NULL;
 }
@@ -625,7 +433,6 @@ static int CheckReturnCode(char *TextHdr, struct device_node *DevNode,
         if (ret != 0)  {
                 struct pci_dn *pdn = PCI_DN(DevNode);
 
-                ++Pci_Error_Count;
                 (*retry)++;
                 printk("PCI: %s: Device 0x%04X:%02X  I/O Error(%2d): 0x%04X\n",
                                 TextHdr, pdn->busno, pdn->devfn,
@@ -707,7 +514,6 @@ u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
                 return 0xff;
         }
         do {
-                ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad8, &ret, dsa, BarOffset, 0);
         } while (CheckReturnCode("RDB", DevNode, &retry, ret.rc) != 0);
 
@@ -737,7 +543,6 @@ u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
                 return 0xffff;
         }
         do {
-                ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad16, &ret, dsa,
                                 BarOffset, 0);
         } while (CheckReturnCode("RDW", DevNode, &retry, ret.rc) != 0);
@@ -768,7 +573,6 @@ u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
                 return 0xffffffff;
         }
         do {
-                ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad32, &ret, dsa,
                                 BarOffset, 0);
         } while (CheckReturnCode("RDL", DevNode, &retry, ret.rc) != 0);
@@ -806,7 +610,6 @@ void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
                 return;
         }
         do {
-                ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore8, dsa, BarOffset, data, 0);
         } while (CheckReturnCode("WWB", DevNode, &retry, rc) != 0);
 }
@@ -834,7 +637,6 @@ void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
                 return;
         }
         do {
-                ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore16, dsa, BarOffset, swab16(data), 0);
         } while (CheckReturnCode("WWW", DevNode, &retry, rc) != 0);
 }
@@ -862,7 +664,6 @@ void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
                 return;
         }
         do {
-                ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore32, dsa, BarOffset, swab32(data), 0);
         } while (CheckReturnCode("WWL", DevNode, &retry, rc) != 0);
 }
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
index a6fd9bedb074..617c724c4590 100644
--- a/arch/powerpc/platforms/iseries/setup.c
+++ b/arch/powerpc/platforms/iseries/setup.c
@@ -50,7 +50,6 @@
 #include <asm/iseries/hv_call_xm.h>
 #include <asm/iseries/it_lp_queue.h>
 #include <asm/iseries/mf.h>
-#include <asm/iseries/it_exp_vpd_panel.h>
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/lpar_map.h>
 #include <asm/udbg.h>
@@ -81,9 +80,6 @@ extern void iSeries_pci_final_fixup(void);
 static void iSeries_pci_final_fixup(void) { }
 #endif
 
-/* Global Variables */
-int piranha_simulator;
-
 extern int rd_size;             /* Defined in drivers/block/rd.c */
 extern unsigned long embedded_sysmap_start;
 extern unsigned long embedded_sysmap_end;
@@ -91,8 +87,6 @@ extern unsigned long embedded_sysmap_end;
 extern unsigned long iSeries_recal_tb;
 extern unsigned long iSeries_recal_titan;
 
-static unsigned long cmd_mem_limit;
-
 struct MemoryBlock {
         unsigned long absStart;
         unsigned long absEnd;
@@ -340,8 +334,6 @@ static void __init iSeries_init_early(void)
 #ifdef CONFIG_SMP
         smp_init_iSeries();
 #endif
-        if (itLpNaca.xPirEnvironMode == 0)
-                piranha_simulator = 1;
 
         /* Associate Lp Event Queue 0 with processor 0 */
         HvCallEvent_setLpEventQueueInterruptProc(0, 0);
@@ -536,10 +528,10 @@ static void __init iSeries_setup_arch(void)
 {
         if (get_lppaca()->shared_proc) {
                 ppc_md.idle_loop = iseries_shared_idle;
-                printk(KERN_INFO "Using shared processor idle loop\n");
+                printk(KERN_DEBUG "Using shared processor idle loop\n");
         } else {
                 ppc_md.idle_loop = iseries_dedicated_idle;
-                printk(KERN_INFO "Using dedicated idle loop\n");
+                printk(KERN_DEBUG "Using dedicated idle loop\n");
         }
 
         /* Setup the Lp Event Queue */
@@ -714,243 +706,6 @@ define_machine(iseries) {
         /* XXX Implement enable_pmcs for iSeries */
 };
 
-struct blob {
-        unsigned char data[PAGE_SIZE];
-        unsigned long next;
-};
-
-struct iseries_flat_dt {
-        struct boot_param_header header;
-        u64 reserve_map[2];
-        struct blob dt;
-        struct blob strings;
-};
-
-struct iseries_flat_dt iseries_dt;
-
-void dt_init(struct iseries_flat_dt *dt)
-{
-        dt->header.off_mem_rsvmap =
-                offsetof(struct iseries_flat_dt, reserve_map);
-        dt->header.off_dt_struct = offsetof(struct iseries_flat_dt, dt);
-        dt->header.off_dt_strings = offsetof(struct iseries_flat_dt, strings);
-        dt->header.totalsize = sizeof(struct iseries_flat_dt);
-        dt->header.dt_strings_size = sizeof(struct blob);
-
-        /* There is no notion of hardware cpu id on iSeries */
-        dt->header.boot_cpuid_phys = smp_processor_id();
-
-        dt->dt.next = (unsigned long)&dt->dt.data;
-        dt->strings.next = (unsigned long)&dt->strings.data;
-
-        dt->header.magic = OF_DT_HEADER;
-        dt->header.version = 0x10;
-        dt->header.last_comp_version = 0x10;
-
-        dt->reserve_map[0] = 0;
-        dt->reserve_map[1] = 0;
-}
-
-void dt_check_blob(struct blob *b)
-{
-        if (b->next >= (unsigned long)&b->next) {
-                DBG("Ran out of space in flat device tree blob!\n");
-                BUG();
-        }
-}
-
-void dt_push_u32(struct iseries_flat_dt *dt, u32 value)
-{
-        *((u32*)dt->dt.next) = value;
-        dt->dt.next += sizeof(u32);
-
-        dt_check_blob(&dt->dt);
-}
-
-void dt_push_u64(struct iseries_flat_dt *dt, u64 value)
-{
-        *((u64*)dt->dt.next) = value;
-        dt->dt.next += sizeof(u64);
-
-        dt_check_blob(&dt->dt);
-}
-
-unsigned long dt_push_bytes(struct blob *blob, char *data, int len)
-{
-        unsigned long start = blob->next - (unsigned long)blob->data;
-
-        memcpy((char *)blob->next, data, len);
-        blob->next = _ALIGN(blob->next + len, 4);
-
-        dt_check_blob(blob);
-
-        return start;
-}
-
-void dt_start_node(struct iseries_flat_dt *dt, char *name)
-{
-        dt_push_u32(dt, OF_DT_BEGIN_NODE);
-        dt_push_bytes(&dt->dt, name, strlen(name) + 1);
-}
-
-#define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
-
-void dt_prop(struct iseries_flat_dt *dt, char *name, char *data, int len)
-{
-        unsigned long offset;
-
-        dt_push_u32(dt, OF_DT_PROP);
-
-        /* Length of the data */
-        dt_push_u32(dt, len);
-
-        /* Put the property name in the string blob. */
-        offset = dt_push_bytes(&dt->strings, name, strlen(name) + 1);
-
-        /* The offset of the properties name in the string blob. */
-        dt_push_u32(dt, (u32)offset);
-
-        /* The actual data. */
-        dt_push_bytes(&dt->dt, data, len);
-}
-
-void dt_prop_str(struct iseries_flat_dt *dt, char *name, char *data)
-{
-        dt_prop(dt, name, data, strlen(data) + 1); /* + 1 for NULL */
-}
-
-void dt_prop_u32(struct iseries_flat_dt *dt, char *name, u32 data)
-{
-        dt_prop(dt, name, (char *)&data, sizeof(u32));
-}
-
-void dt_prop_u64(struct iseries_flat_dt *dt, char *name, u64 data)
-{
-        dt_prop(dt, name, (char *)&data, sizeof(u64));
-}
-
-void dt_prop_u64_list(struct iseries_flat_dt *dt, char *name, u64 *data, int n)
-{
-        dt_prop(dt, name, (char *)data, sizeof(u64) * n);
-}
-
-void dt_prop_u32_list(struct iseries_flat_dt *dt, char *name, u32 *data, int n)
-{
-        dt_prop(dt, name, (char *)data, sizeof(u32) * n);
-}
-
-void dt_prop_empty(struct iseries_flat_dt *dt, char *name)
-{
-        dt_prop(dt, name, NULL, 0);
-}
-
-void dt_cpus(struct iseries_flat_dt *dt)
-{
-        unsigned char buf[32];
-        unsigned char *p;
-        unsigned int i, index;
-        struct IoHriProcessorVpd *d;
-        u32 pft_size[2];
-
-        /* yuck */
-        snprintf(buf, 32, "PowerPC,%s", cur_cpu_spec->cpu_name);
-        p = strchr(buf, ' ');
-        if (!p) p = buf + strlen(buf);
-
-        dt_start_node(dt, "cpus");
-        dt_prop_u32(dt, "#address-cells", 1);
-        dt_prop_u32(dt, "#size-cells", 0);
-
-        pft_size[0] = 0; /* NUMA CEC cookie, 0 for non NUMA  */
-        pft_size[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE);
-
-        for (i = 0; i < NR_CPUS; i++) {
-                if (lppaca[i].dyn_proc_status >= 2)
-                        continue;
-
-                snprintf(p, 32 - (p - buf), "@%d", i);
-                dt_start_node(dt, buf);
-
-                dt_prop_str(dt, "device_type", "cpu");
-
-                index = lppaca[i].dyn_hv_phys_proc_index;
-                d = &xIoHriProcessorVpd[index];
-
-                dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
-                dt_prop_u32(dt, "i-cache-line-size", d->xInstCacheOperandSize);
-
-                dt_prop_u32(dt, "d-cache-size", d->xDataL1CacheSizeKB * 1024);
-                dt_prop_u32(dt, "d-cache-line-size", d->xDataCacheOperandSize);
-
-                /* magic conversions to Hz copied from old code */
-                dt_prop_u32(dt, "clock-frequency",
-                        ((1UL << 34) * 1000000) / d->xProcFreq);
-                dt_prop_u32(dt, "timebase-frequency",
-                        ((1UL << 32) * 1000000) / d->xTimeBaseFreq);
-
-                dt_prop_u32(dt, "reg", i);
-
-                dt_prop_u32_list(dt, "ibm,pft-size", pft_size, 2);
-
-                dt_end_node(dt);
-        }
-
-        dt_end_node(dt);
-}
-
-void dt_model(struct iseries_flat_dt *dt)
-{
-        char buf[16] = "IBM,";
-
-        /* "IBM," + mfgId[2:3] + systemSerial[1:5] */
-        strne2a(buf + 4, xItExtVpdPanel.mfgID + 2, 2);
-        strne2a(buf + 6, xItExtVpdPanel.systemSerial + 1, 5);
-        buf[11] = '\0';
-        dt_prop_str(dt, "system-id", buf);
-
-        /* "IBM," + machineType[0:4] */
-        strne2a(buf + 4, xItExtVpdPanel.machineType, 4);
-        buf[8] = '\0';
-        dt_prop_str(dt, "model", buf);
-
-        dt_prop_str(dt, "compatible", "IBM,iSeries");
-}
-
-void build_flat_dt(struct iseries_flat_dt *dt, unsigned long phys_mem_size)
-{
-        u64 tmp[2];
-
-        dt_init(dt);
-
-        dt_start_node(dt, "");
-
-        dt_prop_u32(dt, "#address-cells", 2);
-        dt_prop_u32(dt, "#size-cells", 2);
-        dt_model(dt);
-
-        /* /memory */
-        dt_start_node(dt, "memory@0");
-        dt_prop_str(dt, "name", "memory");
-        dt_prop_str(dt, "device_type", "memory");
-        tmp[0] = 0;
-        tmp[1] = phys_mem_size;
-        dt_prop_u64_list(dt, "reg", tmp, 2);
-        dt_end_node(dt);
-
-        /* /chosen */
-        dt_start_node(dt, "chosen");
-        dt_prop_str(dt, "bootargs", cmd_line);
-        if (cmd_mem_limit)
-                dt_prop_u64(dt, "linux,memory-limit", cmd_mem_limit);
-        dt_end_node(dt);
-
-        dt_cpus(dt);
-
-        dt_end_node(dt);
-
-        dt_push_u32(dt, OF_DT_END);
-}
-
 void * __init iSeries_early_setup(void)
 {
         unsigned long phys_mem_size;
@@ -965,28 +720,8 @@ void * __init iSeries_early_setup(void)
 
         iSeries_get_cmdline();
 
-        /* Save unparsed command line copy for /proc/cmdline */
-        strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-
-        /* Parse early parameters, in particular mem=x */
-        parse_early_param();
-
-        build_flat_dt(&iseries_dt, phys_mem_size);
-
-        return (void *) __pa(&iseries_dt);
-}
-
-/*
- * On iSeries we just parse the mem=X option from the command line.
- * On pSeries it's a bit more complicated, see prom_init_mem()
- */
-static int __init early_parsemem(char *p)
-{
-        if (p)
-                cmd_mem_limit = ALIGN(memparse(p, &p), PAGE_SIZE);
-        return 0;
+        return (void *) __pa(build_flat_dt(phys_mem_size));
 }
-early_param("mem", early_parsemem);
 
 static void hvputc(char c)
 {
diff --git a/arch/powerpc/platforms/iseries/setup.h b/arch/powerpc/platforms/iseries/setup.h
index 5213044ec411..0a47ac53c959 100644
--- a/arch/powerpc/platforms/iseries/setup.h
+++ b/arch/powerpc/platforms/iseries/setup.h
@@ -21,4 +21,6 @@ extern unsigned long iSeries_get_boot_time(void);
 extern int iSeries_set_rtc_time(struct rtc_time *tm);
 extern void iSeries_get_rtc_time(struct rtc_time *tm);
 
+extern void *build_flat_dt(unsigned long phys_mem_size);
+
 #endif /* __ISERIES_SETUP_H__ */
diff --git a/arch/powerpc/platforms/iseries/vio.c b/arch/powerpc/platforms/iseries/vio.c
deleted file mode 100644
index ad36ab0639f0..000000000000
--- a/arch/powerpc/platforms/iseries/vio.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * IBM PowerPC iSeries Virtual I/O Infrastructure Support.
- *
- *    Copyright (c) 2005 Stephen Rothwell, IBM Corp.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- */
-#include <linux/types.h>
-#include <linux/device.h>
-#include <linux/init.h>
-
-#include <asm/vio.h>
-#include <asm/iommu.h>
-#include <asm/tce.h>
-#include <asm/abs_addr.h>
-#include <asm/page.h>
-#include <asm/iseries/vio.h>
-#include <asm/iseries/hv_types.h>
-#include <asm/iseries/hv_lp_config.h>
-#include <asm/iseries/hv_call_xm.h>
-
-#include "iommu.h"
-
-struct device *iSeries_vio_dev = &vio_bus_device.dev;
-EXPORT_SYMBOL(iSeries_vio_dev);
-
-static struct iommu_table veth_iommu_table;
-static struct iommu_table vio_iommu_table;
-
-static void __init iommu_vio_init(void)
-{
-        iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table);
-        veth_iommu_table.it_size /= 2;
-        vio_iommu_table = veth_iommu_table;
-        vio_iommu_table.it_offset += veth_iommu_table.it_size;
-
-        if (!iommu_init_table(&veth_iommu_table))
-                printk("Virtual Bus VETH TCE table failed.\n");
-        if (!iommu_init_table(&vio_iommu_table))
-                printk("Virtual Bus VIO TCE table failed.\n");
-}
-
-/**
- * vio_register_device_iseries: - Register a new iSeries vio device.
- * @voidev:     The device to register.
- */
-static struct vio_dev *__init vio_register_device_iseries(char *type,
-                uint32_t unit_num)
-{
-        struct vio_dev *viodev;
-
-        /* allocate a vio_dev for this device */
-        viodev = kmalloc(sizeof(struct vio_dev), GFP_KERNEL);
-        if (!viodev)
-                return NULL;
-        memset(viodev, 0, sizeof(struct vio_dev));
-
-        snprintf(viodev->dev.bus_id, BUS_ID_SIZE, "%s%d", type, unit_num);
-
-        viodev->name = viodev->dev.bus_id;
-        viodev->type = type;
-        viodev->unit_address = unit_num;
-        viodev->iommu_table = &vio_iommu_table;
-        if (vio_register_device(viodev) == NULL) {
-                kfree(viodev);
-                return NULL;
-        }
-        return viodev;
-}
-
-void __init probe_bus_iseries(void)
-{
-        HvLpIndexMap vlan_map;
-        struct vio_dev *viodev;
-        int i;
-
-        /* there is only one of each of these */
-        vio_register_device_iseries("viocons", 0);
-        vio_register_device_iseries("vscsi", 0);
-
-        vlan_map = HvLpConfig_getVirtualLanIndexMap();
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALLANS; i++) {
-                if ((vlan_map & (0x8000 >> i)) == 0)
-                        continue;
-                viodev = vio_register_device_iseries("vlan", i);
-                /* veth is special and has it own iommu_table */
-                viodev->iommu_table = &veth_iommu_table;
-        }
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALDISKS; i++)
-                vio_register_device_iseries("viodasd", i);
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALCDROMS; i++)
-                vio_register_device_iseries("viocd", i);
-        for (i = 0; i < HVMAXARCHITECTEDVIRTUALTAPES; i++)
-                vio_register_device_iseries("viotape", i);
-}
-
-/**
- * vio_match_device_iseries: - Tell if a iSeries VIO device matches a
- *      vio_device_id
- */
-static int vio_match_device_iseries(const struct vio_device_id *id,
-                const struct vio_dev *dev)
-{
-        return strncmp(dev->type, id->type, strlen(id->type)) == 0;
-}
-
-static struct vio_bus_ops vio_bus_ops_iseries = {
-        .match = vio_match_device_iseries,
-};
-
-/**
- * vio_bus_init_iseries: - Initialize the iSeries virtual IO bus
- */
-static int __init vio_bus_init_iseries(void)
-{
-        int err;
-
-        err = vio_bus_init(&vio_bus_ops_iseries);
-        if (err == 0) {
-                iommu_vio_init();
-                vio_bus_device.iommu_table = &vio_iommu_table;
-                iSeries_vio_dev = &vio_bus_device.dev;
-                probe_bus_iseries();
-        }
-        return err;
-}
-
-__initcall(vio_bus_init_iseries);
diff --git a/arch/powerpc/platforms/maple/pci.c b/arch/powerpc/platforms/maple/pci.c
index 85d6c93659cc..9a4efc0c3b29 100644
--- a/arch/powerpc/platforms/maple/pci.c
+++ b/arch/powerpc/platforms/maple/pci.c
@@ -437,9 +437,6 @@ void __init maple_pci_init(void)
 
         /* Tell pci.c to not change any resource allocations.  */
         pci_probe_only = 1;
-        
-        /* Allow all IO */
-        io_page_mask = -1;
 }
 
 int maple_pci_get_legacy_ide_irq(struct pci_dev *pdev, int channel)
diff --git a/arch/powerpc/platforms/maple/setup.c b/arch/powerpc/platforms/maple/setup.c
index 24c0aef4ea39..a0505ea48a86 100644
--- a/arch/powerpc/platforms/maple/setup.c
+++ b/arch/powerpc/platforms/maple/setup.c
@@ -189,7 +189,7 @@ void __init maple_setup_arch(void)
         conswitchp = &dummy_con;
 #endif
 
-        printk(KERN_INFO "Using native/NAP idle loop\n");
+        printk(KERN_DEBUG "Using native/NAP idle loop\n");
 }
 
 /* 
diff --git a/arch/powerpc/platforms/powermac/feature.c b/arch/powerpc/platforms/powermac/feature.c
index a5063cd675c5..85e00cb0006e 100644
--- a/arch/powerpc/platforms/powermac/feature.c
+++ b/arch/powerpc/platforms/powermac/feature.c
@@ -2510,7 +2510,7 @@ found:
                 if (get_property(np, "flush-on-lock", NULL))
                         break;
                 powersave_nap = 1;
-                printk(KERN_INFO "Processor NAP mode on idle enabled.\n");
+                printk(KERN_DEBUG "Processor NAP mode on idle enabled.\n");
                 break;
         }
 
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index ea179afea632..80035853467b 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -1068,9 +1068,6 @@ void __init pmac_pci_init(void)
         /* Tell pci.c to not use the common resource allocation mechanism */
         pci_probe_only = 1;
 
-        /* Allow all IO */
-        io_page_mask = -1;
-
 #else /* CONFIG_PPC64 */
         init_p2pbridge();
         fixup_nec_usb2();
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 930898635c9f..b46ce3b9bb3c 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -2,7 +2,6 @@ obj-y			:= pci.o lpar.o hvCall.o nvram.o reconfig.o \
                            setup.o iommu.o ras.o rtasd.o pci_dlpar.o \
                            firmware.o
 obj-$(CONFIG_SMP)       += smp.o
-obj-$(CONFIG_IBMVIO)    += vio.o
 obj-$(CONFIG_XICS)      += xics.o
 obj-$(CONFIG_SCANLOG)   += scanlog.o
 obj-$(CONFIG_EEH)       += eeh.o eeh_cache.o eeh_driver.o eeh_event.o
diff --git a/arch/powerpc/platforms/pseries/eeh_driver.c b/arch/powerpc/platforms/pseries/eeh_driver.c
index 1fba695e32e8..4d45347afabc 100644
--- a/arch/powerpc/platforms/pseries/eeh_driver.c
+++ b/arch/powerpc/platforms/pseries/eeh_driver.c
@@ -23,9 +23,8 @@
  *
  */
 #include <linux/delay.h>
-#include <linux/irq.h>
 #include <linux/interrupt.h>
-#include <linux/notifier.h>
+#include <linux/irq.h>
 #include <linux/pci.h>
 #include <asm/eeh.h>
 #include <asm/eeh_event.h>
@@ -202,7 +201,11 @@ static void eeh_report_failure(struct pci_dev *dev, void *userdata)
 
 static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
 {
-        int rc;
+        int cnt, rc;
+
+        /* pcibios will clear the counter; save the value */
+        cnt = pe_dn->eeh_freeze_count;
+
         if (bus)
                 pcibios_remove_pci_devices(bus);
 
@@ -241,6 +244,7 @@ static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
                 ssleep (5);
                 pcibios_add_pci_devices(bus);
         }
+        pe_dn->eeh_freeze_count = cnt;
 
         return 0;
 }
@@ -250,7 +254,7 @@ static int eeh_reset_device (struct pci_dn *pe_dn, struct pci_bus *bus)
  */
 #define MAX_WAIT_FOR_RECOVERY 15
 
-void handle_eeh_events (struct eeh_event *event)
+struct pci_dn * handle_eeh_events (struct eeh_event *event)
 {
         struct device_node *frozen_dn;
         struct pci_dn *frozen_pdn;
@@ -265,7 +269,7 @@ void handle_eeh_events (struct eeh_event *event)
         if (!frozen_dn) {
                 printk(KERN_ERR "EEH: Error: Cannot find partition endpoint for %s\n",
                         pci_name(event->dev));
-                return;
+                return NULL;
         }
 
         /* There are two different styles for coming up with the PE.
@@ -280,7 +284,7 @@ void handle_eeh_events (struct eeh_event *event)
         if (!frozen_bus) {
                 printk(KERN_ERR "EEH: Cannot find PCI bus for %s\n",
                         frozen_dn->full_name);
-                return;
+                return NULL;
         }
 
 #if 0
@@ -355,7 +359,7 @@ void handle_eeh_events (struct eeh_event *event)
         /* Tell all device drivers that they can resume operations */
         pci_walk_bus(frozen_bus, eeh_report_resume, NULL);
 
-        return;
+        return frozen_pdn;
         
 excess_failures:
         /*
@@ -384,6 +388,8 @@ perm_error:
 
         /* Shut down the device drivers for good. */
         pcibios_remove_pci_devices(frozen_bus);
+
+        return NULL;
 }
 
 /* ---------- end of file ---------- */
diff --git a/arch/powerpc/platforms/pseries/eeh_event.c b/arch/powerpc/platforms/pseries/eeh_event.c
index 40020c65c89e..8f2d12935b99 100644
--- a/arch/powerpc/platforms/pseries/eeh_event.c
+++ b/arch/powerpc/platforms/pseries/eeh_event.c
@@ -18,6 +18,7 @@
  * Copyright (c) 2005 Linas Vepstas <linas@linas.org>
  */
 
+#include <linux/delay.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
@@ -56,38 +57,43 @@ static int eeh_event_handler(void * dummy)
 {
         unsigned long flags;
         struct eeh_event        *event;
+        struct pci_dn *pdn;
 
         daemonize ("eehd");
+        set_current_state(TASK_INTERRUPTIBLE);
 
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
+        spin_lock_irqsave(&eeh_eventlist_lock, flags);
+        event = NULL;
 
-                spin_lock_irqsave(&eeh_eventlist_lock, flags);
-                event = NULL;
+        /* Unqueue the event, get ready to process. */
+        if (!list_empty(&eeh_eventlist)) {
+                event = list_entry(eeh_eventlist.next, struct eeh_event, list);
+                list_del(&event->list);
+        }
+        spin_unlock_irqrestore(&eeh_eventlist_lock, flags);
 
-                /* Unqueue the event, get ready to process. */
-                if (!list_empty(&eeh_eventlist)) {
-                        event = list_entry(eeh_eventlist.next, struct eeh_event, list);
-                        list_del(&event->list);
-                }
-                spin_unlock_irqrestore(&eeh_eventlist_lock, flags);
+        if (event == NULL)
+                return 0;
 
-                if (event == NULL)
-                        break;
+        /* Serialize processing of EEH events */
+        mutex_lock(&eeh_event_mutex);
+        eeh_mark_slot(event->dn, EEH_MODE_RECOVERING);
 
-                /* Serialize processing of EEH events */
-                mutex_lock(&eeh_event_mutex);
-                eeh_mark_slot(event->dn, EEH_MODE_RECOVERING);
+        printk(KERN_INFO "EEH: Detected PCI bus error on device %s\n",
+               pci_name(event->dev));
 
-                printk(KERN_INFO "EEH: Detected PCI bus error on device %s\n",
-                       pci_name(event->dev));
+        pdn = handle_eeh_events(event);
 
-                handle_eeh_events(event);
+        eeh_clear_slot(event->dn, EEH_MODE_RECOVERING);
+        pci_dev_put(event->dev);
+        kfree(event);
+        mutex_unlock(&eeh_event_mutex);
 
-                eeh_clear_slot(event->dn, EEH_MODE_RECOVERING);
-                pci_dev_put(event->dev);
-                kfree(event);
-                mutex_unlock(&eeh_event_mutex);
+        /* If there are no new errors after an hour, clear the counter. */
+        if (pdn && pdn->eeh_freeze_count>0) {
+                msleep_interruptible (3600*1000);
+                if (pdn->eeh_freeze_count>0)
+                        pdn->eeh_freeze_count--;
         }
 
         return 0;
diff --git a/arch/powerpc/platforms/pseries/iommu.c b/arch/powerpc/platforms/pseries/iommu.c
index 2643078433f0..44a507e6fb34 100644
--- a/arch/powerpc/platforms/pseries/iommu.c
+++ b/arch/powerpc/platforms/pseries/iommu.c
@@ -1,23 +1,24 @@
 /*
  * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
  *
- * Rewrite, cleanup: 
+ * Rewrite, cleanup:
  *
  * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
+ * Copyright (C) 2006 Olof Johansson <olof@lixom.net>
  *
  * Dynamic DMA mapping support, pSeries-specific parts, both SMP and LPAR.
  *
- * 
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
@@ -49,52 +50,46 @@
 
 #define DBG(fmt...)
 
-static void tce_build_pSeries(struct iommu_table *tbl, long index, 
-                              long npages, unsigned long uaddr, 
+static void tce_build_pSeries(struct iommu_table *tbl, long index,
+                              long npages, unsigned long uaddr,
                               enum dma_data_direction direction)
 {
-        union tce_entry t;
-        union tce_entry *tp;
+        u64 proto_tce;
+        u64 *tcep;
+        u64 rpn;
 
         index <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        t.te_word = 0;
-        t.te_rdwr = 1; // Read allowed 
+        proto_tce = TCE_PCI_READ; // Read allowed
 
         if (direction != DMA_TO_DEVICE)
-                t.te_pciwr = 1;
+                proto_tce |= TCE_PCI_WRITE;
 
-        tp = ((union tce_entry *)tbl->it_base) + index;
+        tcep = ((u64 *)tbl->it_base) + index;
 
         while (npages--) {
                 /* can't move this out since we might cross LMB boundary */
-                t.te_rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
-        
-                tp->te_word = t.te_word;
+                rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
+                *tcep = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
 
                 uaddr += TCE_PAGE_SIZE;
-                tp++;
+                tcep++;
         }
 }
 
 
 static void tce_free_pSeries(struct iommu_table *tbl, long index, long npages)
 {
-        union tce_entry t;
-        union tce_entry *tp;
+        u64 *tcep;
 
         npages <<= TCE_PAGE_FACTOR;
         index <<= TCE_PAGE_FACTOR;
 
-        t.te_word = 0;
-        tp  = ((union tce_entry *)tbl->it_base) + index;
-                
-        while (npages--) {
-                tp->te_word = t.te_word;
-                
-                tp++;
-        }
+        tcep = ((u64 *)tbl->it_base) + index;
+
+        while (npages--)
+                *(tcep++) = 0;
 }
 
 
@@ -103,43 +98,44 @@ static void tce_build_pSeriesLP(struct iommu_table *tbl, long tcenum,
                                 enum dma_data_direction direction)
 {
         u64 rc;
-        union tce_entry tce;
+        u64 proto_tce, tce;
+        u64 rpn;
 
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-        tce.te_rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
-        tce.te_rdwr = 1;
+        rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
+        proto_tce = TCE_PCI_READ;
         if (direction != DMA_TO_DEVICE)
-                tce.te_pciwr = 1;
+                proto_tce |= TCE_PCI_WRITE;
 
         while (npages--) {
-                rc = plpar_tce_put((u64)tbl->it_index, 
-                                   (u64)tcenum << 12, 
-                                   tce.te_word );
-                
+                tce = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
+                rc = plpar_tce_put((u64)tbl->it_index, (u64)tcenum << 12, tce);
+
                 if (rc && printk_ratelimit()) {
                         printk("tce_build_pSeriesLP: plpar_tce_put failed. rc=%ld\n", rc);
                         printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                         printk("\ttcenum  = 0x%lx\n", (u64)tcenum);
-                        printk("\ttce val = 0x%lx\n", tce.te_word );
+                        printk("\ttce val = 0x%lx\n", tce );
                         show_stack(current, (unsigned long *)__get_SP());
                 }
-                        
+
                 tcenum++;
-                tce.te_rpn++;
+                rpn++;
         }
 }
 
-static DEFINE_PER_CPU(void *, tce_page) = NULL;
+static DEFINE_PER_CPU(u64 *, tce_page) = NULL;
 
 static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                                      long npages, unsigned long uaddr,
                                      enum dma_data_direction direction)
 {
         u64 rc;
-        union tce_entry tce, *tcep;
+        u64 proto_tce;
+        u64 *tcep;
+        u64 rpn;
         long l, limit;
 
         if (TCE_PAGE_FACTOR == 0 && npages == 1)
@@ -152,7 +148,7 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
          * from iommu_alloc{,_sg}()
          */
         if (!tcep) {
-                tcep = (void *)__get_free_page(GFP_ATOMIC);
+                tcep = (u64 *)__get_free_page(GFP_ATOMIC);
                 /* If allocation fails, fall back to the loop implementation */
                 if (!tcep)
                         return tce_build_pSeriesLP(tbl, tcenum, npages,
@@ -163,11 +159,10 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-        tce.te_rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
-        tce.te_rdwr = 1;
+        rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
+        proto_tce = TCE_PCI_READ;
         if (direction != DMA_TO_DEVICE)
-                tce.te_pciwr = 1;
+                proto_tce |= TCE_PCI_WRITE;
 
         /* We can map max one pageful of TCEs at a time */
         do {
@@ -175,11 +170,11 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                  * Set up the page with TCE data, looping through and setting
                  * the values.
                  */
-                limit = min_t(long, npages, 4096/sizeof(union tce_entry));
+                limit = min_t(long, npages, 4096/TCE_ENTRY_SIZE);
 
                 for (l = 0; l < limit; l++) {
-                        tcep[l] = tce;
-                        tce.te_rpn++;
+                        tcep[l] = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
+                        rpn++;
                 }
 
                 rc = plpar_tce_put_indirect((u64)tbl->it_index,
@@ -195,7 +190,7 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                 printk("tce_buildmulti_pSeriesLP: plpar_tce_put failed. rc=%ld\n", rc);
                 printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                 printk("\tnpages  = 0x%lx\n", (u64)npages);
-                printk("\ttce[0] val = 0x%lx\n", tcep[0].te_word);
+                printk("\ttce[0] val = 0x%lx\n", tcep[0]);
                 show_stack(current, (unsigned long *)__get_SP());
         }
 }
@@ -203,23 +198,17 @@ static void tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
 static void tce_free_pSeriesLP(struct iommu_table *tbl, long tcenum, long npages)
 {
         u64 rc;
-        union tce_entry tce;
 
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-
         while (npages--) {
-                rc = plpar_tce_put((u64)tbl->it_index,
-                                   (u64)tcenum << 12,
-                                   tce.te_word);
+                rc = plpar_tce_put((u64)tbl->it_index, (u64)tcenum << 12, 0);
 
                 if (rc && printk_ratelimit()) {
                         printk("tce_free_pSeriesLP: plpar_tce_put failed. rc=%ld\n", rc);
                         printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                         printk("\ttcenum  = 0x%lx\n", (u64)tcenum);
-                        printk("\ttce val = 0x%lx\n", tce.te_word );
                         show_stack(current, (unsigned long *)__get_SP());
                 }
 
@@ -231,31 +220,24 @@ static void tce_free_pSeriesLP(struct iommu_table *tbl, long tcenum, long npages
 static void tce_freemulti_pSeriesLP(struct iommu_table *tbl, long tcenum, long npages)
 {
         u64 rc;
-        union tce_entry tce;
 
         tcenum <<= TCE_PAGE_FACTOR;
         npages <<= TCE_PAGE_FACTOR;
 
-        tce.te_word = 0;
-
-        rc = plpar_tce_stuff((u64)tbl->it_index,
-                           (u64)tcenum << 12,
-                           tce.te_word,
-                           npages);
+        rc = plpar_tce_stuff((u64)tbl->it_index, (u64)tcenum << 12, 0, npages);
 
         if (rc && printk_ratelimit()) {
                 printk("tce_freemulti_pSeriesLP: plpar_tce_stuff failed\n");
                 printk("\trc      = %ld\n", rc);
                 printk("\tindex   = 0x%lx\n", (u64)tbl->it_index);
                 printk("\tnpages  = 0x%lx\n", (u64)npages);
-                printk("\ttce val = 0x%lx\n", tce.te_word );
                 show_stack(current, (unsigned long *)__get_SP());
         }
 }
 
 static void iommu_table_setparms(struct pci_controller *phb,
                                  struct device_node *dn,
-                                 struct iommu_table *tbl) 
+                                 struct iommu_table *tbl)
 {
         struct device_node *node;
         unsigned long *basep;
@@ -275,16 +257,16 @@ static void iommu_table_setparms(struct pci_controller *phb,
         memset((void *)tbl->it_base, 0, *sizep);
 
         tbl->it_busno = phb->bus->number;
-        
+
         /* Units of tce entries */
         tbl->it_offset = phb->dma_window_base_cur >> PAGE_SHIFT;
-        
+
         /* Test if we are going over 2GB of DMA space */
         if (phb->dma_window_base_cur + phb->dma_window_size > 0x80000000ul) {
                 udbg_printf("PCI_DMA: Unexpected number of IOAs under this PHB.\n");
-                panic("PCI_DMA: Unexpected number of IOAs under this PHB.\n"); 
+                panic("PCI_DMA: Unexpected number of IOAs under this PHB.\n");
         }
-        
+
         phb->dma_window_base_cur += phb->dma_window_size;
 
         /* Set the tce table size - measured in entries */
@@ -299,30 +281,22 @@ static void iommu_table_setparms(struct pci_controller *phb,
  * iommu_table_setparms_lpar
  *
  * Function: On pSeries LPAR systems, return TCE table info, given a pci bus.
- *
- * ToDo: properly interpret the ibm,dma-window property.  The definition is:
- *      logical-bus-number      (1 word)
- *      phys-address            (#address-cells words)
- *      size                    (#cell-size words)
- *
- * Currently we hard code these sizes (more or less).
  */
 static void iommu_table_setparms_lpar(struct pci_controller *phb,
                                       struct device_node *dn,
                                       struct iommu_table *tbl,
-                                      unsigned int *dma_window)
+                                      unsigned char *dma_window)
 {
+        unsigned long offset, size;
+
         tbl->it_busno  = PCI_DN(dn)->bussubno;
+        of_parse_dma_window(dn, dma_window, &tbl->it_index, &offset, &size);
 
-        /* TODO: Parse field size properties properly. */
-        tbl->it_size   = (((unsigned long)dma_window[4] << 32) |
-                           (unsigned long)dma_window[5]) >> PAGE_SHIFT;
-        tbl->it_offset = (((unsigned long)dma_window[2] << 32) |
-                           (unsigned long)dma_window[3]) >> PAGE_SHIFT;
         tbl->it_base   = 0;
-        tbl->it_index  = dma_window[0];
         tbl->it_blocksize  = 16;
         tbl->it_type = TCE_PCI;
+        tbl->it_offset = offset >> PAGE_SHIFT;
+        tbl->it_size = size >> PAGE_SHIFT;
 }
 
 static void iommu_bus_setup_pSeries(struct pci_bus *bus)
@@ -414,7 +388,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
         struct iommu_table *tbl;
         struct device_node *dn, *pdn;
         struct pci_dn *ppci;
-        unsigned int *dma_window = NULL;
+        unsigned char *dma_window = NULL;
 
         DBG("iommu_bus_setup_pSeriesLP, bus %p, bus->self %p\n", bus, bus->self);
 
@@ -422,7 +396,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
 
         /* Find nearest ibm,dma-window, walking up the device tree */
         for (pdn = dn; pdn != NULL; pdn = pdn->parent) {
-                dma_window = (unsigned int *)get_property(pdn, "ibm,dma-window", NULL);
+                dma_window = get_property(pdn, "ibm,dma-window", NULL);
                 if (dma_window != NULL)
                         break;
         }
@@ -442,7 +416,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
 
                 tbl = (struct iommu_table *)kmalloc(sizeof(struct iommu_table),
                                                     GFP_KERNEL);
-        
+
                 iommu_table_setparms_lpar(ppci->phb, pdn, tbl, dma_window);
 
                 ppci->iommu_table = iommu_init_table(tbl);
@@ -516,7 +490,7 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
 {
         struct device_node *pdn, *dn;
         struct iommu_table *tbl;
-        int *dma_window = NULL;
+        unsigned char *dma_window = NULL;
         struct pci_dn *pci;
 
         DBG("iommu_dev_setup_pSeriesLP, dev %p (%s)\n", dev, pci_name(dev));
@@ -531,8 +505,7 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
 
         for (pdn = dn; pdn && PCI_DN(pdn) && !PCI_DN(pdn)->iommu_table;
              pdn = pdn->parent) {
-                dma_window = (unsigned int *)
-                        get_property(pdn, "ibm,dma-window", NULL);
+                dma_window = get_property(pdn, "ibm,dma-window", NULL);
                 if (dma_window)
                         break;
         }
diff --git a/arch/powerpc/platforms/pseries/rtasd.c b/arch/powerpc/platforms/pseries/rtasd.c
index e0000ce769e5..2e4e04042d85 100644
--- a/arch/powerpc/platforms/pseries/rtasd.c
+++ b/arch/powerpc/platforms/pseries/rtasd.c
@@ -348,7 +348,7 @@ static int enable_surveillance(int timeout)
                 return 0;
 
         if (error == -EINVAL) {
-                printk(KERN_INFO "rtasd: surveillance not supported\n");
+                printk(KERN_DEBUG "rtasd: surveillance not supported\n");
                 return 0;
         }
 
@@ -440,7 +440,7 @@ static int rtasd(void *unused)
                 goto error;
         }
 
-        printk(KERN_INFO "RTAS daemon started\n");
+        printk(KERN_DEBUG "RTAS daemon started\n");
 
         DEBUG("will sleep for %d milliseconds\n", (30000/rtas_event_scan_rate));
 
@@ -487,7 +487,7 @@ static int __init rtas_init(void)
 
         /* No RTAS */
         if (rtas_token("event-scan") == RTAS_UNKNOWN_SERVICE) {
-                printk(KERN_INFO "rtasd: no event-scan on system\n");
+                printk(KERN_DEBUG "rtasd: no event-scan on system\n");
                 return -ENODEV;
         }
 
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index 5f79f01c44f2..ee89d19c436a 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -235,14 +235,14 @@ static void __init pSeries_setup_arch(void)
         if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
                 vpa_init(boot_cpuid);
                 if (get_lppaca()->shared_proc) {
-                        printk(KERN_INFO "Using shared processor idle loop\n");
+                        printk(KERN_DEBUG "Using shared processor idle loop\n");
                         ppc_md.power_save = pseries_shared_idle_sleep;
                 } else {
-                        printk(KERN_INFO "Using dedicated idle loop\n");
+                        printk(KERN_DEBUG "Using dedicated idle loop\n");
                         ppc_md.power_save = pseries_dedicated_idle_sleep;
                 }
         } else {
-                printk(KERN_INFO "Using default idle loop\n");
+                printk(KERN_DEBUG "Using default idle loop\n");
         }
 
         if (firmware_has_feature(FW_FEATURE_LPAR))
diff --git a/arch/powerpc/platforms/pseries/vio.c b/arch/powerpc/platforms/pseries/vio.c
deleted file mode 100644
index 8e53e04ada8b..000000000000
--- a/arch/powerpc/platforms/pseries/vio.c
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * IBM PowerPC pSeries Virtual I/O Infrastructure Support.
- *
- *    Copyright (c) 2003-2005 IBM Corp.
- *     Dave Engebretsen engebret@us.ibm.com
- *     Santiago Leon santil@us.ibm.com
- *     Hollis Blanchard <hollisb@us.ibm.com>
- *     Stephen Rothwell
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/kobject.h>
-#include <asm/iommu.h>
-#include <asm/dma.h>
-#include <asm/prom.h>
-#include <asm/vio.h>
-#include <asm/hvcall.h>
-#include <asm/tce.h>
-
-extern struct subsystem devices_subsys; /* needed for vio_find_name() */
-
-static void probe_bus_pseries(void)
-{
-        struct device_node *node_vroot, *of_node;
-
-        node_vroot = find_devices("vdevice");
-        if ((node_vroot == NULL) || (node_vroot->child == NULL))
-                /* this machine doesn't do virtual IO, and that's ok */
-                return;
-
-        /*
-         * Create struct vio_devices for each virtual device in the device tree.
-         * Drivers will associate with them later.
-         */
-        for (of_node = node_vroot->child; of_node != NULL;
-                        of_node = of_node->sibling) {
-                printk(KERN_DEBUG "%s: processing %p\n", __FUNCTION__, of_node);
-                vio_register_device_node(of_node);
-        }
-}
-
-/**
- * vio_match_device_pseries: - Tell if a pSeries VIO device matches a
- *      vio_device_id
- */
-static int vio_match_device_pseries(const struct vio_device_id *id,
-                const struct vio_dev *dev)
-{
-        return (strncmp(dev->type, id->type, strlen(id->type)) == 0) &&
-                        device_is_compatible(dev->dev.platform_data, id->compat);
-}
-
-static void vio_release_device_pseries(struct device *dev)
-{
-        /* XXX free TCE table */
-        of_node_put(dev->platform_data);
-}
-
-static ssize_t viodev_show_devspec(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct device_node *of_node = dev->platform_data;
-
-        return sprintf(buf, "%s\n", of_node->full_name);
-}
-DEVICE_ATTR(devspec, S_IRUSR | S_IRGRP | S_IROTH, viodev_show_devspec, NULL);
-
-static void vio_unregister_device_pseries(struct vio_dev *viodev)
-{
-        device_remove_file(&viodev->dev, &dev_attr_devspec);
-}
-
-static struct vio_bus_ops vio_bus_ops_pseries = {
-        .match = vio_match_device_pseries,
-        .unregister_device = vio_unregister_device_pseries,
-        .release_device = vio_release_device_pseries,
-};
-
-/**
- * vio_bus_init_pseries: - Initialize the pSeries virtual IO bus
- */
-static int __init vio_bus_init_pseries(void)
-{
-        int err;
-
-        err = vio_bus_init(&vio_bus_ops_pseries);
-        if (err == 0)
-                probe_bus_pseries();
-        return err;
-}
-
-__initcall(vio_bus_init_pseries);
-
-/**
- * vio_build_iommu_table: - gets the dma information from OF and
- *      builds the TCE tree.
- * @dev: the virtual device.
- *
- * Returns a pointer to the built tce tree, or NULL if it can't
- * find property.
-*/
-static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
-{
-        unsigned int *dma_window;
-        struct iommu_table *newTceTable;
-        unsigned long offset;
-        int dma_window_property_size;
-
-        dma_window = (unsigned int *) get_property(dev->dev.platform_data, "ibm,my-dma-window", &dma_window_property_size);
-        if(!dma_window) {
-                return NULL;
-        }
-
-        newTceTable = (struct iommu_table *) kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
-
-        /*  There should be some code to extract the phys-encoded offset
-                using prom_n_addr_cells(). However, according to a comment
-                on earlier versions, it's always zero, so we don't bother */
-        offset = dma_window[1] >>  PAGE_SHIFT;
-
-        /* TCE table size - measured in tce entries */
-        newTceTable->it_size            = dma_window[4] >> PAGE_SHIFT;
-        /* offset for VIO should always be 0 */
-        newTceTable->it_offset          = offset;
-        newTceTable->it_busno           = 0;
-        newTceTable->it_index           = (unsigned long)dma_window[0];
-        newTceTable->it_type            = TCE_VB;
-
-        return iommu_init_table(newTceTable);
-}
-
-/**
- * vio_register_device_node: - Register a new vio device.
- * @of_node:    The OF node for this device.
- *
- * Creates and initializes a vio_dev structure from the data in
- * of_node (dev.platform_data) and adds it to the list of virtual devices.
- * Returns a pointer to the created vio_dev or NULL if node has
- * NULL device_type or compatible fields.
- */
-struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
-{
-        struct vio_dev *viodev;
-        unsigned int *unit_address;
-        unsigned int *irq_p;
-
-        /* we need the 'device_type' property, in order to match with drivers */
-        if ((NULL == of_node->type)) {
-                printk(KERN_WARNING
-                        "%s: node %s missing 'device_type'\n", __FUNCTION__,
-                        of_node->name ? of_node->name : "<unknown>");
-                return NULL;
-        }
-
-        unit_address = (unsigned int *)get_property(of_node, "reg", NULL);
-        if (!unit_address) {
-                printk(KERN_WARNING "%s: node %s missing 'reg'\n", __FUNCTION__,
-                        of_node->name ? of_node->name : "<unknown>");
-                return NULL;
-        }
-
-        /* allocate a vio_dev for this node */
-        viodev = kmalloc(sizeof(struct vio_dev), GFP_KERNEL);
-        if (!viodev) {
-                return NULL;
-        }
-        memset(viodev, 0, sizeof(struct vio_dev));
-
-        viodev->dev.platform_data = of_node_get(of_node);
-
-        viodev->irq = NO_IRQ;
-        irq_p = (unsigned int *)get_property(of_node, "interrupts", NULL);
-        if (irq_p) {
-                int virq = virt_irq_create_mapping(*irq_p);
-                if (virq == NO_IRQ) {
-                        printk(KERN_ERR "Unable to allocate interrupt "
-                               "number for %s\n", of_node->full_name);
-                } else
-                        viodev->irq = irq_offset_up(virq);
-        }
-
-        snprintf(viodev->dev.bus_id, BUS_ID_SIZE, "%x", *unit_address);
-        viodev->name = of_node->name;
-        viodev->type = of_node->type;
-        viodev->unit_address = *unit_address;
-        viodev->iommu_table = vio_build_iommu_table(viodev);
-
-        /* register with generic device framework */
-        if (vio_register_device(viodev) == NULL) {
-                /* XXX free TCE table */
-                kfree(viodev);
-                return NULL;
-        }
-        device_create_file(&viodev->dev, &dev_attr_devspec);
-
-        return viodev;
-}
-EXPORT_SYMBOL(vio_register_device_node);
-
-/**
- * vio_get_attribute: - get attribute for virtual device
- * @vdev:       The vio device to get property.
- * @which:      The property/attribute to be extracted.
- * @length:     Pointer to length of returned data size (unused if NULL).
- *
- * Calls prom.c's get_property() to return the value of the
- * attribute specified by the preprocessor constant @which
-*/
-const void * vio_get_attribute(struct vio_dev *vdev, void* which, int* length)
-{
-        return get_property(vdev->dev.platform_data, (char*)which, length);
-}
-EXPORT_SYMBOL(vio_get_attribute);
-
-/* vio_find_name() - internal because only vio.c knows how we formatted the
- * kobject name
- * XXX once vio_bus_type.devices is actually used as a kset in
- * drivers/base/bus.c, this function should be removed in favor of
- * "device_find(kobj_name, &vio_bus_type)"
- */
-static struct vio_dev *vio_find_name(const char *kobj_name)
-{
-        struct kobject *found;
-
-        found = kset_find_obj(&devices_subsys.kset, kobj_name);
-        if (!found)
-                return NULL;
-
-        return to_vio_dev(container_of(found, struct device, kobj));
-}
-
-/**
- * vio_find_node - find an already-registered vio_dev
- * @vnode: device_node of the virtual device we're looking for
- */
-struct vio_dev *vio_find_node(struct device_node *vnode)
-{
-        uint32_t *unit_address;
-        char kobj_name[BUS_ID_SIZE];
-
-        /* construct the kobject name from the device node */
-        unit_address = (uint32_t *)get_property(vnode, "reg", NULL);
-        if (!unit_address)
-                return NULL;
-        snprintf(kobj_name, BUS_ID_SIZE, "%x", *unit_address);
-
-        return vio_find_name(kobj_name);
-}
-EXPORT_SYMBOL(vio_find_node);
-
-int vio_enable_interrupts(struct vio_dev *dev)
-{
-        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_ENABLE);
-        if (rc != H_SUCCESS)
-                printk(KERN_ERR "vio: Error 0x%x enabling interrupts\n", rc);
-        return rc;
-}
-EXPORT_SYMBOL(vio_enable_interrupts);
-
-int vio_disable_interrupts(struct vio_dev *dev)
-{
-        int rc = h_vio_signal(dev->unit_address, VIO_IRQ_DISABLE);
-        if (rc != H_SUCCESS)
-                printk(KERN_ERR "vio: Error 0x%x disabling interrupts\n", rc);
-        return rc;
-}
-EXPORT_SYMBOL(vio_disable_interrupts);
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index 2d60ea30fed6..b14f9b5c114e 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -522,7 +522,7 @@ nextnode:
 
         np = of_find_node_by_type(NULL, "interrupt-controller");
         if (!np) {
-                printk(KERN_WARNING "xics: no ISA interrupt controller\n");
+                printk(KERN_DEBUG "xics: no ISA interrupt controller\n");
                 xics_irq_8259_cascade_real = -1;
                 xics_irq_8259_cascade = -1;
         } else {
@@ -641,23 +641,26 @@ void xics_teardown_cpu(int secondary)
         ops->cppr_info(cpu, 0x00);
         iosync();
 
+        /* Clear IPI */
+        ops->qirr_info(cpu, 0xff);
+
+        /*
+         * we need to EOI the IPI if we got here from kexec down IPI
+         *
+         * probably need to check all the other interrupts too
+         * should we be flagging idle loop instead?
+         * or creating some task to be scheduled?
+         */
+        ops->xirr_info_set(cpu, XICS_IPI);
+
         /*
          * Some machines need to have at least one cpu in the GIQ,
          * so leave the master cpu in the group.
          */
-        if (secondary) {
-                /*
-                 * we need to EOI the IPI if we got here from kexec down IPI
-                 *
-                 * probably need to check all the other interrupts too
-                 * should we be flagging idle loop instead?
-                 * or creating some task to be scheduled?
-                 */
-                ops->xirr_info_set(cpu, XICS_IPI);
+        if (secondary)
                 rtas_set_indicator(GLOBAL_INTERRUPT_QUEUE,
                         (1UL << interrupt_server_size) - 1 -
                         default_distrib_server, 0);
-        }
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
diff --git a/arch/ppc/Kconfig b/arch/ppc/Kconfig
index e9a8f5d1dfcd..b55de4f42aec 100644
--- a/arch/ppc/Kconfig
+++ b/arch/ppc/Kconfig
@@ -40,6 +40,10 @@ config GENERIC_NVRAM
         bool
         default y
 
+config GENERIC_FIND_NEXT_BIT
+        bool
+        default y
+
 config SCHED_NO_NO_OMIT_FRAME_POINTER
         bool
         default y