Merge commit 'v2.6.29-rc1' into core/urgent

author: Ingo Molnar <mingo@elte.hu> 2009-01-10 21:41:39 -0500
committer: Ingo Molnar <mingo@elte.hu> 2009-01-10 21:41:39 -0500
commit: abede81c4fb2e3b85d8760f25e3da39d2c69a134 (patch)
tree: 26c893ec108d837eb9171d678c55a1cea7b22af4 /arch
parent: c9d557c19f94df42db78d4a5de4d25feee694bad (diff)
parent: c59765042f53a79a7a65585042ff463b69cb248c (diff)
293 files changed, 4107 insertions, 2877 deletions
diff --git a/arch/alpha/kernel/pci.c b/arch/alpha/kernel/pci.c
index ff8cb638472e..a3b938811400 100644
--- a/arch/alpha/kernel/pci.c
+++ b/arch/alpha/kernel/pci.c
@@ -320,24 +320,6 @@ pcibios_update_irq(struct pci_dev *dev, int irq)
        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
 }
-/* Most Alphas have straight-forward swizzling needs.  */
-u8 __init
-common_swizzle(struct pci_dev *dev, u8 *pinp)
-{
-        u8 pin = *pinp;
-        while (dev->bus->parent) {
-                pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
-                /* Move up the chain of bridges. */
-                dev = dev->bus->self;
-        }
-        *pinp = pin;
-        /* The slot is the slot of the last bridge. */
-        return PCI_SLOT(dev->devfn);
-}
 void
 pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
                         struct resource *res)
diff --git a/arch/alpha/kernel/pci_impl.h b/arch/alpha/kernel/pci_impl.h
index f8b74995a002..00edd04b585e 100644
--- a/arch/alpha/kernel/pci_impl.h
+++ b/arch/alpha/kernel/pci_impl.h
@@ -106,16 +106,11 @@ struct pci_iommu_arena;
 *   Where A = pin 1, B = pin 2 and so on and pin=0 = default = A.
 *   Thus, each swizzle is ((pin-1) + (device#-4)) % 4
 *
- *   The following code swizzles for exactly one bridge.  The routine
+ *   pci_swizzle_interrupt_pin() swizzles for exactly one bridge.  The routine
- *   common_swizzle below handles multiple bridges.  But there are a
+ *   pci_common_swizzle() handles multiple bridges.  But there are a
- *   couple boards that do strange things, so we define this here.
+ *   couple boards that do strange things.
 */
-static inline u8 bridge_swizzle(u8 pin, u8 slot) 
-{
-        return (((pin-1) + slot) % 4) + 1;
-}
 /* The following macro is used to implement the table-based irq mapping
   function for all single-bus Alphas.  */
@@ -184,7 +179,7 @@ extern int pci_probe_only;
 extern unsigned long alpha_agpgart_size;
 extern void common_init_pci(void);
-extern u8 common_swizzle(struct pci_dev *, u8 *);
+#define common_swizzle pci_common_swizzle
 extern struct pci_controller *alloc_pci_controller(void);
 extern struct resource *alloc_resource(void);
diff --git a/arch/alpha/kernel/sys_dp264.c b/arch/alpha/kernel/sys_dp264.c
index ab44c164d9d4..9c9d1fd4155f 100644
--- a/arch/alpha/kernel/sys_dp264.c
+++ b/arch/alpha/kernel/sys_dp264.c
@@ -481,7 +481,7 @@ monet_swizzle(struct pci_dev *dev, u8 *pinp)
                                slot = PCI_SLOT(dev->devfn);
                                break;
                        }
-                        pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn)) ;
+                        pin = pci_swizzle_interrupt_pin(dev, pin);
                        /* Move up the chain of bridges.  */
                        dev = dev->bus->self;
diff --git a/arch/alpha/kernel/sys_eiger.c b/arch/alpha/kernel/sys_eiger.c
index 7ef3b6fb3700..baf60f36cbd7 100644
--- a/arch/alpha/kernel/sys_eiger.c
+++ b/arch/alpha/kernel/sys_eiger.c
@@ -204,7 +204,7 @@ eiger_swizzle(struct pci_dev *dev, u8 *pinp)
                        break;
                }
                /* Must be a card-based bridge.  */
-                pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
+                pin = pci_swizzle_interrupt_pin(dev, pin);
                /* Move up the chain of bridges.  */
                dev = dev->bus->self;
diff --git a/arch/alpha/kernel/sys_miata.c b/arch/alpha/kernel/sys_miata.c
index 910b43cd63e8..61ccd95579ec 100644
--- a/arch/alpha/kernel/sys_miata.c
+++ b/arch/alpha/kernel/sys_miata.c
@@ -219,7 +219,7 @@ miata_swizzle(struct pci_dev *dev, u8 *pinp)
                                slot = PCI_SLOT(dev->devfn) + 9;
                                break;
                        }
-                        pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
+                        pin = pci_swizzle_interrupt_pin(dev, pin);
                        /* Move up the chain of bridges.  */
                        dev = dev->bus->self;
diff --git a/arch/alpha/kernel/sys_noritake.c b/arch/alpha/kernel/sys_noritake.c
index eb2a1d63f484..538876b62449 100644
--- a/arch/alpha/kernel/sys_noritake.c
+++ b/arch/alpha/kernel/sys_noritake.c
@@ -257,7 +257,7 @@ noritake_swizzle(struct pci_dev *dev, u8 *pinp)
                                slot = PCI_SLOT(dev->devfn) + 15;
                                break;
                        }
-                        pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn)) ;
+                        pin = pci_swizzle_interrupt_pin(dev, pin);
                        /* Move up the chain of bridges.  */
                        dev = dev->bus->self;
diff --git a/arch/alpha/kernel/sys_ruffian.c b/arch/alpha/kernel/sys_ruffian.c
index 5b99cf3cd69c..f15a329b6011 100644
--- a/arch/alpha/kernel/sys_ruffian.c
+++ b/arch/alpha/kernel/sys_ruffian.c
@@ -160,7 +160,7 @@ ruffian_swizzle(struct pci_dev *dev, u8 *pinp)
                                slot = PCI_SLOT(dev->devfn) + 10;
                                break;
                        }
-                        pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
+                        pin = pci_swizzle_interrupt_pin(dev, pin);
                        /* Move up the chain of bridges.  */
                        dev = dev->bus->self;
diff --git a/arch/alpha/kernel/sys_sable.c b/arch/alpha/kernel/sys_sable.c
index a4555f497639..d232e42be018 100644
--- a/arch/alpha/kernel/sys_sable.c
+++ b/arch/alpha/kernel/sys_sable.c
@@ -425,7 +425,7 @@ lynx_swizzle(struct pci_dev *dev, u8 *pinp)
                                slot = PCI_SLOT(dev->devfn) + 11;
                                break;
                        }
-                        pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn)) ;
+                        pin = pci_swizzle_interrupt_pin(dev, pin);
                        /* Move up the chain of bridges.  */
                        dev = dev->bus->self;
diff --git a/arch/arm/configs/clps7500_defconfig b/arch/arm/configs/clps7500_defconfig
deleted file mode 100644
index 49e9f9d8b3d1..000000000000
--- a/arch/arm/configs/clps7500_defconfig
+++ /dev/null
@@ -1,801 +0,0 @@
-#
-# Automatically generated make config: don't edit
-# Linux kernel version: 2.6.12-rc1-bk2
-# Sun Mar 27 17:20:48 2005
-#
-CONFIG_ARM=y
-CONFIG_MMU=y
-CONFIG_UID16=y
-CONFIG_RWSEM_GENERIC_SPINLOCK=y
-CONFIG_GENERIC_CALIBRATE_DELAY=y
-CONFIG_GENERIC_IOMAP=y
-#
-# Code maturity level options
-#
-CONFIG_EXPERIMENTAL=y
-CONFIG_CLEAN_COMPILE=y
-CONFIG_BROKEN_ON_SMP=y
-#
-# General setup
-#
-CONFIG_LOCALVERSION=""
-CONFIG_SWAP=y
-CONFIG_SYSVIPC=y
-# CONFIG_POSIX_MQUEUE is not set
-# CONFIG_BSD_PROCESS_ACCT is not set
-# CONFIG_SYSCTL is not set
-# CONFIG_AUDIT is not set
-# CONFIG_HOTPLUG is not set
-CONFIG_KOBJECT_UEVENT=y
-# CONFIG_IKCONFIG is not set
-CONFIG_EMBEDDED=y
-CONFIG_KALLSYMS=y
-# CONFIG_KALLSYMS_EXTRA_PASS is not set
-CONFIG_BASE_FULL=y
-CONFIG_FUTEX=y
-CONFIG_EPOLL=y
-CONFIG_CC_OPTIMIZE_FOR_SIZE=y
-CONFIG_SHMEM=y
-CONFIG_CC_ALIGN_FUNCTIONS=0
-CONFIG_CC_ALIGN_LABELS=0
-CONFIG_CC_ALIGN_LOOPS=0
-CONFIG_CC_ALIGN_JUMPS=0
-# CONFIG_TINY_SHMEM is not set
-CONFIG_BASE_SMALL=0
-#
-# Loadable module support
-#
-# CONFIG_MODULES is not set
-#
-# System Type
-#
-CONFIG_ARCH_CLPS7500=y
-# CONFIG_ARCH_CLPS711X is not set
-# CONFIG_ARCH_CO285 is not set
-# CONFIG_ARCH_EBSA110 is not set
-# CONFIG_ARCH_FOOTBRIDGE is not set
-# CONFIG_ARCH_INTEGRATOR is not set
-# CONFIG_ARCH_IOP3XX is not set
-# CONFIG_ARCH_IXP4XX is not set
-# CONFIG_ARCH_IXP2000 is not set
-# CONFIG_ARCH_L7200 is not set
-# CONFIG_ARCH_PXA is not set
-# CONFIG_ARCH_RPC is not set
-# CONFIG_ARCH_SA1100 is not set
-# CONFIG_ARCH_S3C2410 is not set
-# CONFIG_ARCH_SHARK is not set
-# CONFIG_ARCH_LH7A40X is not set
-# CONFIG_ARCH_OMAP is not set
-# CONFIG_ARCH_VERSATILE is not set
-# CONFIG_ARCH_IMX is not set
-# CONFIG_ARCH_H720X is not set
-#
-# Processor Type
-#
-CONFIG_CPU_32=y
-CONFIG_CPU_ARM710=y
-CONFIG_CPU_32v3=y
-CONFIG_CPU_CACHE_V3=y
-CONFIG_CPU_CACHE_VIVT=y
-CONFIG_CPU_COPY_V3=y
-CONFIG_CPU_TLB_V3=y
-#
-# Processor Features
-#
-CONFIG_TIMER_ACORN=y
-#
-# Bus support
-#
-CONFIG_ISA=y
-#
-# PCCARD (PCMCIA/CardBus) support
-#
-# CONFIG_PCCARD is not set
-#
-# Kernel Features
-#
-# CONFIG_PREEMPT is not set
-CONFIG_ALIGNMENT_TRAP=y
-#
-# Boot options
-#
-CONFIG_ZBOOT_ROM_TEXT=0x0
-CONFIG_ZBOOT_ROM_BSS=0x0
-CONFIG_CMDLINE="mem=16M root=nfs"
-# CONFIG_XIP_KERNEL is not set
-#
-# Floating point emulation
-#
-#
-# At least one emulation must be selected
-#
-# CONFIG_FPE_NWFPE is not set
-#
-# Userspace binary formats
-#
-CONFIG_BINFMT_ELF=y
-# CONFIG_BINFMT_AOUT is not set
-# CONFIG_BINFMT_MISC is not set
-# CONFIG_ARTHUR is not set
-#
-# Power management options
-#
-# CONFIG_PM is not set
-#
-# Device Drivers
-#
-#
-# Generic Driver Options
-#
-CONFIG_STANDALONE=y
-CONFIG_PREVENT_FIRMWARE_BUILD=y
-# CONFIG_FW_LOADER is not set
-#
-# Memory Technology Devices (MTD)
-#
-CONFIG_MTD=y
-# CONFIG_MTD_DEBUG is not set
-# CONFIG_MTD_CONCAT is not set
-# CONFIG_MTD_PARTITIONS is not set
-#
-# User Modules And Translation Layers
-#
-# CONFIG_MTD_CHAR is not set
-# CONFIG_MTD_BLOCK is not set
-# CONFIG_MTD_BLOCK_RO is not set
-# CONFIG_FTL is not set
-# CONFIG_NFTL is not set
-# CONFIG_INFTL is not set
-#
-# RAM/ROM/Flash chip drivers
-#
-# CONFIG_MTD_CFI is not set
-# CONFIG_MTD_JEDECPROBE is not set
-CONFIG_MTD_MAP_BANK_WIDTH_1=y
-CONFIG_MTD_MAP_BANK_WIDTH_2=y
-CONFIG_MTD_MAP_BANK_WIDTH_4=y
-# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
-# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
-# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
-CONFIG_MTD_CFI_I1=y
-CONFIG_MTD_CFI_I2=y
-# CONFIG_MTD_CFI_I4 is not set
-# CONFIG_MTD_CFI_I8 is not set
-# CONFIG_MTD_RAM is not set
-# CONFIG_MTD_ROM is not set
-# CONFIG_MTD_ABSENT is not set
-#
-# Mapping drivers for chip access
-#
-# CONFIG_MTD_COMPLEX_MAPPINGS is not set
-#
-# Self-contained MTD device drivers
-#
-# CONFIG_MTD_SLRAM is not set
-# CONFIG_MTD_PHRAM is not set
-# CONFIG_MTD_MTDRAM is not set
-# CONFIG_MTD_BLKMTD is not set
-# CONFIG_MTD_BLOCK2MTD is not set
-#
-# Disk-On-Chip Device Drivers
-#
-# CONFIG_MTD_DOC2000 is not set
-# CONFIG_MTD_DOC2001 is not set
-# CONFIG_MTD_DOC2001PLUS is not set
-#
-# NAND Flash Device Drivers
-#
-# CONFIG_MTD_NAND is not set
-#
-# Parallel port support
-#
-CONFIG_PARPORT=y
-CONFIG_PARPORT_PC=y
-CONFIG_PARPORT_PC_FIFO=y
-# CONFIG_PARPORT_PC_SUPERIO is not set
-# CONFIG_PARPORT_ARC is not set
-# CONFIG_PARPORT_GSC is not set
-CONFIG_PARPORT_1284=y
-#
-# Plug and Play support
-#
-# CONFIG_PNP is not set
-#
-# Block devices
-#
-# CONFIG_BLK_DEV_FD is not set
-# CONFIG_BLK_DEV_XD is not set
-# CONFIG_PARIDE is not set
-# CONFIG_BLK_DEV_COW_COMMON is not set
-# CONFIG_BLK_DEV_LOOP is not set
-CONFIG_BLK_DEV_NBD=y
-CONFIG_BLK_DEV_RAM=y
-CONFIG_BLK_DEV_RAM_COUNT=16
-CONFIG_BLK_DEV_RAM_SIZE=4096
-# CONFIG_BLK_DEV_INITRD is not set
-CONFIG_INITRAMFS_SOURCE=""
-# CONFIG_CDROM_PKTCDVD is not set
-#
-# IO Schedulers
-#
-CONFIG_IOSCHED_NOOP=y
-CONFIG_IOSCHED_AS=y
-CONFIG_IOSCHED_DEADLINE=y
-CONFIG_IOSCHED_CFQ=y
-# CONFIG_ATA_OVER_ETH is not set
-#
-# ATA/ATAPI/MFM/RLL support
-#
-# CONFIG_IDE is not set
-#
-# SCSI device support
-#
-# CONFIG_SCSI is not set
-#
-# Multi-device support (RAID and LVM)
-#
-# CONFIG_MD is not set
-#
-# Fusion MPT device support
-#
-#
-# IEEE 1394 (FireWire) support
-#
-#
-# I2O device support
-#
-#
-# Networking support
-#
-CONFIG_NET=y
-#
-# Networking options
-#
-# CONFIG_PACKET is not set
-# CONFIG_NETLINK_DEV is not set
-CONFIG_UNIX=y
-# CONFIG_NET_KEY is not set
-CONFIG_INET=y
-# CONFIG_IP_MULTICAST is not set
-# CONFIG_IP_ADVANCED_ROUTER is not set
-CONFIG_IP_PNP=y
-# CONFIG_IP_PNP_DHCP is not set
-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_ARPD is not set
-# CONFIG_SYN_COOKIES is not set
-# CONFIG_INET_AH is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-CONFIG_IP_TCPDIAG=y
-# CONFIG_IP_TCPDIAG_IPV6 is not set
-# CONFIG_IPV6 is not set
-# CONFIG_NETFILTER is not set
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
-# CONFIG_IP_SCTP 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
-# CONFIG_NET_CLS_ROUTE is not set
-#
-# Network testing
-#
-# CONFIG_NET_PKTGEN is not set
-# CONFIG_NETPOLL is not set
-# CONFIG_NET_POLL_CONTROLLER is not set
-# CONFIG_HAMRADIO is not set
-# CONFIG_IRDA is not set
-# CONFIG_BT is not set
-CONFIG_NETDEVICES=y
-CONFIG_DUMMY=y
-# CONFIG_BONDING is not set
-# CONFIG_EQUALIZER is not set
-# CONFIG_TUN is not set
-#
-# ARCnet devices
-#
-# CONFIG_ARCNET is not set
-#
-# Ethernet (10 or 100Mbit)
-#
-CONFIG_NET_ETHERNET=y
-# CONFIG_MII is not set
-# CONFIG_NET_VENDOR_3COM is not set
-# CONFIG_LANCE is not set
-# CONFIG_NET_VENDOR_SMC is not set
-# CONFIG_SMC91X is not set
-# CONFIG_NET_VENDOR_RACAL is not set
-# CONFIG_AT1700 is not set
-# CONFIG_DEPCA is not set
-# CONFIG_HP100 is not set
-# CONFIG_NET_ISA is not set
-CONFIG_NET_PCI=y
-# CONFIG_AC3200 is not set
-# CONFIG_APRICOT is not set
-CONFIG_CS89x0=y
-# CONFIG_NET_POCKET is not set
-#
-# Ethernet (1000 Mbit)
-#
-#
-# Ethernet (10000 Mbit)
-#
-#
-# 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_PLIP is not set
-CONFIG_PPP=y
-# CONFIG_PPP_MULTILINK is not set
-# CONFIG_PPP_FILTER is not set
-# CONFIG_PPP_ASYNC is not set
-# CONFIG_PPP_SYNC_TTY is not set
-# CONFIG_PPP_DEFLATE is not set
-# CONFIG_PPP_BSDCOMP is not set
-# CONFIG_PPPOE is not set
-CONFIG_SLIP=y
-CONFIG_SLIP_COMPRESSED=y
-# CONFIG_SLIP_SMART is not set
-# CONFIG_SLIP_MODE_SLIP6 is not set
-# CONFIG_SHAPER is not set
-# CONFIG_NETCONSOLE is not set
-#
-# ISDN subsystem
-#
-# CONFIG_ISDN is not set
-#
-# Input device support
-#
-CONFIG_INPUT=y
-#
-# Userland interfaces
-#
-CONFIG_INPUT_MOUSEDEV=y
-CONFIG_INPUT_MOUSEDEV_PSAUX=y
-CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
-CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
-# 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=y
-CONFIG_KEYBOARD_ATKBD=y
-# CONFIG_KEYBOARD_SUNKBD is not set
-# CONFIG_KEYBOARD_LKKBD is not set
-# CONFIG_KEYBOARD_XTKBD is not set
-# CONFIG_KEYBOARD_NEWTON is not set
-CONFIG_INPUT_MOUSE=y
-CONFIG_MOUSE_PS2=y
-# CONFIG_MOUSE_SERIAL is not set
-# CONFIG_MOUSE_INPORT is not set
-# CONFIG_MOUSE_LOGIBM is not set
-# CONFIG_MOUSE_PC110PAD is not set
-# CONFIG_MOUSE_VSXXXAA 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=y
-# CONFIG_SERIO_SERPORT is not set
-# CONFIG_SERIO_PARKBD is not set
-CONFIG_SERIO_RPCKBD=y
-CONFIG_SERIO_LIBPS2=y
-# CONFIG_SERIO_RAW is not set
-# CONFIG_GAMEPORT is not set
-CONFIG_SOUND_GAMEPORT=y
-#
-# Character devices
-#
-CONFIG_VT=y
-CONFIG_VT_CONSOLE=y
-CONFIG_HW_CONSOLE=y
-# CONFIG_SERIAL_NONSTANDARD is not set
-#
-# Serial drivers
-#
-CONFIG_SERIAL_8250=y
-CONFIG_SERIAL_8250_CONSOLE=y
-CONFIG_SERIAL_8250_NR_UARTS=4
-# CONFIG_SERIAL_8250_EXTENDED is not set
-#
-# Non-8250 serial port support
-#
-CONFIG_SERIAL_CORE=y
-CONFIG_SERIAL_CORE_CONSOLE=y
-CONFIG_UNIX98_PTYS=y
-CONFIG_LEGACY_PTYS=y
-CONFIG_LEGACY_PTY_COUNT=256
-CONFIG_PRINTER=y
-# CONFIG_LP_CONSOLE is not set
-# CONFIG_PPDEV is not set
-# CONFIG_TIPAR is not set
-#
-# IPMI
-#
-# CONFIG_IPMI_HANDLER is not set
-#
-# Watchdog Cards
-#
-# CONFIG_WATCHDOG is not set
-# CONFIG_NVRAM is not set
-# CONFIG_RTC is not set
-# CONFIG_DTLK is not set
-# CONFIG_R3964 is not set
-#
-# Ftape, the floppy tape device driver
-#
-# CONFIG_DRM is not set
-# CONFIG_RAW_DRIVER is not set
-#
-# TPM devices
-#
-# CONFIG_TCG_TPM is not set
-#
-# I2C support
-#
-CONFIG_I2C=y
-# CONFIG_I2C_CHARDEV is not set
-#
-# I2C Algorithms
-#
-CONFIG_I2C_ALGOBIT=y
-# CONFIG_I2C_ALGOPCF is not set
-# CONFIG_I2C_ALGOPCA is not set
-#
-# I2C Hardware Bus support
-#
-# CONFIG_I2C_ELEKTOR is not set
-# CONFIG_I2C_PARPORT is not set
-# CONFIG_I2C_PARPORT_LIGHT is not set
-# CONFIG_I2C_PCA_ISA is not set
-#
-# Hardware Sensors Chip support
-#
-# CONFIG_I2C_SENSOR is not set
-# CONFIG_SENSORS_ADM1021 is not set
-# CONFIG_SENSORS_ADM1025 is not set
-# CONFIG_SENSORS_ADM1026 is not set
-# CONFIG_SENSORS_ADM1031 is not set
-# CONFIG_SENSORS_ASB100 is not set
-# CONFIG_SENSORS_DS1621 is not set
-# CONFIG_SENSORS_FSCHER is not set
-# CONFIG_SENSORS_FSCPOS is not set
-# CONFIG_SENSORS_GL518SM is not set
-# CONFIG_SENSORS_GL520SM is not set
-# CONFIG_SENSORS_IT87 is not set
-# CONFIG_SENSORS_LM63 is not set
-# CONFIG_SENSORS_LM75 is not set
-# CONFIG_SENSORS_LM77 is not set
-# CONFIG_SENSORS_LM78 is not set
-# CONFIG_SENSORS_LM80 is not set
-# CONFIG_SENSORS_LM83 is not set
-# CONFIG_SENSORS_LM85 is not set
-# CONFIG_SENSORS_LM87 is not set
-# CONFIG_SENSORS_LM90 is not set
-# CONFIG_SENSORS_MAX1619 is not set
-# CONFIG_SENSORS_PC87360 is not set
-# CONFIG_SENSORS_SMSC47B397 is not set
-# CONFIG_SENSORS_SMSC47M1 is not set
-# CONFIG_SENSORS_W83781D is not set
-# CONFIG_SENSORS_W83L785TS is not set
-# CONFIG_SENSORS_W83627HF is not set
-#
-# Other I2C Chip support
-#
-# CONFIG_SENSORS_EEPROM is not set
-# CONFIG_SENSORS_PCF8574 is not set
-# CONFIG_SENSORS_PCF8591 is not set
-# CONFIG_SENSORS_RTC8564 is not set
-# CONFIG_I2C_DEBUG_CORE is not set
-# CONFIG_I2C_DEBUG_ALGO is not set
-# CONFIG_I2C_DEBUG_BUS is not set
-# CONFIG_I2C_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=y
-CONFIG_FB_CFB_FILLRECT=y
-CONFIG_FB_CFB_COPYAREA=y
-CONFIG_FB_CFB_IMAGEBLIT=y
-CONFIG_FB_SOFT_CURSOR=y
-# CONFIG_FB_MODE_HELPERS is not set
-# CONFIG_FB_TILEBLITTING is not set
-CONFIG_FB_ACORN=y
-# CONFIG_FB_VIRTUAL is not set
-#
-# Console display driver support
-#
-# CONFIG_VGA_CONSOLE is not set
-# CONFIG_MDA_CONSOLE is not set
-CONFIG_DUMMY_CONSOLE=y
-CONFIG_FRAMEBUFFER_CONSOLE=y
-CONFIG_FONTS=y
-CONFIG_FONT_8x8=y
-CONFIG_FONT_8x16=y
-# CONFIG_FONT_6x11 is not set
-# CONFIG_FONT_PEARL_8x8 is not set
-# CONFIG_FONT_ACORN_8x8 is not set
-# CONFIG_FONT_MINI_4x6 is not set
-# CONFIG_FONT_SUN8x16 is not set
-# CONFIG_FONT_SUN12x22 is not set
-#
-# Logo configuration
-#
-CONFIG_LOGO=y
-CONFIG_LOGO_LINUX_MONO=y
-CONFIG_LOGO_LINUX_VGA16=y
-CONFIG_LOGO_LINUX_CLUT224=y
-# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
-#
-# Sound
-#
-# CONFIG_SOUND is not set
-#
-# USB support
-#
-CONFIG_USB_ARCH_HAS_HCD=y
-# CONFIG_USB_ARCH_HAS_OHCI is not set
-# CONFIG_USB is not set
-#
-# USB Gadget Support
-#
-# CONFIG_USB_GADGET is not set
-#
-# MMC/SD Card support
-#
-# CONFIG_MMC is not set
-#
-# File systems
-#
-CONFIG_EXT2_FS=y
-# CONFIG_EXT2_FS_XATTR is not set
-# CONFIG_EXT3_FS is not set
-# CONFIG_JBD is not set
-# CONFIG_REISERFS_FS is not set
-# CONFIG_JFS_FS is not set
-#
-# XFS support
-#
-# CONFIG_XFS_FS is not set
-CONFIG_MINIX_FS=y
-# CONFIG_ROMFS_FS is not set
-# CONFIG_QUOTA is not set
-CONFIG_DNOTIFY=y
-# CONFIG_AUTOFS_FS is not set
-# CONFIG_AUTOFS4_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_SYSFS=y
-# CONFIG_DEVFS_FS is not set
-# CONFIG_DEVPTS_FS_XATTR is not set
-# CONFIG_TMPFS is not set
-# CONFIG_HUGETLB_PAGE is not set
-CONFIG_RAMFS=y
-#
-# 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_JFFS_FS is not set
-# CONFIG_JFFS2_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_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
-#
-# 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_EFI_PARTITION is not set
-#
-# Native Language Support
-#
-# CONFIG_NLS is not set
-#
-# Profiling support
-#
-# CONFIG_PROFILING is not set
-#
-# Kernel hacking
-#
-# CONFIG_PRINTK_TIME is not set
-# CONFIG_DEBUG_KERNEL is not set
-CONFIG_LOG_BUF_SHIFT=14
-# CONFIG_DEBUG_BUGVERBOSE is not set
-CONFIG_FRAME_POINTER=y
-# CONFIG_DEBUG_USER 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
-#
-#
-# Library routines
-#
-# CONFIG_CRC_CCITT is not set
-CONFIG_CRC32=y
-# CONFIG_LIBCRC32C is not set
diff --git a/arch/arm/include/asm/mach/pci.h b/arch/arm/include/asm/mach/pci.h
index 32da1ae17e06..a38bdc7afa34 100644
--- a/arch/arm/include/asm/mach/pci.h
+++ b/arch/arm/include/asm/mach/pci.h
@@ -42,7 +42,7 @@ struct pci_sys_data {
 /*
 * This is the standard PCI-PCI bridge swizzling algorithm.
 */
-u8 pci_std_swizzle(struct pci_dev *dev, u8 *pinp);
+#define pci_std_swizzle pci_common_swizzle
 /*
 * Call this with your hw_pci struct to initialise the PCI system.
diff --git a/arch/arm/include/asm/mmu.h b/arch/arm/include/asm/mmu.h
index 53099d4ee421..b561584d04a1 100644
--- a/arch/arm/include/asm/mmu.h
+++ b/arch/arm/include/asm/mmu.h
@@ -24,7 +24,6 @@ typedef struct {
 *  modified for 2.6 by Hyok S. Choi <hyok.choi@samsung.com>
 */
 typedef struct {
-        struct vm_list_struct   *vmlist;
        unsigned long           end_brk;
 } mm_context_t;
diff --git a/arch/arm/kernel/bios32.c b/arch/arm/kernel/bios32.c
index 17a59b6e521f..809681900ec8 100644
--- a/arch/arm/kernel/bios32.c
+++ b/arch/arm/kernel/bios32.c
@@ -480,33 +480,6 @@ EXPORT_SYMBOL(pcibios_bus_to_resource);
 #endif
 /*
- * This is the standard PCI-PCI bridge swizzling algorithm:
- *
- *   Dev: 0  1  2  3
- *    A   A  B  C  D
- *    B   B  C  D  A
- *    C   C  D  A  B
- *    D   D  A  B  C
- *        ^^^^^^^^^^ irq pin on bridge
- */
-u8 __devinit pci_std_swizzle(struct pci_dev *dev, u8 *pinp)
-{
-        int pin = *pinp - 1;
-        while (dev->bus->self) {
-                pin = (pin + PCI_SLOT(dev->devfn)) & 3;
-                /*
-                 * move up the chain of bridges,
-                 * swizzling as we go.
-                 */
-                dev = dev->bus->self;
-        }
-        *pinp = pin + 1;
-        return PCI_SLOT(dev->devfn);
-}
-/*
 * Swizzle the device pin each time we cross a bridge.
 * This might update pin and returns the slot number.
 */
diff --git a/arch/arm/kernel/isa.c b/arch/arm/kernel/isa.c
index 50a30bc91872..8ac9b8424007 100644
--- a/arch/arm/kernel/isa.c
+++ b/arch/arm/kernel/isa.c
@@ -16,6 +16,7 @@
 #include <linux/fs.h>
 #include <linux/sysctl.h>
 #include <linux/init.h>
+#include <linux/io.h>
 static unsigned int isa_membase, isa_portbase, isa_portshift;
diff --git a/arch/arm/mach-at91/at91cap9.c b/arch/arm/mach-at91/at91cap9.c
index 0a38c69fdbc4..73376170fb91 100644
--- a/arch/arm/mach-at91/at91cap9.c
+++ b/arch/arm/mach-at91/at91cap9.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/pm.h>
+#include <asm/irq.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
diff --git a/arch/arm/mach-at91/at91rm9200.c b/arch/arm/mach-at91/at91rm9200.c
index 28594fcc88e3..2e9ecad97f3d 100644
--- a/arch/arm/mach-at91/at91rm9200.c
+++ b/arch/arm/mach-at91/at91rm9200.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
+#include <asm/irq.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 #include <mach/at91rm9200.h>
diff --git a/arch/arm/mach-at91/at91sam9260.c b/arch/arm/mach-at91/at91sam9260.c
index accb69ec478e..0894f1077be7 100644
--- a/arch/arm/mach-at91/at91sam9260.c
+++ b/arch/arm/mach-at91/at91sam9260.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/pm.h>
+#include <asm/irq.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 #include <mach/cpu.h>
diff --git a/arch/arm/mach-at91/at91sam9261.c b/arch/arm/mach-at91/at91sam9261.c
index 7b51a59ae8b3..3acd7d7e6a42 100644
--- a/arch/arm/mach-at91/at91sam9261.c
+++ b/arch/arm/mach-at91/at91sam9261.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/pm.h>
+#include <asm/irq.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 #include <mach/at91sam9261.h>
diff --git a/arch/arm/mach-at91/at91sam9263.c b/arch/arm/mach-at91/at91sam9263.c
index ada4b6769107..942792d630d8 100644
--- a/arch/arm/mach-at91/at91sam9263.c
+++ b/arch/arm/mach-at91/at91sam9263.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/pm.h>
+#include <asm/irq.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 #include <mach/at91sam9263.h>
diff --git a/arch/arm/mach-at91/at91sam9rl.c b/arch/arm/mach-at91/at91sam9rl.c
index 252e954b49fd..211c5c14a1e6 100644
--- a/arch/arm/mach-at91/at91sam9rl.c
+++ b/arch/arm/mach-at91/at91sam9rl.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/pm.h>
+#include <asm/irq.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 #include <mach/cpu.h>
diff --git a/arch/arm/mach-at91/board-sam9rlek.c b/arch/arm/mach-at91/board-sam9rlek.c
index 9b937ee4815a..35e12a49d1a6 100644
--- a/arch/arm/mach-at91/board-sam9rlek.c
+++ b/arch/arm/mach-at91/board-sam9rlek.c
@@ -29,6 +29,7 @@
 #include <mach/hardware.h>
 #include <mach/board.h>
 #include <mach/gpio.h>
+#include <mach/at91sam9_smc.h>
 #include <mach/at91_shdwc.h>
 #include "sam9_smc.h"
diff --git a/arch/arm/mach-clps711x/edb7211-mm.c b/arch/arm/mach-clps711x/edb7211-mm.c
index c58e32ec4c5d..0bea1454ae03 100644
--- a/arch/arm/mach-clps711x/edb7211-mm.c
+++ b/arch/arm/mach-clps711x/edb7211-mm.c
@@ -24,7 +24,6 @@
 #include <mach/hardware.h>
 #include <asm/page.h>
-#include <asm/pgtable.h>
 #include <asm/sizes.h>
 
 #include <asm/mach/map.h>
diff --git a/arch/arm/mach-clps711x/fortunet.c b/arch/arm/mach-clps711x/fortunet.c
index 7122b3d21043..7430e4049d87 100644
--- a/arch/arm/mach-clps711x/fortunet.c
+++ b/arch/arm/mach-clps711x/fortunet.c
@@ -24,7 +24,6 @@
 #include <linux/initrd.h>
 #include <mach/hardware.h>
-#include <asm/irq.h>
 #include <asm/setup.h>
 #include <asm/mach-types.h>
diff --git a/arch/arm/mach-davinci/devices.c b/arch/arm/mach-davinci/devices.c
index 3d4b1de8f898..808633f9f03c 100644
--- a/arch/arm/mach-davinci/devices.c
+++ b/arch/arm/mach-davinci/devices.c
@@ -20,6 +20,7 @@
 #include <mach/hardware.h>
 #include <mach/i2c.h>
+#include <mach/irqs.h>
 static struct resource i2c_resources[] = {
        {
diff --git a/arch/arm/mach-davinci/include/mach/gpio.h b/arch/arm/mach-davinci/include/mach/gpio.h
index b3a2961f0f46..b456f079f43f 100644
--- a/arch/arm/mach-davinci/include/mach/gpio.h
+++ b/arch/arm/mach-davinci/include/mach/gpio.h
@@ -16,6 +16,7 @@
 #include <linux/io.h>
 #include <asm-generic/gpio.h>
 #include <mach/hardware.h>
+#include <mach/irqs.h>
 /*
 * basic gpio routines
diff --git a/arch/arm/mach-footbridge/common.c b/arch/arm/mach-footbridge/common.c
index 36ff06d4df15..b97f529e58e8 100644
--- a/arch/arm/mach-footbridge/common.c
+++ b/arch/arm/mach-footbridge/common.c
@@ -28,12 +28,17 @@
 #include "common.h"
-extern void __init isa_init_irq(unsigned int irq);
 unsigned int mem_fclk_21285 = 50000000;
 EXPORT_SYMBOL(mem_fclk_21285);
+static void __init early_fclk(char **arg)
+{
+        mem_fclk_21285 = simple_strtoul(*arg, arg, 0);
+}
+__early_param("mem_fclk_21285=", early_fclk);
 static int __init parse_tag_memclk(const struct tag *tag)
 {
        mem_fclk_21285 = tag->u.memclk.fmemclk;
diff --git a/arch/arm/mach-footbridge/common.h b/arch/arm/mach-footbridge/common.h
index 580e31bbc711..b05e662d21ad 100644
--- a/arch/arm/mach-footbridge/common.h
+++ b/arch/arm/mach-footbridge/common.h
@@ -7,3 +7,4 @@ extern void isa_rtc_init(void);
 extern void footbridge_map_io(void);
 extern void footbridge_init_irq(void);
+extern void isa_init_irq(unsigned int irq);
diff --git a/arch/arm/mach-footbridge/dc21285.c b/arch/arm/mach-footbridge/dc21285.c
index 133086019e3e..3ffa54841ec5 100644
--- a/arch/arm/mach-footbridge/dc21285.c
+++ b/arch/arm/mach-footbridge/dc21285.c
@@ -287,6 +287,9 @@ struct pci_bus * __init dc21285_scan_bus(int nr, struct pci_sys_data *sys)
        return pci_scan_bus(0, &dc21285_ops, sys);
 }
+#define dc21285_request_irq(_a, _b, _c, _d, _e) \
+        WARN_ON(request_irq(_a, _b, _c, _d, _e) < 0)
 void __init dc21285_preinit(void)
 {
        unsigned int mem_size, mem_mask;
@@ -335,16 +338,16 @@ void __init dc21285_preinit(void)
        /*
         * We don't care if these fail.
         */
-        request_irq(IRQ_PCI_SERR, dc21285_serr_irq, IRQF_DISABLED,
+        dc21285_request_irq(IRQ_PCI_SERR, dc21285_serr_irq, IRQF_DISABLED,
-                    "PCI system error", &serr_timer);
+                            "PCI system error", &serr_timer);
-        request_irq(IRQ_PCI_PERR, dc21285_parity_irq, IRQF_DISABLED,
+        dc21285_request_irq(IRQ_PCI_PERR, dc21285_parity_irq, IRQF_DISABLED,
-                    "PCI parity error", &perr_timer);
+                            "PCI parity error", &perr_timer);
-        request_irq(IRQ_PCI_ABORT, dc21285_abort_irq, IRQF_DISABLED,
+        dc21285_request_irq(IRQ_PCI_ABORT, dc21285_abort_irq, IRQF_DISABLED,
-                    "PCI abort", NULL);
+                            "PCI abort", NULL);
-        request_irq(IRQ_DISCARD_TIMER, dc21285_discard_irq, IRQF_DISABLED,
+        dc21285_request_irq(IRQ_DISCARD_TIMER, dc21285_discard_irq, IRQF_DISABLED,
-                    "Discard timer", NULL);
+                            "Discard timer", NULL);
-        request_irq(IRQ_PCI_DPERR, dc21285_dparity_irq, IRQF_DISABLED,
+        dc21285_request_irq(IRQ_PCI_DPERR, dc21285_dparity_irq, IRQF_DISABLED,
-                    "PCI data parity", NULL);
+                            "PCI data parity", NULL);
        if (cfn_mode) {
                static struct resource csrio;
diff --git a/arch/arm/mach-footbridge/isa-irq.c b/arch/arm/mach-footbridge/isa-irq.c
index 9ee80a211d3c..8bfd06aeb64d 100644
--- a/arch/arm/mach-footbridge/isa-irq.c
+++ b/arch/arm/mach-footbridge/isa-irq.c
@@ -28,6 +28,8 @@
 #include <asm/irq.h>
 #include <asm/mach-types.h>
+#include "common.h"
 static void isa_mask_pic_lo_irq(unsigned int irq)
 {
        unsigned int mask = 1 << (irq & 7);
diff --git a/arch/arm/mach-h720x/h7202-eval.c b/arch/arm/mach-h720x/h7202-eval.c
index 56161d55cf47..8c0ba99d683f 100644
--- a/arch/arm/mach-h720x/h7202-eval.c
+++ b/arch/arm/mach-h720x/h7202-eval.c
@@ -25,6 +25,7 @@
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/mach/arch.h>
+#include <mach/irqs.h>
 #include <mach/hardware.h>
 #include "common.h"
diff --git a/arch/arm/mach-integrator/pci.c b/arch/arm/mach-integrator/pci.c
index af7d3ff013ec..2fdb95433f0a 100644
--- a/arch/arm/mach-integrator/pci.c
+++ b/arch/arm/mach-integrator/pci.c
@@ -63,13 +63,7 @@
 *
 * Where A = pin 1, B = pin 2 and so on and pin=0 = default = A.
 * Thus, each swizzle is ((pin-1) + (device#-4)) % 4
- *
- * The following code swizzles for exactly one bridge.  
 */
-static inline int bridge_swizzle(int pin, unsigned int slot) 
-{
-        return (pin + slot) & 3;
-}
 /*
 * This routine handles multiple bridges.
@@ -81,15 +75,14 @@ static u8 __init integrator_swizzle(struct pci_dev *dev, u8 *pinp)
        if (pin == 0)
                pin = 1;
-        pin -= 1;
        while (dev->bus->self) {
-                pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
+                pin = pci_swizzle_interrupt_pin(dev, pin);
                /*
                 * move up the chain of bridges, swizzling as we go.
                 */
                dev = dev->bus->self;
        }
-        *pinp = pin + 1;
+        *pinp = pin;
        return PCI_SLOT(dev->devfn);
 }
diff --git a/arch/arm/mach-kirkwood/common.c b/arch/arm/mach-kirkwood/common.c
index 7b8ef97fb501..b3404b7775b3 100644
--- a/arch/arm/mach-kirkwood/common.c
+++ b/arch/arm/mach-kirkwood/common.c
@@ -698,6 +698,7 @@ void __init kirkwood_init(void)
        printk(KERN_INFO "Kirkwood: %s, TCLK=%d.\n",
                kirkwood_id(), kirkwood_tclk);
        kirkwood_ge00_shared_data.t_clk = kirkwood_tclk;
+        kirkwood_ge01_shared_data.t_clk = kirkwood_tclk;
        kirkwood_spi_plat_data.tclk = kirkwood_tclk;
        kirkwood_uart0_data[0].uartclk = kirkwood_tclk;
        kirkwood_uart1_data[0].uartclk = kirkwood_tclk;
diff --git a/arch/arm/mach-kirkwood/pcie.c b/arch/arm/mach-kirkwood/pcie.c
index f6b08f207c89..73fccacd1a73 100644
--- a/arch/arm/mach-kirkwood/pcie.c
+++ b/arch/arm/mach-kirkwood/pcie.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/mbus.h>
+#include <asm/irq.h>
 #include <asm/mach/pci.h>
 #include <plat/pcie.h>
 #include "common.h"
diff --git a/arch/arm/mach-ks8695/devices.c b/arch/arm/mach-ks8695/devices.c
index 36ab0fd3d9b6..b89fb6d46ccc 100644
--- a/arch/arm/mach-ks8695/devices.c
+++ b/arch/arm/mach-ks8695/devices.c
@@ -22,6 +22,7 @@
 #include <linux/platform_device.h>
+#include <mach/irqs.h>
 #include <mach/regs-wan.h>
 #include <mach/regs-lan.h>
 #include <mach/regs-hpna.h>
diff --git a/arch/arm/mach-msm/devices.c b/arch/arm/mach-msm/devices.c
index f2a74b92a97f..31b6b30e98bf 100644
--- a/arch/arm/mach-msm/devices.c
+++ b/arch/arm/mach-msm/devices.c
@@ -16,6 +16,7 @@
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
+#include <mach/irqs.h>
 #include <mach/msm_iomap.h>
 #include "devices.h"
diff --git a/arch/arm/mach-mv78xx0/pcie.c b/arch/arm/mach-mv78xx0/pcie.c
index 430ea84d587d..aad3a7a2f830 100644
--- a/arch/arm/mach-mv78xx0/pcie.c
+++ b/arch/arm/mach-mv78xx0/pcie.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/mbus.h>
+#include <asm/irq.h>
 #include <asm/mach/pci.h>
 #include <plat/pcie.h>
 #include "common.h"
diff --git a/arch/arm/mach-mx2/devices.c b/arch/arm/mach-mx2/devices.c
index af121f5ab710..2f9240be1c76 100644
--- a/arch/arm/mach-mx2/devices.c
+++ b/arch/arm/mach-mx2/devices.c
@@ -32,6 +32,7 @@
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
+#include <mach/irqs.h>
 #include <mach/hardware.h>
 /*
diff --git a/arch/arm/mach-mx3/devices.c b/arch/arm/mach-mx3/devices.c
index 1d46cb4adf96..f8428800f286 100644
--- a/arch/arm/mach-mx3/devices.c
+++ b/arch/arm/mach-mx3/devices.c
@@ -22,6 +22,7 @@
 #include <linux/serial.h>
 #include <linux/gpio.h>
 #include <mach/hardware.h>
+#include <mach/irqs.h>
 #include <mach/imx-uart.h>
 static struct resource uart0[] = {
diff --git a/arch/arm/mach-netx/fb.c b/arch/arm/mach-netx/fb.c
index ea8fa8898fe8..1d844e228ea9 100644
--- a/arch/arm/mach-netx/fb.c
+++ b/arch/arm/mach-netx/fb.c
@@ -24,6 +24,8 @@
 #include <linux/amba/clcd.h>
 #include <linux/err.h>
+#include <asm/irq.h>
 #include <mach/netx-regs.h>
 #include <mach/hardware.h>
diff --git a/arch/arm/mach-netx/time.c b/arch/arm/mach-netx/time.c
index d51d627ce7cf..f201fddb594f 100644
--- a/arch/arm/mach-netx/time.c
+++ b/arch/arm/mach-netx/time.c
@@ -163,7 +163,7 @@ static void __init netx_timer_init(void)
         * Adding some safety ... */
        netx_clockevent.min_delta_ns =
                clockevent_delta2ns(0xa00, &netx_clockevent);
-        netx_clockevent.cpumask = cpumask_of_cpu(0);
+        netx_clockevent.cpumask = cpumask_of(0);
        clockevents_register_device(&netx_clockevent);
 }
diff --git a/arch/arm/mach-netx/xc.c b/arch/arm/mach-netx/xc.c
index 8fc6205dc3a5..181a78ba8165 100644
--- a/arch/arm/mach-netx/xc.c
+++ b/arch/arm/mach-netx/xc.c
@@ -24,6 +24,7 @@
 #include <linux/io.h>
 #include <mach/hardware.h>
+#include <mach/irqs.h>
 #include <mach/netx-regs.h>
 #include <mach/xc.h>
diff --git a/arch/arm/mach-omap1/mcbsp.c b/arch/arm/mach-omap1/mcbsp.c
index 7de7c6915584..4474da7bc88a 100644
--- a/arch/arm/mach-omap1/mcbsp.c
+++ b/arch/arm/mach-omap1/mcbsp.c
@@ -18,6 +18,7 @@
 #include <linux/platform_device.h>
 #include <mach/dma.h>
+#include <mach/irqs.h>
 #include <mach/mux.h>
 #include <mach/cpu.h>
 #include <mach/mcbsp.h>
diff --git a/arch/arm/mach-omap2/mcbsp.c b/arch/arm/mach-omap2/mcbsp.c
index cae3ebe249b3..acdc709901cd 100644
--- a/arch/arm/mach-omap2/mcbsp.c
+++ b/arch/arm/mach-omap2/mcbsp.c
@@ -18,6 +18,7 @@
 #include <linux/platform_device.h>
 #include <mach/dma.h>
+#include <mach/irqs.h>
 #include <mach/mux.h>
 #include <mach/cpu.h>
 #include <mach/mcbsp.h>
diff --git a/arch/arm/mach-orion5x/pci.c b/arch/arm/mach-orion5x/pci.c
index a7b7d77b1b09..d0a785a3b880 100644
--- a/arch/arm/mach-orion5x/pci.c
+++ b/arch/arm/mach-orion5x/pci.c
@@ -13,6 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/mbus.h>
+#include <asm/irq.h>
 #include <asm/mach/pci.h>
 #include <plat/pcie.h>
 #include "common.h"
diff --git a/arch/arm/mach-pnx4008/gpio.c b/arch/arm/mach-pnx4008/gpio.c
index 015cc21d5f55..f219914f5b29 100644
--- a/arch/arm/mach-pnx4008/gpio.c
+++ b/arch/arm/mach-pnx4008/gpio.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/io.h>
+#include <mach/hardware.h>
 #include <mach/platform.h>
 #include <mach/gpio.h>
diff --git a/arch/arm/mach-pnx4008/i2c.c b/arch/arm/mach-pnx4008/i2c.c
index 87c093286ff9..f3fea29c00d3 100644
--- a/arch/arm/mach-pnx4008/i2c.c
+++ b/arch/arm/mach-pnx4008/i2c.c
@@ -15,6 +15,7 @@
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <mach/platform.h>
+#include <mach/irqs.h>
 #include <mach/i2c.h>
 static int set_clock_run(struct platform_device *pdev)
diff --git a/arch/arm/mach-pxa/corgi.c b/arch/arm/mach-pxa/corgi.c
index c5e28a46b292..a8d91b6c136b 100644
--- a/arch/arm/mach-pxa/corgi.c
+++ b/arch/arm/mach-pxa/corgi.c
@@ -27,6 +27,7 @@
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 #include <linux/spi/corgi_lcd.h>
+#include <linux/mtd/sharpsl.h>
 #include <video/w100fb.h>
 #include <asm/setup.h>
@@ -542,6 +543,55 @@ err_free_1:
 static inline void corgi_init_spi(void) {}
 #endif
+static struct mtd_partition sharpsl_nand_partitions[] = {
+        {
+                .name = "System Area",
+                .offset = 0,
+                .size = 7 * 1024 * 1024,
+        },
+        {
+                .name = "Root Filesystem",
+                .offset = 7 * 1024 * 1024,
+                .size = 25 * 1024 * 1024,
+        },
+        {
+                .name = "Home Filesystem",
+                .offset = MTDPART_OFS_APPEND,
+                .size = MTDPART_SIZ_FULL,
+        },
+};
+static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
+static struct nand_bbt_descr sharpsl_bbt = {
+        .options = 0,
+        .offs = 4,
+        .len = 2,
+        .pattern = scan_ff_pattern
+};
+static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
+        .badblock_pattern       = &sharpsl_bbt,
+        .partitions             = sharpsl_nand_partitions,
+        .nr_partitions          = ARRAY_SIZE(sharpsl_nand_partitions),
+};
+static struct resource sharpsl_nand_resources[] = {
+        {
+                .start  = 0x0C000000,
+                .end    = 0x0C000FFF,
+                .flags  = IORESOURCE_MEM,
+        },
+};
+static struct platform_device sharpsl_nand_device = {
+        .name           = "sharpsl-nand",
+        .id             = -1,
+        .resource       = sharpsl_nand_resources,
+        .num_resources  = ARRAY_SIZE(sharpsl_nand_resources),
+        .dev.platform_data      = &sharpsl_nand_platform_data,
+};
 static struct mtd_partition sharpsl_rom_parts[] = {
        {
                .name   ="Boot PROM Filesystem",
@@ -577,6 +627,7 @@ static struct platform_device *devices[] __initdata = {
        &corgifb_device,
        &corgikbd_device,
        &corgiled_device,
+        &sharpsl_nand_device,
        &sharpsl_rom_device,
 };
@@ -617,6 +668,9 @@ static void __init corgi_init(void)
        platform_scoop_config = &corgi_pcmcia_config;
+        if (machine_is_husky())
+                sharpsl_nand_partitions[1].size = 53 * 1024 * 1024;
        platform_add_devices(devices, ARRAY_SIZE(devices));
 }
diff --git a/arch/arm/mach-pxa/e350.c b/arch/arm/mach-pxa/e350.c
index 251129391d7d..edcd9d5ce545 100644
--- a/arch/arm/mach-pxa/e350.c
+++ b/arch/arm/mach-pxa/e350.c
@@ -20,6 +20,7 @@
 #include <asm/mach/arch.h>
 #include <asm/mach-types.h>
+#include <mach/irqs.h>
 #include <mach/mfp-pxa25x.h>
 #include <mach/pxa-regs.h>
 #include <mach/hardware.h>
diff --git a/arch/arm/mach-pxa/e400.c b/arch/arm/mach-pxa/e400.c
index bed0336aca3d..77bb8e2c48c0 100644
--- a/arch/arm/mach-pxa/e400.c
+++ b/arch/arm/mach-pxa/e400.c
@@ -28,6 +28,7 @@
 #include <mach/eseries-gpio.h>
 #include <mach/pxafb.h>
 #include <mach/udc.h>
+#include <mach/irqs.h>
 #include "generic.h"
 #include "eseries.h"
diff --git a/arch/arm/mach-pxa/e740.c b/arch/arm/mach-pxa/e740.c
index b00d670b2ea6..6d48e00f4f0b 100644
--- a/arch/arm/mach-pxa/e740.c
+++ b/arch/arm/mach-pxa/e740.c
@@ -30,6 +30,7 @@
 #include <mach/eseries-gpio.h>
 #include <mach/udc.h>
 #include <mach/irda.h>
+#include <mach/irqs.h>
 #include "generic.h"
 #include "eseries.h"
diff --git a/arch/arm/mach-pxa/e750.c b/arch/arm/mach-pxa/e750.c
index 84d7c1aac58d..be1ab8edb973 100644
--- a/arch/arm/mach-pxa/e750.c
+++ b/arch/arm/mach-pxa/e750.c
@@ -29,6 +29,7 @@
 #include <mach/eseries-gpio.h>
 #include <mach/udc.h>
 #include <mach/irda.h>
+#include <mach/irqs.h>
 #include "generic.h"
 #include "eseries.h"
@@ -105,6 +106,57 @@ static struct platform_device e750_fb_device = {
        .resource       = e750_fb_resources,
 };
+/* -------------------- e750 MFP parameters -------------------- */
+static unsigned long e750_pin_config[] __initdata = {
+        /* Chip selects */
+        GPIO15_nCS_1,   /* CS1 - Flash */
+        GPIO79_nCS_3,   /* CS3 - IMAGEON */
+        GPIO80_nCS_4,   /* CS4 - TMIO */
+        /* Clocks */
+        GPIO11_3_6MHz,
+        /* BTUART */
+        GPIO42_BTUART_RXD,
+        GPIO43_BTUART_TXD,
+        GPIO44_BTUART_CTS,
+        /* TMIO controller */
+        GPIO19_GPIO, /* t7l66xb #PCLR */
+        GPIO45_GPIO, /* t7l66xb #SUSPEND (NOT BTUART!) */
+        /* UDC */
+        GPIO13_GPIO,
+        GPIO3_GPIO,
+        /* IrDA */
+        GPIO38_GPIO | MFP_LPM_DRIVE_HIGH,
+        /* PC Card */
+        GPIO8_GPIO,   /* CD0 */
+        GPIO44_GPIO,  /* CD1 */
+        GPIO11_GPIO,  /* IRQ0 */
+        GPIO6_GPIO,   /* IRQ1 */
+        GPIO27_GPIO,  /* RST0 */
+        GPIO24_GPIO,  /* RST1 */
+        GPIO20_GPIO,  /* PWR0 */
+        GPIO23_GPIO,  /* PWR1 */
+        GPIO48_nPOE,
+        GPIO49_nPWE,
+        GPIO50_nPIOR,
+        GPIO51_nPIOW,
+        GPIO52_nPCE_1,
+        GPIO53_nPCE_2,
+        GPIO54_nPSKTSEL,
+        GPIO55_nPREG,
+        GPIO56_nPWAIT,
+        GPIO57_nIOIS16,
+        /* wakeup */
+        GPIO0_GPIO | WAKEUP_ON_EDGE_RISE,
+};
 /* ----------------- e750 tc6393xb parameters ------------------ */
 static struct tc6393xb_platform_data e750_tc6393xb_info = {
@@ -137,6 +189,7 @@ static struct platform_device *devices[] __initdata = {
 static void __init e750_init(void)
 {
+        pxa2xx_mfp_config(ARRAY_AND_SIZE(e750_pin_config));
        clk_add_alias("CLK_CK3P6MI", &e750_tc6393xb_device.dev,
                        "GPIO11_CLK", NULL),
        eseries_get_tmio_gpios();
diff --git a/arch/arm/mach-pxa/e800.c b/arch/arm/mach-pxa/e800.c
index 9a86a426f924..cc9b1293e866 100644
--- a/arch/arm/mach-pxa/e800.c
+++ b/arch/arm/mach-pxa/e800.c
@@ -28,6 +28,7 @@
 #include <mach/hardware.h>
 #include <mach/eseries-gpio.h>
 #include <mach/udc.h>
+#include <mach/irqs.h>
 #include "generic.h"
 #include "eseries.h"
diff --git a/arch/arm/mach-pxa/include/mach/pxa3xx-regs.h b/arch/arm/mach-pxa/include/mach/pxa3xx-regs.h
index b1fcd10ab6c6..bcf3fb2c4b3a 100644
--- a/arch/arm/mach-pxa/include/mach/pxa3xx-regs.h
+++ b/arch/arm/mach-pxa/include/mach/pxa3xx-regs.h
@@ -193,10 +193,8 @@
 #define CKEN_MINI_IM    48      /* < Mini-IM */
 #define CKEN_MINI_LCD   49      /* < Mini LCD */
-#if defined(CONFIG_CPU_PXA310)
 #define CKEN_MMC3       5       /* < MMC3 Clock Enable */
 #define CKEN_MVED       43      /* < MVED clock enable */
-#endif
 /* Note: GCU clock enable bit differs on PXA300/PXA310 and PXA320 */
 #define PXA300_CKEN_GRAPHICS    42      /* Graphics controller clock enable */
diff --git a/arch/arm/mach-pxa/poodle.c b/arch/arm/mach-pxa/poodle.c
index ae88855bf974..f9093beba752 100644
--- a/arch/arm/mach-pxa/poodle.c
+++ b/arch/arm/mach-pxa/poodle.c
@@ -24,6 +24,7 @@
 #include <linux/gpio.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
+#include <linux/mtd/sharpsl.h>
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
@@ -414,6 +415,55 @@ static struct pxafb_mach_info poodle_fb_info = {
        .lcd_conn       = LCD_COLOR_TFT_16BPP,
 };
+static struct mtd_partition sharpsl_nand_partitions[] = {
+        {
+                .name = "System Area",
+                .offset = 0,
+                .size = 7 * 1024 * 1024,
+        },
+        {
+                .name = "Root Filesystem",
+                .offset = 7 * 1024 * 1024,
+                .size = 22 * 1024 * 1024,
+        },
+        {
+                .name = "Home Filesystem",
+                .offset = MTDPART_OFS_APPEND,
+                .size = MTDPART_SIZ_FULL,
+        },
+};
+static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
+static struct nand_bbt_descr sharpsl_bbt = {
+        .options = 0,
+        .offs = 4,
+        .len = 2,
+        .pattern = scan_ff_pattern
+};
+static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
+        .badblock_pattern       = &sharpsl_bbt,
+        .partitions             = sharpsl_nand_partitions,
+        .nr_partitions          = ARRAY_SIZE(sharpsl_nand_partitions),
+};
+static struct resource sharpsl_nand_resources[] = {
+        {
+                .start  = 0x0C000000,
+                .end    = 0x0C000FFF,
+                .flags  = IORESOURCE_MEM,
+        },
+};
+static struct platform_device sharpsl_nand_device = {
+        .name           = "sharpsl-nand",
+        .id             = -1,
+        .resource       = sharpsl_nand_resources,
+        .num_resources  = ARRAY_SIZE(sharpsl_nand_resources),
+        .dev.platform_data      = &sharpsl_nand_platform_data,
+};
 static struct mtd_partition sharpsl_rom_parts[] = {
        {
                .name   ="Boot PROM Filesystem",
@@ -447,6 +497,7 @@ static struct platform_device sharpsl_rom_device = {
 static struct platform_device *devices[] __initdata = {
        &poodle_locomo_device,
        &poodle_scoop_device,
+        &sharpsl_nand_device,
        &sharpsl_rom_device,
 };
diff --git a/arch/arm/mach-pxa/spitz.c b/arch/arm/mach-pxa/spitz.c
index 7299d87a1cb3..6d447c9ce8ab 100644
--- a/arch/arm/mach-pxa/spitz.c
+++ b/arch/arm/mach-pxa/spitz.c
@@ -31,6 +31,7 @@
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 #include <linux/spi/corgi_lcd.h>
+#include <linux/mtd/sharpsl.h>
 #include <asm/setup.h>
 #include <asm/memory.h>
@@ -613,6 +614,54 @@ static struct pxafb_mach_info spitz_pxafb_info = {
        .lcd_conn       = LCD_COLOR_TFT_16BPP | LCD_ALTERNATE_MAPPING,
 };
+static struct mtd_partition sharpsl_nand_partitions[] = {
+        {
+                .name = "System Area",
+                .offset = 0,
+                .size = 7 * 1024 * 1024,
+        },
+        {
+                .name = "Root Filesystem",
+                .offset = 7 * 1024 * 1024,
+        },
+        {
+                .name = "Home Filesystem",
+                .offset = MTDPART_OFS_APPEND,
+                .size = MTDPART_SIZ_FULL,
+        },
+};
+static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
+static struct nand_bbt_descr sharpsl_bbt = {
+        .options = 0,
+        .offs = 4,
+        .len = 2,
+        .pattern = scan_ff_pattern
+};
+static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
+        .badblock_pattern       = &sharpsl_bbt,
+        .partitions             = sharpsl_nand_partitions,
+        .nr_partitions          = ARRAY_SIZE(sharpsl_nand_partitions),
+};
+static struct resource sharpsl_nand_resources[] = {
+        {
+                .start  = 0x0C000000,
+                .end    = 0x0C000FFF,
+                .flags  = IORESOURCE_MEM,
+        },
+};
+static struct platform_device sharpsl_nand_device = {
+        .name           = "sharpsl-nand",
+        .id             = -1,
+        .resource       = sharpsl_nand_resources,
+        .num_resources  = ARRAY_SIZE(sharpsl_nand_resources),
+        .dev.platform_data      = &sharpsl_nand_platform_data,
+};
 static struct mtd_partition sharpsl_rom_parts[] = {
        {
@@ -648,6 +697,7 @@ static struct platform_device *devices[] __initdata = {
        &spitzscoop_device,
        &spitzkbd_device,
        &spitzled_device,
+        &sharpsl_nand_device,
        &sharpsl_rom_device,
 };
@@ -671,6 +721,14 @@ static void __init common_init(void)
        pm_power_off = spitz_poweroff;
        arm_pm_restart = spitz_restart;
+        if (machine_is_spitz()) {
+                sharpsl_nand_partitions[1].size = 5 * 1024 * 1024;
+        } else if (machine_is_akita()) {
+                sharpsl_nand_partitions[1].size = 58 * 1024 * 1024;
+        } else if (machine_is_borzoi()) {
+                sharpsl_nand_partitions[1].size = 32 * 1024 * 1024;
+        }
        PMCR = 0x00;
        /* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
@@ -715,10 +773,29 @@ static struct i2c_board_info akita_i2c_board_info[] = {
        },
 };
+static struct nand_bbt_descr sharpsl_akita_bbt = {
+        .options = 0,
+        .offs = 4,
+        .len = 1,
+        .pattern = scan_ff_pattern
+};
+static struct nand_ecclayout akita_oobinfo = {
+        .eccbytes = 24,
+        .eccpos = {
+                   0x5, 0x1, 0x2, 0x3, 0x6, 0x7, 0x15, 0x11,
+                   0x12, 0x13, 0x16, 0x17, 0x25, 0x21, 0x22, 0x23,
+                   0x26, 0x27, 0x35, 0x31, 0x32, 0x33, 0x36, 0x37},
+        .oobfree = {{0x08, 0x09}}
+};
 static void __init akita_init(void)
 {
        spitz_ficp_platform_data.transceiver_mode = akita_irda_transceiver_mode;
+        sharpsl_nand_platform_data.badblock_pattern = &sharpsl_akita_bbt;
+        sharpsl_nand_platform_data.ecc_layout = &akita_oobinfo;
        /* We just pretend the second element of the array doesn't exist */
        spitz_pcmcia_config.num_devs = 1;
        platform_scoop_config = &spitz_pcmcia_config;
diff --git a/arch/arm/mach-realview/platsmp.c b/arch/arm/mach-realview/platsmp.c
index 8fce85f33033..ea3c75595fa9 100644
--- a/arch/arm/mach-realview/platsmp.c
+++ b/arch/arm/mach-realview/platsmp.c
@@ -12,6 +12,7 @@
 #include <linux/errno.h>
 #include <linux/delay.h>
 #include <linux/device.h>
+#include <linux/jiffies.h>
 #include <linux/smp.h>
 #include <linux/io.h>
diff --git a/arch/arm/mach-s3c2410/include/mach/gpio.h b/arch/arm/mach-s3c2410/include/mach/gpio.h
index e0349af8a483..00476a573bbe 100644
--- a/arch/arm/mach-s3c2410/include/mach/gpio.h
+++ b/arch/arm/mach-s3c2410/include/mach/gpio.h
@@ -14,6 +14,7 @@
 #define gpio_get_value  __gpio_get_value
 #define gpio_set_value  __gpio_set_value
 #define gpio_cansleep   __gpio_cansleep
+#define gpio_to_irq     __gpio_to_irq
 /* some boards require extra gpio capacity to support external
 * devices that need GPIO.
diff --git a/arch/arm/mach-s3c2410/include/mach/irqs.h b/arch/arm/mach-s3c2410/include/mach/irqs.h
index 9565903d490b..49efce8cd4a7 100644
--- a/arch/arm/mach-s3c2410/include/mach/irqs.h
+++ b/arch/arm/mach-s3c2410/include/mach/irqs.h
@@ -12,10 +12,6 @@
 #ifndef __ASM_ARCH_IRQS_H
 #define __ASM_ARCH_IRQS_H __FILE__
-#ifndef __ASM_ARM_IRQ_H
-#error "Do not include this directly, instead #include <asm/irq.h>"
-#endif
 /* we keep the first set of CPU IRQs out of the range of
 * the ISA space, so that the PC104 has them to itself
 * and we don't end up having to do horrible things to the
diff --git a/arch/arm/mach-s3c2440/mach-at2440evb.c b/arch/arm/mach-s3c2440/mach-at2440evb.c
index 0a6d0a5d961b..315c42e31278 100644
--- a/arch/arm/mach-s3c2440/mach-at2440evb.c
+++ b/arch/arm/mach-s3c2440/mach-at2440evb.c
@@ -47,7 +47,7 @@
 #include <plat/clock.h>
 #include <plat/devs.h>
 #include <plat/cpu.h>
-#include <asm/plat-s3c24xx/mci.h>
+#include <plat/mci.h>
 static struct map_desc at2440evb_iodesc[] __initdata = {
        /* Nothing here */
diff --git a/arch/arm/mach-s3c6400/include/mach/irqs.h b/arch/arm/mach-s3c6400/include/mach/irqs.h
index b38c47cffc28..4c97f9a4370b 100644
--- a/arch/arm/mach-s3c6400/include/mach/irqs.h
+++ b/arch/arm/mach-s3c6400/include/mach/irqs.h
@@ -11,10 +11,6 @@
 #ifndef __ASM_ARCH_IRQS_H
 #define __ASM_ARCH_IRQS_H __FILE__
-#ifndef __ASM_ARM_IRQ_H
-#error "Do not include this directly, instead #include <asm/irq.h>"
-#endif
 #include <plat/irqs.h>
 #endif /* __ASM_ARCH_IRQ_H */
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index 67960017dc8f..310e479309ef 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -71,7 +71,7 @@ static DEFINE_SPINLOCK(consistent_lock);
 * the amount of RAM found at boot time.)  I would imagine that get_vm_area()
 * would have to initialise this each time prior to calling vm_region_alloc().
 */
-struct vm_region {
+struct arm_vm_region {
        struct list_head        vm_list;
        unsigned long           vm_start;
        unsigned long           vm_end;
@@ -79,20 +79,20 @@ struct vm_region {
        int                     vm_active;
 };
-static struct vm_region consistent_head = {
+static struct arm_vm_region consistent_head = {
        .vm_list        = LIST_HEAD_INIT(consistent_head.vm_list),
        .vm_start       = CONSISTENT_BASE,
        .vm_end         = CONSISTENT_END,
 };
-static struct vm_region *
+static struct arm_vm_region *
-vm_region_alloc(struct vm_region *head, size_t size, gfp_t gfp)
+arm_vm_region_alloc(struct arm_vm_region *head, size_t size, gfp_t gfp)
 {
        unsigned long addr = head->vm_start, end = head->vm_end - size;
        unsigned long flags;
-        struct vm_region *c, *new;
+        struct arm_vm_region *c, *new;
-        new = kmalloc(sizeof(struct vm_region), gfp);
+        new = kmalloc(sizeof(struct arm_vm_region), gfp);
        if (!new)
                goto out;
@@ -127,9 +127,9 @@ vm_region_alloc(struct vm_region *head, size_t size, gfp_t gfp)
        return NULL;
 }
-static struct vm_region *vm_region_find(struct vm_region *head, unsigned long addr)
+static struct arm_vm_region *arm_vm_region_find(struct arm_vm_region *head, unsigned long addr)
 {
-        struct vm_region *c;
+        struct arm_vm_region *c;
        
        list_for_each_entry(c, &head->vm_list, vm_list) {
                if (c->vm_active && c->vm_start == addr)
@@ -149,7 +149,7 @@ __dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp,
            pgprot_t prot)
 {
        struct page *page;
-        struct vm_region *c;
+        struct arm_vm_region *c;
        unsigned long order;
        u64 mask = ISA_DMA_THRESHOLD, limit;
@@ -214,7 +214,7 @@ __dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp,
        /*
         * Allocate a virtual address in the consistent mapping region.
         */
-        c = vm_region_alloc(&consistent_head, size,
+        c = arm_vm_region_alloc(&consistent_head, size,
                            gfp & ~(__GFP_DMA | __GFP_HIGHMEM));
        if (c) {
                pte_t *pte;
@@ -311,13 +311,13 @@ static int dma_mmap(struct device *dev, struct vm_area_struct *vma,
                    void *cpu_addr, dma_addr_t dma_addr, size_t size)
 {
        unsigned long flags, user_size, kern_size;
-        struct vm_region *c;
+        struct arm_vm_region *c;
        int ret = -ENXIO;
        user_size = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
        spin_lock_irqsave(&consistent_lock, flags);
-        c = vm_region_find(&consistent_head, (unsigned long)cpu_addr);
+        c = arm_vm_region_find(&consistent_head, (unsigned long)cpu_addr);
        spin_unlock_irqrestore(&consistent_lock, flags);
        if (c) {
@@ -359,7 +359,7 @@ EXPORT_SYMBOL(dma_mmap_writecombine);
 */
 void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr_t handle)
 {
-        struct vm_region *c;
+        struct arm_vm_region *c;
        unsigned long flags, addr;
        pte_t *ptep;
        int idx;
@@ -378,7 +378,7 @@ void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr
        size = PAGE_ALIGN(size);
        spin_lock_irqsave(&consistent_lock, flags);
-        c = vm_region_find(&consistent_head, (unsigned long)cpu_addr);
+        c = arm_vm_region_find(&consistent_head, (unsigned long)cpu_addr);
        if (!c)
                goto no_area;
diff --git a/arch/arm/plat-mxc/include/mach/usb.h b/arch/arm/plat-mxc/include/mach/usb.h
new file mode 100644
index 000000000000..2dacb3086f1c
--- /dev/null
+++ b/arch/arm/plat-mxc/include/mach/usb.h
@@ -0,0 +1,23 @@
+/*
+ *      Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com>
+ *
+ *      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.
+ */
+#ifndef __ASM_ARCH_MXC_USB
+#define __ASM_ARCH_MXC_USB
+struct imxusb_platform_data {
+        int (*init)(struct device *);
+        int (*exit)(struct device *);
+};
+#endif /* __ASM_ARCH_MXC_USB */
diff --git a/arch/arm/plat-omap/i2c.c b/arch/arm/plat-omap/i2c.c
index 89a6ab0b7db8..467531edefd3 100644
--- a/arch/arm/plat-omap/i2c.c
+++ b/arch/arm/plat-omap/i2c.c
@@ -26,6 +26,7 @@
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
+#include <mach/irqs.h>
 #include <mach/mux.h>
 #define OMAP_I2C_SIZE           0x3f
diff --git a/arch/arm/plat-omap/usb.c b/arch/arm/plat-omap/usb.c
index 67ca1e216df7..add0485703b5 100644
--- a/arch/arm/plat-omap/usb.c
+++ b/arch/arm/plat-omap/usb.c
@@ -77,38 +77,6 @@
 /*-------------------------------------------------------------------------*/
-#if     defined(CONFIG_ARCH_OMAP_OTG) || defined(CONFIG_USB_MUSB_OTG)
-static struct otg_transceiver *xceiv;
-/**
- * otg_get_transceiver - find the (single) OTG transceiver driver
- *
- * Returns the transceiver driver, after getting a refcount to it; or
- * null if there is no such transceiver.  The caller is responsible for
- * releasing that count.
- */
-struct otg_transceiver *otg_get_transceiver(void)
-{
-        if (xceiv)
-                get_device(xceiv->dev);
-        return xceiv;
-}
-EXPORT_SYMBOL(otg_get_transceiver);
-int otg_set_transceiver(struct otg_transceiver *x)
-{
-        if (xceiv && x)
-                return -EBUSY;
-        xceiv = x;
-        return 0;
-}
-EXPORT_SYMBOL(otg_set_transceiver);
-#endif
-/*-------------------------------------------------------------------------*/
 #if defined(CONFIG_ARCH_OMAP_OTG) || defined(CONFIG_ARCH_OMAP15XX)
 static void omap2_usb_devconf_clear(u8 port, u32 mask)
diff --git a/arch/arm/plat-s3c/dev-fb.c b/arch/arm/plat-s3c/dev-fb.c
index 0454b8ec02e2..a90198fc4b0f 100644
--- a/arch/arm/plat-s3c/dev-fb.c
+++ b/arch/arm/plat-s3c/dev-fb.c
@@ -16,6 +16,7 @@
 #include <linux/platform_device.h>
 #include <linux/fb.h>
+#include <mach/irqs.h>
 #include <mach/map.h>
 #include <mach/regs-fb.h>
diff --git a/arch/arm/plat-s3c/dev-i2c0.c b/arch/arm/plat-s3c/dev-i2c0.c
index 2c0128c77c6e..fe327074037e 100644
--- a/arch/arm/plat-s3c/dev-i2c0.c
+++ b/arch/arm/plat-s3c/dev-i2c0.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/platform_device.h>
+#include <mach/irqs.h>
 #include <mach/map.h>
 #include <plat/regs-iic.h>
diff --git a/arch/arm/plat-s3c/dev-i2c1.c b/arch/arm/plat-s3c/dev-i2c1.c
index 9658fb0aec95..2387fbf57af6 100644
--- a/arch/arm/plat-s3c/dev-i2c1.c
+++ b/arch/arm/plat-s3c/dev-i2c1.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/platform_device.h>
+#include <mach/irqs.h>
 #include <mach/map.h>
 #include <plat/regs-iic.h>
diff --git a/arch/arm/plat-s3c24xx/gpiolib.c b/arch/arm/plat-s3c24xx/gpiolib.c
index f95c6c9d9f1a..94a341aaa4e4 100644
--- a/arch/arm/plat-s3c24xx/gpiolib.c
+++ b/arch/arm/plat-s3c24xx/gpiolib.c
@@ -59,6 +59,22 @@ static int s3c24xx_gpiolib_banka_output(struct gpio_chip *chip,
        return 0;
 }
+static int s3c24xx_gpiolib_bankf_toirq(struct gpio_chip *chip, unsigned offset)
+{
+        if (offset < 4)
+                return IRQ_EINT0 + offset;
+        
+        if (offset < 8)
+                return IRQ_EINT4 + offset - 4;
+        
+        return -EINVAL;
+}
+static int s3c24xx_gpiolib_bankg_toirq(struct gpio_chip *chip, unsigned offset)
+{
+        return IRQ_EINT8 + offset;
+}
 struct s3c_gpio_chip s3c24xx_gpios[] = {
        [0] = {
                .base   = S3C24XX_GPIO_BASE(S3C2410_GPA0),
@@ -114,6 +130,7 @@ struct s3c_gpio_chip s3c24xx_gpios[] = {
                        .owner                  = THIS_MODULE,
                        .label                  = "GPIOF",
                        .ngpio                  = 8,
+                        .to_irq                 = s3c24xx_gpiolib_bankf_toirq,
                },
        },
        [6] = {
@@ -123,6 +140,7 @@ struct s3c_gpio_chip s3c24xx_gpios[] = {
                        .owner                  = THIS_MODULE,
                        .label                  = "GPIOG",
                        .ngpio                  = 10,
+                        .to_irq                 = s3c24xx_gpiolib_bankg_toirq,
                },
        },
 };
diff --git a/arch/arm/plat-s3c24xx/pwm.c b/arch/arm/plat-s3c24xx/pwm.c
index ec56b88866c4..0120b760315b 100644
--- a/arch/arm/plat-s3c24xx/pwm.c
+++ b/arch/arm/plat-s3c24xx/pwm.c
@@ -19,6 +19,8 @@
 #include <linux/io.h>
 #include <linux/pwm.h>
+#include <mach/irqs.h>
 #include <plat/devs.h>
 #include <plat/regs-timer.h>
diff --git a/arch/arm/plat-s3c64xx/include/plat/irqs.h b/arch/arm/plat-s3c64xx/include/plat/irqs.h
index 02e8dd4c97d5..2846f550b727 100644
--- a/arch/arm/plat-s3c64xx/include/plat/irqs.h
+++ b/arch/arm/plat-s3c64xx/include/plat/irqs.h
@@ -191,7 +191,7 @@
 #define IRQ_EINT_GROUP8_BASE    (IRQ_EINT_GROUP7_BASE + IRQ_EINT_GROUP7_NR)
 #define IRQ_EINT_GROUP9_BASE    (IRQ_EINT_GROUP8_BASE + IRQ_EINT_GROUP8_NR)
-#define IRQ_EINT_GROUP(group, no)       (IRQ_EINT_GROUP##group##__BASE + (x))
+#define IRQ_EINT_GROUP(group, no)       (IRQ_EINT_GROUP##group##_BASE + (no))
 /* Set the default NR_IRQS */
diff --git a/arch/avr32/mach-at32ap/at32ap700x.c b/arch/avr32/mach-at32ap/at32ap700x.c
index ea7bc1e8562b..3fbfd1e32a9e 100644
--- a/arch/avr32/mach-at32ap/at32ap700x.c
+++ b/arch/avr32/mach-at32ap/at32ap700x.c
@@ -1305,7 +1305,7 @@ struct platform_device *__init
 at32_add_device_mci(unsigned int id, struct mci_platform_data *data)
 {
        struct platform_device          *pdev;
-        struct dw_dma_slave             *dws;
+        struct dw_dma_slave             *dws = &data->dma_slave;
        u32                             pioa_mask;
        u32                             piob_mask;
@@ -1324,22 +1324,13 @@ at32_add_device_mci(unsigned int id, struct mci_platform_data *data)
                                ARRAY_SIZE(atmel_mci0_resource)))
                goto fail;
-        if (data->dma_slave)
+        dws->dma_dev = &dw_dmac0_device.dev;
-                dws = kmemdup(to_dw_dma_slave(data->dma_slave),
+        dws->reg_width = DW_DMA_SLAVE_WIDTH_32BIT;
-                                sizeof(struct dw_dma_slave), GFP_KERNEL);
-        else
-                dws = kzalloc(sizeof(struct dw_dma_slave), GFP_KERNEL);
-        dws->slave.dev = &pdev->dev;
-        dws->slave.dma_dev = &dw_dmac0_device.dev;
-        dws->slave.reg_width = DMA_SLAVE_WIDTH_32BIT;
        dws->cfg_hi = (DWC_CFGH_SRC_PER(0)
                                | DWC_CFGH_DST_PER(1));
        dws->cfg_lo &= ~(DWC_CFGL_HS_DST_POL
                                | DWC_CFGL_HS_SRC_POL);
-        data->dma_slave = &dws->slave;
        if (platform_device_add_data(pdev, data,
                                sizeof(struct mci_platform_data)))
                goto fail;
diff --git a/arch/blackfin/include/asm/mmu.h b/arch/blackfin/include/asm/mmu.h
index 757e43906ed4..dbfd686360e6 100644
--- a/arch/blackfin/include/asm/mmu.h
+++ b/arch/blackfin/include/asm/mmu.h
@@ -10,7 +10,6 @@ struct sram_list_struct {
 };
 typedef struct {
-        struct vm_list_struct *vmlist;
        unsigned long end_brk;
        unsigned long stack_start;
diff --git a/arch/blackfin/kernel/ptrace.c b/arch/blackfin/kernel/ptrace.c
index d2d388536630..594e325b40e4 100644
--- a/arch/blackfin/kernel/ptrace.c
+++ b/arch/blackfin/kernel/ptrace.c
@@ -160,15 +160,15 @@ put_reg(struct task_struct *task, int regno, unsigned long data)
 static inline int is_user_addr_valid(struct task_struct *child,
                                     unsigned long start, unsigned long len)
 {
-        struct vm_list_struct *vml;
+        struct vm_area_struct *vma;
        struct sram_list_struct *sraml;
        /* overflow */
        if (start + len < start)
                return -EIO;
-        for (vml = child->mm->context.vmlist; vml; vml = vml->next)
+        vma = find_vma(child->mm, start);
-                if (start >= vml->vma->vm_start && start + len < vml->vma->vm_end)
+        if (vma && start >= vma->vm_start && start + len <= vma->vm_end)
                        return 0;
        for (sraml = child->mm->context.sram_list; sraml; sraml = sraml->next)
diff --git a/arch/blackfin/kernel/traps.c b/arch/blackfin/kernel/traps.c
index 17d8e4172896..5b0667da8d05 100644
--- a/arch/blackfin/kernel/traps.c
+++ b/arch/blackfin/kernel/traps.c
@@ -32,6 +32,7 @@
 #include <linux/module.h>
 #include <linux/kallsyms.h>
 #include <linux/fs.h>
+#include <linux/rbtree.h>
 #include <asm/traps.h>
 #include <asm/cacheflush.h>
 #include <asm/cplb.h>
@@ -83,6 +84,7 @@ static void decode_address(char *buf, unsigned long address)
        struct mm_struct *mm;
        unsigned long flags, offset;
        unsigned char in_atomic = (bfin_read_IPEND() & 0x10) || in_atomic();
+        struct rb_node *n;
 #ifdef CONFIG_KALLSYMS
        unsigned long symsize;
@@ -128,9 +130,10 @@ static void decode_address(char *buf, unsigned long address)
                if (!mm)
                        continue;
-                vml = mm->context.vmlist;
+                for (n = rb_first(&mm->mm_rb); n; n = rb_next(n)) {
-                while (vml) {
+                        struct vm_area_struct *vma;
-                        struct vm_area_struct *vma = vml->vma;
+                        vma = rb_entry(n, struct vm_area_struct, vm_rb);
                        if (address >= vma->vm_start && address < vma->vm_end) {
                                char _tmpbuf[256];
@@ -176,8 +179,6 @@ static void decode_address(char *buf, unsigned long address)
                                goto done;
                        }
-                        vml = vml->next;
                }
                if (!in_atomic)
                        mmput(mm);
diff --git a/arch/frv/kernel/ptrace.c b/arch/frv/kernel/ptrace.c
index 709e9bdc6126..5e7d401d21e7 100644
--- a/arch/frv/kernel/ptrace.c
+++ b/arch/frv/kernel/ptrace.c
@@ -69,7 +69,8 @@ static inline int put_reg(struct task_struct *task, int regno,
 }
 /*
- * check that an address falls within the bounds of the target process's memory mappings
+ * check that an address falls within the bounds of the target process's memory
+ * mappings
 */
 static inline int is_user_addr_valid(struct task_struct *child,
                                     unsigned long start, unsigned long len)
@@ -79,11 +80,11 @@ static inline int is_user_addr_valid(struct task_struct *child,
                return -EIO;
        return 0;
 #else
-        struct vm_list_struct *vml;
+        struct vm_area_struct *vma;
-        for (vml = child->mm->context.vmlist; vml; vml = vml->next)
+        vma = find_vma(child->mm, start);
-                if (start >= vml->vma->vm_start && start + len <= vml->vma->vm_end)
+        if (vma && start >= vma->vm_start && start + len <= vma->vm_end)
-                        return 0;
+                return 0;
        return -EIO;
 #endif
diff --git a/arch/h8300/include/asm/mmu.h b/arch/h8300/include/asm/mmu.h
index 2ce06ea46104..31309969df70 100644
--- a/arch/h8300/include/asm/mmu.h
+++ b/arch/h8300/include/asm/mmu.h
@@ -4,7 +4,6 @@
 /* Copyright (C) 2002, David McCullough <davidm@snapgear.com> */
 typedef struct {
-        struct vm_list_struct   *vmlist;
        unsigned long           end_brk;
 } mm_context_t;
diff --git a/arch/ia64/include/asm/acpi-ext.h b/arch/ia64/include/asm/acpi-ext.h
index 734d137dda6e..7f8362b379eb 100644
--- a/arch/ia64/include/asm/acpi-ext.h
+++ b/arch/ia64/include/asm/acpi-ext.h
@@ -14,7 +14,6 @@
 #define _ASM_IA64_ACPI_EXT_H
 #include <linux/types.h>
-#include <acpi/actypes.h>
 extern acpi_status hp_acpi_csr_space (acpi_handle, u64 *base, u64 *length);
diff --git a/arch/ia64/include/asm/irq.h b/arch/ia64/include/asm/irq.h
index 36429a532630..5282546cdf82 100644
--- a/arch/ia64/include/asm/irq.h
+++ b/arch/ia64/include/asm/irq.h
@@ -27,7 +27,7 @@ irq_canonicalize (int irq)
 }
 extern void set_irq_affinity_info (unsigned int irq, int dest, int redir);
-bool is_affinity_mask_valid(cpumask_var_t cpumask);
+bool is_affinity_mask_valid(const struct cpumask *cpumask);
 #define is_affinity_mask_valid is_affinity_mask_valid
diff --git a/arch/ia64/include/asm/sn/acpi.h b/arch/ia64/include/asm/sn/acpi.h
index 9ce2801cbd57..fd480db25565 100644
--- a/arch/ia64/include/asm/sn/acpi.h
+++ b/arch/ia64/include/asm/sn/acpi.h
@@ -9,8 +9,6 @@
 #ifndef _ASM_IA64_SN_ACPI_H
 #define _ASM_IA64_SN_ACPI_H
-#include "acpi/acglobal.h"
 extern int sn_acpi_rev;
 #define SN_ACPI_BASE_SUPPORT()   (sn_acpi_rev >= 0x20101)
diff --git a/arch/ia64/include/asm/topology.h b/arch/ia64/include/asm/topology.h
index 76a33a91ca69..32f3af1641c5 100644
--- a/arch/ia64/include/asm/topology.h
+++ b/arch/ia64/include/asm/topology.h
@@ -124,7 +124,7 @@ extern void arch_fix_phys_package_id(int num, u32 slot);
 #define cpumask_of_pcibus(bus)  (pcibus_to_node(bus) == -1 ?            \
                                 cpu_all_mask :                         \
-                                 cpumask_from_node(pcibus_to_node(bus)))
+                                 cpumask_of_node(pcibus_to_node(bus)))
 #include <asm-generic/topology.h>
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 0553648b7595..d541671caf4a 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -65,6 +65,7 @@ EXPORT_SYMBOL(pm_idle);
 void (*pm_power_off) (void);
 EXPORT_SYMBOL(pm_power_off);
+u32 acpi_rsdt_forced;
 unsigned int acpi_cpei_override;
 unsigned int acpi_cpei_phys_cpuid;
diff --git a/arch/ia64/kernel/irq.c b/arch/ia64/kernel/irq.c
index 95ff16cb05d8..a58f64ca9f0e 100644
--- a/arch/ia64/kernel/irq.c
+++ b/arch/ia64/kernel/irq.c
@@ -102,17 +102,14 @@ static char irq_redir [NR_IRQS]; // = { [0 ... NR_IRQS-1] = 1 };
 void set_irq_affinity_info (unsigned int irq, int hwid, int redir)
 {
-        cpumask_t mask = CPU_MASK_NONE;
-        cpu_set(cpu_logical_id(hwid), mask);
        if (irq < NR_IRQS) {
-                irq_desc[irq].affinity = mask;
+                cpumask_copy(&irq_desc[irq].affinity,
+                             cpumask_of(cpu_logical_id(hwid)));
                irq_redir[irq] = (char) (redir & 0xff);
        }
 }
-bool is_affinity_mask_valid(cpumask_var_t cpumask)
+bool is_affinity_mask_valid(const struct cpumask *cpumask)
 {
        if (ia64_platform_is("sn2")) {
                /* Only allow one CPU to be specified in the smp_affinity mask */
@@ -128,7 +125,7 @@ bool is_affinity_mask_valid(cpumask_var_t cpumask)
 unsigned int vectors_in_migration[NR_IRQS];
 /*
- * Since cpu_online_map is already updated, we just need to check for
+ * Since cpu_online_mask is already updated, we just need to check for
 * affinity that has zeros
 */
 static void migrate_irqs(void)
@@ -158,7 +155,7 @@ static void migrate_irqs(void)
                         */
                        vectors_in_migration[irq] = irq;
-                        new_cpu = any_online_cpu(cpu_online_map);
+                        new_cpu = cpumask_any(cpu_online_mask);
                        /*
                         * Al three are essential, currently WARN_ON.. maybe panic?
@@ -191,7 +188,7 @@ void fixup_irqs(void)
         * Find a new timesync master
         */
        if (smp_processor_id() == time_keeper_id) {
-                time_keeper_id = first_cpu(cpu_online_map);
+                time_keeper_id = cpumask_first(cpu_online_mask);
                printk ("CPU %d is now promoted to time-keeper master\n", time_keeper_id);
        }
diff --git a/arch/ia64/sn/kernel/io_acpi_init.c b/arch/ia64/sn/kernel/io_acpi_init.c
index bc610a6c7851..c5a214026a77 100644
--- a/arch/ia64/sn/kernel/io_acpi_init.c
+++ b/arch/ia64/sn/kernel/io_acpi_init.c
@@ -13,7 +13,6 @@
 #include <asm/sn/sn_sal.h>
 #include "xtalk/hubdev.h"
 #include <linux/acpi.h>
-#include <acpi/acnamesp.h>
 /*
@@ -64,6 +63,7 @@ static acpi_status __init
 sn_acpi_hubdev_init(acpi_handle handle, u32 depth, void *context, void **ret)
 {
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        u64 addr;
        struct hubdev_info *hubdev;
        struct hubdev_info *hubdev_ptr;
@@ -77,11 +77,12 @@ sn_acpi_hubdev_init(acpi_handle handle, u32 depth, void *context, void **ret)
        status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
                                          &sn_uuid, &buffer);
        if (ACPI_FAILURE(status)) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                printk(KERN_ERR
                       "sn_acpi_hubdev_init: acpi_get_vendor_resource() "
-                       "(0x%x) failed for: ", status);
+                       "(0x%x) failed for: %s\n", status,
-                acpi_ns_print_node_pathname(handle, NULL);
+                        (char *)name_buffer.pointer);
-                printk("\n");
+                kfree(name_buffer.pointer);
                return AE_OK;           /* Continue walking namespace */
        }
@@ -89,11 +90,12 @@ sn_acpi_hubdev_init(acpi_handle handle, u32 depth, void *context, void **ret)
        vendor = &resource->data.vendor_typed;
        if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
            sizeof(struct hubdev_info *)) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                printk(KERN_ERR
-                       "sn_acpi_hubdev_init: Invalid vendor data length: %d for: ",
+                       "sn_acpi_hubdev_init: Invalid vendor data length: "
-                        vendor->byte_length);
+                       "%d for: %s\n",
-                acpi_ns_print_node_pathname(handle, NULL);
+                        vendor->byte_length, (char *)name_buffer.pointer);
-                printk("\n");
+                kfree(name_buffer.pointer);
                goto exit;
        }
@@ -120,6 +122,7 @@ sn_get_bussoft_ptr(struct pci_bus *bus)
 {
        u64 addr;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        acpi_handle handle;
        struct pcibus_bussoft *prom_bussoft_ptr;
        struct acpi_resource *resource;
@@ -131,11 +134,11 @@ sn_get_bussoft_ptr(struct pci_bus *bus)
        status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
                                          &sn_uuid, &buffer);
        if (ACPI_FAILURE(status)) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                printk(KERN_ERR "%s: "
-                       "acpi_get_vendor_resource() failed (0x%x) for: ",
+                       "acpi_get_vendor_resource() failed (0x%x) for: %s\n",
-                       __func__, status);
+                       __func__, status, (char *)name_buffer.pointer);
-                acpi_ns_print_node_pathname(handle, NULL);
+                kfree(name_buffer.pointer);
-                printk("\n");
                return NULL;
        }
        resource = buffer.pointer;
@@ -168,6 +171,7 @@ sn_extract_device_info(acpi_handle handle, struct pcidev_info **pcidev_info,
 {
        u64 addr;
        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct sn_irq_info *irq_info, *irq_info_prom;
        struct pcidev_info *pcidev_ptr, *pcidev_prom_ptr;
        struct acpi_resource *resource;
@@ -182,11 +186,11 @@ sn_extract_device_info(acpi_handle handle, struct pcidev_info **pcidev_info,
        status = acpi_get_vendor_resource(handle, METHOD_NAME__CRS,
                                          &sn_uuid, &buffer);
        if (ACPI_FAILURE(status)) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                printk(KERN_ERR
-                       "%s: acpi_get_vendor_resource() failed (0x%x) for: ",
+                       "%s: acpi_get_vendor_resource() failed (0x%x) for: %s\n",
-                        __func__, status);
+                        __func__, status, (char *)name_buffer.pointer);
-                acpi_ns_print_node_pathname(handle, NULL);
+                kfree(name_buffer.pointer);
-                printk("\n");
                return 1;
        }
@@ -194,11 +198,12 @@ sn_extract_device_info(acpi_handle handle, struct pcidev_info **pcidev_info,
        vendor = &resource->data.vendor_typed;
        if ((vendor->byte_length - sizeof(struct acpi_vendor_uuid)) !=
            sizeof(struct pci_devdev_info *)) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                printk(KERN_ERR
-                       "%s: Invalid vendor data length: %d for: ",
+                       "%s: Invalid vendor data length: %d for: %s\n",
-                        __func__, vendor->byte_length);
+                         __func__, vendor->byte_length,
-                acpi_ns_print_node_pathname(handle, NULL);
+                        (char *)name_buffer.pointer);
-                printk("\n");
+                kfree(name_buffer.pointer);
                ret = 1;
                goto exit;
        }
@@ -239,6 +244,9 @@ get_host_devfn(acpi_handle device_handle, acpi_handle rootbus_handle)
        acpi_handle parent;
        int slot;
        acpi_status status;
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        acpi_get_name(device_handle, ACPI_FULL_PATHNAME, &name_buffer);
        /*
         * Do an upward search to find the root bus device, and
@@ -249,9 +257,8 @@ get_host_devfn(acpi_handle device_handle, acpi_handle rootbus_handle)
                status = acpi_get_parent(child, &parent);
                if (ACPI_FAILURE(status)) {
                        printk(KERN_ERR "%s: acpi_get_parent() failed "
-                               "(0x%x) for: ", __func__, status);
+                               "(0x%x) for: %s\n", __func__, status,
-                        acpi_ns_print_node_pathname(child, NULL);
+                                (char *)name_buffer.pointer);
-                        printk("\n");
                        panic("%s: Unable to find host devfn\n", __func__);
                }
                if (parent == rootbus_handle)
@@ -259,22 +266,20 @@ get_host_devfn(acpi_handle device_handle, acpi_handle rootbus_handle)
                child = parent;
        }
        if (!child) {
-                printk(KERN_ERR "%s: Unable to find root bus for: ",
+                printk(KERN_ERR "%s: Unable to find root bus for: %s\n",
-                       __func__);
+                       __func__, (char *)name_buffer.pointer);
-                acpi_ns_print_node_pathname(device_handle, NULL);
-                printk("\n");
                BUG();
        }
        status = acpi_evaluate_integer(child, METHOD_NAME__ADR, NULL, &adr);
        if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR "%s: Unable to get _ADR (0x%x) for: ",
+                printk(KERN_ERR "%s: Unable to get _ADR (0x%x) for: %s\n",
-                       __func__, status);
+                       __func__, status, (char *)name_buffer.pointer);
-                acpi_ns_print_node_pathname(child, NULL);
-                printk("\n");
                panic("%s: Unable to find host devfn\n", __func__);
        }
+        kfree(name_buffer.pointer);
        slot = (adr >> 16) & 0xffff;
        function = adr & 0xffff;
        devfn = PCI_DEVFN(slot, function);
@@ -300,27 +305,28 @@ find_matching_device(acpi_handle handle, u32 lvl, void *context, void **rv)
        int function;
        int slot;
        struct sn_pcidev_match *info = context;
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
                                       &adr);
        if (ACPI_SUCCESS(status)) {
                status = acpi_get_parent(handle, &parent);
                if (ACPI_FAILURE(status)) {
+                        acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                        printk(KERN_ERR
-                               "%s: acpi_get_parent() failed (0x%x) for: ",
+                               "%s: acpi_get_parent() failed (0x%x) for: %s\n",
-                                        __func__, status);
+                                __func__, status, (char *)name_buffer.pointer);
-                        acpi_ns_print_node_pathname(handle, NULL);
+                        kfree(name_buffer.pointer);
-                        printk("\n");
                        return AE_OK;
                }
                status = acpi_evaluate_integer(parent, METHOD_NAME__BBN,
                                               NULL, &bbn);
                if (ACPI_FAILURE(status)) {
+                        acpi_get_name(handle, ACPI_FULL_PATHNAME, &name_buffer);
                        printk(KERN_ERR
-                          "%s: Failed to find _BBN in parent of: ",
+                          "%s: Failed to find _BBN in parent of: %s\n",
-                                        __func__);
+                                        __func__, (char *)name_buffer.pointer);
-                        acpi_ns_print_node_pathname(handle, NULL);
+                        kfree(name_buffer.pointer);
-                        printk("\n");
                        return AE_OK;
                }
@@ -350,24 +356,27 @@ sn_acpi_get_pcidev_info(struct pci_dev *dev, struct pcidev_info **pcidev_info,
        acpi_handle rootbus_handle;
        unsigned long long segment;
        acpi_status status;
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        rootbus_handle = PCI_CONTROLLER(dev)->acpi_handle;
        status = acpi_evaluate_integer(rootbus_handle, METHOD_NAME__SEG, NULL,
                                       &segment);
        if (ACPI_SUCCESS(status)) {
                if (segment != pci_domain_nr(dev)) {
+                        acpi_get_name(rootbus_handle, ACPI_FULL_PATHNAME,
+                                &name_buffer);
                        printk(KERN_ERR
-                               "%s: Segment number mismatch, 0x%llx vs 0x%x for: ",
+                               "%s: Segment number mismatch, 0x%llx vs 0x%x for: %s\n",
-                               __func__, segment, pci_domain_nr(dev));
+                               __func__, segment, pci_domain_nr(dev),
-                        acpi_ns_print_node_pathname(rootbus_handle, NULL);
+                               (char *)name_buffer.pointer);
-                        printk("\n");
+                        kfree(name_buffer.pointer);
                        return 1;
                }
        } else {
-                printk(KERN_ERR "%s: Unable to get __SEG from: ",
+                acpi_get_name(rootbus_handle, ACPI_FULL_PATHNAME, &name_buffer);
-                       __func__);
+                printk(KERN_ERR "%s: Unable to get __SEG from: %s\n",
-                acpi_ns_print_node_pathname(rootbus_handle, NULL);
+                       __func__, (char *)name_buffer.pointer);
-                printk("\n");
+                kfree(name_buffer.pointer);
                return 1;
        }
diff --git a/arch/ia64/sn/kernel/io_common.c b/arch/ia64/sn/kernel/io_common.c
index 8a924a5661dd..0d4ffa4da1da 100644
--- a/arch/ia64/sn/kernel/io_common.c
+++ b/arch/ia64/sn/kernel/io_common.c
@@ -26,7 +26,6 @@
 #include <linux/acpi.h>
 #include <asm/sn/sn2/sn_hwperf.h>
 #include <asm/sn/acpi.h>
-#include "acpi/acglobal.h"
 extern void sn_init_cpei_timer(void);
 extern void register_sn_procfs(void);
@@ -473,7 +472,7 @@ sn_io_early_init(void)
        {
                struct acpi_table_header *header = NULL;
-                acpi_get_table_by_index(ACPI_TABLE_INDEX_DSDT, &header);
+                acpi_get_table(ACPI_SIG_DSDT, 1, &header);
                BUG_ON(header == NULL);
                sn_acpi_rev = header->oem_revision;
        }
@@ -505,7 +504,7 @@ sn_io_early_init(void)
        {
                struct acpi_table_header *header;
-                (void)acpi_get_table_by_index(ACPI_TABLE_INDEX_DSDT, &header);
+                (void)acpi_get_table(ACPI_SIG_DSDT, 1, &header);
                printk(KERN_INFO "ACPI  DSDT OEM Rev 0x%x\n",
                        header->oem_revision);
        }
diff --git a/arch/m68knommu/include/asm/mmu.h b/arch/m68knommu/include/asm/mmu.h
index 5fa6b68353ba..e2da1e6f09fe 100644
--- a/arch/m68knommu/include/asm/mmu.h
+++ b/arch/m68knommu/include/asm/mmu.h
@@ -4,7 +4,6 @@
 /* Copyright (C) 2002, David McCullough <davidm@snapgear.com> */
 typedef struct {
-        struct vm_list_struct   *vmlist;
        unsigned long           end_brk;
 } mm_context_t;
diff --git a/arch/mips/pci/pci-ip27.c b/arch/mips/pci/pci-ip27.c
index f97ab1461012..dda6f2058665 100644
--- a/arch/mips/pci/pci-ip27.c
+++ b/arch/mips/pci/pci-ip27.c
@@ -146,12 +146,6 @@ int __devinit pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
        return 0;
 }
-/* Most MIPS systems have straight-forward swizzling needs.  */
-static inline u8 bridge_swizzle(u8 pin, u8 slot)
-{
-        return (((pin - 1) + slot) % 4) + 1;
-}
 static inline struct pci_dev *bridge_root_dev(struct pci_dev *dev)
 {
        while (dev->bus->parent) {
diff --git a/arch/mips/pci/pci.c b/arch/mips/pci/pci.c
index 62cae740e250..b0eb9e75c682 100644
--- a/arch/mips/pci/pci.c
+++ b/arch/mips/pci/pci.c
@@ -149,28 +149,6 @@ out:
               "Skipping PCI bus scan due to resource conflict\n");
 }
-/* Most MIPS systems have straight-forward swizzling needs.  */
-static inline u8 bridge_swizzle(u8 pin, u8 slot)
-{
-        return (((pin - 1) + slot) % 4) + 1;
-}
-static u8 __init common_swizzle(struct pci_dev *dev, u8 *pinp)
-{
-        u8 pin = *pinp;
-        while (dev->bus->parent) {
-                pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
-                /* Move up the chain of bridges. */
-                dev = dev->bus->self;
-        }
-        *pinp = pin;
-        /* The slot is the slot of the last bridge. */
-        return PCI_SLOT(dev->devfn);
-}
 static int __init pcibios_init(void)
 {
        struct pci_controller *hose;
@@ -179,7 +157,7 @@ static int __init pcibios_init(void)
        for (hose = hose_head; hose; hose = hose->next)
                pcibios_scanbus(hose);
-        pci_fixup_irqs(common_swizzle, pcibios_map_irq);
+        pci_fixup_irqs(pci_common_swizzle, pcibios_map_irq);
        pci_initialized = 1;
diff --git a/arch/parisc/Makefile b/arch/parisc/Makefile
index 5ddad7bd60ac..0d428278356d 100644
--- a/arch/parisc/Makefile
+++ b/arch/parisc/Makefile
@@ -77,7 +77,7 @@ libs-y	+= arch/parisc/lib/ `$(CC) -print-libgcc-file-name`
 drivers-$(CONFIG_OPROFILE)              += arch/parisc/oprofile/
-PALO := $(shell if which palo; then : ; \
+PALO := $(shell if (which palo 2>&1); then : ; \
        elif [ -x /sbin/palo ]; then echo /sbin/palo; \
        fi)
diff --git a/arch/parisc/include/asm/Kbuild b/arch/parisc/include/asm/Kbuild
index f88b252e419c..2121d99f8364 100644
--- a/arch/parisc/include/asm/Kbuild
+++ b/arch/parisc/include/asm/Kbuild
@@ -1,3 +1,4 @@
 include include/asm-generic/Kbuild.asm
 unifdef-y += pdc.h
+unifdef-y += swab.h
diff --git a/arch/parisc/include/asm/byteorder.h b/arch/parisc/include/asm/byteorder.h
index db148313de5d..da66029c4cb2 100644
--- a/arch/parisc/include/asm/byteorder.h
+++ b/arch/parisc/include/asm/byteorder.h
@@ -1,82 +1,7 @@
 #ifndef _PARISC_BYTEORDER_H
 #define _PARISC_BYTEORDER_H
-#include <asm/types.h>
+#include <asm/swab.h>
-#include <linux/compiler.h>
-#ifdef __GNUC__
-static __inline__ __attribute_const__ __u16 ___arch__swab16(__u16 x)
-{
-        __asm__("dep %0, 15, 8, %0\n\t"         /* deposit 00ab -> 0bab */
-                "shd %%r0, %0, 8, %0"           /* shift 000000ab -> 00ba */
-                : "=r" (x)
-                : "0" (x));
-        return x;
-}
-static __inline__ __attribute_const__ __u32 ___arch__swab24(__u32 x)
-{
-        __asm__("shd %0, %0, 8, %0\n\t"         /* shift xabcxabc -> cxab */
-                "dep %0, 15, 8, %0\n\t"         /* deposit cxab -> cbab */
-                "shd %%r0, %0, 8, %0"           /* shift 0000cbab -> 0cba */
-                : "=r" (x)
-                : "0" (x));
-        return x;
-}
-static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
-{
-        unsigned int temp;
-        __asm__("shd %0, %0, 16, %1\n\t"        /* shift abcdabcd -> cdab */
-                "dep %1, 15, 8, %1\n\t"         /* deposit cdab -> cbab */
-                "shd %0, %1, 8, %0"             /* shift abcdcbab -> dcba */
-                : "=r" (x), "=&r" (temp)
-                : "0" (x));
-        return x;
-}
-#if BITS_PER_LONG > 32
-/*
-** From "PA-RISC 2.0 Architecture", HP Professional Books.
-** See Appendix I page 8 , "Endian Byte Swapping".
-**
-** Pretty cool algorithm: (* == zero'd bits)
-**      PERMH   01234567 -> 67452301 into %0
-**      HSHL    67452301 -> 7*5*3*1* into %1
-**      HSHR    67452301 -> *6*4*2*0 into %0
-**      OR      %0 | %1  -> 76543210 into %0 (all done!)
-*/
-static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 x) {
-        __u64 temp;
-        __asm__("permh,3210 %0, %0\n\t"
-                "hshl %0, 8, %1\n\t"
-                "hshr,u %0, 8, %0\n\t"
-                "or %1, %0, %0"
-                : "=r" (x), "=&r" (temp)
-                : "0" (x));
-        return x;
-}
-#define __arch__swab64(x) ___arch__swab64(x)
-#define __BYTEORDER_HAS_U64__
-#elif !defined(__STRICT_ANSI__)
-static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 x)
-{
-        __u32 t1 = ___arch__swab32((__u32) x);
-        __u32 t2 = ___arch__swab32((__u32) (x >> 32));
-        return (((__u64) t1 << 32) | t2);
-}
-#define __arch__swab64(x) ___arch__swab64(x)
-#define __BYTEORDER_HAS_U64__
-#endif
-#define __arch__swab16(x) ___arch__swab16(x)
-#define __arch__swab24(x) ___arch__swab24(x)
-#define __arch__swab32(x) ___arch__swab32(x)
-#endif /* __GNUC__ */
 #include <linux/byteorder/big_endian.h>
 #endif /* _PARISC_BYTEORDER_H */
diff --git a/arch/parisc/include/asm/checksum.h b/arch/parisc/include/asm/checksum.h
index e9639ccc3fce..c84b2fcb18a9 100644
--- a/arch/parisc/include/asm/checksum.h
+++ b/arch/parisc/include/asm/checksum.h
@@ -182,7 +182,7 @@ static __inline__ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
 #endif
        : "=r" (sum), "=r" (saddr), "=r" (daddr), "=r" (len)
        : "0" (sum), "1" (saddr), "2" (daddr), "3" (len), "r" (proto)
-        : "r19", "r20", "r21", "r22");
+        : "r19", "r20", "r21", "r22", "memory");
        return csum_fold(sum);
 }
diff --git a/arch/parisc/include/asm/io.h b/arch/parisc/include/asm/io.h
index 55ddb1842107..d3031d1f9d03 100644
--- a/arch/parisc/include/asm/io.h
+++ b/arch/parisc/include/asm/io.h
@@ -4,12 +4,6 @@
 #include <linux/types.h>
 #include <asm/pgtable.h>
-extern unsigned long parisc_vmerge_boundary;
-extern unsigned long parisc_vmerge_max_size;
-#define BIO_VMERGE_BOUNDARY     parisc_vmerge_boundary
-#define BIO_VMERGE_MAX_SIZE     parisc_vmerge_max_size
 #define virt_to_phys(a) ((unsigned long)__pa(a))
 #define phys_to_virt(a) __va(a)
 #define virt_to_bus virt_to_phys
@@ -182,9 +176,9 @@ static inline void __raw_writeq(unsigned long long b, volatile void __iomem *add
 /* readb can never be const, so use __fswab instead of le*_to_cpu */
 #define readb(addr) __raw_readb(addr)
-#define readw(addr) __fswab16(__raw_readw(addr))
+#define readw(addr) le16_to_cpu(__raw_readw(addr))
-#define readl(addr) __fswab32(__raw_readl(addr))
+#define readl(addr) le32_to_cpu(__raw_readl(addr))
-#define readq(addr) __fswab64(__raw_readq(addr))
+#define readq(addr) le64_to_cpu(__raw_readq(addr))
 #define writeb(b, addr) __raw_writeb(b, addr)
 #define writew(b, addr) __raw_writew(cpu_to_le16(b), addr)
 #define writel(b, addr) __raw_writel(cpu_to_le32(b), addr)
diff --git a/arch/parisc/include/asm/mmu_context.h b/arch/parisc/include/asm/mmu_context.h
index 85856c74ad1d..354b2aca990e 100644
--- a/arch/parisc/include/asm/mmu_context.h
+++ b/arch/parisc/include/asm/mmu_context.h
@@ -34,16 +34,21 @@ destroy_context(struct mm_struct *mm)
        mm->context = 0;
 }
-static inline void load_context(mm_context_t context)
+static inline unsigned long __space_to_prot(mm_context_t context)
 {
-        mtsp(context, 3);
 #if SPACEID_SHIFT == 0
-        mtctl(context << 1,8);
+        return context << 1;
 #else
-        mtctl(context >> (SPACEID_SHIFT - 1),8);
+        return context >> (SPACEID_SHIFT - 1);
 #endif
 }
+static inline void load_context(mm_context_t context)
+{
+        mtsp(context, 3);
+        mtctl(__space_to_prot(context), 8);
+}
 static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, struct task_struct *tsk)
 {
diff --git a/arch/parisc/include/asm/processor.h b/arch/parisc/include/asm/processor.h
index 3c9d34844c83..9d64df8754ba 100644
--- a/arch/parisc/include/asm/processor.h
+++ b/arch/parisc/include/asm/processor.h
@@ -17,6 +17,7 @@
 #include <asm/ptrace.h>
 #include <asm/types.h>
 #include <asm/system.h>
+#include <asm/percpu.h>
 #endif /* __ASSEMBLY__ */
 #define KERNEL_STACK_SIZE       (4*PAGE_SIZE)
@@ -109,8 +110,7 @@ struct cpuinfo_parisc {
 };
 extern struct system_cpuinfo_parisc boot_cpu_data;
-extern struct cpuinfo_parisc cpu_data[NR_CPUS];
+DECLARE_PER_CPU(struct cpuinfo_parisc, cpu_data);
-#define current_cpu_data cpu_data[smp_processor_id()]
 #define CPU_HVERSION ((boot_cpu_data.hversion >> 4) & 0x0FFF)
diff --git a/arch/parisc/include/asm/swab.h b/arch/parisc/include/asm/swab.h
new file mode 100644
index 000000000000..3ff16c5a3358
--- /dev/null
+++ b/arch/parisc/include/asm/swab.h
@@ -0,0 +1,66 @@
+#ifndef _PARISC_SWAB_H
+#define _PARISC_SWAB_H
+#include <asm/types.h>
+#include <linux/compiler.h>
+#define __SWAB_64_THRU_32__
+static inline __attribute_const__ __u16 __arch_swab16(__u16 x)
+{
+        __asm__("dep %0, 15, 8, %0\n\t"         /* deposit 00ab -> 0bab */
+                "shd %%r0, %0, 8, %0"           /* shift 000000ab -> 00ba */
+                : "=r" (x)
+                : "0" (x));
+        return x;
+}
+#define __arch_swab16 __arch_swab16
+static inline __attribute_const__ __u32 __arch_swab24(__u32 x)
+{
+        __asm__("shd %0, %0, 8, %0\n\t"         /* shift xabcxabc -> cxab */
+                "dep %0, 15, 8, %0\n\t"         /* deposit cxab -> cbab */
+                "shd %%r0, %0, 8, %0"           /* shift 0000cbab -> 0cba */
+                : "=r" (x)
+                : "0" (x));
+        return x;
+}
+static inline __attribute_const__ __u32 __arch_swab32(__u32 x)
+{
+        unsigned int temp;
+        __asm__("shd %0, %0, 16, %1\n\t"        /* shift abcdabcd -> cdab */
+                "dep %1, 15, 8, %1\n\t"         /* deposit cdab -> cbab */
+                "shd %0, %1, 8, %0"             /* shift abcdcbab -> dcba */
+                : "=r" (x), "=&r" (temp)
+                : "0" (x));
+        return x;
+}
+#define __arch_swab32 __arch_swab32
+#if BITS_PER_LONG > 32
+/*
+** From "PA-RISC 2.0 Architecture", HP Professional Books.
+** See Appendix I page 8 , "Endian Byte Swapping".
+**
+** Pretty cool algorithm: (* == zero'd bits)
+**      PERMH   01234567 -> 67452301 into %0
+**      HSHL    67452301 -> 7*5*3*1* into %1
+**      HSHR    67452301 -> *6*4*2*0 into %0
+**      OR      %0 | %1  -> 76543210 into %0 (all done!)
+*/
+static inline __attribute_const__ __u64 __arch_swab64(__u64 x)
+{
+        __u64 temp;
+        __asm__("permh,3210 %0, %0\n\t"
+                "hshl %0, 8, %1\n\t"
+                "hshr,u %0, 8, %0\n\t"
+                "or %1, %0, %0"
+                : "=r" (x), "=&r" (temp)
+                : "0" (x));
+        return x;
+}
+#define __arch_swab64 __arch_swab64
+#endif /* BITS_PER_LONG > 32 */
+#endif /* _PARISC_SWAB_H */
diff --git a/arch/parisc/include/asm/uaccess.h b/arch/parisc/include/asm/uaccess.h
index 4878b9501f24..1c6dbb6f6e56 100644
--- a/arch/parisc/include/asm/uaccess.h
+++ b/arch/parisc/include/asm/uaccess.h
@@ -241,4 +241,6 @@ unsigned long copy_in_user(void __user *dst, const void __user *src, unsigned lo
 #define __copy_to_user_inatomic __copy_to_user
 #define __copy_from_user_inatomic __copy_from_user
+int fixup_exception(struct pt_regs *regs);
 #endif /* __PARISC_UACCESS_H */
diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c
index 884b7ce16a3b..994bcd980909 100644
--- a/arch/parisc/kernel/drivers.c
+++ b/arch/parisc/kernel/drivers.c
@@ -549,6 +549,38 @@ static int parisc_generic_match(struct device *dev, struct device_driver *drv)
        return match_device(to_parisc_driver(drv), to_parisc_device(dev));
 }
+static ssize_t make_modalias(struct device *dev, char *buf)
+{
+        const struct parisc_device *padev = to_parisc_device(dev);
+        const struct parisc_device_id *id = &padev->id;
+        return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n",
+                (u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev,
+                (u32)id->sversion);
+}
+static int parisc_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        const struct parisc_device *padev;
+        char modalias[40];
+        if (!dev)
+                return -ENODEV;
+        padev = to_parisc_device(dev);
+        if (!padev)
+                return -ENODEV;
+        if (add_uevent_var(env, "PARISC_NAME=%s", padev->name))
+                return -ENOMEM;
+        make_modalias(dev, modalias);
+        if (add_uevent_var(env, "MODALIAS=%s", modalias))
+                return -ENOMEM;
+        return 0;
+}
 #define pa_dev_attr(name, field, format_string)                         \
 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf)                \
 {                                                                       \
@@ -566,12 +598,7 @@ pa_dev_attr_id(sversion, "0x%05x\n");
 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct parisc_device *padev = to_parisc_device(dev);
+        return make_modalias(dev, buf);
-        struct parisc_device_id *id = &padev->id;
-        return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n",
-                (u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev,
-                (u32)id->sversion);
 }
 static struct device_attribute parisc_device_attrs[] = {
@@ -587,6 +614,7 @@ static struct device_attribute parisc_device_attrs[] = {
 struct bus_type parisc_bus_type = {
        .name = "parisc",
        .match = parisc_generic_match,
+        .uevent = parisc_uevent,
        .dev_attrs = parisc_device_attrs,
        .probe = parisc_driver_probe,
        .remove = parisc_driver_remove,
diff --git a/arch/parisc/kernel/hpmc.S b/arch/parisc/kernel/hpmc.S
index 2cbf13b3ef11..5595a2f31181 100644
--- a/arch/parisc/kernel/hpmc.S
+++ b/arch/parisc/kernel/hpmc.S
@@ -80,6 +80,7 @@ END(hpmc_pim_data)
        .import intr_save, code
 ENTRY(os_hpmc)
+.os_hpmc:
        /*
         * registers modified:
@@ -295,5 +296,10 @@ os_hpmc_6:
        b .
        nop
 ENDPROC(os_hpmc)
-ENTRY(os_hpmc_end)      /* this label used to compute os_hpmc checksum */
+.os_hpmc_end:
        nop
+.data
+.align 4
+        .export os_hpmc_size
+os_hpmc_size:
+        .word .os_hpmc_end-.os_hpmc
diff --git a/arch/parisc/kernel/irq.c b/arch/parisc/kernel/irq.c
index 4cea935e2f99..ac2c822928c7 100644
--- a/arch/parisc/kernel/irq.c
+++ b/arch/parisc/kernel/irq.c
@@ -298,7 +298,7 @@ unsigned long txn_affinity_addr(unsigned int irq, int cpu)
        irq_desc[irq].affinity = cpumask_of_cpu(cpu);
 #endif
-        return cpu_data[cpu].txn_addr;
+        return per_cpu(cpu_data, cpu).txn_addr;
 }
@@ -309,8 +309,9 @@ unsigned long txn_alloc_addr(unsigned int virt_irq)
        next_cpu++; /* assign to "next" CPU we want this bugger on */
        /* validate entry */
-        while ((next_cpu < NR_CPUS) && (!cpu_data[next_cpu].txn_addr || 
+        while ((next_cpu < NR_CPUS) &&
-                !cpu_online(next_cpu)))
+                (!per_cpu(cpu_data, next_cpu).txn_addr ||
+                 !cpu_online(next_cpu)))
                next_cpu++;
        if (next_cpu >= NR_CPUS) 
@@ -359,7 +360,7 @@ void do_cpu_irq_mask(struct pt_regs *regs)
                printk(KERN_DEBUG "redirecting irq %d from CPU %d to %d\n",
                       irq, smp_processor_id(), cpu);
                gsc_writel(irq + CPU_IRQ_BASE,
-                           cpu_data[cpu].hpa);
+                           per_cpu(cpu_data, cpu).hpa);
                goto set_out;
        }
 #endif
@@ -421,5 +422,5 @@ void __init init_IRQ(void)
 void ack_bad_irq(unsigned int irq)
 {
-        printk("unexpected IRQ %d\n", irq);
+        printk(KERN_WARNING "unexpected IRQ %d\n", irq);
 }
diff --git a/arch/parisc/kernel/pdc_cons.c b/arch/parisc/kernel/pdc_cons.c
index ccb68090781e..1ff366cb9685 100644
--- a/arch/parisc/kernel/pdc_cons.c
+++ b/arch/parisc/kernel/pdc_cons.c
@@ -52,7 +52,7 @@
 #include <linux/tty.h>
 #include <asm/pdc.h>            /* for iodc_call() proto and friends */
-static spinlock_t pdc_console_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(pdc_console_lock);
 static void pdc_console_write(struct console *co, const char *s, unsigned count)
 {
diff --git a/arch/parisc/kernel/perf.c b/arch/parisc/kernel/perf.c
index f696f57faa15..75099efb3bf3 100644
--- a/arch/parisc/kernel/perf.c
+++ b/arch/parisc/kernel/perf.c
@@ -541,9 +541,9 @@ static int __init perf_init(void)
        spin_lock_init(&perf_lock);
        /* TODO: this only lets us access the first cpu.. what to do for SMP? */
-        cpu_device = cpu_data[0].dev;
+        cpu_device = per_cpu(cpu_data, 0).dev;
        printk("Performance monitoring counters enabled for %s\n",
-                cpu_data[0].dev->name);
+                per_cpu(cpu_data, 0).dev->name);
        return 0;
 }
diff --git a/arch/parisc/kernel/processor.c b/arch/parisc/kernel/processor.c
index 370086fb8333..ecb609342feb 100644
--- a/arch/parisc/kernel/processor.c
+++ b/arch/parisc/kernel/processor.c
@@ -3,7 +3,7 @@
 *    Initial setup-routines for HP 9000 based hardware.
 *
 *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
- *    Modifications for PA-RISC (C) 1999 Helge Deller <deller@gmx.de>
+ *    Modifications for PA-RISC (C) 1999-2008 Helge Deller <deller@gmx.de>
 *    Modifications copyright 1999 SuSE GmbH (Philipp Rumpf)
 *    Modifications copyright 2000 Martin K. Petersen <mkp@mkp.net>
 *    Modifications copyright 2000 Philipp Rumpf <prumpf@tux.org>
@@ -46,7 +46,7 @@
 struct system_cpuinfo_parisc boot_cpu_data __read_mostly;
 EXPORT_SYMBOL(boot_cpu_data);
-struct cpuinfo_parisc cpu_data[NR_CPUS] __read_mostly;
+DEFINE_PER_CPU(struct cpuinfo_parisc, cpu_data);
 extern int update_cr16_clocksource(void);       /* from time.c */
@@ -69,6 +69,23 @@ extern int update_cr16_clocksource(void);	/* from time.c */
 */
 /**
+ * init_cpu_profiler - enable/setup per cpu profiling hooks.
+ * @cpunum: The processor instance.
+ *
+ * FIXME: doesn't do much yet...
+ */
+static void __cpuinit
+init_percpu_prof(unsigned long cpunum)
+{
+        struct cpuinfo_parisc *p;
+        p = &per_cpu(cpu_data, cpunum);
+        p->prof_counter = 1;
+        p->prof_multiplier = 1;
+}
+/**
 * processor_probe - Determine if processor driver should claim this device.
 * @dev: The device which has been found.
 *
@@ -147,7 +164,7 @@ static int __cpuinit processor_probe(struct parisc_device *dev)
        }
 #endif
-        p = &cpu_data[cpuid];
+        p = &per_cpu(cpu_data, cpuid);
        boot_cpu_data.cpu_count++;
        /* initialize counters - CPU 0 gets it_value set in time_init() */
@@ -162,12 +179,9 @@ static int __cpuinit processor_probe(struct parisc_device *dev)
 #ifdef CONFIG_SMP
        /*
        ** FIXME: review if any other initialization is clobbered
-        **      for boot_cpu by the above memset().
+        **        for boot_cpu by the above memset().
        */
+        init_percpu_prof(cpuid);
-        /* stolen from init_percpu_prof() */
-        cpu_data[cpuid].prof_counter = 1;
-        cpu_data[cpuid].prof_multiplier = 1;
 #endif
        /*
@@ -261,19 +275,6 @@ void __init collect_boot_cpu_data(void)
 }
-/**
- * init_cpu_profiler - enable/setup per cpu profiling hooks.
- * @cpunum: The processor instance.
- *
- * FIXME: doesn't do much yet...
- */
-static inline void __init
-init_percpu_prof(int cpunum)
-{
-        cpu_data[cpunum].prof_counter = 1;
-        cpu_data[cpunum].prof_multiplier = 1;
-}
 /**
 * init_per_cpu - Handle individual processor initializations.
@@ -293,7 +294,7 @@ init_percpu_prof(int cpunum)
 *
 * o Enable CPU profiling hooks.
 */
-int __init init_per_cpu(int cpunum)
+int __cpuinit init_per_cpu(int cpunum)
 {
        int ret;
        struct pdc_coproc_cfg coproc_cfg;
@@ -307,8 +308,8 @@ int __init init_per_cpu(int cpunum)
                /* FWIW, FP rev/model is a more accurate way to determine
                ** CPU type. CPU rev/model has some ambiguous cases.
                */
-                cpu_data[cpunum].fp_rev = coproc_cfg.revision;
+                per_cpu(cpu_data, cpunum).fp_rev = coproc_cfg.revision;
-                cpu_data[cpunum].fp_model = coproc_cfg.model;
+                per_cpu(cpu_data, cpunum).fp_model = coproc_cfg.model;
                printk(KERN_INFO  "FP[%d] enabled: Rev %ld Model %ld\n",
                        cpunum, coproc_cfg.revision, coproc_cfg.model);
@@ -344,16 +345,17 @@ int __init init_per_cpu(int cpunum)
 int
 show_cpuinfo (struct seq_file *m, void *v)
 {
-        int     n;
+        unsigned long cpu;
-        for(n=0; n<boot_cpu_data.cpu_count; n++) {
+        for_each_online_cpu(cpu) {
+                const struct cpuinfo_parisc *cpuinfo = &per_cpu(cpu_data, cpu);
 #ifdef CONFIG_SMP
-                if (0 == cpu_data[n].hpa)
+                if (0 == cpuinfo->hpa)
                        continue;
 #endif
-                seq_printf(m, "processor\t: %d\n"
+                seq_printf(m, "processor\t: %lu\n"
                                "cpu family\t: PA-RISC %s\n",
-                                 n, boot_cpu_data.family_name);
+                                 cpu, boot_cpu_data.family_name);
                seq_printf(m, "cpu\t\t: %s\n",  boot_cpu_data.cpu_name );
@@ -365,8 +367,8 @@ show_cpuinfo (struct seq_file *m, void *v)
                seq_printf(m, "model\t\t: %s\n"
                                "model name\t: %s\n",
                                 boot_cpu_data.pdc.sys_model_name,
-                                 cpu_data[n].dev ? 
+                                 cpuinfo->dev ?
-                                 cpu_data[n].dev->name : "Unknown" );
+                                 cpuinfo->dev->name : "Unknown");
                seq_printf(m, "hversion\t: 0x%08x\n"
                                "sversion\t: 0x%08x\n",
@@ -377,8 +379,8 @@ show_cpuinfo (struct seq_file *m, void *v)
                show_cache_info(m);
                seq_printf(m, "bogomips\t: %lu.%02lu\n",
-                             cpu_data[n].loops_per_jiffy / (500000 / HZ),
+                             cpuinfo->loops_per_jiffy / (500000 / HZ),
-                             (cpu_data[n].loops_per_jiffy / (5000 / HZ)) % 100);
+                             (cpuinfo->loops_per_jiffy / (5000 / HZ)) % 100);
                seq_printf(m, "software id\t: %ld\n\n",
                                boot_cpu_data.pdc.model.sw_id);
diff --git a/arch/parisc/kernel/setup.c b/arch/parisc/kernel/setup.c
index 7d27853ff8c8..82131ca8e05c 100644
--- a/arch/parisc/kernel/setup.c
+++ b/arch/parisc/kernel/setup.c
@@ -58,11 +58,6 @@ int parisc_bus_is_phys __read_mostly = 1;	/* Assume no IOMMU is present */
 EXPORT_SYMBOL(parisc_bus_is_phys);
 #endif
-/* This sets the vmerge boundary and size, it's here because it has to
- * be available on all platforms (zero means no-virtual merging) */
-unsigned long parisc_vmerge_boundary = 0;
-unsigned long parisc_vmerge_max_size = 0;
 void __init setup_cmdline(char **cmdline_p)
 {
        extern unsigned int boot_args[];
@@ -321,7 +316,7 @@ static int __init parisc_init(void)
        
        processor_init();
        printk(KERN_INFO "CPU(s): %d x %s at %d.%06d MHz\n",
-                        boot_cpu_data.cpu_count,
+                        num_present_cpus(),
                        boot_cpu_data.cpu_name,
                        boot_cpu_data.cpu_hz / 1000000,
                        boot_cpu_data.cpu_hz % 1000000  );
@@ -387,8 +382,8 @@ void start_parisc(void)
        if (ret >= 0 && coproc_cfg.ccr_functional) {
                mtctl(coproc_cfg.ccr_functional, 10);
-                cpu_data[cpunum].fp_rev = coproc_cfg.revision;
+                per_cpu(cpu_data, cpunum).fp_rev = coproc_cfg.revision;
-                cpu_data[cpunum].fp_model = coproc_cfg.model;
+                per_cpu(cpu_data, cpunum).fp_model = coproc_cfg.model;
                asm volatile ("fstd     %fr0,8(%sp)");
        } else {
diff --git a/arch/parisc/kernel/smp.c b/arch/parisc/kernel/smp.c
index 80bc000523fa..9995d7ed5819 100644
--- a/arch/parisc/kernel/smp.c
+++ b/arch/parisc/kernel/smp.c
@@ -56,16 +56,17 @@ static int smp_debug_lvl = 0;
                if (lvl >= smp_debug_lvl)       \
                        printk(printargs);
 #else
-#define smp_debug(lvl, ...)
+#define smp_debug(lvl, ...)     do { } while(0)
 #endif /* DEBUG_SMP */
 DEFINE_SPINLOCK(smp_lock);
 volatile struct task_struct *smp_init_current_idle_task;
-static volatile int cpu_now_booting __read_mostly = 0;  /* track which CPU is booting */
+/* track which CPU is booting */
+static volatile int cpu_now_booting __cpuinitdata;
-static int parisc_max_cpus __read_mostly = 1;
+static int parisc_max_cpus __cpuinitdata = 1;
 DEFINE_PER_CPU(spinlock_t, ipi_lock) = SPIN_LOCK_UNLOCKED;
@@ -123,7 +124,7 @@ irqreturn_t
 ipi_interrupt(int irq, void *dev_id) 
 {
        int this_cpu = smp_processor_id();
-        struct cpuinfo_parisc *p = &cpu_data[this_cpu];
+        struct cpuinfo_parisc *p = &per_cpu(cpu_data, this_cpu);
        unsigned long ops;
        unsigned long flags;
@@ -202,13 +203,13 @@ ipi_interrupt(int irq, void *dev_id)
 static inline void
 ipi_send(int cpu, enum ipi_message_type op)
 {
-        struct cpuinfo_parisc *p = &cpu_data[cpu];
+        struct cpuinfo_parisc *p = &per_cpu(cpu_data, cpu);
        spinlock_t *lock = &per_cpu(ipi_lock, cpu);
        unsigned long flags;
        spin_lock_irqsave(lock, flags);
        p->pending_ipi |= 1 << op;
-        gsc_writel(IPI_IRQ - CPU_IRQ_BASE, cpu_data[cpu].hpa);
+        gsc_writel(IPI_IRQ - CPU_IRQ_BASE, p->hpa);
        spin_unlock_irqrestore(lock, flags);
 }
@@ -224,10 +225,7 @@ send_IPI_mask(cpumask_t mask, enum ipi_message_type op)
 static inline void
 send_IPI_single(int dest_cpu, enum ipi_message_type op)
 {
-        if (dest_cpu == NO_PROC_ID) {
+        BUG_ON(dest_cpu == NO_PROC_ID);
-                BUG();
-                return;
-        }
        ipi_send(dest_cpu, op);
 }
@@ -309,8 +307,7 @@ smp_cpu_init(int cpunum)
        /* Initialise the idle task for this CPU */
        atomic_inc(&init_mm.mm_count);
        current->active_mm = &init_mm;
-        if(current->mm)
+        BUG_ON(current->mm);
-                BUG();
        enter_lazy_tlb(&init_mm, current);
        init_IRQ();   /* make sure no IRQs are enabled or pending */
@@ -345,6 +342,7 @@ void __init smp_callin(void)
 */
 int __cpuinit smp_boot_one_cpu(int cpuid)
 {
+        const struct cpuinfo_parisc *p = &per_cpu(cpu_data, cpuid);
        struct task_struct *idle;
        long timeout;
@@ -376,7 +374,7 @@ int __cpuinit smp_boot_one_cpu(int cpuid)
        smp_init_current_idle_task = idle ;
        mb();
-        printk("Releasing cpu %d now, hpa=%lx\n", cpuid, cpu_data[cpuid].hpa);
+        printk(KERN_INFO "Releasing cpu %d now, hpa=%lx\n", cpuid, p->hpa);
        /*
        ** This gets PDC to release the CPU from a very tight loop.
@@ -387,7 +385,7 @@ int __cpuinit smp_boot_one_cpu(int cpuid)
        ** EIR{0}). MEM_RENDEZ is valid only when it is nonzero and the 
        ** contents of memory are valid."
        */
-        gsc_writel(TIMER_IRQ - CPU_IRQ_BASE, cpu_data[cpuid].hpa);
+        gsc_writel(TIMER_IRQ - CPU_IRQ_BASE, p->hpa);
        mb();
        /* 
@@ -419,12 +417,12 @@ alive:
        return 0;
 }
-void __devinit smp_prepare_boot_cpu(void)
+void __init smp_prepare_boot_cpu(void)
 {
-        int bootstrap_processor=cpu_data[0].cpuid;      /* CPU ID of BSP */
+        int bootstrap_processor = per_cpu(cpu_data, 0).cpuid;
        /* Setup BSP mappings */
-        printk("SMP: bootstrap CPU ID is %d\n",bootstrap_processor);
+        printk(KERN_INFO "SMP: bootstrap CPU ID is %d\n", bootstrap_processor);
        cpu_set(bootstrap_processor, cpu_online_map);
        cpu_set(bootstrap_processor, cpu_present_map);
diff --git a/arch/parisc/kernel/time.c b/arch/parisc/kernel/time.c
index 4d09203bc693..9d46c43a4152 100644
--- a/arch/parisc/kernel/time.c
+++ b/arch/parisc/kernel/time.c
@@ -60,7 +60,7 @@ irqreturn_t timer_interrupt(int irq, void *dev_id)
        unsigned long cycles_elapsed, ticks_elapsed;
        unsigned long cycles_remainder;
        unsigned int cpu = smp_processor_id();
-        struct cpuinfo_parisc *cpuinfo = &cpu_data[cpu];
+        struct cpuinfo_parisc *cpuinfo = &per_cpu(cpu_data, cpu);
        /* gcc can optimize for "read-only" case with a local clocktick */
        unsigned long cpt = clocktick;
@@ -213,7 +213,7 @@ void __init start_cpu_itimer(void)
        mtctl(next_tick, 16);           /* kick off Interval Timer (CR16) */
-        cpu_data[cpu].it_value = next_tick;
+        per_cpu(cpu_data, cpu).it_value = next_tick;
 }
 struct platform_device rtc_parisc_dev = {
diff --git a/arch/parisc/kernel/topology.c b/arch/parisc/kernel/topology.c
index d71cb018a21e..f5159381fdd6 100644
--- a/arch/parisc/kernel/topology.c
+++ b/arch/parisc/kernel/topology.c
@@ -22,14 +22,14 @@
 #include <linux/cpu.h>
 #include <linux/cache.h>
-static struct cpu cpu_devices[NR_CPUS] __read_mostly;
+static DEFINE_PER_CPU(struct cpu, cpu_devices);
 static int __init topology_init(void)
 {
        int num;
        for_each_present_cpu(num) {
-                register_cpu(&cpu_devices[num], num);
+                register_cpu(&per_cpu(cpu_devices, num), num);
        }
        return 0;
 }
diff --git a/arch/parisc/kernel/traps.c b/arch/parisc/kernel/traps.c
index 4c771cd580ec..ba658d2086f7 100644
--- a/arch/parisc/kernel/traps.c
+++ b/arch/parisc/kernel/traps.c
@@ -745,6 +745,10 @@ void handle_interruption(int code, struct pt_regs *regs)
                /* Fall Through */
        case 27: 
                /* Data memory protection ID trap */
+                if (code == 27 && !user_mode(regs) &&
+                        fixup_exception(regs))
+                        return;
                die_if_kernel("Protection id trap", regs, code);
                si.si_code = SEGV_MAPERR;
                si.si_signo = SIGSEGV;
@@ -821,8 +825,8 @@ void handle_interruption(int code, struct pt_regs *regs)
 int __init check_ivt(void *iva)
 {
+        extern u32 os_hpmc_size;
        extern const u32 os_hpmc[];
-        extern const u32 os_hpmc_end[];
        int i;
        u32 check = 0;
@@ -839,8 +843,7 @@ int __init check_ivt(void *iva)
            *ivap++ = 0;
        /* Compute Checksum for HPMC handler */
+        length = os_hpmc_size;
-        length = os_hpmc_end - os_hpmc;
        ivap[7] = length;
        hpmcp = (u32 *)os_hpmc;
diff --git a/arch/parisc/kernel/unwind.c b/arch/parisc/kernel/unwind.c
index 6773c582e457..69dad5a850a8 100644
--- a/arch/parisc/kernel/unwind.c
+++ b/arch/parisc/kernel/unwind.c
@@ -372,7 +372,7 @@ void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct
        struct pt_regs *r = &t->thread.regs;
        struct pt_regs *r2;
-        r2 = kmalloc(sizeof(struct pt_regs), GFP_KERNEL);
+        r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
        if (!r2)
                return;
        *r2 = *r;
diff --git a/arch/parisc/lib/iomap.c b/arch/parisc/lib/iomap.c
index 9abed07db7fc..5069e8b2ca71 100644
--- a/arch/parisc/lib/iomap.c
+++ b/arch/parisc/lib/iomap.c
@@ -261,7 +261,7 @@ static const struct iomap_ops iomem_ops = {
        iomem_write32r,
 };
-const struct iomap_ops *iomap_ops[8] = {
+static const struct iomap_ops *iomap_ops[8] = {
        [0] = &ioport_ops,
        [7] = &iomem_ops
 };
diff --git a/arch/parisc/lib/memcpy.c b/arch/parisc/lib/memcpy.c
index 2d68431fc22e..bbda909c866e 100644
--- a/arch/parisc/lib/memcpy.c
+++ b/arch/parisc/lib/memcpy.c
@@ -275,7 +275,7 @@ handle_store_error:
 /* Returns 0 for success, otherwise, returns number of bytes not transferred. */
-unsigned long pa_memcpy(void *dstp, const void *srcp, unsigned long len)
+static unsigned long pa_memcpy(void *dstp, const void *srcp, unsigned long len)
 {
        register unsigned long src, dst, t1, t2, t3;
        register unsigned char *pcs, *pcd;
diff --git a/arch/parisc/mm/fault.c b/arch/parisc/mm/fault.c
index b2e3e9a8cece..92c7fa4ecc3f 100644
--- a/arch/parisc/mm/fault.c
+++ b/arch/parisc/mm/fault.c
@@ -139,13 +139,41 @@ parisc_acctyp(unsigned long code, unsigned int inst)
                        }
 #endif
+int fixup_exception(struct pt_regs *regs)
+{
+        const struct exception_table_entry *fix;
+        fix = search_exception_tables(regs->iaoq[0]);
+        if (fix) {
+                struct exception_data *d;
+                d = &__get_cpu_var(exception_data);
+                d->fault_ip = regs->iaoq[0];
+                d->fault_space = regs->isr;
+                d->fault_addr = regs->ior;
+                regs->iaoq[0] = ((fix->fixup) & ~3);
+                /*
+                 * NOTE: In some cases the faulting instruction
+                 * may be in the delay slot of a branch. We
+                 * don't want to take the branch, so we don't
+                 * increment iaoq[1], instead we set it to be
+                 * iaoq[0]+4, and clear the B bit in the PSW
+                 */
+                regs->iaoq[1] = regs->iaoq[0] + 4;
+                regs->gr[0] &= ~PSW_B; /* IPSW in gr[0] */
+                return 1;
+        }
+        return 0;
+}
 void do_page_fault(struct pt_regs *regs, unsigned long code,
                              unsigned long address)
 {
        struct vm_area_struct *vma, *prev_vma;
        struct task_struct *tsk = current;
        struct mm_struct *mm = tsk->mm;
-        const struct exception_table_entry *fix;
        unsigned long acc_type;
        int fault;
@@ -229,32 +257,8 @@ bad_area:
 no_context:
-        if (!user_mode(regs)) {
+        if (!user_mode(regs) && fixup_exception(regs)) {
-                fix = search_exception_tables(regs->iaoq[0]);
+                return;
-                if (fix) {
-                        struct exception_data *d;
-                        d = &__get_cpu_var(exception_data);
-                        d->fault_ip = regs->iaoq[0];
-                        d->fault_space = regs->isr;
-                        d->fault_addr = regs->ior;
-                        regs->iaoq[0] = ((fix->fixup) & ~3);
-                        /*
-                         * NOTE: In some cases the faulting instruction
-                         * may be in the delay slot of a branch. We
-                         * don't want to take the branch, so we don't
-                         * increment iaoq[1], instead we set it to be
-                         * iaoq[0]+4, and clear the B bit in the PSW
-                         */
-                        regs->iaoq[1] = regs->iaoq[0] + 4;
-                        regs->gr[0] &= ~PSW_B; /* IPSW in gr[0] */
-                        return;
-                }
        }
        parisc_terminate("Bad Address (null pointer deref?)", regs, code, address);
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 79f25cef32df..84b861316ce7 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -108,6 +108,8 @@ config ARCH_NO_VIRT_TO_BUS
 config PPC
        bool
        default y
+        select HAVE_FTRACE_MCOUNT_RECORD
+        select HAVE_DYNAMIC_FTRACE
        select HAVE_FUNCTION_TRACER
        select ARCH_WANT_OPTIONAL_GPIOLIB
        select HAVE_IDE
@@ -326,7 +328,8 @@ config KEXEC
 config CRASH_DUMP
        bool "Build a kdump crash kernel"
-        depends on (PPC64 && RELOCATABLE) || 6xx
+        depends on PPC64 || 6xx
+        select RELOCATABLE if PPC64
        help
          Build a kernel suitable for use as a kdump capture kernel.
          The same kernel binary can be used as production kernel and dump
diff --git a/arch/powerpc/boot/Makefile b/arch/powerpc/boot/Makefile
index ab6dda372438..e84df338ea29 100644
--- a/arch/powerpc/boot/Makefile
+++ b/arch/powerpc/boot/Makefile
@@ -356,7 +356,7 @@ $(obj)/zImage.initrd:	$(addprefix $(obj)/, $(initrd-y))
        @rm -f $@; ln $< $@
 install: $(CONFIGURE) $(addprefix $(obj)/, $(image-y))
-        sh -x $(srctree)/$(src)/install.sh "$(KERNELRELEASE)" vmlinux System.map "$(INSTALL_PATH)" $<
+        sh -x $(srctree)/$(src)/install.sh "$(KERNELRELEASE)" vmlinux System.map "$(INSTALL_PATH)" $^
 # anything not in $(targets)
 clean-files += $(image-) $(initrd-) cuImage.* dtbImage.* treeImage.* \
diff --git a/arch/powerpc/boot/dts/mpc836x_mds.dts b/arch/powerpc/boot/dts/mpc836x_mds.dts
index 14534d04e4db..6e34f170fa62 100644
--- a/arch/powerpc/boot/dts/mpc836x_mds.dts
+++ b/arch/powerpc/boot/dts/mpc836x_mds.dts
@@ -69,8 +69,18 @@
                };
                bcsr@1,0 {
+                        #address-cells = <1>;
+                        #size-cells = <1>;
                        compatible = "fsl,mpc8360mds-bcsr";
                        reg = <1 0 0x8000>;
+                        ranges = <0 1 0 0x8000>;
+                        bcsr13: gpio-controller@d {
+                                #gpio-cells = <2>;
+                                compatible = "fsl,mpc8360mds-bcsr-gpio";
+                                reg = <0xd 1>;
+                                gpio-controller;
+                        };
                };
        };
@@ -195,10 +205,21 @@
                };
                par_io@1400 {
+                        #address-cells = <1>;
+                        #size-cells = <1>;
                        reg = <0x1400 0x100>;
+                        ranges = <0 0x1400 0x100>;
                        device_type = "par_io";
                        num-ports = <7>;
+                        qe_pio_b: gpio-controller@18 {
+                                #gpio-cells = <2>;
+                                compatible = "fsl,mpc8360-qe-pario-bank",
+                                             "fsl,mpc8323-qe-pario-bank";
+                                reg = <0x18 0x18>;
+                                gpio-controller;
+                        };
                        pio1: ucc_pin@01 {
                                pio-map = <
                        /* port  pin  dir  open_drain  assignment  has_irq */
@@ -282,6 +303,15 @@
                        };
                };
+                timer@440 {
+                        compatible = "fsl,mpc8360-qe-gtm",
+                                     "fsl,qe-gtm", "fsl,gtm";
+                        reg = <0x440 0x40>;
+                        clock-frequency = <132000000>;
+                        interrupts = <12 13 14 15>;
+                        interrupt-parent = <&qeic>;
+                };
                spi@4c0 {
                        cell-index = <0>;
                        compatible = "fsl,spi";
@@ -301,11 +331,20 @@
                };
                usb@6c0 {
-                        compatible = "qe_udc";
+                        compatible = "fsl,mpc8360-qe-usb",
+                                     "fsl,mpc8323-qe-usb";
                        reg = <0x6c0 0x40 0x8b00 0x100>;
                        interrupts = <11>;
                        interrupt-parent = <&qeic>;
-                        mode = "slave";
+                        fsl,fullspeed-clock = "clk21";
+                        fsl,lowspeed-clock = "brg9";
+                        gpios = <&qe_pio_b  2 0   /* USBOE */
+                                 &qe_pio_b  3 0   /* USBTP */
+                                 &qe_pio_b  8 0   /* USBTN */
+                                 &qe_pio_b  9 0   /* USBRP */
+                                 &qe_pio_b 11 0   /* USBRN */
+                                 &bcsr13    5 0   /* SPEED */
+                                 &bcsr13    4 1>; /* POWER */
                };
                enet0: ucc@2000 {
diff --git a/arch/powerpc/boot/dts/mpc836x_rdk.dts b/arch/powerpc/boot/dts/mpc836x_rdk.dts
index decadf3d9e98..37b789510d68 100644
--- a/arch/powerpc/boot/dts/mpc836x_rdk.dts
+++ b/arch/powerpc/boot/dts/mpc836x_rdk.dts
@@ -218,8 +218,23 @@
                                reg = <0x440 0x40>;
                                interrupts = <12 13 14 15>;
                                interrupt-parent = <&qeic>;
-                                /* filled by u-boot */
+                                clock-frequency = <166666666>;
-                                clock-frequency = <0>;
+                        };
+                        usb@6c0 {
+                                compatible = "fsl,mpc8360-qe-usb",
+                                             "fsl,mpc8323-qe-usb";
+                                reg = <0x6c0 0x40 0x8b00 0x100>;
+                                interrupts = <11>;
+                                interrupt-parent = <&qeic>;
+                                fsl,fullspeed-clock = "clk21";
+                                gpios = <&qe_pio_b  2 0 /* USBOE */
+                                         &qe_pio_b  3 0 /* USBTP */
+                                         &qe_pio_b  8 0 /* USBTN */
+                                         &qe_pio_b  9 0 /* USBRP */
+                                         &qe_pio_b 11 0 /* USBRN */
+                                         &qe_pio_e 20 0 /* SPEED */
+                                         &qe_pio_e 21 1 /* POWER */>;
                        };
                        spi@4c0 {
diff --git a/arch/powerpc/boot/dts/mpc8641_hpcn.dts b/arch/powerpc/boot/dts/mpc8641_hpcn.dts
index 35d5e248ccd7..4481532cbe77 100644
--- a/arch/powerpc/boot/dts/mpc8641_hpcn.dts
+++ b/arch/powerpc/boot/dts/mpc8641_hpcn.dts
@@ -26,7 +26,13 @@
                serial1 = &serial1;
                pci0 = &pci0;
                pci1 = &pci1;
-                rapidio0 = &rapidio0;
+/*
+ * Only one of Rapid IO or PCI can be present due to HW limitations and
+ * due to the fact that the 2 now share address space in the new memory
+ * map.  The most likely case is that we have PCI, so comment out the
+ * rapidio node.  Leave it here for reference.
+ */
+                /* rapidio0 = &rapidio0; */
        };
        cpus {
@@ -62,18 +68,17 @@
                reg = <0x00000000 0x40000000>;  // 1G at 0x0
        };
-        localbus@f8005000 {
+        localbus@ffe05000 {
                #address-cells = <2>;
                #size-cells = <1>;
                compatible = "fsl,mpc8641-localbus", "simple-bus";
-                reg = <0xf8005000 0x1000>;
+                reg = <0xffe05000 0x1000>;
                interrupts = <19 2>;
                interrupt-parent = <&mpic>;
-                ranges = <0 0 0xff800000 0x00800000
+                ranges = <0 0 0xef800000 0x00800000
-                          1 0 0xfe000000 0x01000000
+                          2 0 0xffdf8000 0x00008000
-                          2 0 0xf8200000 0x00100000
+                          3 0 0xffdf0000 0x00008000>;
-                          3 0 0xf8100000 0x00100000>;
                flash@0,0 {
                        compatible = "cfi-flash";
@@ -103,13 +108,13 @@
                };
        };
-        soc8641@f8000000 {
+        soc8641@ffe00000 {
                #address-cells = <1>;
                #size-cells = <1>;
                device_type = "soc";
                compatible = "simple-bus";
-                ranges = <0x00000000 0xf8000000 0x00100000>;
+                ranges = <0x00000000 0xffe00000 0x00100000>;
-                reg = <0xf8000000 0x00001000>;  // CCSRBAR
+                reg = <0xffe00000 0x00001000>;  // CCSRBAR
                bus-frequency = <0>;
                i2c@3000 {
@@ -340,17 +345,17 @@
                };
        };
-        pci0: pcie@f8008000 {
+        pci0: pcie@ffe08000 {
                cell-index = <0>;
                compatible = "fsl,mpc8641-pcie";
                device_type = "pci";
                #interrupt-cells = <1>;
                #size-cells = <2>;
                #address-cells = <3>;
-                reg = <0xf8008000 0x1000>;
+                reg = <0xffe08000 0x1000>;
                bus-range = <0x0 0xff>;
                ranges = <0x02000000 0x0 0x80000000 0x80000000 0x0 0x20000000
-                          0x01000000 0x0 0x00000000 0xe2000000 0x0 0x00100000>;
+                          0x01000000 0x0 0x00000000 0xffc00000 0x0 0x00010000>;
                clock-frequency = <33333333>;
                interrupt-parent = <&mpic>;
                interrupts = <24 2>;
@@ -481,7 +486,7 @@
                                  0x01000000 0x0 0x00000000
                                  0x01000000 0x0 0x00000000
-                                  0x0 0x00100000>;
+                                  0x0 0x00010000>;
                        uli1575@0 {
                                reg = <0 0 0 0 0>;
                                #size-cells = <2>;
@@ -491,7 +496,7 @@
                                          0x0 0x20000000
                                          0x01000000 0x0 0x00000000
                                          0x01000000 0x0 0x00000000
-                                          0x0 0x00100000>;
+                                          0x0 0x00010000>;
                                isa@1e {
                                        device_type = "isa";
                                        #interrupt-cells = <2>;
@@ -549,17 +554,17 @@
        };
-        pci1: pcie@f8009000 {
+        pci1: pcie@ffe09000 {
                cell-index = <1>;
                compatible = "fsl,mpc8641-pcie";
                device_type = "pci";
                #interrupt-cells = <1>;
                #size-cells = <2>;
                #address-cells = <3>;
-                reg = <0xf8009000 0x1000>;
+                reg = <0xffe09000 0x1000>;
                bus-range = <0 0xff>;
                ranges = <0x02000000 0x0 0xa0000000 0xa0000000 0x0 0x20000000
-                          0x01000000 0x0 0x00000000 0xe3000000 0x0 0x00100000>;
+                          0x01000000 0x0 0x00000000 0xffc10000 0x0 0x00010000>;
                clock-frequency = <33333333>;
                interrupt-parent = <&mpic>;
                interrupts = <25 2>;
@@ -582,18 +587,21 @@
                                  0x01000000 0x0 0x00000000
                                  0x01000000 0x0 0x00000000
-                                  0x0 0x00100000>;
+                                  0x0 0x00010000>;
                };
        };
-        rapidio0: rapidio@f80c0000 {
+/*
+        rapidio0: rapidio@ffec0000 {
                #address-cells = <2>;
                #size-cells = <2>;
                compatible = "fsl,rapidio-delta";
-                reg = <0xf80c0000 0x20000>;
+                reg = <0xffec0000 0x20000>;
-                ranges = <0 0 0xc0000000 0 0x20000000>;
+                ranges = <0 0 0x80000000 0 0x20000000>;
                interrupt-parent = <&mpic>;
-                /* err_irq bell_outb_irq bell_inb_irq
+                // err_irq bell_outb_irq bell_inb_irq
-                        msg1_tx_irq msg1_rx_irq msg2_tx_irq msg2_rx_irq */
+                //      msg1_tx_irq msg1_rx_irq msg2_tx_irq msg2_rx_irq
                interrupts = <48 2 49 2 50 2 53 2 54 2 55 2 56 2>;
        };
+*/
 };
diff --git a/arch/powerpc/boot/dts/sequoia.dts b/arch/powerpc/boot/dts/sequoia.dts
index 3b295e8df53f..43cc68bd3192 100644
--- a/arch/powerpc/boot/dts/sequoia.dts
+++ b/arch/powerpc/boot/dts/sequoia.dts
@@ -134,7 +134,7 @@
                };
                USB1: usb@e0000400 {
-                        compatible = "ohci-be";
+                        compatible = "ibm,usb-ohci-440epx", "ohci-be";
                        reg = <0x00000000 0xe0000400 0x00000060>;
                        interrupt-parent = <&UIC0>;
                        interrupts = <0x15 0x8>;
diff --git a/arch/powerpc/boot/install.sh b/arch/powerpc/boot/install.sh
index b002bfd56786..51b2387bdba0 100644
--- a/arch/powerpc/boot/install.sh
+++ b/arch/powerpc/boot/install.sh
@@ -15,7 +15,7 @@
 #   $2 - kernel image file
 #   $3 - kernel map file
 #   $4 - default install path (blank if root directory)
-#   $5 - kernel boot file, the zImage
+#   $5 and more - kernel boot files; zImage*, uImage, cuImage.*, etc.
 #
 # User may have a custom install script
@@ -38,3 +38,15 @@ fi
 cat $2 > $4/$image_name
 cp $3 $4/System.map
+# Copy all the bootable image files
+path=$4
+shift 4
+while [ $# -ne 0 ]; do
+        image_name=`basename $1`
+        if [ -f $path/$image_name ]; then
+                mv $path/$image_name $path/$image_name.old
+        fi
+        cat $1 > $path/$image_name
+        shift
+done;
diff --git a/arch/powerpc/configs/85xx/mpc8572_ds_defconfig b/arch/powerpc/configs/85xx/mpc8572_ds_defconfig
index 635588319e0d..32aeb79216f7 100644
--- a/arch/powerpc/configs/85xx/mpc8572_ds_defconfig
+++ b/arch/powerpc/configs/85xx/mpc8572_ds_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.28-rc3
+# Linux kernel version: 2.6.28-rc8
-# Sat Nov  8 12:40:13 2008
+# Tue Dec 30 11:17:46 2008
 #
 # CONFIG_PPC64 is not set
@@ -21,7 +21,10 @@ CONFIG_FSL_BOOKE=y
 CONFIG_FSL_EMB_PERFMON=y
 # CONFIG_PHYS_64BIT is not set
 CONFIG_SPE=y
+CONFIG_PPC_MMU_NOHASH=y
 # CONFIG_PPC_MM_SLICES is not set
+CONFIG_SMP=y
+CONFIG_NR_CPUS=2
 CONFIG_PPC32=y
 CONFIG_WORD_SIZE=32
 # CONFIG_ARCH_PHYS_ADDR_T_64BIT is not set
@@ -50,7 +53,7 @@ CONFIG_ARCH_MAY_HAVE_PC_FDC=y
 CONFIG_PPC_OF=y
 CONFIG_OF=y
 CONFIG_PPC_UDBG_16550=y
-# CONFIG_GENERIC_TBSYNC is not set
+CONFIG_GENERIC_TBSYNC=y
 CONFIG_AUDIT_ARCH=y
 CONFIG_GENERIC_BUG=y
 CONFIG_DEFAULT_UIMAGE=y
@@ -62,7 +65,7 @@ CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
 # General setup
 #
 CONFIG_EXPERIMENTAL=y
-CONFIG_BROKEN_ON_SMP=y
+CONFIG_LOCK_KERNEL=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
 CONFIG_LOCALVERSION=""
 CONFIG_LOCALVERSION_AUTO=y
@@ -126,6 +129,7 @@ CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
+CONFIG_USE_GENERIC_SMP_HELPERS=y
 # CONFIG_HAVE_GENERIC_DMA_COHERENT is not set
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -138,6 +142,7 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_KMOD=y
+CONFIG_STOP_MACHINE=y
 CONFIG_BLOCK=y
 CONFIG_LBD=y
 # CONFIG_BLK_DEV_IO_TRACE is not set
@@ -197,6 +202,7 @@ CONFIG_PPC_I8259=y
 # CONFIG_CPM2 is not set
 CONFIG_FSL_ULI1575=y
 # CONFIG_MPC8xxx_GPIO is not set
+# CONFIG_SIMPLE_GPIO is not set
 #
 # Kernel options
@@ -224,6 +230,7 @@ CONFIG_MATH_EMULATION=y
 CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
 CONFIG_ARCH_HAS_WALK_MEMORY=y
 CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
+# CONFIG_IRQ_ALL_CPUS is not set
 CONFIG_ARCH_FLATMEM_ENABLE=y
 CONFIG_ARCH_POPULATES_NODE_MAP=y
 CONFIG_SELECT_MEMORY_MODEL=y
@@ -241,6 +248,9 @@ CONFIG_ZONE_DMA_FLAG=1
 CONFIG_BOUNCE=y
 CONFIG_VIRT_TO_BUS=y
 CONFIG_UNEVICTABLE_LRU=y
+CONFIG_PPC_4K_PAGES=y
+# CONFIG_PPC_16K_PAGES is not set
+# CONFIG_PPC_64K_PAGES is not set
 CONFIG_FORCE_MAX_ZONEORDER=11
 CONFIG_PROC_DEVICETREE=y
 # CONFIG_CMDLINE_BOOL is not set
@@ -443,8 +453,10 @@ CONFIG_MISC_DEVICES=y
 # CONFIG_EEPROM_93CX6 is not set
 # CONFIG_SGI_IOC4 is not set
 # CONFIG_TIFM_CORE is not set
+# CONFIG_ICS932S401 is not set
 # CONFIG_ENCLOSURE_SERVICES is not set
 # CONFIG_HP_ILO is not set
+# CONFIG_C2PORT is not set
 CONFIG_HAVE_IDE=y
 # CONFIG_IDE is not set
@@ -784,6 +796,7 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
+# CONFIG_HVC_UDBG is not set
 # CONFIG_IPMI_HANDLER is not set
 CONFIG_HW_RANDOM=y
 CONFIG_NVRAM=y
@@ -869,11 +882,11 @@ CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y
 # CONFIG_THERMAL is not set
 # CONFIG_THERMAL_HWMON is not set
 # CONFIG_WATCHDOG is not set
+CONFIG_SSB_POSSIBLE=y
 #
 # Sonics Silicon Backplane
 #
-CONFIG_SSB_POSSIBLE=y
 # CONFIG_SSB is not set
 #
@@ -886,14 +899,7 @@ CONFIG_SSB_POSSIBLE=y
 # CONFIG_PMIC_DA903X is not set
 # CONFIG_MFD_WM8400 is not set
 # CONFIG_MFD_WM8350_I2C is not set
-#
-# Voltage and Current regulators
-#
 # CONFIG_REGULATOR is not set
-# CONFIG_REGULATOR_FIXED_VOLTAGE is not set
-# CONFIG_REGULATOR_VIRTUAL_CONSUMER is not set
-# CONFIG_REGULATOR_BQ24022 is not set
 #
 # Multimedia devices
@@ -1252,11 +1258,11 @@ CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 # CONFIG_USB_TMC is not set
 #
-# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may also be needed;
 #
 #
-# may also be needed; see USB_STORAGE Help for more information
+# see USB_STORAGE Help for more information
 #
 CONFIG_USB_STORAGE=y
 # CONFIG_USB_STORAGE_DEBUG is not set
@@ -1348,6 +1354,7 @@ CONFIG_RTC_INTF_DEV=y
 # CONFIG_RTC_DRV_M41T80 is not set
 # CONFIG_RTC_DRV_S35390A is not set
 # CONFIG_RTC_DRV_FM3130 is not set
+# CONFIG_RTC_DRV_RX8581 is not set
 #
 # SPI RTC drivers
@@ -1624,6 +1631,7 @@ CONFIG_HAVE_FUNCTION_TRACER=y
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
+CONFIG_PRINT_STACK_DEPTH=64
 # CONFIG_DEBUG_STACKOVERFLOW is not set
 # CONFIG_DEBUG_STACK_USAGE is not set
 # CONFIG_DEBUG_PAGEALLOC is not set
@@ -1649,11 +1657,16 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_FIPS is not set
 CONFIG_CRYPTO_ALGAPI=y
+CONFIG_CRYPTO_ALGAPI2=y
 CONFIG_CRYPTO_AEAD=y
+CONFIG_CRYPTO_AEAD2=y
 CONFIG_CRYPTO_BLKCIPHER=y
+CONFIG_CRYPTO_BLKCIPHER2=y
 CONFIG_CRYPTO_HASH=y
-CONFIG_CRYPTO_RNG=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_RNG2=y
 CONFIG_CRYPTO_MANAGER=y
+CONFIG_CRYPTO_MANAGER2=y
 # CONFIG_CRYPTO_GF128MUL is not set
 # CONFIG_CRYPTO_NULL is not set
 # CONFIG_CRYPTO_CRYPTD is not set
diff --git a/arch/powerpc/include/asm/cell-pmu.h b/arch/powerpc/include/asm/cell-pmu.h
index 8066eede3a0c..b4b7338ad79e 100644
--- a/arch/powerpc/include/asm/cell-pmu.h
+++ b/arch/powerpc/include/asm/cell-pmu.h
@@ -37,9 +37,11 @@
 #define CBE_PM_STOP_AT_MAX                 0x40000000
 #define CBE_PM_TRACE_MODE_GET(pm_control)  (((pm_control) >> 28) & 0x3)
 #define CBE_PM_TRACE_MODE_SET(mode)        (((mode)  & 0x3) << 28)
+#define CBE_PM_TRACE_BUF_OVFLW(bit)        (((bit) & 0x1) << 17)
 #define CBE_PM_COUNT_MODE_SET(count)       (((count) & 0x3) << 18)
 #define CBE_PM_FREEZE_ALL_CTRS             0x00100000
 #define CBE_PM_ENABLE_EXT_TRACE            0x00008000
+#define CBE_PM_SPU_ADDR_TRACE_SET(msk)     (((msk) & 0x3) << 9)
 /* Macros for the trace_address register. */
 #define CBE_PM_TRACE_BUF_FULL              0x00000800
diff --git a/arch/powerpc/include/asm/ioctls.h b/arch/powerpc/include/asm/ioctls.h
index 279a6229584b..1842186d872c 100644
--- a/arch/powerpc/include/asm/ioctls.h
+++ b/arch/powerpc/include/asm/ioctls.h
@@ -89,6 +89,8 @@
 #define TIOCSBRK        0x5427  /* BSD compatibility */
 #define TIOCCBRK        0x5428  /* BSD compatibility */
 #define TIOCGSID        0x5429  /* Return the session ID of FD */
+#define TIOCGRS485      0x542e
+#define TIOCSRS485      0x542f
 #define TIOCGPTN        _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
 #define TIOCSPTLCK      _IOW('T',0x31, int)  /* Lock/unlock Pty */
diff --git a/arch/powerpc/include/asm/kexec.h b/arch/powerpc/include/asm/kexec.h
index 6dbffc981702..7e06b43720d3 100644
--- a/arch/powerpc/include/asm/kexec.h
+++ b/arch/powerpc/include/asm/kexec.h
@@ -48,63 +48,8 @@ static inline void crash_setup_regs(struct pt_regs *newregs,
 {
        if (oldregs)
                memcpy(newregs, oldregs, sizeof(*newregs));
-#ifdef __powerpc64__
-        else {
-                /* FIXME Merge this with xmon_save_regs ?? */
-                unsigned long tmp1, tmp2;
-                __asm__ __volatile__ (
-                        "std    0,0(%2)\n"
-                        "std    1,8(%2)\n"
-                        "std    2,16(%2)\n"
-                        "std    3,24(%2)\n"
-                        "std    4,32(%2)\n"
-                        "std    5,40(%2)\n"
-                        "std    6,48(%2)\n"
-                        "std    7,56(%2)\n"
-                        "std    8,64(%2)\n"
-                        "std    9,72(%2)\n"
-                        "std    10,80(%2)\n"
-                        "std    11,88(%2)\n"
-                        "std    12,96(%2)\n"
-                        "std    13,104(%2)\n"
-                        "std    14,112(%2)\n"
-                        "std    15,120(%2)\n"
-                        "std    16,128(%2)\n"
-                        "std    17,136(%2)\n"
-                        "std    18,144(%2)\n"
-                        "std    19,152(%2)\n"
-                        "std    20,160(%2)\n"
-                        "std    21,168(%2)\n"
-                        "std    22,176(%2)\n"
-                        "std    23,184(%2)\n"
-                        "std    24,192(%2)\n"
-                        "std    25,200(%2)\n"
-                        "std    26,208(%2)\n"
-                        "std    27,216(%2)\n"
-                        "std    28,224(%2)\n"
-                        "std    29,232(%2)\n"
-                        "std    30,240(%2)\n"
-                        "std    31,248(%2)\n"
-                        "mfmsr  %0\n"
-                        "std    %0, 264(%2)\n"
-                        "mfctr  %0\n"
-                        "std    %0, 280(%2)\n"
-                        "mflr   %0\n"
-                        "std    %0, 288(%2)\n"
-                        "bl     1f\n"
-                "1:     mflr   %1\n"
-                        "std    %1, 256(%2)\n"
-                        "mtlr   %0\n"
-                        "mfxer  %0\n"
-                        "std    %0, 296(%2)\n"
-                        : "=&r" (tmp1), "=&r" (tmp2)
-                        : "b" (newregs)
-                        : "memory");
-        }
-#else
        else
                ppc_save_regs(newregs);
-#endif /* __powerpc64__ */
 }
 extern void kexec_smp_wait(void);       /* get and clear naca physid, wait for
diff --git a/arch/powerpc/include/asm/oprofile_impl.h b/arch/powerpc/include/asm/oprofile_impl.h
index 95035c602ba6..639dc96077ab 100644
--- a/arch/powerpc/include/asm/oprofile_impl.h
+++ b/arch/powerpc/include/asm/oprofile_impl.h
@@ -32,6 +32,12 @@ struct op_system_config {
        unsigned long mmcr0;
        unsigned long mmcr1;
        unsigned long mmcra;
+#ifdef CONFIG_OPROFILE_CELL
+        /* Register for oprofile user tool to check cell kernel profiling
+         * suport.
+         */
+        unsigned long cell_support;
+#endif
 #endif
        unsigned long enable_kernel;
        unsigned long enable_user;
diff --git a/arch/powerpc/include/asm/ps3.h b/arch/powerpc/include/asm/ps3.h
index cff30c0ef1ff..eead5c67197a 100644
--- a/arch/powerpc/include/asm/ps3.h
+++ b/arch/powerpc/include/asm/ps3.h
@@ -320,6 +320,7 @@ enum ps3_match_id {
 enum ps3_match_sub_id {
        PS3_MATCH_SUB_ID_GPU_FB         = 1,
+        PS3_MATCH_SUB_ID_GPU_RAMDISK    = 2,
 };
 #define PS3_MODULE_ALIAS_EHCI           "ps3:1:0"
@@ -332,6 +333,7 @@ enum ps3_match_sub_id {
 #define PS3_MODULE_ALIAS_STOR_FLASH     "ps3:8:0"
 #define PS3_MODULE_ALIAS_SOUND          "ps3:9:0"
 #define PS3_MODULE_ALIAS_GPU_FB         "ps3:10:1"
+#define PS3_MODULE_ALIAS_GPU_RAMDISK    "ps3:10:2"
 #define PS3_MODULE_ALIAS_LPM            "ps3:11:0"
 enum ps3_system_bus_device_type {
diff --git a/arch/powerpc/include/asm/qe.h b/arch/powerpc/include/asm/qe.h
index edee15d269ea..a0a15311d0d8 100644
--- a/arch/powerpc/include/asm/qe.h
+++ b/arch/powerpc/include/asm/qe.h
@@ -17,6 +17,8 @@
 #ifdef __KERNEL__
 #include <linux/spinlock.h>
+#include <linux/errno.h>
+#include <linux/err.h>
 #include <asm/cpm.h>
 #include <asm/immap_qe.h>
@@ -84,7 +86,11 @@ static inline bool qe_clock_is_brg(enum qe_clock clk)
 extern spinlock_t cmxgcr_lock;
 /* Export QE common operations */
+#ifdef CONFIG_QUICC_ENGINE
 extern void __init qe_reset(void);
+#else
+static inline void qe_reset(void) {}
+#endif
 /* QE PIO */
 #define QE_PIO_PINS 32
@@ -101,16 +107,43 @@ struct qe_pio_regs {
 #endif
 };
-extern int par_io_init(struct device_node *np);
-extern int par_io_of_config(struct device_node *np);
 #define QE_PIO_DIR_IN   2
 #define QE_PIO_DIR_OUT  1
 extern void __par_io_config_pin(struct qe_pio_regs __iomem *par_io, u8 pin,
                                int dir, int open_drain, int assignment,
                                int has_irq);
+#ifdef CONFIG_QUICC_ENGINE
+extern int par_io_init(struct device_node *np);
+extern int par_io_of_config(struct device_node *np);
 extern int par_io_config_pin(u8 port, u8 pin, int dir, int open_drain,
                             int assignment, int has_irq);
 extern int par_io_data_set(u8 port, u8 pin, u8 val);
+#else
+static inline int par_io_init(struct device_node *np) { return -ENOSYS; }
+static inline int par_io_of_config(struct device_node *np) { return -ENOSYS; }
+static inline int par_io_config_pin(u8 port, u8 pin, int dir, int open_drain,
+                int assignment, int has_irq) { return -ENOSYS; }
+static inline int par_io_data_set(u8 port, u8 pin, u8 val) { return -ENOSYS; }
+#endif /* CONFIG_QUICC_ENGINE */
+/*
+ * Pin multiplexing functions.
+ */
+struct qe_pin;
+#ifdef CONFIG_QE_GPIO
+extern struct qe_pin *qe_pin_request(struct device_node *np, int index);
+extern void qe_pin_free(struct qe_pin *qe_pin);
+extern void qe_pin_set_gpio(struct qe_pin *qe_pin);
+extern void qe_pin_set_dedicated(struct qe_pin *pin);
+#else
+static inline struct qe_pin *qe_pin_request(struct device_node *np, int index)
+{
+        return ERR_PTR(-ENOSYS);
+}
+static inline void qe_pin_free(struct qe_pin *qe_pin) {}
+static inline void qe_pin_set_gpio(struct qe_pin *qe_pin) {}
+static inline void qe_pin_set_dedicated(struct qe_pin *pin) {}
+#endif /* CONFIG_QE_GPIO */
 /* QE internal API */
 int qe_issue_cmd(u32 cmd, u32 device, u8 mcn_protocol, u32 cmd_input);
diff --git a/arch/powerpc/include/asm/qe_ic.h b/arch/powerpc/include/asm/qe_ic.h
index 56a7745ca343..cf519663a791 100644
--- a/arch/powerpc/include/asm/qe_ic.h
+++ b/arch/powerpc/include/asm/qe_ic.h
@@ -17,6 +17,9 @@
 #include <linux/irq.h>
+struct device_node;
+struct qe_ic;
 #define NUM_OF_QE_IC_GROUPS     6
 /* Flags when we init the QE IC */
@@ -54,17 +57,27 @@ enum qe_ic_grp_id {
        QE_IC_GRP_RISCB         /* QE interrupt controller RISC group B */
 };
+#ifdef CONFIG_QUICC_ENGINE
 void qe_ic_init(struct device_node *node, unsigned int flags,
                void (*low_handler)(unsigned int irq, struct irq_desc *desc),
                void (*high_handler)(unsigned int irq, struct irq_desc *desc));
+unsigned int qe_ic_get_low_irq(struct qe_ic *qe_ic);
+unsigned int qe_ic_get_high_irq(struct qe_ic *qe_ic);
+#else
+static inline void qe_ic_init(struct device_node *node, unsigned int flags,
+                void (*low_handler)(unsigned int irq, struct irq_desc *desc),
+                void (*high_handler)(unsigned int irq, struct irq_desc *desc))
+{}
+static inline unsigned int qe_ic_get_low_irq(struct qe_ic *qe_ic)
+{ return 0; }
+static inline unsigned int qe_ic_get_high_irq(struct qe_ic *qe_ic)
+{ return 0; }
+#endif /* CONFIG_QUICC_ENGINE */
 void qe_ic_set_highest_priority(unsigned int virq, int high);
 int qe_ic_set_priority(unsigned int virq, unsigned int priority);
 int qe_ic_set_high_priority(unsigned int virq, unsigned int priority, int high);
-struct qe_ic;
-unsigned int qe_ic_get_low_irq(struct qe_ic *qe_ic);
-unsigned int qe_ic_get_high_irq(struct qe_ic *qe_ic);
 static inline void qe_ic_cascade_low_ipic(unsigned int irq,
                                          struct irq_desc *desc)
 {
diff --git a/arch/powerpc/include/asm/spu.h b/arch/powerpc/include/asm/spu.h
index 8b2eb044270a..0ab8d869e3d6 100644
--- a/arch/powerpc/include/asm/spu.h
+++ b/arch/powerpc/include/asm/spu.h
@@ -128,7 +128,7 @@ struct spu {
        int number;
        unsigned int irqs[3];
        u32 node;
-        u64 flags;
+        unsigned long flags;
        u64 class_0_pending;
        u64 class_0_dar;
        u64 class_1_dar;
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 1308a86e9070..8d1a419df35d 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -29,7 +29,7 @@ endif
 obj-y                           := cputable.o ptrace.o syscalls.o \
                                   irq.o align.o signal_32.o pmc.o vdso.o \
                                   init_task.o process.o systbl.o idle.o \
-                                   signal.o sysfs.o
+                                   signal.o sysfs.o cacheinfo.o
 obj-y                           += vdso32/
 obj-$(CONFIG_PPC64)             += setup_64.o sys_ppc32.o \
                                   signal_64.o ptrace32.o \
diff --git a/arch/powerpc/kernel/cacheinfo.c b/arch/powerpc/kernel/cacheinfo.c
new file mode 100644
index 000000000000..b33f0417a4bf
--- /dev/null
+++ b/arch/powerpc/kernel/cacheinfo.c
@@ -0,0 +1,837 @@
+/*
+ * Processor cache information made available to userspace via sysfs;
+ * intended to be compatible with x86 intel_cacheinfo implementation.
+ *
+ * Copyright 2008 IBM Corporation
+ * Author: Nathan Lynch
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ */
+#include <linux/cpu.h>
+#include <linux/cpumask.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/kobject.h>
+#include <linux/list.h>
+#include <linux/notifier.h>
+#include <linux/of.h>
+#include <linux/percpu.h>
+#include <asm/prom.h>
+#include "cacheinfo.h"
+/* per-cpu object for tracking:
+ * - a "cache" kobject for the top-level directory
+ * - a list of "index" objects representing the cpu's local cache hierarchy
+ */
+struct cache_dir {
+        struct kobject *kobj; /* bare (not embedded) kobject for cache
+                               * directory */
+        struct cache_index_dir *index; /* list of index objects */
+};
+/* "index" object: each cpu's cache directory has an index
+ * subdirectory corresponding to a cache object associated with the
+ * cpu.  This object's lifetime is managed via the embedded kobject.
+ */
+struct cache_index_dir {
+        struct kobject kobj;
+        struct cache_index_dir *next; /* next index in parent directory */
+        struct cache *cache;
+};
+/* Template for determining which OF properties to query for a given
+ * cache type */
+struct cache_type_info {
+        const char *name;
+        const char *size_prop;
+        /* Allow for both [di]-cache-line-size and
+         * [di]-cache-block-size properties.  According to the PowerPC
+         * Processor binding, -line-size should be provided if it
+         * differs from the cache block size (that which is operated
+         * on by cache instructions), so we look for -line-size first.
+         * See cache_get_line_size(). */
+        const char *line_size_props[2];
+        const char *nr_sets_prop;
+};
+/* These are used to index the cache_type_info array. */
+#define CACHE_TYPE_UNIFIED     0
+#define CACHE_TYPE_INSTRUCTION 1
+#define CACHE_TYPE_DATA        2
+static const struct cache_type_info cache_type_info[] = {
+        {
+                /* PowerPC Processor binding says the [di]-cache-*
+                 * must be equal on unified caches, so just use
+                 * d-cache properties. */
+                .name            = "Unified",
+                .size_prop       = "d-cache-size",
+                .line_size_props = { "d-cache-line-size",
+                                     "d-cache-block-size", },
+                .nr_sets_prop    = "d-cache-sets",
+        },
+        {
+                .name            = "Instruction",
+                .size_prop       = "i-cache-size",
+                .line_size_props = { "i-cache-line-size",
+                                     "i-cache-block-size", },
+                .nr_sets_prop    = "i-cache-sets",
+        },
+        {
+                .name            = "Data",
+                .size_prop       = "d-cache-size",
+                .line_size_props = { "d-cache-line-size",
+                                     "d-cache-block-size", },
+                .nr_sets_prop    = "d-cache-sets",
+        },
+};
+/* Cache object: each instance of this corresponds to a distinct cache
+ * in the system.  There are separate objects for Harvard caches: one
+ * each for instruction and data, and each refers to the same OF node.
+ * The refcount of the OF node is elevated for the lifetime of the
+ * cache object.  A cache object is released when its shared_cpu_map
+ * is cleared (see cache_cpu_clear).
+ *
+ * A cache object is on two lists: an unsorted global list
+ * (cache_list) of cache objects; and a singly-linked list
+ * representing the local cache hierarchy, which is ordered by level
+ * (e.g. L1d -> L1i -> L2 -> L3).
+ */
+struct cache {
+        struct device_node *ofnode;    /* OF node for this cache, may be cpu */
+        struct cpumask shared_cpu_map; /* online CPUs using this cache */
+        int type;                      /* split cache disambiguation */
+        int level;                     /* level not explicit in device tree */
+        struct list_head list;         /* global list of cache objects */
+        struct cache *next_local;      /* next cache of >= level */
+};
+static DEFINE_PER_CPU(struct cache_dir *, cache_dir);
+/* traversal/modification of this list occurs only at cpu hotplug time;
+ * access is serialized by cpu hotplug locking
+ */
+static LIST_HEAD(cache_list);
+static struct cache_index_dir *kobj_to_cache_index_dir(struct kobject *k)
+{
+        return container_of(k, struct cache_index_dir, kobj);
+}
+static const char *cache_type_string(const struct cache *cache)
+{
+        return cache_type_info[cache->type].name;
+}
+static void __cpuinit cache_init(struct cache *cache, int type, int level, struct device_node *ofnode)
+{
+        cache->type = type;
+        cache->level = level;
+        cache->ofnode = of_node_get(ofnode);
+        INIT_LIST_HEAD(&cache->list);
+        list_add(&cache->list, &cache_list);
+}
+static struct cache *__cpuinit new_cache(int type, int level, struct device_node *ofnode)
+{
+        struct cache *cache;
+        cache = kzalloc(sizeof(*cache), GFP_KERNEL);
+        if (cache)
+                cache_init(cache, type, level, ofnode);
+        return cache;
+}
+static void release_cache_debugcheck(struct cache *cache)
+{
+        struct cache *iter;
+        list_for_each_entry(iter, &cache_list, list)
+                WARN_ONCE(iter->next_local == cache,
+                          "cache for %s(%s) refers to cache for %s(%s)\n",
+                          iter->ofnode->full_name,
+                          cache_type_string(iter),
+                          cache->ofnode->full_name,
+                          cache_type_string(cache));
+}
+static void release_cache(struct cache *cache)
+{
+        if (!cache)
+                return;
+        pr_debug("freeing L%d %s cache for %s\n", cache->level,
+                 cache_type_string(cache), cache->ofnode->full_name);
+        release_cache_debugcheck(cache);
+        list_del(&cache->list);
+        of_node_put(cache->ofnode);
+        kfree(cache);
+}
+static void cache_cpu_set(struct cache *cache, int cpu)
+{
+        struct cache *next = cache;
+        while (next) {
+                WARN_ONCE(cpumask_test_cpu(cpu, &next->shared_cpu_map),
+                          "CPU %i already accounted in %s(%s)\n",
+                          cpu, next->ofnode->full_name,
+                          cache_type_string(next));
+                cpumask_set_cpu(cpu, &next->shared_cpu_map);
+                next = next->next_local;
+        }
+}
+static int cache_size(const struct cache *cache, unsigned int *ret)
+{
+        const char *propname;
+        const u32 *cache_size;
+        propname = cache_type_info[cache->type].size_prop;
+        cache_size = of_get_property(cache->ofnode, propname, NULL);
+        if (!cache_size)
+                return -ENODEV;
+        *ret = *cache_size;
+        return 0;
+}
+static int cache_size_kb(const struct cache *cache, unsigned int *ret)
+{
+        unsigned int size;
+        if (cache_size(cache, &size))
+                return -ENODEV;
+        *ret = size / 1024;
+        return 0;
+}
+/* not cache_line_size() because that's a macro in include/linux/cache.h */
+static int cache_get_line_size(const struct cache *cache, unsigned int *ret)
+{
+        const u32 *line_size;
+        int i, lim;
+        lim = ARRAY_SIZE(cache_type_info[cache->type].line_size_props);
+        for (i = 0; i < lim; i++) {
+                const char *propname;
+                propname = cache_type_info[cache->type].line_size_props[i];
+                line_size = of_get_property(cache->ofnode, propname, NULL);
+                if (line_size)
+                        break;
+        }
+        if (!line_size)
+                return -ENODEV;
+        *ret = *line_size;
+        return 0;
+}
+static int cache_nr_sets(const struct cache *cache, unsigned int *ret)
+{
+        const char *propname;
+        const u32 *nr_sets;
+        propname = cache_type_info[cache->type].nr_sets_prop;
+        nr_sets = of_get_property(cache->ofnode, propname, NULL);
+        if (!nr_sets)
+                return -ENODEV;
+        *ret = *nr_sets;
+        return 0;
+}
+static int cache_associativity(const struct cache *cache, unsigned int *ret)
+{
+        unsigned int line_size;
+        unsigned int nr_sets;
+        unsigned int size;
+        if (cache_nr_sets(cache, &nr_sets))
+                goto err;
+        /* If the cache is fully associative, there is no need to
+         * check the other properties.
+         */
+        if (nr_sets == 1) {
+                *ret = 0;
+                return 0;
+        }
+        if (cache_get_line_size(cache, &line_size))
+                goto err;
+        if (cache_size(cache, &size))
+                goto err;
+        if (!(nr_sets > 0 && size > 0 && line_size > 0))
+                goto err;
+        *ret = (size / nr_sets) / line_size;
+        return 0;
+err:
+        return -ENODEV;
+}
+/* helper for dealing with split caches */
+static struct cache *cache_find_first_sibling(struct cache *cache)
+{
+        struct cache *iter;
+        if (cache->type == CACHE_TYPE_UNIFIED)
+                return cache;
+        list_for_each_entry(iter, &cache_list, list)
+                if (iter->ofnode == cache->ofnode && iter->next_local == cache)
+                        return iter;
+        return cache;
+}
+/* return the first cache on a local list matching node */
+static struct cache *cache_lookup_by_node(const struct device_node *node)
+{
+        struct cache *cache = NULL;
+        struct cache *iter;
+        list_for_each_entry(iter, &cache_list, list) {
+                if (iter->ofnode != node)
+                        continue;
+                cache = cache_find_first_sibling(iter);
+                break;
+        }
+        return cache;
+}
+static bool cache_node_is_unified(const struct device_node *np)
+{
+        return of_get_property(np, "cache-unified", NULL);
+}
+static struct cache *__cpuinit cache_do_one_devnode_unified(struct device_node *node, int level)
+{
+        struct cache *cache;
+        pr_debug("creating L%d ucache for %s\n", level, node->full_name);
+        cache = new_cache(CACHE_TYPE_UNIFIED, level, node);
+        return cache;
+}
+static struct cache *__cpuinit cache_do_one_devnode_split(struct device_node *node, int level)
+{
+        struct cache *dcache, *icache;
+        pr_debug("creating L%d dcache and icache for %s\n", level,
+                 node->full_name);
+        dcache = new_cache(CACHE_TYPE_DATA, level, node);
+        icache = new_cache(CACHE_TYPE_INSTRUCTION, level, node);
+        if (!dcache || !icache)
+                goto err;
+        dcache->next_local = icache;
+        return dcache;
+err:
+        release_cache(dcache);
+        release_cache(icache);
+        return NULL;
+}
+static struct cache *__cpuinit cache_do_one_devnode(struct device_node *node, int level)
+{
+        struct cache *cache;
+        if (cache_node_is_unified(node))
+                cache = cache_do_one_devnode_unified(node, level);
+        else
+                cache = cache_do_one_devnode_split(node, level);
+        return cache;
+}
+static struct cache *__cpuinit cache_lookup_or_instantiate(struct device_node *node, int level)
+{
+        struct cache *cache;
+        cache = cache_lookup_by_node(node);
+        WARN_ONCE(cache && cache->level != level,
+                  "cache level mismatch on lookup (got %d, expected %d)\n",
+                  cache->level, level);
+        if (!cache)
+                cache = cache_do_one_devnode(node, level);
+        return cache;
+}
+static void __cpuinit link_cache_lists(struct cache *smaller, struct cache *bigger)
+{
+        while (smaller->next_local) {
+                if (smaller->next_local == bigger)
+                        return; /* already linked */
+                smaller = smaller->next_local;
+        }
+        smaller->next_local = bigger;
+}
+static void __cpuinit do_subsidiary_caches_debugcheck(struct cache *cache)
+{
+        WARN_ON_ONCE(cache->level != 1);
+        WARN_ON_ONCE(strcmp(cache->ofnode->type, "cpu"));
+}
+static void __cpuinit do_subsidiary_caches(struct cache *cache)
+{
+        struct device_node *subcache_node;
+        int level = cache->level;
+        do_subsidiary_caches_debugcheck(cache);
+        while ((subcache_node = of_find_next_cache_node(cache->ofnode))) {
+                struct cache *subcache;
+                level++;
+                subcache = cache_lookup_or_instantiate(subcache_node, level);
+                of_node_put(subcache_node);
+                if (!subcache)
+                        break;
+                link_cache_lists(cache, subcache);
+                cache = subcache;
+        }
+}
+static struct cache *__cpuinit cache_chain_instantiate(unsigned int cpu_id)
+{
+        struct device_node *cpu_node;
+        struct cache *cpu_cache = NULL;
+        pr_debug("creating cache object(s) for CPU %i\n", cpu_id);
+        cpu_node = of_get_cpu_node(cpu_id, NULL);
+        WARN_ONCE(!cpu_node, "no OF node found for CPU %i\n", cpu_id);
+        if (!cpu_node)
+                goto out;
+        cpu_cache = cache_lookup_or_instantiate(cpu_node, 1);
+        if (!cpu_cache)
+                goto out;
+        do_subsidiary_caches(cpu_cache);
+        cache_cpu_set(cpu_cache, cpu_id);
+out:
+        of_node_put(cpu_node);
+        return cpu_cache;
+}
+static struct cache_dir *__cpuinit cacheinfo_create_cache_dir(unsigned int cpu_id)
+{
+        struct cache_dir *cache_dir;
+        struct sys_device *sysdev;
+        struct kobject *kobj = NULL;
+        sysdev = get_cpu_sysdev(cpu_id);
+        WARN_ONCE(!sysdev, "no sysdev for CPU %i\n", cpu_id);
+        if (!sysdev)
+                goto err;
+        kobj = kobject_create_and_add("cache", &sysdev->kobj);
+        if (!kobj)
+                goto err;
+        cache_dir = kzalloc(sizeof(*cache_dir), GFP_KERNEL);
+        if (!cache_dir)
+                goto err;
+        cache_dir->kobj = kobj;
+        WARN_ON_ONCE(per_cpu(cache_dir, cpu_id) != NULL);
+        per_cpu(cache_dir, cpu_id) = cache_dir;
+        return cache_dir;
+err:
+        kobject_put(kobj);
+        return NULL;
+}
+static void cache_index_release(struct kobject *kobj)
+{
+        struct cache_index_dir *index;
+        index = kobj_to_cache_index_dir(kobj);
+        pr_debug("freeing index directory for L%d %s cache\n",
+                 index->cache->level, cache_type_string(index->cache));
+        kfree(index);
+}
+static ssize_t cache_index_show(struct kobject *k, struct attribute *attr, char *buf)
+{
+        struct kobj_attribute *kobj_attr;
+        kobj_attr = container_of(attr, struct kobj_attribute, attr);
+        return kobj_attr->show(k, kobj_attr, buf);
+}
+static struct cache *index_kobj_to_cache(struct kobject *k)
+{
+        struct cache_index_dir *index;
+        index = kobj_to_cache_index_dir(k);
+        return index->cache;
+}
+static ssize_t size_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        unsigned int size_kb;
+        struct cache *cache;
+        cache = index_kobj_to_cache(k);
+        if (cache_size_kb(cache, &size_kb))
+                return -ENODEV;
+        return sprintf(buf, "%uK\n", size_kb);
+}
+static struct kobj_attribute cache_size_attr =
+        __ATTR(size, 0444, size_show, NULL);
+static ssize_t line_size_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        unsigned int line_size;
+        struct cache *cache;
+        cache = index_kobj_to_cache(k);
+        if (cache_get_line_size(cache, &line_size))
+                return -ENODEV;
+        return sprintf(buf, "%u\n", line_size);
+}
+static struct kobj_attribute cache_line_size_attr =
+        __ATTR(coherency_line_size, 0444, line_size_show, NULL);
+static ssize_t nr_sets_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        unsigned int nr_sets;
+        struct cache *cache;
+        cache = index_kobj_to_cache(k);
+        if (cache_nr_sets(cache, &nr_sets))
+                return -ENODEV;
+        return sprintf(buf, "%u\n", nr_sets);
+}
+static struct kobj_attribute cache_nr_sets_attr =
+        __ATTR(number_of_sets, 0444, nr_sets_show, NULL);
+static ssize_t associativity_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        unsigned int associativity;
+        struct cache *cache;
+        cache = index_kobj_to_cache(k);
+        if (cache_associativity(cache, &associativity))
+                return -ENODEV;
+        return sprintf(buf, "%u\n", associativity);
+}
+static struct kobj_attribute cache_assoc_attr =
+        __ATTR(ways_of_associativity, 0444, associativity_show, NULL);
+static ssize_t type_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        struct cache *cache;
+        cache = index_kobj_to_cache(k);
+        return sprintf(buf, "%s\n", cache_type_string(cache));
+}
+static struct kobj_attribute cache_type_attr =
+        __ATTR(type, 0444, type_show, NULL);
+static ssize_t level_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        struct cache_index_dir *index;
+        struct cache *cache;
+        index = kobj_to_cache_index_dir(k);
+        cache = index->cache;
+        return sprintf(buf, "%d\n", cache->level);
+}
+static struct kobj_attribute cache_level_attr =
+        __ATTR(level, 0444, level_show, NULL);
+static ssize_t shared_cpu_map_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
+{
+        struct cache_index_dir *index;
+        struct cache *cache;
+        int len;
+        int n = 0;
+        index = kobj_to_cache_index_dir(k);
+        cache = index->cache;
+        len = PAGE_SIZE - 2;
+        if (len > 1) {
+                n = cpumask_scnprintf(buf, len, &cache->shared_cpu_map);
+                buf[n++] = '\n';
+                buf[n] = '\0';
+        }
+        return n;
+}
+static struct kobj_attribute cache_shared_cpu_map_attr =
+        __ATTR(shared_cpu_map, 0444, shared_cpu_map_show, NULL);
+/* Attributes which should always be created -- the kobject/sysfs core
+ * does this automatically via kobj_type->default_attrs.  This is the
+ * minimum data required to uniquely identify a cache.
+ */
+static struct attribute *cache_index_default_attrs[] = {
+        &cache_type_attr.attr,
+        &cache_level_attr.attr,
+        &cache_shared_cpu_map_attr.attr,
+        NULL,
+};
+/* Attributes which should be created if the cache device node has the
+ * right properties -- see cacheinfo_create_index_opt_attrs
+ */
+static struct kobj_attribute *cache_index_opt_attrs[] = {
+        &cache_size_attr,
+        &cache_line_size_attr,
+        &cache_nr_sets_attr,
+        &cache_assoc_attr,
+};
+static struct sysfs_ops cache_index_ops = {
+        .show = cache_index_show,
+};
+static struct kobj_type cache_index_type = {
+        .release = cache_index_release,
+        .sysfs_ops = &cache_index_ops,
+        .default_attrs = cache_index_default_attrs,
+};
+static void __cpuinit cacheinfo_create_index_opt_attrs(struct cache_index_dir *dir)
+{
+        const char *cache_name;
+        const char *cache_type;
+        struct cache *cache;
+        char *buf;
+        int i;
+        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!buf)
+                return;
+        cache = dir->cache;
+        cache_name = cache->ofnode->full_name;
+        cache_type = cache_type_string(cache);
+        /* We don't want to create an attribute that can't provide a
+         * meaningful value.  Check the return value of each optional
+         * attribute's ->show method before registering the
+         * attribute.
+         */
+        for (i = 0; i < ARRAY_SIZE(cache_index_opt_attrs); i++) {
+                struct kobj_attribute *attr;
+                ssize_t rc;
+                attr = cache_index_opt_attrs[i];
+                rc = attr->show(&dir->kobj, attr, buf);
+                if (rc <= 0) {
+                        pr_debug("not creating %s attribute for "
+                                 "%s(%s) (rc = %zd)\n",
+                                 attr->attr.name, cache_name,
+                                 cache_type, rc);
+                        continue;
+                }
+                if (sysfs_create_file(&dir->kobj, &attr->attr))
+                        pr_debug("could not create %s attribute for %s(%s)\n",
+                                 attr->attr.name, cache_name, cache_type);
+        }
+        kfree(buf);
+}
+static void __cpuinit cacheinfo_create_index_dir(struct cache *cache, int index, struct cache_dir *cache_dir)
+{
+        struct cache_index_dir *index_dir;
+        int rc;
+        index_dir = kzalloc(sizeof(*index_dir), GFP_KERNEL);
+        if (!index_dir)
+                goto err;
+        index_dir->cache = cache;
+        rc = kobject_init_and_add(&index_dir->kobj, &cache_index_type,
+                                  cache_dir->kobj, "index%d", index);
+        if (rc)
+                goto err;
+        index_dir->next = cache_dir->index;
+        cache_dir->index = index_dir;
+        cacheinfo_create_index_opt_attrs(index_dir);
+        return;
+err:
+        kfree(index_dir);
+}
+static void __cpuinit cacheinfo_sysfs_populate(unsigned int cpu_id, struct cache *cache_list)
+{
+        struct cache_dir *cache_dir;
+        struct cache *cache;
+        int index = 0;
+        cache_dir = cacheinfo_create_cache_dir(cpu_id);
+        if (!cache_dir)
+                return;
+        cache = cache_list;
+        while (cache) {
+                cacheinfo_create_index_dir(cache, index, cache_dir);
+                index++;
+                cache = cache->next_local;
+        }
+}
+void __cpuinit cacheinfo_cpu_online(unsigned int cpu_id)
+{
+        struct cache *cache;
+        cache = cache_chain_instantiate(cpu_id);
+        if (!cache)
+                return;
+        cacheinfo_sysfs_populate(cpu_id, cache);
+}
+#ifdef CONFIG_HOTPLUG_CPU /* functions needed for cpu offline */
+static struct cache *cache_lookup_by_cpu(unsigned int cpu_id)
+{
+        struct device_node *cpu_node;
+        struct cache *cache;
+        cpu_node = of_get_cpu_node(cpu_id, NULL);
+        WARN_ONCE(!cpu_node, "no OF node found for CPU %i\n", cpu_id);
+        if (!cpu_node)
+                return NULL;
+        cache = cache_lookup_by_node(cpu_node);
+        of_node_put(cpu_node);
+        return cache;
+}
+static void remove_index_dirs(struct cache_dir *cache_dir)
+{
+        struct cache_index_dir *index;
+        index = cache_dir->index;
+        while (index) {
+                struct cache_index_dir *next;
+                next = index->next;
+                kobject_put(&index->kobj);
+                index = next;
+        }
+}
+static void remove_cache_dir(struct cache_dir *cache_dir)
+{
+        remove_index_dirs(cache_dir);
+        kobject_put(cache_dir->kobj);
+        kfree(cache_dir);
+}
+static void cache_cpu_clear(struct cache *cache, int cpu)
+{
+        while (cache) {
+                struct cache *next = cache->next_local;
+                WARN_ONCE(!cpumask_test_cpu(cpu, &cache->shared_cpu_map),
+                          "CPU %i not accounted in %s(%s)\n",
+                          cpu, cache->ofnode->full_name,
+                          cache_type_string(cache));
+                cpumask_clear_cpu(cpu, &cache->shared_cpu_map);
+                /* Release the cache object if all the cpus using it
+                 * are offline */
+                if (cpumask_empty(&cache->shared_cpu_map))
+                        release_cache(cache);
+                cache = next;
+        }
+}
+void cacheinfo_cpu_offline(unsigned int cpu_id)
+{
+        struct cache_dir *cache_dir;
+        struct cache *cache;
+        /* Prevent userspace from seeing inconsistent state - remove
+         * the sysfs hierarchy first */
+        cache_dir = per_cpu(cache_dir, cpu_id);
+        /* careful, sysfs population may have failed */
+        if (cache_dir)
+                remove_cache_dir(cache_dir);
+        per_cpu(cache_dir, cpu_id) = NULL;
+        /* clear the CPU's bit in its cache chain, possibly freeing
+         * cache objects */
+        cache = cache_lookup_by_cpu(cpu_id);
+        if (cache)
+                cache_cpu_clear(cache, cpu_id);
+}
+#endif /* CONFIG_HOTPLUG_CPU */
diff --git a/arch/powerpc/kernel/cacheinfo.h b/arch/powerpc/kernel/cacheinfo.h
new file mode 100644
index 000000000000..a7b74d36acd7
--- /dev/null
+++ b/arch/powerpc/kernel/cacheinfo.h
@@ -0,0 +1,8 @@
+#ifndef _PPC_CACHEINFO_H
+#define _PPC_CACHEINFO_H
+/* These are just hooks for sysfs.c to use. */
+extern void cacheinfo_cpu_online(unsigned int cpu_id);
+extern void cacheinfo_cpu_offline(unsigned int cpu_id);
+#endif /* _PPC_CACHEINFO_H */
diff --git a/arch/powerpc/kernel/pci-common.c b/arch/powerpc/kernel/pci-common.c
index 2538030954d8..da5a3855a0c4 100644
--- a/arch/powerpc/kernel/pci-common.c
+++ b/arch/powerpc/kernel/pci-common.c
@@ -16,7 +16,7 @@
 * 2 of the License, or (at your option) any later version.
 */
-#undef DEBUG
+#define DEBUG
 #include <linux/kernel.h>
 #include <linux/pci.h>
@@ -1356,6 +1356,63 @@ static void __init pcibios_allocate_resources(int pass)
        }
 }
+static void __init pcibios_reserve_legacy_regions(struct pci_bus *bus)
+{
+        struct pci_controller *hose = pci_bus_to_host(bus);
+        resource_size_t offset;
+        struct resource *res, *pres;
+        int i;
+        pr_debug("Reserving legacy ranges for domain %04x\n", pci_domain_nr(bus));
+        /* Check for IO */
+        if (!(hose->io_resource.flags & IORESOURCE_IO))
+                goto no_io;
+        offset = (unsigned long)hose->io_base_virt - _IO_BASE;
+        res = kzalloc(sizeof(struct resource), GFP_KERNEL);
+        BUG_ON(res == NULL);
+        res->name = "Legacy IO";
+        res->flags = IORESOURCE_IO;
+        res->start = offset;
+        res->end = (offset + 0xfff) & 0xfffffffful;
+        pr_debug("Candidate legacy IO: %pR\n", res);
+        if (request_resource(&hose->io_resource, res)) {
+                printk(KERN_DEBUG
+                       "PCI %04x:%02x Cannot reserve Legacy IO %pR\n",
+                       pci_domain_nr(bus), bus->number, res);
+                kfree(res);
+        }
+ no_io:
+        /* Check for memory */
+        offset = hose->pci_mem_offset;
+        pr_debug("hose mem offset: %016llx\n", (unsigned long long)offset);
+        for (i = 0; i < 3; i++) {
+                pres = &hose->mem_resources[i];
+                if (!(pres->flags & IORESOURCE_MEM))
+                        continue;
+                pr_debug("hose mem res: %pR\n", pres);
+                if ((pres->start - offset) <= 0xa0000 &&
+                    (pres->end - offset) >= 0xbffff)
+                        break;
+        }
+        if (i >= 3)
+                return;
+        res = kzalloc(sizeof(struct resource), GFP_KERNEL);
+        BUG_ON(res == NULL);
+        res->name = "Legacy VGA memory";
+        res->flags = IORESOURCE_MEM;
+        res->start = 0xa0000 + offset;
+        res->end = 0xbffff + offset;
+        pr_debug("Candidate VGA memory: %pR\n", res);
+        if (request_resource(pres, res)) {
+                printk(KERN_DEBUG
+                       "PCI %04x:%02x Cannot reserve VGA memory %pR\n",
+                       pci_domain_nr(bus), bus->number, res);
+                kfree(res);
+        }
+}
 void __init pcibios_resource_survey(void)
 {
        struct pci_bus *b;
@@ -1371,6 +1428,18 @@ void __init pcibios_resource_survey(void)
                pcibios_allocate_resources(1);
        }
+        /* Before we start assigning unassigned resource, we try to reserve
+         * the low IO area and the VGA memory area if they intersect the
+         * bus available resources to avoid allocating things on top of them
+         */
+        if (!(ppc_pci_flags & PPC_PCI_PROBE_ONLY)) {
+                list_for_each_entry(b, &pci_root_buses, node)
+                        pcibios_reserve_legacy_regions(b);
+        }
+        /* Now, if the platform didn't decide to blindly trust the firmware,
+         * we proceed to assigning things that were left unassigned
+         */
        if (!(ppc_pci_flags & PPC_PCI_PROBE_ONLY)) {
                pr_debug("PCI: Assigning unassigned resouces...\n");
                pci_assign_unassigned_resources();
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 39fadc6e1492..586962f65c2a 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -560,9 +560,14 @@ long sys_pciconfig_iobase(long which, unsigned long in_bus,
         * G5 machines... So when something asks for bus 0 io base
         * (bus 0 is HT root), we return the AGP one instead.
         */
-        if (machine_is_compatible("MacRISC4"))
+        if (in_bus == 0 && machine_is_compatible("MacRISC4")) {
-                if (in_bus == 0)
+                struct device_node *agp;
+                agp = of_find_compatible_node(NULL, NULL, "u3-agp");
+                if (agp)
                        in_bus = 0xf0;
+                of_node_put(agp);
+        }
        /* That syscall isn't quite compatible with PCI domains, but it's
         * used on pre-domains setup. We return the first match
diff --git a/arch/powerpc/kernel/ppc_ksyms.c b/arch/powerpc/kernel/ppc_ksyms.c
index dcec1325d340..c8b27bb4dbde 100644
--- a/arch/powerpc/kernel/ppc_ksyms.c
+++ b/arch/powerpc/kernel/ppc_ksyms.c
@@ -165,6 +165,7 @@ EXPORT_SYMBOL(timer_interrupt);
 EXPORT_SYMBOL(irq_desc);
 EXPORT_SYMBOL(tb_ticks_per_jiffy);
 EXPORT_SYMBOL(cacheable_memcpy);
+EXPORT_SYMBOL(cacheable_memzero);
 #endif
 #ifdef CONFIG_PPC32
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index 6f73c739f1e2..c09cffafb6ee 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -824,11 +824,11 @@ static int __init early_init_dt_scan_chosen(unsigned long node,
 #endif
 #ifdef CONFIG_KEXEC
-        lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
+        lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
        if (lprop)
                crashk_res.start = *lprop;
-        lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
+        lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
        if (lprop)
                crashk_res.end = crashk_res.start + *lprop - 1;
 #endif
@@ -893,12 +893,12 @@ static int __init early_init_dt_scan_drconf_memory(unsigned long node)
        u64 base, size, lmb_size;
        unsigned int is_kexec_kdump = 0, rngs;
-        ls = (cell_t *)of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
+        ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
        if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t))
                return 0;
        lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls);
-        dm = (cell_t *)of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
+        dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
        if (dm == NULL || l < sizeof(cell_t))
                return 0;
@@ -907,7 +907,7 @@ static int __init early_init_dt_scan_drconf_memory(unsigned long node)
                return 0;
        /* check if this is a kexec/kdump kernel. */
-        usm = (cell_t *)of_get_flat_dt_prop(node, "linux,drconf-usable-memory",
+        usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory",
                                                 &l);
        if (usm != NULL)
                is_kexec_kdump = 1;
@@ -981,9 +981,9 @@ static int __init early_init_dt_scan_memory(unsigned long node,
        } else if (strcmp(type, "memory") != 0)
                return 0;
-        reg = (cell_t *)of_get_flat_dt_prop(node, "linux,usable-memory", &l);
+        reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
        if (reg == NULL)
-                reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l);
+                reg = of_get_flat_dt_prop(node, "reg", &l);
        if (reg == NULL)
                return 0;
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index 2445945d3761..7f1b33d5e30d 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -1210,7 +1210,7 @@ static void __init prom_initialize_tce_table(void)
                /* Initialize the table to have a one-to-one mapping
                 * over the allocated size.
                 */
-                tce_entryp = (unsigned long *)base;
+                tce_entryp = (u64 *)base;
                for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
                        tce_entry = (i << PAGE_SHIFT);
                        tce_entry |= 0x3;
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c
index 8c1335566089..8f0856f312da 100644
--- a/arch/powerpc/kernel/prom_parse.c
+++ b/arch/powerpc/kernel/prom_parse.c
@@ -232,11 +232,6 @@ int of_pci_address_to_resource(struct device_node *dev, int bar,
 }
 EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
-static u8 of_irq_pci_swizzle(u8 slot, u8 pin)
-{
-        return (((pin - 1) + slot) % 4) + 1;
-}
 int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
 {
        struct device_node *dn, *ppnode;
@@ -306,7 +301,7 @@ int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
                /* We can only get here if we hit a P2P bridge with no node,
                 * let's do standard swizzling and try again
                 */
-                lspec = of_irq_pci_swizzle(PCI_SLOT(pdev->devfn), lspec);
+                lspec = pci_swizzle_interrupt_pin(pdev, lspec);
                pdev = ppdev;
        }
diff --git a/arch/powerpc/kernel/sysfs.c b/arch/powerpc/kernel/sysfs.c
index 0c64f10087b9..4a2ee08af6a7 100644
--- a/arch/powerpc/kernel/sysfs.c
+++ b/arch/powerpc/kernel/sysfs.c
@@ -18,6 +18,8 @@
 #include <asm/machdep.h>
 #include <asm/smp.h>
+#include "cacheinfo.h"
 #ifdef CONFIG_PPC64
 #include <asm/paca.h>
 #include <asm/lppaca.h>
@@ -25,8 +27,6 @@
 static DEFINE_PER_CPU(struct cpu, cpu_devices);
-static DEFINE_PER_CPU(struct kobject *, cache_toplevel);
 /*
 * SMT snooze delay stuff, 64-bit only for now
 */
@@ -343,283 +343,6 @@ static struct sysdev_attribute pa6t_attrs[] = {
 #endif /* HAS_PPC_PMC_PA6T */
 #endif /* HAS_PPC_PMC_CLASSIC */
-struct cache_desc {
-        struct kobject kobj;
-        struct cache_desc *next;
-        const char *type;       /* Instruction, Data, or Unified */
-        u32 size;               /* total cache size in KB */
-        u32 line_size;          /* in bytes */
-        u32 nr_sets;            /* number of sets */
-        u32 level;              /* e.g. 1, 2, 3... */
-        u32 associativity;      /* e.g. 8-way... 0 is fully associative */
-};
-DEFINE_PER_CPU(struct cache_desc *, cache_desc);
-static struct cache_desc *kobj_to_cache_desc(struct kobject *k)
-{
-        return container_of(k, struct cache_desc, kobj);
-}
-static void cache_desc_release(struct kobject *k)
-{
-        struct cache_desc *desc = kobj_to_cache_desc(k);
-        pr_debug("%s: releasing %s\n", __func__, kobject_name(k));
-        if (desc->next)
-                kobject_put(&desc->next->kobj);
-        kfree(kobj_to_cache_desc(k));
-}
-static ssize_t cache_desc_show(struct kobject *k, struct attribute *attr, char *buf)
-{
-        struct kobj_attribute *kobj_attr;
-        kobj_attr = container_of(attr, struct kobj_attribute, attr);
-        return kobj_attr->show(k, kobj_attr, buf);
-}
-static struct sysfs_ops cache_desc_sysfs_ops = {
-        .show = cache_desc_show,
-};
-static struct kobj_type cache_desc_type = {
-        .release = cache_desc_release,
-        .sysfs_ops = &cache_desc_sysfs_ops,
-};
-static ssize_t cache_size_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
-{
-        struct cache_desc *cache = kobj_to_cache_desc(k);
-        return sprintf(buf, "%uK\n", cache->size);
-}
-static struct kobj_attribute cache_size_attr =
-        __ATTR(size, 0444, cache_size_show, NULL);
-static ssize_t cache_line_size_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
-{
-        struct cache_desc *cache = kobj_to_cache_desc(k);
-        return sprintf(buf, "%u\n", cache->line_size);
-}
-static struct kobj_attribute cache_line_size_attr =
-        __ATTR(coherency_line_size, 0444, cache_line_size_show, NULL);
-static ssize_t cache_nr_sets_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
-{
-        struct cache_desc *cache = kobj_to_cache_desc(k);
-        return sprintf(buf, "%u\n", cache->nr_sets);
-}
-static struct kobj_attribute cache_nr_sets_attr =
-        __ATTR(number_of_sets, 0444, cache_nr_sets_show, NULL);
-static ssize_t cache_type_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
-{
-        struct cache_desc *cache = kobj_to_cache_desc(k);
-        return sprintf(buf, "%s\n", cache->type);
-}
-static struct kobj_attribute cache_type_attr =
-        __ATTR(type, 0444, cache_type_show, NULL);
-static ssize_t cache_level_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
-{
-        struct cache_desc *cache = kobj_to_cache_desc(k);
-        return sprintf(buf, "%u\n", cache->level);
-}
-static struct kobj_attribute cache_level_attr =
-        __ATTR(level, 0444, cache_level_show, NULL);
-static ssize_t cache_assoc_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
-{
-        struct cache_desc *cache = kobj_to_cache_desc(k);
-        return sprintf(buf, "%u\n", cache->associativity);
-}
-static struct kobj_attribute cache_assoc_attr =
-        __ATTR(ways_of_associativity, 0444, cache_assoc_show, NULL);
-struct cache_desc_info {
-        const char *type;
-        const char *size_prop;
-        const char *line_size_prop;
-        const char *nr_sets_prop;
-};
-/* PowerPC Processor binding says the [di]-cache-* must be equal on
- * unified caches, so just use d-cache properties. */
-static struct cache_desc_info ucache_info = {
-        .type = "Unified",
-        .size_prop = "d-cache-size",
-        .line_size_prop = "d-cache-line-size",
-        .nr_sets_prop = "d-cache-sets",
-};
-static struct cache_desc_info dcache_info = {
-        .type = "Data",
-        .size_prop = "d-cache-size",
-        .line_size_prop = "d-cache-line-size",
-        .nr_sets_prop = "d-cache-sets",
-};
-static struct cache_desc_info icache_info = {
-        .type = "Instruction",
-        .size_prop = "i-cache-size",
-        .line_size_prop = "i-cache-line-size",
-        .nr_sets_prop = "i-cache-sets",
-};
-static struct cache_desc * __cpuinit create_cache_desc(struct device_node *np, struct kobject *parent, int index, int level, struct cache_desc_info *info)
-{
-        const u32 *cache_line_size;
-        struct cache_desc *new;
-        const u32 *cache_size;
-        const u32 *nr_sets;
-        int rc;
-        new = kzalloc(sizeof(*new), GFP_KERNEL);
-        if (!new)
-                return NULL;
-        rc = kobject_init_and_add(&new->kobj, &cache_desc_type, parent,
-                                  "index%d", index);
-        if (rc)
-                goto err;
-        /* type */
-        new->type = info->type;
-        rc = sysfs_create_file(&new->kobj, &cache_type_attr.attr);
-        WARN_ON(rc);
-        /* level */
-        new->level = level;
-        rc = sysfs_create_file(&new->kobj, &cache_level_attr.attr);
-        WARN_ON(rc);
-        /* size */
-        cache_size = of_get_property(np, info->size_prop, NULL);
-        if (cache_size) {
-                new->size = *cache_size / 1024;
-                rc = sysfs_create_file(&new->kobj,
-                                       &cache_size_attr.attr);
-                WARN_ON(rc);
-        }
-        /* coherency_line_size */
-        cache_line_size = of_get_property(np, info->line_size_prop, NULL);
-        if (cache_line_size) {
-                new->line_size = *cache_line_size;
-                rc = sysfs_create_file(&new->kobj,
-                                       &cache_line_size_attr.attr);
-                WARN_ON(rc);
-        }
-        /* number_of_sets */
-        nr_sets = of_get_property(np, info->nr_sets_prop, NULL);
-        if (nr_sets) {
-                new->nr_sets = *nr_sets;
-                rc = sysfs_create_file(&new->kobj,
-                                       &cache_nr_sets_attr.attr);
-                WARN_ON(rc);
-        }
-        /* ways_of_associativity */
-        if (new->nr_sets == 1) {
-                /* fully associative */
-                new->associativity = 0;
-                goto create_assoc;
-        }
-        if (new->nr_sets && new->size && new->line_size) {
-                /* If we have values for all of these we can derive
-                 * the associativity. */
-                new->associativity =
-                        ((new->size * 1024) / new->nr_sets) / new->line_size;
-create_assoc:
-                rc = sysfs_create_file(&new->kobj,
-                                       &cache_assoc_attr.attr);
-                WARN_ON(rc);
-        }
-        return new;
-err:
-        kfree(new);
-        return NULL;
-}
-static bool cache_is_unified(struct device_node *np)
-{
-        return of_get_property(np, "cache-unified", NULL);
-}
-static struct cache_desc * __cpuinit create_cache_index_info(struct device_node *np, struct kobject *parent, int index, int level)
-{
-        struct device_node *next_cache;
-        struct cache_desc *new, **end;
-        pr_debug("%s(node = %s, index = %d)\n", __func__, np->full_name, index);
-        if (cache_is_unified(np)) {
-                new = create_cache_desc(np, parent, index, level,
-                                        &ucache_info);
-        } else {
-                new = create_cache_desc(np, parent, index, level,
-                                        &dcache_info);
-                if (new) {
-                        index++;
-                        new->next = create_cache_desc(np, parent, index, level,
-                                                      &icache_info);
-                }
-        }
-        if (!new)
-                return NULL;
-        end = &new->next;
-        while (*end)
-                end = &(*end)->next;
-        next_cache = of_find_next_cache_node(np);
-        if (!next_cache)
-                goto out;
-        *end = create_cache_index_info(next_cache, parent, ++index, ++level);
-        of_node_put(next_cache);
-out:
-        return new;
-}
-static void __cpuinit create_cache_info(struct sys_device *sysdev)
-{
-        struct kobject *cache_toplevel;
-        struct device_node *np = NULL;
-        int cpu = sysdev->id;
-        cache_toplevel = kobject_create_and_add("cache", &sysdev->kobj);
-        if (!cache_toplevel)
-                return;
-        per_cpu(cache_toplevel, cpu) = cache_toplevel;
-        np = of_get_cpu_node(cpu, NULL);
-        if (np != NULL) {
-                per_cpu(cache_desc, cpu) =
-                        create_cache_index_info(np, cache_toplevel, 0, 1);
-                of_node_put(np);
-        }
-        return;
-}
 static void __cpuinit register_cpu_online(unsigned int cpu)
 {
        struct cpu *c = &per_cpu(cpu_devices, cpu);
@@ -684,25 +407,10 @@ static void __cpuinit register_cpu_online(unsigned int cpu)
                sysdev_create_file(s, &attr_dscr);
 #endif /* CONFIG_PPC64 */
-        create_cache_info(s);
+        cacheinfo_cpu_online(cpu);
 }
 #ifdef CONFIG_HOTPLUG_CPU
-static void remove_cache_info(struct sys_device *sysdev)
-{
-        struct kobject *cache_toplevel;
-        struct cache_desc *cache_desc;
-        int cpu = sysdev->id;
-        cache_desc = per_cpu(cache_desc, cpu);
-        if (cache_desc != NULL)
-                kobject_put(&cache_desc->kobj);
-        cache_toplevel = per_cpu(cache_toplevel, cpu);
-        if (cache_toplevel != NULL)
-                kobject_put(cache_toplevel);
-}
 static void unregister_cpu_online(unsigned int cpu)
 {
        struct cpu *c = &per_cpu(cpu_devices, cpu);
@@ -769,7 +477,7 @@ static void unregister_cpu_online(unsigned int cpu)
                sysdev_remove_file(s, &attr_dscr);
 #endif /* CONFIG_PPC64 */
-        remove_cache_info(s);
+        cacheinfo_cpu_offline(cpu);
 }
 #endif /* CONFIG_HOTPLUG_CPU */
diff --git a/arch/powerpc/mm/mmu_decl.h b/arch/powerpc/mm/mmu_decl.h
index 4314b39b6faf..ad123bced404 100644
--- a/arch/powerpc/mm/mmu_decl.h
+++ b/arch/powerpc/mm/mmu_decl.h
@@ -30,11 +30,11 @@
 #if defined(CONFIG_40x) || defined(CONFIG_8xx)
 static inline void _tlbil_all(void)
 {
-        asm volatile ("sync; tlbia; isync" : : : "memory")
+        asm volatile ("sync; tlbia; isync" : : : "memory");
 }
 static inline void _tlbil_pid(unsigned int pid)
 {
-        asm volatile ("sync; tlbia; isync" : : : "memory")
+        asm volatile ("sync; tlbia; isync" : : : "memory");
 }
 #else /* CONFIG_40x || CONFIG_8xx */
 extern void _tlbil_all(void);
@@ -47,7 +47,7 @@ extern void _tlbil_pid(unsigned int pid);
 #ifdef CONFIG_8xx
 static inline void _tlbil_va(unsigned long address, unsigned int pid)
 {
-        asm volatile ("tlbie %0; sync" : : "r" (address) : "memory")
+        asm volatile ("tlbie %0; sync" : : "r" (address) : "memory");
 }
 #else /* CONFIG_8xx */
 extern void _tlbil_va(unsigned long address, unsigned int pid);
diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
index cf81049e1e51..7393bd76d698 100644
--- a/arch/powerpc/mm/numa.c
+++ b/arch/powerpc/mm/numa.c
@@ -822,42 +822,50 @@ static void __init dump_numa_memory_topology(void)
 * required. nid is the preferred node and end is the physical address of
 * the highest address in the node.
 *
- * Returns the physical address of the memory.
+ * Returns the virtual address of the memory.
 */
-static void __init *careful_allocation(int nid, unsigned long size,
+static void __init *careful_zallocation(int nid, unsigned long size,
                                       unsigned long align,
                                       unsigned long end_pfn)
 {
+        void *ret;
        int new_nid;
-        unsigned long ret = __lmb_alloc_base(size, align, end_pfn << PAGE_SHIFT);
+        unsigned long ret_paddr;
+        ret_paddr = __lmb_alloc_base(size, align, end_pfn << PAGE_SHIFT);
        /* retry over all memory */
-        if (!ret)
+        if (!ret_paddr)
-                ret = __lmb_alloc_base(size, align, lmb_end_of_DRAM());
+                ret_paddr = __lmb_alloc_base(size, align, lmb_end_of_DRAM());
-        if (!ret)
+        if (!ret_paddr)
-                panic("numa.c: cannot allocate %lu bytes on node %d",
+                panic("numa.c: cannot allocate %lu bytes for node %d",
                      size, nid);
+        ret = __va(ret_paddr);
        /*
-         * If the memory came from a previously allocated node, we must
+         * We initialize the nodes in numeric order: 0, 1, 2...
-         * retry with the bootmem allocator.
+         * and hand over control from the LMB allocator to the
+         * bootmem allocator.  If this function is called for
+         * node 5, then we know that all nodes <5 are using the
+         * bootmem allocator instead of the LMB allocator.
+         *
+         * So, check the nid from which this allocation came
+         * and double check to see if we need to use bootmem
+         * instead of the LMB.  We don't free the LMB memory
+         * since it would be useless.
         */
-        new_nid = early_pfn_to_nid(ret >> PAGE_SHIFT);
+        new_nid = early_pfn_to_nid(ret_paddr >> PAGE_SHIFT);
        if (new_nid < nid) {
-                ret = (unsigned long)__alloc_bootmem_node(NODE_DATA(new_nid),
+                ret = __alloc_bootmem_node(NODE_DATA(new_nid),
                                size, align, 0);
-                if (!ret)
+                dbg("alloc_bootmem %p %lx\n", ret, size);
-                        panic("numa.c: cannot allocate %lu bytes on node %d",
-                              size, new_nid);
-                ret = __pa(ret);
-                dbg("alloc_bootmem %lx %lx\n", ret, size);
        }
-        return (void *)ret;
+        memset(ret, 0, size);
+        return ret;
 }
 static struct notifier_block __cpuinitdata ppc64_numa_nb = {
@@ -952,7 +960,7 @@ void __init do_init_bootmem(void)
        for_each_online_node(nid) {
                unsigned long start_pfn, end_pfn;
-                unsigned long bootmem_paddr;
+                void *bootmem_vaddr;
                unsigned long bootmap_pages;
                get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
@@ -964,11 +972,9 @@ void __init do_init_bootmem(void)
                 * previous nodes' bootmem to be initialized and have
                 * all reserved areas marked.
                 */
-                NODE_DATA(nid) = careful_allocation(nid,
+                NODE_DATA(nid) = careful_zallocation(nid,
                                        sizeof(struct pglist_data),
                                        SMP_CACHE_BYTES, end_pfn);
-                NODE_DATA(nid) = __va(NODE_DATA(nid));
-                memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
                dbg("node %d\n", nid);
                dbg("NODE_DATA() = %p\n", NODE_DATA(nid));
@@ -984,20 +990,20 @@ void __init do_init_bootmem(void)
                dbg("end_paddr = %lx\n", end_pfn << PAGE_SHIFT);
                bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
-                bootmem_paddr = (unsigned long)careful_allocation(nid,
+                bootmem_vaddr = careful_zallocation(nid,
                                        bootmap_pages << PAGE_SHIFT,
                                        PAGE_SIZE, end_pfn);
-                memset(__va(bootmem_paddr), 0, bootmap_pages << PAGE_SHIFT);
-                dbg("bootmap_paddr = %lx\n", bootmem_paddr);
+                dbg("bootmap_vaddr = %p\n", bootmem_vaddr);
-                init_bootmem_node(NODE_DATA(nid), bootmem_paddr >> PAGE_SHIFT,
+                init_bootmem_node(NODE_DATA(nid),
+                                  __pa(bootmem_vaddr) >> PAGE_SHIFT,
                                  start_pfn, end_pfn);
                free_bootmem_with_active_regions(nid, end_pfn);
                /*
                 * Be very careful about moving this around.  Future
-                 * calls to careful_allocation() depend on this getting
+                 * calls to careful_zallocation() depend on this getting
                 * done correctly.
                 */
                mark_reserved_regions_for_nid(nid);
diff --git a/arch/powerpc/mm/pgtable_32.c b/arch/powerpc/mm/pgtable_32.c
index 38ff35f2142a..22972cd83cc9 100644
--- a/arch/powerpc/mm/pgtable_32.c
+++ b/arch/powerpc/mm/pgtable_32.c
@@ -266,7 +266,8 @@ int map_page(unsigned long va, phys_addr_t pa, int flags)
                /* The PTE should never be already set nor present in the
                 * hash table
                 */
-                BUG_ON(pte_val(*pg) & (_PAGE_PRESENT | _PAGE_HASHPTE));
+                BUG_ON((pte_val(*pg) & (_PAGE_PRESENT | _PAGE_HASHPTE)) &&
+                       flags);
                set_pte_at(&init_mm, va, pg, pfn_pte(pa >> PAGE_SHIFT,
                                                     __pgprot(flags)));
        }
diff --git a/arch/powerpc/mm/tlb_nohash.c b/arch/powerpc/mm/tlb_nohash.c
index 803a64c02b06..39ac22b13c73 100644
--- a/arch/powerpc/mm/tlb_nohash.c
+++ b/arch/powerpc/mm/tlb_nohash.c
@@ -189,8 +189,9 @@ void flush_tlb_kernel_range(unsigned long start, unsigned long end)
        smp_call_function(do_flush_tlb_mm_ipi, NULL, 1);
        _tlbil_pid(0);
        preempt_enable();
-#endif
+#else
        _tlbil_pid(0);
+#endif
 }
 EXPORT_SYMBOL(flush_tlb_kernel_range);
diff --git a/arch/powerpc/oprofile/cell/pr_util.h b/arch/powerpc/oprofile/cell/pr_util.h
index 628009c01958..964b93974d89 100644
--- a/arch/powerpc/oprofile/cell/pr_util.h
+++ b/arch/powerpc/oprofile/cell/pr_util.h
@@ -30,6 +30,10 @@
 extern struct delayed_work spu_work;
 extern int spu_prof_running;
+#define TRACE_ARRAY_SIZE 1024
+extern spinlock_t oprof_spu_smpl_arry_lck;
 struct spu_overlay_info {       /* map of sections within an SPU overlay */
        unsigned int vma;       /* SPU virtual memory address from elf */
        unsigned int size;      /* size of section from elf */
@@ -79,7 +83,7 @@ struct spu_buffer {
 * the vma-to-fileoffset map.
 */
 struct vma_to_fileoffset_map *create_vma_map(const struct spu *spu,
-                                             u64 objectid);
+                                             unsigned long objectid);
 unsigned int vma_map_lookup(struct vma_to_fileoffset_map *map,
                            unsigned int vma, const struct spu *aSpu,
                            int *grd_val);
@@ -89,10 +93,11 @@ void vma_map_free(struct vma_to_fileoffset_map *map);
 * Entry point for SPU profiling.
 * cycles_reset is the SPU_CYCLES count value specified by the user.
 */
-int start_spu_profiling(unsigned int cycles_reset);
+int start_spu_profiling_cycles(unsigned int cycles_reset);
+void start_spu_profiling_events(void);
-void stop_spu_profiling(void);
+void stop_spu_profiling_cycles(void);
+void stop_spu_profiling_events(void);
 /* add the necessary profiling hooks */
 int spu_sync_start(void);
diff --git a/arch/powerpc/oprofile/cell/spu_profiler.c b/arch/powerpc/oprofile/cell/spu_profiler.c
index 83faa958b9d4..9305ddaac512 100644
--- a/arch/powerpc/oprofile/cell/spu_profiler.c
+++ b/arch/powerpc/oprofile/cell/spu_profiler.c
@@ -18,11 +18,21 @@
 #include <asm/cell-pmu.h>
 #include "pr_util.h"
-#define TRACE_ARRAY_SIZE 1024
 #define SCALE_SHIFT 14
 static u32 *samples;
+/* spu_prof_running is a flag used to indicate if spu profiling is enabled
+ * or not.  It is set by the routines start_spu_profiling_cycles() and
+ * start_spu_profiling_events().  The flag is cleared by the routines
+ * stop_spu_profiling_cycles() and stop_spu_profiling_events().  These
+ * routines are called via global_start() and global_stop() which are called in
+ * op_powerpc_start() and op_powerpc_stop().  These routines are called once
+ * per system as a result of the user starting/stopping oprofile.  Hence, only
+ * one CPU per user at a time will be changing  the value of spu_prof_running.
+ * In general, OProfile does not protect against multiple users trying to run
+ * OProfile at a time.
+ */
 int spu_prof_running;
 static unsigned int profiling_interval;
@@ -31,8 +41,8 @@ static unsigned int profiling_interval;
 #define SPU_PC_MASK          0xFFFF
-static DEFINE_SPINLOCK(sample_array_lock);
+DEFINE_SPINLOCK(oprof_spu_smpl_arry_lck);
-unsigned long sample_array_lock_flags;
+unsigned long oprof_spu_smpl_arry_lck_flags;
 void set_spu_profiling_frequency(unsigned int freq_khz, unsigned int cycles_reset)
 {
@@ -145,13 +155,13 @@ static enum hrtimer_restart profile_spus(struct hrtimer *timer)
                 * sample array must be loaded and then processed for a given
                 * cpu.  The sample array is not per cpu.
                 */
-                spin_lock_irqsave(&sample_array_lock,
+                spin_lock_irqsave(&oprof_spu_smpl_arry_lck,
-                                  sample_array_lock_flags);
+                                  oprof_spu_smpl_arry_lck_flags);
                num_samples = cell_spu_pc_collection(cpu);
                if (num_samples == 0) {
-                        spin_unlock_irqrestore(&sample_array_lock,
+                        spin_unlock_irqrestore(&oprof_spu_smpl_arry_lck,
-                                               sample_array_lock_flags);
+                                               oprof_spu_smpl_arry_lck_flags);
                        continue;
                }
@@ -162,8 +172,8 @@ static enum hrtimer_restart profile_spus(struct hrtimer *timer)
                                        num_samples);
                }
-                spin_unlock_irqrestore(&sample_array_lock,
+                spin_unlock_irqrestore(&oprof_spu_smpl_arry_lck,
-                                       sample_array_lock_flags);
+                                       oprof_spu_smpl_arry_lck_flags);
        }
        smp_wmb();      /* insure spu event buffer updates are written */
@@ -182,13 +192,13 @@ static enum hrtimer_restart profile_spus(struct hrtimer *timer)
 static struct hrtimer timer;
 /*
- * Entry point for SPU profiling.
+ * Entry point for SPU cycle profiling.
 * NOTE:  SPU profiling is done system-wide, not per-CPU.
 *
 * cycles_reset is the count value specified by the user when
 * setting up OProfile to count SPU_CYCLES.
 */
-int start_spu_profiling(unsigned int cycles_reset)
+int start_spu_profiling_cycles(unsigned int cycles_reset)
 {
        ktime_t kt;
@@ -212,10 +222,30 @@ int start_spu_profiling(unsigned int cycles_reset)
        return 0;
 }
-void stop_spu_profiling(void)
+/*
+ * Entry point for SPU event profiling.
+ * NOTE:  SPU profiling is done system-wide, not per-CPU.
+ *
+ * cycles_reset is the count value specified by the user when
+ * setting up OProfile to count SPU_CYCLES.
+ */
+void start_spu_profiling_events(void)
+{
+        spu_prof_running = 1;
+        schedule_delayed_work(&spu_work, DEFAULT_TIMER_EXPIRE);
+        return;
+}
+void stop_spu_profiling_cycles(void)
 {
        spu_prof_running = 0;
        hrtimer_cancel(&timer);
        kfree(samples);
-        pr_debug("SPU_PROF: stop_spu_profiling issued\n");
+        pr_debug("SPU_PROF: stop_spu_profiling_cycles issued\n");
+}
+void stop_spu_profiling_events(void)
+{
+        spu_prof_running = 0;
 }
diff --git a/arch/powerpc/oprofile/common.c b/arch/powerpc/oprofile/common.c
index 17807acb05d9..21f16edf6c8d 100644
--- a/arch/powerpc/oprofile/common.c
+++ b/arch/powerpc/oprofile/common.c
@@ -132,6 +132,28 @@ static int op_powerpc_create_files(struct super_block *sb, struct dentry *root)
        oprofilefs_create_ulong(sb, root, "mmcr0", &sys.mmcr0);
        oprofilefs_create_ulong(sb, root, "mmcr1", &sys.mmcr1);
        oprofilefs_create_ulong(sb, root, "mmcra", &sys.mmcra);
+#ifdef CONFIG_OPROFILE_CELL
+        /* create a file the user tool can check to see what level of profiling
+         * support exits with this kernel. Initialize bit mask to indicate
+         * what support the kernel has:
+         * bit 0      -  Supports SPU event profiling in addition to PPU
+         *               event and cycles; and SPU cycle profiling
+         * bits 1-31  -  Currently unused.
+         *
+         * If the file does not exist, then the kernel only supports SPU
+         * cycle profiling, PPU event and cycle profiling.
+         */
+        oprofilefs_create_ulong(sb, root, "cell_support", &sys.cell_support);
+        sys.cell_support = 0x1; /* Note, the user OProfile tool must check
+                                 * that this bit is set before attempting to
+                                 * user SPU event profiling.  Older kernels
+                                 * will not have this file, hence the user
+                                 * tool is not allowed to do SPU event
+                                 * profiling on older kernels.  Older kernels
+                                 * will accept SPU events but collected data
+                                 * is garbage.
+                                 */
+#endif
 #endif
        for (i = 0; i < model->num_counters; ++i) {
diff --git a/arch/powerpc/oprofile/op_model_cell.c b/arch/powerpc/oprofile/op_model_cell.c
index 25a4ec2514a3..ae06c6236d9c 100644
--- a/arch/powerpc/oprofile/op_model_cell.c
+++ b/arch/powerpc/oprofile/op_model_cell.c
@@ -40,14 +40,15 @@
 #include "../platforms/cell/interrupt.h"
 #include "cell/pr_util.h"
-static void cell_global_stop_spu(void);
+#define PPU_PROFILING            0
+#define SPU_PROFILING_CYCLES     1
+#define SPU_PROFILING_EVENTS     2
-/*
+#define SPU_EVENT_NUM_START      4100
- * spu_cycle_reset is the number of cycles between samples.
+#define SPU_EVENT_NUM_STOP       4399
- * This variable is used for SPU profiling and should ONLY be set
+#define SPU_PROFILE_EVENT_ADDR          4363  /* spu, address trace, decimal */
- * at the beginning of cell_reg_setup; otherwise, it's read-only.
+#define SPU_PROFILE_EVENT_ADDR_MASK_A   0x146 /* sub unit set to zero */
- */
+#define SPU_PROFILE_EVENT_ADDR_MASK_B   0x186 /* sub unit set to zero */
-static unsigned int spu_cycle_reset;
 #define NUM_SPUS_PER_NODE    8
 #define SPU_CYCLES_EVENT_NUM 2  /*  event number for SPU_CYCLES */
@@ -66,6 +67,21 @@ static unsigned int spu_cycle_reset;
 #define MAX_SPU_COUNT 0xFFFFFF  /* maximum 24 bit LFSR value */
+/* Minumum HW interval timer setting to send value to trace buffer is 10 cycle.
+ * To configure counter to send value every N cycles set counter to
+ * 2^32 - 1 - N.
+ */
+#define NUM_INTERVAL_CYC  0xFFFFFFFF - 10
+/*
+ * spu_cycle_reset is the number of cycles between samples.
+ * This variable is used for SPU profiling and should ONLY be set
+ * at the beginning of cell_reg_setup; otherwise, it's read-only.
+ */
+static unsigned int spu_cycle_reset;
+static unsigned int profiling_mode;
+static int spu_evnt_phys_spu_indx;
 struct pmc_cntrl_data {
        unsigned long vcntr;
        unsigned long evnts;
@@ -105,6 +121,8 @@ struct pm_cntrl {
        u16 trace_mode;
        u16 freeze;
        u16 count_mode;
+        u16 spu_addr_trace;
+        u8  trace_buf_ovflw;
 };
 static struct {
@@ -122,7 +140,7 @@ static struct {
 #define GET_INPUT_CONTROL(x) ((x & 0x00000004) >> 2)
 static DEFINE_PER_CPU(unsigned long[NR_PHYS_CTRS], pmc_values);
+static unsigned long spu_pm_cnt[MAX_NUMNODES * NUM_SPUS_PER_NODE];
 static struct pmc_cntrl_data pmc_cntrl[NUM_THREADS][NR_PHYS_CTRS];
 /*
@@ -152,6 +170,7 @@ static u32 hdw_thread;
 static u32 virt_cntr_inter_mask;
 static struct timer_list timer_virt_cntr;
+static struct timer_list timer_spu_event_swap;
 /*
 * pm_signal needs to be global since it is initialized in
@@ -165,7 +184,7 @@ static int spu_rtas_token;   /* token for SPU cycle profiling */
 static u32 reset_value[NR_PHYS_CTRS];
 static int num_counters;
 static int oprofile_running;
-static DEFINE_SPINLOCK(virt_cntr_lock);
+static DEFINE_SPINLOCK(cntr_lock);
 static u32 ctr_enabled;
@@ -336,13 +355,13 @@ static void set_pm_event(u32 ctr, int event, u32 unit_mask)
        for (i = 0; i < NUM_DEBUG_BUS_WORDS; i++) {
                if (bus_word & (1 << i)) {
                        pm_regs.debug_bus_control |=
-                            (bus_type << (30 - (2 * i)));
+                                (bus_type << (30 - (2 * i)));
                        for (j = 0; j < NUM_INPUT_BUS_WORDS; j++) {
                                if (input_bus[j] == 0xff) {
                                        input_bus[j] = i;
                                        pm_regs.group_control |=
-                                            (i << (30 - (2 * j)));
+                                                (i << (30 - (2 * j)));
                                        break;
                                }
@@ -367,12 +386,16 @@ static void write_pm_cntrl(int cpu)
        if (pm_regs.pm_cntrl.stop_at_max == 1)
                val |= CBE_PM_STOP_AT_MAX;
-        if (pm_regs.pm_cntrl.trace_mode == 1)
+        if (pm_regs.pm_cntrl.trace_mode != 0)
                val |= CBE_PM_TRACE_MODE_SET(pm_regs.pm_cntrl.trace_mode);
+        if (pm_regs.pm_cntrl.trace_buf_ovflw == 1)
+                val |= CBE_PM_TRACE_BUF_OVFLW(pm_regs.pm_cntrl.trace_buf_ovflw);
        if (pm_regs.pm_cntrl.freeze == 1)
                val |= CBE_PM_FREEZE_ALL_CTRS;
+        val |= CBE_PM_SPU_ADDR_TRACE_SET(pm_regs.pm_cntrl.spu_addr_trace);
        /*
         * Routine set_count_mode must be called previously to set
         * the count mode based on the user selection of user and kernel.
@@ -441,7 +464,7 @@ static void cell_virtual_cntr(unsigned long data)
         * not both playing with the counters on the same node.
         */
-        spin_lock_irqsave(&virt_cntr_lock, flags);
+        spin_lock_irqsave(&cntr_lock, flags);
        prev_hdw_thread = hdw_thread;
@@ -480,7 +503,7 @@ static void cell_virtual_cntr(unsigned long data)
                cbe_disable_pm_interrupts(cpu);
                for (i = 0; i < num_counters; i++) {
                        per_cpu(pmc_values, cpu + prev_hdw_thread)[i]
-                            = cbe_read_ctr(cpu, i);
+                                = cbe_read_ctr(cpu, i);
                        if (per_cpu(pmc_values, cpu + next_hdw_thread)[i]
                            == 0xFFFFFFFF)
@@ -527,7 +550,7 @@ static void cell_virtual_cntr(unsigned long data)
                cbe_enable_pm(cpu);
        }
-        spin_unlock_irqrestore(&virt_cntr_lock, flags);
+        spin_unlock_irqrestore(&cntr_lock, flags);
        mod_timer(&timer_virt_cntr, jiffies + HZ / 10);
 }
@@ -541,38 +564,146 @@ static void start_virt_cntrs(void)
        add_timer(&timer_virt_cntr);
 }
-/* This function is called once for all cpus combined */
+static int cell_reg_setup_spu_cycles(struct op_counter_config *ctr,
-static int cell_reg_setup(struct op_counter_config *ctr,
                        struct op_system_config *sys, int num_ctrs)
 {
-        int i, j, cpu;
+        spu_cycle_reset = ctr[0].count;
-        spu_cycle_reset = 0;
-        if (ctr[0].event == SPU_CYCLES_EVENT_NUM) {
+        /*
-                spu_cycle_reset = ctr[0].count;
+         * Each node will need to make the rtas call to start
+         * and stop SPU profiling.  Get the token once and store it.
+         */
+        spu_rtas_token = rtas_token("ibm,cbe-spu-perftools");
+        if (unlikely(spu_rtas_token == RTAS_UNKNOWN_SERVICE)) {
+                printk(KERN_ERR
+                       "%s: rtas token ibm,cbe-spu-perftools unknown\n",
+                       __func__);
+                return -EIO;
+        }
+        return 0;
+}
+/* Unfortunately, the hardware will only support event profiling
+ * on one SPU per node at a time.  Therefore, we must time slice
+ * the profiling across all SPUs in the node.  Note, we do this
+ * in parallel for each node.  The following routine is called
+ * periodically based on kernel timer to switch which SPU is
+ * being monitored in a round robbin fashion.
+ */
+static void spu_evnt_swap(unsigned long data)
+{
+        int node;
+        int cur_phys_spu, nxt_phys_spu, cur_spu_evnt_phys_spu_indx;
+        unsigned long flags;
+        int cpu;
+        int ret;
+        u32 interrupt_mask;
+        /* enable interrupts on cntr 0 */
+        interrupt_mask = CBE_PM_CTR_OVERFLOW_INTR(0);
+        hdw_thread = 0;
+        /* Make sure spu event interrupt handler and spu event swap
+         * don't access the counters simultaneously.
+         */
+        spin_lock_irqsave(&cntr_lock, flags);
+        cur_spu_evnt_phys_spu_indx = spu_evnt_phys_spu_indx;
+        if (++(spu_evnt_phys_spu_indx) == NUM_SPUS_PER_NODE)
+                spu_evnt_phys_spu_indx = 0;
+        pm_signal[0].sub_unit = spu_evnt_phys_spu_indx;
+        pm_signal[1].sub_unit = spu_evnt_phys_spu_indx;
+        pm_signal[2].sub_unit = spu_evnt_phys_spu_indx;
+        /* switch the SPU being profiled on each node */
+        for_each_online_cpu(cpu) {
+                if (cbe_get_hw_thread_id(cpu))
+                        continue;
+                node = cbe_cpu_to_node(cpu);
+                cur_phys_spu = (node * NUM_SPUS_PER_NODE)
+                        + cur_spu_evnt_phys_spu_indx;
+                nxt_phys_spu = (node * NUM_SPUS_PER_NODE)
+                        + spu_evnt_phys_spu_indx;
                /*
-                 * Each node will need to make the rtas call to start
+                 * stop counters, save counter values, restore counts
-                 * and stop SPU profiling.  Get the token once and store it.
+                 * for previous physical SPU
                 */
-                spu_rtas_token = rtas_token("ibm,cbe-spu-perftools");
+                cbe_disable_pm(cpu);
+                cbe_disable_pm_interrupts(cpu);
-                if (unlikely(spu_rtas_token == RTAS_UNKNOWN_SERVICE)) {
+                spu_pm_cnt[cur_phys_spu]
-                        printk(KERN_ERR
+                        = cbe_read_ctr(cpu, 0);
-                               "%s: rtas token ibm,cbe-spu-perftools unknown\n",
-                               __func__);
+                /* restore previous count for the next spu to sample */
-                        return -EIO;
+                /* NOTE, hardware issue, counter will not start if the
-                }
+                 * counter value is at max (0xFFFFFFFF).
+                 */
+                if (spu_pm_cnt[nxt_phys_spu] >= 0xFFFFFFFF)
+                        cbe_write_ctr(cpu, 0, 0xFFFFFFF0);
+                 else
+                         cbe_write_ctr(cpu, 0, spu_pm_cnt[nxt_phys_spu]);
+                pm_rtas_reset_signals(cbe_cpu_to_node(cpu));
+                /* setup the debug bus measure the one event and
+                 * the two events to route the next SPU's PC on
+                 * the debug bus
+                 */
+                ret = pm_rtas_activate_signals(cbe_cpu_to_node(cpu), 3);
+                if (ret)
+                        printk(KERN_ERR "%s: pm_rtas_activate_signals failed, "
+                               "SPU event swap\n", __func__);
+                /* clear the trace buffer, don't want to take PC for
+                 * previous SPU*/
+                cbe_write_pm(cpu, trace_address, 0);
+                enable_ctr(cpu, 0, pm_regs.pm07_cntrl);
+                /* Enable interrupts on the CPU thread that is starting */
+                cbe_enable_pm_interrupts(cpu, hdw_thread,
+                                         interrupt_mask);
+                cbe_enable_pm(cpu);
        }
-        pm_rtas_token = rtas_token("ibm,cbe-perftools");
+        spin_unlock_irqrestore(&cntr_lock, flags);
+        /* swap approximately every 0.1 seconds */
+        mod_timer(&timer_spu_event_swap, jiffies + HZ / 25);
+}
+static void start_spu_event_swap(void)
+{
+        init_timer(&timer_spu_event_swap);
+        timer_spu_event_swap.function = spu_evnt_swap;
+        timer_spu_event_swap.data = 0UL;
+        timer_spu_event_swap.expires = jiffies + HZ / 25;
+        add_timer(&timer_spu_event_swap);
+}
+static int cell_reg_setup_spu_events(struct op_counter_config *ctr,
+                        struct op_system_config *sys, int num_ctrs)
+{
+        int i;
+        /* routine is called once for all nodes */
+        spu_evnt_phys_spu_indx = 0;
        /*
-         * For all events excetp PPU CYCLEs, each node will need to make
+         * For all events except PPU CYCLEs, each node will need to make
         * the rtas cbe-perftools call to setup and reset the debug bus.
         * Make the token lookup call once and store it in the global
         * variable pm_rtas_token.
         */
+        pm_rtas_token = rtas_token("ibm,cbe-perftools");
        if (unlikely(pm_rtas_token == RTAS_UNKNOWN_SERVICE)) {
                printk(KERN_ERR
                       "%s: rtas token ibm,cbe-perftools unknown\n",
@@ -580,6 +711,58 @@ static int cell_reg_setup(struct op_counter_config *ctr,
                return -EIO;
        }
+        /* setup the pm_control register settings,
+         * settings will be written per node by the
+         * cell_cpu_setup() function.
+         */
+        pm_regs.pm_cntrl.trace_buf_ovflw = 1;
+        /* Use the occurrence trace mode to have SPU PC saved
+         * to the trace buffer.  Occurrence data in trace buffer
+         * is not used.  Bit 2 must be set to store SPU addresses.
+         */
+        pm_regs.pm_cntrl.trace_mode = 2;
+        pm_regs.pm_cntrl.spu_addr_trace = 0x1;  /* using debug bus
+                                                   event 2 & 3 */
+        /* setup the debug bus event array with the SPU PC routing events.
+        *  Note, pm_signal[0] will be filled in by set_pm_event() call below.
+        */
+        pm_signal[1].signal_group = SPU_PROFILE_EVENT_ADDR / 100;
+        pm_signal[1].bus_word = GET_BUS_WORD(SPU_PROFILE_EVENT_ADDR_MASK_A);
+        pm_signal[1].bit = SPU_PROFILE_EVENT_ADDR % 100;
+        pm_signal[1].sub_unit = spu_evnt_phys_spu_indx;
+        pm_signal[2].signal_group = SPU_PROFILE_EVENT_ADDR / 100;
+        pm_signal[2].bus_word = GET_BUS_WORD(SPU_PROFILE_EVENT_ADDR_MASK_B);
+        pm_signal[2].bit = SPU_PROFILE_EVENT_ADDR % 100;
+        pm_signal[2].sub_unit = spu_evnt_phys_spu_indx;
+        /* Set the user selected spu event to profile on,
+         * note, only one SPU profiling event is supported
+         */
+        num_counters = 1;  /* Only support one SPU event at a time */
+        set_pm_event(0, ctr[0].event, ctr[0].unit_mask);
+        reset_value[0] = 0xFFFFFFFF - ctr[0].count;
+        /* global, used by cell_cpu_setup */
+        ctr_enabled |= 1;
+        /* Initialize the count for each SPU to the reset value */
+        for (i=0; i < MAX_NUMNODES * NUM_SPUS_PER_NODE; i++)
+                spu_pm_cnt[i] = reset_value[0];
+        return 0;
+}
+static int cell_reg_setup_ppu(struct op_counter_config *ctr,
+                        struct op_system_config *sys, int num_ctrs)
+{
+        /* routine is called once for all nodes */
+        int i, j, cpu;
        num_counters = num_ctrs;
        if (unlikely(num_ctrs > NR_PHYS_CTRS)) {
@@ -589,14 +772,6 @@ static int cell_reg_setup(struct op_counter_config *ctr,
                       __func__);
                return -EIO;
        }
-        pm_regs.group_control = 0;
-        pm_regs.debug_bus_control = 0;
-        /* setup the pm_control register */
-        memset(&pm_regs.pm_cntrl, 0, sizeof(struct pm_cntrl));
-        pm_regs.pm_cntrl.stop_at_max = 1;
-        pm_regs.pm_cntrl.trace_mode = 0;
-        pm_regs.pm_cntrl.freeze = 1;
        set_count_mode(sys->enable_kernel, sys->enable_user);
@@ -665,6 +840,63 @@ static int cell_reg_setup(struct op_counter_config *ctr,
 }
+/* This function is called once for all cpus combined */
+static int cell_reg_setup(struct op_counter_config *ctr,
+                        struct op_system_config *sys, int num_ctrs)
+{
+        int ret=0;
+        spu_cycle_reset = 0;
+        /* initialize the spu_arr_trace value, will be reset if
+         * doing spu event profiling.
+         */
+        pm_regs.group_control = 0;
+        pm_regs.debug_bus_control = 0;
+        pm_regs.pm_cntrl.stop_at_max = 1;
+        pm_regs.pm_cntrl.trace_mode = 0;
+        pm_regs.pm_cntrl.freeze = 1;
+        pm_regs.pm_cntrl.trace_buf_ovflw = 0;
+        pm_regs.pm_cntrl.spu_addr_trace = 0;
+        /*
+         * For all events except PPU CYCLEs, each node will need to make
+         * the rtas cbe-perftools call to setup and reset the debug bus.
+         * Make the token lookup call once and store it in the global
+         * variable pm_rtas_token.
+         */
+        pm_rtas_token = rtas_token("ibm,cbe-perftools");
+        if (unlikely(pm_rtas_token == RTAS_UNKNOWN_SERVICE)) {
+                printk(KERN_ERR
+                       "%s: rtas token ibm,cbe-perftools unknown\n",
+                       __func__);
+                return -EIO;
+        }
+        if (ctr[0].event == SPU_CYCLES_EVENT_NUM) {
+                profiling_mode = SPU_PROFILING_CYCLES;
+                ret = cell_reg_setup_spu_cycles(ctr, sys, num_ctrs);
+        } else if ((ctr[0].event >= SPU_EVENT_NUM_START) &&
+                   (ctr[0].event <= SPU_EVENT_NUM_STOP)) {
+                profiling_mode = SPU_PROFILING_EVENTS;
+                spu_cycle_reset = ctr[0].count;
+                /* for SPU event profiling, need to setup the
+                 * pm_signal array with the events to route the
+                 * SPU PC before making the FW call.  Note, only
+                 * one SPU event for profiling can be specified
+                 * at a time.
+                 */
+                cell_reg_setup_spu_events(ctr, sys, num_ctrs);
+        } else {
+                profiling_mode = PPU_PROFILING;
+                ret = cell_reg_setup_ppu(ctr, sys, num_ctrs);
+        }
+        return ret;
+}
 /* This function is called once for each cpu */
 static int cell_cpu_setup(struct op_counter_config *cntr)
@@ -672,8 +904,13 @@ static int cell_cpu_setup(struct op_counter_config *cntr)
        u32 cpu = smp_processor_id();
        u32 num_enabled = 0;
        int i;
+        int ret;
-        if (spu_cycle_reset)
+        /* Cycle based SPU profiling does not use the performance
+         * counters.  The trace array is configured to collect
+         * the data.
+         */
+        if (profiling_mode == SPU_PROFILING_CYCLES)
                return 0;
        /* There is one performance monitor per processor chip (i.e. node),
@@ -686,7 +923,6 @@ static int cell_cpu_setup(struct op_counter_config *cntr)
        cbe_disable_pm(cpu);
        cbe_disable_pm_interrupts(cpu);
-        cbe_write_pm(cpu, pm_interval, 0);
        cbe_write_pm(cpu, pm_start_stop, 0);
        cbe_write_pm(cpu, group_control, pm_regs.group_control);
        cbe_write_pm(cpu, debug_bus_control, pm_regs.debug_bus_control);
@@ -703,7 +939,20 @@ static int cell_cpu_setup(struct op_counter_config *cntr)
         * The pm_rtas_activate_signals will return -EIO if the FW
         * call failed.
         */
-        return pm_rtas_activate_signals(cbe_cpu_to_node(cpu), num_enabled);
+        if (profiling_mode == SPU_PROFILING_EVENTS) {
+                /* For SPU event profiling also need to setup the
+                 * pm interval timer
+                 */
+                ret = pm_rtas_activate_signals(cbe_cpu_to_node(cpu),
+                                               num_enabled+2);
+                /* store PC from debug bus to Trace buffer as often
+                 * as possible (every 10 cycles)
+                 */
+                cbe_write_pm(cpu, pm_interval, NUM_INTERVAL_CYC);
+                return ret;
+        } else
+                return pm_rtas_activate_signals(cbe_cpu_to_node(cpu),
+                                                num_enabled);
 }
 #define ENTRIES  303
@@ -885,7 +1134,122 @@ static struct notifier_block cpu_freq_notifier_block = {
 };
 #endif
-static int cell_global_start_spu(struct op_counter_config *ctr)
+/*
+ * Note the generic OProfile stop calls do not support returning
+ * an error on stop.  Hence, will not return an error if the FW
+ * calls fail on stop.  Failure to reset the debug bus is not an issue.
+ * Failure to disable the SPU profiling is not an issue.  The FW calls
+ * to enable the performance counters and debug bus will work even if
+ * the hardware was not cleanly reset.
+ */
+static void cell_global_stop_spu_cycles(void)
+{
+        int subfunc, rtn_value;
+        unsigned int lfsr_value;
+        int cpu;
+        oprofile_running = 0;
+        smp_wmb();
+#ifdef CONFIG_CPU_FREQ
+        cpufreq_unregister_notifier(&cpu_freq_notifier_block,
+                                    CPUFREQ_TRANSITION_NOTIFIER);
+#endif
+        for_each_online_cpu(cpu) {
+                if (cbe_get_hw_thread_id(cpu))
+                        continue;
+                subfunc = 3;    /*
+                                 * 2 - activate SPU tracing,
+                                 * 3 - deactivate
+                                 */
+                lfsr_value = 0x8f100000;
+                rtn_value = rtas_call(spu_rtas_token, 3, 1, NULL,
+                                      subfunc, cbe_cpu_to_node(cpu),
+                                      lfsr_value);
+                if (unlikely(rtn_value != 0)) {
+                        printk(KERN_ERR
+                               "%s: rtas call ibm,cbe-spu-perftools " \
+                               "failed, return = %d\n",
+                               __func__, rtn_value);
+                }
+                /* Deactivate the signals */
+                pm_rtas_reset_signals(cbe_cpu_to_node(cpu));
+        }
+        stop_spu_profiling_cycles();
+}
+static void cell_global_stop_spu_events(void)
+{
+        int cpu;
+        oprofile_running = 0;
+        stop_spu_profiling_events();
+        smp_wmb();
+        for_each_online_cpu(cpu) {
+                if (cbe_get_hw_thread_id(cpu))
+                        continue;
+                cbe_sync_irq(cbe_cpu_to_node(cpu));
+                /* Stop the counters */
+                cbe_disable_pm(cpu);
+                cbe_write_pm07_control(cpu, 0, 0);
+                /* Deactivate the signals */
+                pm_rtas_reset_signals(cbe_cpu_to_node(cpu));
+                /* Deactivate interrupts */
+                cbe_disable_pm_interrupts(cpu);
+        }
+        del_timer_sync(&timer_spu_event_swap);
+}
+static void cell_global_stop_ppu(void)
+{
+        int cpu;
+        /*
+         * This routine will be called once for the system.
+         * There is one performance monitor per node, so we
+         * only need to perform this function once per node.
+         */
+        del_timer_sync(&timer_virt_cntr);
+        oprofile_running = 0;
+        smp_wmb();
+        for_each_online_cpu(cpu) {
+                if (cbe_get_hw_thread_id(cpu))
+                        continue;
+                cbe_sync_irq(cbe_cpu_to_node(cpu));
+                /* Stop the counters */
+                cbe_disable_pm(cpu);
+                /* Deactivate the signals */
+                pm_rtas_reset_signals(cbe_cpu_to_node(cpu));
+                /* Deactivate interrupts */
+                cbe_disable_pm_interrupts(cpu);
+        }
+}
+static void cell_global_stop(void)
+{
+        if (profiling_mode == PPU_PROFILING)
+                cell_global_stop_ppu();
+        else if (profiling_mode == SPU_PROFILING_EVENTS)
+                cell_global_stop_spu_events();
+        else
+                cell_global_stop_spu_cycles();
+}
+static int cell_global_start_spu_cycles(struct op_counter_config *ctr)
 {
        int subfunc;
        unsigned int lfsr_value;
@@ -951,18 +1315,18 @@ static int cell_global_start_spu(struct op_counter_config *ctr)
                /* start profiling */
                ret = rtas_call(spu_rtas_token, 3, 1, NULL, subfunc,
-                  cbe_cpu_to_node(cpu), lfsr_value);
+                                cbe_cpu_to_node(cpu), lfsr_value);
                if (unlikely(ret != 0)) {
                        printk(KERN_ERR
-                               "%s: rtas call ibm,cbe-spu-perftools failed, return = %d\n",
+                               "%s: rtas call ibm,cbe-spu-perftools failed, " \
-                               __func__, ret);
+                               "return = %d\n", __func__, ret);
                        rtas_error = -EIO;
                        goto out;
                }
        }
-        rtas_error = start_spu_profiling(spu_cycle_reset);
+        rtas_error = start_spu_profiling_cycles(spu_cycle_reset);
        if (rtas_error)
                goto out_stop;
@@ -970,11 +1334,74 @@ static int cell_global_start_spu(struct op_counter_config *ctr)
        return 0;
 out_stop:
-        cell_global_stop_spu();         /* clean up the PMU/debug bus */
+        cell_global_stop_spu_cycles();  /* clean up the PMU/debug bus */
 out:
        return rtas_error;
 }
+static int cell_global_start_spu_events(struct op_counter_config *ctr)
+{
+        int cpu;
+        u32 interrupt_mask = 0;
+        int rtn = 0;
+        hdw_thread = 0;
+        /* spu event profiling, uses the performance counters to generate
+         * an interrupt.  The hardware is setup to store the SPU program
+         * counter into the trace array.  The occurrence mode is used to
+         * enable storing data to the trace buffer.  The bits are set
+         * to send/store the SPU address in the trace buffer.  The debug
+         * bus must be setup to route the SPU program counter onto the
+         * debug bus.  The occurrence data in the trace buffer is not used.
+         */
+        /* This routine gets called once for the system.
+         * There is one performance monitor per node, so we
+         * only need to perform this function once per node.
+         */
+        for_each_online_cpu(cpu) {
+                if (cbe_get_hw_thread_id(cpu))
+                        continue;
+                /*
+                 * Setup SPU event-based profiling.
+                 * Set perf_mon_control bit 0 to a zero before
+                 * enabling spu collection hardware.
+                 *
+                 * Only support one SPU event on one SPU per node.
+                 */
+                if (ctr_enabled & 1) {
+                        cbe_write_ctr(cpu, 0, reset_value[0]);
+                        enable_ctr(cpu, 0, pm_regs.pm07_cntrl);
+                        interrupt_mask |=
+                                CBE_PM_CTR_OVERFLOW_INTR(0);
+                } else {
+                        /* Disable counter */
+                        cbe_write_pm07_control(cpu, 0, 0);
+                }
+                cbe_get_and_clear_pm_interrupts(cpu);
+                cbe_enable_pm_interrupts(cpu, hdw_thread, interrupt_mask);
+                cbe_enable_pm(cpu);
+                /* clear the trace buffer */
+                cbe_write_pm(cpu, trace_address, 0);
+        }
+        /* Start the timer to time slice collecting the event profile
+         * on each of the SPUs.  Note, can collect profile on one SPU
+         * per node at a time.
+         */
+        start_spu_event_swap();
+        start_spu_profiling_events();
+        oprofile_running = 1;
+        smp_wmb();
+        return rtn;
+}
 static int cell_global_start_ppu(struct op_counter_config *ctr)
 {
        u32 cpu, i;
@@ -994,8 +1421,7 @@ static int cell_global_start_ppu(struct op_counter_config *ctr)
                        if (ctr_enabled & (1 << i)) {
                                cbe_write_ctr(cpu, i, reset_value[i]);
                                enable_ctr(cpu, i, pm_regs.pm07_cntrl);
-                                interrupt_mask |=
+                                interrupt_mask |= CBE_PM_CTR_OVERFLOW_INTR(i);
-                                    CBE_PM_CTR_OVERFLOW_INTR(i);
                        } else {
                                /* Disable counter */
                                cbe_write_pm07_control(cpu, i, 0);
@@ -1024,99 +1450,162 @@ static int cell_global_start_ppu(struct op_counter_config *ctr)
 static int cell_global_start(struct op_counter_config *ctr)
 {
-        if (spu_cycle_reset)
+        if (profiling_mode == SPU_PROFILING_CYCLES)
-                return cell_global_start_spu(ctr);
+                return cell_global_start_spu_cycles(ctr);
+        else if (profiling_mode == SPU_PROFILING_EVENTS)
+                return cell_global_start_spu_events(ctr);
        else
                return cell_global_start_ppu(ctr);
 }
-/*
- * Note the generic OProfile stop calls do not support returning
+/* The SPU interrupt handler
- * an error on stop.  Hence, will not return an error if the FW
+ *
- * calls fail on stop.  Failure to reset the debug bus is not an issue.
+ * SPU event profiling works as follows:
- * Failure to disable the SPU profiling is not an issue.  The FW calls
+ * The pm_signal[0] holds the one SPU event to be measured.  It is routed on
- * to enable the performance counters and debug bus will work even if
+ * the debug bus using word 0 or 1.  The value of pm_signal[1] and
- * the hardware was not cleanly reset.
+ * pm_signal[2] contain the necessary events to route the SPU program
+ * counter for the selected SPU onto the debug bus using words 2 and 3.
+ * The pm_interval register is setup to write the SPU PC value into the
+ * trace buffer at the maximum rate possible.  The trace buffer is configured
+ * to store the PCs, wrapping when it is full.  The performance counter is
+ * intialized to the max hardware count minus the number of events, N, between
+ * samples.  Once the N events have occured, a HW counter overflow occurs
+ * causing the generation of a HW counter interrupt which also stops the
+ * writing of the SPU PC values to the trace buffer.  Hence the last PC
+ * written to the trace buffer is the SPU PC that we want.  Unfortunately,
+ * we have to read from the beginning of the trace buffer to get to the
+ * last value written.  We just hope the PPU has nothing better to do then
+ * service this interrupt. The PC for the specific SPU being profiled is
+ * extracted from the trace buffer processed and stored.  The trace buffer
+ * is cleared, interrupts are cleared, the counter is reset to max - N.
+ * A kernel timer is used to periodically call the routine spu_evnt_swap()
+ * to switch to the next physical SPU in the node to profile in round robbin
+ * order.  This way data is collected for all SPUs on the node. It does mean
+ * that we need to use a relatively small value of N to ensure enough samples
+ * on each SPU are collected each SPU is being profiled 1/8 of the time.
+ * It may also be necessary to use a longer sample collection period.
 */
-static void cell_global_stop_spu(void)
+static void cell_handle_interrupt_spu(struct pt_regs *regs,
+                                      struct op_counter_config *ctr)
 {
-        int subfunc, rtn_value;
+        u32 cpu, cpu_tmp;
-        unsigned int lfsr_value;
+        u64 trace_entry;
-        int cpu;
+        u32 interrupt_mask;
+        u64 trace_buffer[2];
+        u64 last_trace_buffer;
+        u32 sample;
+        u32 trace_addr;
+        unsigned long sample_array_lock_flags;
+        int spu_num;
+        unsigned long flags;
-        oprofile_running = 0;
+        /* Make sure spu event interrupt handler and spu event swap
+         * don't access the counters simultaneously.
+         */
+        cpu = smp_processor_id();
+        spin_lock_irqsave(&cntr_lock, flags);
-#ifdef CONFIG_CPU_FREQ
+        cpu_tmp = cpu;
-        cpufreq_unregister_notifier(&cpu_freq_notifier_block,
+        cbe_disable_pm(cpu);
-                                    CPUFREQ_TRANSITION_NOTIFIER);
-#endif
-        for_each_online_cpu(cpu) {
+        interrupt_mask = cbe_get_and_clear_pm_interrupts(cpu);
-                if (cbe_get_hw_thread_id(cpu))
-                        continue;
-                subfunc = 3;    /*
+        sample = 0xABCDEF;
-                                 * 2 - activate SPU tracing,
+        trace_entry = 0xfedcba;
-                                 * 3 - deactivate
+        last_trace_buffer = 0xdeadbeaf;
-                                 */
-                lfsr_value = 0x8f100000;
-                rtn_value = rtas_call(spu_rtas_token, 3, 1, NULL,
+        if ((oprofile_running == 1) && (interrupt_mask != 0)) {
-                                      subfunc, cbe_cpu_to_node(cpu),
+                /* disable writes to trace buff */
-                                      lfsr_value);
+                cbe_write_pm(cpu, pm_interval, 0);
-                if (unlikely(rtn_value != 0)) {
+                /* only have one perf cntr being used, cntr 0 */
-                        printk(KERN_ERR
+                if ((interrupt_mask & CBE_PM_CTR_OVERFLOW_INTR(0))
-                               "%s: rtas call ibm,cbe-spu-perftools failed, return = %d\n",
+                    && ctr[0].enabled)
-                               __func__, rtn_value);
+                        /* The SPU PC values will be read
+                         * from the trace buffer, reset counter
+                         */
+                        cbe_write_ctr(cpu, 0, reset_value[0]);
+                trace_addr = cbe_read_pm(cpu, trace_address);
+                while (!(trace_addr & CBE_PM_TRACE_BUF_EMPTY)) {
+                        /* There is data in the trace buffer to process
+                         * Read the buffer until you get to the last
+                         * entry.  This is the value we want.
+                         */
+                        cbe_read_trace_buffer(cpu, trace_buffer);
+                        trace_addr = cbe_read_pm(cpu, trace_address);
                }
-                /* Deactivate the signals */
+                /* SPU Address 16 bit count format for 128 bit
-                pm_rtas_reset_signals(cbe_cpu_to_node(cpu));
+                 * HW trace buffer is used for the SPU PC storage
-        }
+                 *    HDR bits          0:15
+                 *    SPU Addr 0 bits   16:31
+                 *    SPU Addr 1 bits   32:47
+                 *    unused bits       48:127
+                 *
+                 * HDR: bit4 = 1 SPU Address 0 valid
+                 * HDR: bit5 = 1 SPU Address 1 valid
+                 *  - unfortunately, the valid bits don't seem to work
+                 *
+                 * Note trace_buffer[0] holds bits 0:63 of the HW
+                 * trace buffer, trace_buffer[1] holds bits 64:127
+                 */
-        stop_spu_profiling();
+                trace_entry = trace_buffer[0]
-}
+                        & 0x00000000FFFF0000;
-static void cell_global_stop_ppu(void)
+                /* only top 16 of the 18 bit SPU PC address
-{
+                 * is stored in trace buffer, hence shift right
-        int cpu;
+                 * by 16 -2 bits */
+                sample = trace_entry >> 14;
+                last_trace_buffer = trace_buffer[0];
-        /*
+                spu_num = spu_evnt_phys_spu_indx
-         * This routine will be called once for the system.
+                        + (cbe_cpu_to_node(cpu) * NUM_SPUS_PER_NODE);
-         * There is one performance monitor per node, so we
-         * only need to perform this function once per node.
-         */
-        del_timer_sync(&timer_virt_cntr);
-        oprofile_running = 0;
-        smp_wmb();
-        for_each_online_cpu(cpu) {
+                /* make sure only one process at a time is calling
-                if (cbe_get_hw_thread_id(cpu))
+                 * spu_sync_buffer()
-                        continue;
+                 */
+                spin_lock_irqsave(&oprof_spu_smpl_arry_lck,
+                                  sample_array_lock_flags);
+                spu_sync_buffer(spu_num, &sample, 1);
+                spin_unlock_irqrestore(&oprof_spu_smpl_arry_lck,
+                                       sample_array_lock_flags);
-                cbe_sync_irq(cbe_cpu_to_node(cpu));
+                smp_wmb();    /* insure spu event buffer updates are written
-                /* Stop the counters */
+                               * don't want events intermingled... */
-                cbe_disable_pm(cpu);
-                /* Deactivate the signals */
+                /* The counters were frozen by the interrupt.
-                pm_rtas_reset_signals(cbe_cpu_to_node(cpu));
+                 * Reenable the interrupt and restart the counters.
+                 */
+                cbe_write_pm(cpu, pm_interval, NUM_INTERVAL_CYC);
+                cbe_enable_pm_interrupts(cpu, hdw_thread,
+                                         virt_cntr_inter_mask);
-                /* Deactivate interrupts */
+                /* clear the trace buffer, re-enable writes to trace buff */
-                cbe_disable_pm_interrupts(cpu);
+                cbe_write_pm(cpu, trace_address, 0);
-        }
+                cbe_write_pm(cpu, pm_interval, NUM_INTERVAL_CYC);
-}
-static void cell_global_stop(void)
+                /* The writes to the various performance counters only writes
-{
+                 * to a latch.  The new values (interrupt setting bits, reset
-        if (spu_cycle_reset)
+                 * counter value etc.) are not copied to the actual registers
-                cell_global_stop_spu();
+                 * until the performance monitor is enabled.  In order to get
-        else
+                 * this to work as desired, the permormance monitor needs to
-                cell_global_stop_ppu();
+                 * be disabled while writing to the latches.  This is a
+                 * HW design issue.
+                 */
+                write_pm_cntrl(cpu);
+                cbe_enable_pm(cpu);
+        }
+        spin_unlock_irqrestore(&cntr_lock, flags);
 }
-static void cell_handle_interrupt(struct pt_regs *regs,
+static void cell_handle_interrupt_ppu(struct pt_regs *regs,
-                                struct op_counter_config *ctr)
+                                      struct op_counter_config *ctr)
 {
        u32 cpu;
        u64 pc;
@@ -1132,7 +1621,7 @@ static void cell_handle_interrupt(struct pt_regs *regs,
         * routine are not running at the same time. See the
         * cell_virtual_cntr() routine for additional comments.
         */
-        spin_lock_irqsave(&virt_cntr_lock, flags);
+        spin_lock_irqsave(&cntr_lock, flags);
        /*
         * Need to disable and reenable the performance counters
@@ -1185,7 +1674,16 @@ static void cell_handle_interrupt(struct pt_regs *regs,
                 */
                cbe_enable_pm(cpu);
        }
-        spin_unlock_irqrestore(&virt_cntr_lock, flags);
+        spin_unlock_irqrestore(&cntr_lock, flags);
+}
+static void cell_handle_interrupt(struct pt_regs *regs,
+                                  struct op_counter_config *ctr)
+{
+        if (profiling_mode == PPU_PROFILING)
+                cell_handle_interrupt_ppu(regs, ctr);
+        else
+                cell_handle_interrupt_spu(regs, ctr);
 }
 /*
@@ -1195,7 +1693,8 @@ static void cell_handle_interrupt(struct pt_regs *regs,
 */
 static int cell_sync_start(void)
 {
-        if (spu_cycle_reset)
+        if ((profiling_mode == SPU_PROFILING_CYCLES) ||
+            (profiling_mode == SPU_PROFILING_EVENTS))
                return spu_sync_start();
        else
                return DO_GENERIC_SYNC;
@@ -1203,7 +1702,8 @@ static int cell_sync_start(void)
 static int cell_sync_stop(void)
 {
-        if (spu_cycle_reset)
+        if ((profiling_mode == SPU_PROFILING_CYCLES) ||
+            (profiling_mode == SPU_PROFILING_EVENTS))
                return spu_sync_stop();
        else
                return 1;
diff --git a/arch/powerpc/platforms/52xx/mpc52xx_common.c b/arch/powerpc/platforms/52xx/mpc52xx_common.c
index ae7c34f37e1c..98367a0255f3 100644
--- a/arch/powerpc/platforms/52xx/mpc52xx_common.c
+++ b/arch/powerpc/platforms/52xx/mpc52xx_common.c
@@ -42,7 +42,7 @@ static struct of_device_id mpc52xx_bus_ids[] __initdata = {
 * from interrupt context while node mapping (which calls ioremap())
 * cannot be used at such point.
 */
-static spinlock_t mpc52xx_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(mpc52xx_lock);
 static struct mpc52xx_gpt __iomem *mpc52xx_wdt;
 static struct mpc52xx_cdm __iomem *mpc52xx_cdm;
diff --git a/arch/powerpc/platforms/83xx/mpc831x_rdb.c b/arch/powerpc/platforms/83xx/mpc831x_rdb.c
index a428f8d1ac80..5177bdd2c62a 100644
--- a/arch/powerpc/platforms/83xx/mpc831x_rdb.c
+++ b/arch/powerpc/platforms/83xx/mpc831x_rdb.c
@@ -42,7 +42,7 @@ static void __init mpc831x_rdb_setup_arch(void)
        mpc831x_usb_cfg();
 }
-void __init mpc831x_rdb_init_IRQ(void)
+static void __init mpc831x_rdb_init_IRQ(void)
 {
        struct device_node *np;
diff --git a/arch/powerpc/platforms/83xx/mpc832x_mds.c b/arch/powerpc/platforms/83xx/mpc832x_mds.c
index ec43477caa63..ec0b401bc9cf 100644
--- a/arch/powerpc/platforms/83xx/mpc832x_mds.c
+++ b/arch/powerpc/platforms/83xx/mpc832x_mds.c
@@ -49,8 +49,6 @@
 #define DBG(fmt...)
 #endif
-static u8 *bcsr_regs = NULL;
 /* ************************************************************************
 *
 * Setup the architecture
@@ -59,13 +57,14 @@ static u8 *bcsr_regs = NULL;
 static void __init mpc832x_sys_setup_arch(void)
 {
        struct device_node *np;
+        u8 __iomem *bcsr_regs = NULL;
        if (ppc_md.progress)
                ppc_md.progress("mpc832x_sys_setup_arch()", 0);
        /* Map BCSR area */
        np = of_find_node_by_name(NULL, "bcsr");
-        if (np != 0) {
+        if (np) {
                struct resource res;
                of_address_to_resource(np, 0, &res);
@@ -93,9 +92,9 @@ static void __init mpc832x_sys_setup_arch(void)
                        != NULL){
                /* Reset the Ethernet PHYs */
 #define BCSR8_FETH_RST 0x50
-                bcsr_regs[8] &= ~BCSR8_FETH_RST;
+                clrbits8(&bcsr_regs[8], BCSR8_FETH_RST);
                udelay(1000);
-                bcsr_regs[8] |= BCSR8_FETH_RST;
+                setbits8(&bcsr_regs[8], BCSR8_FETH_RST);
                iounmap(bcsr_regs);
                of_node_put(np);
        }
diff --git a/arch/powerpc/platforms/83xx/mpc832x_rdb.c b/arch/powerpc/platforms/83xx/mpc832x_rdb.c
index 0300268ce5b8..2a1295f19832 100644
--- a/arch/powerpc/platforms/83xx/mpc832x_rdb.c
+++ b/arch/powerpc/platforms/83xx/mpc832x_rdb.c
@@ -38,6 +38,7 @@
 #define DBG(fmt...)
 #endif
+#ifdef CONFIG_QUICC_ENGINE
 static void mpc83xx_spi_activate_cs(u8 cs, u8 polarity)
 {
        pr_debug("%s %d %d\n", __func__, cs, polarity);
@@ -77,8 +78,8 @@ static int __init mpc832x_spi_init(void)
                            mpc83xx_spi_activate_cs,
                            mpc83xx_spi_deactivate_cs);
 }
 machine_device_initcall(mpc832x_rdb, mpc832x_spi_init);
+#endif /* CONFIG_QUICC_ENGINE */
 /* ************************************************************************
 *
@@ -130,7 +131,7 @@ static int __init mpc832x_declare_of_platform_devices(void)
 }
 machine_device_initcall(mpc832x_rdb, mpc832x_declare_of_platform_devices);
-void __init mpc832x_rdb_init_IRQ(void)
+static void __init mpc832x_rdb_init_IRQ(void)
 {
        struct device_node *np;
diff --git a/arch/powerpc/platforms/83xx/mpc836x_mds.c b/arch/powerpc/platforms/83xx/mpc836x_mds.c
index 9d46e5bdd101..09e9d6fb7411 100644
--- a/arch/powerpc/platforms/83xx/mpc836x_mds.c
+++ b/arch/powerpc/platforms/83xx/mpc836x_mds.c
@@ -18,6 +18,7 @@
 #include <linux/stddef.h>
 #include <linux/kernel.h>
+#include <linux/compiler.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/reboot.h>
@@ -43,6 +44,7 @@
 #include <asm/udbg.h>
 #include <sysdev/fsl_soc.h>
 #include <sysdev/fsl_pci.h>
+#include <sysdev/simple_gpio.h>
 #include <asm/qe.h>
 #include <asm/qe_ic.h>
@@ -55,8 +57,6 @@
 #define DBG(fmt...)
 #endif
-static u8 *bcsr_regs = NULL;
 /* ************************************************************************
 *
 * Setup the architecture
@@ -65,13 +65,14 @@ static u8 *bcsr_regs = NULL;
 static void __init mpc836x_mds_setup_arch(void)
 {
        struct device_node *np;
+        u8 __iomem *bcsr_regs = NULL;
        if (ppc_md.progress)
                ppc_md.progress("mpc836x_mds_setup_arch()", 0);
        /* Map BCSR area */
        np = of_find_node_by_name(NULL, "bcsr");
-        if (np != 0) {
+        if (np) {
                struct resource res;
                of_address_to_resource(np, 0, &res);
@@ -93,6 +94,16 @@ static void __init mpc836x_mds_setup_arch(void)
                for (np = NULL; (np = of_find_node_by_name(np, "ucc")) != NULL;)
                        par_io_of_config(np);
+#ifdef CONFIG_QE_USB
+                /* Must fixup Par IO before QE GPIO chips are registered. */
+                par_io_config_pin(1,  2, 1, 0, 3, 0); /* USBOE  */
+                par_io_config_pin(1,  3, 1, 0, 3, 0); /* USBTP  */
+                par_io_config_pin(1,  8, 1, 0, 1, 0); /* USBTN  */
+                par_io_config_pin(1, 10, 2, 0, 3, 0); /* USBRXD */
+                par_io_config_pin(1,  9, 2, 1, 3, 0); /* USBRP  */
+                par_io_config_pin(1, 11, 2, 1, 3, 0); /* USBRN  */
+                par_io_config_pin(2, 20, 2, 0, 1, 0); /* CLK21  */
+#endif /* CONFIG_QE_USB */
        }
        if ((np = of_find_compatible_node(NULL, "network", "ucc_geth"))
@@ -151,6 +162,70 @@ static int __init mpc836x_declare_of_platform_devices(void)
 }
 machine_device_initcall(mpc836x_mds, mpc836x_declare_of_platform_devices);
+#ifdef CONFIG_QE_USB
+static int __init mpc836x_usb_cfg(void)
+{
+        u8 __iomem *bcsr;
+        struct device_node *np;
+        const char *mode;
+        int ret = 0;
+        np = of_find_compatible_node(NULL, NULL, "fsl,mpc8360mds-bcsr");
+        if (!np)
+                return -ENODEV;
+        bcsr = of_iomap(np, 0);
+        of_node_put(np);
+        if (!bcsr)
+                return -ENOMEM;
+        np = of_find_compatible_node(NULL, NULL, "fsl,mpc8323-qe-usb");
+        if (!np) {
+                ret = -ENODEV;
+                goto err;
+        }
+#define BCSR8_TSEC1M_MASK       (0x3 << 6)
+#define BCSR8_TSEC1M_RGMII      (0x0 << 6)
+#define BCSR8_TSEC2M_MASK       (0x3 << 4)
+#define BCSR8_TSEC2M_RGMII      (0x0 << 4)
+        /*
+         * Default is GMII (2), but we should set it to RGMII (0) if we use
+         * USB (Eth PHY is in RGMII mode anyway).
+         */
+        clrsetbits_8(&bcsr[8], BCSR8_TSEC1M_MASK | BCSR8_TSEC2M_MASK,
+                               BCSR8_TSEC1M_RGMII | BCSR8_TSEC2M_RGMII);
+#define BCSR13_USBMASK  0x0f
+#define BCSR13_nUSBEN   0x08 /* 1 - Disable, 0 - Enable                 */
+#define BCSR13_USBSPEED 0x04 /* 1 - Full, 0 - Low                       */
+#define BCSR13_USBMODE  0x02 /* 1 - Host, 0 - Function                  */
+#define BCSR13_nUSBVCC  0x01 /* 1 - gets VBUS, 0 - supplies VBUS        */
+        clrsetbits_8(&bcsr[13], BCSR13_USBMASK, BCSR13_USBSPEED);
+        mode = of_get_property(np, "mode", NULL);
+        if (mode && !strcmp(mode, "peripheral")) {
+                setbits8(&bcsr[13], BCSR13_nUSBVCC);
+                qe_usb_clock_set(QE_CLK21, 48000000);
+        } else {
+                setbits8(&bcsr[13], BCSR13_USBMODE);
+                /*
+                 * The BCSR GPIOs are used to control power and
+                 * speed of the USB transceiver. This is needed for
+                 * the USB Host only.
+                 */
+                simple_gpiochip_init("fsl,mpc8360mds-bcsr-gpio");
+        }
+        of_node_put(np);
+err:
+        iounmap(bcsr);
+        return ret;
+}
+machine_arch_initcall(mpc836x_mds, mpc836x_usb_cfg);
+#endif /* CONFIG_QE_USB */
 static void __init mpc836x_mds_init_IRQ(void)
 {
        struct device_node *np;
diff --git a/arch/powerpc/platforms/83xx/mpc836x_rdk.c b/arch/powerpc/platforms/83xx/mpc836x_rdk.c
index a5273bb28e1b..b0090aac9642 100644
--- a/arch/powerpc/platforms/83xx/mpc836x_rdk.c
+++ b/arch/powerpc/platforms/83xx/mpc836x_rdk.c
@@ -51,8 +51,9 @@ static void __init mpc836x_rdk_setup_arch(void)
        for_each_compatible_node(np, "pci", "fsl,mpc8349-pci")
                mpc83xx_add_bridge(np);
 #endif
+#ifdef CONFIG_QUICC_ENGINE
        qe_reset();
+#endif
 }
 static void __init mpc836x_rdk_init_IRQ(void)
@@ -71,13 +72,14 @@ static void __init mpc836x_rdk_init_IRQ(void)
         */
        ipic_set_default_priority();
        of_node_put(np);
+#ifdef CONFIG_QUICC_ENGINE
        np = of_find_compatible_node(NULL, NULL, "fsl,qe-ic");
        if (!np)
                return;
        qe_ic_init(np, 0, qe_ic_cascade_low_ipic, qe_ic_cascade_high_ipic);
        of_node_put(np);
+#endif
 }
 /*
diff --git a/arch/powerpc/platforms/83xx/mpc837x_mds.c b/arch/powerpc/platforms/83xx/mpc837x_mds.c
index 8bb13c807142..530ef990ca7c 100644
--- a/arch/powerpc/platforms/83xx/mpc837x_mds.c
+++ b/arch/powerpc/platforms/83xx/mpc837x_mds.c
@@ -26,7 +26,6 @@
 #define BCSR12_USB_SER_MASK     0x8a
 #define BCSR12_USB_SER_PIN      0x80
 #define BCSR12_USB_SER_DEVICE   0x02
-extern int mpc837x_usb_cfg(void);
 static int mpc837xmds_usb_cfg(void)
 {
diff --git a/arch/powerpc/platforms/83xx/mpc837x_rdb.c b/arch/powerpc/platforms/83xx/mpc837x_rdb.c
index da030afa2e2c..1d096545322b 100644
--- a/arch/powerpc/platforms/83xx/mpc837x_rdb.c
+++ b/arch/powerpc/platforms/83xx/mpc837x_rdb.c
@@ -21,8 +21,6 @@
 #include "mpc83xx.h"
-extern int mpc837x_usb_cfg(void);
 /* ************************************************************************
 *
 * Setup the architecture
diff --git a/arch/powerpc/platforms/83xx/mpc83xx.h b/arch/powerpc/platforms/83xx/mpc83xx.h
index 2a7cbabb410a..83cfe51526ec 100644
--- a/arch/powerpc/platforms/83xx/mpc83xx.h
+++ b/arch/powerpc/platforms/83xx/mpc83xx.h
@@ -61,6 +61,7 @@
 extern void mpc83xx_restart(char *cmd);
 extern long mpc83xx_time_init(void);
+extern int mpc837x_usb_cfg(void);
 extern int mpc834x_usb_cfg(void);
 extern int mpc831x_usb_cfg(void);
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_ds.c b/arch/powerpc/platforms/85xx/mpc85xx_ds.c
index a8301c8ad537..7326d904202c 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_ds.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_ds.c
@@ -148,6 +148,9 @@ static int mpc85xx_exclude_device(struct pci_controller *hose,
 /*
 * Setup the architecture
 */
+#ifdef CONFIG_SMP
+extern void __init mpc85xx_smp_init(void);
+#endif
 static void __init mpc85xx_ds_setup_arch(void)
 {
 #ifdef CONFIG_PCI
@@ -173,6 +176,10 @@ static void __init mpc85xx_ds_setup_arch(void)
        ppc_md.pci_exclude_device = mpc85xx_exclude_device;
 #endif
+#ifdef CONFIG_SMP
+        mpc85xx_smp_init();
+#endif
        printk("MPC85xx DS board from Freescale Semiconductor\n");
 }
diff --git a/arch/powerpc/platforms/85xx/smp.c b/arch/powerpc/platforms/85xx/smp.c
index d652c713f496..79a0df17078b 100644
--- a/arch/powerpc/platforms/85xx/smp.c
+++ b/arch/powerpc/platforms/85xx/smp.c
@@ -58,6 +58,7 @@ smp_85xx_kick_cpu(int nr)
        if (cpu_rel_addr == NULL) {
                printk(KERN_ERR "No cpu-release-addr for cpu %d\n", nr);
+                local_irq_restore(flags);
                return;
        }
diff --git a/arch/powerpc/platforms/Kconfig b/arch/powerpc/platforms/Kconfig
index 47e956c871fe..47fe2bea9865 100644
--- a/arch/powerpc/platforms/Kconfig
+++ b/arch/powerpc/platforms/Kconfig
@@ -312,4 +312,15 @@ config MPC8xxx_GPIO
          Say Y here if you're going to use hardware that connects to the
          MPC831x/834x/837x/8572/8610 GPIOs.
+config SIMPLE_GPIO
+        bool "Support for simple, memory-mapped GPIO controllers"
+        depends on PPC
+        select GENERIC_GPIO
+        select ARCH_REQUIRE_GPIOLIB
+        help
+          Say Y here to support simple, memory-mapped GPIO controllers.
+          These are usually BCSRs used to control board's switches, LEDs,
+          chip-selects, Ethernet/USB PHY's power and various other small
+          on-board peripherals.
 endmenu
diff --git a/arch/powerpc/platforms/Kconfig.cputype b/arch/powerpc/platforms/Kconfig.cputype
index 3d0c776f888d..e868b5c50723 100644
--- a/arch/powerpc/platforms/Kconfig.cputype
+++ b/arch/powerpc/platforms/Kconfig.cputype
@@ -231,7 +231,7 @@ config VIRT_CPU_ACCOUNTING
          If in doubt, say Y here.
 config SMP
-        depends on PPC_STD_MMU
+        depends on PPC_STD_MMU || FSL_BOOKE
        bool "Symmetric multi-processing support"
        ---help---
          This enables support for systems with more than one CPU. If you have
diff --git a/arch/powerpc/platforms/cell/beat_htab.c b/arch/powerpc/platforms/cell/beat_htab.c
index 2e67bd840e01..35b1ec492715 100644
--- a/arch/powerpc/platforms/cell/beat_htab.c
+++ b/arch/powerpc/platforms/cell/beat_htab.c
@@ -44,8 +44,8 @@ static DEFINE_SPINLOCK(beat_htab_lock);
 static inline unsigned int beat_read_mask(unsigned hpte_group)
 {
-        unsigned long hpte_v[5];
        unsigned long rmask = 0;
+        u64 hpte_v[5];
        beat_read_htab_entries(0, hpte_group + 0, hpte_v);
        if (!(hpte_v[0] & HPTE_V_BOLTED))
@@ -93,8 +93,7 @@ static long beat_lpar_hpte_insert(unsigned long hpte_group,
                                  int psize, int ssize)
 {
        unsigned long lpar_rc;
-        unsigned long slot;
+        u64 hpte_v, hpte_r, slot;
-        unsigned long hpte_v, hpte_r;
        /* same as iseries */
        if (vflags & HPTE_V_SECONDARY)
@@ -153,8 +152,9 @@ static long beat_lpar_hpte_remove(unsigned long hpte_group)
 static unsigned long beat_lpar_hpte_getword0(unsigned long slot)
 {
-        unsigned long dword0, dword[5];
+        unsigned long dword0;
        unsigned long lpar_rc;
+        u64 dword[5];
        lpar_rc = beat_read_htab_entries(0, slot & ~3UL, dword);
@@ -170,7 +170,7 @@ static void beat_lpar_hptab_clear(void)
        unsigned long size_bytes = 1UL << ppc64_pft_size;
        unsigned long hpte_count = size_bytes >> 4;
        int i;
-        unsigned long dummy0, dummy1;
+        u64 dummy0, dummy1;
        /* TODO: Use bulk call */
        for (i = 0; i < hpte_count; i++)
@@ -189,7 +189,8 @@ static long beat_lpar_hpte_updatepp(unsigned long slot,
                                    int psize, int ssize, int local)
 {
        unsigned long lpar_rc;
-        unsigned long dummy0, dummy1, want_v;
+        u64 dummy0, dummy1;
+        unsigned long want_v;
        want_v = hpte_encode_v(va, psize, MMU_SEGSIZE_256M);
@@ -255,7 +256,8 @@ static void beat_lpar_hpte_updateboltedpp(unsigned long newpp,
                                          unsigned long ea,
                                          int psize, int ssize)
 {
-        unsigned long lpar_rc, slot, vsid, va, dummy0, dummy1;
+        unsigned long lpar_rc, slot, vsid, va;
+        u64 dummy0, dummy1;
        vsid = get_kernel_vsid(ea, MMU_SEGSIZE_256M);
        va = (vsid << 28) | (ea & 0x0fffffff);
@@ -276,7 +278,7 @@ static void beat_lpar_hpte_invalidate(unsigned long slot, unsigned long va,
 {
        unsigned long want_v;
        unsigned long lpar_rc;
-        unsigned long dummy1, dummy2;
+        u64 dummy1, dummy2;
        unsigned long flags;
        DBG_LOW("    inval : slot=%lx, va=%016lx, psize: %d, local: %d\n",
@@ -315,8 +317,7 @@ static long beat_lpar_hpte_insert_v3(unsigned long hpte_group,
                                  int psize, int ssize)
 {
        unsigned long lpar_rc;
-        unsigned long slot;
+        u64 hpte_v, hpte_r, slot;
-        unsigned long hpte_v, hpte_r;
        /* same as iseries */
        if (vflags & HPTE_V_SECONDARY)
diff --git a/arch/powerpc/platforms/cell/beat_udbg.c b/arch/powerpc/platforms/cell/beat_udbg.c
index 6b418f6b6175..350735bc8888 100644
--- a/arch/powerpc/platforms/cell/beat_udbg.c
+++ b/arch/powerpc/platforms/cell/beat_udbg.c
@@ -40,8 +40,8 @@ static void udbg_putc_beat(char c)
 }
 /* Buffered chars getc */
-static long inbuflen;
+static u64 inbuflen;
-static long inbuf[2];   /* must be 2 longs */
+static u64 inbuf[2];    /* must be 2 u64s */
 static int udbg_getc_poll_beat(void)
 {
diff --git a/arch/powerpc/platforms/cell/cbe_cpufreq_pervasive.c b/arch/powerpc/platforms/cell/cbe_cpufreq_pervasive.c
index 70fa7aef5edd..20472e487b6f 100644
--- a/arch/powerpc/platforms/cell/cbe_cpufreq_pervasive.c
+++ b/arch/powerpc/platforms/cell/cbe_cpufreq_pervasive.c
@@ -54,7 +54,7 @@ int cbe_cpufreq_set_pmode(int cpu, unsigned int pmode)
 {
        struct cbe_pmd_regs __iomem *pmd_regs;
        struct cbe_mic_tm_regs __iomem *mic_tm_regs;
-        u64 flags;
+        unsigned long flags;
        u64 value;
 #ifdef DEBUG
        long time;
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index 2d5bb22d6c09..28c04dab2633 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -148,7 +148,7 @@ static unsigned int iic_get_irq(void)
        iic = &__get_cpu_var(iic);
        *(unsigned long *) &pending =
-                in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
+                in_be64((u64 __iomem *) &iic->regs->pending_destr);
        if (!(pending.flags & CBE_IIC_IRQ_VALID))
                return NO_IRQ;
        virq = irq_linear_revmap(iic_host, iic_pending_to_hwnum(pending));
diff --git a/arch/powerpc/platforms/cell/io-workarounds.c b/arch/powerpc/platforms/cell/io-workarounds.c
index b5f84e8f0899..059cad6c3f69 100644
--- a/arch/powerpc/platforms/cell/io-workarounds.c
+++ b/arch/powerpc/platforms/cell/io-workarounds.c
@@ -130,14 +130,14 @@ static const struct ppc_pci_io __devinitconst iowa_pci_io = {
 };
-static void __iomem *iowa_ioremap(unsigned long addr, unsigned long size,
+static void __iomem *iowa_ioremap(phys_addr_t addr, unsigned long size,
                                                unsigned long flags)
 {
        struct iowa_bus *bus;
        void __iomem *res = __ioremap(addr, size, flags);
        int busno;
-        bus = iowa_pci_find(0, addr);
+        bus = iowa_pci_find(0, (unsigned long)addr);
        if (bus != NULL) {
                busno = bus - iowa_busses;
                PCI_SET_ADDR_TOKEN(res, busno + 1);
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index 86db4dd170a0..88d94b59a7cb 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -150,8 +150,8 @@ static int cbe_nr_iommus;
 static void invalidate_tce_cache(struct cbe_iommu *iommu, unsigned long *pte,
                long n_ptes)
 {
-        unsigned long __iomem *reg;
+        u64 __iomem *reg;
-        unsigned long val;
+        u64 val;
        long n;
        reg = iommu->xlate_regs + IOC_IOPT_CacheInvd;
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index 15c62d3ca129..3bf908e2873a 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -314,7 +314,7 @@ extern char *isolated_loader;
 *      we need to call spu_release(ctx) before sleeping, and
 *      then spu_acquire(ctx) when awoken.
 *
- *      Returns with state_mutex re-acquired when successfull or
+ *      Returns with state_mutex re-acquired when successful or
 *      with -ERESTARTSYS and the state_mutex dropped when interrupted.
 */
diff --git a/arch/powerpc/platforms/iseries/Kconfig b/arch/powerpc/platforms/iseries/Kconfig
index ed3753d8c109..7ddd0a2c8027 100644
--- a/arch/powerpc/platforms/iseries/Kconfig
+++ b/arch/powerpc/platforms/iseries/Kconfig
@@ -10,18 +10,21 @@ menu "iSeries device drivers"
 config VIODASD
        tristate "iSeries Virtual I/O disk support"
        depends on BLOCK
+        select VIOPATH
        help
          If you are running on an iSeries system and you want to use
          virtual disks created and managed by OS/400, say Y.
 config VIOCD
        tristate "iSeries Virtual I/O CD support"
+        select VIOPATH
        help
          If you are running Linux on an IBM iSeries system and you want to
          read a CD drive owned by OS/400, say Y here.
 config VIOTAPE
        tristate "iSeries Virtual Tape Support"
+        select VIOPATH
        help
          If you are running Linux on an iSeries system and you want Linux
          to read and/or write a tape drive owned by OS/400, say Y here.
@@ -30,5 +33,3 @@ endmenu
 config VIOPATH
        bool
-        depends on VIODASD || VIOCD || VIOTAPE || ISERIES_VETH
-        default y
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
index 70b688c1aefb..24519b96d6ad 100644
--- a/arch/powerpc/platforms/iseries/setup.c
+++ b/arch/powerpc/platforms/iseries/setup.c
@@ -23,6 +23,7 @@
 #include <linux/string.h>
 #include <linux/seq_file.h>
 #include <linux/kdev_t.h>
+#include <linux/kexec.h>
 #include <linux/major.h>
 #include <linux/root_dev.h>
 #include <linux/kernel.h>
@@ -638,6 +639,13 @@ static int __init iseries_probe(void)
        return 1;
 }
+#ifdef CONFIG_KEXEC
+static int iseries_kexec_prepare(struct kimage *image)
+{
+        return -ENOSYS;
+}
+#endif
 define_machine(iseries) {
        .name                   = "iSeries",
        .setup_arch             = iSeries_setup_arch,
@@ -658,6 +666,9 @@ define_machine(iseries) {
        .probe                  = iseries_probe,
        .ioremap                = iseries_ioremap,
        .iounmap                = iseries_iounmap,
+#ifdef CONFIG_KEXEC
+        .machine_kexec_prepare  = iseries_kexec_prepare,
+#endif
        /* XXX Implement enable_pmcs for iSeries */
 };
diff --git a/arch/powerpc/platforms/pasemi/cpufreq.c b/arch/powerpc/platforms/pasemi/cpufreq.c
index 58556b028a4c..86db47c1b665 100644
--- a/arch/powerpc/platforms/pasemi/cpufreq.c
+++ b/arch/powerpc/platforms/pasemi/cpufreq.c
@@ -112,7 +112,7 @@ static int get_gizmo_latency(void)
 static void set_astate(int cpu, unsigned int astate)
 {
-        u64 flags;
+        unsigned long flags;
        /* Return if called before init has run */
        if (unlikely(!sdcasr_mapbase))
diff --git a/arch/powerpc/platforms/pasemi/dma_lib.c b/arch/powerpc/platforms/pasemi/dma_lib.c
index 217af321b0ca..a6152d922243 100644
--- a/arch/powerpc/platforms/pasemi/dma_lib.c
+++ b/arch/powerpc/platforms/pasemi/dma_lib.c
@@ -509,7 +509,7 @@ fallback:
 */
 int pasemi_dma_init(void)
 {
-        static spinlock_t init_lock = SPIN_LOCK_UNLOCKED;
+        static DEFINE_SPINLOCK(init_lock);
        struct pci_dev *iob_pdev;
        struct pci_dev *pdev;
        struct resource res;
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index 54b7b76ed4f0..04cdd32624d4 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -661,6 +661,7 @@ static void __init init_second_ohare(void)
                        pci_find_hose_for_OF_device(np);
                if (!hose) {
                        printk(KERN_ERR "Can't find PCI hose for OHare2 !\n");
+                        of_node_put(np);
                        return;
                }
                early_read_config_word(hose, bus, devfn, PCI_COMMAND, &cmd);
@@ -669,6 +670,7 @@ static void __init init_second_ohare(void)
                early_write_config_word(hose, bus, devfn, PCI_COMMAND, cmd);
        }
        has_second_ohare = 1;
+        of_node_put(np);
 }
 /*
diff --git a/arch/powerpc/platforms/powermac/time.c b/arch/powerpc/platforms/powermac/time.c
index 59eb840d8ce2..1810e4226e56 100644
--- a/arch/powerpc/platforms/powermac/time.c
+++ b/arch/powerpc/platforms/powermac/time.c
@@ -265,12 +265,15 @@ int __init via_calibrate_decr(void)
        struct resource rsrc;
        vias = of_find_node_by_name(NULL, "via-cuda");
-        if (vias == 0)
+        if (vias == NULL)
                vias = of_find_node_by_name(NULL, "via-pmu");
-        if (vias == 0)
+        if (vias == NULL)
                vias = of_find_node_by_name(NULL, "via");
-        if (vias == 0 || of_address_to_resource(vias, 0, &rsrc))
+        if (vias == NULL || of_address_to_resource(vias, 0, &rsrc)) {
+                of_node_put(vias);
                return 0;
+        }
+        of_node_put(vias);
        via = ioremap(rsrc.start, rsrc.end - rsrc.start + 1);
        if (via == NULL) {
                printk(KERN_ERR "Failed to map VIA for timer calibration !\n");
@@ -297,7 +300,7 @@ int __init via_calibrate_decr(void)
        ppc_tb_freq = (dstart - dend) * 100 / 6;
        iounmap(via);
-        
        return 1;
 }
 #endif
diff --git a/arch/powerpc/platforms/ps3/device-init.c b/arch/powerpc/platforms/ps3/device-init.c
index dbc124e05646..ca71a12b764c 100644
--- a/arch/powerpc/platforms/ps3/device-init.c
+++ b/arch/powerpc/platforms/ps3/device-init.c
@@ -518,6 +518,41 @@ fail_device_register:
        return result;
 }
+static int __init ps3_register_ramdisk_device(void)
+{
+        int result;
+        struct layout {
+                struct ps3_system_bus_device dev;
+        } *p;
+        pr_debug(" -> %s:%d\n", __func__, __LINE__);
+        p = kzalloc(sizeof(struct layout), GFP_KERNEL);
+        if (!p)
+                return -ENOMEM;
+        p->dev.match_id = PS3_MATCH_ID_GPU;
+        p->dev.match_sub_id = PS3_MATCH_SUB_ID_GPU_RAMDISK;
+        p->dev.dev_type = PS3_DEVICE_TYPE_IOC0;
+        result = ps3_system_bus_device_register(&p->dev);
+        if (result) {
+                pr_debug("%s:%d ps3_system_bus_device_register failed\n",
+                        __func__, __LINE__);
+                goto fail_device_register;
+        }
+        pr_debug(" <- %s:%d\n", __func__, __LINE__);
+        return 0;
+fail_device_register:
+        kfree(p);
+        pr_debug(" <- %s:%d failed\n", __func__, __LINE__);
+        return result;
+}
 /**
 * ps3_setup_dynamic_device - Setup a dynamic device from the repository
 */
@@ -946,6 +981,8 @@ static int __init ps3_register_devices(void)
        ps3_register_lpm_devices();
+        ps3_register_ramdisk_device();
        pr_debug(" <- %s:%d\n", __func__, __LINE__);
        return 0;
 }
diff --git a/arch/powerpc/sysdev/Makefile b/arch/powerpc/sysdev/Makefile
index 5afce115ab1f..b33b28a6fe12 100644
--- a/arch/powerpc/sysdev/Makefile
+++ b/arch/powerpc/sysdev/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_FSL_PCI)		+= fsl_pci.o $(fsl-msi-obj-y)
 obj-$(CONFIG_FSL_LBC)           += fsl_lbc.o
 obj-$(CONFIG_FSL_GTM)           += fsl_gtm.o
 obj-$(CONFIG_MPC8xxx_GPIO)      += mpc8xxx_gpio.o
+obj-$(CONFIG_SIMPLE_GPIO)       += simple_gpio.o
 obj-$(CONFIG_RAPIDIO)           += fsl_rio.o
 obj-$(CONFIG_TSI108_BRIDGE)     += tsi108_pci.o tsi108_dev.o
 obj-$(CONFIG_QUICC_ENGINE)      += qe_lib/
diff --git a/arch/powerpc/sysdev/fsl_pci.c b/arch/powerpc/sysdev/fsl_pci.c
index d5f9ae0f1b75..f611d0369cc8 100644
--- a/arch/powerpc/sysdev/fsl_pci.c
+++ b/arch/powerpc/sysdev/fsl_pci.c
@@ -29,7 +29,8 @@
 #if defined(CONFIG_PPC_85xx) || defined(CONFIG_PPC_86xx)
 /* atmu setup for fsl pci/pcie controller */
-void __init setup_pci_atmu(struct pci_controller *hose, struct resource *rsrc)
+static void __init setup_pci_atmu(struct pci_controller *hose,
+                                  struct resource *rsrc)
 {
        struct ccsr_pci __iomem *pci;
        int i;
@@ -86,7 +87,7 @@ void __init setup_pci_atmu(struct pci_controller *hose, struct resource *rsrc)
        out_be32(&pci->piw[2].piwar, PIWAR_2G);
 }
-void __init setup_pci_cmd(struct pci_controller *hose)
+static void __init setup_pci_cmd(struct pci_controller *hose)
 {
        u16 cmd;
        int cap_x;
@@ -130,7 +131,7 @@ static void __init quirk_fsl_pcie_header(struct pci_dev *dev)
        return ;
 }
-int __init fsl_pcie_check_link(struct pci_controller *hose)
+static int __init fsl_pcie_check_link(struct pci_controller *hose)
 {
        u32 val;
        early_read_config_dword(hose, 0, 0, PCIE_LTSSM, &val);
diff --git a/arch/powerpc/sysdev/fsl_soc.h b/arch/powerpc/sysdev/fsl_soc.h
index 60f7f227327c..9c744e4285a0 100644
--- a/arch/powerpc/sysdev/fsl_soc.h
+++ b/arch/powerpc/sysdev/fsl_soc.h
@@ -5,8 +5,13 @@
 #include <asm/mmu.h>
 extern phys_addr_t get_immrbase(void);
+#if defined(CONFIG_CPM2) || defined(CONFIG_QUICC_ENGINE) || defined(CONFIG_8xx)
 extern u32 get_brgfreq(void);
 extern u32 get_baudrate(void);
+#else
+static inline u32 get_brgfreq(void) { return -1; }
+static inline u32 get_baudrate(void) { return -1; }
+#endif
 extern u32 fsl_get_sys_freq(void);
 struct spi_board_info;
diff --git a/arch/powerpc/sysdev/qe_lib/Kconfig b/arch/powerpc/sysdev/qe_lib/Kconfig
index 76ffbc48d4b9..41ac3dfac98e 100644
--- a/arch/powerpc/sysdev/qe_lib/Kconfig
+++ b/arch/powerpc/sysdev/qe_lib/Kconfig
@@ -22,5 +22,6 @@ config UCC
 config QE_USB
        bool
+        default y if USB_GADGET_FSL_QE
        help
-          QE USB Host Controller support
+          QE USB Controller support
diff --git a/arch/powerpc/sysdev/qe_lib/gpio.c b/arch/powerpc/sysdev/qe_lib/gpio.c
index 8e5a0bc36d0b..3485288dce31 100644
--- a/arch/powerpc/sysdev/qe_lib/gpio.c
+++ b/arch/powerpc/sysdev/qe_lib/gpio.c
@@ -14,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/err.h>
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
@@ -24,8 +25,14 @@ struct qe_gpio_chip {
        struct of_mm_gpio_chip mm_gc;
        spinlock_t lock;
+        unsigned long pin_flags[QE_PIO_PINS];
+#define QE_PIN_REQUESTED 0
        /* shadowed data register to clear/set bits safely */
        u32 cpdata;
+        /* saved_regs used to restore dedicated functions */
+        struct qe_pio_regs saved_regs;
 };
 static inline struct qe_gpio_chip *
@@ -40,6 +47,12 @@ static void qe_gpio_save_regs(struct of_mm_gpio_chip *mm_gc)
        struct qe_pio_regs __iomem *regs = mm_gc->regs;
        qe_gc->cpdata = in_be32(&regs->cpdata);
+        qe_gc->saved_regs.cpdata = qe_gc->cpdata;
+        qe_gc->saved_regs.cpdir1 = in_be32(&regs->cpdir1);
+        qe_gc->saved_regs.cpdir2 = in_be32(&regs->cpdir2);
+        qe_gc->saved_regs.cppar1 = in_be32(&regs->cppar1);
+        qe_gc->saved_regs.cppar2 = in_be32(&regs->cppar2);
+        qe_gc->saved_regs.cpodr = in_be32(&regs->cpodr);
 }
 static int qe_gpio_get(struct gpio_chip *gc, unsigned int gpio)
@@ -103,6 +116,188 @@ static int qe_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
        return 0;
 }
+struct qe_pin {
+        /*
+         * The qe_gpio_chip name is unfortunate, we should change that to
+         * something like qe_pio_controller. Someday.
+         */
+        struct qe_gpio_chip *controller;
+        int num;
+};
+/**
+ * qe_pin_request - Request a QE pin
+ * @np:         device node to get a pin from
+ * @index:      index of a pin in the device tree
+ * Context:     non-atomic
+ *
+ * This function return qe_pin so that you could use it with the rest of
+ * the QE Pin Multiplexing API.
+ */
+struct qe_pin *qe_pin_request(struct device_node *np, int index)
+{
+        struct qe_pin *qe_pin;
+        struct device_node *gc;
+        struct of_gpio_chip *of_gc = NULL;
+        struct of_mm_gpio_chip *mm_gc;
+        struct qe_gpio_chip *qe_gc;
+        int err;
+        int size;
+        const void *gpio_spec;
+        const u32 *gpio_cells;
+        unsigned long flags;
+        qe_pin = kzalloc(sizeof(*qe_pin), GFP_KERNEL);
+        if (!qe_pin) {
+                pr_debug("%s: can't allocate memory\n", __func__);
+                return ERR_PTR(-ENOMEM);
+        }
+        err = of_parse_phandles_with_args(np, "gpios", "#gpio-cells", index,
+                                          &gc, &gpio_spec);
+        if (err) {
+                pr_debug("%s: can't parse gpios property\n", __func__);
+                goto err0;
+        }
+        if (!of_device_is_compatible(gc, "fsl,mpc8323-qe-pario-bank")) {
+                pr_debug("%s: tried to get a non-qe pin\n", __func__);
+                err = -EINVAL;
+                goto err1;
+        }
+        of_gc = gc->data;
+        if (!of_gc) {
+                pr_debug("%s: gpio controller %s isn't registered\n",
+                         np->full_name, gc->full_name);
+                err = -ENODEV;
+                goto err1;
+        }
+        gpio_cells = of_get_property(gc, "#gpio-cells", &size);
+        if (!gpio_cells || size != sizeof(*gpio_cells) ||
+                        *gpio_cells != of_gc->gpio_cells) {
+                pr_debug("%s: wrong #gpio-cells for %s\n",
+                         np->full_name, gc->full_name);
+                err = -EINVAL;
+                goto err1;
+        }
+        err = of_gc->xlate(of_gc, np, gpio_spec, NULL);
+        if (err < 0)
+                goto err1;
+        mm_gc = to_of_mm_gpio_chip(&of_gc->gc);
+        qe_gc = to_qe_gpio_chip(mm_gc);
+        spin_lock_irqsave(&qe_gc->lock, flags);
+        if (test_and_set_bit(QE_PIN_REQUESTED, &qe_gc->pin_flags[err]) == 0) {
+                qe_pin->controller = qe_gc;
+                qe_pin->num = err;
+                err = 0;
+        } else {
+                err = -EBUSY;
+        }
+        spin_unlock_irqrestore(&qe_gc->lock, flags);
+        if (!err)
+                return qe_pin;
+err1:
+        of_node_put(gc);
+err0:
+        kfree(qe_pin);
+        pr_debug("%s failed with status %d\n", __func__, err);
+        return ERR_PTR(err);
+}
+EXPORT_SYMBOL(qe_pin_request);
+/**
+ * qe_pin_free - Free a pin
+ * @qe_pin:     pointer to the qe_pin structure
+ * Context:     any
+ *
+ * This function frees the qe_pin structure and makes a pin available
+ * for further qe_pin_request() calls.
+ */
+void qe_pin_free(struct qe_pin *qe_pin)
+{
+        struct qe_gpio_chip *qe_gc = qe_pin->controller;
+        unsigned long flags;
+        const int pin = qe_pin->num;
+        spin_lock_irqsave(&qe_gc->lock, flags);
+        test_and_clear_bit(QE_PIN_REQUESTED, &qe_gc->pin_flags[pin]);
+        spin_unlock_irqrestore(&qe_gc->lock, flags);
+        kfree(qe_pin);
+}
+EXPORT_SYMBOL(qe_pin_free);
+/**
+ * qe_pin_set_dedicated - Revert a pin to a dedicated peripheral function mode
+ * @qe_pin:     pointer to the qe_pin structure
+ * Context:     any
+ *
+ * This function resets a pin to a dedicated peripheral function that
+ * has been set up by the firmware.
+ */
+void qe_pin_set_dedicated(struct qe_pin *qe_pin)
+{
+        struct qe_gpio_chip *qe_gc = qe_pin->controller;
+        struct qe_pio_regs __iomem *regs = qe_gc->mm_gc.regs;
+        struct qe_pio_regs *sregs = &qe_gc->saved_regs;
+        int pin = qe_pin->num;
+        u32 mask1 = 1 << (QE_PIO_PINS - (pin + 1));
+        u32 mask2 = 0x3 << (QE_PIO_PINS - (pin % (QE_PIO_PINS / 2) + 1) * 2);
+        bool second_reg = pin > (QE_PIO_PINS / 2) - 1;
+        unsigned long flags;
+        spin_lock_irqsave(&qe_gc->lock, flags);
+        if (second_reg) {
+                clrsetbits_be32(&regs->cpdir2, mask2, sregs->cpdir2 & mask2);
+                clrsetbits_be32(&regs->cppar2, mask2, sregs->cppar2 & mask2);
+        } else {
+                clrsetbits_be32(&regs->cpdir1, mask2, sregs->cpdir1 & mask2);
+                clrsetbits_be32(&regs->cppar1, mask2, sregs->cppar1 & mask2);
+        }
+        if (sregs->cpdata & mask1)
+                qe_gc->cpdata |= mask1;
+        else
+                qe_gc->cpdata &= ~mask1;
+        out_be32(&regs->cpdata, qe_gc->cpdata);
+        clrsetbits_be32(&regs->cpodr, mask1, sregs->cpodr & mask1);
+        spin_unlock_irqrestore(&qe_gc->lock, flags);
+}
+EXPORT_SYMBOL(qe_pin_set_dedicated);
+/**
+ * qe_pin_set_gpio - Set a pin to the GPIO mode
+ * @qe_pin:     pointer to the qe_pin structure
+ * Context:     any
+ *
+ * This function sets a pin to the GPIO mode.
+ */
+void qe_pin_set_gpio(struct qe_pin *qe_pin)
+{
+        struct qe_gpio_chip *qe_gc = qe_pin->controller;
+        struct qe_pio_regs __iomem *regs = qe_gc->mm_gc.regs;
+        unsigned long flags;
+        spin_lock_irqsave(&qe_gc->lock, flags);
+        /* Let's make it input by default, GPIO API is able to change that. */
+        __par_io_config_pin(regs, qe_pin->num, QE_PIO_DIR_IN, 0, 0, 0);
+        spin_unlock_irqrestore(&qe_gc->lock, flags);
+}
+EXPORT_SYMBOL(qe_pin_set_gpio);
 static int __init qe_add_gpiochips(void)
 {
        struct device_node *np;
diff --git a/arch/powerpc/sysdev/simple_gpio.c b/arch/powerpc/sysdev/simple_gpio.c
new file mode 100644
index 000000000000..43c4569e24b7
--- /dev/null
+++ b/arch/powerpc/sysdev/simple_gpio.c
@@ -0,0 +1,155 @@
+/*
+ * Simple Memory-Mapped GPIOs
+ *
+ * Copyright (c) MontaVista Software, Inc. 2008.
+ *
+ * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/gpio.h>
+#include <asm/prom.h>
+#include "simple_gpio.h"
+struct u8_gpio_chip {
+        struct of_mm_gpio_chip mm_gc;
+        spinlock_t lock;
+        /* shadowed data register to clear/set bits safely */
+        u8 data;
+};
+static struct u8_gpio_chip *to_u8_gpio_chip(struct of_mm_gpio_chip *mm_gc)
+{
+        return container_of(mm_gc, struct u8_gpio_chip, mm_gc);
+}
+static u8 u8_pin2mask(unsigned int pin)
+{
+        return 1 << (8 - 1 - pin);
+}
+static int u8_gpio_get(struct gpio_chip *gc, unsigned int gpio)
+{
+        struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
+        return in_8(mm_gc->regs) & u8_pin2mask(gpio);
+}
+static void u8_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
+{
+        struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc);
+        struct u8_gpio_chip *u8_gc = to_u8_gpio_chip(mm_gc);
+        unsigned long flags;
+        spin_lock_irqsave(&u8_gc->lock, flags);
+        if (val)
+                u8_gc->data |= u8_pin2mask(gpio);
+        else
+                u8_gc->data &= ~u8_pin2mask(gpio);
+        out_8(mm_gc->regs, u8_gc->data);
+        spin_unlock_irqrestore(&u8_gc->lock, flags);
+}
+static int u8_gpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
+{
+        return 0;
+}
+static int u8_gpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
+{
+        u8_gpio_set(gc, gpio, val);
+        return 0;
+}
+static void u8_gpio_save_regs(struct of_mm_gpio_chip *mm_gc)
+{
+        struct u8_gpio_chip *u8_gc = to_u8_gpio_chip(mm_gc);
+        u8_gc->data = in_8(mm_gc->regs);
+}
+static int __init u8_simple_gpiochip_add(struct device_node *np)
+{
+        int ret;
+        struct u8_gpio_chip *u8_gc;
+        struct of_mm_gpio_chip *mm_gc;
+        struct of_gpio_chip *of_gc;
+        struct gpio_chip *gc;
+        u8_gc = kzalloc(sizeof(*u8_gc), GFP_KERNEL);
+        if (!u8_gc)
+                return -ENOMEM;
+        spin_lock_init(&u8_gc->lock);
+        mm_gc = &u8_gc->mm_gc;
+        of_gc = &mm_gc->of_gc;
+        gc = &of_gc->gc;
+        mm_gc->save_regs = u8_gpio_save_regs;
+        of_gc->gpio_cells = 2;
+        gc->ngpio = 8;
+        gc->direction_input = u8_gpio_dir_in;
+        gc->direction_output = u8_gpio_dir_out;
+        gc->get = u8_gpio_get;
+        gc->set = u8_gpio_set;
+        ret = of_mm_gpiochip_add(np, mm_gc);
+        if (ret)
+                goto err;
+        return 0;
+err:
+        kfree(u8_gc);
+        return ret;
+}
+void __init simple_gpiochip_init(const char *compatible)
+{
+        struct device_node *np;
+        for_each_compatible_node(np, NULL, compatible) {
+                int ret;
+                struct resource r;
+                ret = of_address_to_resource(np, 0, &r);
+                if (ret)
+                        goto err;
+                switch (resource_size(&r)) {
+                case 1:
+                        ret = u8_simple_gpiochip_add(np);
+                        if (ret)
+                                goto err;
+                        break;
+                default:
+                        /*
+                         * Whenever you need support for GPIO bank width > 1,
+                         * please just turn u8_ code into huge macros, and
+                         * construct needed uX_ code with it.
+                         */
+                        ret = -ENOSYS;
+                        goto err;
+                }
+                continue;
+err:
+                pr_err("%s: registration failed, status %d\n",
+                       np->full_name, ret);
+        }
+}
diff --git a/arch/powerpc/sysdev/simple_gpio.h b/arch/powerpc/sysdev/simple_gpio.h
new file mode 100644
index 000000000000..3a7b0c513c76
--- /dev/null
+++ b/arch/powerpc/sysdev/simple_gpio.h
@@ -0,0 +1,12 @@
+#ifndef __SYSDEV_SIMPLE_GPIO_H
+#define __SYSDEV_SIMPLE_GPIO_H
+#include <linux/errno.h>
+#ifdef CONFIG_SIMPLE_GPIO
+extern void simple_gpiochip_init(const char *compatible);
+#else
+static inline void simple_gpiochip_init(const char *compatible) {}
+#endif /* CONFIG_SIMPLE_GPIO */
+#endif /* __SYSDEV_SIMPLE_GPIO_H */
diff --git a/arch/s390/include/asm/chpid.h b/arch/s390/include/asm/chpid.h
index dfe3c7f3439a..fc71d8a6709b 100644
--- a/arch/s390/include/asm/chpid.h
+++ b/arch/s390/include/asm/chpid.h
@@ -9,7 +9,7 @@
 #define _ASM_S390_CHPID_H _ASM_S390_CHPID_H
 #include <linux/string.h>
-#include <asm/types.h>
+#include <linux/types.h>
 #define __MAX_CHPID 255
diff --git a/arch/s390/include/asm/chsc.h b/arch/s390/include/asm/chsc.h
index d38d0cf62d4b..807997f7414b 100644
--- a/arch/s390/include/asm/chsc.h
+++ b/arch/s390/include/asm/chsc.h
@@ -8,6 +8,7 @@
 #ifndef _ASM_CHSC_H
 #define _ASM_CHSC_H
+#include <linux/types.h>
 #include <asm/chpid.h>
 #include <asm/schid.h>
diff --git a/arch/s390/include/asm/cmb.h b/arch/s390/include/asm/cmb.h
index 50196857d27a..39ae03294794 100644
--- a/arch/s390/include/asm/cmb.h
+++ b/arch/s390/include/asm/cmb.h
@@ -1,5 +1,8 @@
 #ifndef S390_CMB_H
 #define S390_CMB_H
+#include <linux/types.h>
 /**
 * struct cmbdata - channel measurement block data for user space
 * @size: size of the stored data
diff --git a/arch/s390/include/asm/dasd.h b/arch/s390/include/asm/dasd.h
index 55b2b80cdf6e..e2db6f16d9c8 100644
--- a/arch/s390/include/asm/dasd.h
+++ b/arch/s390/include/asm/dasd.h
@@ -14,6 +14,7 @@
 #ifndef DASD_H
 #define DASD_H
+#include <linux/types.h>
 #include <linux/ioctl.h>
 #define DASD_IOCTL_LETTER 'D'
@@ -78,6 +79,7 @@ typedef struct dasd_information2_t {
 #define DASD_FEATURE_USEDIAG         0x02
 #define DASD_FEATURE_INITIAL_ONLINE  0x04
 #define DASD_FEATURE_ERPLOG          0x08
+#define DASD_FEATURE_FAILFAST        0x10
 #define DASD_PARTN_BITS 2
diff --git a/arch/s390/include/asm/kvm.h b/arch/s390/include/asm/kvm.h
index d74002f95794..e1f54654e3ae 100644
--- a/arch/s390/include/asm/kvm.h
+++ b/arch/s390/include/asm/kvm.h
@@ -13,7 +13,7 @@
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Christian Borntraeger <borntraeger@de.ibm.com>
 */
-#include <asm/types.h>
+#include <linux/types.h>
 /* for KVM_GET_IRQCHIP and KVM_SET_IRQCHIP */
 struct kvm_pic_state {
diff --git a/arch/s390/include/asm/posix_types.h b/arch/s390/include/asm/posix_types.h
index 397d93fba3a7..8cc113f92523 100644
--- a/arch/s390/include/asm/posix_types.h
+++ b/arch/s390/include/asm/posix_types.h
@@ -68,11 +68,7 @@ typedef unsigned short __kernel_old_dev_t;
 #endif /* __s390x__ */
 typedef struct {
-#if defined(__KERNEL__) || defined(__USE_ALL)
        int     val[2];
-#else                        /* !defined(__KERNEL__) && !defined(__USE_ALL)*/
-        int     __val[2];
-#endif                       /* !defined(__KERNEL__) && !defined(__USE_ALL)*/
 } __kernel_fsid_t;
diff --git a/arch/s390/include/asm/ptrace.h b/arch/s390/include/asm/ptrace.h
index 5396f9f12263..8920025c3c02 100644
--- a/arch/s390/include/asm/ptrace.h
+++ b/arch/s390/include/asm/ptrace.h
@@ -272,12 +272,15 @@ typedef struct
 #define PSW_ASC_SECONDARY       0x0000800000000000UL
 #define PSW_ASC_HOME            0x0000C00000000000UL
-extern long psw_user32_bits;
 #endif /* __s390x__ */
+#ifdef __KERNEL__
 extern long psw_kernel_bits;
 extern long psw_user_bits;
+#ifdef CONFIG_64BIT
+extern long psw_user32_bits;
+#endif
+#endif
 /* This macro merges a NEW PSW mask specified by the user into
   the currently active PSW mask CURRENT, modifying only those
diff --git a/arch/s390/include/asm/qeth.h b/arch/s390/include/asm/qeth.h
index 930d378ef75a..06cbd1e8c943 100644
--- a/arch/s390/include/asm/qeth.h
+++ b/arch/s390/include/asm/qeth.h
@@ -10,6 +10,7 @@
 */
 #ifndef __ASM_S390_QETH_IOCTL_H__
 #define __ASM_S390_QETH_IOCTL_H__
+#include <linux/types.h>
 #include <linux/ioctl.h>
 #define SIOC_QETH_ARP_SET_NO_ENTRIES    (SIOCDEVPRIVATE)
diff --git a/arch/s390/include/asm/schid.h b/arch/s390/include/asm/schid.h
index 825503cf3dc2..3e4d401b4e45 100644
--- a/arch/s390/include/asm/schid.h
+++ b/arch/s390/include/asm/schid.h
@@ -1,6 +1,8 @@
 #ifndef ASM_SCHID_H
 #define ASM_SCHID_H
+#include <linux/types.h>
 struct subchannel_id {
        __u32 cssid : 8;
        __u32 : 4;
diff --git a/arch/s390/include/asm/swab.h b/arch/s390/include/asm/swab.h
index bd9321aa55a9..eb18dc1f327b 100644
--- a/arch/s390/include/asm/swab.h
+++ b/arch/s390/include/asm/swab.h
@@ -9,7 +9,7 @@
 *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
 */
-#include <asm/types.h>
+#include <linux/types.h>
 #ifndef __s390x__
 # define __SWAB_64_THRU_32__
diff --git a/arch/s390/include/asm/types.h b/arch/s390/include/asm/types.h
index 41c547656130..3dc3fc228812 100644
--- a/arch/s390/include/asm/types.h
+++ b/arch/s390/include/asm/types.h
@@ -9,11 +9,7 @@
 #ifndef _S390_TYPES_H
 #define _S390_TYPES_H
-#ifndef __s390x__
+#include <asm-generic/int-ll64.h>
-# include <asm-generic/int-ll64.h>
-#else
-# include <asm-generic/int-l64.h>
-#endif
 #ifndef __ASSEMBLY__
diff --git a/arch/s390/kernel/entry.h b/arch/s390/kernel/entry.h
index 6b1896345eda..a65afc91e8aa 100644
--- a/arch/s390/kernel/entry.h
+++ b/arch/s390/kernel/entry.h
@@ -54,7 +54,5 @@ long sys_sigreturn(void);
 long sys_rt_sigreturn(void);
 long sys32_sigreturn(void);
 long sys32_rt_sigreturn(void);
-long old_select(struct sel_arg_struct __user *arg);
-long sys_ptrace(long request, long pid, long addr, long data);
 #endif /* _ENTRY_H */
diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
index 9c0ccb532a45..2d337cbb9329 100644
--- a/arch/s390/kernel/smp.c
+++ b/arch/s390/kernel/smp.c
@@ -685,7 +685,8 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
        if (MACHINE_HAS_IEEE)
                lowcore->extended_save_area_addr = (u32) save_area;
 #else
-        BUG_ON(vdso_alloc_per_cpu(smp_processor_id(), lowcore));
+        if (vdso_alloc_per_cpu(smp_processor_id(), lowcore))
+                BUG();
 #endif
        set_prefix((u32)(unsigned long) lowcore);
        local_mcck_enable();
diff --git a/arch/s390/kernel/sys_s390.c b/arch/s390/kernel/sys_s390.c
index 4fe952e557ac..c34be4568b80 100644
--- a/arch/s390/kernel/sys_s390.c
+++ b/arch/s390/kernel/sys_s390.c
@@ -103,25 +103,6 @@ out:
        return error;
 }
-#ifndef CONFIG_64BIT
-struct sel_arg_struct {
-        unsigned long n;
-        fd_set __user *inp, *outp, *exp;
-        struct timeval __user *tvp;
-};
-asmlinkage long old_select(struct sel_arg_struct __user *arg)
-{
-        struct sel_arg_struct a;
-        if (copy_from_user(&a, arg, sizeof(a)))
-                return -EFAULT;
-        /* sys_select() does the appropriate kernel locking */
-        return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
-}
-#endif /* CONFIG_64BIT */
 /*
 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
 *
diff --git a/arch/s390/kernel/vdso.c b/arch/s390/kernel/vdso.c
index 25a6a82f1c02..690e17819686 100644
--- a/arch/s390/kernel/vdso.c
+++ b/arch/s390/kernel/vdso.c
@@ -322,7 +322,8 @@ static int __init vdso_init(void)
        vdso64_pagelist[vdso64_pages - 1] = virt_to_page(vdso_data);
        vdso64_pagelist[vdso64_pages] = NULL;
 #ifndef CONFIG_SMP
-        BUG_ON(vdso_alloc_per_cpu(0, S390_lowcore));
+        if (vdso_alloc_per_cpu(0, &S390_lowcore))
+                BUG();
 #endif
        vdso_init_cr5();
 #endif /* CONFIG_64BIT */
diff --git a/arch/s390/kernel/vdso32/gettimeofday.S b/arch/s390/kernel/vdso32/gettimeofday.S
index c32f29c3d70c..ad8acfc949fb 100644
--- a/arch/s390/kernel/vdso32/gettimeofday.S
+++ b/arch/s390/kernel/vdso32/gettimeofday.S
@@ -13,10 +13,6 @@
 #include <asm/asm-offsets.h>
 #include <asm/unistd.h>
-#include <asm/vdso.h>
-#include <asm/asm-offsets.h>
-#include <asm/unistd.h>
        .text
        .align 4
        .globl __kernel_gettimeofday
diff --git a/arch/s390/kvm/diag.c b/arch/s390/kvm/diag.c
index a0775e1f08df..8300309698fa 100644
--- a/arch/s390/kvm/diag.c
+++ b/arch/s390/kvm/diag.c
@@ -47,7 +47,7 @@ static int __diag_ipl_functions(struct kvm_vcpu *vcpu)
        vcpu->run->s390_reset_flags |= KVM_S390_RESET_IPL;
        vcpu->run->s390_reset_flags |= KVM_S390_RESET_CPU_INIT;
        vcpu->run->exit_reason = KVM_EXIT_S390_RESET;
-        VCPU_EVENT(vcpu, 3, "requesting userspace resets %lx",
+        VCPU_EVENT(vcpu, 3, "requesting userspace resets %llx",
          vcpu->run->s390_reset_flags);
        return -EREMOTE;
 }
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index 2960702b4824..f4fe28a2521a 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -160,7 +160,7 @@ static void __do_deliver_interrupt(struct kvm_vcpu *vcpu,
                break;
        case KVM_S390_INT_VIRTIO:
-                VCPU_EVENT(vcpu, 4, "interrupt: virtio parm:%x,parm64:%lx",
+                VCPU_EVENT(vcpu, 4, "interrupt: virtio parm:%x,parm64:%llx",
                           inti->ext.ext_params, inti->ext.ext_params2);
                vcpu->stat.deliver_virtio_interrupt++;
                rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2603);
@@ -360,7 +360,7 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
        vcpu->arch.ckc_timer.expires = jiffies + sltime;
        add_timer(&vcpu->arch.ckc_timer);
-        VCPU_EVENT(vcpu, 5, "enabled wait timer:%lx jiffies", sltime);
+        VCPU_EVENT(vcpu, 5, "enabled wait timer:%llx jiffies", sltime);
 no_timer:
        spin_lock_bh(&vcpu->arch.local_int.float_int->lock);
        spin_lock_bh(&vcpu->arch.local_int.lock);
@@ -491,7 +491,7 @@ int kvm_s390_inject_vm(struct kvm *kvm,
        switch (s390int->type) {
        case KVM_S390_INT_VIRTIO:
-                VM_EVENT(kvm, 5, "inject: virtio parm:%x,parm64:%lx",
+                VM_EVENT(kvm, 5, "inject: virtio parm:%x,parm64:%llx",
                         s390int->parm, s390int->parm64);
                inti->type = s390int->type;
                inti->ext.ext_params = s390int->parm;
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index cce40ff2913b..3605df45dd41 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -118,7 +118,7 @@ static int handle_store_cpu_address(struct kvm_vcpu *vcpu)
                goto out;
        }
-        VCPU_EVENT(vcpu, 5, "storing cpu address to %lx", useraddr);
+        VCPU_EVENT(vcpu, 5, "storing cpu address to %llx", useraddr);
 out:
        return 0;
 }
diff --git a/arch/sh/drivers/pci/ops-cayman.c b/arch/sh/drivers/pci/ops-cayman.c
index 5ccf9ea3a9de..38ef76207af6 100644
--- a/arch/sh/drivers/pci/ops-cayman.c
+++ b/arch/sh/drivers/pci/ops-cayman.c
@@ -5,11 +5,6 @@
 #include <cpu/irq.h>
 #include "pci-sh5.h"
-static inline u8 bridge_swizzle(u8 pin, u8 slot)
-{
-        return (((pin - 1) + slot) % 4) + 1;
-}
 int __init pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin)
 {
        int result = -1;
@@ -42,7 +37,7 @@ int __init pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin)
        while (dev->bus->number > 0) {
                slot = path[i].slot = PCI_SLOT(dev->devfn);
-                pin = path[i].pin = bridge_swizzle(pin, slot);
+                pin = path[i].pin = pci_swizzle_interrupt_pin(dev, pin);
                dev = dev->bus->self;
                i++;
                if (i > 3) panic("PCI path to root bus too long!\n");
@@ -56,7 +51,7 @@ int __init pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin)
        if ((slot < 3) || (i == 0)) {
                /* Bus 0 (incl. PCI-PCI bridge itself) : perform the final
                   swizzle now. */
-                result = IRQ_INTA + bridge_swizzle(pin, slot) - 1;
+                result = IRQ_INTA + pci_swizzle_interrupt_pin(dev, pin) - 1;
        } else {
                i--;
                slot = path[i].slot;
diff --git a/arch/sh/drivers/pci/pci.c b/arch/sh/drivers/pci/pci.c
index d3839e609aac..e36c7b870861 100644
--- a/arch/sh/drivers/pci/pci.c
+++ b/arch/sh/drivers/pci/pci.c
@@ -21,26 +21,6 @@
 #include <linux/init.h>
 #include <asm/io.h>
-static inline u8 bridge_swizzle(u8 pin, u8 slot)
-{
-        return (((pin - 1) + slot) % 4) + 1;
-}
-static u8 __init simple_swizzle(struct pci_dev *dev, u8 *pinp)
-{
-        u8 pin = *pinp;
-        while (dev->bus->parent) {
-                pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
-                /* Move up the chain of bridges. */
-                dev = dev->bus->self;
-        }
-        *pinp = pin;
-        /* The slot is the slot of the last bridge. */
-        return PCI_SLOT(dev->devfn);
-}
 static int __init pcibios_init(void)
 {
        struct pci_channel *p;
@@ -61,7 +41,7 @@ static int __init pcibios_init(void)
                busno = bus->subordinate + 1;
        }
-        pci_fixup_irqs(simple_swizzle, pcibios_map_platform_irq);
+        pci_fixup_irqs(pci_common_swizzle, pcibios_map_platform_irq);
        return 0;
 }
diff --git a/arch/sh/include/asm/mmu.h b/arch/sh/include/asm/mmu.h
index fdcb93bc6d11..6c43625bb1a5 100644
--- a/arch/sh/include/asm/mmu.h
+++ b/arch/sh/include/asm/mmu.h
@@ -9,7 +9,6 @@ typedef struct {
        mm_context_id_t         id;
        void                    *vdso;
 #else
-        struct vm_list_struct   *vmlist;
        unsigned long           end_brk;
 #endif
 #ifdef CONFIG_BINFMT_ELF_FDPIC
diff --git a/arch/sparc/include/asm/timer_64.h b/arch/sparc/include/asm/timer_64.h
index 5b779fd1f788..ef3c3682debf 100644
--- a/arch/sparc/include/asm/timer_64.h
+++ b/arch/sparc/include/asm/timer_64.h
@@ -10,7 +10,7 @@
 #include <linux/init.h>
 struct sparc64_tick_ops {
-        unsigned long (*get_tick)(void);
+        unsigned long long (*get_tick)(void);
        int (*add_compare)(unsigned long);
        unsigned long softint_mask;
        void (*disable_irq)(void);
diff --git a/arch/sparc/include/asm/types.h b/arch/sparc/include/asm/types.h
index 8c28fde5eaa2..2237118825d0 100644
--- a/arch/sparc/include/asm/types.h
+++ b/arch/sparc/include/asm/types.h
@@ -11,7 +11,7 @@
 #if defined(__sparc__) && defined(__arch64__)
 /*** SPARC 64 bit ***/
-#include <asm-generic/int-l64.h>
+#include <asm-generic/int-ll64.h>
 #ifndef __ASSEMBLY__
diff --git a/arch/sparc/kernel/ds.c b/arch/sparc/kernel/ds.c
index f52e0534d91d..57c39843fb2a 100644
--- a/arch/sparc/kernel/ds.c
+++ b/arch/sparc/kernel/ds.c
@@ -286,7 +286,7 @@ static void md_update_data(struct ds_info *dp,
        rp = (struct ds_md_update_req *) (dpkt + 1);
-        printk(KERN_INFO "ds-%lu: Machine description update.\n", dp->id);
+        printk(KERN_INFO "ds-%llu: Machine description update.\n", dp->id);
        mdesc_update();
@@ -325,7 +325,7 @@ static void domain_shutdown_data(struct ds_info *dp,
        rp = (struct ds_shutdown_req *) (dpkt + 1);
-        printk(KERN_ALERT "ds-%lu: Shutdown request from "
+        printk(KERN_ALERT "ds-%llu: Shutdown request from "
               "LDOM manager received.\n", dp->id);
        memset(&pkt, 0, sizeof(pkt));
@@ -365,7 +365,7 @@ static void domain_panic_data(struct ds_info *dp,
        rp = (struct ds_panic_req *) (dpkt + 1);
-        printk(KERN_ALERT "ds-%lu: Panic request from "
+        printk(KERN_ALERT "ds-%llu: Panic request from "
               "LDOM manager received.\n", dp->id);
        memset(&pkt, 0, sizeof(pkt));
@@ -549,7 +549,7 @@ static int __cpuinit dr_cpu_configure(struct ds_info *dp,
        for_each_cpu_mask(cpu, *mask) {
                int err;
-                printk(KERN_INFO "ds-%lu: Starting cpu %d...\n",
+                printk(KERN_INFO "ds-%llu: Starting cpu %d...\n",
                       dp->id, cpu);
                err = cpu_up(cpu);
                if (err) {
@@ -565,7 +565,7 @@ static int __cpuinit dr_cpu_configure(struct ds_info *dp,
                                res = DR_CPU_RES_CPU_NOT_RESPONDING;
                        }
-                        printk(KERN_INFO "ds-%lu: CPU startup failed err=%d\n",
+                        printk(KERN_INFO "ds-%llu: CPU startup failed err=%d\n",
                               dp->id, err);
                        dr_cpu_mark(resp, cpu, ncpus, res, stat);
                }
@@ -605,7 +605,7 @@ static int dr_cpu_unconfigure(struct ds_info *dp,
        for_each_cpu_mask(cpu, *mask) {
                int err;
-                printk(KERN_INFO "ds-%lu: Shutting down cpu %d...\n",
+                printk(KERN_INFO "ds-%llu: Shutting down cpu %d...\n",
                       dp->id, cpu);
                err = cpu_down(cpu);
                if (err)
@@ -684,7 +684,7 @@ static void ds_pri_data(struct ds_info *dp,
        rp = (struct ds_pri_msg *) (dpkt + 1);
-        printk(KERN_INFO "ds-%lu: PRI REQ [%lx:%lx], len=%d\n",
+        printk(KERN_INFO "ds-%llu: PRI REQ [%llx:%llx], len=%d\n",
               dp->id, rp->req_num, rp->type, len);
 }
@@ -816,7 +816,7 @@ void ldom_set_var(const char *var, const char *value)
                if (ds_var_doorbell == 0 ||
                    ds_var_response != DS_VAR_SUCCESS)
-                        printk(KERN_ERR "ds-%lu: var-config [%s:%s] "
+                        printk(KERN_ERR "ds-%llu: var-config [%s:%s] "
                               "failed, response(%d).\n",
                               dp->id, var, value,
                               ds_var_response);
@@ -850,7 +850,7 @@ void ldom_power_off(void)
 static void ds_conn_reset(struct ds_info *dp)
 {
-        printk(KERN_ERR "ds-%lu: ds_conn_reset() from %p\n",
+        printk(KERN_ERR "ds-%llu: ds_conn_reset() from %p\n",
               dp->id, __builtin_return_address(0));
 }
@@ -912,11 +912,11 @@ static int ds_handshake(struct ds_info *dp, struct ds_msg_tag *pkt)
                struct ds_cap_state *cp = find_cap(dp, ap->handle);
                if (!cp) {
-                        printk(KERN_ERR "ds-%lu: REG ACK for unknown "
+                        printk(KERN_ERR "ds-%llu: REG ACK for unknown "
-                               "handle %lx\n", dp->id, ap->handle);
+                               "handle %llx\n", dp->id, ap->handle);
                        return 0;
                }
-                printk(KERN_INFO "ds-%lu: Registered %s service.\n",
+                printk(KERN_INFO "ds-%llu: Registered %s service.\n",
                       dp->id, cp->service_id);
                cp->state = CAP_STATE_REGISTERED;
        } else if (pkt->type == DS_REG_NACK) {
@@ -924,8 +924,8 @@ static int ds_handshake(struct ds_info *dp, struct ds_msg_tag *pkt)
                struct ds_cap_state *cp = find_cap(dp, np->handle);
                if (!cp) {
-                        printk(KERN_ERR "ds-%lu: REG NACK for "
+                        printk(KERN_ERR "ds-%llu: REG NACK for "
-                               "unknown handle %lx\n",
+                               "unknown handle %llx\n",
                               dp->id, np->handle);
                        return 0;
                }
@@ -982,8 +982,8 @@ static void process_ds_work(void)
                int req_len = qp->req_len;
                if (!cp) {
-                        printk(KERN_ERR "ds-%lu: Data for unknown "
+                        printk(KERN_ERR "ds-%llu: Data for unknown "
-                               "handle %lu\n",
+                               "handle %llu\n",
                               dp->id, dpkt->handle);
                        spin_lock_irqsave(&ds_lock, flags);
@@ -1085,7 +1085,7 @@ static void ds_event(void *arg, int event)
        }
        if (event != LDC_EVENT_DATA_READY) {
-                printk(KERN_WARNING "ds-%lu: Unexpected LDC event %d\n",
+                printk(KERN_WARNING "ds-%llu: Unexpected LDC event %d\n",
                       dp->id, event);
                spin_unlock_irqrestore(&ds_lock, flags);
                return;
diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
index 1cc1995531e2..d8900e1d5aad 100644
--- a/arch/sparc/kernel/iommu.c
+++ b/arch/sparc/kernel/iommu.c
@@ -434,7 +434,7 @@ static void strbuf_flush(struct strbuf *strbuf, struct iommu *iommu,
                val = iommu_read(matchreg);
                if (unlikely(val)) {
                        printk(KERN_WARNING "strbuf_flush: ctx flush "
-                               "timeout matchreg[%lx] ctx[%lx]\n",
+                               "timeout matchreg[%llx] ctx[%lx]\n",
                               val, ctx);
                        goto do_page_flush;
                }
diff --git a/arch/sparc/kernel/ldc.c b/arch/sparc/kernel/ldc.c
index d68982330f66..6ce5d2598a09 100644
--- a/arch/sparc/kernel/ldc.c
+++ b/arch/sparc/kernel/ldc.c
@@ -625,22 +625,23 @@ static int process_ver_ack(struct ldc_channel *lp, struct ldc_version *vp)
 static int process_ver_nack(struct ldc_channel *lp, struct ldc_version *vp)
 {
        struct ldc_version *vap;
+        struct ldc_packet *p;
+        unsigned long new_tail;
-        if ((vp->major == 0 && vp->minor == 0) ||
+        if (vp->major == 0 && vp->minor == 0)
-            !(vap = find_by_major(vp->major))) {
+                return ldc_abort(lp);
+        vap = find_by_major(vp->major);
+        if (!vap)
                return ldc_abort(lp);
-        } else {
-                struct ldc_packet *p;
-                unsigned long new_tail;
-                p = handshake_compose_ctrl(lp, LDC_INFO, LDC_VERS,
+        p = handshake_compose_ctrl(lp, LDC_INFO, LDC_VERS,
                                           vap, sizeof(*vap),
                                           &new_tail);
-                if (p)
+        if (!p)
-                        return send_tx_packet(lp, p, new_tail);
+                return ldc_abort(lp);
-                else
-                        return ldc_abort(lp);
+        return send_tx_packet(lp, p, new_tail);
-        }
 }
 static int process_version(struct ldc_channel *lp,
diff --git a/arch/sparc/kernel/mdesc.c b/arch/sparc/kernel/mdesc.c
index 3c539a6d7c18..3f79f0c23a08 100644
--- a/arch/sparc/kernel/mdesc.c
+++ b/arch/sparc/kernel/mdesc.c
@@ -536,24 +536,24 @@ static void __init report_platform_properties(void)
        v = mdesc_get_property(hp, pn, "hostid", NULL);
        if (v)
-                printk("PLATFORM: hostid [%08lx]\n", *v);
+                printk("PLATFORM: hostid [%08llx]\n", *v);
        v = mdesc_get_property(hp, pn, "serial#", NULL);
        if (v)
-                printk("PLATFORM: serial# [%08lx]\n", *v);
+                printk("PLATFORM: serial# [%08llx]\n", *v);
        v = mdesc_get_property(hp, pn, "stick-frequency", NULL);
-        printk("PLATFORM: stick-frequency [%08lx]\n", *v);
+        printk("PLATFORM: stick-frequency [%08llx]\n", *v);
        v = mdesc_get_property(hp, pn, "mac-address", NULL);
        if (v)
-                printk("PLATFORM: mac-address [%lx]\n", *v);
+                printk("PLATFORM: mac-address [%llx]\n", *v);
        v = mdesc_get_property(hp, pn, "watchdog-resolution", NULL);
        if (v)
-                printk("PLATFORM: watchdog-resolution [%lu ms]\n", *v);
+                printk("PLATFORM: watchdog-resolution [%llu ms]\n", *v);
        v = mdesc_get_property(hp, pn, "watchdog-max-timeout", NULL);
        if (v)
-                printk("PLATFORM: watchdog-max-timeout [%lu ms]\n", *v);
+                printk("PLATFORM: watchdog-max-timeout [%llu ms]\n", *v);
        v = mdesc_get_property(hp, pn, "max-cpus", NULL);
        if (v)
-                printk("PLATFORM: max-cpus [%lu]\n", *v);
+                printk("PLATFORM: max-cpus [%llu]\n", *v);
 #ifdef CONFIG_SMP
        {
diff --git a/arch/sparc/kernel/of_device_64.c b/arch/sparc/kernel/of_device_64.c
index 4873f28905b0..b4a12c9aa5f8 100644
--- a/arch/sparc/kernel/of_device_64.c
+++ b/arch/sparc/kernel/of_device_64.c
@@ -554,7 +554,7 @@ static void __init build_device_resources(struct of_device *op,
                memset(r, 0, sizeof(*r));
                if (of_resource_verbose)
-                        printk("%s reg[%d] -> %lx\n",
+                        printk("%s reg[%d] -> %llx\n",
                               op->node->full_name, index,
                               result);
diff --git a/arch/sparc/kernel/pci.c b/arch/sparc/kernel/pci.c
index bdb7c0a6d83d..923e9bbb9fe2 100644
--- a/arch/sparc/kernel/pci.c
+++ b/arch/sparc/kernel/pci.c
@@ -223,7 +223,7 @@ static void pci_parse_of_addrs(struct of_device *op,
                        continue;
                i = addrs[0] & 0xff;
                if (ofpci_verbose)
-                        printk("  start: %lx, end: %lx, i: %x\n",
+                        printk("  start: %llx, end: %llx, i: %x\n",
                               op_res->start, op_res->end, i);
                if (PCI_BASE_ADDRESS_0 <= i && i <= PCI_BASE_ADDRESS_5) {
diff --git a/arch/sparc/kernel/pci_common.c b/arch/sparc/kernel/pci_common.c
index 23b88082d0b2..64e6edf17b9d 100644
--- a/arch/sparc/kernel/pci_common.c
+++ b/arch/sparc/kernel/pci_common.c
@@ -457,7 +457,7 @@ void pci_determine_mem_io_space(struct pci_pbm_info *pbm)
                prom_halt();
        }
-        printk("%s: PCI IO[%lx] MEM[%lx]\n",
+        printk("%s: PCI IO[%llx] MEM[%llx]\n",
               pbm->name,
               pbm->io_space.start,
               pbm->mem_space.start);
diff --git a/arch/sparc/kernel/pci_msi.c b/arch/sparc/kernel/pci_msi.c
index 4ef282e81912..f1be37a7b123 100644
--- a/arch/sparc/kernel/pci_msi.c
+++ b/arch/sparc/kernel/pci_msi.c
@@ -426,8 +426,8 @@ void sparc64_pbm_msi_init(struct pci_pbm_info *pbm,
                       pbm->name,
                       pbm->msi_first, pbm->msi_num, pbm->msi_data_mask,
                       pbm->msix_data_width);
-                printk(KERN_INFO "%s: MSI addr32[0x%lx:0x%x] "
+                printk(KERN_INFO "%s: MSI addr32[0x%llx:0x%x] "
-                       "addr64[0x%lx:0x%x]\n",
+                       "addr64[0x%llx:0x%x]\n",
                       pbm->name,
                       pbm->msi32_start, pbm->msi32_len,
                       pbm->msi64_start, pbm->msi64_len);
diff --git a/arch/sparc/kernel/pci_schizo.c b/arch/sparc/kernel/pci_schizo.c
index 45d9dba1ba11..2b5cdde77af7 100644
--- a/arch/sparc/kernel/pci_schizo.c
+++ b/arch/sparc/kernel/pci_schizo.c
@@ -794,7 +794,7 @@ static irqreturn_t schizo_safarierr_intr(int irq, void *dev_id)
                   pbm->controller_regs + SCHIZO_SAFARI_ERRLOG);
        if (!(errlog & BUS_ERROR_UNMAP)) {
-                printk("%s: Unexpected Safari/JBUS error interrupt, errlog[%016lx]\n",
+                printk("%s: Unexpected Safari/JBUS error interrupt, errlog[%016llx]\n",
                       pbm->name, errlog);
                return IRQ_HANDLED;
diff --git a/arch/sparc/kernel/pci_sun4v.c b/arch/sparc/kernel/pci_sun4v.c
index 34a1fded3941..0ef0ab3d4763 100644
--- a/arch/sparc/kernel/pci_sun4v.c
+++ b/arch/sparc/kernel/pci_sun4v.c
@@ -73,7 +73,7 @@ static long iommu_batch_flush(struct iommu_batch *p)
                if (unlikely(num < 0)) {
                        if (printk_ratelimit())
                                printk("iommu_batch_flush: IOMMU map of "
-                                       "[%08lx:%08lx:%lx:%lx:%lx] failed with "
+                                       "[%08lx:%08llx:%lx:%lx:%lx] failed with "
                                       "status %ld\n",
                                       devhandle, HV_PCI_TSBID(0, entry),
                                       npages, prot, __pa(pglist), num);
diff --git a/arch/sparc/kernel/power.c b/arch/sparc/kernel/power.c
index 076cad7f9757..ae88f06a7ec4 100644
--- a/arch/sparc/kernel/power.c
+++ b/arch/sparc/kernel/power.c
@@ -40,7 +40,7 @@ static int __devinit power_probe(struct of_device *op, const struct of_device_id
        power_reg = of_ioremap(res, 0, 0x4, "power");
-        printk(KERN_INFO "%s: Control reg at %lx\n",
+        printk(KERN_INFO "%s: Control reg at %llx\n",
               op->node->name, res->start);
        if (has_button_interrupt(irq, op->node)) {
diff --git a/arch/sparc/kernel/prom_irqtrans.c b/arch/sparc/kernel/prom_irqtrans.c
index 96958c4dce8e..5702ad4710cb 100644
--- a/arch/sparc/kernel/prom_irqtrans.c
+++ b/arch/sparc/kernel/prom_irqtrans.c
@@ -346,7 +346,7 @@ static void tomatillo_wsync_handler(unsigned int ino, void *_arg1, void *_arg2)
                        break;
        }
        if (limit <= 0) {
-                printk("tomatillo_wsync_handler: DMA won't sync [%lx:%lx]\n",
+                printk("tomatillo_wsync_handler: DMA won't sync [%llx:%llx]\n",
                       val, mask);
        }
diff --git a/arch/sparc/kernel/psycho_common.c b/arch/sparc/kernel/psycho_common.c
index 790996428c14..40689ae3c9b0 100644
--- a/arch/sparc/kernel/psycho_common.c
+++ b/arch/sparc/kernel/psycho_common.c
@@ -94,7 +94,7 @@ static void psycho_check_stc_error(struct pci_pbm_info *pbm)
                if (saw_error != 0) {
                        u64 tagval = stc_tag_buf[i];
                        u64 lineval = stc_line_buf[i];
-                        printk(KERN_ERR "%s: STC_TAG(%d)[PA(%016lx)VA(%08lx)"
+                        printk(KERN_ERR "%s: STC_TAG(%d)[PA(%016llx)VA(%08llx)"
                               "V(%d)W(%d)]\n",
                               pbm->name,
                               i,
@@ -102,8 +102,8 @@ static void psycho_check_stc_error(struct pci_pbm_info *pbm)
                               (tagval & PSYCHO_STCTAG_VPN),
                               ((tagval & PSYCHO_STCTAG_VALID) ? 1 : 0),
                               ((tagval & PSYCHO_STCTAG_WRITE) ? 1 : 0));
-                        printk(KERN_ERR "%s: STC_LINE(%d)[LIDX(%lx)SP(%lx)"
+                        printk(KERN_ERR "%s: STC_LINE(%d)[LIDX(%llx)SP(%llx)"
-                               "LADDR(%lx)EP(%lx)V(%d)FOFN(%d)]\n",
+                               "LADDR(%llx)EP(%llx)V(%d)FOFN(%d)]\n",
                               pbm->name,
                               i,
                               ((lineval & PSYCHO_STCLINE_LINDX) >> 21UL),
@@ -179,14 +179,14 @@ static void psycho_dump_iommu_tags_and_data(struct pci_pbm_info *pbm,
                }
                printk(KERN_ERR "%s: IOMMU TAG(%d)[error(%s) wr(%d) "
-                       "str(%d) sz(%dK) vpg(%08lx)]\n",
+                       "str(%d) sz(%dK) vpg(%08llx)]\n",
                       pbm->name, i, type_str,
                       ((tag_val & PSYCHO_IOMMU_TAG_WRITE) ? 1 : 0),
                       ((tag_val & PSYCHO_IOMMU_TAG_STREAM) ? 1 : 0),
                       ((tag_val & PSYCHO_IOMMU_TAG_SIZE) ? 64 : 8),
                       (tag_val & PSYCHO_IOMMU_TAG_VPAGE) << IOMMU_PAGE_SHIFT);
                printk(KERN_ERR "%s: IOMMU DATA(%d)[valid(%d) cache(%d) "
-                       "ppg(%016lx)]\n",
+                       "ppg(%016llx)]\n",
                       pbm->name, i,
                       ((data_val & PSYCHO_IOMMU_DATA_VALID) ? 1 : 0),
                       ((data_val & PSYCHO_IOMMU_DATA_CACHE) ? 1 : 0),
@@ -326,12 +326,12 @@ irqreturn_t psycho_pcierr_intr(int irq, void *dev_id)
                   "Excessive Retries" :
                   ((error_bits & PSYCHO_PCIAFSR_PPERR) ?
                    "Parity Error" : "???"))))));
-        printk(KERN_ERR "%s: bytemask[%04lx] UPA_MID[%02lx] was_block(%d)\n",
+        printk(KERN_ERR "%s: bytemask[%04llx] UPA_MID[%02llx] was_block(%d)\n",
               pbm->name,
               (afsr & PSYCHO_PCIAFSR_BMSK) >> 32UL,
               (afsr & PSYCHO_PCIAFSR_MID) >> 25UL,
               (afsr & PSYCHO_PCIAFSR_BLK) ? 1 : 0);
-        printk(KERN_ERR "%s: PCI AFAR [%016lx]\n", pbm->name, afar);
+        printk(KERN_ERR "%s: PCI AFAR [%016llx]\n", pbm->name, afar);
        printk(KERN_ERR "%s: PCI Secondary errors [", pbm->name);
        reported = 0;
        if (afsr & PSYCHO_PCIAFSR_SMA) {
diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c
index 46329799f346..6cd1a5b65067 100644
--- a/arch/sparc/kernel/smp_64.c
+++ b/arch/sparc/kernel/smp_64.c
@@ -449,7 +449,7 @@ again:
        __asm__ __volatile__("wrpr %0, 0x0, %%pstate"
                             : : "r" (pstate));
        if (stuck == 0) {
-                printk("CPU[%d]: mondo stuckage result[%016lx]\n",
+                printk("CPU[%d]: mondo stuckage result[%016llx]\n",
                       smp_processor_id(), result);
        } else {
                udelay(2);
@@ -584,7 +584,7 @@ retry:
                        /* Busy bits will not clear, continue instead
                         * of freezing up on this cpu.
                         */
-                        printk("CPU[%d]: mondo stuckage result[%016lx]\n",
+                        printk("CPU[%d]: mondo stuckage result[%016llx]\n",
                               smp_processor_id(), dispatch_stat);
                } else {
                        int i, this_busy_nack = 0;
diff --git a/arch/sparc/kernel/sun4m_smp.c b/arch/sparc/kernel/sun4m_smp.c
index 4f8d60586b07..8040376c4890 100644
--- a/arch/sparc/kernel/sun4m_smp.c
+++ b/arch/sparc/kernel/sun4m_smp.c
@@ -54,7 +54,8 @@ extern int __smp4m_processor_id(void);
 #define SMP_PRINTK(x)
 #endif
-static inline unsigned long swap(volatile unsigned long *ptr, unsigned long val)
+static inline unsigned long
+swap_ulong(volatile unsigned long *ptr, unsigned long val)
 {
        __asm__ __volatile__("swap [%1], %0\n\t" :
                             "=&r" (val), "=&r" (ptr) :
@@ -90,7 +91,7 @@ void __cpuinit smp4m_callin(void)
         * to call the scheduler code.
         */
        /* Allow master to continue. */
-        swap(&cpu_callin_map[cpuid], 1);
+        swap_ulong(&cpu_callin_map[cpuid], 1);
        /* XXX: What's up with all the flushes? */
        local_flush_cache_all();
diff --git a/arch/sparc/kernel/time_64.c b/arch/sparc/kernel/time_64.c
index 9df8f095a8b1..54405d362148 100644
--- a/arch/sparc/kernel/time_64.c
+++ b/arch/sparc/kernel/time_64.c
@@ -106,7 +106,7 @@ static void tick_init_tick(void)
        tick_disable_irq();
 }
-static unsigned long tick_get_tick(void)
+static unsigned long long tick_get_tick(void)
 {
        unsigned long ret;
@@ -208,7 +208,7 @@ static void stick_init_tick(void)
        stick_disable_irq();
 }
-static unsigned long stick_get_tick(void)
+static unsigned long long stick_get_tick(void)
 {
        unsigned long ret;
@@ -352,7 +352,7 @@ static void hbtick_init_tick(void)
        hbtick_disable_irq();
 }
-static unsigned long hbtick_get_tick(void)
+static unsigned long long hbtick_get_tick(void)
 {
        return __hbird_read_stick() & ~TICK_PRIV_BIT;
 }
@@ -422,7 +422,7 @@ static int __devinit rtc_probe(struct of_device *op, const struct of_device_id *
 {
        struct resource *r;
-        printk(KERN_INFO "%s: RTC regs at 0x%lx\n",
+        printk(KERN_INFO "%s: RTC regs at 0x%llx\n",
               op->node->full_name, op->resource[0].start);
        /* The CMOS RTC driver only accepts IORESOURCE_IO, so cons
@@ -478,7 +478,7 @@ static struct platform_device rtc_bq4802_device = {
 static int __devinit bq4802_probe(struct of_device *op, const struct of_device_id *match)
 {
-        printk(KERN_INFO "%s: BQ4802 regs at 0x%lx\n",
+        printk(KERN_INFO "%s: BQ4802 regs at 0x%llx\n",
               op->node->full_name, op->resource[0].start);
        rtc_bq4802_device.resource = &op->resource[0];
@@ -542,7 +542,7 @@ static int __devinit mostek_probe(struct of_device *op, const struct of_device_i
            strcmp(dp->parent->parent->name, "central") != 0)
                return -ENODEV;
-        printk(KERN_INFO "%s: Mostek regs at 0x%lx\n",
+        printk(KERN_INFO "%s: Mostek regs at 0x%llx\n",
               dp->full_name, op->resource[0].start);
        m48t59_rtc.resource = &op->resource[0];
diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
index 4638af2f55a0..bca3b4e09c41 100644
--- a/arch/sparc/kernel/traps_64.c
+++ b/arch/sparc/kernel/traps_64.c
@@ -1168,20 +1168,20 @@ static void cheetah_log_errors(struct pt_regs *regs, struct cheetah_err_info *in
        }
        /* Now dump the cache snapshots. */
-        printk("%s" "ERROR(%d): D-cache idx[%x] tag[%016lx] utag[%016lx] stag[%016lx]\n",
+        printk("%s" "ERROR(%d): D-cache idx[%x] tag[%016llx] utag[%016llx] stag[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               (int) info->dcache_index,
               info->dcache_tag,
               info->dcache_utag,
               info->dcache_stag);
-        printk("%s" "ERROR(%d): D-cache data0[%016lx] data1[%016lx] data2[%016lx] data3[%016lx]\n",
+        printk("%s" "ERROR(%d): D-cache data0[%016llx] data1[%016llx] data2[%016llx] data3[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->dcache_data[0],
               info->dcache_data[1],
               info->dcache_data[2],
               info->dcache_data[3]);
-        printk("%s" "ERROR(%d): I-cache idx[%x] tag[%016lx] utag[%016lx] stag[%016lx] "
+        printk("%s" "ERROR(%d): I-cache idx[%x] tag[%016llx] utag[%016llx] stag[%016llx] "
-               "u[%016lx] l[%016lx]\n",
+               "u[%016llx] l[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               (int) info->icache_index,
               info->icache_tag,
@@ -1189,22 +1189,22 @@ static void cheetah_log_errors(struct pt_regs *regs, struct cheetah_err_info *in
               info->icache_stag,
               info->icache_upper,
               info->icache_lower);
-        printk("%s" "ERROR(%d): I-cache INSN0[%016lx] INSN1[%016lx] INSN2[%016lx] INSN3[%016lx]\n",
+        printk("%s" "ERROR(%d): I-cache INSN0[%016llx] INSN1[%016llx] INSN2[%016llx] INSN3[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->icache_data[0],
               info->icache_data[1],
               info->icache_data[2],
               info->icache_data[3]);
-        printk("%s" "ERROR(%d): I-cache INSN4[%016lx] INSN5[%016lx] INSN6[%016lx] INSN7[%016lx]\n",
+        printk("%s" "ERROR(%d): I-cache INSN4[%016llx] INSN5[%016llx] INSN6[%016llx] INSN7[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->icache_data[4],
               info->icache_data[5],
               info->icache_data[6],
               info->icache_data[7]);
-        printk("%s" "ERROR(%d): E-cache idx[%x] tag[%016lx]\n",
+        printk("%s" "ERROR(%d): E-cache idx[%x] tag[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               (int) info->ecache_index, info->ecache_tag);
-        printk("%s" "ERROR(%d): E-cache data0[%016lx] data1[%016lx] data2[%016lx] data3[%016lx]\n",
+        printk("%s" "ERROR(%d): E-cache data0[%016llx] data1[%016llx] data2[%016llx] data3[%016llx]\n",
               (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
               info->ecache_data[0],
               info->ecache_data[1],
@@ -1794,7 +1794,7 @@ static void sun4v_log_error(struct pt_regs *regs, struct sun4v_error_entry *ent,
        int cnt;
        printk("%s: Reporting on cpu %d\n", pfx, cpu);
-        printk("%s: err_handle[%lx] err_stick[%lx] err_type[%08x:%s]\n",
+        printk("%s: err_handle[%llx] err_stick[%llx] err_type[%08x:%s]\n",
               pfx,
               ent->err_handle, ent->err_stick,
               ent->err_type,
@@ -1818,7 +1818,7 @@ static void sun4v_log_error(struct pt_regs *regs, struct sun4v_error_entry *ent,
                "privileged" : ""),
               ((ent->err_attrs & SUN4V_ERR_ATTRS_RES_QUEUE_FULL) ?
                "queue-full" : ""));
-        printk("%s: err_raddr[%016lx] err_size[%u] err_cpu[%u]\n",
+        printk("%s: err_raddr[%016llx] err_size[%u] err_cpu[%u]\n",
               pfx,
               ent->err_raddr, ent->err_size, ent->err_cpu);
diff --git a/arch/sparc/kernel/unaligned_64.c b/arch/sparc/kernel/unaligned_64.c
index 203ddfad9f27..f164d5a850f9 100644
--- a/arch/sparc/kernel/unaligned_64.c
+++ b/arch/sparc/kernel/unaligned_64.c
@@ -601,11 +601,15 @@ void handle_lddfmna(struct pt_regs *regs, unsigned long sfar, unsigned long sfsr
                pc = (u32)pc;
        if (get_user(insn, (u32 __user *) pc) != -EFAULT) {
                int asi = decode_asi(insn, regs);
+                int err;
                if ((asi > ASI_SNFL) ||
                    (asi < ASI_P))
                        goto daex;
-                if (get_user(first, (u32 __user *)sfar) ||
+                err = get_user(first, (u32 __user *)sfar);
-                     get_user(second, (u32 __user *)(sfar + 4))) {
+                if (!err)
+                        err = get_user(second, (u32 __user *)(sfar + 4));
+                if (err) {
                        if (asi & 0x2) /* NF */ {
                                first = 0; second = 0;
                        } else
diff --git a/arch/sparc/kernel/vio.c b/arch/sparc/kernel/vio.c
index 92b1f8ec01de..753d128ed158 100644
--- a/arch/sparc/kernel/vio.c
+++ b/arch/sparc/kernel/vio.c
@@ -263,10 +263,10 @@ static struct vio_dev *vio_create_one(struct mdesc_handle *hp, u64 mp,
                dev_set_name(&vdev->dev, "%s", bus_id_name);
                vdev->dev_no = ~(u64)0;
        } else if (!cfg_handle) {
-                dev_set_name(&vdev->dev, "%s-%lu", bus_id_name, *id);
+                dev_set_name(&vdev->dev, "%s-%llu", bus_id_name, *id);
                vdev->dev_no = *id;
        } else {
-                dev_set_name(&vdev->dev, "%s-%lu-%lu", bus_id_name,
+                dev_set_name(&vdev->dev, "%s-%llu-%llu", bus_id_name,
                             *cfg_handle, *id);
                vdev->dev_no = *cfg_handle;
        }
diff --git a/arch/sparc/kernel/viohs.c b/arch/sparc/kernel/viohs.c
index 708fa1705fbe..aa6ac70d4fd5 100644
--- a/arch/sparc/kernel/viohs.c
+++ b/arch/sparc/kernel/viohs.c
@@ -337,8 +337,10 @@ static int process_ver_nack(struct vio_driver_state *vio,
        viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
               pkt->major, pkt->minor, pkt->dev_class);
-        if ((pkt->major == 0 && pkt->minor == 0) ||
+        if (pkt->major == 0 && pkt->minor == 0)
-            !(nver = find_by_major(vio, pkt->major)))
+                return handshake_failure(vio);
+        nver = find_by_major(vio, pkt->major);
+        if (!nver)
                return handshake_failure(vio);
        if (send_version(vio, nver->major, nver->minor) < 0)
diff --git a/arch/sparc/mm/fault_32.c b/arch/sparc/mm/fault_32.c
index a507e1174662..12e447fc8542 100644
--- a/arch/sparc/mm/fault_32.c
+++ b/arch/sparc/mm/fault_32.c
@@ -283,7 +283,8 @@ bad_area_nosemaphore:
        /* Is this in ex_table? */
 no_context:
        g2 = regs->u_regs[UREG_G2];
-        if (!from_user && (fixup = search_extables_range(regs->pc, &g2))) {
+        if (!from_user) {
+                fixup = search_extables_range(regs->pc, &g2);
                if (fixup > 10) { /* Values below are reserved for other things */
                        extern const unsigned __memset_start[];
                        extern const unsigned __memset_end[];
diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 6ea73da29312..c77c7ef5d5d4 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -258,21 +258,16 @@ static inline void tsb_insert(struct tsb *ent, unsigned long tag, unsigned long
 unsigned long _PAGE_ALL_SZ_BITS __read_mostly;
 unsigned long _PAGE_SZBITS __read_mostly;
-void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t pte)
+static void flush_dcache(unsigned long pfn)
 {
-        struct mm_struct *mm;
+        struct page *page;
-        struct tsb *tsb;
-        unsigned long tag, flags;
-        unsigned long tsb_index, tsb_hash_shift;
-        if (tlb_type != hypervisor) {
+        page = pfn_to_page(pfn);
-                unsigned long pfn = pte_pfn(pte);
+        if (page && page_mapping(page)) {
                unsigned long pg_flags;
-                struct page *page;
-                if (pfn_valid(pfn) &&
+                pg_flags = page->flags;
-                    (page = pfn_to_page(pfn), page_mapping(page)) &&
+                if (pg_flags & (1UL << PG_dcache_dirty)) {
-                    ((pg_flags = page->flags) & (1UL << PG_dcache_dirty))) {
                        int cpu = ((pg_flags >> PG_dcache_cpu_shift) &
                                   PG_dcache_cpu_mask);
                        int this_cpu = get_cpu();
@@ -290,6 +285,21 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t p
                        put_cpu();
                }
        }
+}
+void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t pte)
+{
+        struct mm_struct *mm;
+        struct tsb *tsb;
+        unsigned long tag, flags;
+        unsigned long tsb_index, tsb_hash_shift;
+        if (tlb_type != hypervisor) {
+                unsigned long pfn = pte_pfn(pte);
+                if (pfn_valid(pfn))
+                        flush_dcache(pfn);
+        }
        mm = vma->vm_mm;
@@ -769,8 +779,8 @@ static int find_node(unsigned long addr)
        return -1;
 }
-static unsigned long nid_range(unsigned long start, unsigned long end,
+static unsigned long long nid_range(unsigned long long start,
-                               int *nid)
+                                    unsigned long long end, int *nid)
 {
        *nid = find_node(start);
        start += PAGE_SIZE;
@@ -788,8 +798,8 @@ static unsigned long nid_range(unsigned long start, unsigned long end,
        return start;
 }
 #else
-static unsigned long nid_range(unsigned long start, unsigned long end,
+static unsigned long long nid_range(unsigned long long start,
-                               int *nid)
+                                    unsigned long long end, int *nid)
 {
        *nid = 0;
        return end;
@@ -1016,8 +1026,8 @@ static int __init grab_mlgroups(struct mdesc_handle *md)
                val = mdesc_get_property(md, node, "address-mask", NULL);
                m->mask = *val;
-                numadbg("MLGROUP[%d]: node[%lx] latency[%lx] "
+                numadbg("MLGROUP[%d]: node[%llx] latency[%llx] "
-                        "match[%lx] mask[%lx]\n",
+                        "match[%llx] mask[%llx]\n",
                        count - 1, m->node, m->latency, m->match, m->mask);
        }
@@ -1056,7 +1066,7 @@ static int __init grab_mblocks(struct mdesc_handle *md)
                                         "address-congruence-offset", NULL);
                m->offset = *val;
-                numadbg("MBLOCK[%d]: base[%lx] size[%lx] offset[%lx]\n",
+                numadbg("MBLOCK[%d]: base[%llx] size[%llx] offset[%llx]\n",
                        count - 1, m->base, m->size, m->offset);
        }
@@ -1127,7 +1137,7 @@ static int __init numa_attach_mlgroup(struct mdesc_handle *md, u64 grp,
        n->mask = candidate->mask;
        n->val = candidate->match;
-        numadbg("NUMA NODE[%d]: mask[%lx] val[%lx] (latency[%lx])\n",
+        numadbg("NUMA NODE[%d]: mask[%lx] val[%lx] (latency[%llx])\n",
                index, n->mask, n->val, candidate->latency);
        return 0;
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 862adb9bf0d4..73f7fe8fd4d1 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -27,6 +27,7 @@ config X86
        select HAVE_IOREMAP_PROT
        select HAVE_KPROBES
        select ARCH_WANT_OPTIONAL_GPIOLIB
+        select ARCH_WANT_FRAME_POINTERS
        select HAVE_KRETPROBES
        select HAVE_FTRACE_MCOUNT_RECORD
        select HAVE_DYNAMIC_FTRACE
diff --git a/arch/x86/include/asm/bitops.h b/arch/x86/include/asm/bitops.h
index 9fa9dcdf344b..e02a359d2aa5 100644
--- a/arch/x86/include/asm/bitops.h
+++ b/arch/x86/include/asm/bitops.h
@@ -300,7 +300,7 @@ static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
        return oldbit;
 }
-static inline int constant_test_bit(int nr, const volatile unsigned long *addr)
+static inline int constant_test_bit(unsigned int nr, const volatile unsigned long *addr)
 {
        return ((1UL << (nr % BITS_PER_LONG)) &
                (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0;
diff --git a/arch/x86/include/asm/es7000/apic.h b/arch/x86/include/asm/es7000/apic.h
index bc53d5ef1386..c58b9cc74465 100644
--- a/arch/x86/include/asm/es7000/apic.h
+++ b/arch/x86/include/asm/es7000/apic.h
@@ -1,6 +1,8 @@
 #ifndef __ASM_ES7000_APIC_H
 #define __ASM_ES7000_APIC_H
+#include <linux/gfp.h>
 #define xapic_phys_to_log_apicid(cpu) per_cpu(x86_bios_cpu_apicid, cpu)
 #define esr_disable (1)
diff --git a/arch/x86/include/asm/es7000/mpparse.h b/arch/x86/include/asm/es7000/mpparse.h
index ed5a3caae141..c1629b090ec2 100644
--- a/arch/x86/include/asm/es7000/mpparse.h
+++ b/arch/x86/include/asm/es7000/mpparse.h
@@ -10,8 +10,7 @@ extern void setup_unisys(void);
 #ifndef CONFIG_X86_GENERICARCH
 extern int acpi_madt_oem_check(char *oem_id, char *oem_table_id);
-extern int mps_oem_check(struct mp_config_table *mpc, char *oem,
+extern int mps_oem_check(struct mpc_table *mpc, char *oem, char *productid);
-                                char *productid);
 #endif
 #ifdef CONFIG_ACPI
diff --git a/arch/x86/include/asm/genapic_32.h b/arch/x86/include/asm/genapic_32.h
index 746f37a7963a..2c05b737ee22 100644
--- a/arch/x86/include/asm/genapic_32.h
+++ b/arch/x86/include/asm/genapic_32.h
@@ -15,9 +15,9 @@
 * Copyright 2003 Andi Kleen, SuSE Labs.
 */
-struct mpc_config_bus;
+struct mpc_bus;
-struct mp_config_table;
+struct mpc_table;
-struct mpc_config_processor;
+struct mpc_cpu;
 struct genapic {
        char *name;
@@ -51,7 +51,7 @@ struct genapic {
        /* When one of the next two hooks returns 1 the genapic
           is switched to this. Essentially they are additional probe
           functions. */
-        int (*mps_oem_check)(struct mp_config_table *mpc, char *oem,
+        int (*mps_oem_check)(struct mpc_table *mpc, char *oem,
                             char *productid);
        int (*acpi_madt_oem_check)(char *oem_id, char *oem_table_id);
diff --git a/arch/x86/include/asm/mach-default/mach_mpparse.h b/arch/x86/include/asm/mach-default/mach_mpparse.h
index 8c1ea21238a7..c70a263d68cd 100644
--- a/arch/x86/include/asm/mach-default/mach_mpparse.h
+++ b/arch/x86/include/asm/mach-default/mach_mpparse.h
@@ -1,8 +1,8 @@
 #ifndef _ASM_X86_MACH_DEFAULT_MACH_MPPARSE_H
 #define _ASM_X86_MACH_DEFAULT_MACH_MPPARSE_H
-static inline int mps_oem_check(struct mp_config_table *mpc, char *oem, 
+static inline int
-                char *productid)
+mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
 {
        return 0;
 }
diff --git a/arch/x86/include/asm/mach-generic/mach_mpparse.h b/arch/x86/include/asm/mach-generic/mach_mpparse.h
index 048f1d468535..9444ab8dca94 100644
--- a/arch/x86/include/asm/mach-generic/mach_mpparse.h
+++ b/arch/x86/include/asm/mach-generic/mach_mpparse.h
@@ -2,9 +2,8 @@
 #define _ASM_X86_MACH_GENERIC_MACH_MPPARSE_H
-extern int mps_oem_check(struct mp_config_table *mpc, char *oem,
+extern int mps_oem_check(struct mpc_table *, char *, char *);
-                         char *productid);
-extern int acpi_madt_oem_check(char *oem_id, char *oem_table_id);
+extern int acpi_madt_oem_check(char *, char *);
 #endif /* _ASM_X86_MACH_GENERIC_MACH_MPPARSE_H */
diff --git a/arch/x86/include/asm/mach-generic/mach_mpspec.h b/arch/x86/include/asm/mach-generic/mach_mpspec.h
index bbab5ccfd4fe..3bc407226578 100644
--- a/arch/x86/include/asm/mach-generic/mach_mpspec.h
+++ b/arch/x86/include/asm/mach-generic/mach_mpspec.h
@@ -7,6 +7,6 @@
 /* Maximum 256 PCI busses, plus 1 ISA bus in each of 4 cabinets. */
 #define MAX_MP_BUSSES 260
-extern void numaq_mps_oem_check(struct mp_config_table *mpc, char *oem,
+extern void numaq_mps_oem_check(struct mpc_table *, char *, char *);
-                                char *productid);
 #endif /* _ASM_X86_MACH_GENERIC_MACH_MPSPEC_H */
diff --git a/arch/x86/include/asm/mpspec_def.h b/arch/x86/include/asm/mpspec_def.h
index e3ace7d1d35d..59568bc4767f 100644
--- a/arch/x86/include/asm/mpspec_def.h
+++ b/arch/x86/include/asm/mpspec_def.h
@@ -39,17 +39,17 @@ struct intel_mp_floating {
 #define MPC_SIGNATURE "PCMP"
-struct mp_config_table {
+struct mpc_table {
-        char mpc_signature[4];
+        char signature[4];
-        unsigned short mpc_length;      /* Size of table */
+        unsigned short length;          /* Size of table */
-        char mpc_spec;                  /* 0x01 */
+        char spec;                      /* 0x01 */
-        char mpc_checksum;
+        char checksum;
-        char mpc_oem[8];
+        char oem[8];
-        char mpc_productid[12];
+        char productid[12];
-        unsigned int mpc_oemptr;        /* 0 if not present */
+        unsigned int oemptr;            /* 0 if not present */
-        unsigned short mpc_oemsize;     /* 0 if not present */
+        unsigned short oemsize;         /* 0 if not present */
-        unsigned short mpc_oemcount;
+        unsigned short oemcount;
-        unsigned int mpc_lapic; /* APIC address */
+        unsigned int lapic;             /* APIC address */
        unsigned int reserved;
 };
@@ -70,20 +70,20 @@ struct mp_config_table {
 #define CPU_MODEL_MASK          0x00F0
 #define CPU_FAMILY_MASK         0x0F00
-struct mpc_config_processor {
+struct mpc_cpu {
-        unsigned char mpc_type;
+        unsigned char type;
-        unsigned char mpc_apicid;       /* Local APIC number */
+        unsigned char apicid;           /* Local APIC number */
-        unsigned char mpc_apicver;      /* Its versions */
+        unsigned char apicver;          /* Its versions */
-        unsigned char mpc_cpuflag;
+        unsigned char cpuflag;
-        unsigned int mpc_cpufeature;
+        unsigned int cpufeature;
-        unsigned int mpc_featureflag;   /* CPUID feature value */
+        unsigned int featureflag;       /* CPUID feature value */
-        unsigned int mpc_reserved[2];
+        unsigned int reserved[2];
 };
-struct mpc_config_bus {
+struct mpc_bus {
-        unsigned char mpc_type;
+        unsigned char type;
-        unsigned char mpc_busid;
+        unsigned char busid;
-        unsigned char mpc_bustype[6];
+        unsigned char bustype[6];
 };
 /* List of Bus Type string values, Intel MP Spec. */
@@ -108,22 +108,22 @@ struct mpc_config_bus {
 #define MPC_APIC_USABLE         0x01
-struct mpc_config_ioapic {
+struct mpc_ioapic {
-        unsigned char mpc_type;
+        unsigned char type;
-        unsigned char mpc_apicid;
+        unsigned char apicid;
-        unsigned char mpc_apicver;
+        unsigned char apicver;
-        unsigned char mpc_flags;
+        unsigned char flags;
-        unsigned int mpc_apicaddr;
+        unsigned int apicaddr;
 };
-struct mpc_config_intsrc {
+struct mpc_intsrc {
-        unsigned char mpc_type;
+        unsigned char type;
-        unsigned char mpc_irqtype;
+        unsigned char irqtype;
-        unsigned short mpc_irqflag;
+        unsigned short irqflag;
-        unsigned char mpc_srcbus;
+        unsigned char srcbus;
-        unsigned char mpc_srcbusirq;
+        unsigned char srcbusirq;
-        unsigned char mpc_dstapic;
+        unsigned char dstapic;
-        unsigned char mpc_dstirq;
+        unsigned char dstirq;
 };
 enum mp_irq_source_types {
@@ -139,24 +139,24 @@ enum mp_irq_source_types {
 #define MP_APIC_ALL     0xFF
-struct mpc_config_lintsrc {
+struct mpc_lintsrc {
-        unsigned char mpc_type;
+        unsigned char type;
-        unsigned char mpc_irqtype;
+        unsigned char irqtype;
-        unsigned short mpc_irqflag;
+        unsigned short irqflag;
-        unsigned char mpc_srcbusid;
+        unsigned char srcbusid;
-        unsigned char mpc_srcbusirq;
+        unsigned char srcbusirq;
-        unsigned char mpc_destapic;
+        unsigned char destapic;
-        unsigned char mpc_destapiclint;
+        unsigned char destapiclint;
 };
 #define MPC_OEM_SIGNATURE "_OEM"
-struct mp_config_oemtable {
+struct mpc_oemtable {
-        char oem_signature[4];
+        char signature[4];
-        unsigned short oem_length;      /* Size of table */
+        unsigned short length;          /* Size of table */
-        char  oem_rev;                  /* 0x01 */
+        char  rev;                      /* 0x01 */
-        char  oem_checksum;
+        char  checksum;
-        char  mpc_oem[8];
+        char  mpc[8];
 };
 /*
diff --git a/arch/x86/include/asm/numaq/mpparse.h b/arch/x86/include/asm/numaq/mpparse.h
index 252292e077b6..a2eeefcd1cc7 100644
--- a/arch/x86/include/asm/numaq/mpparse.h
+++ b/arch/x86/include/asm/numaq/mpparse.h
@@ -1,7 +1,6 @@
 #ifndef __ASM_NUMAQ_MPPARSE_H
 #define __ASM_NUMAQ_MPPARSE_H
-extern void numaq_mps_oem_check(struct mp_config_table *mpc, char *oem,
+extern void numaq_mps_oem_check(struct mpc_table *, char *, char *);
-                                char *productid);
 #endif /* __ASM_NUMAQ_MPPARSE_H */
diff --git a/arch/x86/include/asm/setup.h b/arch/x86/include/asm/setup.h
index 4fcd53fd5f43..ebe858cdc8a3 100644
--- a/arch/x86/include/asm/setup.h
+++ b/arch/x86/include/asm/setup.h
@@ -25,9 +25,9 @@ extern int wakeup_secondary_cpu_via_init(int apicid, unsigned long start_eip);
 /*
 * Any setup quirks to be performed?
 */
-struct mpc_config_processor;
+struct mpc_cpu;
-struct mpc_config_bus;
+struct mpc_bus;
-struct mp_config_oemtable;
+struct mpc_oemtable;
 struct x86_quirks {
        int (*arch_pre_time_init)(void);
        int (*arch_time_init)(void);
@@ -39,10 +39,10 @@ struct x86_quirks {
        int (*mach_find_smp_config)(unsigned int reserve);
        int *mpc_record;
-        int (*mpc_apic_id)(struct mpc_config_processor *m);
+        int (*mpc_apic_id)(struct mpc_cpu *m);
-        void (*mpc_oem_bus_info)(struct mpc_config_bus *m, char *name);
+        void (*mpc_oem_bus_info)(struct mpc_bus *m, char *name);
-        void (*mpc_oem_pci_bus)(struct mpc_config_bus *m);
+        void (*mpc_oem_pci_bus)(struct mpc_bus *m);
-        void (*smp_read_mpc_oem)(struct mp_config_oemtable *oemtable,
+        void (*smp_read_mpc_oem)(struct mpc_oemtable *oemtable,
                                    unsigned short oemsize);
        int (*setup_ioapic_ids)(void);
        int (*update_genapic)(void);
diff --git a/arch/x86/include/asm/smp.h b/arch/x86/include/asm/smp.h
index 830b9fcb6427..19953df61c52 100644
--- a/arch/x86/include/asm/smp.h
+++ b/arch/x86/include/asm/smp.h
@@ -18,9 +18,26 @@
 #include <asm/pda.h>
 #include <asm/thread_info.h>
+#ifdef CONFIG_X86_64
+extern cpumask_var_t cpu_callin_mask;
+extern cpumask_var_t cpu_callout_mask;
+extern cpumask_var_t cpu_initialized_mask;
+extern cpumask_var_t cpu_sibling_setup_mask;
+#else /* CONFIG_X86_32 */
+extern cpumask_t cpu_callin_map;
 extern cpumask_t cpu_callout_map;
 extern cpumask_t cpu_initialized;
-extern cpumask_t cpu_callin_map;
+extern cpumask_t cpu_sibling_setup_map;
+#define cpu_callin_mask         ((struct cpumask *)&cpu_callin_map)
+#define cpu_callout_mask        ((struct cpumask *)&cpu_callout_map)
+#define cpu_initialized_mask    ((struct cpumask *)&cpu_initialized)
+#define cpu_sibling_setup_mask  ((struct cpumask *)&cpu_sibling_setup_map)
+#endif /* CONFIG_X86_32 */
 extern void (*mtrr_hook)(void);
 extern void zap_low_mappings(void);
@@ -29,7 +46,6 @@ extern int __cpuinit get_local_pda(int cpu);
 extern int smp_num_siblings;
 extern unsigned int num_processors;
-extern cpumask_t cpu_initialized;
 DECLARE_PER_CPU(cpumask_t, cpu_sibling_map);
 DECLARE_PER_CPU(cpumask_t, cpu_core_map);
@@ -38,6 +54,16 @@ DECLARE_PER_CPU(u16, cpu_llc_id);
 DECLARE_PER_CPU(int, cpu_number);
 #endif
+static inline struct cpumask *cpu_sibling_mask(int cpu)
+{
+        return &per_cpu(cpu_sibling_map, cpu);
+}
+static inline struct cpumask *cpu_core_mask(int cpu)
+{
+        return &per_cpu(cpu_core_map, cpu);
+}
 DECLARE_EARLY_PER_CPU(u16, x86_cpu_to_apicid);
 DECLARE_EARLY_PER_CPU(u16, x86_bios_cpu_apicid);
@@ -149,7 +175,7 @@ void smp_store_cpu_info(int id);
 /* We don't mark CPUs online until __cpu_up(), so we need another measure */
 static inline int num_booting_cpus(void)
 {
-        return cpus_weight(cpu_callout_map);
+        return cpumask_weight(cpu_callout_mask);
 }
 #else
 static inline void prefill_possible_map(void)
diff --git a/arch/x86/include/asm/summit/apic.h b/arch/x86/include/asm/summit/apic.h
index 4bb5fb34f030..93d2c8667cfe 100644
--- a/arch/x86/include/asm/summit/apic.h
+++ b/arch/x86/include/asm/summit/apic.h
@@ -2,6 +2,7 @@
 #define __ASM_SUMMIT_APIC_H
 #include <asm/smp.h>
+#include <linux/gfp.h>
 #define esr_disable (1)
 #define NO_BALANCE_IRQ (0)
diff --git a/arch/x86/include/asm/summit/mpparse.h b/arch/x86/include/asm/summit/mpparse.h
index 013ce6fab2d5..380e86c02363 100644
--- a/arch/x86/include/asm/summit/mpparse.h
+++ b/arch/x86/include/asm/summit/mpparse.h
@@ -11,7 +11,7 @@ extern void setup_summit(void);
 #define setup_summit()  {}
 #endif
-static inline int mps_oem_check(struct mp_config_table *mpc, char *oem,
+static inline int mps_oem_check(struct mpc_table *mpc, char *oem,
                char *productid)
 {
        if (!strncmp(oem, "IBM ENSW", 8) &&
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 29dc0c89d4af..d37593c2f438 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -47,7 +47,7 @@
 #endif
 static int __initdata acpi_force = 0;
+u32 acpi_rsdt_forced;
 #ifdef  CONFIG_ACPI
 int acpi_disabled = 0;
 #else
@@ -1374,6 +1374,17 @@ static void __init acpi_process_madt(void)
                               "Invalid BIOS MADT, disabling ACPI\n");
                        disable_acpi();
                }
+        } else {
+                /*
+                 * ACPI found no MADT, and so ACPI wants UP PIC mode.
+                 * In the event an MPS table was found, forget it.
+                 * Boot with "acpi=off" to use MPS on such a system.
+                 */
+                if (smp_found_config) {
+                        printk(KERN_WARNING PREFIX
+                                "No APIC-table, disabling MPS\n");
+                        smp_found_config = 0;
+                }
        }
        /*
@@ -1809,6 +1820,10 @@ static int __init parse_acpi(char *arg)
                        disable_acpi();
                acpi_ht = 1;
        }
+        /* acpi=rsdt use RSDT instead of XSDT */
+        else if (strcmp(arg, "rsdt") == 0) {
+                acpi_rsdt_forced = 1;
+        }
        /* "acpi=noirq" disables ACPI interrupt routing */
        else if (strcmp(arg, "noirq") == 0) {
                acpi_noirq_set();
diff --git a/arch/x86/kernel/acpi/cstate.c b/arch/x86/kernel/acpi/cstate.c
index c2502eb9aa83..bbbe4bbb6f34 100644
--- a/arch/x86/kernel/acpi/cstate.c
+++ b/arch/x86/kernel/acpi/cstate.c
@@ -56,6 +56,7 @@ static struct cstate_entry *cpu_cstate_entry;	/* per CPU ptr */
 static short mwait_supported[ACPI_PROCESSOR_MAX_POWER];
 #define MWAIT_SUBSTATE_MASK     (0xf)
+#define MWAIT_CSTATE_MASK       (0xf)
 #define MWAIT_SUBSTATE_SIZE     (4)
 #define CPUID_MWAIT_LEAF (5)
@@ -66,39 +67,20 @@ static short mwait_supported[ACPI_PROCESSOR_MAX_POWER];
 #define NATIVE_CSTATE_BEYOND_HALT       (2)
-int acpi_processor_ffh_cstate_probe(unsigned int cpu,
+static long acpi_processor_ffh_cstate_probe_cpu(void *_cx)
-                struct acpi_processor_cx *cx, struct acpi_power_register *reg)
 {
-        struct cstate_entry *percpu_entry;
+        struct acpi_processor_cx *cx = _cx;
-        struct cpuinfo_x86 *c = &cpu_data(cpu);
+        long retval;
-        cpumask_t saved_mask;
-        int retval;
        unsigned int eax, ebx, ecx, edx;
        unsigned int edx_part;
        unsigned int cstate_type; /* C-state type and not ACPI C-state type */
        unsigned int num_cstate_subtype;
-        if (!cpu_cstate_entry || c->cpuid_level < CPUID_MWAIT_LEAF )
-                return -1;
-        if (reg->bit_offset != NATIVE_CSTATE_BEYOND_HALT)
-                return -1;
-        percpu_entry = per_cpu_ptr(cpu_cstate_entry, cpu);
-        percpu_entry->states[cx->index].eax = 0;
-        percpu_entry->states[cx->index].ecx = 0;
-        /* Make sure we are running on right CPU */
-        saved_mask = current->cpus_allowed;
-        retval = set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
-        if (retval)
-                return -1;
        cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx);
        /* Check whether this particular cx_type (in CST) is supported or not */
-        cstate_type = (cx->address >> MWAIT_SUBSTATE_SIZE) + 1;
+        cstate_type = ((cx->address >> MWAIT_SUBSTATE_SIZE) &
+                        MWAIT_CSTATE_MASK) + 1;
        edx_part = edx >> (cstate_type * MWAIT_SUBSTATE_SIZE);
        num_cstate_subtype = edx_part & MWAIT_SUBSTATE_MASK;
@@ -114,21 +96,45 @@ int acpi_processor_ffh_cstate_probe(unsigned int cpu,
                retval = -1;
                goto out;
        }
-        percpu_entry->states[cx->index].ecx = MWAIT_ECX_INTERRUPT_BREAK;
-        /* Use the hint in CST */
-        percpu_entry->states[cx->index].eax = cx->address;
        if (!mwait_supported[cstate_type]) {
                mwait_supported[cstate_type] = 1;
-                printk(KERN_DEBUG "Monitor-Mwait will be used to enter C-%d "
+                printk(KERN_DEBUG
-                       "state\n", cx->type);
+                        "Monitor-Mwait will be used to enter C-%d "
+                        "state\n", cx->type);
        }
-        snprintf(cx->desc, ACPI_CX_DESC_LEN, "ACPI FFH INTEL MWAIT 0x%x",
+        snprintf(cx->desc,
-                 cx->address);
+                        ACPI_CX_DESC_LEN, "ACPI FFH INTEL MWAIT 0x%x",
+                        cx->address);
 out:
-        set_cpus_allowed_ptr(current, &saved_mask);
+        return retval;
+}
+int acpi_processor_ffh_cstate_probe(unsigned int cpu,
+                struct acpi_processor_cx *cx, struct acpi_power_register *reg)
+{
+        struct cstate_entry *percpu_entry;
+        struct cpuinfo_x86 *c = &cpu_data(cpu);
+        long retval;
+        if (!cpu_cstate_entry || c->cpuid_level < CPUID_MWAIT_LEAF)
+                return -1;
+        if (reg->bit_offset != NATIVE_CSTATE_BEYOND_HALT)
+                return -1;
+        percpu_entry = per_cpu_ptr(cpu_cstate_entry, cpu);
+        percpu_entry->states[cx->index].eax = 0;
+        percpu_entry->states[cx->index].ecx = 0;
+        /* Make sure we are running on right CPU */
+        retval = work_on_cpu(cpu, acpi_processor_ffh_cstate_probe_cpu, cx);
+        if (retval == 0) {
+                /* Use the hint in CST */
+                percpu_entry->states[cx->index].eax = cx->address;
+                percpu_entry->states[cx->index].ecx = MWAIT_ECX_INTERRUPT_BREAK;
+        }
        return retval;
 }
 EXPORT_SYMBOL_GPL(acpi_processor_ffh_cstate_probe);
diff --git a/arch/x86/kernel/acpi/sleep.c b/arch/x86/kernel/acpi/sleep.c
index 806b4e9051b4..707c1f6f95fa 100644
--- a/arch/x86/kernel/acpi/sleep.c
+++ b/arch/x86/kernel/acpi/sleep.c
@@ -159,6 +159,8 @@ static int __init acpi_sleep_setup(char *str)
 #endif
                if (strncmp(str, "old_ordering", 12) == 0)
                        acpi_old_suspend_ordering();
+                if (strncmp(str, "s4_nonvs", 8) == 0)
+                        acpi_s4_no_nvs();
                str = strchr(str, ',');
                if (str != NULL)
                        str += strspn(str, ", \t");
diff --git a/arch/x86/kernel/apic.c b/arch/x86/kernel/apic.c
index b13d3c4dbd42..566a08466b19 100644
--- a/arch/x86/kernel/apic.c
+++ b/arch/x86/kernel/apic.c
@@ -31,9 +31,11 @@
 #include <linux/dmi.h>
 #include <linux/dmar.h>
 #include <linux/ftrace.h>
+#include <linux/smp.h>
+#include <linux/nmi.h>
+#include <linux/timex.h>
 #include <asm/atomic.h>
-#include <asm/smp.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
 #include <asm/desc.h>
@@ -41,10 +43,8 @@
 #include <asm/hpet.h>
 #include <asm/pgalloc.h>
 #include <asm/i8253.h>
-#include <asm/nmi.h>
 #include <asm/idle.h>
 #include <asm/proto.h>
-#include <asm/timex.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
@@ -687,7 +687,7 @@ static int __init calibrate_APIC_clock(void)
                local_irq_enable();
        if (levt->features & CLOCK_EVT_FEAT_DUMMY) {
-                pr_warning("APIC timer disabled due to verification failure.\n");
+                pr_warning("APIC timer disabled due to verification failure\n");
                        return -1;
        }
@@ -2087,14 +2087,12 @@ __cpuinit int apic_is_clustered_box(void)
                /* are we being called early in kernel startup? */
                if (bios_cpu_apicid) {
                        id = bios_cpu_apicid[i];
-                }
+                } else if (i < nr_cpu_ids) {
-                else if (i < nr_cpu_ids) {
                        if (cpu_present(i))
                                id = per_cpu(x86_bios_cpu_apicid, i);
                        else
                                continue;
-                }
+                } else
-                else
                        break;
                if (id != BAD_APICID)
diff --git a/arch/x86/kernel/apm_32.c b/arch/x86/kernel/apm_32.c
index 3a26525a3f31..98807bb095ad 100644
--- a/arch/x86/kernel/apm_32.c
+++ b/arch/x86/kernel/apm_32.c
@@ -160,9 +160,9 @@
 *         Work around byte swap bug in one of the Vaio's BIOS's
 *         (Marc Boucher <marc@mbsi.ca>).
 *         Exposed the disable flag to dmi so that we can handle known
- *         broken APM (Alan Cox <alan@redhat.com>).
+ *         broken APM (Alan Cox <alan@lxorguk.ukuu.org.uk>).
 *   1.14ac: If the BIOS says "I slowed the CPU down" then don't spin
- *         calling it - instead idle. (Alan Cox <alan@redhat.com>)
+ *         calling it - instead idle. (Alan Cox <alan@lxorguk.ukuu.org.uk>)
 *         If an APM idle fails log it and idle sensibly
 *   1.15: Don't queue events to clients who open the device O_WRONLY.
 *         Don't expect replies from clients who open the device O_RDONLY.
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index 3f95a40f718a..83492b1f93b1 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -40,6 +40,26 @@
 #include "cpu.h"
+#ifdef CONFIG_X86_64
+/* all of these masks are initialized in setup_cpu_local_masks() */
+cpumask_var_t cpu_callin_mask;
+cpumask_var_t cpu_callout_mask;
+cpumask_var_t cpu_initialized_mask;
+/* representing cpus for which sibling maps can be computed */
+cpumask_var_t cpu_sibling_setup_mask;
+#else /* CONFIG_X86_32 */
+cpumask_t cpu_callin_map;
+cpumask_t cpu_callout_map;
+cpumask_t cpu_initialized;
+cpumask_t cpu_sibling_setup_map;
+#endif /* CONFIG_X86_32 */
 static struct cpu_dev *this_cpu __cpuinitdata;
 #ifdef CONFIG_X86_64
@@ -856,8 +876,6 @@ static __init int setup_disablecpuid(char *arg)
 }
 __setup("clearcpuid=", setup_disablecpuid);
-cpumask_t cpu_initialized __cpuinitdata = CPU_MASK_NONE;
 #ifdef CONFIG_X86_64
 struct x8664_pda **_cpu_pda __read_mostly;
 EXPORT_SYMBOL(_cpu_pda);
@@ -976,7 +994,7 @@ void __cpuinit cpu_init(void)
        me = current;
-        if (cpu_test_and_set(cpu, cpu_initialized))
+        if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask))
                panic("CPU#%d already initialized!\n", cpu);
        printk(KERN_INFO "Initializing CPU#%d\n", cpu);
@@ -1085,7 +1103,7 @@ void __cpuinit cpu_init(void)
        struct tss_struct *t = &per_cpu(init_tss, cpu);
        struct thread_struct *thread = &curr->thread;
-        if (cpu_test_and_set(cpu, cpu_initialized)) {
+        if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) {
                printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
                for (;;) local_irq_enable();
        }
diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
index 28102ad1a363..06fcd8f9323c 100644
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -145,13 +145,14 @@ typedef union {
 struct drv_cmd {
        unsigned int type;
-        cpumask_t mask;
+        cpumask_var_t mask;
        drv_addr_union addr;
        u32 val;
 };
-static void do_drv_read(struct drv_cmd *cmd)
+static long do_drv_read(void *_cmd)
 {
+        struct drv_cmd *cmd = _cmd;
        u32 h;
        switch (cmd->type) {
@@ -166,10 +167,12 @@ static void do_drv_read(struct drv_cmd *cmd)
        default:
                break;
        }
+        return 0;
 }
-static void do_drv_write(struct drv_cmd *cmd)
+static long do_drv_write(void *_cmd)
 {
+        struct drv_cmd *cmd = _cmd;
        u32 lo, hi;
        switch (cmd->type) {
@@ -186,48 +189,41 @@ static void do_drv_write(struct drv_cmd *cmd)
        default:
                break;
        }
+        return 0;
 }
 static void drv_read(struct drv_cmd *cmd)
 {
-        cpumask_t saved_mask = current->cpus_allowed;
        cmd->val = 0;
-        set_cpus_allowed_ptr(current, &cmd->mask);
+        work_on_cpu(cpumask_any(cmd->mask), do_drv_read, cmd);
-        do_drv_read(cmd);
-        set_cpus_allowed_ptr(current, &saved_mask);
 }
 static void drv_write(struct drv_cmd *cmd)
 {
-        cpumask_t saved_mask = current->cpus_allowed;
        unsigned int i;
-        for_each_cpu_mask_nr(i, cmd->mask) {
+        for_each_cpu(i, cmd->mask) {
-                set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
+                work_on_cpu(i, do_drv_write, cmd);
-                do_drv_write(cmd);
        }
-        set_cpus_allowed_ptr(current, &saved_mask);
-        return;
 }
-static u32 get_cur_val(const cpumask_t *mask)
+static u32 get_cur_val(const struct cpumask *mask)
 {
        struct acpi_processor_performance *perf;
        struct drv_cmd cmd;
-        if (unlikely(cpus_empty(*mask)))
+        if (unlikely(cpumask_empty(mask)))
                return 0;
-        switch (per_cpu(drv_data, first_cpu(*mask))->cpu_feature) {
+        switch (per_cpu(drv_data, cpumask_first(mask))->cpu_feature) {
        case SYSTEM_INTEL_MSR_CAPABLE:
                cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
                cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
                break;
        case SYSTEM_IO_CAPABLE:
                cmd.type = SYSTEM_IO_CAPABLE;
-                perf = per_cpu(drv_data, first_cpu(*mask))->acpi_data;
+                perf = per_cpu(drv_data, cpumask_first(mask))->acpi_data;
                cmd.addr.io.port = perf->control_register.address;
                cmd.addr.io.bit_width = perf->control_register.bit_width;
                break;
@@ -235,15 +231,44 @@ static u32 get_cur_val(const cpumask_t *mask)
                return 0;
        }
-        cmd.mask = *mask;
+        if (unlikely(!alloc_cpumask_var(&cmd.mask, GFP_KERNEL)))
+                return 0;
+        cpumask_copy(cmd.mask, mask);
        drv_read(&cmd);
+        free_cpumask_var(cmd.mask);
        dprintk("get_cur_val = %u\n", cmd.val);
        return cmd.val;
 }
+struct perf_cur {
+        union {
+                struct {
+                        u32 lo;
+                        u32 hi;
+                } split;
+                u64 whole;
+        } aperf_cur, mperf_cur;
+};
+static long read_measured_perf_ctrs(void *_cur)
+{
+        struct perf_cur *cur = _cur;
+        rdmsr(MSR_IA32_APERF, cur->aperf_cur.split.lo, cur->aperf_cur.split.hi);
+        rdmsr(MSR_IA32_MPERF, cur->mperf_cur.split.lo, cur->mperf_cur.split.hi);
+        wrmsr(MSR_IA32_APERF, 0, 0);
+        wrmsr(MSR_IA32_MPERF, 0, 0);
+        return 0;
+}
 /*
 * Return the measured active (C0) frequency on this CPU since last call
 * to this function.
@@ -260,31 +285,12 @@ static u32 get_cur_val(const cpumask_t *mask)
 static unsigned int get_measured_perf(struct cpufreq_policy *policy,
                                      unsigned int cpu)
 {
-        union {
+        struct perf_cur cur;
-                struct {
-                        u32 lo;
-                        u32 hi;
-                } split;
-                u64 whole;
-        } aperf_cur, mperf_cur;
-        cpumask_t saved_mask;
        unsigned int perf_percent;
        unsigned int retval;
-        saved_mask = current->cpus_allowed;
+        if (!work_on_cpu(cpu, read_measured_perf_ctrs, &cur))
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
-        if (get_cpu() != cpu) {
-                /* We were not able to run on requested processor */
-                put_cpu();
                return 0;
-        }
-        rdmsr(MSR_IA32_APERF, aperf_cur.split.lo, aperf_cur.split.hi);
-        rdmsr(MSR_IA32_MPERF, mperf_cur.split.lo, mperf_cur.split.hi);
-        wrmsr(MSR_IA32_APERF, 0,0);
-        wrmsr(MSR_IA32_MPERF, 0,0);
 #ifdef __i386__
        /*
@@ -292,37 +298,39 @@ static unsigned int get_measured_perf(struct cpufreq_policy *policy,
         * Get an approximate value. Return failure in case we cannot get
         * an approximate value.
         */
-        if (unlikely(aperf_cur.split.hi || mperf_cur.split.hi)) {
+        if (unlikely(cur.aperf_cur.split.hi || cur.mperf_cur.split.hi)) {
                int shift_count;
                u32 h;
-                h = max_t(u32, aperf_cur.split.hi, mperf_cur.split.hi);
+                h = max_t(u32, cur.aperf_cur.split.hi, cur.mperf_cur.split.hi);
                shift_count = fls(h);
-                aperf_cur.whole >>= shift_count;
+                cur.aperf_cur.whole >>= shift_count;
-                mperf_cur.whole >>= shift_count;
+                cur.mperf_cur.whole >>= shift_count;
        }
-        if (((unsigned long)(-1) / 100) < aperf_cur.split.lo) {
+        if (((unsigned long)(-1) / 100) < cur.aperf_cur.split.lo) {
                int shift_count = 7;
-                aperf_cur.split.lo >>= shift_count;
+                cur.aperf_cur.split.lo >>= shift_count;
-                mperf_cur.split.lo >>= shift_count;
+                cur.mperf_cur.split.lo >>= shift_count;
        }
-        if (aperf_cur.split.lo && mperf_cur.split.lo)
+        if (cur.aperf_cur.split.lo && cur.mperf_cur.split.lo)
-                perf_percent = (aperf_cur.split.lo * 100) / mperf_cur.split.lo;
+                perf_percent = (cur.aperf_cur.split.lo * 100) /
+                                cur.mperf_cur.split.lo;
        else
                perf_percent = 0;
 #else
-        if (unlikely(((unsigned long)(-1) / 100) < aperf_cur.whole)) {
+        if (unlikely(((unsigned long)(-1) / 100) < cur.aperf_cur.whole)) {
                int shift_count = 7;
-                aperf_cur.whole >>= shift_count;
+                cur.aperf_cur.whole >>= shift_count;
-                mperf_cur.whole >>= shift_count;
+                cur.mperf_cur.whole >>= shift_count;
        }
-        if (aperf_cur.whole && mperf_cur.whole)
+        if (cur.aperf_cur.whole && cur.mperf_cur.whole)
-                perf_percent = (aperf_cur.whole * 100) / mperf_cur.whole;
+                perf_percent = (cur.aperf_cur.whole * 100) /
+                                cur.mperf_cur.whole;
        else
                perf_percent = 0;
@@ -330,10 +338,6 @@ static unsigned int get_measured_perf(struct cpufreq_policy *policy,
        retval = per_cpu(drv_data, policy->cpu)->max_freq * perf_percent / 100;
-        put_cpu();
-        set_cpus_allowed_ptr(current, &saved_mask);
-        dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
        return retval;
 }
@@ -351,7 +355,7 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
        }
        cached_freq = data->freq_table[data->acpi_data->state].frequency;
-        freq = extract_freq(get_cur_val(&cpumask_of_cpu(cpu)), data);
+        freq = extract_freq(get_cur_val(cpumask_of(cpu)), data);
        if (freq != cached_freq) {
                /*
                 * The dreaded BIOS frequency change behind our back.
@@ -386,7 +390,6 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
        struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
        struct acpi_processor_performance *perf;
        struct cpufreq_freqs freqs;
-        cpumask_t online_policy_cpus;
        struct drv_cmd cmd;
        unsigned int next_state = 0; /* Index into freq_table */
        unsigned int next_perf_state = 0; /* Index into perf table */
@@ -401,20 +404,18 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                return -ENODEV;
        }
+        if (unlikely(!alloc_cpumask_var(&cmd.mask, GFP_KERNEL)))
+                return -ENOMEM;
        perf = data->acpi_data;
        result = cpufreq_frequency_table_target(policy,
                                                data->freq_table,
                                                target_freq,
                                                relation, &next_state);
-        if (unlikely(result))
+        if (unlikely(result)) {
-                return -ENODEV;
+                result = -ENODEV;
+                goto out;
-#ifdef CONFIG_HOTPLUG_CPU
+        }
-        /* cpufreq holds the hotplug lock, so we are safe from here on */
-        cpus_and(online_policy_cpus, cpu_online_map, policy->cpus);
-#else
-        online_policy_cpus = policy->cpus;
-#endif
        next_perf_state = data->freq_table[next_state].index;
        if (perf->state == next_perf_state) {
@@ -425,7 +426,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                } else {
                        dprintk("Already at target state (P%d)\n",
                                next_perf_state);
-                        return 0;
+                        goto out;
                }
        }
@@ -444,19 +445,19 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                cmd.val = (u32) perf->states[next_perf_state].control;
                break;
        default:
-                return -ENODEV;
+                result = -ENODEV;
+                goto out;
        }
-        cpus_clear(cmd.mask);
+        /* cpufreq holds the hotplug lock, so we are safe from here on */
        if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
-                cmd.mask = online_policy_cpus;
+                cpumask_and(cmd.mask, cpu_online_mask, policy->cpus);
        else
-                cpu_set(policy->cpu, cmd.mask);
+                cpumask_copy(cmd.mask, cpumask_of(policy->cpu));
        freqs.old = perf->states[perf->state].core_frequency * 1000;
        freqs.new = data->freq_table[next_state].frequency;
-        for_each_cpu_mask_nr(i, cmd.mask) {
+        for_each_cpu(i, cmd.mask) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
        }
@@ -464,19 +465,22 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
        drv_write(&cmd);
        if (acpi_pstate_strict) {
-                if (!check_freqs(&cmd.mask, freqs.new, data)) {
+                if (!check_freqs(cmd.mask, freqs.new, data)) {
                        dprintk("acpi_cpufreq_target failed (%d)\n",
                                policy->cpu);
-                        return -EAGAIN;
+                        result = -EAGAIN;
+                        goto out;
                }
        }
-        for_each_cpu_mask_nr(i, cmd.mask) {
+        for_each_cpu(i, cmd.mask) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
        }
        perf->state = next_perf_state;
+out:
+        free_cpumask_var(cmd.mask);
        return result;
 }
@@ -626,15 +630,15 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
         */
        if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
-                cpumask_copy(&policy->cpus, perf->shared_cpu_map);
+                cpumask_copy(policy->cpus, perf->shared_cpu_map);
        }
-        cpumask_copy(&policy->related_cpus, perf->shared_cpu_map);
+        cpumask_copy(policy->related_cpus, perf->shared_cpu_map);
 #ifdef CONFIG_SMP
        dmi_check_system(sw_any_bug_dmi_table);
-        if (bios_with_sw_any_bug && cpus_weight(policy->cpus) == 1) {
+        if (bios_with_sw_any_bug && cpumask_weight(policy->cpus) == 1) {
                policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
-                policy->cpus = per_cpu(cpu_core_map, cpu);
+                cpumask_copy(policy->cpus, cpu_core_mask(cpu));
        }
 #endif
diff --git a/arch/x86/kernel/cpu/cpufreq/longhaul.c b/arch/x86/kernel/cpu/cpufreq/longhaul.c
index b0461856acfb..a4cff5d6e380 100644
--- a/arch/x86/kernel/cpu/cpufreq/longhaul.c
+++ b/arch/x86/kernel/cpu/cpufreq/longhaul.c
@@ -982,7 +982,7 @@ static int __init longhaul_init(void)
        case 10:
                printk(KERN_ERR PFX "Use acpi-cpufreq driver for VIA C7\n");
        default:
-                ;;
+                ;
        }
        return -ENODEV;
diff --git a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
index beea4466b063..b585e04cbc9e 100644
--- a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
+++ b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
@@ -122,7 +122,7 @@ static int cpufreq_p4_target(struct cpufreq_policy *policy,
                return 0;
        /* notifiers */
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
        }
@@ -130,11 +130,11 @@ static int cpufreq_p4_target(struct cpufreq_policy *policy,
        /* run on each logical CPU, see section 13.15.3 of IA32 Intel Architecture Software
         * Developer's Manual, Volume 3
         */
-        for_each_cpu_mask_nr(i, policy->cpus)
+        for_each_cpu(i, policy->cpus)
                cpufreq_p4_setdc(i, p4clockmod_table[newstate].index);
        /* notifiers */
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
        }
@@ -203,7 +203,7 @@ static int cpufreq_p4_cpu_init(struct cpufreq_policy *policy)
        unsigned int i;
 #ifdef CONFIG_SMP
-        policy->cpus = per_cpu(cpu_sibling_map, policy->cpu);
+        cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
 #endif
        /* Errata workaround */
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index c3c9adbaa26f..5c28b37dea11 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -1199,10 +1199,10 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
        set_cpus_allowed_ptr(current, &oldmask);
        if (cpu_family == CPU_HW_PSTATE)
-                pol->cpus = cpumask_of_cpu(pol->cpu);
+                cpumask_copy(pol->cpus, cpumask_of(pol->cpu));
        else
-                pol->cpus = per_cpu(cpu_core_map, pol->cpu);
+                cpumask_copy(pol->cpus, &per_cpu(cpu_core_map, pol->cpu));
-        data->available_cores = &(pol->cpus);
+        data->available_cores = pol->cpus;
        /* Take a crude guess here.
         * That guess was in microseconds, so multiply with 1000 */
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.h b/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
index 65cfb5d7f77f..8ecc75b6c7c3 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
@@ -53,7 +53,7 @@ struct powernow_k8_data {
        /* we need to keep track of associated cores, but let cpufreq
         * handle hotplug events - so just point at cpufreq pol->cpus
         * structure */
-        cpumask_t *available_cores;
+        struct cpumask *available_cores;
 };
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
index f0ea6fa2f53c..f08998278a3a 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -458,11 +458,6 @@ static int centrino_verify (struct cpufreq_policy *policy)
 *
 * Sets a new CPUFreq policy.
 */
-struct allmasks {
-        cpumask_t               saved_mask;
-        cpumask_t               covered_cpus;
-};
 static int centrino_target (struct cpufreq_policy *policy,
                            unsigned int target_freq,
                            unsigned int relation)
@@ -472,12 +467,15 @@ static int centrino_target (struct cpufreq_policy *policy,
        struct cpufreq_freqs    freqs;
        int                     retval = 0;
        unsigned int            j, k, first_cpu, tmp;
-        CPUMASK_ALLOC(allmasks);
+        cpumask_var_t saved_mask, covered_cpus;
-        CPUMASK_PTR(saved_mask, allmasks);
-        CPUMASK_PTR(covered_cpus, allmasks);
-        if (unlikely(allmasks == NULL))
+        if (unlikely(!alloc_cpumask_var(&saved_mask, GFP_KERNEL)))
                return -ENOMEM;
+        if (unlikely(!alloc_cpumask_var(&covered_cpus, GFP_KERNEL))) {
+                free_cpumask_var(saved_mask);
+                return -ENOMEM;
+        }
+        cpumask_copy(saved_mask, &current->cpus_allowed);
        if (unlikely(per_cpu(centrino_model, cpu) == NULL)) {
                retval = -ENODEV;
@@ -493,11 +491,9 @@ static int centrino_target (struct cpufreq_policy *policy,
                goto out;
        }
-        *saved_mask = current->cpus_allowed;
        first_cpu = 1;
-        cpus_clear(*covered_cpus);
+        for_each_cpu(j, policy->cpus) {
-        for_each_cpu_mask_nr(j, policy->cpus) {
+                const struct cpumask *mask;
-                const cpumask_t *mask;
                /* cpufreq holds the hotplug lock, so we are safe here */
                if (!cpu_online(j))
@@ -508,9 +504,9 @@ static int centrino_target (struct cpufreq_policy *policy,
                 * Make sure we are running on CPU that wants to change freq
                 */
                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        mask = &policy->cpus;
+                        mask = policy->cpus;
                else
-                        mask = &cpumask_of_cpu(j);
+                        mask = cpumask_of(j);
                set_cpus_allowed_ptr(current, mask);
                preempt_disable();
@@ -542,7 +538,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                        dprintk("target=%dkHz old=%d new=%d msr=%04x\n",
                                target_freq, freqs.old, freqs.new, msr);
-                        for_each_cpu_mask_nr(k, policy->cpus) {
+                        for_each_cpu(k, policy->cpus) {
                                if (!cpu_online(k))
                                        continue;
                                freqs.cpu = k;
@@ -567,7 +563,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                preempt_enable();
        }
-        for_each_cpu_mask_nr(k, policy->cpus) {
+        for_each_cpu(k, policy->cpus) {
                if (!cpu_online(k))
                        continue;
                freqs.cpu = k;
@@ -590,7 +586,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                tmp = freqs.new;
                freqs.new = freqs.old;
                freqs.old = tmp;
-                for_each_cpu_mask_nr(j, policy->cpus) {
+                for_each_cpu(j, policy->cpus) {
                        if (!cpu_online(j))
                                continue;
                        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
@@ -605,7 +601,8 @@ migrate_end:
        preempt_enable();
        set_cpus_allowed_ptr(current, saved_mask);
 out:
-        CPUMASK_FREE(allmasks);
+        free_cpumask_var(saved_mask);
+        free_cpumask_var(covered_cpus);
        return retval;
 }
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
index 04d0376b64b0..dedc1e98f168 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
@@ -229,7 +229,7 @@ static unsigned int speedstep_detect_chipset (void)
        return 0;
 }
-static unsigned int _speedstep_get(const cpumask_t *cpus)
+static unsigned int _speedstep_get(const struct cpumask *cpus)
 {
        unsigned int speed;
        cpumask_t cpus_allowed;
@@ -244,7 +244,7 @@ static unsigned int _speedstep_get(const cpumask_t *cpus)
 static unsigned int speedstep_get(unsigned int cpu)
 {
-        return _speedstep_get(&cpumask_of_cpu(cpu));
+        return _speedstep_get(cpumask_of(cpu));
 }
 /**
@@ -267,7 +267,7 @@ static int speedstep_target (struct cpufreq_policy *policy,
        if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0], target_freq, relation, &newstate))
                return -EINVAL;
-        freqs.old = _speedstep_get(&policy->cpus);
+        freqs.old = _speedstep_get(policy->cpus);
        freqs.new = speedstep_freqs[newstate].frequency;
        freqs.cpu = policy->cpu;
@@ -279,20 +279,20 @@ static int speedstep_target (struct cpufreq_policy *policy,
        cpus_allowed = current->cpus_allowed;
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
        }
        /* switch to physical CPU where state is to be changed */
-        set_cpus_allowed_ptr(current, &policy->cpus);
+        set_cpus_allowed_ptr(current, policy->cpus);
        speedstep_set_state(newstate);
        /* allow to be run on all CPUs */
        set_cpus_allowed_ptr(current, &cpus_allowed);
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
        }
@@ -322,11 +322,11 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
        /* only run on CPU to be set, or on its sibling */
 #ifdef CONFIG_SMP
-        policy->cpus = per_cpu(cpu_sibling_map, policy->cpu);
+        cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
 #endif
        cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &policy->cpus);
+        set_cpus_allowed_ptr(current, policy->cpus);
        /* detect low and high frequency and transition latency */
        result = speedstep_get_freqs(speedstep_processor,
@@ -339,7 +339,7 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
                return result;
        /* get current speed setting */
-        speed = _speedstep_get(&policy->cpus);
+        speed = _speedstep_get(policy->cpus);
        if (!speed)
                return -EIO;
diff --git a/arch/x86/kernel/cpu/mcheck/mce_32.c b/arch/x86/kernel/cpu/mcheck/mce_32.c
index 0ebf3fc6a610..dfaebce3633e 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_32.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_32.c
@@ -1,6 +1,6 @@
 /*
 * mce.c - x86 Machine Check Exception Reporting
- * (c) 2002 Alan Cox <alan@redhat.com>, Dave Jones <davej@redhat.com>
+ * (c) 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>, Dave Jones <davej@redhat.com>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
index a5a5e0530370..8ae8c4ff094d 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
@@ -462,7 +462,7 @@ out_free:
        return err;
 }
-static long local_allocate_threshold_blocks(void *_bank)
+static __cpuinit long local_allocate_threshold_blocks(void *_bank)
 {
        unsigned int *bank = _bank;
diff --git a/arch/x86/kernel/cpu/mcheck/p5.c b/arch/x86/kernel/cpu/mcheck/p5.c
index bfa5817afdda..c9f77ea69edc 100644
--- a/arch/x86/kernel/cpu/mcheck/p5.c
+++ b/arch/x86/kernel/cpu/mcheck/p5.c
@@ -1,6 +1,6 @@
 /*
 * P5 specific Machine Check Exception Reporting
- * (C) Copyright 2002 Alan Cox <alan@redhat.com>
+ * (C) Copyright 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/cpu/mcheck/p6.c b/arch/x86/kernel/cpu/mcheck/p6.c
index 62efc9c2b3af..2ac52d7b434b 100644
--- a/arch/x86/kernel/cpu/mcheck/p6.c
+++ b/arch/x86/kernel/cpu/mcheck/p6.c
@@ -1,6 +1,6 @@
 /*
 * P6 specific Machine Check Exception Reporting
- * (C) Copyright 2002 Alan Cox <alan@redhat.com>
+ * (C) Copyright 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/cpu/mcheck/winchip.c b/arch/x86/kernel/cpu/mcheck/winchip.c
index f2be3e190c6b..2a043d89811d 100644
--- a/arch/x86/kernel/cpu/mcheck/winchip.c
+++ b/arch/x86/kernel/cpu/mcheck/winchip.c
@@ -1,6 +1,6 @@
 /*
 * IDT Winchip specific Machine Check Exception Reporting
- * (C) Copyright 2002 Alan Cox <alan@redhat.com>
+ * (C) Copyright 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
index 65a13943e098..e85826829cf2 100644
--- a/arch/x86/kernel/e820.c
+++ b/arch/x86/kernel/e820.c
@@ -665,6 +665,27 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)
 }
 #endif
+#ifdef CONFIG_HIBERNATION
+/**
+ * Mark ACPI NVS memory region, so that we can save/restore it during
+ * hibernation and the subsequent resume.
+ */
+static int __init e820_mark_nvs_memory(void)
+{
+        int i;
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                if (ei->type == E820_NVS)
+                        hibernate_nvs_register(ei->addr, ei->size);
+        }
+        return 0;
+}
+core_initcall(e820_mark_nvs_memory);
+#endif
 /*
 * Early reserved memory areas.
 */
diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
index 744aa7fc49d5..76b8cd953dee 100644
--- a/arch/x86/kernel/early-quirks.c
+++ b/arch/x86/kernel/early-quirks.c
@@ -201,6 +201,12 @@ struct chipset {
        void (*f)(int num, int slot, int func);
 };
+/*
+ * Only works for devices on the root bus. If you add any devices
+ * not on bus 0 readd another loop level in early_quirks(). But
+ * be careful because at least the Nvidia quirk here relies on
+ * only matching on bus 0.
+ */
 static struct chipset early_qrk[] __initdata = {
        { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
          PCI_CLASS_BRIDGE_PCI, PCI_ANY_ID, QFLAG_APPLY_ONCE, nvidia_bugs },
@@ -267,17 +273,17 @@ static int __init check_dev_quirk(int num, int slot, int func)
 void __init early_quirks(void)
 {
-        int num, slot, func;
+        int slot, func;
        if (!early_pci_allowed())
                return;
        /* Poor man's PCI discovery */
-        for (num = 0; num < 32; num++)
+        /* Only scan the root bus */
-                for (slot = 0; slot < 32; slot++)
+        for (slot = 0; slot < 32; slot++)
-                        for (func = 0; func < 8; func++) {
+                for (func = 0; func < 8; func++) {
-                                /* Only probe function 0 on single fn devices */
+                        /* Only probe function 0 on single fn devices */
-                                if (check_dev_quirk(num, slot, func))
+                        if (check_dev_quirk(0, slot, func))
-                                        break;
+                                break;
-                        }
+                }
 }
diff --git a/arch/x86/kernel/head_64.S b/arch/x86/kernel/head_64.S
index 26cfdc1d7c7f..0e275d495563 100644
--- a/arch/x86/kernel/head_64.S
+++ b/arch/x86/kernel/head_64.S
@@ -305,7 +305,7 @@ ENTRY(early_idt_handler)
        call dump_stack
 #ifdef CONFIG_KALLSYMS  
        leaq early_idt_ripmsg(%rip),%rdi
-        movq 8(%rsp),%rsi       # get rip again
+        movq 0(%rsp),%rsi       # get rip again
        call __print_symbol
 #endif
 #endif /* EARLY_PRINTK */
diff --git a/arch/x86/kernel/i8259.c b/arch/x86/kernel/i8259.c
index 4b8a53d841f7..11d5093eb281 100644
--- a/arch/x86/kernel/i8259.c
+++ b/arch/x86/kernel/i8259.c
@@ -11,15 +11,15 @@
 #include <linux/kernel_stat.h>
 #include <linux/sysdev.h>
 #include <linux/bitops.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/delay.h>
-#include <asm/acpi.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/timer.h>
 #include <asm/hw_irq.h>
 #include <asm/pgtable.h>
-#include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/arch_hooks.h>
@@ -323,7 +323,7 @@ void init_8259A(int auto_eoi)
        outb_pic(0x11, PIC_MASTER_CMD); /* ICW1: select 8259A-1 init */
        /* ICW2: 8259A-1 IR0-7 mapped to 0x30-0x37 on x86-64,
-                               to 0x20-0x27 on i386 */
+           to 0x20-0x27 on i386 */
        outb_pic(IRQ0_VECTOR, PIC_MASTER_IMR);
        /* 8259A-1 (the master) has a slave on IR2 */
diff --git a/arch/x86/kernel/io_apic.c b/arch/x86/kernel/io_apic.c
index 3639442aa7a4..1c4a1302536c 100644
--- a/arch/x86/kernel/io_apic.c
+++ b/arch/x86/kernel/io_apic.c
@@ -129,7 +129,6 @@ static struct irq_pin_list *get_one_free_irq_2_pin(int cpu)
        node = cpu_to_node(cpu);
        pin = kzalloc_node(sizeof(*pin), GFP_ATOMIC, node);
-        printk(KERN_DEBUG "  alloc irq_2_pin on cpu %d node %d\n", cpu, node);
        return pin;
 }
@@ -227,7 +226,6 @@ static struct irq_cfg *get_one_free_irq_cfg(int cpu)
                        cpumask_clear(cfg->old_domain);
                }
        }
-        printk(KERN_DEBUG "  alloc irq_cfg on cpu %d node %d\n", cpu, node);
        return cfg;
 }
diff --git a/arch/x86/kernel/ioport.c b/arch/x86/kernel/ioport.c
index 191914302744..b12208f4dfee 100644
--- a/arch/x86/kernel/ioport.c
+++ b/arch/x86/kernel/ioport.c
@@ -35,8 +35,8 @@ static void set_bitmap(unsigned long *bitmap, unsigned int base,
 */
 asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int turn_on)
 {
-        struct thread_struct * t = &current->thread;
+        struct thread_struct *t = &current->thread;
-        struct tss_struct * tss;
+        struct tss_struct *tss;
        unsigned int i, max_long, bytes, bytes_updated;
        if ((from + num <= from) || (from + num > IO_BITMAP_BITS))
diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c
index bce53e1352a0..3973e2df7f87 100644
--- a/arch/x86/kernel/irq.c
+++ b/arch/x86/kernel/irq.c
@@ -5,10 +5,10 @@
 #include <linux/interrupt.h>
 #include <linux/kernel_stat.h>
 #include <linux/seq_file.h>
+#include <linux/smp.h>
 #include <asm/apic.h>
 #include <asm/io_apic.h>
-#include <asm/smp.h>
 #include <asm/irq.h>
 atomic_t irq_err_count;
diff --git a/arch/x86/kernel/irq_32.c b/arch/x86/kernel/irq_32.c
index 9dc5588f336a..74b9ff7341e9 100644
--- a/arch/x86/kernel/irq_32.c
+++ b/arch/x86/kernel/irq_32.c
@@ -15,9 +15,9 @@
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/delay.h>
+#include <linux/uaccess.h>
 #include <asm/apic.h>
-#include <asm/uaccess.h>
 DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
 EXPORT_PER_CPU_SYMBOL(irq_stat);
@@ -93,7 +93,7 @@ execute_on_irq_stack(int overflow, struct irq_desc *desc, int irq)
                return 0;
        /* build the stack frame on the IRQ stack */
-        isp = (u32 *) ((char*)irqctx + sizeof(*irqctx));
+        isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));
        irqctx->tinfo.task = curctx->tinfo.task;
        irqctx->tinfo.previous_esp = current_stack_pointer;
@@ -137,7 +137,7 @@ void __cpuinit irq_ctx_init(int cpu)
        hardirq_ctx[cpu] = irqctx;
-        irqctx = (union irq_ctx*) &softirq_stack[cpu*THREAD_SIZE];
+        irqctx = (union irq_ctx *) &softirq_stack[cpu*THREAD_SIZE];
        irqctx->tinfo.task              = NULL;
        irqctx->tinfo.exec_domain       = NULL;
        irqctx->tinfo.cpu               = cpu;
@@ -147,7 +147,7 @@ void __cpuinit irq_ctx_init(int cpu)
        softirq_ctx[cpu] = irqctx;
        printk(KERN_DEBUG "CPU %u irqstacks, hard=%p soft=%p\n",
-               cpu,hardirq_ctx[cpu],softirq_ctx[cpu]);
+               cpu, hardirq_ctx[cpu], softirq_ctx[cpu]);
 }
 void irq_ctx_exit(int cpu)
@@ -174,7 +174,7 @@ asmlinkage void do_softirq(void)
                irqctx->tinfo.previous_esp = current_stack_pointer;
                /* build the stack frame on the softirq stack */
-                isp = (u32*) ((char*)irqctx + sizeof(*irqctx));
+                isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));
                call_on_stack(__do_softirq, isp);
                /*
diff --git a/arch/x86/kernel/irq_64.c b/arch/x86/kernel/irq_64.c
index 6383d50f82ea..63c88e6ec025 100644
--- a/arch/x86/kernel/irq_64.c
+++ b/arch/x86/kernel/irq_64.c
@@ -14,10 +14,10 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/ftrace.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
+#include <linux/smp.h>
 #include <asm/io_apic.h>
 #include <asm/idle.h>
-#include <asm/smp.h>
 /*
 * Probabilistic stack overflow check:
@@ -142,18 +142,18 @@ extern void call_softirq(void);
 asmlinkage void do_softirq(void)
 {
-        __u32 pending;
+        __u32 pending;
-        unsigned long flags;
+        unsigned long flags;
-        if (in_interrupt())
+        if (in_interrupt())
-                return;
+                return;
-        local_irq_save(flags);
+        local_irq_save(flags);
-        pending = local_softirq_pending();
+        pending = local_softirq_pending();
-        /* Switch to interrupt stack */
+        /* Switch to interrupt stack */
-        if (pending) {
+        if (pending) {
                call_softirq();
                WARN_ON_ONCE(softirq_count());
        }
-        local_irq_restore(flags);
+        local_irq_restore(flags);
 }
diff --git a/arch/x86/kernel/irqinit_32.c b/arch/x86/kernel/irqinit_32.c
index 84723295f88a..1507ad4e674d 100644
--- a/arch/x86/kernel/irqinit_32.c
+++ b/arch/x86/kernel/irqinit_32.c
@@ -9,18 +9,18 @@
 #include <linux/kernel_stat.h>
 #include <linux/sysdev.h>
 #include <linux/bitops.h>
+#include <linux/io.h>
+#include <linux/delay.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/timer.h>
 #include <asm/pgtable.h>
-#include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/arch_hooks.h>
 #include <asm/i8259.h>
+#include <asm/traps.h>
 /*
@@ -34,12 +34,10 @@
 * leads to races. IBM designers who came up with it should
 * be shot.
 */
- 
 static irqreturn_t math_error_irq(int cpl, void *dev_id)
 {
-        extern void math_error(void __user *);
+        outb(0, 0xF0);
-        outb(0,0xF0);
        if (ignore_fpu_irq || !boot_cpu_data.hard_math)
                return IRQ_NONE;
        math_error((void __user *)get_irq_regs()->ip);
@@ -56,7 +54,7 @@ static struct irqaction fpu_irq = {
        .name = "fpu",
 };
-void __init init_ISA_irqs (void)
+void __init init_ISA_irqs(void)
 {
        int i;
diff --git a/arch/x86/kernel/irqinit_64.c b/arch/x86/kernel/irqinit_64.c
index 31ebfe38e96c..da481a1e3f30 100644
--- a/arch/x86/kernel/irqinit_64.c
+++ b/arch/x86/kernel/irqinit_64.c
@@ -11,14 +11,14 @@
 #include <linux/kernel_stat.h>
 #include <linux/sysdev.h>
 #include <linux/bitops.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/delay.h>
-#include <asm/acpi.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/hw_irq.h>
 #include <asm/pgtable.h>
-#include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
@@ -81,7 +81,7 @@ int vector_used_by_percpu_irq(unsigned int vector)
        return 0;
 }
-void __init init_ISA_irqs(void)
+static void __init init_ISA_irqs(void)
 {
        int i;
diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c
index c5c5b8df1dbc..c0601c2848a1 100644
--- a/arch/x86/kernel/mpparse.c
+++ b/arch/x86/kernel/mpparse.c
@@ -2,7 +2,7 @@
 *      Intel Multiprocessor Specification 1.1 and 1.4
 *      compliant MP-table parsing routines.
 *
- *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
+ *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
 *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
 *      (c) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
 */
@@ -17,7 +17,6 @@
 #include <linux/acpi.h>
 #include <linux/module.h>
 #include <linux/smp.h>
-#include <linux/acpi.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
@@ -49,12 +48,12 @@ static int __init mpf_checksum(unsigned char *mp, int len)
        return sum & 0xFF;
 }
-static void __init MP_processor_info(struct mpc_config_processor *m)
+static void __init MP_processor_info(struct mpc_cpu *m)
 {
        int apicid;
        char *bootup_cpu = "";
-        if (!(m->mpc_cpuflag & CPU_ENABLED)) {
+        if (!(m->cpuflag & CPU_ENABLED)) {
                disabled_cpus++;
                return;
        }
@@ -62,54 +61,54 @@ static void __init MP_processor_info(struct mpc_config_processor *m)
        if (x86_quirks->mpc_apic_id)
                apicid = x86_quirks->mpc_apic_id(m);
        else
-                apicid = m->mpc_apicid;
+                apicid = m->apicid;
-        if (m->mpc_cpuflag & CPU_BOOTPROCESSOR) {
+        if (m->cpuflag & CPU_BOOTPROCESSOR) {
                bootup_cpu = " (Bootup-CPU)";
-                boot_cpu_physical_apicid = m->mpc_apicid;
+                boot_cpu_physical_apicid = m->apicid;
        }
-        printk(KERN_INFO "Processor #%d%s\n", m->mpc_apicid, bootup_cpu);
+        printk(KERN_INFO "Processor #%d%s\n", m->apicid, bootup_cpu);
-        generic_processor_info(apicid, m->mpc_apicver);
+        generic_processor_info(apicid, m->apicver);
 }
 #ifdef CONFIG_X86_IO_APIC
-static void __init MP_bus_info(struct mpc_config_bus *m)
+static void __init MP_bus_info(struct mpc_bus *m)
 {
        char str[7];
-        memcpy(str, m->mpc_bustype, 6);
+        memcpy(str, m->bustype, 6);
        str[6] = 0;
        if (x86_quirks->mpc_oem_bus_info)
                x86_quirks->mpc_oem_bus_info(m, str);
        else
-                apic_printk(APIC_VERBOSE, "Bus #%d is %s\n", m->mpc_busid, str);
+                apic_printk(APIC_VERBOSE, "Bus #%d is %s\n", m->busid, str);
 #if MAX_MP_BUSSES < 256
-        if (m->mpc_busid >= MAX_MP_BUSSES) {
+        if (m->busid >= MAX_MP_BUSSES) {
                printk(KERN_WARNING "MP table busid value (%d) for bustype %s "
                       " is too large, max. supported is %d\n",
-                       m->mpc_busid, str, MAX_MP_BUSSES - 1);
+                       m->busid, str, MAX_MP_BUSSES - 1);
                return;
        }
 #endif
        if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) {
-                set_bit(m->mpc_busid, mp_bus_not_pci);
+                set_bit(m->busid, mp_bus_not_pci);
 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_ISA;
+                mp_bus_id_to_type[m->busid] = MP_BUS_ISA;
 #endif
        } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) {
                if (x86_quirks->mpc_oem_pci_bus)
                        x86_quirks->mpc_oem_pci_bus(m);
-                clear_bit(m->mpc_busid, mp_bus_not_pci);
+                clear_bit(m->busid, mp_bus_not_pci);
 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_PCI;
+                mp_bus_id_to_type[m->busid] = MP_BUS_PCI;
        } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) {
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_EISA;
+                mp_bus_id_to_type[m->busid] = MP_BUS_EISA;
        } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA) - 1) == 0) {
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_MCA;
+                mp_bus_id_to_type[m->busid] = MP_BUS_MCA;
 #endif
        } else
                printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str);
@@ -133,32 +132,31 @@ static int bad_ioapic(unsigned long address)
        return 0;
 }
-static void __init MP_ioapic_info(struct mpc_config_ioapic *m)
+static void __init MP_ioapic_info(struct mpc_ioapic *m)
 {
-        if (!(m->mpc_flags & MPC_APIC_USABLE))
+        if (!(m->flags & MPC_APIC_USABLE))
                return;
        printk(KERN_INFO "I/O APIC #%d Version %d at 0x%X.\n",
-               m->mpc_apicid, m->mpc_apicver, m->mpc_apicaddr);
+               m->apicid, m->apicver, m->apicaddr);
-        if (bad_ioapic(m->mpc_apicaddr))
+        if (bad_ioapic(m->apicaddr))
                return;
-        mp_ioapics[nr_ioapics].mp_apicaddr = m->mpc_apicaddr;
+        mp_ioapics[nr_ioapics].mp_apicaddr = m->apicaddr;
-        mp_ioapics[nr_ioapics].mp_apicid = m->mpc_apicid;
+        mp_ioapics[nr_ioapics].mp_apicid = m->apicid;
-        mp_ioapics[nr_ioapics].mp_type = m->mpc_type;
+        mp_ioapics[nr_ioapics].mp_type = m->type;
-        mp_ioapics[nr_ioapics].mp_apicver = m->mpc_apicver;
+        mp_ioapics[nr_ioapics].mp_apicver = m->apicver;
-        mp_ioapics[nr_ioapics].mp_flags = m->mpc_flags;
+        mp_ioapics[nr_ioapics].mp_flags = m->flags;
        nr_ioapics++;
 }
-static void print_MP_intsrc_info(struct mpc_config_intsrc *m)
+static void print_MP_intsrc_info(struct mpc_intsrc *m)
 {
        apic_printk(APIC_VERBOSE, "Int: type %d, pol %d, trig %d, bus %02x,"
                " IRQ %02x, APIC ID %x, APIC INT %02x\n",
-                m->mpc_irqtype, m->mpc_irqflag & 3,
+                m->irqtype, m->irqflag & 3, (m->irqflag >> 2) & 3, m->srcbus,
-                (m->mpc_irqflag >> 2) & 3, m->mpc_srcbus,
+                m->srcbusirq, m->dstapic, m->dstirq);
-                m->mpc_srcbusirq, m->mpc_dstapic, m->mpc_dstirq);
 }
 static void __init print_mp_irq_info(struct mp_config_intsrc *mp_irq)
@@ -170,52 +168,52 @@ static void __init print_mp_irq_info(struct mp_config_intsrc *mp_irq)
                mp_irq->mp_srcbusirq, mp_irq->mp_dstapic, mp_irq->mp_dstirq);
 }
-static void __init assign_to_mp_irq(struct mpc_config_intsrc *m,
+static void __init assign_to_mp_irq(struct mpc_intsrc *m,
                                    struct mp_config_intsrc *mp_irq)
 {
-        mp_irq->mp_dstapic = m->mpc_dstapic;
+        mp_irq->mp_dstapic = m->dstapic;
-        mp_irq->mp_type = m->mpc_type;
+        mp_irq->mp_type = m->type;
-        mp_irq->mp_irqtype = m->mpc_irqtype;
+        mp_irq->mp_irqtype = m->irqtype;
-        mp_irq->mp_irqflag = m->mpc_irqflag;
+        mp_irq->mp_irqflag = m->irqflag;
-        mp_irq->mp_srcbus = m->mpc_srcbus;
+        mp_irq->mp_srcbus = m->srcbus;
-        mp_irq->mp_srcbusirq = m->mpc_srcbusirq;
+        mp_irq->mp_srcbusirq = m->srcbusirq;
-        mp_irq->mp_dstirq = m->mpc_dstirq;
+        mp_irq->mp_dstirq = m->dstirq;
 }
 static void __init assign_to_mpc_intsrc(struct mp_config_intsrc *mp_irq,
-                                        struct mpc_config_intsrc *m)
+                                        struct mpc_intsrc *m)
 {
-        m->mpc_dstapic = mp_irq->mp_dstapic;
+        m->dstapic = mp_irq->mp_dstapic;
-        m->mpc_type = mp_irq->mp_type;
+        m->type = mp_irq->mp_type;
-        m->mpc_irqtype = mp_irq->mp_irqtype;
+        m->irqtype = mp_irq->mp_irqtype;
-        m->mpc_irqflag = mp_irq->mp_irqflag;
+        m->irqflag = mp_irq->mp_irqflag;
-        m->mpc_srcbus = mp_irq->mp_srcbus;
+        m->srcbus = mp_irq->mp_srcbus;
-        m->mpc_srcbusirq = mp_irq->mp_srcbusirq;
+        m->srcbusirq = mp_irq->mp_srcbusirq;
-        m->mpc_dstirq = mp_irq->mp_dstirq;
+        m->dstirq = mp_irq->mp_dstirq;
 }
 static int __init mp_irq_mpc_intsrc_cmp(struct mp_config_intsrc *mp_irq,
-                                        struct mpc_config_intsrc *m)
+                                        struct mpc_intsrc *m)
 {
-        if (mp_irq->mp_dstapic != m->mpc_dstapic)
+        if (mp_irq->mp_dstapic != m->dstapic)
                return 1;
-        if (mp_irq->mp_type != m->mpc_type)
+        if (mp_irq->mp_type != m->type)
                return 2;
-        if (mp_irq->mp_irqtype != m->mpc_irqtype)
+        if (mp_irq->mp_irqtype != m->irqtype)
                return 3;
-        if (mp_irq->mp_irqflag != m->mpc_irqflag)
+        if (mp_irq->mp_irqflag != m->irqflag)
                return 4;
-        if (mp_irq->mp_srcbus != m->mpc_srcbus)
+        if (mp_irq->mp_srcbus != m->srcbus)
                return 5;
-        if (mp_irq->mp_srcbusirq != m->mpc_srcbusirq)
+        if (mp_irq->mp_srcbusirq != m->srcbusirq)
                return 6;
-        if (mp_irq->mp_dstirq != m->mpc_dstirq)
+        if (mp_irq->mp_dstirq != m->dstirq)
                return 7;
        return 0;
 }
-static void __init MP_intsrc_info(struct mpc_config_intsrc *m)
+static void __init MP_intsrc_info(struct mpc_intsrc *m)
 {
        int i;
@@ -233,57 +231,55 @@ static void __init MP_intsrc_info(struct mpc_config_intsrc *m)
 #endif
-static void __init MP_lintsrc_info(struct mpc_config_lintsrc *m)
+static void __init MP_lintsrc_info(struct mpc_lintsrc *m)
 {
        apic_printk(APIC_VERBOSE, "Lint: type %d, pol %d, trig %d, bus %02x,"
                " IRQ %02x, APIC ID %x, APIC LINT %02x\n",
-                m->mpc_irqtype, m->mpc_irqflag & 3,
+                m->irqtype, m->irqflag & 3, (m->irqflag >> 2) & 3, m->srcbusid,
-                (m->mpc_irqflag >> 2) & 3, m->mpc_srcbusid,
+                m->srcbusirq, m->destapic, m->destapiclint);
-                m->mpc_srcbusirq, m->mpc_destapic, m->mpc_destapiclint);
 }
 /*
 * Read/parse the MPC
 */
-static int __init smp_check_mpc(struct mp_config_table *mpc, char *oem,
+static int __init smp_check_mpc(struct mpc_table *mpc, char *oem, char *str)
-                                char *str)
 {
-        if (memcmp(mpc->mpc_signature, MPC_SIGNATURE, 4)) {
+        if (memcmp(mpc->signature, MPC_SIGNATURE, 4)) {
                printk(KERN_ERR "MPTABLE: bad signature [%c%c%c%c]!\n",
-                       mpc->mpc_signature[0], mpc->mpc_signature[1],
+                       mpc->signature[0], mpc->signature[1],
-                       mpc->mpc_signature[2], mpc->mpc_signature[3]);
+                       mpc->signature[2], mpc->signature[3]);
                return 0;
        }
-        if (mpf_checksum((unsigned char *)mpc, mpc->mpc_length)) {
+        if (mpf_checksum((unsigned char *)mpc, mpc->length)) {
                printk(KERN_ERR "MPTABLE: checksum error!\n");
                return 0;
        }
-        if (mpc->mpc_spec != 0x01 && mpc->mpc_spec != 0x04) {
+        if (mpc->spec != 0x01 && mpc->spec != 0x04) {
                printk(KERN_ERR "MPTABLE: bad table version (%d)!!\n",
-                       mpc->mpc_spec);
+                       mpc->spec);
                return 0;
        }
-        if (!mpc->mpc_lapic) {
+        if (!mpc->lapic) {
                printk(KERN_ERR "MPTABLE: null local APIC address!\n");
                return 0;
        }
-        memcpy(oem, mpc->mpc_oem, 8);
+        memcpy(oem, mpc->oem, 8);
        oem[8] = 0;
        printk(KERN_INFO "MPTABLE: OEM ID: %s\n", oem);
-        memcpy(str, mpc->mpc_productid, 12);
+        memcpy(str, mpc->productid, 12);
        str[12] = 0;
        printk(KERN_INFO "MPTABLE: Product ID: %s\n", str);
-        printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->mpc_lapic);
+        printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->lapic);
        return 1;
 }
-static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
+static int __init smp_read_mpc(struct mpc_table *mpc, unsigned early)
 {
        char str[16];
        char oem[10];
@@ -308,14 +304,14 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
 #endif
        /* save the local APIC address, it might be non-default */
        if (!acpi_lapic)
-                mp_lapic_addr = mpc->mpc_lapic;
+                mp_lapic_addr = mpc->lapic;
        if (early)
                return 1;
-        if (mpc->mpc_oemptr && x86_quirks->smp_read_mpc_oem) {
+        if (mpc->oemptr && x86_quirks->smp_read_mpc_oem) {
-                struct mp_config_oemtable *oem_table = (struct mp_config_oemtable *)(unsigned long)mpc->mpc_oemptr;
+                struct mpc_oemtable *oem_table = (void *)(long)mpc->oemptr;
-                x86_quirks->smp_read_mpc_oem(oem_table, mpc->mpc_oemsize);
+                x86_quirks->smp_read_mpc_oem(oem_table, mpc->oemsize);
        }
        /*
@@ -324,12 +320,11 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
        if (x86_quirks->mpc_record)
                *x86_quirks->mpc_record = 0;
-        while (count < mpc->mpc_length) {
+        while (count < mpc->length) {
                switch (*mpt) {
                case MP_PROCESSOR:
                        {
-                                struct mpc_config_processor *m =
+                                struct mpc_cpu *m = (struct mpc_cpu *)mpt;
-                                    (struct mpc_config_processor *)mpt;
                                /* ACPI may have already provided this data */
                                if (!acpi_lapic)
                                        MP_processor_info(m);
@@ -339,8 +334,7 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
                        }
                case MP_BUS:
                        {
-                                struct mpc_config_bus *m =
+                                struct mpc_bus *m = (struct mpc_bus *)mpt;
-                                    (struct mpc_config_bus *)mpt;
 #ifdef CONFIG_X86_IO_APIC
                                MP_bus_info(m);
 #endif
@@ -351,30 +345,28 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
                case MP_IOAPIC:
                        {
 #ifdef CONFIG_X86_IO_APIC
-                                struct mpc_config_ioapic *m =
+                                struct mpc_ioapic *m = (struct mpc_ioapic *)mpt;
-                                    (struct mpc_config_ioapic *)mpt;
                                MP_ioapic_info(m);
 #endif
-                                mpt += sizeof(struct mpc_config_ioapic);
+                                mpt += sizeof(struct mpc_ioapic);
-                                count += sizeof(struct mpc_config_ioapic);
+                                count += sizeof(struct mpc_ioapic);
                                break;
                        }
                case MP_INTSRC:
                        {
 #ifdef CONFIG_X86_IO_APIC
-                                struct mpc_config_intsrc *m =
+                                struct mpc_intsrc *m = (struct mpc_intsrc *)mpt;
-                                    (struct mpc_config_intsrc *)mpt;
                                MP_intsrc_info(m);
 #endif
-                                mpt += sizeof(struct mpc_config_intsrc);
+                                mpt += sizeof(struct mpc_intsrc);
-                                count += sizeof(struct mpc_config_intsrc);
+                                count += sizeof(struct mpc_intsrc);
                                break;
                        }
                case MP_LINTSRC:
                        {
-                                struct mpc_config_lintsrc *m =
+                                struct mpc_lintsrc *m =
-                                    (struct mpc_config_lintsrc *)mpt;
+                                    (struct mpc_lintsrc *)mpt;
                                MP_lintsrc_info(m);
                                mpt += sizeof(*m);
                                count += sizeof(*m);
@@ -385,8 +377,8 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
                        printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
                        printk(KERN_ERR "type %x\n", *mpt);
                        print_hex_dump(KERN_ERR, "  ", DUMP_PREFIX_ADDRESS, 16,
-                                        1, mpc, mpc->mpc_length, 1);
+                                        1, mpc, mpc->length, 1);
-                        count = mpc->mpc_length;
+                        count = mpc->length;
                        break;
                }
                if (x86_quirks->mpc_record)
@@ -417,16 +409,16 @@ static int __init ELCR_trigger(unsigned int irq)
 static void __init construct_default_ioirq_mptable(int mpc_default_type)
 {
-        struct mpc_config_intsrc intsrc;
+        struct mpc_intsrc intsrc;
        int i;
        int ELCR_fallback = 0;
-        intsrc.mpc_type = MP_INTSRC;
+        intsrc.type = MP_INTSRC;
-        intsrc.mpc_irqflag = 0; /* conforming */
+        intsrc.irqflag = 0;     /* conforming */
-        intsrc.mpc_srcbus = 0;
+        intsrc.srcbus = 0;
-        intsrc.mpc_dstapic = mp_ioapics[0].mp_apicid;
+        intsrc.dstapic = mp_ioapics[0].mp_apicid;
-        intsrc.mpc_irqtype = mp_INT;
+        intsrc.irqtype = mp_INT;
        /*
         *  If true, we have an ISA/PCI system with no IRQ entries
@@ -469,30 +461,30 @@ static void __init construct_default_ioirq_mptable(int mpc_default_type)
                         *  irqflag field (level sensitive, active high polarity).
                         */
                        if (ELCR_trigger(i))
-                                intsrc.mpc_irqflag = 13;
+                                intsrc.irqflag = 13;
                        else
-                                intsrc.mpc_irqflag = 0;
+                                intsrc.irqflag = 0;
                }
-                intsrc.mpc_srcbusirq = i;
+                intsrc.srcbusirq = i;
-                intsrc.mpc_dstirq = i ? i : 2;  /* IRQ0 to INTIN2 */
+                intsrc.dstirq = i ? i : 2;      /* IRQ0 to INTIN2 */
                MP_intsrc_info(&intsrc);
        }
-        intsrc.mpc_irqtype = mp_ExtINT;
+        intsrc.irqtype = mp_ExtINT;
-        intsrc.mpc_srcbusirq = 0;
+        intsrc.srcbusirq = 0;
-        intsrc.mpc_dstirq = 0;  /* 8259A to INTIN0 */
+        intsrc.dstirq = 0;      /* 8259A to INTIN0 */
        MP_intsrc_info(&intsrc);
 }
 static void __init construct_ioapic_table(int mpc_default_type)
 {
-        struct mpc_config_ioapic ioapic;
+        struct mpc_ioapic ioapic;
-        struct mpc_config_bus bus;
+        struct mpc_bus bus;
-        bus.mpc_type = MP_BUS;
+        bus.type = MP_BUS;
-        bus.mpc_busid = 0;
+        bus.busid = 0;
        switch (mpc_default_type) {
        default:
                printk(KERN_ERR "???\nUnknown standard configuration %d\n",
@@ -500,29 +492,29 @@ static void __init construct_ioapic_table(int mpc_default_type)
                /* fall through */
        case 1:
        case 5:
-                memcpy(bus.mpc_bustype, "ISA   ", 6);
+                memcpy(bus.bustype, "ISA   ", 6);
                break;
        case 2:
        case 6:
        case 3:
-                memcpy(bus.mpc_bustype, "EISA  ", 6);
+                memcpy(bus.bustype, "EISA  ", 6);
                break;
        case 4:
        case 7:
-                memcpy(bus.mpc_bustype, "MCA   ", 6);
+                memcpy(bus.bustype, "MCA   ", 6);
        }
        MP_bus_info(&bus);
        if (mpc_default_type > 4) {
-                bus.mpc_busid = 1;
+                bus.busid = 1;
-                memcpy(bus.mpc_bustype, "PCI   ", 6);
+                memcpy(bus.bustype, "PCI   ", 6);
                MP_bus_info(&bus);
        }
-        ioapic.mpc_type = MP_IOAPIC;
+        ioapic.type = MP_IOAPIC;
-        ioapic.mpc_apicid = 2;
+        ioapic.apicid = 2;
-        ioapic.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
+        ioapic.apicver = mpc_default_type > 4 ? 0x10 : 0x01;
-        ioapic.mpc_flags = MPC_APIC_USABLE;
+        ioapic.flags = MPC_APIC_USABLE;
-        ioapic.mpc_apicaddr = 0xFEC00000;
+        ioapic.apicaddr = 0xFEC00000;
        MP_ioapic_info(&ioapic);
        /*
@@ -536,8 +528,8 @@ static inline void __init construct_ioapic_table(int mpc_default_type) { }
 static inline void __init construct_default_ISA_mptable(int mpc_default_type)
 {
-        struct mpc_config_processor processor;
+        struct mpc_cpu processor;
-        struct mpc_config_lintsrc lintsrc;
+        struct mpc_lintsrc lintsrc;
        int linttypes[2] = { mp_ExtINT, mp_NMI };
        int i;
@@ -549,30 +541,30 @@ static inline void __init construct_default_ISA_mptable(int mpc_default_type)
        /*
         * 2 CPUs, numbered 0 & 1.
         */
-        processor.mpc_type = MP_PROCESSOR;
+        processor.type = MP_PROCESSOR;
        /* Either an integrated APIC or a discrete 82489DX. */
-        processor.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
+        processor.apicver = mpc_default_type > 4 ? 0x10 : 0x01;
-        processor.mpc_cpuflag = CPU_ENABLED;
+        processor.cpuflag = CPU_ENABLED;
-        processor.mpc_cpufeature = (boot_cpu_data.x86 << 8) |
+        processor.cpufeature = (boot_cpu_data.x86 << 8) |
            (boot_cpu_data.x86_model << 4) | boot_cpu_data.x86_mask;
-        processor.mpc_featureflag = boot_cpu_data.x86_capability[0];
+        processor.featureflag = boot_cpu_data.x86_capability[0];
-        processor.mpc_reserved[0] = 0;
+        processor.reserved[0] = 0;
-        processor.mpc_reserved[1] = 0;
+        processor.reserved[1] = 0;
        for (i = 0; i < 2; i++) {
-                processor.mpc_apicid = i;
+                processor.apicid = i;
                MP_processor_info(&processor);
        }
        construct_ioapic_table(mpc_default_type);
-        lintsrc.mpc_type = MP_LINTSRC;
+        lintsrc.type = MP_LINTSRC;
-        lintsrc.mpc_irqflag = 0;        /* conforming */
+        lintsrc.irqflag = 0;            /* conforming */
-        lintsrc.mpc_srcbusid = 0;
+        lintsrc.srcbusid = 0;
-        lintsrc.mpc_srcbusirq = 0;
+        lintsrc.srcbusirq = 0;
-        lintsrc.mpc_destapic = MP_APIC_ALL;
+        lintsrc.destapic = MP_APIC_ALL;
        for (i = 0; i < 2; i++) {
-                lintsrc.mpc_irqtype = linttypes[i];
+                lintsrc.irqtype = linttypes[i];
-                lintsrc.mpc_destapiclint = i;
+                lintsrc.destapiclint = i;
                MP_lintsrc_info(&lintsrc);
        }
 }
@@ -657,15 +649,15 @@ static void __init __get_smp_config(unsigned int early)
                 * ISA defaults and hope it will work.
                 */
                if (!mp_irq_entries) {
-                        struct mpc_config_bus bus;
+                        struct mpc_bus bus;
                        printk(KERN_ERR "BIOS bug, no explicit IRQ entries, "
                               "using default mptable. "
                               "(tell your hw vendor)\n");
-                        bus.mpc_type = MP_BUS;
+                        bus.type = MP_BUS;
-                        bus.mpc_busid = 0;
+                        bus.busid = 0;
-                        memcpy(bus.mpc_bustype, "ISA   ", 6);
+                        memcpy(bus.bustype, "ISA   ", 6);
                        MP_bus_info(&bus);
                        construct_default_ioirq_mptable(0);
@@ -803,14 +795,14 @@ void __init find_smp_config(void)
 #ifdef CONFIG_X86_IO_APIC
 static u8 __initdata irq_used[MAX_IRQ_SOURCES];
-static int  __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
+static int  __init get_MP_intsrc_index(struct mpc_intsrc *m)
 {
        int i;
-        if (m->mpc_irqtype != mp_INT)
+        if (m->irqtype != mp_INT)
                return 0;
-        if (m->mpc_irqflag != 0x0f)
+        if (m->irqflag != 0x0f)
                return 0;
        /* not legacy */
@@ -822,9 +814,9 @@ static int  __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
                if (mp_irqs[i].mp_irqflag != 0x0f)
                        continue;
-                if (mp_irqs[i].mp_srcbus != m->mpc_srcbus)
+                if (mp_irqs[i].mp_srcbus != m->srcbus)
                        continue;
-                if (mp_irqs[i].mp_srcbusirq != m->mpc_srcbusirq)
+                if (mp_irqs[i].mp_srcbusirq != m->srcbusirq)
                        continue;
                if (irq_used[i]) {
                        /* already claimed */
@@ -840,10 +832,10 @@ static int  __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
 #define SPARE_SLOT_NUM 20
-static struct mpc_config_intsrc __initdata *m_spare[SPARE_SLOT_NUM];
+static struct mpc_intsrc __initdata *m_spare[SPARE_SLOT_NUM];
 #endif
-static int  __init replace_intsrc_all(struct mp_config_table *mpc,
+static int  __init replace_intsrc_all(struct mpc_table *mpc,
                                        unsigned long mpc_new_phys,
                                        unsigned long mpc_new_length)
 {
@@ -855,36 +847,33 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
        int count = sizeof(*mpc);
        unsigned char *mpt = ((unsigned char *)mpc) + count;
-        printk(KERN_INFO "mpc_length %x\n", mpc->mpc_length);
+        printk(KERN_INFO "mpc_length %x\n", mpc->length);
-        while (count < mpc->mpc_length) {
+        while (count < mpc->length) {
                switch (*mpt) {
                case MP_PROCESSOR:
                        {
-                                struct mpc_config_processor *m =
+                                struct mpc_cpu *m = (struct mpc_cpu *)mpt;
-                                    (struct mpc_config_processor *)mpt;
                                mpt += sizeof(*m);
                                count += sizeof(*m);
                                break;
                        }
                case MP_BUS:
                        {
-                                struct mpc_config_bus *m =
+                                struct mpc_bus *m = (struct mpc_bus *)mpt;
-                                    (struct mpc_config_bus *)mpt;
                                mpt += sizeof(*m);
                                count += sizeof(*m);
                                break;
                        }
                case MP_IOAPIC:
                        {
-                                mpt += sizeof(struct mpc_config_ioapic);
+                                mpt += sizeof(struct mpc_ioapic);
-                                count += sizeof(struct mpc_config_ioapic);
+                                count += sizeof(struct mpc_ioapic);
                                break;
                        }
                case MP_INTSRC:
                        {
 #ifdef CONFIG_X86_IO_APIC
-                                struct mpc_config_intsrc *m =
+                                struct mpc_intsrc *m = (struct mpc_intsrc *)mpt;
-                                    (struct mpc_config_intsrc *)mpt;
                                printk(KERN_INFO "OLD ");
                                print_MP_intsrc_info(m);
@@ -905,14 +894,14 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                                        nr_m_spare++;
                                }
 #endif
-                                mpt += sizeof(struct mpc_config_intsrc);
+                                mpt += sizeof(struct mpc_intsrc);
-                                count += sizeof(struct mpc_config_intsrc);
+                                count += sizeof(struct mpc_intsrc);
                                break;
                        }
                case MP_LINTSRC:
                        {
-                                struct mpc_config_lintsrc *m =
+                                struct mpc_lintsrc *m =
-                                    (struct mpc_config_lintsrc *)mpt;
+                                    (struct mpc_lintsrc *)mpt;
                                mpt += sizeof(*m);
                                count += sizeof(*m);
                                break;
@@ -922,7 +911,7 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                        printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
                        printk(KERN_ERR "type %x\n", *mpt);
                        print_hex_dump(KERN_ERR, "  ", DUMP_PREFIX_ADDRESS, 16,
-                                        1, mpc, mpc->mpc_length, 1);
+                                        1, mpc, mpc->length, 1);
                        goto out;
                }
        }
@@ -944,9 +933,8 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                        assign_to_mpc_intsrc(&mp_irqs[i], m_spare[nr_m_spare]);
                        m_spare[nr_m_spare] = NULL;
                } else {
-                        struct mpc_config_intsrc *m =
+                        struct mpc_intsrc *m = (struct mpc_intsrc *)mpt;
-                            (struct mpc_config_intsrc *)mpt;
+                        count += sizeof(struct mpc_intsrc);
-                        count += sizeof(struct mpc_config_intsrc);
                        if (!mpc_new_phys) {
                                printk(KERN_INFO "No spare slots, try to append...take your risk, new mpc_length %x\n", count);
                        } else {
@@ -958,17 +946,16 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                                }
                        }
                        assign_to_mpc_intsrc(&mp_irqs[i], m);
-                        mpc->mpc_length = count;
+                        mpc->length = count;
-                        mpt += sizeof(struct mpc_config_intsrc);
+                        mpt += sizeof(struct mpc_intsrc);
                }
                print_mp_irq_info(&mp_irqs[i]);
        }
 #endif
 out:
        /* update checksum */
-        mpc->mpc_checksum = 0;
+        mpc->checksum = 0;
-        mpc->mpc_checksum -= mpf_checksum((unsigned char *)mpc,
+        mpc->checksum -= mpf_checksum((unsigned char *)mpc, mpc->length);
-                                           mpc->mpc_length);
        return 0;
 }
@@ -1014,8 +1001,7 @@ static int __init update_mp_table(void)
        char str[16];
        char oem[10];
        struct intel_mp_floating *mpf;
-        struct mp_config_table *mpc;
+        struct mpc_table *mpc, *mpc_new;
-        struct mp_config_table *mpc_new;
        if (!enable_update_mptable)
                return 0;
@@ -1041,7 +1027,7 @@ static int __init update_mp_table(void)
        printk(KERN_INFO "mpf: %lx\n", virt_to_phys(mpf));
        printk(KERN_INFO "mpf_physptr: %x\n", mpf->mpf_physptr);
-        if (mpc_new_phys && mpc->mpc_length > mpc_new_length) {
+        if (mpc_new_phys && mpc->length > mpc_new_length) {
                mpc_new_phys = 0;
                printk(KERN_INFO "mpc_new_length is %ld, please use alloc_mptable=8k\n",
                         mpc_new_length);
@@ -1050,10 +1036,10 @@ static int __init update_mp_table(void)
        if (!mpc_new_phys) {
                unsigned char old, new;
                /* check if we can change the postion */
-                mpc->mpc_checksum = 0;
+                mpc->checksum = 0;
-                old = mpf_checksum((unsigned char *)mpc, mpc->mpc_length);
+                old = mpf_checksum((unsigned char *)mpc, mpc->length);
-                mpc->mpc_checksum = 0xff;
+                mpc->checksum = 0xff;
-                new = mpf_checksum((unsigned char *)mpc, mpc->mpc_length);
+                new = mpf_checksum((unsigned char *)mpc, mpc->length);
                if (old == new) {
                        printk(KERN_INFO "mpc is readonly, please try alloc_mptable instead\n");
                        return 0;
@@ -1062,7 +1048,7 @@ static int __init update_mp_table(void)
        } else {
                mpf->mpf_physptr = mpc_new_phys;
                mpc_new = phys_to_virt(mpc_new_phys);
-                memcpy(mpc_new, mpc, mpc->mpc_length);
+                memcpy(mpc_new, mpc, mpc->length);
                mpc = mpc_new;
                /* check if we can modify that */
                if (mpc_new_phys - mpf->mpf_physptr) {
diff --git a/arch/x86/kernel/nmi.c b/arch/x86/kernel/nmi.c
index 45a09ccdc214..7228979f1e7f 100644
--- a/arch/x86/kernel/nmi.c
+++ b/arch/x86/kernel/nmi.c
@@ -26,7 +26,6 @@
 #include <linux/kernel_stat.h>
 #include <linux/kdebug.h>
 #include <linux/smp.h>
-#include <linux/nmi.h>
 #include <asm/i8259.h>
 #include <asm/io_apic.h>
diff --git a/arch/x86/kernel/numaq_32.c b/arch/x86/kernel/numaq_32.c
index 0deea37a53cf..f2191d4f2717 100644
--- a/arch/x86/kernel/numaq_32.c
+++ b/arch/x86/kernel/numaq_32.c
@@ -117,16 +117,15 @@ static inline int generate_logical_apicid(int quad, int phys_apicid)
 }
 /* x86_quirks member */
-static int mpc_apic_id(struct mpc_config_processor *m)
+static int mpc_apic_id(struct mpc_cpu *m)
 {
        int quad = translation_table[mpc_record]->trans_quad;
-        int logical_apicid = generate_logical_apicid(quad, m->mpc_apicid);
+        int logical_apicid = generate_logical_apicid(quad, m->apicid);
        printk(KERN_DEBUG "Processor #%d %u:%u APIC version %d (quad %d, apic %d)\n",
-               m->mpc_apicid,
+               m->apicid, (m->cpufeature & CPU_FAMILY_MASK) >> 8,
-               (m->mpc_cpufeature & CPU_FAMILY_MASK) >> 8,
+               (m->cpufeature & CPU_MODEL_MASK) >> 4,
-               (m->mpc_cpufeature & CPU_MODEL_MASK) >> 4,
+               m->apicver, quad, logical_apicid);
-               m->mpc_apicver, quad, logical_apicid);
        return logical_apicid;
 }
@@ -135,26 +134,26 @@ int mp_bus_id_to_node[MAX_MP_BUSSES];
 int mp_bus_id_to_local[MAX_MP_BUSSES];
 /* x86_quirks member */
-static void mpc_oem_bus_info(struct mpc_config_bus *m, char *name)
+static void mpc_oem_bus_info(struct mpc_bus *m, char *name)
 {
        int quad = translation_table[mpc_record]->trans_quad;
        int local = translation_table[mpc_record]->trans_local;
-        mp_bus_id_to_node[m->mpc_busid] = quad;
+        mp_bus_id_to_node[m->busid] = quad;
-        mp_bus_id_to_local[m->mpc_busid] = local;
+        mp_bus_id_to_local[m->busid] = local;
        printk(KERN_INFO "Bus #%d is %s (node %d)\n",
-               m->mpc_busid, name, quad);
+               m->busid, name, quad);
 }
 int quad_local_to_mp_bus_id [NR_CPUS/4][4];
 /* x86_quirks member */
-static void mpc_oem_pci_bus(struct mpc_config_bus *m)
+static void mpc_oem_pci_bus(struct mpc_bus *m)
 {
        int quad = translation_table[mpc_record]->trans_quad;
        int local = translation_table[mpc_record]->trans_local;
-        quad_local_to_mp_bus_id[quad][local] = m->mpc_busid;
+        quad_local_to_mp_bus_id[quad][local] = m->busid;
 }
 static void __init MP_translation_info(struct mpc_config_translation *m)
@@ -186,7 +185,7 @@ static int __init mpf_checksum(unsigned char *mp, int len)
 * Read/parse the MPC oem tables
 */
-static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable,
+static void __init smp_read_mpc_oem(struct mpc_oemtable *oemtable,
                                    unsigned short oemsize)
 {
        int count = sizeof(*oemtable);  /* the header size */
@@ -195,18 +194,18 @@ static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable,
        mpc_record = 0;
        printk(KERN_INFO "Found an OEM MPC table at %8p - parsing it ... \n",
               oemtable);
-        if (memcmp(oemtable->oem_signature, MPC_OEM_SIGNATURE, 4)) {
+        if (memcmp(oemtable->signature, MPC_OEM_SIGNATURE, 4)) {
                printk(KERN_WARNING
                       "SMP mpc oemtable: bad signature [%c%c%c%c]!\n",
-                       oemtable->oem_signature[0], oemtable->oem_signature[1],
+                       oemtable->signature[0], oemtable->signature[1],
-                       oemtable->oem_signature[2], oemtable->oem_signature[3]);
+                       oemtable->signature[2], oemtable->signature[3]);
                return;
        }
-        if (mpf_checksum((unsigned char *)oemtable, oemtable->oem_length)) {
+        if (mpf_checksum((unsigned char *)oemtable, oemtable->length)) {
                printk(KERN_WARNING "SMP oem mptable: checksum error!\n");
                return;
        }
-        while (count < oemtable->oem_length) {
+        while (count < oemtable->length) {
                switch (*oemptr) {
                case MP_TRANSLATION:
                        {
@@ -260,8 +259,7 @@ static struct x86_quirks numaq_x86_quirks __initdata = {
        .update_genapic         = numaq_update_genapic,
 };
-void numaq_mps_oem_check(struct mp_config_table *mpc, char *oem,
+void numaq_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
-                                 char *productid)
 {
        if (strncmp(oem, "IBM NUMA", 8))
                printk("Warning!  Not a NUMA-Q system!\n");
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index 19a1044a0cd9..b25428533141 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -38,7 +38,7 @@ EXPORT_SYMBOL(bad_dma_address);
   be probably a smaller DMA mask, but this is bug-to-bug compatible
   to older i386. */
 struct device x86_dma_fallback_dev = {
-        .bus_id = "fallback device",
+        .init_name = "fallback device",
        .coherent_dma_mask = DMA_32BIT_MASK,
        .dma_mask = &x86_dma_fallback_dev.coherent_dma_mask,
 };
diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
index 3ba155d24884..a546f55c77b4 100644
--- a/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@ -39,11 +39,12 @@
 #include <linux/prctl.h>
 #include <linux/dmi.h>
 #include <linux/ftrace.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/kdebug.h>
-#include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/ldt.h>
 #include <asm/processor.h>
 #include <asm/i387.h>
@@ -56,10 +57,8 @@
 #include <asm/tlbflush.h>
 #include <asm/cpu.h>
-#include <asm/kdebug.h>
 #include <asm/idle.h>
 #include <asm/syscalls.h>
-#include <asm/smp.h>
 #include <asm/ds.h>
 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
@@ -205,7 +204,7 @@ extern void kernel_thread_helper(void);
 /*
 * Create a kernel thread
 */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
+int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 {
        struct pt_regs regs;
@@ -266,7 +265,7 @@ void flush_thread(void)
        tsk->thread.debugreg3 = 0;
        tsk->thread.debugreg6 = 0;
        tsk->thread.debugreg7 = 0;
-        memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));        
+        memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
        clear_tsk_thread_flag(tsk, TIF_DEBUG);
        /*
         * Forget coprocessor state..
@@ -293,9 +292,9 @@ void prepare_to_copy(struct task_struct *tsk)
 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
        unsigned long unused,
-        struct task_struct * p, struct pt_regs * regs)
+        struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs * childregs;
+        struct pt_regs *childregs;
        struct task_struct *tsk;
        int err;
@@ -347,7 +346,7 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 void
 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 {
-        __asm__("movl %0, %%gs" :: "r"(0));
+        __asm__("movl %0, %%gs" : : "r"(0));
        regs->fs                = 0;
        set_fs(USER_DS);
        regs->ds                = __USER_DS;
@@ -638,7 +637,7 @@ asmlinkage int sys_vfork(struct pt_regs regs)
 asmlinkage int sys_execve(struct pt_regs regs)
 {
        int error;
-        char * filename;
+        char *filename;
        filename = getname((char __user *) regs.bx);
        error = PTR_ERR(filename);
diff --git a/arch/x86/kernel/setup_percpu.c b/arch/x86/kernel/setup_percpu.c
index a4b619c33106..55c46074eba0 100644
--- a/arch/x86/kernel/setup_percpu.c
+++ b/arch/x86/kernel/setup_percpu.c
@@ -5,12 +5,11 @@
 #include <linux/percpu.h>
 #include <linux/kexec.h>
 #include <linux/crash_dump.h>
-#include <asm/smp.h>
+#include <linux/smp.h>
-#include <asm/percpu.h>
+#include <linux/topology.h>
 #include <asm/sections.h>
 #include <asm/processor.h>
 #include <asm/setup.h>
-#include <asm/topology.h>
 #include <asm/mpspec.h>
 #include <asm/apicdef.h>
 #include <asm/highmem.h>
@@ -20,8 +19,8 @@ unsigned int num_processors;
 unsigned disabled_cpus __cpuinitdata;
 /* Processor that is doing the boot up */
 unsigned int boot_cpu_physical_apicid = -1U;
-unsigned int max_physical_apicid;
 EXPORT_SYMBOL(boot_cpu_physical_apicid);
+unsigned int max_physical_apicid;
 /* Bitmask of physically existing CPUs */
 physid_mask_t phys_cpu_present_map;
@@ -131,7 +130,27 @@ static void __init setup_cpu_pda_map(void)
        /* point to new pointer table */
        _cpu_pda = new_cpu_pda;
 }
-#endif
+#endif /* CONFIG_SMP && CONFIG_X86_64 */
+#ifdef CONFIG_X86_64
+/* correctly size the local cpu masks */
+static void setup_cpu_local_masks(void)
+{
+        alloc_bootmem_cpumask_var(&cpu_initialized_mask);
+        alloc_bootmem_cpumask_var(&cpu_callin_mask);
+        alloc_bootmem_cpumask_var(&cpu_callout_mask);
+        alloc_bootmem_cpumask_var(&cpu_sibling_setup_mask);
+}
+#else /* CONFIG_X86_32 */
+static inline void setup_cpu_local_masks(void)
+{
+}
+#endif /* CONFIG_X86_32 */
 /*
 * Great future plan:
@@ -187,6 +206,9 @@ void __init setup_per_cpu_areas(void)
        /* Setup node to cpumask map */
        setup_node_to_cpumask_map();
+        /* Setup cpu initialized, callin, callout masks */
+        setup_cpu_local_masks();
 }
 #endif
@@ -280,8 +302,8 @@ static void __cpuinit numa_set_cpumask(int cpu, int enable)
        cpulist_scnprintf(buf, sizeof(buf), mask);
        printk(KERN_DEBUG "%s cpu %d node %d: mask now %s\n",
-                enable? "numa_add_cpu":"numa_remove_cpu", cpu, node, buf);
+                enable ? "numa_add_cpu" : "numa_remove_cpu", cpu, node, buf);
- }
+}
 void __cpuinit numa_add_cpu(int cpu)
 {
diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index beea2649a240..e6faa3316bd2 100644
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -1,7 +1,7 @@
 /*
 *      Intel SMP support routines.
 *
- *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
+ *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
 *      (c) 1998-99, 2000 Ingo Molnar <mingo@redhat.com>
 *      (c) 2002,2003 Andi Kleen, SuSE Labs.
 *
@@ -128,16 +128,23 @@ void native_send_call_func_single_ipi(int cpu)
 void native_send_call_func_ipi(const struct cpumask *mask)
 {
-        cpumask_t allbutself;
+        cpumask_var_t allbutself;
-        allbutself = cpu_online_map;
+        if (!alloc_cpumask_var(&allbutself, GFP_ATOMIC)) {
-        cpu_clear(smp_processor_id(), allbutself);
+                send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
+                return;
+        }
-        if (cpus_equal(*mask, allbutself) &&
+        cpumask_copy(allbutself, cpu_online_mask);
-            cpus_equal(cpu_online_map, cpu_callout_map))
+        cpumask_clear_cpu(smp_processor_id(), allbutself);
+        if (cpumask_equal(mask, allbutself) &&
+            cpumask_equal(cpu_online_mask, cpu_callout_mask))
                send_IPI_allbutself(CALL_FUNCTION_VECTOR);
        else
                send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
+        free_cpumask_var(allbutself);
 }
 /*
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 6bd4d9b73870..bb1a3b1fc87f 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -1,7 +1,7 @@
 /*
 *      x86 SMP booting functions
 *
- *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
+ *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
 *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
 *      Copyright 2001 Andi Kleen, SuSE Labs.
 *
@@ -102,9 +102,6 @@ EXPORT_SYMBOL(smp_num_siblings);
 /* Last level cache ID of each logical CPU */
 DEFINE_PER_CPU(u16, cpu_llc_id) = BAD_APICID;
-cpumask_t cpu_callin_map;
-cpumask_t cpu_callout_map;
 /* representing HT siblings of each logical CPU */
 DEFINE_PER_CPU(cpumask_t, cpu_sibling_map);
 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
@@ -120,9 +117,6 @@ EXPORT_PER_CPU_SYMBOL(cpu_info);
 static atomic_t init_deasserted;
-/* representing cpus for which sibling maps can be computed */
-static cpumask_t cpu_sibling_setup_map;
 /* Set if we find a B stepping CPU */
 static int __cpuinitdata smp_b_stepping;
@@ -140,7 +134,7 @@ EXPORT_SYMBOL(cpu_to_node_map);
 static void map_cpu_to_node(int cpu, int node)
 {
        printk(KERN_INFO "Mapping cpu %d to node %d\n", cpu, node);
-        cpu_set(cpu, node_to_cpumask_map[node]);
+        cpumask_set_cpu(cpu, &node_to_cpumask_map[node]);
        cpu_to_node_map[cpu] = node;
 }
@@ -151,7 +145,7 @@ static void unmap_cpu_to_node(int cpu)
        printk(KERN_INFO "Unmapping cpu %d from all nodes\n", cpu);
        for (node = 0; node < MAX_NUMNODES; node++)
-                cpu_clear(cpu, node_to_cpumask_map[node]);
+                cpumask_clear_cpu(cpu, &node_to_cpumask_map[node]);
        cpu_to_node_map[cpu] = 0;
 }
 #else /* !(CONFIG_NUMA && CONFIG_X86_32) */
@@ -209,7 +203,7 @@ static void __cpuinit smp_callin(void)
         */
        phys_id = read_apic_id();
        cpuid = smp_processor_id();
-        if (cpu_isset(cpuid, cpu_callin_map)) {
+        if (cpumask_test_cpu(cpuid, cpu_callin_mask)) {
                panic("%s: phys CPU#%d, CPU#%d already present??\n", __func__,
                                        phys_id, cpuid);
        }
@@ -231,7 +225,7 @@ static void __cpuinit smp_callin(void)
                /*
                 * Has the boot CPU finished it's STARTUP sequence?
                 */
-                if (cpu_isset(cpuid, cpu_callout_map))
+                if (cpumask_test_cpu(cpuid, cpu_callout_mask))
                        break;
                cpu_relax();
        }
@@ -274,7 +268,7 @@ static void __cpuinit smp_callin(void)
        /*
         * Allow the master to continue.
         */
-        cpu_set(cpuid, cpu_callin_map);
+        cpumask_set_cpu(cpuid, cpu_callin_mask);
 }
 static int __cpuinitdata unsafe_smp;
@@ -332,7 +326,7 @@ notrace static void __cpuinit start_secondary(void *unused)
        ipi_call_lock();
        lock_vector_lock();
        __setup_vector_irq(smp_processor_id());
-        cpu_set(smp_processor_id(), cpu_online_map);
+        set_cpu_online(smp_processor_id(), true);
        unlock_vector_lock();
        ipi_call_unlock();
        per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
@@ -438,50 +432,52 @@ void __cpuinit set_cpu_sibling_map(int cpu)
        int i;
        struct cpuinfo_x86 *c = &cpu_data(cpu);
-        cpu_set(cpu, cpu_sibling_setup_map);
+        cpumask_set_cpu(cpu, cpu_sibling_setup_mask);
        if (smp_num_siblings > 1) {
-                for_each_cpu_mask_nr(i, cpu_sibling_setup_map) {
+                for_each_cpu(i, cpu_sibling_setup_mask) {
-                        if (c->phys_proc_id == cpu_data(i).phys_proc_id &&
+                        struct cpuinfo_x86 *o = &cpu_data(i);
-                            c->cpu_core_id == cpu_data(i).cpu_core_id) {
-                                cpu_set(i, per_cpu(cpu_sibling_map, cpu));
+                        if (c->phys_proc_id == o->phys_proc_id &&
-                                cpu_set(cpu, per_cpu(cpu_sibling_map, i));
+                            c->cpu_core_id == o->cpu_core_id) {
-                                cpu_set(i, per_cpu(cpu_core_map, cpu));
+                                cpumask_set_cpu(i, cpu_sibling_mask(cpu));
-                                cpu_set(cpu, per_cpu(cpu_core_map, i));
+                                cpumask_set_cpu(cpu, cpu_sibling_mask(i));
-                                cpu_set(i, c->llc_shared_map);
+                                cpumask_set_cpu(i, cpu_core_mask(cpu));
-                                cpu_set(cpu, cpu_data(i).llc_shared_map);
+                                cpumask_set_cpu(cpu, cpu_core_mask(i));
+                                cpumask_set_cpu(i, &c->llc_shared_map);
+                                cpumask_set_cpu(cpu, &o->llc_shared_map);
                        }
                }
        } else {
-                cpu_set(cpu, per_cpu(cpu_sibling_map, cpu));
+                cpumask_set_cpu(cpu, cpu_sibling_mask(cpu));
        }
-        cpu_set(cpu, c->llc_shared_map);
+        cpumask_set_cpu(cpu, &c->llc_shared_map);
        if (current_cpu_data.x86_max_cores == 1) {
-                per_cpu(cpu_core_map, cpu) = per_cpu(cpu_sibling_map, cpu);
+                cpumask_copy(cpu_core_mask(cpu), cpu_sibling_mask(cpu));
                c->booted_cores = 1;
                return;
        }
-        for_each_cpu_mask_nr(i, cpu_sibling_setup_map) {
+        for_each_cpu(i, cpu_sibling_setup_mask) {
                if (per_cpu(cpu_llc_id, cpu) != BAD_APICID &&
                    per_cpu(cpu_llc_id, cpu) == per_cpu(cpu_llc_id, i)) {
-                        cpu_set(i, c->llc_shared_map);
+                        cpumask_set_cpu(i, &c->llc_shared_map);
-                        cpu_set(cpu, cpu_data(i).llc_shared_map);
+                        cpumask_set_cpu(cpu, &cpu_data(i).llc_shared_map);
                }
                if (c->phys_proc_id == cpu_data(i).phys_proc_id) {
-                        cpu_set(i, per_cpu(cpu_core_map, cpu));
+                        cpumask_set_cpu(i, cpu_core_mask(cpu));
-                        cpu_set(cpu, per_cpu(cpu_core_map, i));
+                        cpumask_set_cpu(cpu, cpu_core_mask(i));
                        /*
                         *  Does this new cpu bringup a new core?
                         */
-                        if (cpus_weight(per_cpu(cpu_sibling_map, cpu)) == 1) {
+                        if (cpumask_weight(cpu_sibling_mask(cpu)) == 1) {
                                /*
                                 * for each core in package, increment
                                 * the booted_cores for this new cpu
                                 */
-                                if (first_cpu(per_cpu(cpu_sibling_map, i)) == i)
+                                if (cpumask_first(cpu_sibling_mask(i)) == i)
                                        c->booted_cores++;
                                /*
                                 * increment the core count for all
@@ -504,7 +500,7 @@ const struct cpumask *cpu_coregroup_mask(int cpu)
         * And for power savings, we return cpu_core_map
         */
        if (sched_mc_power_savings || sched_smt_power_savings)
-                return &per_cpu(cpu_core_map, cpu);
+                return cpu_core_mask(cpu);
        else
                return &c->llc_shared_map;
 }
@@ -523,7 +519,7 @@ static void impress_friends(void)
         */
        pr_debug("Before bogomips.\n");
        for_each_possible_cpu(cpu)
-                if (cpu_isset(cpu, cpu_callout_map))
+                if (cpumask_test_cpu(cpu, cpu_callout_mask))
                        bogosum += cpu_data(cpu).loops_per_jiffy;
        printk(KERN_INFO
                "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
@@ -904,19 +900,19 @@ do_rest:
                 * allow APs to start initializing.
                 */
                pr_debug("Before Callout %d.\n", cpu);
-                cpu_set(cpu, cpu_callout_map);
+                cpumask_set_cpu(cpu, cpu_callout_mask);
                pr_debug("After Callout %d.\n", cpu);
                /*
                 * Wait 5s total for a response
                 */
                for (timeout = 0; timeout < 50000; timeout++) {
-                        if (cpu_isset(cpu, cpu_callin_map))
+                        if (cpumask_test_cpu(cpu, cpu_callin_mask))
                                break;  /* It has booted */
                        udelay(100);
                }
-                if (cpu_isset(cpu, cpu_callin_map)) {
+                if (cpumask_test_cpu(cpu, cpu_callin_mask)) {
                        /* number CPUs logically, starting from 1 (BSP is 0) */
                        pr_debug("OK.\n");
                        printk(KERN_INFO "CPU%d: ", cpu);
@@ -941,9 +937,14 @@ restore_state:
        if (boot_error) {
                /* Try to put things back the way they were before ... */
                numa_remove_cpu(cpu); /* was set by numa_add_cpu */
-                cpu_clear(cpu, cpu_callout_map); /* was set by do_boot_cpu() */
-                cpu_clear(cpu, cpu_initialized); /* was set by cpu_init() */
+                /* was set by do_boot_cpu() */
-                cpu_clear(cpu, cpu_present_map);
+                cpumask_clear_cpu(cpu, cpu_callout_mask);
+                /* was set by cpu_init() */
+                cpumask_clear_cpu(cpu, cpu_initialized_mask);
+                set_cpu_present(cpu, false);
                per_cpu(x86_cpu_to_apicid, cpu) = BAD_APICID;
        }
@@ -977,7 +978,7 @@ int __cpuinit native_cpu_up(unsigned int cpu)
        /*
         * Already booted CPU?
         */
-        if (cpu_isset(cpu, cpu_callin_map)) {
+        if (cpumask_test_cpu(cpu, cpu_callin_mask)) {
                pr_debug("do_boot_cpu %d Already started\n", cpu);
                return -ENOSYS;
        }
@@ -1032,8 +1033,9 @@ int __cpuinit native_cpu_up(unsigned int cpu)
 */
 static __init void disable_smp(void)
 {
-        cpu_present_map = cpumask_of_cpu(0);
+        /* use the read/write pointers to the present and possible maps */
-        cpu_possible_map = cpumask_of_cpu(0);
+        cpumask_copy(&cpu_present_map, cpumask_of(0));
+        cpumask_copy(&cpu_possible_map, cpumask_of(0));
        smpboot_clear_io_apic_irqs();
        if (smp_found_config)
@@ -1041,8 +1043,8 @@ static __init void disable_smp(void)
        else
                physid_set_mask_of_physid(0, &phys_cpu_present_map);
        map_cpu_to_logical_apicid();
-        cpu_set(0, per_cpu(cpu_sibling_map, 0));
+        cpumask_set_cpu(0, cpu_sibling_mask(0));
-        cpu_set(0, per_cpu(cpu_core_map, 0));
+        cpumask_set_cpu(0, cpu_core_mask(0));
 }
 /*
@@ -1064,14 +1066,14 @@ static int __init smp_sanity_check(unsigned max_cpus)
                nr = 0;
                for_each_present_cpu(cpu) {
                        if (nr >= 8)
-                                cpu_clear(cpu, cpu_present_map);
+                                set_cpu_present(cpu, false);
                        nr++;
                }
                nr = 0;
                for_each_possible_cpu(cpu) {
                        if (nr >= 8)
-                                cpu_clear(cpu, cpu_possible_map);
+                                set_cpu_possible(cpu, false);
                        nr++;
                }
@@ -1167,7 +1169,7 @@ void __init native_smp_prepare_cpus(unsigned int max_cpus)
        preempt_disable();
        smp_cpu_index_default();
        current_cpu_data = boot_cpu_data;
-        cpu_callin_map = cpumask_of_cpu(0);
+        cpumask_copy(cpu_callin_mask, cpumask_of(0));
        mb();
        /*
         * Setup boot CPU information
@@ -1242,8 +1244,8 @@ void __init native_smp_prepare_boot_cpu(void)
        init_gdt(me);
 #endif
        switch_to_new_gdt();
-        /* already set me in cpu_online_map in boot_cpu_init() */
+        /* already set me in cpu_online_mask in boot_cpu_init() */
-        cpu_set(me, cpu_callout_map);
+        cpumask_set_cpu(me, cpu_callout_mask);
        per_cpu(cpu_state, me) = CPU_ONLINE;
 }
@@ -1311,7 +1313,7 @@ __init void prefill_possible_map(void)
                possible, max_t(int, possible - num_processors, 0));
        for (i = 0; i < possible; i++)
-                cpu_set(i, cpu_possible_map);
+                set_cpu_possible(i, true);
        nr_cpu_ids = possible;
 }
@@ -1323,31 +1325,31 @@ static void remove_siblinginfo(int cpu)
        int sibling;
        struct cpuinfo_x86 *c = &cpu_data(cpu);
-        for_each_cpu_mask_nr(sibling, per_cpu(cpu_core_map, cpu)) {
+        for_each_cpu(sibling, cpu_core_mask(cpu)) {
-                cpu_clear(cpu, per_cpu(cpu_core_map, sibling));
+                cpumask_clear_cpu(cpu, cpu_core_mask(sibling));
                /*/
                 * last thread sibling in this cpu core going down
                 */
-                if (cpus_weight(per_cpu(cpu_sibling_map, cpu)) == 1)
+                if (cpumask_weight(cpu_sibling_mask(cpu)) == 1)
                        cpu_data(sibling).booted_cores--;
        }
-        for_each_cpu_mask_nr(sibling, per_cpu(cpu_sibling_map, cpu))
+        for_each_cpu(sibling, cpu_sibling_mask(cpu))
-                cpu_clear(cpu, per_cpu(cpu_sibling_map, sibling));
+                cpumask_clear_cpu(cpu, cpu_sibling_mask(sibling));
-        cpus_clear(per_cpu(cpu_sibling_map, cpu));
+        cpumask_clear(cpu_sibling_mask(cpu));
-        cpus_clear(per_cpu(cpu_core_map, cpu));
+        cpumask_clear(cpu_core_mask(cpu));
        c->phys_proc_id = 0;
        c->cpu_core_id = 0;
-        cpu_clear(cpu, cpu_sibling_setup_map);
+        cpumask_clear_cpu(cpu, cpu_sibling_setup_mask);
 }
 static void __ref remove_cpu_from_maps(int cpu)
 {
-        cpu_clear(cpu, cpu_online_map);
+        set_cpu_online(cpu, false);
-        cpu_clear(cpu, cpu_callout_map);
+        cpumask_clear_cpu(cpu, cpu_callout_mask);
-        cpu_clear(cpu, cpu_callin_map);
+        cpumask_clear_cpu(cpu, cpu_callin_mask);
        /* was set by cpu_init() */
-        cpu_clear(cpu, cpu_initialized);
+        cpumask_clear_cpu(cpu, cpu_initialized_mask);
        numa_remove_cpu(cpu);
 }
diff --git a/arch/x86/kernel/time_32.c b/arch/x86/kernel/time_32.c
index 65309e4cb1c0..3985cac0ed47 100644
--- a/arch/x86/kernel/time_32.c
+++ b/arch/x86/kernel/time_32.c
@@ -105,8 +105,8 @@ irqreturn_t timer_interrupt(int irq, void *dev_id)
                high bit of the PPI port B (0x61).  Note that some PS/2s,
                notably the 55SX, work fine if this is removed.  */
-                u8 irq_v = inb_p( 0x61 );       /* read the current state */
+                u8 irq_v = inb_p(0x61);         /* read the current state */
-                outb_p( irq_v|0x80, 0x61 );     /* reset the IRQ */
+                outb_p(irq_v | 0x80, 0x61);     /* reset the IRQ */
        }
 #endif
diff --git a/arch/x86/kernel/time_64.c b/arch/x86/kernel/time_64.c
index 891e7a7c4334..e6e695acd725 100644
--- a/arch/x86/kernel/time_64.c
+++ b/arch/x86/kernel/time_64.c
@@ -17,10 +17,10 @@
 #include <linux/module.h>
 #include <linux/time.h>
 #include <linux/mca.h>
+#include <linux/nmi.h>
 #include <asm/i8253.h>
 #include <asm/hpet.h>
-#include <asm/nmi.h>
 #include <asm/vgtod.h>
 #include <asm/time.h>
 #include <asm/timer.h>
diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
index c9a666cdd3db..98c2d055284b 100644
--- a/arch/x86/kernel/traps.c
+++ b/arch/x86/kernel/traps.c
@@ -63,9 +63,6 @@
 #else
 #include <asm/processor-flags.h>
 #include <asm/arch_hooks.h>
-#include <asm/nmi.h>
-#include <asm/smp.h>
-#include <asm/io.h>
 #include <asm/traps.h>
 #include "cpu/mcheck/mce.h"
diff --git a/arch/x86/kernel/visws_quirks.c b/arch/x86/kernel/visws_quirks.c
index 0c9667f0752a..d801d06af068 100644
--- a/arch/x86/kernel/visws_quirks.c
+++ b/arch/x86/kernel/visws_quirks.c
@@ -176,33 +176,31 @@ static int __init visws_get_smp_config(unsigned int early)
 * No problem for Linux.
 */
-static void __init MP_processor_info(struct mpc_config_processor *m)
+static void __init MP_processor_info(struct mpc_cpu *m)
 {
        int ver, logical_apicid;
        physid_mask_t apic_cpus;
-        if (!(m->mpc_cpuflag & CPU_ENABLED))
+        if (!(m->cpuflag & CPU_ENABLED))
                return;
-        logical_apicid = m->mpc_apicid;
+        logical_apicid = m->apicid;
        printk(KERN_INFO "%sCPU #%d %u:%u APIC version %d\n",
-               m->mpc_cpuflag & CPU_BOOTPROCESSOR ? "Bootup " : "",
+               m->cpuflag & CPU_BOOTPROCESSOR ? "Bootup " : "",
-               m->mpc_apicid,
+               m->apicid, (m->cpufeature & CPU_FAMILY_MASK) >> 8,
-               (m->mpc_cpufeature & CPU_FAMILY_MASK) >> 8,
+               (m->cpufeature & CPU_MODEL_MASK) >> 4, m->apicver);
-               (m->mpc_cpufeature & CPU_MODEL_MASK) >> 4,
-               m->mpc_apicver);
-        if (m->mpc_cpuflag & CPU_BOOTPROCESSOR)
+        if (m->cpuflag & CPU_BOOTPROCESSOR)
-                boot_cpu_physical_apicid = m->mpc_apicid;
+                boot_cpu_physical_apicid = m->apicid;
-        ver = m->mpc_apicver;
+        ver = m->apicver;
-        if ((ver >= 0x14 && m->mpc_apicid >= 0xff) || m->mpc_apicid >= 0xf) {
+        if ((ver >= 0x14 && m->apicid >= 0xff) || m->apicid >= 0xf) {
                printk(KERN_ERR "Processor #%d INVALID. (Max ID: %d).\n",
-                        m->mpc_apicid, MAX_APICS);
+                        m->apicid, MAX_APICS);
                return;
        }
-        apic_cpus = apicid_to_cpu_present(m->mpc_apicid);
+        apic_cpus = apicid_to_cpu_present(m->apicid);
        physids_or(phys_cpu_present_map, phys_cpu_present_map, apic_cpus);
        /*
         * Validate version
@@ -210,15 +208,15 @@ static void __init MP_processor_info(struct mpc_config_processor *m)
        if (ver == 0x0) {
                printk(KERN_ERR "BIOS bug, APIC version is 0 for CPU#%d! "
                        "fixing up to 0x10. (tell your hw vendor)\n",
-                        m->mpc_apicid);
+                        m->apicid);
                ver = 0x10;
        }
-        apic_version[m->mpc_apicid] = ver;
+        apic_version[m->apicid] = ver;
 }
 static int __init visws_find_smp_config(unsigned int reserve)
 {
-        struct mpc_config_processor *mp = phys_to_virt(CO_CPU_TAB_PHYS);
+        struct mpc_cpu *mp = phys_to_virt(CO_CPU_TAB_PHYS);
        unsigned short ncpus = readw(phys_to_virt(CO_CPU_NUM_PHYS));
        if (ncpus > CO_CPU_MAX) {
diff --git a/arch/x86/mach-generic/es7000.c b/arch/x86/mach-generic/es7000.c
index 4ba5ccaa1584..c2ded1448024 100644
--- a/arch/x86/mach-generic/es7000.c
+++ b/arch/x86/mach-generic/es7000.c
@@ -43,12 +43,12 @@ static void __init enable_apic_mode(void)
        return;
 }
-static __init int mps_oem_check(struct mp_config_table *mpc, char *oem,
+static __init int
-                char *productid)
+mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
 {
-        if (mpc->mpc_oemptr) {
+        if (mpc->oemptr) {
-                struct mp_config_oemtable *oem_table =
+                struct mpc_oemtable *oem_table =
-                        (struct mp_config_oemtable *)mpc->mpc_oemptr;
+                        (struct mpc_oemtable *)mpc->oemptr;
                if (!strncmp(oem, "UNISYS", 6))
                        return parse_unisys_oem((char *)oem_table);
        }
diff --git a/arch/x86/mach-generic/numaq.c b/arch/x86/mach-generic/numaq.c
index 511d7941364f..3679e2255645 100644
--- a/arch/x86/mach-generic/numaq.c
+++ b/arch/x86/mach-generic/numaq.c
@@ -19,8 +19,7 @@
 #include <asm/numaq/wakecpu.h>
 #include <asm/numaq.h>
-static int mps_oem_check(struct mp_config_table *mpc, char *oem,
+static int mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
-                char *productid)
 {
        numaq_mps_oem_check(mpc, oem, productid);
        return found_numaq;
diff --git a/arch/x86/mach-generic/probe.c b/arch/x86/mach-generic/probe.c
index c346d9d0226f..15a38daef1a8 100644
--- a/arch/x86/mach-generic/probe.c
+++ b/arch/x86/mach-generic/probe.c
@@ -110,8 +110,7 @@ void __init generic_apic_probe(void)
 /* These functions can switch the APIC even after the initial ->probe() */
-int __init mps_oem_check(struct mp_config_table *mpc, char *oem,
+int __init mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
-                                 char *productid)
 {
        int i;
        for (i = 0; apic_probe[i]; ++i) {
diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c
index 544d724caeee..88f1b10de3be 100644
--- a/arch/x86/mm/init_32.c
+++ b/arch/x86/mm/init_32.c
@@ -328,6 +328,8 @@ int devmem_is_allowed(unsigned long pagenr)
 {
        if (pagenr <= 256)
                return 1;
+        if (iomem_is_exclusive(pagenr << PAGE_SHIFT))
+                return 0;
        if (!page_is_ram(pagenr))
                return 1;
        return 0;
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 54c437e96541..23f68e77ad1f 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -888,6 +888,8 @@ int devmem_is_allowed(unsigned long pagenr)
 {
        if (pagenr <= 256)
                return 1;
+        if (iomem_is_exclusive(pagenr << PAGE_SHIFT))
+                return 0;
        if (!page_is_ram(pagenr))
                return 1;
        return 0;
diff --git a/arch/x86/mm/k8topology_64.c b/arch/x86/mm/k8topology_64.c
index 41f1b5c00a1d..268f8255280f 100644
--- a/arch/x86/mm/k8topology_64.c
+++ b/arch/x86/mm/k8topology_64.c
@@ -81,7 +81,6 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
        unsigned numnodes, cores, bits, apicid_base;
        unsigned long prevbase;
        struct bootnode nodes[8];
-        unsigned char nodeids[8];
        int i, j, nb, found = 0;
        u32 nodeid, reg;
@@ -110,7 +109,6 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
                limit = read_pci_config(0, nb, 1, 0x44 + i*8);
                nodeid = limit & 7;
-                nodeids[i] = nodeid;
                if ((base & 3) == 0) {
                        if (i < numnodes)
                                printk("Skipping disabled node %d\n", i);
@@ -179,9 +177,6 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
                nodes[nodeid].start = base;
                nodes[nodeid].end = limit;
-                e820_register_active_regions(nodeid,
-                                nodes[nodeid].start >> PAGE_SHIFT,
-                                nodes[nodeid].end >> PAGE_SHIFT);
                prevbase = base;
@@ -211,12 +206,15 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
        }
        for (i = 0; i < 8; i++) {
-                if (nodes[i].start != nodes[i].end) {
+                if (nodes[i].start == nodes[i].end)
-                        nodeid = nodeids[i];
+                        continue;
-                        for (j = apicid_base; j < cores + apicid_base; j++)
-                                apicid_to_node[(nodeid << bits) + j] = i;
+                e820_register_active_regions(i,
-                        setup_node_bootmem(i, nodes[i].start, nodes[i].end);
+                                nodes[i].start >> PAGE_SHIFT,
-                }
+                                nodes[i].end >> PAGE_SHIFT);
+                for (j = apicid_base; j < cores + apicid_base; j++)
+                        apicid_to_node[(i << bits) + j] = i;
+                setup_node_bootmem(i, nodes[i].start, nodes[i].end);
        }
        numa_init_array();
diff --git a/arch/x86/mm/numa_32.c b/arch/x86/mm/numa_32.c
index 8518c678d83f..d1f7439d173c 100644
--- a/arch/x86/mm/numa_32.c
+++ b/arch/x86/mm/numa_32.c
@@ -239,7 +239,7 @@ void resume_map_numa_kva(pgd_t *pgd_base)
                start_pfn = node_remap_start_pfn[node];
                size = node_remap_size[node];
-                printk(KERN_DEBUG "%s: node %d\n", __FUNCTION__, node);
+                printk(KERN_DEBUG "%s: node %d\n", __func__, node);
                for (pfn = 0; pfn < size; pfn += PTRS_PER_PTE) {
                        unsigned long vaddr = start_va + (pfn << PAGE_SHIFT);
@@ -251,7 +251,7 @@ void resume_map_numa_kva(pgd_t *pgd_base)
                                                PAGE_KERNEL_LARGE_EXEC));
                        printk(KERN_DEBUG "%s: %08lx -> pfn %08lx\n",
-                                __FUNCTION__, vaddr, start_pfn + pfn);
+                                __func__, vaddr, start_pfn + pfn);
                }
        }
 }
diff --git a/arch/x86/oprofile/op_model_amd.c b/arch/x86/oprofile/op_model_amd.c
index 98658f25f542..8fdf06e4edf9 100644
--- a/arch/x86/oprofile/op_model_amd.c
+++ b/arch/x86/oprofile/op_model_amd.c
@@ -2,7 +2,7 @@
 * @file op_model_amd.c
 * athlon / K7 / K8 / Family 10h model-specific MSR operations
 *
- * @remark Copyright 2002-2008 OProfile authors
+ * @remark Copyright 2002-2009 OProfile authors
 * @remark Read the file COPYING
 *
 * @author John Levon
@@ -10,7 +10,7 @@
 * @author Graydon Hoare
 * @author Robert Richter <robert.richter@amd.com>
 * @author Barry Kasindorf
-*/
+ */
 #include <linux/oprofile.h>
 #include <linux/device.h>
@@ -60,53 +60,10 @@ static unsigned long reset_value[NUM_COUNTERS];
 #define IBS_OP_LOW_VALID_BIT            (1ULL<<18)      /* bit 18 */
 #define IBS_OP_LOW_ENABLE               (1ULL<<17)      /* bit 17 */
-/* Codes used in cpu_buffer.c */
+#define IBS_FETCH_SIZE  6
-/* This produces duplicate code, need to be fixed */
+#define IBS_OP_SIZE     12
-#define IBS_FETCH_BEGIN 3
-#define IBS_OP_BEGIN    4
-/*
- * The function interface needs to be fixed, something like add
- * data. Should then be added to linux/oprofile.h.
- */
-extern void
-oprofile_add_ibs_sample(struct pt_regs * const regs,
-                        unsigned int * const ibs_sample, int ibs_code);
-struct ibs_fetch_sample {
-        /* MSRC001_1031 IBS Fetch Linear Address Register */
-        unsigned int ibs_fetch_lin_addr_low;
-        unsigned int ibs_fetch_lin_addr_high;
-        /* MSRC001_1030 IBS Fetch Control Register */
-        unsigned int ibs_fetch_ctl_low;
-        unsigned int ibs_fetch_ctl_high;
-        /* MSRC001_1032 IBS Fetch Physical Address Register */
-        unsigned int ibs_fetch_phys_addr_low;
-        unsigned int ibs_fetch_phys_addr_high;
-};
-struct ibs_op_sample {
-        /* MSRC001_1034 IBS Op Logical Address Register (IbsRIP) */
-        unsigned int ibs_op_rip_low;
-        unsigned int ibs_op_rip_high;
-        /* MSRC001_1035 IBS Op Data Register */
-        unsigned int ibs_op_data1_low;
-        unsigned int ibs_op_data1_high;
-        /* MSRC001_1036 IBS Op Data 2 Register */
-        unsigned int ibs_op_data2_low;
-        unsigned int ibs_op_data2_high;
-        /* MSRC001_1037 IBS Op Data 3 Register */
-        unsigned int ibs_op_data3_low;
-        unsigned int ibs_op_data3_high;
-        /* MSRC001_1038 IBS DC Linear Address Register (IbsDcLinAd) */
-        unsigned int ibs_dc_linear_low;
-        unsigned int ibs_dc_linear_high;
-        /* MSRC001_1039 IBS DC Physical Address Register (IbsDcPhysAd) */
-        unsigned int ibs_dc_phys_low;
-        unsigned int ibs_dc_phys_high;
-};
-static int ibs_allowed; /* AMD Family10h and later */
+static int has_ibs;     /* AMD Family10h and later */
 struct op_ibs_config {
        unsigned long op_enabled;
@@ -197,31 +154,29 @@ static inline int
 op_amd_handle_ibs(struct pt_regs * const regs,
                  struct op_msrs const * const msrs)
 {
-        unsigned int low, high;
+        u32 low, high;
-        struct ibs_fetch_sample ibs_fetch;
+        u64 msr;
-        struct ibs_op_sample ibs_op;
+        struct op_entry entry;
-        if (!ibs_allowed)
+        if (!has_ibs)
                return 1;
        if (ibs_config.fetch_enabled) {
                rdmsr(MSR_AMD64_IBSFETCHCTL, low, high);
                if (high & IBS_FETCH_HIGH_VALID_BIT) {
-                        ibs_fetch.ibs_fetch_ctl_high = high;
+                        rdmsrl(MSR_AMD64_IBSFETCHLINAD, msr);
-                        ibs_fetch.ibs_fetch_ctl_low = low;
+                        oprofile_write_reserve(&entry, regs, msr,
-                        rdmsr(MSR_AMD64_IBSFETCHLINAD, low, high);
+                                               IBS_FETCH_CODE, IBS_FETCH_SIZE);
-                        ibs_fetch.ibs_fetch_lin_addr_high = high;
+                        oprofile_add_data(&entry, (u32)msr);
-                        ibs_fetch.ibs_fetch_lin_addr_low = low;
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        rdmsr(MSR_AMD64_IBSFETCHPHYSAD, low, high);
+                        oprofile_add_data(&entry, low);
-                        ibs_fetch.ibs_fetch_phys_addr_high = high;
+                        oprofile_add_data(&entry, high);
-                        ibs_fetch.ibs_fetch_phys_addr_low = low;
+                        rdmsrl(MSR_AMD64_IBSFETCHPHYSAD, msr);
+                        oprofile_add_data(&entry, (u32)msr);
-                        oprofile_add_ibs_sample(regs,
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                                                (unsigned int *)&ibs_fetch,
+                        oprofile_write_commit(&entry);
-                                                IBS_FETCH_BEGIN);
                        /* reenable the IRQ */
-                        rdmsr(MSR_AMD64_IBSFETCHCTL, low, high);
                        high &= ~IBS_FETCH_HIGH_VALID_BIT;
                        high |= IBS_FETCH_HIGH_ENABLE;
                        low &= IBS_FETCH_LOW_MAX_CNT_MASK;
@@ -232,30 +187,29 @@ op_amd_handle_ibs(struct pt_regs * const regs,
        if (ibs_config.op_enabled) {
                rdmsr(MSR_AMD64_IBSOPCTL, low, high);
                if (low & IBS_OP_LOW_VALID_BIT) {
-                        rdmsr(MSR_AMD64_IBSOPRIP, low, high);
+                        rdmsrl(MSR_AMD64_IBSOPRIP, msr);
-                        ibs_op.ibs_op_rip_low = low;
+                        oprofile_write_reserve(&entry, regs, msr,
-                        ibs_op.ibs_op_rip_high = high;
+                                               IBS_OP_CODE, IBS_OP_SIZE);
-                        rdmsr(MSR_AMD64_IBSOPDATA, low, high);
+                        oprofile_add_data(&entry, (u32)msr);
-                        ibs_op.ibs_op_data1_low = low;
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        ibs_op.ibs_op_data1_high = high;
+                        rdmsrl(MSR_AMD64_IBSOPDATA, msr);
-                        rdmsr(MSR_AMD64_IBSOPDATA2, low, high);
+                        oprofile_add_data(&entry, (u32)msr);
-                        ibs_op.ibs_op_data2_low = low;
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        ibs_op.ibs_op_data2_high = high;
+                        rdmsrl(MSR_AMD64_IBSOPDATA2, msr);
-                        rdmsr(MSR_AMD64_IBSOPDATA3, low, high);
+                        oprofile_add_data(&entry, (u32)msr);
-                        ibs_op.ibs_op_data3_low = low;
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        ibs_op.ibs_op_data3_high = high;
+                        rdmsrl(MSR_AMD64_IBSOPDATA3, msr);
-                        rdmsr(MSR_AMD64_IBSDCLINAD, low, high);
+                        oprofile_add_data(&entry, (u32)msr);
-                        ibs_op.ibs_dc_linear_low = low;
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        ibs_op.ibs_dc_linear_high = high;
+                        rdmsrl(MSR_AMD64_IBSDCLINAD, msr);
-                        rdmsr(MSR_AMD64_IBSDCPHYSAD, low, high);
+                        oprofile_add_data(&entry, (u32)msr);
-                        ibs_op.ibs_dc_phys_low = low;
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
-                        ibs_op.ibs_dc_phys_high = high;
+                        rdmsrl(MSR_AMD64_IBSDCPHYSAD, msr);
+                        oprofile_add_data(&entry, (u32)msr);
+                        oprofile_add_data(&entry, (u32)(msr >> 32));
+                        oprofile_write_commit(&entry);
                        /* reenable the IRQ */
-                        oprofile_add_ibs_sample(regs,
-                                                (unsigned int *)&ibs_op,
-                                                IBS_OP_BEGIN);
-                        rdmsr(MSR_AMD64_IBSOPCTL, low, high);
                        high = 0;
                        low &= ~IBS_OP_LOW_VALID_BIT;
                        low |= IBS_OP_LOW_ENABLE;
@@ -305,14 +259,14 @@ static void op_amd_start(struct op_msrs const * const msrs)
        }
 #ifdef CONFIG_OPROFILE_IBS
-        if (ibs_allowed && ibs_config.fetch_enabled) {
+        if (has_ibs && ibs_config.fetch_enabled) {
                low = (ibs_config.max_cnt_fetch >> 4) & 0xFFFF;
                high = ((ibs_config.rand_en & 0x1) << 25) /* bit 57 */
                        + IBS_FETCH_HIGH_ENABLE;
                wrmsr(MSR_AMD64_IBSFETCHCTL, low, high);
        }
-        if (ibs_allowed && ibs_config.op_enabled) {
+        if (has_ibs && ibs_config.op_enabled) {
                low = ((ibs_config.max_cnt_op >> 4) & 0xFFFF)
                        + ((ibs_config.dispatched_ops & 0x1) << 19) /* bit 19 */
                        + IBS_OP_LOW_ENABLE;
@@ -341,14 +295,14 @@ static void op_amd_stop(struct op_msrs const * const msrs)
        }
 #ifdef CONFIG_OPROFILE_IBS
-        if (ibs_allowed && ibs_config.fetch_enabled) {
+        if (has_ibs && ibs_config.fetch_enabled) {
                /* clear max count and enable */
                low = 0;
                high = 0;
                wrmsr(MSR_AMD64_IBSFETCHCTL, low, high);
        }
-        if (ibs_allowed && ibs_config.op_enabled) {
+        if (has_ibs && ibs_config.op_enabled) {
                /* clear max count and enable */
                low = 0;
                high = 0;
@@ -409,6 +363,7 @@ static int init_ibs_nmi(void)
                                       | IBSCTL_LVTOFFSETVAL);
                pci_read_config_dword(cpu_cfg, IBSCTL, &value);
                if (value != (ibs_eilvt_off | IBSCTL_LVTOFFSETVAL)) {
+                        pci_dev_put(cpu_cfg);
                        printk(KERN_DEBUG "Failed to setup IBS LVT offset, "
                                "IBSCTL = 0x%08x", value);
                        return 1;
@@ -436,20 +391,20 @@ static int init_ibs_nmi(void)
 /* uninitialize the APIC for the IBS interrupts if needed */
 static void clear_ibs_nmi(void)
 {
-        if (ibs_allowed)
+        if (has_ibs)
                on_each_cpu(apic_clear_ibs_nmi_per_cpu, NULL, 1);
 }
 /* initialize the APIC for the IBS interrupts if available */
 static void ibs_init(void)
 {
-        ibs_allowed = boot_cpu_has(X86_FEATURE_IBS);
+        has_ibs = boot_cpu_has(X86_FEATURE_IBS);
-        if (!ibs_allowed)
+        if (!has_ibs)
                return;
        if (init_ibs_nmi()) {
-                ibs_allowed = 0;
+                has_ibs = 0;
                return;
        }
@@ -458,7 +413,7 @@ static void ibs_init(void)
 static void ibs_exit(void)
 {
-        if (!ibs_allowed)
+        if (!has_ibs)
                return;
        clear_ibs_nmi();
@@ -478,7 +433,7 @@ static int setup_ibs_files(struct super_block *sb, struct dentry *root)
        if (ret)
                return ret;
-        if (!ibs_allowed)
+        if (!has_ibs)
                return ret;
        /* model specific files */
diff --git a/arch/x86/pci/acpi.c b/arch/x86/pci/acpi.c
index 9e5752fe4d15..c0ecf250fe51 100644
--- a/arch/x86/pci/acpi.c
+++ b/arch/x86/pci/acpi.c
@@ -210,11 +210,10 @@ struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int do
        if (bus && node != -1) {
 #ifdef CONFIG_ACPI_NUMA
                if (pxm >= 0)
-                        printk(KERN_DEBUG "bus %02x -> pxm %d -> node %d\n",
+                        dev_printk(KERN_DEBUG, &bus->dev,
-                                busnum, pxm, node);
+                                   "on NUMA node %d (pxm %d)\n", node, pxm);
 #else
-                printk(KERN_DEBUG "bus %02x -> node %d\n",
+                dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
-                        busnum, node);
 #endif
        }
diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c
index 62ddb73e09ed..82d22fc601ae 100644
--- a/arch/x86/pci/common.c
+++ b/arch/x86/pci/common.c
@@ -551,17 +551,25 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
        if ((err = pci_enable_resources(dev, mask)) < 0)
                return err;
-        if (!dev->msi_enabled)
+        if (!pci_dev_msi_enabled(dev))
                return pcibios_enable_irq(dev);
        return 0;
 }
 void pcibios_disable_device (struct pci_dev *dev)
 {
-        if (!dev->msi_enabled && pcibios_disable_irq)
+        if (!pci_dev_msi_enabled(dev) && pcibios_disable_irq)
                pcibios_disable_irq(dev);
 }
+int pci_ext_cfg_avail(struct pci_dev *dev)
+{
+        if (raw_pci_ext_ops)
+                return 1;
+        else
+                return 0;
+}
 struct pci_bus * __devinit pci_scan_bus_on_node(int busno, struct pci_ops *ops, int node)
 {
        struct pci_bus *bus = NULL;
diff --git a/arch/x86/pci/i386.c b/arch/x86/pci/i386.c
index e51bf2cda4b0..f884740da318 100644
--- a/arch/x86/pci/i386.c
+++ b/arch/x86/pci/i386.c
@@ -129,7 +129,7 @@ static void __init pcibios_allocate_bus_resources(struct list_head *bus_list)
                                pr = pci_find_parent_resource(dev, r);
                                if (!r->start || !pr ||
                                    request_resource(pr, r) < 0) {
-                                        dev_err(&dev->dev, "BAR %d: can't allocate resource\n", idx);
+                                        dev_info(&dev->dev, "BAR %d: can't allocate resource\n", idx);
                                        /*
                                         * Something is wrong with the region.
                                         * Invalidate the resource to prevent
@@ -170,7 +170,7 @@ static void __init pcibios_allocate_resources(int pass)
                                        r->flags, disabled, pass);
                                pr = pci_find_parent_resource(dev, r);
                                if (!pr || request_resource(pr, r) < 0) {
-                                        dev_err(&dev->dev, "BAR %d: can't allocate resource\n", idx);
+                                        dev_info(&dev->dev, "BAR %d: can't allocate resource\n", idx);
                                        /* We'll assign a new address later */
                                        r->end -= r->start;
                                        r->start = 0;
diff --git a/arch/x86/pci/init.c b/arch/x86/pci/init.c
index bec3b048e72b..25a1f8efed4a 100644
--- a/arch/x86/pci/init.c
+++ b/arch/x86/pci/init.c
@@ -12,7 +12,8 @@ static __init int pci_arch_init(void)
        type = pci_direct_probe();
 #endif
-        pci_mmcfg_early_init();
+        if (!(pci_probe & PCI_PROBE_NOEARLY))
+                pci_mmcfg_early_init();
 #ifdef CONFIG_PCI_OLPC
        if (!pci_olpc_init())
diff --git a/arch/x86/pci/irq.c b/arch/x86/pci/irq.c
index 373b9afe6d44..4064345cf144 100644
--- a/arch/x86/pci/irq.c
+++ b/arch/x86/pci/irq.c
@@ -533,7 +533,7 @@ static int pirq_bios_set(struct pci_dev *router, struct pci_dev *dev, int pirq,
 {
        struct pci_dev *bridge;
        int pin = pci_get_interrupt_pin(dev, &bridge);
-        return pcibios_set_irq_routing(bridge, pin, irq);
+        return pcibios_set_irq_routing(bridge, pin - 1, irq);
 }
 #endif
@@ -887,7 +887,6 @@ static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
                dev_dbg(&dev->dev, "no interrupt pin\n");
                return 0;
        }
-        pin = pin - 1;
        /* Find IRQ routing entry */
@@ -897,17 +896,17 @@ static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
        info = pirq_get_info(dev);
        if (!info) {
                dev_dbg(&dev->dev, "PCI INT %c not found in routing table\n",
-                        'A' + pin);
+                        'A' + pin - 1);
                return 0;
        }
-        pirq = info->irq[pin].link;
+        pirq = info->irq[pin - 1].link;
-        mask = info->irq[pin].bitmap;
+        mask = info->irq[pin - 1].bitmap;
        if (!pirq) {
-                dev_dbg(&dev->dev, "PCI INT %c not routed\n", 'A' + pin);
+                dev_dbg(&dev->dev, "PCI INT %c not routed\n", 'A' + pin - 1);
                return 0;
        }
        dev_dbg(&dev->dev, "PCI INT %c -> PIRQ %02x, mask %04x, excl %04x",
-                'A' + pin, pirq, mask, pirq_table->exclusive_irqs);
+                'A' + pin - 1, pirq, mask, pirq_table->exclusive_irqs);
        mask &= pcibios_irq_mask;
        /* Work around broken HP Pavilion Notebooks which assign USB to
@@ -949,7 +948,7 @@ static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
                                newirq = i;
                }
        }
-        dev_dbg(&dev->dev, "PCI INT %c -> newirq %d", 'A' + pin, newirq);
+        dev_dbg(&dev->dev, "PCI INT %c -> newirq %d", 'A' + pin - 1, newirq);
        /* Check if it is hardcoded */
        if ((pirq & 0xf0) == 0xf0) {
@@ -977,18 +976,18 @@ static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
                        return 0;
                }
        }
-        dev_info(&dev->dev, "%s PCI INT %c -> IRQ %d\n", msg, 'A' + pin, irq);
+        dev_info(&dev->dev, "%s PCI INT %c -> IRQ %d\n", msg, 'A' + pin - 1, irq);
        /* Update IRQ for all devices with the same pirq value */
        while ((dev2 = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev2)) != NULL) {
                pci_read_config_byte(dev2, PCI_INTERRUPT_PIN, &pin);
                if (!pin)
                        continue;
-                pin--;
                info = pirq_get_info(dev2);
                if (!info)
                        continue;
-                if (info->irq[pin].link == pirq) {
+                if (info->irq[pin - 1].link == pirq) {
                        /*
                         * We refuse to override the dev->irq
                         * information. Give a warning!
@@ -1042,6 +1041,9 @@ static void __init pcibios_fixup_irqs(void)
        dev = NULL;
        while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
                pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
+                if (!pin)
+                        continue;
 #ifdef CONFIG_X86_IO_APIC
                /*
                 * Recalculate IRQ numbers if we use the I/O APIC.
@@ -1049,15 +1051,11 @@ static void __init pcibios_fixup_irqs(void)
                if (io_apic_assign_pci_irqs) {
                        int irq;
-                        if (!pin)
-                                continue;
                        /*
                         * interrupt pins are numbered starting from 1
                         */
-                        pin--;
                        irq = IO_APIC_get_PCI_irq_vector(dev->bus->number,
-                                PCI_SLOT(dev->devfn), pin);
+                                PCI_SLOT(dev->devfn), pin - 1);
                        /*
                         * Busses behind bridges are typically not listed in the
                         * MP-table.  In this case we have to look up the IRQ
@@ -1070,22 +1068,22 @@ static void __init pcibios_fixup_irqs(void)
                                struct pci_dev *bridge = dev->bus->self;
                                int bus;
-                                pin = (pin + PCI_SLOT(dev->devfn)) % 4;
+                                pin = pci_swizzle_interrupt_pin(dev, pin);
                                bus = bridge->bus->number;
                                irq = IO_APIC_get_PCI_irq_vector(bus,
-                                                PCI_SLOT(bridge->devfn), pin);
+                                                PCI_SLOT(bridge->devfn), pin - 1);
                                if (irq >= 0)
                                        dev_warn(&dev->dev,
                                                "using bridge %s INT %c to "
                                                        "get IRQ %d\n",
                                                 pci_name(bridge),
-                                                 'A' + pin, irq);
+                                                 'A' + pin - 1, irq);
                        }
                        if (irq >= 0) {
                                dev_info(&dev->dev,
                                        "PCI->APIC IRQ transform: INT %c "
                                                "-> IRQ %d\n",
-                                        'A' + pin, irq);
+                                        'A' + pin - 1, irq);
                                dev->irq = irq;
                        }
                }
@@ -1093,7 +1091,7 @@ static void __init pcibios_fixup_irqs(void)
                /*
                 * Still no IRQ? Try to lookup one...
                 */
-                if (pin && !dev->irq)
+                if (!dev->irq)
                        pcibios_lookup_irq(dev, 0);
        }
 }
@@ -1220,12 +1218,10 @@ static int pirq_enable_irq(struct pci_dev *dev)
        if (pin && !pcibios_lookup_irq(dev, 1) && !dev->irq) {
                char *msg = "";
-                pin--; /* interrupt pins are numbered starting from 1 */
                if (io_apic_assign_pci_irqs) {
                        int irq;
-                        irq = IO_APIC_get_PCI_irq_vector(dev->bus->number, PCI_SLOT(dev->devfn), pin);
+                        irq = IO_APIC_get_PCI_irq_vector(dev->bus->number, PCI_SLOT(dev->devfn), pin - 1);
                        /*
                         * Busses behind bridges are typically not listed in the MP-table.
                         * In this case we have to look up the IRQ based on the parent bus,
@@ -1236,20 +1232,20 @@ static int pirq_enable_irq(struct pci_dev *dev)
                        while (irq < 0 && dev->bus->parent) { /* go back to the bridge */
                                struct pci_dev *bridge = dev->bus->self;
-                                pin = (pin + PCI_SLOT(dev->devfn)) % 4;
+                                pin = pci_swizzle_interrupt_pin(dev, pin);
                                irq = IO_APIC_get_PCI_irq_vector(bridge->bus->number,
-                                                PCI_SLOT(bridge->devfn), pin);
+                                                PCI_SLOT(bridge->devfn), pin - 1);
                                if (irq >= 0)
                                        dev_warn(&dev->dev, "using bridge %s "
                                                 "INT %c to get IRQ %d\n",
-                                                 pci_name(bridge), 'A' + pin,
+                                                 pci_name(bridge), 'A' + pin - 1,
                                                 irq);
                                dev = bridge;
                        }
                        dev = temp_dev;
                        if (irq >= 0) {
                                dev_info(&dev->dev, "PCI->APIC IRQ transform: "
-                                         "INT %c -> IRQ %d\n", 'A' + pin, irq);
+                                         "INT %c -> IRQ %d\n", 'A' + pin - 1, irq);
                                dev->irq = irq;
                                return 0;
                        } else
@@ -1268,7 +1264,7 @@ static int pirq_enable_irq(struct pci_dev *dev)
                        return 0;
                dev_warn(&dev->dev, "can't find IRQ for PCI INT %c%s\n",
-                         'A' + pin, msg);
+                         'A' + pin - 1, msg);
        }
        return 0;
 }
diff --git a/arch/x86/pci/visws.c b/arch/x86/pci/visws.c
index 16d0c0eb0d19..bcead7a46871 100644
--- a/arch/x86/pci/visws.c
+++ b/arch/x86/pci/visws.c
@@ -24,24 +24,6 @@ static void pci_visws_disable_irq(struct pci_dev *dev) { }
 unsigned int pci_bus0, pci_bus1;
-static inline u8 bridge_swizzle(u8 pin, u8 slot) 
-{
-        return (((pin - 1) + slot) % 4) + 1;
-}
-static u8 __init visws_swizzle(struct pci_dev *dev, u8 *pinp)
-{
-        u8 pin = *pinp;
-        while (dev->bus->self) {        /* Move up the chain of bridges. */
-                pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
-                dev = dev->bus->self;
-        }
-        *pinp = pin;
-        return PCI_SLOT(dev->devfn);
-}
 static int __init visws_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
 {
        int irq, bus = dev->bus->number;
@@ -106,7 +88,7 @@ int __init pci_visws_init(void)
        raw_pci_ops = &pci_direct_conf1;
        pci_scan_bus_with_sysdata(pci_bus0);
        pci_scan_bus_with_sysdata(pci_bus1);
-        pci_fixup_irqs(visws_swizzle, visws_map_irq);
+        pci_fixup_irqs(pci_common_swizzle, visws_map_irq);
        pcibios_resource_survey();
        return 0;
 }
author	Ingo Molnar <mingo@elte.hu>	2009-01-10 21:41:39 -0500
committer	Ingo Molnar <mingo@elte.hu>	2009-01-10 21:41:39 -0500
commit	abede81c4fb2e3b85d8760f25e3da39d2c69a134 (patch)
tree	26c893ec108d837eb9171d678c55a1cea7b22af4 /arch
parent	c9d557c19f94df42db78d4a5de4d25feee694bad (diff)
parent	c59765042f53a79a7a65585042ff463b69cb248c (diff)