Patched in Tegra support.

188 files changed, 3816 insertions, 4927 deletions

diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 3279646120e..3ff7785b3be 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -23,25 +23,12 @@ config IA64
         select HAVE_ARCH_TRACEHOOK
         select HAVE_DMA_API_DEBUG
         select HAVE_GENERIC_HARDIRQS
-        select HAVE_MEMBLOCK
-        select HAVE_MEMBLOCK_NODE_MAP
-        select HAVE_VIRT_CPU_ACCOUNTING
-        select ARCH_DISCARD_MEMBLOCK
         select GENERIC_IRQ_PROBE
         select GENERIC_PENDING_IRQ if SMP
         select IRQ_PER_CPU
         select GENERIC_IRQ_SHOW
         select ARCH_WANT_OPTIONAL_GPIOLIB
         select ARCH_HAVE_NMI_SAFE_CMPXCHG
-        select GENERIC_IOMAP
-        select GENERIC_SMP_IDLE_THREAD
-        select ARCH_INIT_TASK
-        select ARCH_TASK_STRUCT_ALLOCATOR
-        select ARCH_THREAD_INFO_ALLOCATOR
-        select ARCH_CLOCKSOURCE_DATA
-        select GENERIC_TIME_VSYSCALL_OLD
-        select HAVE_MOD_ARCH_SPECIFIC
-        select MODULES_USE_ELF_RELA
         default y
         help
           The Itanium Processor Family is Intel's 64-bit successor to
@@ -97,11 +84,15 @@ config GENERIC_CALIBRATE_DELAY
         bool
         default y
 
+config GENERIC_TIME_VSYSCALL
+        bool
+        default y
+
 config HAVE_SETUP_PER_CPU_AREA
         def_bool y
 
 config GENERIC_GPIO
-        bool
+        def_bool y
 
 config DMI
         bool
@@ -111,6 +102,13 @@ config EFI
         bool
         default y
 
+config GENERIC_IOMAP
+        bool
+        default y
+
+config ARCH_CLOCKSOURCE_DATA
+        def_bool y
+
 config SCHED_OMIT_FRAME_POINTER
         bool
         default y
@@ -129,7 +127,6 @@ config AUDIT_ARCH
 
 menuconfig PARAVIRT_GUEST
         bool "Paravirtualized guest support"
-        depends on BROKEN
         help
           Say Y here to get to see options related to running Linux under
           various hypervisors.  This option alone does not add any kernel code.
@@ -142,6 +139,8 @@ config PARAVIRT
         bool "Enable paravirtualization code"
         depends on PARAVIRT_GUEST
         default y
+        bool
+        default y
         help
           This changes the kernel so it can modify itself when it is run
           under a hypervisor, potentially improving performance significantly
@@ -343,6 +342,17 @@ config FORCE_MAX_ZONEORDER
         default "17" if HUGETLB_PAGE
         default "11"
 
+config VIRT_CPU_ACCOUNTING
+        bool "Deterministic task and CPU time accounting"
+        default n
+        help
+          Select this option to enable more accurate task and CPU time
+          accounting.  This is done by reading a CPU counter on each
+          kernel entry and exit and on transitions within the kernel
+          between system, softirq and hardirq state, so there is a
+          small performance impact.
+          If in doubt, say N here.
+
 config SMP
         bool "Symmetric multi-processing support"
         select USE_GENERIC_SMP_HELPERS
@@ -464,6 +474,9 @@ config NODES_SHIFT
           MAX_NUMNODES will be 2^(This value).
           If in doubt, use the default.
 
+config ARCH_POPULATES_NODE_MAP
+        def_bool y
+
 # VIRTUAL_MEM_MAP and FLAT_NODE_MEM_MAP are functionally equivalent.
 # VIRTUAL_MEM_MAP has been retained for historical reasons.
 config VIRTUAL_MEM_MAP
diff --git a/arch/ia64/configs/generic_defconfig b/arch/ia64/configs/generic_defconfig
index 7913695b2fc..43ab1cd097a 100644
--- a/arch/ia64/configs/generic_defconfig
+++ b/arch/ia64/configs/generic_defconfig
@@ -87,7 +87,6 @@ CONFIG_NET_ETHERNET=y
 CONFIG_NET_TULIP=y
 CONFIG_TULIP=m
 CONFIG_NET_PCI=y
-CONFIG_NET_VENDOR_INTEL=y
 CONFIG_E100=m
 CONFIG_E1000=y
 CONFIG_IGB=y
@@ -234,4 +233,5 @@ CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_MD5=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRC_T10DIF=y
+CONFIG_MISC_DEVICES=y
 CONFIG_INTEL_IOMMU=y
diff --git a/arch/ia64/configs/gensparse_defconfig b/arch/ia64/configs/gensparse_defconfig
index f8e91336542..b11fa880e4b 100644
--- a/arch/ia64/configs/gensparse_defconfig
+++ b/arch/ia64/configs/gensparse_defconfig
@@ -75,7 +75,6 @@ CONFIG_NET_ETHERNET=y
 CONFIG_NET_TULIP=y
 CONFIG_TULIP=m
 CONFIG_NET_PCI=y
-CONFIG_NET_VENDOR_INTEL=y
 CONFIG_E100=m
 CONFIG_E1000=y
 CONFIG_TIGON3=y
@@ -209,3 +208,4 @@ CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_DEBUG_MUTEXES=y
 CONFIG_CRYPTO_MD5=y
+CONFIG_MISC_DEVICES=y
diff --git a/arch/ia64/configs/tiger_defconfig b/arch/ia64/configs/tiger_defconfig
index a5a9e02e60a..137a453dd50 100644
--- a/arch/ia64/configs/tiger_defconfig
+++ b/arch/ia64/configs/tiger_defconfig
@@ -77,7 +77,6 @@ CONFIG_NET_ETHERNET=y
 CONFIG_NET_TULIP=y
 CONFIG_TULIP=m
 CONFIG_NET_PCI=y
-CONFIG_NET_VENDOR_INTEL=y
 CONFIG_E100=m
 CONFIG_E1000=y
 CONFIG_TIGON3=y
diff --git a/arch/ia64/configs/xen_domu_defconfig b/arch/ia64/configs/xen_domu_defconfig
index 37b9b422caa..2bf76e418bc 100644
--- a/arch/ia64/configs/xen_domu_defconfig
+++ b/arch/ia64/configs/xen_domu_defconfig
@@ -80,7 +80,6 @@ CONFIG_NET_ETHERNET=y
 CONFIG_NET_TULIP=y
 CONFIG_TULIP=m
 CONFIG_NET_PCI=y
-CONFIG_NET_VENDOR_INTEL=y
 CONFIG_E100=m
 CONFIG_E1000=y
 CONFIG_TIGON3=y
diff --git a/arch/ia64/configs/zx1_defconfig b/arch/ia64/configs/zx1_defconfig
index fc7aba07c2b..1d42827f9fa 100644
--- a/arch/ia64/configs/zx1_defconfig
+++ b/arch/ia64/configs/zx1_defconfig
@@ -57,7 +57,6 @@ CONFIG_TULIP_MMIO=y
 CONFIG_TULIP_NAPI=y
 CONFIG_TULIP_NAPI_HW_MITIGATION=y
 CONFIG_NET_PCI=y
-CONFIG_NET_VENDOR_INTEL=y
 CONFIG_E100=y
 CONFIG_E1000=y
 CONFIG_TIGON3=y
diff --git a/arch/ia64/dig/setup.c b/arch/ia64/dig/setup.c
index 98131e1db7a..9196b330ff7 100644
--- a/arch/ia64/dig/setup.c
+++ b/arch/ia64/dig/setup.c
@@ -22,7 +22,7 @@
 
 #include <asm/io.h>
 #include <asm/machvec.h>
-#include <asm/setup.h>
+#include <asm/system.h>
 
 void __init
 dig_setup (char **cmdline_p)
diff --git a/arch/ia64/hp/common/aml_nfw.c b/arch/ia64/hp/common/aml_nfw.c
index 6192f718865..22078486d35 100644
--- a/arch/ia64/hp/common/aml_nfw.c
+++ b/arch/ia64/hp/common/aml_nfw.c
@@ -31,7 +31,7 @@ MODULE_AUTHOR("Bjorn Helgaas <bjorn.helgaas@hp.com>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("ACPI opregion handler for native firmware calls");
 
-static bool force_register;
+static int force_register;
 module_param_named(force, force_register, bool, 0);
 MODULE_PARM_DESC(force, "Install opregion handler even without HPQ5001 device");
 
diff --git a/arch/ia64/hp/common/hwsw_iommu.c b/arch/ia64/hp/common/hwsw_iommu.c
index 1e4cae5ae05..e4a80d82e3d 100644
--- a/arch/ia64/hp/common/hwsw_iommu.c
+++ b/arch/ia64/hp/common/hwsw_iommu.c
@@ -15,7 +15,6 @@
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/swiotlb.h>
-#include <linux/export.h>
 #include <asm/machvec.h>
 
 extern struct dma_map_ops sba_dma_ops, swiotlb_dma_ops;
diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
index bcda5b2d121..80241fe03f5 100644
--- a/arch/ia64/hp/common/sba_iommu.c
+++ b/arch/ia64/hp/common/sba_iommu.c
@@ -43,6 +43,7 @@
 #include <asm/io.h>
 #include <asm/page.h>           /* PAGE_OFFSET */
 #include <asm/dma.h>
+#include <asm/system.h>         /* wmb() */
 
 #include <asm/acpi-ext.h>
 
@@ -914,7 +915,7 @@ sba_mark_invalid(struct ioc *ioc, dma_addr_t iova, size_t byte_cnt)
  * @dir:  R/W or both.
  * @attrs: optional dma attributes
  *
- * See Documentation/DMA-API-HOWTO.txt
+ * See Documentation/PCI/PCI-DMA-mapping.txt
  */
 static dma_addr_t sba_map_page(struct device *dev, struct page *page,
                                unsigned long poff, size_t size,
@@ -1043,7 +1044,7 @@ sba_mark_clean(struct ioc *ioc, dma_addr_t iova, size_t size)
  * @dir:  R/W or both.
  * @attrs: optional dma attributes
  *
- * See Documentation/DMA-API-HOWTO.txt
+ * See Documentation/PCI/PCI-DMA-mapping.txt
  */
 static void sba_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
                            enum dma_data_direction dir, struct dma_attrs *attrs)
@@ -1126,11 +1127,10 @@ void sba_unmap_single_attrs(struct device *dev, dma_addr_t iova, size_t size,
  * @size:  number of bytes mapped in driver buffer.
  * @dma_handle:  IOVA of new buffer.
  *
- * See Documentation/DMA-API-HOWTO.txt
+ * See Documentation/PCI/PCI-DMA-mapping.txt
  */
 static void *
-sba_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
-                   gfp_t flags, struct dma_attrs *attrs)
+sba_alloc_coherent (struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flags)
 {
         struct ioc *ioc;
         void *addr;
@@ -1190,10 +1190,10 @@ sba_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  * @vaddr:  virtual address IOVA of "consistent" buffer.
  * @dma_handler:  IO virtual address of "consistent" buffer.
  *
- * See Documentation/DMA-API-HOWTO.txt
+ * See Documentation/PCI/PCI-DMA-mapping.txt
  */
-static void sba_free_coherent(struct device *dev, size_t size, void *vaddr,
-                              dma_addr_t dma_handle, struct dma_attrs *attrs)
+static void sba_free_coherent (struct device *dev, size_t size, void *vaddr,
+                               dma_addr_t dma_handle)
 {
         sba_unmap_single_attrs(dev, dma_handle, size, 0, NULL);
         free_pages((unsigned long) vaddr, get_order(size));
@@ -1453,7 +1453,7 @@ static void sba_unmap_sg_attrs(struct device *dev, struct scatterlist *sglist,
  * @dir:  R/W or both.
  * @attrs: optional dma attributes
  *
- * See Documentation/DMA-API-HOWTO.txt
+ * See Documentation/PCI/PCI-DMA-mapping.txt
  */
 static int sba_map_sg_attrs(struct device *dev, struct scatterlist *sglist,
                             int nents, enum dma_data_direction dir,
@@ -1549,7 +1549,7 @@ static int sba_map_sg_attrs(struct device *dev, struct scatterlist *sglist,
  * @dir:  R/W or both.
  * @attrs: optional dma attributes
  *
- * See Documentation/DMA-API-HOWTO.txt
+ * See Documentation/PCI/PCI-DMA-mapping.txt
  */
 static void sba_unmap_sg_attrs(struct device *dev, struct scatterlist *sglist,
                                int nents, enum dma_data_direction dir,
@@ -2213,8 +2213,8 @@ sba_page_override(char *str)
 __setup("sbapagesize=",sba_page_override);
 
 struct dma_map_ops sba_dma_ops = {
-        .alloc                  = sba_alloc_coherent,
-        .free                   = sba_free_coherent,
+        .alloc_coherent         = sba_alloc_coherent,
+        .free_coherent          = sba_free_coherent,
         .map_page               = sba_map_page,
         .unmap_page             = sba_unmap_page,
         .map_sg                 = sba_map_sg_attrs,
diff --git a/arch/ia64/hp/sim/boot/bootloader.c b/arch/ia64/hp/sim/boot/bootloader.c
index 28f4b230b8c..c5e9baafafe 100644
--- a/arch/ia64/hp/sim/boot/bootloader.c
+++ b/arch/ia64/hp/sim/boot/bootloader.c
@@ -20,6 +20,7 @@ struct task_struct;	/* forward declaration for elf.h */
 #include <asm/pal.h>
 #include <asm/pgtable.h>
 #include <asm/sal.h>
+#include <asm/system.h>
 
 #include "ssc.h"
 
diff --git a/arch/ia64/hp/sim/boot/fw-emu.c b/arch/ia64/hp/sim/boot/fw-emu.c
index 271f412bda1..bf6d9d8c802 100644
--- a/arch/ia64/hp/sim/boot/fw-emu.c
+++ b/arch/ia64/hp/sim/boot/fw-emu.c
@@ -13,7 +13,6 @@
 #include <asm/io.h>
 #include <asm/pal.h>
 #include <asm/sal.h>
-#include <asm/setup.h>
 
 #include "ssc.h"
 
@@ -161,19 +160,28 @@ sal_emulator (long index, unsigned long in1, unsigned long in2,
          */
         status = 0;
         if (index == SAL_FREQ_BASE) {
-                if (in1 == SAL_FREQ_BASE_PLATFORM)
+                switch (in1) {
+                      case SAL_FREQ_BASE_PLATFORM:
                         r9 = 200000000;
-                else if (in1 == SAL_FREQ_BASE_INTERVAL_TIMER) {
+                        break;
+
+                      case SAL_FREQ_BASE_INTERVAL_TIMER:
                         /*
                          * Is this supposed to be the cr.itc frequency
                          * or something platform specific?  The SAL
                          * doc ain't exactly clear on this...
                          */
                         r9 = 700000000;
-                } else if (in1 == SAL_FREQ_BASE_REALTIME_CLOCK)
+                        break;
+
+                      case SAL_FREQ_BASE_REALTIME_CLOCK:
                         r9 = 1;
-                else
+                        break;
+
+                      default:
                         status = -1;
+                        break;
+                }
         } else if (index == SAL_SET_VECTORS) {
                 ;
         } else if (index == SAL_GET_STATE_INFO) {
diff --git a/arch/ia64/hp/sim/hpsim_irq.c b/arch/ia64/hp/sim/hpsim_irq.c
index 0aa70ebda49..4bd9a63260e 100644
--- a/arch/ia64/hp/sim/hpsim_irq.c
+++ b/arch/ia64/hp/sim/hpsim_irq.c
@@ -10,8 +10,6 @@
 #include <linux/sched.h>
 #include <linux/irq.h>
 
-#include "hpsim_ssc.h"
-
 static unsigned int
 hpsim_irq_startup(struct irq_data *data)
 {
@@ -39,37 +37,15 @@ static struct irq_chip irq_type_hp_sim = {
         .irq_set_affinity =     hpsim_set_affinity_noop,
 };
 
-static void hpsim_irq_set_chip(int irq)
-{
-        struct irq_chip *chip = irq_get_chip(irq);
-
-        if (chip == &no_irq_chip)
-                irq_set_chip(irq, &irq_type_hp_sim);
-}
-
-static void hpsim_connect_irq(int intr, int irq)
-{
-        ia64_ssc(intr, irq, 0, 0, SSC_CONNECT_INTERRUPT);
-}
-
-int hpsim_get_irq(int intr)
-{
-        int irq = assign_irq_vector(AUTO_ASSIGN);
-
-        if (irq >= 0) {
-                hpsim_irq_set_chip(irq);
-                irq_set_handler(irq, handle_simple_irq);
-                hpsim_connect_irq(intr, irq);
-        }
-
-        return irq;
-}
-
 void __init
 hpsim_irq_init (void)
 {
         int i;
 
-        for_each_active_irq(i)
-                hpsim_irq_set_chip(i);
+        for_each_active_irq(i) {
+                struct irq_chip *chip = irq_get_chip(i);
+
+                if (chip == &no_irq_chip)
+                        irq_set_chip(i, &irq_type_hp_sim);
+        }
 }
diff --git a/arch/ia64/hp/sim/hpsim_setup.c b/arch/ia64/hp/sim/hpsim_setup.c
index 664a5402a69..f629e903ebc 100644
--- a/arch/ia64/hp/sim/hpsim_setup.c
+++ b/arch/ia64/hp/sim/hpsim_setup.c
@@ -26,6 +26,12 @@
 #include "hpsim_ssc.h"
 
 void
+ia64_ssc_connect_irq (long intr, long irq)
+{
+        ia64_ssc(intr, irq, 0, 0, SSC_CONNECT_INTERRUPT);
+}
+
+void
 ia64_ctl_trace (long on)
 {
         ia64_ssc(on, 0, 0, 0, SSC_CTL_TRACE);
diff --git a/arch/ia64/hp/sim/simeth.c b/arch/ia64/hp/sim/simeth.c
index c13064e422d..7e81966ce48 100644
--- a/arch/ia64/hp/sim/simeth.c
+++ b/arch/ia64/hp/sim/simeth.c
@@ -20,6 +20,7 @@
 #include <linux/skbuff.h>
 #include <linux/notifier.h>
 #include <linux/bitops.h>
+#include <asm/system.h>
 #include <asm/irq.h>
 #include <asm/hpsim.h>
 
@@ -128,6 +129,17 @@ netdev_probe(char *name, unsigned char *ether)
 
 
 static inline int
+netdev_connect(int irq)
+{
+        /* XXX Fix me
+         * this does not support multiple cards
+         * also no return value
+         */
+        ia64_ssc_connect_irq(NETWORK_INTR, irq);
+        return 0;
+}
+
+static inline int
 netdev_attach(int fd, int irq, unsigned int ipaddr)
 {
         /* this puts the host interface in the right mode (start interrupting) */
@@ -160,7 +172,7 @@ static const struct net_device_ops simeth_netdev_ops = {
         .ndo_stop               = simeth_close,
         .ndo_start_xmit         = simeth_tx,
         .ndo_get_stats          = simeth_get_stats,
-        .ndo_set_rx_mode        = set_multicast_list, /* not yet used */
+        .ndo_set_multicast_list = set_multicast_list, /* not yet used */
 
 };
 
@@ -181,7 +193,7 @@ simeth_probe1(void)
         unsigned char mac_addr[ETH_ALEN];
         struct simeth_local *local;
         struct net_device *dev;
-        int fd, err, rc;
+        int fd, i, err, rc;
 
         /*
          * XXX Fix me
@@ -214,16 +226,22 @@ simeth_probe1(void)
                 return err;
         }
 
+        if ((rc = assign_irq_vector(AUTO_ASSIGN)) < 0)
+                panic("%s: out of interrupt vectors!\n", __func__);
+        dev->irq = rc;
+
         /*
          * attach the interrupt in the simulator, this does enable interrupts
          * until a netdev_attach() is called
          */
-        if ((rc = hpsim_get_irq(NETWORK_INTR)) < 0)
-                panic("%s: out of interrupt vectors!\n", __func__);
-        dev->irq = rc;
+        netdev_connect(dev->irq);
 
-        printk(KERN_INFO "%s: hosteth=%s simfd=%d, HwAddr=%pm, IRQ %d\n",
-               dev->name, simeth_device, local->simfd, dev->dev_addr, dev->irq);
+        printk(KERN_INFO "%s: hosteth=%s simfd=%d, HwAddr",
+               dev->name, simeth_device, local->simfd);
+        for(i = 0; i < ETH_ALEN; i++) {
+                printk(" %2.2x", dev->dev_addr[i]);
+        }
+        printk(", IRQ %d\n", dev->irq);
 
         return 0;
 }
diff --git a/arch/ia64/hp/sim/simserial.c b/arch/ia64/hp/sim/simserial.c
index fc3924d18c1..bff0824cf8a 100644
--- a/arch/ia64/hp/sim/simserial.c
+++ b/arch/ia64/hp/sim/simserial.c
@@ -4,11 +4,16 @@
  * This driver is mostly used for bringup purposes and will go away.
  * It has a strong dependency on the system console. All outputs
  * are rerouted to the same facility as the one used by printk which, in our
- * case means sys_sim.c console (goes via the simulator).
+ * case means sys_sim.c console (goes via the simulator). The code hereafter
+ * is completely leveraged from the serial.c driver.
  *
  * Copyright (C) 1999-2000, 2002-2003 Hewlett-Packard Co
  *      Stephane Eranian <eranian@hpl.hp.com>
  *      David Mosberger-Tang <davidm@hpl.hp.com>
+ *
+ * 02/04/00 D. Mosberger        Merged in serial.c bug fixes in rs_close().
+ * 02/25/00 D. Mosberger        Synced up with 2.3.99pre-5 version of serial.c.
+ * 07/30/02 D. Mosberger        Replace sti()/cli() with explicit spinlocks & local irq masking
  */
 
 #include <linux/init.h>
@@ -22,17 +27,15 @@
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/capability.h>
-#include <linux/circ_buf.h>
 #include <linux/console.h>
-#include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/serial.h>
+#include <linux/serialP.h>
 #include <linux/sysrq.h>
-#include <linux/uaccess.h>
-
-#include <asm/hpsim.h>
 
-#include "hpsim_ssc.h"
+#include <asm/irq.h>
+#include <asm/hw_irq.h>
+#include <asm/uaccess.h>
 
 #undef SIMSERIAL_DEBUG  /* define this to get some debug information */
 
@@ -40,44 +43,118 @@
 
 #define NR_PORTS        1       /* only one port for now */
 
-struct serial_state {
-        struct tty_port port;
-        struct circ_buf xmit;
-        int irq;
-        int x_char;
+#define IRQ_T(info) ((info->flags & ASYNC_SHARE_IRQ) ? IRQF_SHARED : IRQF_DISABLED)
+
+#define SSC_GETCHAR     21
+
+extern long ia64_ssc (long, long, long, long, int);
+extern void ia64_ssc_connect_irq (long intr, long irq);
+
+static char *serial_name = "SimSerial driver";
+static char *serial_version = "0.6";
+
+/*
+ * This has been extracted from asm/serial.h. We need one eventually but
+ * I don't know exactly what we're going to put in it so just fake one
+ * for now.
+ */
+#define BASE_BAUD ( 1843200 / 16 )
+
+#define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST)
+
+/*
+ * Most of the values here are meaningless to this particular driver.
+ * However some values must be preserved for the code (leveraged from serial.c
+ * to work correctly).
+ * port must not be 0
+ * type must not be UNKNOWN
+ * So I picked arbitrary (guess from where?) values instead
+ */
+static struct serial_state rs_table[NR_PORTS]={
+  /* UART CLK   PORT IRQ     FLAGS        */
+  { 0, BASE_BAUD, 0x3F8, 0, STD_COM_FLAGS,0,PORT_16550 }  /* ttyS0 */
 };
 
-static struct serial_state rs_table[NR_PORTS];
+/*
+ * Just for the fun of it !
+ */
+static struct serial_uart_config uart_config[] = {
+        { "unknown", 1, 0 },
+        { "8250", 1, 0 },
+        { "16450", 1, 0 },
+        { "16550", 1, 0 },
+        { "16550A", 16, UART_CLEAR_FIFO | UART_USE_FIFO },
+        { "cirrus", 1, 0 },
+        { "ST16650", 1, UART_CLEAR_FIFO | UART_STARTECH },
+        { "ST16650V2", 32, UART_CLEAR_FIFO | UART_USE_FIFO |
+                  UART_STARTECH },
+        { "TI16750", 64, UART_CLEAR_FIFO | UART_USE_FIFO},
+        { NULL, 0}
+};
 
 struct tty_driver *hp_simserial_driver;
 
+static struct async_struct *IRQ_ports[NR_IRQS];
+
 static struct console *console;
 
-static void receive_chars(struct tty_struct *tty)
+static unsigned char *tmp_buf;
+
+extern struct console *console_drivers; /* from kernel/printk.c */
+
+/*
+ * ------------------------------------------------------------
+ * rs_stop() and rs_start()
+ *
+ * This routines are called before setting or resetting tty->stopped.
+ * They enable or disable transmitter interrupts, as necessary.
+ * ------------------------------------------------------------
+ */
+static void rs_stop(struct tty_struct *tty)
+{
+#ifdef SIMSERIAL_DEBUG
+        printk("rs_stop: tty->stopped=%d tty->hw_stopped=%d tty->flow_stopped=%d\n",
+                tty->stopped, tty->hw_stopped, tty->flow_stopped);
+#endif
+
+}
+
+static void rs_start(struct tty_struct *tty)
+{
+#ifdef SIMSERIAL_DEBUG
+        printk("rs_start: tty->stopped=%d tty->hw_stopped=%d tty->flow_stopped=%d\n",
+                tty->stopped, tty->hw_stopped, tty->flow_stopped);
+#endif
+}
+
+static  void receive_chars(struct tty_struct *tty)
 {
         unsigned char ch;
         static unsigned char seen_esc = 0;
 
         while ( (ch = ia64_ssc(0, 0, 0, 0, SSC_GETCHAR)) ) {
-                if (ch == 27 && seen_esc == 0) {
+                if ( ch == 27 && seen_esc == 0 ) {
                         seen_esc = 1;
                         continue;
-                } else if (seen_esc == 1 && ch == 'O') {
-                        seen_esc = 2;
-                        continue;
-                } else if (seen_esc == 2) {
-                        if (ch == 'P') /* F1 */
-                                show_state();
+                } else {
+                        if ( seen_esc==1 && ch == 'O' ) {
+                                seen_esc = 2;
+                                continue;
+                        } else if ( seen_esc == 2 ) {
+                                if ( ch == 'P' ) /* F1 */
+                                        show_state();
 #ifdef CONFIG_MAGIC_SYSRQ
-                        if (ch == 'S') { /* F4 */
-                                do {
-                                        ch = ia64_ssc(0, 0, 0, 0, SSC_GETCHAR);
-                                } while (!ch);
-                                handle_sysrq(ch);
-                        }
+                                if ( ch == 'S' ) { /* F4 */
+                                        do
+                                                ch = ia64_ssc(0, 0, 0, 0,
+                                                              SSC_GETCHAR);
+                                        while (!ch);
+                                        handle_sysrq(ch);
+                                }
 #endif
-                        seen_esc = 0;
-                        continue;
+                                seen_esc = 0;
+                                continue;
+                        }
                 }
                 seen_esc = 0;
 
@@ -92,19 +169,22 @@ static void receive_chars(struct tty_struct *tty)
  */
 static irqreturn_t rs_interrupt_single(int irq, void *dev_id)
 {
-        struct serial_state *info = dev_id;
-        struct tty_struct *tty = tty_port_tty_get(&info->port);
+        struct async_struct * info;
 
-        if (!tty) {
-                printk(KERN_INFO "%s: tty=0 problem\n", __func__);
+        /*
+         * I don't know exactly why they don't use the dev_id opaque data
+         * pointer instead of this extra lookup table
+         */
+        info = IRQ_ports[irq];
+        if (!info || !info->tty) {
+                printk(KERN_INFO "simrs_interrupt_single: info|tty=0 info=%p problem\n", info);
                 return IRQ_NONE;
         }
         /*
          * pretty simple in our case, because we only get interrupts
          * on inbound traffic
          */
-        receive_chars(tty);
-        tty_kref_put(tty);
+        receive_chars(info->tty);
         return IRQ_HANDLED;
 }
 
@@ -114,12 +194,17 @@ static irqreturn_t rs_interrupt_single(int irq, void *dev_id)
  * -------------------------------------------------------------------
  */
 
+static void do_softint(struct work_struct *private_)
+{
+        printk(KERN_ERR "simserial: do_softint called\n");
+}
+
 static int rs_put_char(struct tty_struct *tty, unsigned char ch)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
         unsigned long flags;
 
-        if (!info->xmit.buf)
+        if (!tty || !info->xmit.buf)
                 return 0;
 
         local_irq_save(flags);
@@ -133,12 +218,12 @@ static int rs_put_char(struct tty_struct *tty, unsigned char ch)
         return 1;
 }
 
-static void transmit_chars(struct tty_struct *tty, struct serial_state *info,
-                int *intr_done)
+static void transmit_chars(struct async_struct *info, int *intr_done)
 {
         int count;
         unsigned long flags;
 
+
         local_irq_save(flags);
 
         if (info->x_char) {
@@ -146,16 +231,16 @@ static void transmit_chars(struct tty_struct *tty, struct serial_state *info,
 
                 console->write(console, &c, 1);
 
+                info->state->icount.tx++;
                 info->x_char = 0;
 
                 goto out;
         }
 
-        if (info->xmit.head == info->xmit.tail || tty->stopped ||
-                        tty->hw_stopped) {
+        if (info->xmit.head == info->xmit.tail || info->tty->stopped || info->tty->hw_stopped) {
 #ifdef SIMSERIAL_DEBUG
                 printk("transmit_chars: head=%d, tail=%d, stopped=%d\n",
-                       info->xmit.head, info->xmit.tail, tty->stopped);
+                       info->xmit.head, info->xmit.tail, info->tty->stopped);
 #endif
                 goto out;
         }
@@ -187,24 +272,24 @@ out:
 
 static void rs_flush_chars(struct tty_struct *tty)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
 
-        if (info->xmit.head == info->xmit.tail || tty->stopped ||
-                        tty->hw_stopped || !info->xmit.buf)
+        if (info->xmit.head == info->xmit.tail || tty->stopped || tty->hw_stopped ||
+            !info->xmit.buf)
                 return;
 
-        transmit_chars(tty, info, NULL);
+        transmit_chars(info, NULL);
 }
 
+
 static int rs_write(struct tty_struct * tty,
                     const unsigned char *buf, int count)
 {
-        struct serial_state *info = tty->driver_data;
         int     c, ret = 0;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
         unsigned long flags;
 
-        if (!info->xmit.buf)
-                return 0;
+        if (!tty || !info->xmit.buf || !tmp_buf) return 0;
 
         local_irq_save(flags);
         while (1) {
@@ -225,30 +310,30 @@ static int rs_write(struct tty_struct * tty,
         /*
          * Hey, we transmit directly from here in our case
          */
-        if (CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE) &&
-                        !tty->stopped && !tty->hw_stopped)
-                transmit_chars(tty, info, NULL);
-
+        if (CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE)
+            && !tty->stopped && !tty->hw_stopped) {
+                transmit_chars(info, NULL);
+        }
         return ret;
 }
 
 static int rs_write_room(struct tty_struct *tty)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
 
         return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 }
 
 static int rs_chars_in_buffer(struct tty_struct *tty)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
 
         return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 }
 
 static void rs_flush_buffer(struct tty_struct *tty)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
         unsigned long flags;
 
         local_irq_save(flags);
@@ -264,7 +349,7 @@ static void rs_flush_buffer(struct tty_struct *tty)
  */
 static void rs_send_xchar(struct tty_struct *tty, char ch)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
 
         info->x_char = ch;
         if (ch) {
@@ -272,7 +357,7 @@ static void rs_send_xchar(struct tty_struct *tty, char ch)
                  * I guess we could call console->write() directly but
                  * let's do that for now.
                  */
-                transmit_chars(tty, info, NULL);
+                transmit_chars(info, NULL);
         }
 }
 
@@ -286,15 +371,14 @@ static void rs_send_xchar(struct tty_struct *tty, char ch)
  */
 static void rs_throttle(struct tty_struct * tty)
 {
-        if (I_IXOFF(tty))
-                rs_send_xchar(tty, STOP_CHAR(tty));
+        if (I_IXOFF(tty)) rs_send_xchar(tty, STOP_CHAR(tty));
 
         printk(KERN_INFO "simrs_throttle called\n");
 }
 
 static void rs_unthrottle(struct tty_struct * tty)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct *info = (struct async_struct *)tty->driver_data;
 
         if (I_IXOFF(tty)) {
                 if (info->x_char)
@@ -305,6 +389,7 @@ static void rs_unthrottle(struct tty_struct * tty)
         printk(KERN_INFO "simrs_unthrottle called\n");
 }
 
+
 static int rs_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
 {
         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
@@ -315,21 +400,48 @@ static int rs_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
         }
 
         switch (cmd) {
-        case TIOCGSERIAL:
-        case TIOCSSERIAL:
-        case TIOCSERGSTRUCT:
-        case TIOCMIWAIT:
-                return 0;
-        case TIOCSERCONFIG:
-        case TIOCSERGETLSR: /* Get line status register */
-                return -EINVAL;
-        case TIOCSERGWILD:
-        case TIOCSERSWILD:
-                /* "setserial -W" is called in Debian boot */
-                printk (KERN_INFO "TIOCSER?WILD ioctl obsolete, ignored.\n");
-                return 0;
-        }
-        return -ENOIOCTLCMD;
+                case TIOCGSERIAL:
+                        printk(KERN_INFO "simrs_ioctl TIOCGSERIAL called\n");
+                        return 0;
+                case TIOCSSERIAL:
+                        printk(KERN_INFO "simrs_ioctl TIOCSSERIAL called\n");
+                        return 0;
+                case TIOCSERCONFIG:
+                        printk(KERN_INFO "rs_ioctl: TIOCSERCONFIG called\n");
+                        return -EINVAL;
+
+                case TIOCSERGETLSR: /* Get line status register */
+                        printk(KERN_INFO "rs_ioctl: TIOCSERGETLSR called\n");
+                        return  -EINVAL;
+
+                case TIOCSERGSTRUCT:
+                        printk(KERN_INFO "rs_ioctl: TIOCSERGSTRUCT called\n");
+#if 0
+                        if (copy_to_user((struct async_struct *) arg,
+                                         info, sizeof(struct async_struct)))
+                                return -EFAULT;
+#endif
+                        return 0;
+
+                /*
+                 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
+                 * - mask passed in arg for lines of interest
+                 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
+                 * Caller should use TIOCGICOUNT to see which one it was
+                 */
+                case TIOCMIWAIT:
+                        printk(KERN_INFO "rs_ioctl: TIOCMIWAIT: called\n");
+                        return 0;
+                case TIOCSERGWILD:
+                case TIOCSERSWILD:
+                        /* "setserial -W" is called in Debian boot */
+                        printk (KERN_INFO "TIOCSER?WILD ioctl obsolete, ignored.\n");
+                        return 0;
+
+                default:
+                        return -ENOIOCTLCMD;
+                }
+        return 0;
 }
 
 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
@@ -338,52 +450,222 @@ static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         /* Handle turning off CRTSCTS */
         if ((old_termios->c_cflag & CRTSCTS) &&
-            !(tty->termios.c_cflag & CRTSCTS)) {
+            !(tty->termios->c_cflag & CRTSCTS)) {
                 tty->hw_stopped = 0;
+                rs_start(tty);
         }
 }
 /*
  * This routine will shutdown a serial port; interrupts are disabled, and
  * DTR is dropped if the hangup on close termio flag is on.
  */
-static void shutdown(struct tty_port *port)
+static void shutdown(struct async_struct * info)
 {
-        struct serial_state *info = container_of(port, struct serial_state,
-                        port);
-        unsigned long flags;
+        unsigned long   flags;
+        struct serial_state *state;
+        int             retval;
+
+        if (!(info->flags & ASYNC_INITIALIZED)) return;
+
+        state = info->state;
+
+#ifdef SIMSERIAL_DEBUG
+        printk("Shutting down serial port %d (irq %d)....", info->line,
+               state->irq);
+#endif
 
         local_irq_save(flags);
-        if (info->irq)
-                free_irq(info->irq, info);
+        {
+                /*
+                 * First unlink the serial port from the IRQ chain...
+                 */
+                if (info->next_port)
+                        info->next_port->prev_port = info->prev_port;
+                if (info->prev_port)
+                        info->prev_port->next_port = info->next_port;
+                else
+                        IRQ_ports[state->irq] = info->next_port;
+
+                /*
+                 * Free the IRQ, if necessary
+                 */
+                if (state->irq && (!IRQ_ports[state->irq] ||
+                                   !IRQ_ports[state->irq]->next_port)) {
+                        if (IRQ_ports[state->irq]) {
+                                free_irq(state->irq, NULL);
+                                retval = request_irq(state->irq, rs_interrupt_single,
+                                                     IRQ_T(info), "serial", NULL);
+
+                                if (retval)
+                                        printk(KERN_ERR "serial shutdown: request_irq: error %d"
+                                               "  Couldn't reacquire IRQ.\n", retval);
+                        } else
+                                free_irq(state->irq, NULL);
+                }
+
+                if (info->xmit.buf) {
+                        free_page((unsigned long) info->xmit.buf);
+                        info->xmit.buf = NULL;
+                }
+
+                if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags);
 
-        if (info->xmit.buf) {
-                free_page((unsigned long) info->xmit.buf);
-                info->xmit.buf = NULL;
+                info->flags &= ~ASYNC_INITIALIZED;
         }
         local_irq_restore(flags);
 }
 
+/*
+ * ------------------------------------------------------------
+ * rs_close()
+ *
+ * This routine is called when the serial port gets closed.  First, we
+ * wait for the last remaining data to be sent.  Then, we unlink its
+ * async structure from the interrupt chain if necessary, and we free
+ * that IRQ if nothing is left in the chain.
+ * ------------------------------------------------------------
+ */
 static void rs_close(struct tty_struct *tty, struct file * filp)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct * info = (struct async_struct *)tty->driver_data;
+        struct serial_state *state;
+        unsigned long flags;
+
+        if (!info ) return;
+
+        state = info->state;
+
+        local_irq_save(flags);
+        if (tty_hung_up_p(filp)) {
+#ifdef SIMSERIAL_DEBUG
+                printk("rs_close: hung_up\n");
+#endif
+                local_irq_restore(flags);
+                return;
+        }
+#ifdef SIMSERIAL_DEBUG
+        printk("rs_close ttys%d, count = %d\n", info->line, state->count);
+#endif
+        if ((tty->count == 1) && (state->count != 1)) {
+                /*
+                 * Uh, oh.  tty->count is 1, which means that the tty
+                 * structure will be freed.  state->count should always
+                 * be one in these conditions.  If it's greater than
+                 * one, we've got real problems, since it means the
+                 * serial port won't be shutdown.
+                 */
+                printk(KERN_ERR "rs_close: bad serial port count; tty->count is 1, "
+                       "state->count is %d\n", state->count);
+                state->count = 1;
+        }
+        if (--state->count < 0) {
+                printk(KERN_ERR "rs_close: bad serial port count for ttys%d: %d\n",
+                       info->line, state->count);
+                state->count = 0;
+        }
+        if (state->count) {
+                local_irq_restore(flags);
+                return;
+        }
+        info->flags |= ASYNC_CLOSING;
+        local_irq_restore(flags);
 
-        tty_port_close(&info->port, tty, filp);
+        /*
+         * Now we wait for the transmit buffer to clear; and we notify
+         * the line discipline to only process XON/XOFF characters.
+         */
+        shutdown(info);
+        rs_flush_buffer(tty);
+        tty_ldisc_flush(tty);
+        info->event = 0;
+        info->tty = NULL;
+        if (info->blocked_open) {
+                if (info->close_delay)
+                        schedule_timeout_interruptible(info->close_delay);
+                wake_up_interruptible(&info->open_wait);
+        }
+        info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
+        wake_up_interruptible(&info->close_wait);
 }
 
+/*
+ * rs_wait_until_sent() --- wait until the transmitter is empty
+ */
+static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
+{
+}
+
+
+/*
+ * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
+ */
 static void rs_hangup(struct tty_struct *tty)
 {
-        struct serial_state *info = tty->driver_data;
+        struct async_struct * info = (struct async_struct *)tty->driver_data;
+        struct serial_state *state = info->state;
+
+#ifdef SIMSERIAL_DEBUG
+        printk("rs_hangup: called\n");
+#endif
+
+        state = info->state;
 
         rs_flush_buffer(tty);
-        tty_port_hangup(&info->port);
+        if (info->flags & ASYNC_CLOSING)
+                return;
+        shutdown(info);
+
+        info->event = 0;
+        state->count = 0;
+        info->flags &= ~ASYNC_NORMAL_ACTIVE;
+        info->tty = NULL;
+        wake_up_interruptible(&info->open_wait);
 }
 
-static int activate(struct tty_port *port, struct tty_struct *tty)
+
+static int get_async_struct(int line, struct async_struct **ret_info)
 {
-        struct serial_state *state = container_of(port, struct serial_state,
-                        port);
-        unsigned long flags, page;
-        int retval = 0;
+        struct async_struct *info;
+        struct serial_state *sstate;
+
+        sstate = rs_table + line;
+        sstate->count++;
+        if (sstate->info) {
+                *ret_info = sstate->info;
+                return 0;
+        }
+        info = kzalloc(sizeof(struct async_struct), GFP_KERNEL);
+        if (!info) {
+                sstate->count--;
+                return -ENOMEM;
+        }
+        init_waitqueue_head(&info->open_wait);
+        init_waitqueue_head(&info->close_wait);
+        init_waitqueue_head(&info->delta_msr_wait);
+        info->magic = SERIAL_MAGIC;
+        info->port = sstate->port;
+        info->flags = sstate->flags;
+        info->xmit_fifo_size = sstate->xmit_fifo_size;
+        info->line = line;
+        INIT_WORK(&info->work, do_softint);
+        info->state = sstate;
+        if (sstate->info) {
+                kfree(info);
+                *ret_info = sstate->info;
+                return 0;
+        }
+        *ret_info = sstate->info = info;
+        return 0;
+}
+
+static int
+startup(struct async_struct *info)
+{
+        unsigned long flags;
+        int     retval=0;
+        irq_handler_t handler;
+        struct serial_state *state= info->state;
+        unsigned long page;
 
         page = get_zeroed_page(GFP_KERNEL);
         if (!page)
@@ -391,31 +673,86 @@ static int activate(struct tty_port *port, struct tty_struct *tty)
 
         local_irq_save(flags);
 
-        if (state->xmit.buf)
+        if (info->flags & ASYNC_INITIALIZED) {
+                free_page(page);
+                goto errout;
+        }
+
+        if (!state->port || !state->type) {
+                if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags);
+                free_page(page);
+                goto errout;
+        }
+        if (info->xmit.buf)
                 free_page(page);
         else
-                state->xmit.buf = (unsigned char *) page;
+                info->xmit.buf = (unsigned char *) page;
+
+#ifdef SIMSERIAL_DEBUG
+        printk("startup: ttys%d (irq %d)...", info->line, state->irq);
+#endif
 
-        if (state->irq) {
-                retval = request_irq(state->irq, rs_interrupt_single, 0,
-                                "simserial", state);
-                if (retval)
+        /*
+         * Allocate the IRQ if necessary
+         */
+        if (state->irq && (!IRQ_ports[state->irq] ||
+                          !IRQ_ports[state->irq]->next_port)) {
+                if (IRQ_ports[state->irq]) {
+                        retval = -EBUSY;
+                        goto errout;
+                } else
+                        handler = rs_interrupt_single;
+
+                retval = request_irq(state->irq, handler, IRQ_T(info), "simserial", NULL);
+                if (retval) {
+                        if (capable(CAP_SYS_ADMIN)) {
+                                if (info->tty)
+                                        set_bit(TTY_IO_ERROR,
+                                                &info->tty->flags);
+                                retval = 0;
+                        }
                         goto errout;
+                }
         }
 
-        state->xmit.head = state->xmit.tail = 0;
+        /*
+         * Insert serial port into IRQ chain.
+         */
+        info->prev_port = NULL;
+        info->next_port = IRQ_ports[state->irq];
+        if (info->next_port)
+                info->next_port->prev_port = info;
+        IRQ_ports[state->irq] = info;
+
+        if (info->tty) clear_bit(TTY_IO_ERROR, &info->tty->flags);
+
+        info->xmit.head = info->xmit.tail = 0;
+
+#if 0
+        /*
+         * Set up serial timers...
+         */
+        timer_table[RS_TIMER].expires = jiffies + 2*HZ/100;
+        timer_active |= 1 << RS_TIMER;
+#endif
 
         /*
          * Set up the tty->alt_speed kludge
          */
-        if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                tty->alt_speed = 57600;
-        if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                tty->alt_speed = 115200;
-        if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
-                tty->alt_speed = 230400;
-        if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
-                tty->alt_speed = 460800;
+        if (info->tty) {
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
+                        info->tty->alt_speed = 57600;
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
+                        info->tty->alt_speed = 115200;
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
+                        info->tty->alt_speed = 230400;
+                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
+                        info->tty->alt_speed = 460800;
+        }
+
+        info->flags |= ASYNC_INITIALIZED;
+        local_irq_restore(flags);
+        return 0;
 
 errout:
         local_irq_restore(flags);
@@ -431,11 +768,56 @@ errout:
  */
 static int rs_open(struct tty_struct *tty, struct file * filp)
 {
-        struct serial_state *info = rs_table + tty->index;
-        struct tty_port *port = &info->port;
+        struct async_struct     *info;
+        int                     retval, line;
+        unsigned long           page;
 
+        line = tty->index;
+        if ((line < 0) || (line >= NR_PORTS))
+                return -ENODEV;
+        retval = get_async_struct(line, &info);
+        if (retval)
+                return retval;
         tty->driver_data = info;
-        tty->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        info->tty = tty;
+
+#ifdef SIMSERIAL_DEBUG
+        printk("rs_open %s, count = %d\n", tty->name, info->state->count);
+#endif
+        info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+
+        if (!tmp_buf) {
+                page = get_zeroed_page(GFP_KERNEL);
+                if (!page)
+                        return -ENOMEM;
+                if (tmp_buf)
+                        free_page(page);
+                else
+                        tmp_buf = (unsigned char *) page;
+        }
+
+        /*
+         * If the port is the middle of closing, bail out now
+         */
+        if (tty_hung_up_p(filp) ||
+            (info->flags & ASYNC_CLOSING)) {
+                if (info->flags & ASYNC_CLOSING)
+                        interruptible_sleep_on(&info->close_wait);
+#ifdef SERIAL_DO_RESTART
+                return ((info->flags & ASYNC_HUP_NOTIFY) ?
+                        -EAGAIN : -ERESTARTSYS);
+#else
+                return -EAGAIN;
+#endif
+        }
+
+        /*
+         * Start up serial port
+         */
+        retval = startup(info);
+        if (retval) {
+                return retval;
+        }
 
         /*
          * figure out which console to use (should be one already)
@@ -446,21 +828,30 @@ static int rs_open(struct tty_struct *tty, struct file * filp)
                 console = console->next;
         }
 
-        return tty_port_open(port, tty, filp);
+#ifdef SIMSERIAL_DEBUG
+        printk("rs_open ttys%d successful\n", info->line);
+#endif
+        return 0;
 }
 
 /*
  * /proc fs routines....
  */
 
+static inline void line_info(struct seq_file *m, struct serial_state *state)
+{
+        seq_printf(m, "%d: uart:%s port:%lX irq:%d\n",
+                       state->line, uart_config[state->type].name,
+                       state->port, state->irq);
+}
+
 static int rs_proc_show(struct seq_file *m, void *v)
 {
         int i;
 
-        seq_printf(m, "simserinfo:1.0\n");
+        seq_printf(m, "simserinfo:1.0 driver:%s\n", serial_version);
         for (i = 0; i < NR_PORTS; i++)
-                seq_printf(m, "%d: uart:16550 port:3F8 irq:%d\n",
-                       i, rs_table[i].irq);
+                line_info(m, &rs_table[i]);
         return 0;
 }
 
@@ -477,6 +868,25 @@ static const struct file_operations rs_proc_fops = {
         .release        = single_release,
 };
 
+/*
+ * ---------------------------------------------------------------------
+ * rs_init() and friends
+ *
+ * rs_init() is called at boot-time to initialize the serial driver.
+ * ---------------------------------------------------------------------
+ */
+
+/*
+ * This routine prints out the appropriate serial driver version
+ * number, and identifies which options were configured into this
+ * driver.
+ */
+static inline void show_serial_version(void)
+{
+        printk(KERN_INFO "%s version %s with", serial_name, serial_version);
+        printk(KERN_INFO " no serial options enabled\n");
+}
+
 static const struct tty_operations hp_ops = {
         .open = rs_open,
         .close = rs_close,
@@ -491,31 +901,34 @@ static const struct tty_operations hp_ops = {
         .unthrottle = rs_unthrottle,
         .send_xchar = rs_send_xchar,
         .set_termios = rs_set_termios,
+        .stop = rs_stop,
+        .start = rs_start,
         .hangup = rs_hangup,
+        .wait_until_sent = rs_wait_until_sent,
         .proc_fops = &rs_proc_fops,
 };
 
-static const struct tty_port_operations hp_port_ops = {
-        .activate = activate,
-        .shutdown = shutdown,
-};
-
-static int __init simrs_init(void)
+/*
+ * The serial driver boot-time initialization code!
+ */
+static int __init
+simrs_init (void)
 {
-        struct serial_state *state;
-        int retval;
+        int                     i, rc;
+        struct serial_state     *state;
 
         if (!ia64_platform_is("hpsim"))
                 return -ENODEV;
 
-        hp_simserial_driver = alloc_tty_driver(NR_PORTS);
+        hp_simserial_driver = alloc_tty_driver(1);
         if (!hp_simserial_driver)
                 return -ENOMEM;
 
-        printk(KERN_INFO "SimSerial driver with no serial options enabled\n");
+        show_serial_version();
 
         /* Initialize the tty_driver structure */
 
+        hp_simserial_driver->owner = THIS_MODULE;
         hp_simserial_driver->driver_name = "simserial";
         hp_simserial_driver->name = "ttyS";
         hp_simserial_driver->major = TTY_MAJOR;
@@ -528,35 +941,31 @@ static int __init simrs_init(void)
         hp_simserial_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(hp_simserial_driver, &hp_ops);
 
-        state = rs_table;
-        tty_port_init(&state->port);
-        state->port.ops = &hp_port_ops;
-        state->port.close_delay = 0; /* XXX really 0? */
-
-        retval = hpsim_get_irq(KEYBOARD_INTR);
-        if (retval < 0) {
-                printk(KERN_ERR "%s: out of interrupt vectors!\n",
-                                __func__);
-                goto err_free_tty;
-        }
+        /*
+         * Let's have a little bit of fun !
+         */
+        for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) {
 
-        state->irq = retval;
+                if (state->type == PORT_UNKNOWN) continue;
 
-        /* the port is imaginary */
-        printk(KERN_INFO "ttyS0 at 0x03f8 (irq = %d) is a 16550\n", state->irq);
+                if (!state->irq) {
+                        if ((rc = assign_irq_vector(AUTO_ASSIGN)) < 0)
+                                panic("%s: out of interrupt vectors!\n",
+                                      __func__);
+                        state->irq = rc;
+                        ia64_ssc_connect_irq(KEYBOARD_INTR, state->irq);
+                }
 
-        tty_port_link_device(&state->port, hp_simserial_driver, 0);
-        retval = tty_register_driver(hp_simserial_driver);
-        if (retval) {
-                printk(KERN_ERR "Couldn't register simserial driver\n");
-                goto err_free_tty;
+                printk(KERN_INFO "ttyS%d at 0x%04lx (irq = %d) is a %s\n",
+                       state->line,
+                       state->port, state->irq,
+                       uart_config[state->type].name);
         }
 
+        if (tty_register_driver(hp_simserial_driver))
+                panic("Couldn't register simserial driver\n");
+
         return 0;
-err_free_tty:
-        put_tty_driver(hp_simserial_driver);
-        tty_port_destroy(&state->port);
-        return retval;
 }
 
 #ifndef MODULE
diff --git a/arch/ia64/include/asm/Kbuild b/arch/ia64/include/asm/Kbuild
index 05b03ecd793..241d1c53ba6 100644
--- a/arch/ia64/include/asm/Kbuild
+++ b/arch/ia64/include/asm/Kbuild
@@ -1,5 +1,14 @@
+include include/asm-generic/Kbuild.asm
 
-generic-y += clkdev.h
-generic-y += exec.h
-generic-y += kvm_para.h
-generic-y += trace_clock.h
+header-y += break.h
+header-y += fpu.h
+header-y += gcc_intrin.h
+header-y += ia64regs.h
+header-y += intel_intrin.h
+header-y += intrinsics.h
+header-y += perfmon.h
+header-y += perfmon_default_smpl.h
+header-y += ptrace_offsets.h
+header-y += rse.h
+header-y += ucontext.h
+header-y += ustack.h
diff --git a/arch/ia64/include/asm/acpi.h b/arch/ia64/include/asm/acpi.h
index 359e68a03ca..a06dfb13d51 100644
--- a/arch/ia64/include/asm/acpi.h
+++ b/arch/ia64/include/asm/acpi.h
@@ -32,6 +32,7 @@
 
 #include <linux/init.h>
 #include <linux/numa.h>
+#include <asm/system.h>
 #include <asm/numa.h>
 
 #define COMPILER_DEPENDENT_INT64        long
@@ -153,7 +154,7 @@ extern int additional_cpus;
 #else
 #define MAX_PXM_DOMAINS (256)
 #endif
-extern int pxm_to_nid_map[MAX_PXM_DOMAINS];
+extern int __devinitdata pxm_to_nid_map[MAX_PXM_DOMAINS];
 extern int __initdata nid_to_pxm_map[MAX_NUMNODES];
 #endif
 
diff --git a/arch/ia64/include/asm/atomic.h b/arch/ia64/include/asm/atomic.h
index 6e6fe1839f5..3fad89ee01c 100644
--- a/arch/ia64/include/asm/atomic.h
+++ b/arch/ia64/include/asm/atomic.h
@@ -15,10 +15,11 @@
 #include <linux/types.h>
 
 #include <asm/intrinsics.h>
+#include <asm/system.h>
 
 
-#define ATOMIC_INIT(i)          { (i) }
-#define ATOMIC64_INIT(i)        { (i) }
+#define ATOMIC_INIT(i)          ((atomic_t) { (i) })
+#define ATOMIC64_INIT(i)        ((atomic64_t) { (i) })
 
 #define atomic_read(v)          (*(volatile int *)&(v)->counter)
 #define atomic64_read(v)        (*(volatile long *)&(v)->counter)
diff --git a/arch/ia64/include/asm/barrier.h b/arch/ia64/include/asm/barrier.h
deleted file mode 100644
index 60576e06b6f..00000000000
--- a/arch/ia64/include/asm/barrier.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Memory barrier definitions.  This is based on information published
- * in the Processor Abstraction Layer and the System Abstraction Layer
- * manual.
- *
- * Copyright (C) 1998-2003 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- * Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>
- * Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
- */
-#ifndef _ASM_IA64_BARRIER_H
-#define _ASM_IA64_BARRIER_H
-
-#include <linux/compiler.h>
-
-/*
- * Macros to force memory ordering.  In these descriptions, "previous"
- * and "subsequent" refer to program order; "visible" means that all
- * architecturally visible effects of a memory access have occurred
- * (at a minimum, this means the memory has been read or written).
- *
- *   wmb():     Guarantees that all preceding stores to memory-
- *              like regions are visible before any subsequent
- *              stores and that all following stores will be
- *              visible only after all previous stores.
- *   rmb():     Like wmb(), but for reads.
- *   mb():      wmb()/rmb() combo, i.e., all previous memory
- *              accesses are visible before all subsequent
- *              accesses and vice versa.  This is also known as
- *              a "fence."
- *
- * Note: "mb()" and its variants cannot be used as a fence to order
- * accesses to memory mapped I/O registers.  For that, mf.a needs to
- * be used.  However, we don't want to always use mf.a because (a)
- * it's (presumably) much slower than mf and (b) mf.a is supported for
- * sequential memory pages only.
- */
-#define mb()    ia64_mf()
-#define rmb()   mb()
-#define wmb()   mb()
-#define read_barrier_depends()  do { } while(0)
-
-#ifdef CONFIG_SMP
-# define smp_mb()       mb()
-# define smp_rmb()      rmb()
-# define smp_wmb()      wmb()
-# define smp_read_barrier_depends()     read_barrier_depends()
-#else
-# define smp_mb()       barrier()
-# define smp_rmb()      barrier()
-# define smp_wmb()      barrier()
-# define smp_read_barrier_depends()     do { } while(0)
-#endif
-
-/*
- * XXX check on this ---I suspect what Linus really wants here is
- * acquire vs release semantics but we can't discuss this stuff with
- * Linus just yet.  Grrr...
- */
-#define set_mb(var, value)      do { (var) = (value); mb(); } while (0)
-
-/*
- * The group barrier in front of the rsm & ssm are necessary to ensure
- * that none of the previous instructions in the same group are
- * affected by the rsm/ssm.
- */
-
-#endif /* _ASM_IA64_BARRIER_H */
diff --git a/arch/ia64/include/asm/cputime.h b/arch/ia64/include/asm/cputime.h
index 7fcf7f08ab0..6073b187528 100644
--- a/arch/ia64/include/asm/cputime.h
+++ b/arch/ia64/include/asm/cputime.h
@@ -26,53 +26,59 @@
 #include <linux/jiffies.h>
 #include <asm/processor.h>
 
-typedef u64 __nocast cputime_t;
-typedef u64 __nocast cputime64_t;
+typedef u64 cputime_t;
+typedef u64 cputime64_t;
 
+#define cputime_zero                    ((cputime_t)0)
 #define cputime_one_jiffy               jiffies_to_cputime(1)
+#define cputime_max                     ((~((cputime_t)0) >> 1) - 1)
+#define cputime_add(__a, __b)           ((__a) +  (__b))
+#define cputime_sub(__a, __b)           ((__a) -  (__b))
+#define cputime_div(__a, __n)           ((__a) /  (__n))
+#define cputime_halve(__a)              ((__a) >> 1)
+#define cputime_eq(__a, __b)            ((__a) == (__b))
+#define cputime_gt(__a, __b)            ((__a) >  (__b))
+#define cputime_ge(__a, __b)            ((__a) >= (__b))
+#define cputime_lt(__a, __b)            ((__a) <  (__b))
+#define cputime_le(__a, __b)            ((__a) <= (__b))
+
+#define cputime64_zero                  ((cputime64_t)0)
+#define cputime64_add(__a, __b)         ((__a) + (__b))
+#define cputime64_sub(__a, __b)         ((__a) - (__b))
+#define cputime_to_cputime64(__ct)      (__ct)
 
 /*
  * Convert cputime <-> jiffies (HZ)
  */
-#define cputime_to_jiffies(__ct)        \
-        ((__force u64)(__ct) / (NSEC_PER_SEC / HZ))
-#define jiffies_to_cputime(__jif)       \
-        (__force cputime_t)((__jif) * (NSEC_PER_SEC / HZ))
-#define cputime64_to_jiffies64(__ct)    \
-        ((__force u64)(__ct) / (NSEC_PER_SEC / HZ))
-#define jiffies64_to_cputime64(__jif)   \
-        (__force cputime64_t)((__jif) * (NSEC_PER_SEC / HZ))
+#define cputime_to_jiffies(__ct)        ((__ct) / (NSEC_PER_SEC / HZ))
+#define jiffies_to_cputime(__jif)       ((__jif) * (NSEC_PER_SEC / HZ))
+#define cputime64_to_jiffies64(__ct)    ((__ct) / (NSEC_PER_SEC / HZ))
+#define jiffies64_to_cputime64(__jif)   ((__jif) * (NSEC_PER_SEC / HZ))
 
 /*
  * Convert cputime <-> microseconds
  */
-#define cputime_to_usecs(__ct)          \
-        ((__force u64)(__ct) / NSEC_PER_USEC)
-#define usecs_to_cputime(__usecs)       \
-        (__force cputime_t)((__usecs) * NSEC_PER_USEC)
-#define usecs_to_cputime64(__usecs)     \
-        (__force cputime64_t)((__usecs) * NSEC_PER_USEC)
+#define cputime_to_usecs(__ct)          ((__ct) / NSEC_PER_USEC)
+#define usecs_to_cputime(__usecs)       ((__usecs) * NSEC_PER_USEC)
 
 /*
  * Convert cputime <-> seconds
  */
-#define cputime_to_secs(__ct)           \
-        ((__force u64)(__ct) / NSEC_PER_SEC)
-#define secs_to_cputime(__secs)         \
-        (__force cputime_t)((__secs) * NSEC_PER_SEC)
+#define cputime_to_secs(__ct)           ((__ct) / NSEC_PER_SEC)
+#define secs_to_cputime(__secs)         ((__secs) * NSEC_PER_SEC)
 
 /*
  * Convert cputime <-> timespec (nsec)
  */
 static inline cputime_t timespec_to_cputime(const struct timespec *val)
 {
-        u64 ret = val->tv_sec * NSEC_PER_SEC + val->tv_nsec;
-        return (__force cputime_t) ret;
+        cputime_t ret = val->tv_sec * NSEC_PER_SEC;
+        return (ret + val->tv_nsec);
 }
 static inline void cputime_to_timespec(const cputime_t ct, struct timespec *val)
 {
-        val->tv_sec  = (__force u64) ct / NSEC_PER_SEC;
-        val->tv_nsec = (__force u64) ct % NSEC_PER_SEC;
+        val->tv_sec  = ct / NSEC_PER_SEC;
+        val->tv_nsec = ct % NSEC_PER_SEC;
 }
 
 /*
@@ -80,30 +86,25 @@ static inline void cputime_to_timespec(const cputime_t ct, struct timespec *val)
  */
 static inline cputime_t timeval_to_cputime(struct timeval *val)
 {
-        u64 ret = val->tv_sec * NSEC_PER_SEC + val->tv_usec * NSEC_PER_USEC;
-        return (__force cputime_t) ret;
+        cputime_t ret = val->tv_sec * NSEC_PER_SEC;
+        return (ret + val->tv_usec * NSEC_PER_USEC);
 }
 static inline void cputime_to_timeval(const cputime_t ct, struct timeval *val)
 {
-        val->tv_sec = (__force u64) ct / NSEC_PER_SEC;
-        val->tv_usec = ((__force u64) ct % NSEC_PER_SEC) / NSEC_PER_USEC;
+        val->tv_sec = ct / NSEC_PER_SEC;
+        val->tv_usec = (ct % NSEC_PER_SEC) / NSEC_PER_USEC;
 }
 
 /*
  * Convert cputime <-> clock (USER_HZ)
  */
-#define cputime_to_clock_t(__ct)        \
-        ((__force u64)(__ct) / (NSEC_PER_SEC / USER_HZ))
-#define clock_t_to_cputime(__x)         \
-        (__force cputime_t)((__x) * (NSEC_PER_SEC / USER_HZ))
+#define cputime_to_clock_t(__ct)        ((__ct) / (NSEC_PER_SEC / USER_HZ))
+#define clock_t_to_cputime(__x)         ((__x) * (NSEC_PER_SEC / USER_HZ))
 
 /*
  * Convert cputime64 to clock.
  */
-#define cputime64_to_clock_t(__ct)      \
-        cputime_to_clock_t((__force cputime_t)__ct)
-
-extern void arch_vtime_task_switch(struct task_struct *tsk);
+#define cputime64_to_clock_t(__ct)      cputime_to_clock_t((cputime_t)__ct)
 
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
 #endif /* __IA64_CPUTIME_H */
diff --git a/arch/ia64/include/asm/device.h b/arch/ia64/include/asm/device.h
index f69c32ffbe6..d05e78f6db9 100644
--- a/arch/ia64/include/asm/device.h
+++ b/arch/ia64/include/asm/device.h
@@ -7,6 +7,9 @@
 #define _ASM_IA64_DEVICE_H
 
 struct dev_archdata {
+#ifdef CONFIG_ACPI
+        void    *acpi_handle;
+#endif
 #ifdef CONFIG_INTEL_IOMMU
         void *iommu; /* hook for IOMMU specific extension */
 #endif
diff --git a/arch/ia64/include/asm/dma-mapping.h b/arch/ia64/include/asm/dma-mapping.h
index cf3ab7e784b..4336d080b24 100644
--- a/arch/ia64/include/asm/dma-mapping.h
+++ b/arch/ia64/include/asm/dma-mapping.h
@@ -23,29 +23,23 @@ extern void machvec_dma_sync_single(struct device *, dma_addr_t, size_t,
 extern void machvec_dma_sync_sg(struct device *, struct scatterlist *, int,
                                 enum dma_data_direction);
 
-#define dma_alloc_coherent(d,s,h,f)     dma_alloc_attrs(d,s,h,f,NULL)
-
-static inline void *dma_alloc_attrs(struct device *dev, size_t size,
-                                    dma_addr_t *daddr, gfp_t gfp,
-                                    struct dma_attrs *attrs)
+static inline void *dma_alloc_coherent(struct device *dev, size_t size,
+                                       dma_addr_t *daddr, gfp_t gfp)
 {
         struct dma_map_ops *ops = platform_dma_get_ops(dev);
         void *caddr;
 
-        caddr = ops->alloc(dev, size, daddr, gfp, attrs);
+        caddr = ops->alloc_coherent(dev, size, daddr, gfp);
         debug_dma_alloc_coherent(dev, size, *daddr, caddr);
         return caddr;
 }
 
-#define dma_free_coherent(d,s,c,h) dma_free_attrs(d,s,c,h,NULL)
-
-static inline void dma_free_attrs(struct device *dev, size_t size,
-                                  void *caddr, dma_addr_t daddr,
-                                  struct dma_attrs *attrs)
+static inline void dma_free_coherent(struct device *dev, size_t size,
+                                     void *caddr, dma_addr_t daddr)
 {
         struct dma_map_ops *ops = platform_dma_get_ops(dev);
         debug_dma_free_coherent(dev, size, caddr, daddr);
-        ops->free(dev, size, caddr, daddr, attrs);
+        ops->free_coherent(dev, size, caddr, daddr);
 }
 
 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
@@ -58,7 +52,6 @@ static inline void dma_free_attrs(struct device *dev, size_t size,
 static inline int dma_mapping_error(struct device *dev, dma_addr_t daddr)
 {
         struct dma_map_ops *ops = platform_dma_get_ops(dev);
-        debug_dma_mapping_error(dev, daddr);
         return ops->mapping_error(dev, daddr);
 }
 
diff --git a/arch/ia64/include/asm/futex.h b/arch/ia64/include/asm/futex.h
index d2bf1fd5e44..8428525ddb2 100644
--- a/arch/ia64/include/asm/futex.h
+++ b/arch/ia64/include/asm/futex.h
@@ -4,6 +4,7 @@
 #include <linux/futex.h>
 #include <linux/uaccess.h>
 #include <asm/errno.h>
+#include <asm/system.h>
 
 #define __futex_atomic_op1(insn, ret, oldval, uaddr, oparg) \
 do {                                                                    \
@@ -106,16 +107,15 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
                 return -EFAULT;
 
         {
-                register unsigned long r8 __asm ("r8");
+                register unsigned long r8 __asm ("r8") = 0;
                 unsigned long prev;
                 __asm__ __volatile__(
                         "       mf;;                                    \n"
-                        "       mov %0=r0                               \n"
-                        "       mov ar.ccv=%4;;                         \n"
-                        "[1:]   cmpxchg4.acq %1=[%2],%3,ar.ccv          \n"
+                        "       mov ar.ccv=%3;;                         \n"
+                        "[1:]   cmpxchg4.acq %0=[%1],%2,ar.ccv          \n"
                         "       .xdata4 \"__ex_table\", 1b-., 2f-.      \n"
                         "[2:]"
-                        : "=r" (r8), "=r" (prev)
+                        : "=r" (prev)
                         : "r" (uaddr), "r" (newval),
                           "rO" ((long) (unsigned) oldval)
                         : "memory");
diff --git a/arch/ia64/include/asm/gcc_intrin.h b/arch/ia64/include/asm/gcc_intrin.h
index f9495b1757a..21ddee54ada 100644
--- a/arch/ia64/include/asm/gcc_intrin.h
+++ b/arch/ia64/include/asm/gcc_intrin.h
@@ -1,12 +1,621 @@
+#ifndef _ASM_IA64_GCC_INTRIN_H
+#define _ASM_IA64_GCC_INTRIN_H
 /*
  *
  * Copyright (C) 2002,2003 Jun Nakajima <jun.nakajima@intel.com>
  * Copyright (C) 2002,2003 Suresh Siddha <suresh.b.siddha@intel.com>
  */
-#ifndef _ASM_IA64_GCC_INTRIN_H
-#define _ASM_IA64_GCC_INTRIN_H
 
-#include <uapi/asm/gcc_intrin.h>
+#include <linux/types.h>
+#include <linux/compiler.h>
+
+/* define this macro to get some asm stmts included in 'c' files */
+#define ASM_SUPPORTED
+
+/* Optimization barrier */
+/* The "volatile" is due to gcc bugs */
+#define ia64_barrier()  asm volatile ("":::"memory")
+
+#define ia64_stop()     asm volatile (";;"::)
+
+#define ia64_invala_gr(regnum)  asm volatile ("invala.e r%0" :: "i"(regnum))
+
+#define ia64_invala_fr(regnum)  asm volatile ("invala.e f%0" :: "i"(regnum))
+
+#define ia64_flushrs() asm volatile ("flushrs;;":::"memory")
+
+#define ia64_loadrs() asm volatile ("loadrs;;":::"memory")
+
+extern void ia64_bad_param_for_setreg (void);
+extern void ia64_bad_param_for_getreg (void);
 
+#ifdef __KERNEL__
 register unsigned long ia64_r13 asm ("r13") __used;
+#endif
+
+#define ia64_native_setreg(regnum, val)                                         \
+({                                                                              \
+        switch (regnum) {                                                       \
+            case _IA64_REG_PSR_L:                                               \
+                    asm volatile ("mov psr.l=%0" :: "r"(val) : "memory");       \
+                    break;                                                      \
+            case _IA64_REG_AR_KR0 ... _IA64_REG_AR_EC:                          \
+                    asm volatile ("mov ar%0=%1" ::                              \
+                                          "i" (regnum - _IA64_REG_AR_KR0),      \
+                                          "r"(val): "memory");                  \
+                    break;                                                      \
+            case _IA64_REG_CR_DCR ... _IA64_REG_CR_LRR1:                        \
+                    asm volatile ("mov cr%0=%1" ::                              \
+                                          "i" (regnum - _IA64_REG_CR_DCR),      \
+                                          "r"(val): "memory" );                 \
+                    break;                                                      \
+            case _IA64_REG_SP:                                                  \
+                    asm volatile ("mov r12=%0" ::                               \
+                                          "r"(val): "memory");                  \
+                    break;                                                      \
+            case _IA64_REG_GP:                                                  \
+                    asm volatile ("mov gp=%0" :: "r"(val) : "memory");          \
+                break;                                                          \
+            default:                                                            \
+                    ia64_bad_param_for_setreg();                                \
+                    break;                                                      \
+        }                                                                       \
+})
+
+#define ia64_native_getreg(regnum)                                              \
+({                                                                              \
+        __u64 ia64_intri_res;                                                   \
+                                                                                \
+        switch (regnum) {                                                       \
+        case _IA64_REG_GP:                                                      \
+                asm volatile ("mov %0=gp" : "=r"(ia64_intri_res));              \
+                break;                                                          \
+        case _IA64_REG_IP:                                                      \
+                asm volatile ("mov %0=ip" : "=r"(ia64_intri_res));              \
+                break;                                                          \
+        case _IA64_REG_PSR:                                                     \
+                asm volatile ("mov %0=psr" : "=r"(ia64_intri_res));             \
+                break;                                                          \
+        case _IA64_REG_TP:      /* for current() */                             \
+                ia64_intri_res = ia64_r13;                                      \
+                break;                                                          \
+        case _IA64_REG_AR_KR0 ... _IA64_REG_AR_EC:                              \
+                asm volatile ("mov %0=ar%1" : "=r" (ia64_intri_res)             \
+                                      : "i"(regnum - _IA64_REG_AR_KR0));        \
+                break;                                                          \
+        case _IA64_REG_CR_DCR ... _IA64_REG_CR_LRR1:                            \
+                asm volatile ("mov %0=cr%1" : "=r" (ia64_intri_res)             \
+                                      : "i" (regnum - _IA64_REG_CR_DCR));       \
+                break;                                                          \
+        case _IA64_REG_SP:                                                      \
+                asm volatile ("mov %0=sp" : "=r" (ia64_intri_res));             \
+                break;                                                          \
+        default:                                                                \
+                ia64_bad_param_for_getreg();                                    \
+                break;                                                          \
+        }                                                                       \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_hint_pause 0
+
+#define ia64_hint(mode)                                         \
+({                                                              \
+        switch (mode) {                                         \
+        case ia64_hint_pause:                                   \
+                asm volatile ("hint @pause" ::: "memory");      \
+                break;                                          \
+        }                                                       \
+})
+
+
+/* Integer values for mux1 instruction */
+#define ia64_mux1_brcst 0
+#define ia64_mux1_mix   8
+#define ia64_mux1_shuf  9
+#define ia64_mux1_alt  10
+#define ia64_mux1_rev  11
+
+#define ia64_mux1(x, mode)                                                      \
+({                                                                              \
+        __u64 ia64_intri_res;                                                   \
+                                                                                \
+        switch (mode) {                                                         \
+        case ia64_mux1_brcst:                                                   \
+                asm ("mux1 %0=%1,@brcst" : "=r" (ia64_intri_res) : "r" (x));    \
+                break;                                                          \
+        case ia64_mux1_mix:                                                     \
+                asm ("mux1 %0=%1,@mix" : "=r" (ia64_intri_res) : "r" (x));      \
+                break;                                                          \
+        case ia64_mux1_shuf:                                                    \
+                asm ("mux1 %0=%1,@shuf" : "=r" (ia64_intri_res) : "r" (x));     \
+                break;                                                          \
+        case ia64_mux1_alt:                                                     \
+                asm ("mux1 %0=%1,@alt" : "=r" (ia64_intri_res) : "r" (x));      \
+                break;                                                          \
+        case ia64_mux1_rev:                                                     \
+                asm ("mux1 %0=%1,@rev" : "=r" (ia64_intri_res) : "r" (x));      \
+                break;                                                          \
+        }                                                                       \
+        ia64_intri_res;                                                         \
+})
+
+#if __GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# define ia64_popcnt(x)         __builtin_popcountl(x)
+#else
+# define ia64_popcnt(x)                                         \
+  ({                                                            \
+        __u64 ia64_intri_res;                                   \
+        asm ("popcnt %0=%1" : "=r" (ia64_intri_res) : "r" (x)); \
+                                                                \
+        ia64_intri_res;                                         \
+  })
+#endif
+
+#define ia64_getf_exp(x)                                        \
+({                                                              \
+        long ia64_intri_res;                                    \
+                                                                \
+        asm ("getf.exp %0=%1" : "=r"(ia64_intri_res) : "f"(x)); \
+                                                                \
+        ia64_intri_res;                                         \
+})
+
+#define ia64_shrp(a, b, count)                                                          \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm ("shrp %0=%1,%2,%3" : "=r"(ia64_intri_res) : "r"(a), "r"(b), "i"(count));   \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_ldfs(regnum, x)                                    \
+({                                                              \
+        register double __f__ asm ("f"#regnum);                 \
+        asm volatile ("ldfs %0=[%1]" :"=f"(__f__): "r"(x));     \
+})
+
+#define ia64_ldfd(regnum, x)                                    \
+({                                                              \
+        register double __f__ asm ("f"#regnum);                 \
+        asm volatile ("ldfd %0=[%1]" :"=f"(__f__): "r"(x));     \
+})
+
+#define ia64_ldfe(regnum, x)                                    \
+({                                                              \
+        register double __f__ asm ("f"#regnum);                 \
+        asm volatile ("ldfe %0=[%1]" :"=f"(__f__): "r"(x));     \
+})
+
+#define ia64_ldf8(regnum, x)                                    \
+({                                                              \
+        register double __f__ asm ("f"#regnum);                 \
+        asm volatile ("ldf8 %0=[%1]" :"=f"(__f__): "r"(x));     \
+})
+
+#define ia64_ldf_fill(regnum, x)                                \
+({                                                              \
+        register double __f__ asm ("f"#regnum);                 \
+        asm volatile ("ldf.fill %0=[%1]" :"=f"(__f__): "r"(x)); \
+})
+
+#define ia64_st4_rel_nta(m, val)                                        \
+({                                                                      \
+        asm volatile ("st4.rel.nta [%0] = %1\n\t" :: "r"(m), "r"(val)); \
+})
+
+#define ia64_stfs(x, regnum)                                            \
+({                                                                      \
+        register double __f__ asm ("f"#regnum);                         \
+        asm volatile ("stfs [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
+})
+
+#define ia64_stfd(x, regnum)                                            \
+({                                                                      \
+        register double __f__ asm ("f"#regnum);                         \
+        asm volatile ("stfd [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
+})
+
+#define ia64_stfe(x, regnum)                                            \
+({                                                                      \
+        register double __f__ asm ("f"#regnum);                         \
+        asm volatile ("stfe [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
+})
+
+#define ia64_stf8(x, regnum)                                            \
+({                                                                      \
+        register double __f__ asm ("f"#regnum);                         \
+        asm volatile ("stf8 [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
+})
+
+#define ia64_stf_spill(x, regnum)                                               \
+({                                                                              \
+        register double __f__ asm ("f"#regnum);                                 \
+        asm volatile ("stf.spill [%0]=%1" :: "r"(x), "f"(__f__) : "memory");    \
+})
+
+#define ia64_fetchadd4_acq(p, inc)                                              \
+({                                                                              \
+                                                                                \
+        __u64 ia64_intri_res;                                                   \
+        asm volatile ("fetchadd4.acq %0=[%1],%2"                                \
+                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
+                                : "memory");                                    \
+                                                                                \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_fetchadd4_rel(p, inc)                                              \
+({                                                                              \
+        __u64 ia64_intri_res;                                                   \
+        asm volatile ("fetchadd4.rel %0=[%1],%2"                                \
+                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
+                                : "memory");                                    \
+                                                                                \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_fetchadd8_acq(p, inc)                                              \
+({                                                                              \
+                                                                                \
+        __u64 ia64_intri_res;                                                   \
+        asm volatile ("fetchadd8.acq %0=[%1],%2"                                \
+                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
+                                : "memory");                                    \
+                                                                                \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_fetchadd8_rel(p, inc)                                              \
+({                                                                              \
+        __u64 ia64_intri_res;                                                   \
+        asm volatile ("fetchadd8.rel %0=[%1],%2"                                \
+                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
+                                : "memory");                                    \
+                                                                                \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_xchg1(ptr,x)                                                       \
+({                                                                              \
+        __u64 ia64_intri_res;                                                   \
+        asm volatile ("xchg1 %0=[%1],%2"                                        \
+                      : "=r" (ia64_intri_res) : "r" (ptr), "r" (x) : "memory"); \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_xchg2(ptr,x)                                               \
+({                                                                      \
+        __u64 ia64_intri_res;                                           \
+        asm volatile ("xchg2 %0=[%1],%2" : "=r" (ia64_intri_res)        \
+                      : "r" (ptr), "r" (x) : "memory");                 \
+        ia64_intri_res;                                                 \
+})
+
+#define ia64_xchg4(ptr,x)                                               \
+({                                                                      \
+        __u64 ia64_intri_res;                                           \
+        asm volatile ("xchg4 %0=[%1],%2" : "=r" (ia64_intri_res)        \
+                      : "r" (ptr), "r" (x) : "memory");                 \
+        ia64_intri_res;                                                 \
+})
+
+#define ia64_xchg8(ptr,x)                                               \
+({                                                                      \
+        __u64 ia64_intri_res;                                           \
+        asm volatile ("xchg8 %0=[%1],%2" : "=r" (ia64_intri_res)        \
+                      : "r" (ptr), "r" (x) : "memory");                 \
+        ia64_intri_res;                                                 \
+})
+
+#define ia64_cmpxchg1_acq(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+        asm volatile ("cmpxchg1.acq %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg1_rel(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+        asm volatile ("cmpxchg1.rel %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg2_acq(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+        asm volatile ("cmpxchg2.acq %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg2_rel(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+                                                                                        \
+        asm volatile ("cmpxchg2.rel %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg4_acq(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+        asm volatile ("cmpxchg4.acq %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg4_rel(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+        asm volatile ("cmpxchg4.rel %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg8_acq(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+        asm volatile ("cmpxchg8.acq %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_cmpxchg8_rel(ptr, new, old)                                                \
+({                                                                                      \
+        __u64 ia64_intri_res;                                                           \
+        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
+                                                                                        \
+        asm volatile ("cmpxchg8.rel %0=[%1],%2,ar.ccv":                                 \
+                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
+        ia64_intri_res;                                                                 \
+})
+
+#define ia64_mf()       asm volatile ("mf" ::: "memory")
+#define ia64_mfa()      asm volatile ("mf.a" ::: "memory")
+
+#define ia64_invala() asm volatile ("invala" ::: "memory")
+
+#define ia64_native_thash(addr)                                                 \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("thash %0=%1" : "=r"(ia64_intri_res) : "r" (addr));       \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_srlz_i()   asm volatile (";; srlz.i ;;" ::: "memory")
+#define ia64_srlz_d()   asm volatile (";; srlz.d" ::: "memory");
+
+#ifdef HAVE_SERIALIZE_DIRECTIVE
+# define ia64_dv_serialize_data()               asm volatile (".serialize.data");
+# define ia64_dv_serialize_instruction()        asm volatile (".serialize.instruction");
+#else
+# define ia64_dv_serialize_data()
+# define ia64_dv_serialize_instruction()
+#endif
+
+#define ia64_nop(x)     asm volatile ("nop %0"::"i"(x));
+
+#define ia64_itci(addr) asm volatile ("itc.i %0;;" :: "r"(addr) : "memory")
+
+#define ia64_itcd(addr) asm volatile ("itc.d %0;;" :: "r"(addr) : "memory")
+
+
+#define ia64_itri(trnum, addr) asm volatile ("itr.i itr[%0]=%1"                         \
+                                             :: "r"(trnum), "r"(addr) : "memory")
+
+#define ia64_itrd(trnum, addr) asm volatile ("itr.d dtr[%0]=%1"                         \
+                                             :: "r"(trnum), "r"(addr) : "memory")
+
+#define ia64_tpa(addr)                                                          \
+({                                                                              \
+        unsigned long ia64_pa;                                                  \
+        asm volatile ("tpa %0 = %1" : "=r"(ia64_pa) : "r"(addr) : "memory");    \
+        ia64_pa;                                                                \
+})
+
+#define __ia64_set_dbr(index, val)                                              \
+        asm volatile ("mov dbr[%0]=%1" :: "r"(index), "r"(val) : "memory")
+
+#define ia64_set_ibr(index, val)                                                \
+        asm volatile ("mov ibr[%0]=%1" :: "r"(index), "r"(val) : "memory")
+
+#define ia64_set_pkr(index, val)                                                \
+        asm volatile ("mov pkr[%0]=%1" :: "r"(index), "r"(val) : "memory")
+
+#define ia64_set_pmc(index, val)                                                \
+        asm volatile ("mov pmc[%0]=%1" :: "r"(index), "r"(val) : "memory")
+
+#define ia64_set_pmd(index, val)                                                \
+        asm volatile ("mov pmd[%0]=%1" :: "r"(index), "r"(val) : "memory")
+
+#define ia64_native_set_rr(index, val)                                                  \
+        asm volatile ("mov rr[%0]=%1" :: "r"(index), "r"(val) : "memory");
+
+#define ia64_native_get_cpuid(index)                                                    \
+({                                                                                      \
+        unsigned long ia64_intri_res;                                                   \
+        asm volatile ("mov %0=cpuid[%r1]" : "=r"(ia64_intri_res) : "rO"(index));        \
+        ia64_intri_res;                                                                 \
+})
+
+#define __ia64_get_dbr(index)                                                   \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("mov %0=dbr[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_get_ibr(index)                                                     \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("mov %0=ibr[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_get_pkr(index)                                                     \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("mov %0=pkr[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_get_pmc(index)                                                     \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("mov %0=pmc[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
+        ia64_intri_res;                                                         \
+})
+
+
+#define ia64_native_get_pmd(index)                                              \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("mov %0=pmd[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_native_get_rr(index)                                               \
+({                                                                              \
+        unsigned long ia64_intri_res;                                           \
+        asm volatile ("mov %0=rr[%1]" : "=r"(ia64_intri_res) : "r" (index));    \
+        ia64_intri_res;                                                         \
+})
+
+#define ia64_native_fc(addr)    asm volatile ("fc %0" :: "r"(addr) : "memory")
+
+
+#define ia64_sync_i()   asm volatile (";; sync.i" ::: "memory")
+
+#define ia64_native_ssm(mask)   asm volatile ("ssm %0":: "i"((mask)) : "memory")
+#define ia64_native_rsm(mask)   asm volatile ("rsm %0":: "i"((mask)) : "memory")
+#define ia64_sum(mask)  asm volatile ("sum %0":: "i"((mask)) : "memory")
+#define ia64_rum(mask)  asm volatile ("rum %0":: "i"((mask)) : "memory")
+
+#define ia64_ptce(addr) asm volatile ("ptc.e %0" :: "r"(addr))
+
+#define ia64_native_ptcga(addr, size)                                           \
+do {                                                                            \
+        asm volatile ("ptc.ga %0,%1" :: "r"(addr), "r"(size) : "memory");       \
+        ia64_dv_serialize_data();                                               \
+} while (0)
+
+#define ia64_ptcl(addr, size)                                                   \
+do {                                                                            \
+        asm volatile ("ptc.l %0,%1" :: "r"(addr), "r"(size) : "memory");        \
+        ia64_dv_serialize_data();                                               \
+} while (0)
+
+#define ia64_ptri(addr, size)                                           \
+        asm volatile ("ptr.i %0,%1" :: "r"(addr), "r"(size) : "memory")
+
+#define ia64_ptrd(addr, size)                                           \
+        asm volatile ("ptr.d %0,%1" :: "r"(addr), "r"(size) : "memory")
+
+#define ia64_ttag(addr)                                                 \
+({                                                                        \
+        __u64 ia64_intri_res;                                              \
+        asm volatile ("ttag %0=%1" : "=r"(ia64_intri_res) : "r" (addr));   \
+        ia64_intri_res;                                                  \
+})
+
+
+/* Values for lfhint in ia64_lfetch and ia64_lfetch_fault */
+
+#define ia64_lfhint_none   0
+#define ia64_lfhint_nt1    1
+#define ia64_lfhint_nt2    2
+#define ia64_lfhint_nta    3
+
+#define ia64_lfetch(lfhint, y)                                  \
+({                                                              \
+        switch (lfhint) {                                       \
+        case ia64_lfhint_none:                                  \
+                asm volatile ("lfetch [%0]" : : "r"(y));        \
+                break;                                          \
+        case ia64_lfhint_nt1:                                   \
+                asm volatile ("lfetch.nt1 [%0]" : : "r"(y));    \
+                break;                                          \
+        case ia64_lfhint_nt2:                                   \
+                asm volatile ("lfetch.nt2 [%0]" : : "r"(y));    \
+                break;                                          \
+        case ia64_lfhint_nta:                                   \
+                asm volatile ("lfetch.nta [%0]" : : "r"(y));    \
+                break;                                          \
+        }                                                       \
+})
+
+#define ia64_lfetch_excl(lfhint, y)                                     \
+({                                                                      \
+        switch (lfhint) {                                               \
+        case ia64_lfhint_none:                                          \
+                asm volatile ("lfetch.excl [%0]" :: "r"(y));            \
+                break;                                                  \
+        case ia64_lfhint_nt1:                                           \
+                asm volatile ("lfetch.excl.nt1 [%0]" :: "r"(y));        \
+                break;                                                  \
+        case ia64_lfhint_nt2:                                           \
+                asm volatile ("lfetch.excl.nt2 [%0]" :: "r"(y));        \
+                break;                                                  \
+        case ia64_lfhint_nta:                                           \
+                asm volatile ("lfetch.excl.nta [%0]" :: "r"(y));        \
+                break;                                                  \
+        }                                                               \
+})
+
+#define ia64_lfetch_fault(lfhint, y)                                    \
+({                                                                      \
+        switch (lfhint) {                                               \
+        case ia64_lfhint_none:                                          \
+                asm volatile ("lfetch.fault [%0]" : : "r"(y));          \
+                break;                                                  \
+        case ia64_lfhint_nt1:                                           \
+                asm volatile ("lfetch.fault.nt1 [%0]" : : "r"(y));      \
+                break;                                                  \
+        case ia64_lfhint_nt2:                                           \
+                asm volatile ("lfetch.fault.nt2 [%0]" : : "r"(y));      \
+                break;                                                  \
+        case ia64_lfhint_nta:                                           \
+                asm volatile ("lfetch.fault.nta [%0]" : : "r"(y));      \
+                break;                                                  \
+        }                                                               \
+})
+
+#define ia64_lfetch_fault_excl(lfhint, y)                               \
+({                                                                      \
+        switch (lfhint) {                                               \
+        case ia64_lfhint_none:                                          \
+                asm volatile ("lfetch.fault.excl [%0]" :: "r"(y));      \
+                break;                                                  \
+        case ia64_lfhint_nt1:                                           \
+                asm volatile ("lfetch.fault.excl.nt1 [%0]" :: "r"(y));  \
+                break;                                                  \
+        case ia64_lfhint_nt2:                                           \
+                asm volatile ("lfetch.fault.excl.nt2 [%0]" :: "r"(y));  \
+                break;                                                  \
+        case ia64_lfhint_nta:                                           \
+                asm volatile ("lfetch.fault.excl.nta [%0]" :: "r"(y));  \
+                break;                                                  \
+        }                                                               \
+})
+
+#define ia64_native_intrin_local_irq_restore(x)                 \
+do {                                                            \
+        asm volatile (";;   cmp.ne p6,p7=%0,r0;;"               \
+                      "(p6) ssm psr.i;"                         \
+                      "(p7) rsm psr.i;;"                        \
+                      "(p6) srlz.d"                             \
+                      :: "r"((x)) : "p6", "p7", "memory");      \
+} while (0)
+
 #endif /* _ASM_IA64_GCC_INTRIN_H */
diff --git a/arch/ia64/include/asm/gpio.h b/arch/ia64/include/asm/gpio.h
index b3799d88ffc..590a20debc4 100644
--- a/arch/ia64/include/asm/gpio.h
+++ b/arch/ia64/include/asm/gpio.h
@@ -1,4 +1,55 @@
-#ifndef __LINUX_GPIO_H
-#warning Include linux/gpio.h instead of asm/gpio.h
-#include <linux/gpio.h>
-#endif
+/*
+ * Generic GPIO API implementation for IA-64.
+ *
+ * A stright copy of that for PowerPC which was:
+ *
+ * Copyright (c) 2007-2008  MontaVista Software, Inc.
+ *
+ * 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.
+ */
+
+#ifndef _ASM_IA64_GPIO_H
+#define _ASM_IA64_GPIO_H
+
+#include <linux/errno.h>
+#include <asm-generic/gpio.h>
+
+#ifdef CONFIG_GPIOLIB
+
+/*
+ * We don't (yet) implement inlined/rapid versions for on-chip gpios.
+ * Just call gpiolib.
+ */
+static inline int gpio_get_value(unsigned int gpio)
+{
+        return __gpio_get_value(gpio);
+}
+
+static inline void gpio_set_value(unsigned int gpio, int value)
+{
+        __gpio_set_value(gpio, value);
+}
+
+static inline int gpio_cansleep(unsigned int gpio)
+{
+        return __gpio_cansleep(gpio);
+}
+
+static inline int gpio_to_irq(unsigned int gpio)
+{
+        return __gpio_to_irq(gpio);
+}
+
+static inline int irq_to_gpio(unsigned int irq)
+{
+        return -EINVAL;
+}
+
+#endif /* CONFIG_GPIOLIB */
+
+#endif /* _ASM_IA64_GPIO_H */
diff --git a/arch/ia64/include/asm/hpsim.h b/arch/ia64/include/asm/hpsim.h
index 0fe50225daa..892ab198a9d 100644
--- a/arch/ia64/include/asm/hpsim.h
+++ b/arch/ia64/include/asm/hpsim.h
@@ -10,7 +10,7 @@ int simcons_register(void);
 struct tty_driver;
 extern struct tty_driver *hp_simserial_driver;
 
-extern int hpsim_get_irq(int intr);
+void ia64_ssc_connect_irq(long intr, long irq);
 void ia64_ctl_trace(long on);
 
 #endif
diff --git a/arch/ia64/include/asm/hugetlb.h b/arch/ia64/include/asm/hugetlb.h
index 94eaa5bd5d0..da55c63728e 100644
--- a/arch/ia64/include/asm/hugetlb.h
+++ b/arch/ia64/include/asm/hugetlb.h
@@ -77,8 +77,4 @@ static inline void arch_release_hugepage(struct page *page)
 {
 }
 
-static inline void arch_clear_hugepage_flags(struct page *page)
-{
-}
-
 #endif /* _ASM_IA64_HUGETLB_H */
diff --git a/arch/ia64/include/asm/intrinsics.h b/arch/ia64/include/asm/intrinsics.h
index 20477ea111b..111ed522289 100644
--- a/arch/ia64/include/asm/intrinsics.h
+++ b/arch/ia64/include/asm/intrinsics.h
@@ -1,25 +1,246 @@
+#ifndef _ASM_IA64_INTRINSICS_H
+#define _ASM_IA64_INTRINSICS_H
+
 /*
  * Compiler-dependent intrinsics.
  *
  * Copyright (C) 2002-2003 Hewlett-Packard Co
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
-#ifndef _ASM_IA64_INTRINSICS_H
-#define _ASM_IA64_INTRINSICS_H
 
+#ifndef __ASSEMBLY__
+
+#include <linux/types.h>
+/* include compiler specific intrinsics */
+#include <asm/ia64regs.h>
+#ifdef __INTEL_COMPILER
+# include <asm/intel_intrin.h>
+#else
+# include <asm/gcc_intrin.h>
+#endif
+
+#define ia64_native_get_psr_i() (ia64_native_getreg(_IA64_REG_PSR) & IA64_PSR_I)
+
+#define ia64_native_set_rr0_to_rr4(val0, val1, val2, val3, val4)        \
+do {                                                                    \
+        ia64_native_set_rr(0x0000000000000000UL, (val0));               \
+        ia64_native_set_rr(0x2000000000000000UL, (val1));               \
+        ia64_native_set_rr(0x4000000000000000UL, (val2));               \
+        ia64_native_set_rr(0x6000000000000000UL, (val3));               \
+        ia64_native_set_rr(0x8000000000000000UL, (val4));               \
+} while (0)
+
+/*
+ * Force an unresolved reference if someone tries to use
+ * ia64_fetch_and_add() with a bad value.
+ */
+extern unsigned long __bad_size_for_ia64_fetch_and_add (void);
+extern unsigned long __bad_increment_for_ia64_fetch_and_add (void);
+
+#define IA64_FETCHADD(tmp,v,n,sz,sem)                                           \
+({                                                                              \
+        switch (sz) {                                                           \
+              case 4:                                                           \
+                tmp = ia64_fetchadd4_##sem((unsigned int *) v, n);              \
+                break;                                                          \
+                                                                                \
+              case 8:                                                           \
+                tmp = ia64_fetchadd8_##sem((unsigned long *) v, n);             \
+                break;                                                          \
+                                                                                \
+              default:                                                          \
+                __bad_size_for_ia64_fetch_and_add();                            \
+        }                                                                       \
+})
+
+#define ia64_fetchadd(i,v,sem)                                                          \
+({                                                                                      \
+        __u64 _tmp;                                                                     \
+        volatile __typeof__(*(v)) *_v = (v);                                            \
+        /* Can't use a switch () here: gcc isn't always smart enough for that... */     \
+        if ((i) == -16)                                                                 \
+                IA64_FETCHADD(_tmp, _v, -16, sizeof(*(v)), sem);                        \
+        else if ((i) == -8)                                                             \
+                IA64_FETCHADD(_tmp, _v, -8, sizeof(*(v)), sem);                         \
+        else if ((i) == -4)                                                             \
+                IA64_FETCHADD(_tmp, _v, -4, sizeof(*(v)), sem);                         \
+        else if ((i) == -1)                                                             \
+                IA64_FETCHADD(_tmp, _v, -1, sizeof(*(v)), sem);                         \
+        else if ((i) == 1)                                                              \
+                IA64_FETCHADD(_tmp, _v, 1, sizeof(*(v)), sem);                          \
+        else if ((i) == 4)                                                              \
+                IA64_FETCHADD(_tmp, _v, 4, sizeof(*(v)), sem);                          \
+        else if ((i) == 8)                                                              \
+                IA64_FETCHADD(_tmp, _v, 8, sizeof(*(v)), sem);                          \
+        else if ((i) == 16)                                                             \
+                IA64_FETCHADD(_tmp, _v, 16, sizeof(*(v)), sem);                         \
+        else                                                                            \
+                _tmp = __bad_increment_for_ia64_fetch_and_add();                        \
+        (__typeof__(*(v))) (_tmp);      /* return old value */                          \
+})
+
+#define ia64_fetch_and_add(i,v) (ia64_fetchadd(i, v, rel) + (i)) /* return new value */
+
+/*
+ * This function doesn't exist, so you'll get a linker error if
+ * something tries to do an invalid xchg().
+ */
+extern void ia64_xchg_called_with_bad_pointer (void);
+
+#define __xchg(x,ptr,size)                                              \
+({                                                                      \
+        unsigned long __xchg_result;                                    \
+                                                                        \
+        switch (size) {                                                 \
+              case 1:                                                   \
+                __xchg_result = ia64_xchg1((__u8 *)ptr, x);             \
+                break;                                                  \
+                                                                        \
+              case 2:                                                   \
+                __xchg_result = ia64_xchg2((__u16 *)ptr, x);            \
+                break;                                                  \
+                                                                        \
+              case 4:                                                   \
+                __xchg_result = ia64_xchg4((__u32 *)ptr, x);            \
+                break;                                                  \
+                                                                        \
+              case 8:                                                   \
+                __xchg_result = ia64_xchg8((__u64 *)ptr, x);            \
+                break;                                                  \
+              default:                                                  \
+                ia64_xchg_called_with_bad_pointer();                    \
+        }                                                               \
+        __xchg_result;                                                  \
+})
+
+#define xchg(ptr,x)                                                          \
+  ((__typeof__(*(ptr))) __xchg ((unsigned long) (x), (ptr), sizeof(*(ptr))))
+
+/*
+ * Atomic compare and exchange.  Compare OLD with MEM, if identical,
+ * store NEW in MEM.  Return the initial value in MEM.  Success is
+ * indicated by comparing RETURN with OLD.
+ */
+
+#define __HAVE_ARCH_CMPXCHG 1
+
+/*
+ * This function doesn't exist, so you'll get a linker error
+ * if something tries to do an invalid cmpxchg().
+ */
+extern long ia64_cmpxchg_called_with_bad_pointer (void);
+
+#define ia64_cmpxchg(sem,ptr,old,new,size)                                              \
+({                                                                                      \
+        __u64 _o_, _r_;                                                                 \
+                                                                                        \
+        switch (size) {                                                                 \
+              case 1: _o_ = (__u8 ) (long) (old); break;                                \
+              case 2: _o_ = (__u16) (long) (old); break;                                \
+              case 4: _o_ = (__u32) (long) (old); break;                                \
+              case 8: _o_ = (__u64) (long) (old); break;                                \
+              default: break;                                                           \
+        }                                                                               \
+        switch (size) {                                                                 \
+              case 1:                                                                   \
+                _r_ = ia64_cmpxchg1_##sem((__u8 *) ptr, new, _o_);                      \
+                break;                                                                  \
+                                                                                        \
+              case 2:                                                                   \
+               _r_ = ia64_cmpxchg2_##sem((__u16 *) ptr, new, _o_);                      \
+                break;                                                                  \
+                                                                                        \
+              case 4:                                                                   \
+                _r_ = ia64_cmpxchg4_##sem((__u32 *) ptr, new, _o_);                     \
+                break;                                                                  \
+                                                                                        \
+              case 8:                                                                   \
+                _r_ = ia64_cmpxchg8_##sem((__u64 *) ptr, new, _o_);                     \
+                break;                                                                  \
+                                                                                        \
+              default:                                                                  \
+                _r_ = ia64_cmpxchg_called_with_bad_pointer();                           \
+                break;                                                                  \
+        }                                                                               \
+        (__typeof__(old)) _r_;                                                          \
+})
+
+#define cmpxchg_acq(ptr, o, n)  \
+        ia64_cmpxchg(acq, (ptr), (o), (n), sizeof(*(ptr)))
+#define cmpxchg_rel(ptr, o, n)  \
+        ia64_cmpxchg(rel, (ptr), (o), (n), sizeof(*(ptr)))
+
+/* for compatibility with other platforms: */
+#define cmpxchg(ptr, o, n)      cmpxchg_acq((ptr), (o), (n))
+#define cmpxchg64(ptr, o, n)    cmpxchg_acq((ptr), (o), (n))
+
+#define cmpxchg_local           cmpxchg
+#define cmpxchg64_local         cmpxchg64
+
+#ifdef CONFIG_IA64_DEBUG_CMPXCHG
+# define CMPXCHG_BUGCHECK_DECL  int _cmpxchg_bugcheck_count = 128;
+# define CMPXCHG_BUGCHECK(v)                                                    \
+  do {                                                                          \
+        if (_cmpxchg_bugcheck_count-- <= 0) {                                   \
+                void *ip;                                                       \
+                extern int printk(const char *fmt, ...);                        \
+                ip = (void *) ia64_getreg(_IA64_REG_IP);                        \
+                printk("CMPXCHG_BUGCHECK: stuck at %p on word %p\n", ip, (v));  \
+                break;                                                          \
+        }                                                                       \
+  } while (0)
+#else /* !CONFIG_IA64_DEBUG_CMPXCHG */
+# define CMPXCHG_BUGCHECK_DECL
+# define CMPXCHG_BUGCHECK(v)
+#endif /* !CONFIG_IA64_DEBUG_CMPXCHG */
+
+#endif
+
+#ifdef __KERNEL__
 #include <asm/paravirt_privop.h>
-#include <uapi/asm/intrinsics.h>
+#endif
 
 #ifndef __ASSEMBLY__
-#if defined(CONFIG_PARAVIRT)
-# undef IA64_INTRINSIC_API
-# undef IA64_INTRINSIC_MACRO
-# ifdef ASM_SUPPORTED
-#  define IA64_INTRINSIC_API(name)      paravirt_ ## name
-# else
-#  define IA64_INTRINSIC_API(name)      pv_cpu_ops.name
-# endif
+#if defined(CONFIG_PARAVIRT) && defined(__KERNEL__)
+#ifdef ASM_SUPPORTED
+# define IA64_INTRINSIC_API(name)       paravirt_ ## name
+#else
+# define IA64_INTRINSIC_API(name)       pv_cpu_ops.name
+#endif
 #define IA64_INTRINSIC_MACRO(name)      paravirt_ ## name
+#else
+#define IA64_INTRINSIC_API(name)        ia64_native_ ## name
+#define IA64_INTRINSIC_MACRO(name)      ia64_native_ ## name
 #endif
+
+/************************************************/
+/* Instructions paravirtualized for correctness */
+/************************************************/
+/* fc, thash, get_cpuid, get_pmd, get_eflags, set_eflags */
+/* Note that "ttag" and "cover" are also privilege-sensitive; "ttag"
+ * is not currently used (though it may be in a long-format VHPT system!)
+ */
+#define ia64_fc                         IA64_INTRINSIC_API(fc)
+#define ia64_thash                      IA64_INTRINSIC_API(thash)
+#define ia64_get_cpuid                  IA64_INTRINSIC_API(get_cpuid)
+#define ia64_get_pmd                    IA64_INTRINSIC_API(get_pmd)
+
+
+/************************************************/
+/* Instructions paravirtualized for performance */
+/************************************************/
+#define ia64_ssm                        IA64_INTRINSIC_MACRO(ssm)
+#define ia64_rsm                        IA64_INTRINSIC_MACRO(rsm)
+#define ia64_getreg                     IA64_INTRINSIC_MACRO(getreg)
+#define ia64_setreg                     IA64_INTRINSIC_API(setreg)
+#define ia64_set_rr                     IA64_INTRINSIC_API(set_rr)
+#define ia64_get_rr                     IA64_INTRINSIC_API(get_rr)
+#define ia64_ptcga                      IA64_INTRINSIC_API(ptcga)
+#define ia64_get_psr_i                  IA64_INTRINSIC_API(get_psr_i)
+#define ia64_intrin_local_irq_restore   \
+        IA64_INTRINSIC_API(intrin_local_irq_restore)
+#define ia64_set_rr0_to_rr4             IA64_INTRINSIC_API(set_rr0_to_rr4)
+
 #endif /* !__ASSEMBLY__ */
+
 #endif /* _ASM_IA64_INTRINSICS_H */
diff --git a/arch/ia64/include/asm/io.h b/arch/ia64/include/asm/io.h
index 74a7cc3293b..e5a6c3530c6 100644
--- a/arch/ia64/include/asm/io.h
+++ b/arch/ia64/include/asm/io.h
@@ -71,6 +71,7 @@ extern unsigned int num_io_spaces;
 #include <asm/intrinsics.h>
 #include <asm/machvec.h>
 #include <asm/page.h>
+#include <asm/system.h>
 #include <asm-generic/iomap.h>
 
 /*
@@ -90,7 +91,7 @@ phys_to_virt (unsigned long address)
 
 #define ARCH_HAS_VALID_PHYS_ADDR_RANGE
 extern u64 kern_mem_attribute (unsigned long phys_addr, unsigned long size);
-extern int valid_phys_addr_range (phys_addr_t addr, size_t count); /* efi.c */
+extern int valid_phys_addr_range (unsigned long addr, size_t count); /* efi.c */
 extern int valid_mmap_phys_addr_range (unsigned long pfn, size_t count);
 
 /*
diff --git a/arch/ia64/include/asm/iommu.h b/arch/ia64/include/asm/iommu.h
index 105c93b00b1..b6a809fa299 100644
--- a/arch/ia64/include/asm/iommu.h
+++ b/arch/ia64/include/asm/iommu.h
@@ -11,10 +11,12 @@ extern void no_iommu_init(void);
 extern int force_iommu, no_iommu;
 extern int iommu_pass_through;
 extern int iommu_detected;
+extern int iommu_group_mf;
 #else
 #define iommu_pass_through      (0)
 #define no_iommu                (1)
 #define iommu_detected          (0)
+#define iommu_group_mf          (0)
 #endif
 extern void iommu_dma_init(void);
 extern void machvec_init(const char *name);
diff --git a/arch/ia64/include/asm/iosapic.h b/arch/ia64/include/asm/iosapic.h
index 94c89a2d97f..b9c102e15f2 100644
--- a/arch/ia64/include/asm/iosapic.h
+++ b/arch/ia64/include/asm/iosapic.h
@@ -87,13 +87,18 @@ static inline void iosapic_eoi(char __iomem *iosapic, u32 vector)
 }
 
 extern void __init iosapic_system_init (int pcat_compat);
-extern int iosapic_init (unsigned long address, unsigned int gsi_base);
+extern int __devinit iosapic_init (unsigned long address,
+                                    unsigned int gsi_base);
+#ifdef CONFIG_HOTPLUG
 extern int iosapic_remove (unsigned int gsi_base);
+#else
+#define iosapic_remove(gsi_base)                                (-EINVAL)
+#endif /* CONFIG_HOTPLUG */
 extern int gsi_to_irq (unsigned int gsi);
 extern int iosapic_register_intr (unsigned int gsi, unsigned long polarity,
                                   unsigned long trigger);
 extern void iosapic_unregister_intr (unsigned int irq);
-extern void iosapic_override_isa_irq (unsigned int isa_irq, unsigned int gsi,
+extern void __devinit iosapic_override_isa_irq (unsigned int isa_irq, unsigned int gsi,
                                       unsigned long polarity,
                                       unsigned long trigger);
 extern int __init iosapic_register_platform_intr (u32 int_type,
@@ -104,7 +109,7 @@ extern int __init iosapic_register_platform_intr (u32 int_type,
                                            unsigned long trigger);
 
 #ifdef CONFIG_NUMA
-extern void map_iosapic_to_node (unsigned int, int);
+extern void __devinit map_iosapic_to_node (unsigned int, int);
 #endif
 #else
 #define iosapic_system_init(pcat_compat)                        do { } while (0)
diff --git a/arch/ia64/include/asm/irq_remapping.h b/arch/ia64/include/asm/irq_remapping.h
deleted file mode 100644
index a8687b1d890..00000000000
--- a/arch/ia64/include/asm/irq_remapping.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef __IA64_INTR_REMAPPING_H
-#define __IA64_INTR_REMAPPING_H
-#define irq_remapping_enabled 0
-#endif
diff --git a/arch/ia64/include/asm/irqflags.h b/arch/ia64/include/asm/irqflags.h
index 2b68d856dc7..f82d6be2ecd 100644
--- a/arch/ia64/include/asm/irqflags.h
+++ b/arch/ia64/include/asm/irqflags.h
@@ -10,8 +10,6 @@
 #ifndef _ASM_IA64_IRQFLAGS_H
 #define _ASM_IA64_IRQFLAGS_H
 
-#include <asm/pal.h>
-
 #ifdef CONFIG_IA64_DEBUG_IRQ
 extern unsigned long last_cli_ip;
 static inline void arch_maybe_save_ip(unsigned long flags)
diff --git a/arch/ia64/include/asm/kexec.h b/arch/ia64/include/asm/kexec.h
index aea2b81b03a..e1d58f819d7 100644
--- a/arch/ia64/include/asm/kexec.h
+++ b/arch/ia64/include/asm/kexec.h
@@ -1,7 +1,6 @@
 #ifndef _ASM_IA64_KEXEC_H
 #define _ASM_IA64_KEXEC_H
 
-#include <asm/setup.h>
 
 /* Maximum physical address we can use pages from */
 #define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
diff --git a/arch/ia64/include/asm/kvm_host.h b/arch/ia64/include/asm/kvm_host.h
index 6d6a5ac48d8..2689ee54a1c 100644
--- a/arch/ia64/include/asm/kvm_host.h
+++ b/arch/ia64/include/asm/kvm_host.h
@@ -365,7 +365,6 @@ struct thash_cb {
 };
 
 struct kvm_vcpu_stat {
-        u32 halt_wakeup;
 };
 
 struct kvm_vcpu_arch {
@@ -449,8 +448,6 @@ struct kvm_vcpu_arch {
         char log_buf[VMM_LOG_LEN];
         union context host;
         union context guest;
-
-        char mmio_data[8];
 };
 
 struct kvm_vm_stat {
@@ -462,9 +459,6 @@ struct kvm_sal_data {
         unsigned long boot_gp;
 };
 
-struct kvm_arch_memory_slot {
-};
-
 struct kvm_arch {
         spinlock_t dirty_log_lock;
 
diff --git a/arch/ia64/include/asm/machvec.h b/arch/ia64/include/asm/machvec.h
index 2d1ad4b11a8..367d299d993 100644
--- a/arch/ia64/include/asm/machvec.h
+++ b/arch/ia64/include/asm/machvec.h
@@ -120,7 +120,7 @@ extern void machvec_tlb_migrate_finish (struct mm_struct *);
 # ifdef MACHVEC_PLATFORM_HEADER
 #  include MACHVEC_PLATFORM_HEADER
 # else
-#  define ia64_platform_name    ia64_mv.name
+#  define platform_name         ia64_mv.name
 #  define platform_setup        ia64_mv.setup
 #  define platform_cpu_init     ia64_mv.cpu_init
 #  define platform_irq_init     ia64_mv.irq_init
diff --git a/arch/ia64/include/asm/machvec_dig.h b/arch/ia64/include/asm/machvec_dig.h
index 1f7403a2fbe..8a0752f4098 100644
--- a/arch/ia64/include/asm/machvec_dig.h
+++ b/arch/ia64/include/asm/machvec_dig.h
@@ -10,7 +10,7 @@ extern ia64_mv_setup_t dig_setup;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name      "dig"
+#define platform_name           "dig"
 #define platform_setup          dig_setup
 
 #endif /* _ASM_IA64_MACHVEC_DIG_h */
diff --git a/arch/ia64/include/asm/machvec_dig_vtd.h b/arch/ia64/include/asm/machvec_dig_vtd.h
index 44308b4c3f6..6ab1de5c45e 100644
--- a/arch/ia64/include/asm/machvec_dig_vtd.h
+++ b/arch/ia64/include/asm/machvec_dig_vtd.h
@@ -11,7 +11,7 @@ extern ia64_mv_dma_init			pci_iommu_alloc;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name                      "dig_vtd"
+#define platform_name                           "dig_vtd"
 #define platform_setup                          dig_setup
 #define platform_dma_init                       pci_iommu_alloc
 
diff --git a/arch/ia64/include/asm/machvec_hpsim.h b/arch/ia64/include/asm/machvec_hpsim.h
index e7571127936..cf72fc87fdf 100644
--- a/arch/ia64/include/asm/machvec_hpsim.h
+++ b/arch/ia64/include/asm/machvec_hpsim.h
@@ -11,7 +11,7 @@ extern ia64_mv_irq_init_t hpsim_irq_init;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name      "hpsim"
+#define platform_name           "hpsim"
 #define platform_setup          hpsim_setup
 #define platform_irq_init       hpsim_irq_init
 
diff --git a/arch/ia64/include/asm/machvec_hpzx1.h b/arch/ia64/include/asm/machvec_hpzx1.h
index c74d3159e9e..3bd83d78a41 100644
--- a/arch/ia64/include/asm/machvec_hpzx1.h
+++ b/arch/ia64/include/asm/machvec_hpzx1.h
@@ -11,7 +11,7 @@ extern ia64_mv_dma_init			sba_dma_init;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name                      "hpzx1"
+#define platform_name                           "hpzx1"
 #define platform_setup                          dig_setup
 #define platform_dma_init                       sba_dma_init
 
diff --git a/arch/ia64/include/asm/machvec_hpzx1_swiotlb.h b/arch/ia64/include/asm/machvec_hpzx1_swiotlb.h
index 906ef621077..1091ac39740 100644
--- a/arch/ia64/include/asm/machvec_hpzx1_swiotlb.h
+++ b/arch/ia64/include/asm/machvec_hpzx1_swiotlb.h
@@ -11,7 +11,7 @@ extern ia64_mv_dma_get_ops			hwsw_dma_get_ops;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name                      "hpzx1_swiotlb"
+#define platform_name                           "hpzx1_swiotlb"
 #define platform_setup                          dig_setup
 #define platform_dma_init                       machvec_noop
 #define platform_dma_get_ops                    hwsw_dma_get_ops
diff --git a/arch/ia64/include/asm/machvec_sn2.h b/arch/ia64/include/asm/machvec_sn2.h
index ece9fa85be8..f061a30aac4 100644
--- a/arch/ia64/include/asm/machvec_sn2.h
+++ b/arch/ia64/include/asm/machvec_sn2.h
@@ -71,7 +71,7 @@ extern ia64_mv_pci_fixup_bus_t		sn_pci_fixup_bus;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name              "sn2"
+#define platform_name                   "sn2"
 #define platform_setup                  sn_setup
 #define platform_cpu_init               sn_cpu_init
 #define platform_irq_init               sn_irq_init
diff --git a/arch/ia64/include/asm/machvec_uv.h b/arch/ia64/include/asm/machvec_uv.h
index 2c50853f35a..2931447f381 100644
--- a/arch/ia64/include/asm/machvec_uv.h
+++ b/arch/ia64/include/asm/machvec_uv.h
@@ -20,7 +20,7 @@ extern ia64_mv_setup_t uv_setup;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name              "uv"
+#define platform_name                   "uv"
 #define platform_setup                  uv_setup
 
 #endif /* _ASM_IA64_MACHVEC_UV_H */
diff --git a/arch/ia64/include/asm/machvec_xen.h b/arch/ia64/include/asm/machvec_xen.h
index 8b8bd0eb392..55f9228056c 100644
--- a/arch/ia64/include/asm/machvec_xen.h
+++ b/arch/ia64/include/asm/machvec_xen.h
@@ -13,7 +13,7 @@ extern ia64_mv_send_ipi_t		xen_platform_send_ipi;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define ia64_platform_name                      "xen"
+#define platform_name                           "xen"
 #define platform_setup                          dig_setup
 #define platform_cpu_init                       xen_cpu_init
 #define platform_irq_init                       xen_irq_init
diff --git a/arch/ia64/include/asm/mca_asm.h b/arch/ia64/include/asm/mca_asm.h
index 13c1d4994d4..dd2a5b13439 100644
--- a/arch/ia64/include/asm/mca_asm.h
+++ b/arch/ia64/include/asm/mca_asm.h
@@ -15,8 +15,6 @@
 #ifndef _ASM_IA64_MCA_ASM_H
 #define _ASM_IA64_MCA_ASM_H
 
-#include <asm/percpu.h>
-
 #define PSR_IC          13
 #define PSR_I           14
 #define PSR_DT          17
diff --git a/arch/ia64/include/asm/mman.h b/arch/ia64/include/asm/mman.h
index fdd5f5229f7..4459028e5aa 100644
--- a/arch/ia64/include/asm/mman.h
+++ b/arch/ia64/include/asm/mman.h
@@ -1,17 +1,23 @@
+#ifndef _ASM_IA64_MMAN_H
+#define _ASM_IA64_MMAN_H
+
 /*
  * Based on <asm-i386/mman.h>.
  *
  * Modified 1998-2000, 2002
  *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
  */
-#ifndef _ASM_IA64_MMAN_H
-#define _ASM_IA64_MMAN_H
 
-#include <uapi/asm/mman.h>
+#include <asm-generic/mman.h>
+
+#define MAP_GROWSUP     0x0200          /* register stack-like segment */
 
+#ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 #define arch_mmap_check ia64_mmap_check
 int ia64_mmap_check(unsigned long addr, unsigned long len,
                 unsigned long flags);
 #endif
+#endif
+
 #endif /* _ASM_IA64_MMAN_H */
diff --git a/arch/ia64/include/asm/module.h b/arch/ia64/include/asm/module.h
index dfba22a872c..908eaef42a0 100644
--- a/arch/ia64/include/asm/module.h
+++ b/arch/ia64/include/asm/module.h
@@ -1,8 +1,6 @@
 #ifndef _ASM_IA64_MODULE_H
 #define _ASM_IA64_MODULE_H
 
-#include <asm-generic/module.h>
-
 /*
  * IA-64-specific support for kernel module loader.
  *
@@ -31,6 +29,10 @@ struct mod_arch_specific {
         unsigned int next_got_entry;    /* index of next available got entry */
 };
 
+#define Elf_Shdr        Elf64_Shdr
+#define Elf_Sym         Elf64_Sym
+#define Elf_Ehdr        Elf64_Ehdr
+
 #define MODULE_PROC_FAMILY      "ia64"
 #define MODULE_ARCH_VERMAGIC    MODULE_PROC_FAMILY \
         "gcc-" __stringify(__GNUC__) "." __stringify(__GNUC_MINOR__)
diff --git a/arch/ia64/include/asm/numa.h b/arch/ia64/include/asm/numa.h
index 2e27ef17565..6a8a27cfae3 100644
--- a/arch/ia64/include/asm/numa.h
+++ b/arch/ia64/include/asm/numa.h
@@ -59,7 +59,7 @@ extern struct node_cpuid_s node_cpuid[NR_CPUS];
  */
 
 extern u8 numa_slit[MAX_NUMNODES * MAX_NUMNODES];
-#define node_distance(from,to) (numa_slit[(from) * MAX_NUMNODES + (to)])
+#define node_distance(from,to) (numa_slit[(from) * num_online_nodes() + (to)])
 
 extern int paddr_to_nid(unsigned long paddr);
 
diff --git a/arch/ia64/include/asm/page.h b/arch/ia64/include/asm/page.h
index f1e1b2e3cdb..961a16f43e6 100644
--- a/arch/ia64/include/asm/page.h
+++ b/arch/ia64/include/asm/page.h
@@ -221,14 +221,4 @@ get_order (unsigned long size)
                                          (((current->personality & READ_IMPLIES_EXEC) != 0)     \
                                           ? VM_EXEC : 0))
 
-#define GATE_ADDR               RGN_BASE(RGN_GATE)
-
-/*
- * 0xa000000000000000+2*PERCPU_PAGE_SIZE
- * - 0xa000000000000000+3*PERCPU_PAGE_SIZE remain unmapped (guard page)
- */
-#define KERNEL_START             (GATE_ADDR+__IA64_UL_CONST(0x100000000))
-#define PERCPU_ADDR             (-PERCPU_PAGE_SIZE)
-#define LOAD_OFFSET             (KERNEL_START - KERNEL_TR_PAGE_SIZE)
-
 #endif /* _ASM_IA64_PAGE_H */
diff --git a/arch/ia64/include/asm/param.h b/arch/ia64/include/asm/param.h
index 1295913d6a8..0964c32c135 100644
--- a/arch/ia64/include/asm/param.h
+++ b/arch/ia64/include/asm/param.h
@@ -1,3 +1,6 @@
+#ifndef _ASM_IA64_PARAM_H
+#define _ASM_IA64_PARAM_H
+
 /*
  * Fundamental kernel parameters.
  *
@@ -6,12 +9,25 @@
  * Modified 1998, 1999, 2002-2003
  *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
  */
-#ifndef _ASM_IA64_PARAM_H
-#define _ASM_IA64_PARAM_H
 
-#include <uapi/asm/param.h>
+#define EXEC_PAGESIZE   65536
+
+#ifndef NOGROUP
+# define NOGROUP        (-1)
+#endif
 
+#define MAXHOSTNAMELEN  64      /* max length of hostname */
+
+#ifdef __KERNEL__
 # define HZ             CONFIG_HZ
 # define USER_HZ        HZ
 # define CLOCKS_PER_SEC HZ      /* frequency at which times() counts */
+#else
+   /*
+    * Technically, this is wrong, but some old apps still refer to it.  The proper way to
+    * get the HZ value is via sysconf(_SC_CLK_TCK).
+    */
+# define HZ 1024
+#endif
+
 #endif /* _ASM_IA64_PARAM_H */
diff --git a/arch/ia64/include/asm/paravirt.h b/arch/ia64/include/asm/paravirt.h
index b149b88ea79..32551d304cd 100644
--- a/arch/ia64/include/asm/paravirt.h
+++ b/arch/ia64/include/asm/paravirt.h
@@ -281,9 +281,9 @@ paravirt_init_missing_ticks_accounting(int cpu)
                 pv_time_ops.init_missing_ticks_accounting(cpu);
 }
 
-struct static_key;
-extern struct static_key paravirt_steal_enabled;
-extern struct static_key paravirt_steal_rq_enabled;
+struct jump_label_key;
+extern struct jump_label_key paravirt_steal_enabled;
+extern struct jump_label_key paravirt_steal_rq_enabled;
 
 static inline int
 paravirt_do_steal_accounting(unsigned long *new_itm)
diff --git a/arch/ia64/include/asm/parport.h b/arch/ia64/include/asm/parport.h
index 638b4d271b9..67e16adfcd2 100644
--- a/arch/ia64/include/asm/parport.h
+++ b/arch/ia64/include/asm/parport.h
@@ -9,9 +9,10 @@
 #ifndef _ASM_IA64_PARPORT_H
 #define _ASM_IA64_PARPORT_H 1
 
-static int parport_pc_find_isa_ports(int autoirq, int autodma);
+static int __devinit parport_pc_find_isa_ports (int autoirq, int autodma);
 
-static int parport_pc_find_nonpci_ports(int autoirq, int autodma)
+static int __devinit
+parport_pc_find_nonpci_ports (int autoirq, int autodma)
 {
         return parport_pc_find_isa_ports(autoirq, autodma);
 }
diff --git a/arch/ia64/include/asm/pci.h b/arch/ia64/include/asm/pci.h
index 5e04b591e42..127dd7be346 100644
--- a/arch/ia64/include/asm/pci.h
+++ b/arch/ia64/include/asm/pci.h
@@ -11,14 +11,6 @@
 #include <asm/scatterlist.h>
 #include <asm/hw_irq.h>
 
-struct pci_vector_struct {
-        __u16 segment;  /* PCI Segment number */
-        __u16 bus;      /* PCI Bus number */
-        __u32 pci_id;   /* ACPI split 16 bits device, 16 bits function (see section 6.1.1) */
-        __u8 pin;       /* PCI PIN (0 = A, 1 = B, 2 = C, 3 = D) */
-        __u32 irq;      /* IRQ assigned */
-};
-
 /*
  * Can be used to override the logic in pci_scan_bus for skipping already-configured bus
  * numbers - to be used for buggy BIOSes or architectures with incomplete PCI setup by the
@@ -51,6 +43,12 @@ extern unsigned long ia64_max_iommu_merge_mask;
 #define PCI_DMA_BUS_IS_PHYS     (ia64_max_iommu_merge_mask == ~0UL)
 
 static inline void
+pcibios_set_master (struct pci_dev *dev)
+{
+        /* No special bus mastering setup handling */
+}
+
+static inline void
 pcibios_penalize_isa_irq (int irq, int active)
 {
         /* We don't do dynamic PCI IRQ allocation */
@@ -116,6 +114,12 @@ static inline int pci_proc_domain(struct pci_bus *bus)
         return (pci_domain_nr(bus) != 0);
 }
 
+extern void pcibios_resource_to_bus(struct pci_dev *dev,
+                struct pci_bus_region *region, struct resource *res);
+
+extern void pcibios_bus_to_resource(struct pci_dev *dev,
+                struct resource *res, struct pci_bus_region *region);
+
 static inline struct resource *
 pcibios_select_root(struct pci_dev *pdev, struct resource *res)
 {
diff --git a/arch/ia64/include/asm/perfmon.h b/arch/ia64/include/asm/perfmon.h
index 15476dd3a8b..d551183fee9 100644
--- a/arch/ia64/include/asm/perfmon.h
+++ b/arch/ia64/include/asm/perfmon.h
@@ -2,12 +2,179 @@
  * Copyright (C) 2001-2003 Hewlett-Packard Co
  *               Stephane Eranian <eranian@hpl.hp.com>
  */
+
 #ifndef _ASM_IA64_PERFMON_H
 #define _ASM_IA64_PERFMON_H
 
-#include <uapi/asm/perfmon.h>
+/*
+ * perfmon commands supported on all CPU models
+ */
+#define PFM_WRITE_PMCS          0x01
+#define PFM_WRITE_PMDS          0x02
+#define PFM_READ_PMDS           0x03
+#define PFM_STOP                0x04
+#define PFM_START               0x05
+#define PFM_ENABLE              0x06 /* obsolete */
+#define PFM_DISABLE             0x07 /* obsolete */
+#define PFM_CREATE_CONTEXT      0x08
+#define PFM_DESTROY_CONTEXT     0x09 /* obsolete use close() */
+#define PFM_RESTART             0x0a
+#define PFM_PROTECT_CONTEXT     0x0b /* obsolete */
+#define PFM_GET_FEATURES        0x0c
+#define PFM_DEBUG               0x0d
+#define PFM_UNPROTECT_CONTEXT   0x0e /* obsolete */
+#define PFM_GET_PMC_RESET_VAL   0x0f
+#define PFM_LOAD_CONTEXT        0x10
+#define PFM_UNLOAD_CONTEXT      0x11
+
+/*
+ * PMU model specific commands (may not be supported on all PMU models)
+ */
+#define PFM_WRITE_IBRS          0x20
+#define PFM_WRITE_DBRS          0x21
+
+/*
+ * context flags
+ */
+#define PFM_FL_NOTIFY_BLOCK      0x01   /* block task on user level notifications */
+#define PFM_FL_SYSTEM_WIDE       0x02   /* create a system wide context */
+#define PFM_FL_OVFL_NO_MSG       0x80   /* do not post overflow/end messages for notification */
+
+/*
+ * event set flags
+ */
+#define PFM_SETFL_EXCL_IDLE      0x01   /* exclude idle task (syswide only) XXX: DO NOT USE YET */
+
+/*
+ * PMC flags
+ */
+#define PFM_REGFL_OVFL_NOTIFY   0x1     /* send notification on overflow */
+#define PFM_REGFL_RANDOM        0x2     /* randomize sampling interval   */
+
+/*
+ * PMD/PMC/IBR/DBR return flags (ignored on input)
+ *
+ * Those flags are used on output and must be checked in case EAGAIN is returned
+ * by any of the calls using a pfarg_reg_t or pfarg_dbreg_t structure.
+ */
+#define PFM_REG_RETFL_NOTAVAIL  (1UL<<31) /* set if register is implemented but not available */
+#define PFM_REG_RETFL_EINVAL    (1UL<<30) /* set if register entry is invalid */
+#define PFM_REG_RETFL_MASK      (PFM_REG_RETFL_NOTAVAIL|PFM_REG_RETFL_EINVAL)
+
+#define PFM_REG_HAS_ERROR(flag) (((flag) & PFM_REG_RETFL_MASK) != 0)
+
+typedef unsigned char pfm_uuid_t[16];   /* custom sampling buffer identifier type */
+
+/*
+ * Request structure used to define a context
+ */
+typedef struct {
+        pfm_uuid_t     ctx_smpl_buf_id;  /* which buffer format to use (if needed) */
+        unsigned long  ctx_flags;        /* noblock/block */
+        unsigned short ctx_nextra_sets;  /* number of extra event sets (you always get 1) */
+        unsigned short ctx_reserved1;    /* for future use */
+        int            ctx_fd;           /* return arg: unique identification for context */
+        void           *ctx_smpl_vaddr;  /* return arg: virtual address of sampling buffer, is used */
+        unsigned long  ctx_reserved2[11];/* for future use */
+} pfarg_context_t;
+
+/*
+ * Request structure used to write/read a PMC or PMD
+ */
+typedef struct {
+        unsigned int    reg_num;           /* which register */
+        unsigned short  reg_set;           /* event set for this register */
+        unsigned short  reg_reserved1;     /* for future use */
+
+        unsigned long   reg_value;         /* initial pmc/pmd value */
+        unsigned long   reg_flags;         /* input: pmc/pmd flags, return: reg error */
+
+        unsigned long   reg_long_reset;    /* reset after buffer overflow notification */
+        unsigned long   reg_short_reset;   /* reset after counter overflow */
+
+        unsigned long   reg_reset_pmds[4]; /* which other counters to reset on overflow */
+        unsigned long   reg_random_seed;   /* seed value when randomization is used */
+        unsigned long   reg_random_mask;   /* bitmask used to limit random value */
+        unsigned long   reg_last_reset_val;/* return: PMD last reset value */
+
+        unsigned long   reg_smpl_pmds[4];  /* which pmds are accessed when PMC overflows */
+        unsigned long   reg_smpl_eventid;  /* opaque sampling event identifier */
+
+        unsigned long   reg_reserved2[3];   /* for future use */
+} pfarg_reg_t;
+
+typedef struct {
+        unsigned int    dbreg_num;              /* which debug register */
+        unsigned short  dbreg_set;              /* event set for this register */
+        unsigned short  dbreg_reserved1;        /* for future use */
+        unsigned long   dbreg_value;            /* value for debug register */
+        unsigned long   dbreg_flags;            /* return: dbreg error */
+        unsigned long   dbreg_reserved2[1];     /* for future use */
+} pfarg_dbreg_t;
+
+typedef struct {
+        unsigned int    ft_version;     /* perfmon: major [16-31], minor [0-15] */
+        unsigned int    ft_reserved;    /* reserved for future use */
+        unsigned long   reserved[4];    /* for future use */
+} pfarg_features_t;
+
+typedef struct {
+        pid_t           load_pid;          /* process to load the context into */
+        unsigned short  load_set;          /* first event set to load */
+        unsigned short  load_reserved1;    /* for future use */
+        unsigned long   load_reserved2[3]; /* for future use */
+} pfarg_load_t;
+
+typedef struct {
+        int             msg_type;               /* generic message header */
+        int             msg_ctx_fd;             /* generic message header */
+        unsigned long   msg_ovfl_pmds[4];       /* which PMDs overflowed */
+        unsigned short  msg_active_set;         /* active set at the time of overflow */
+        unsigned short  msg_reserved1;          /* for future use */
+        unsigned int    msg_reserved2;          /* for future use */
+        unsigned long   msg_tstamp;             /* for perf tuning/debug */
+} pfm_ovfl_msg_t;
+
+typedef struct {
+        int             msg_type;               /* generic message header */
+        int             msg_ctx_fd;             /* generic message header */
+        unsigned long   msg_tstamp;             /* for perf tuning */
+} pfm_end_msg_t;
+
+typedef struct {
+        int             msg_type;               /* type of the message */
+        int             msg_ctx_fd;             /* unique identifier for the context */
+        unsigned long   msg_tstamp;             /* for perf tuning */
+} pfm_gen_msg_t;
+
+#define PFM_MSG_OVFL    1       /* an overflow happened */
+#define PFM_MSG_END     2       /* task to which context was attached ended */
+
+typedef union {
+        pfm_ovfl_msg_t  pfm_ovfl_msg;
+        pfm_end_msg_t   pfm_end_msg;
+        pfm_gen_msg_t   pfm_gen_msg;
+} pfm_msg_t;
+
+/*
+ * Define the version numbers for both perfmon as a whole and the sampling buffer format.
+ */
+#define PFM_VERSION_MAJ          2U
+#define PFM_VERSION_MIN          0U
+#define PFM_VERSION              (((PFM_VERSION_MAJ&0xffff)<<16)|(PFM_VERSION_MIN & 0xffff))
+#define PFM_VERSION_MAJOR(x)     (((x)>>16) & 0xffff)
+#define PFM_VERSION_MINOR(x)     ((x) & 0xffff)
 
 
+/*
+ * miscellaneous architected definitions
+ */
+#define PMU_FIRST_COUNTER       4       /* first counting monitor (PMC/PMD) */
+#define PMU_MAX_PMCS            256     /* maximum architected number of PMC registers */
+#define PMU_MAX_PMDS            256     /* maximum architected number of PMD registers */
+
+#ifdef __KERNEL__
+
 extern long perfmonctl(int fd, int cmd, void *arg, int narg);
 
 typedef struct {
@@ -107,4 +274,6 @@ typedef struct {
 extern pfm_sysctl_t pfm_sysctl;
 
 
+#endif /* __KERNEL__ */
+
 #endif /* _ASM_IA64_PERFMON_H */
diff --git a/arch/ia64/include/asm/pgtable.h b/arch/ia64/include/asm/pgtable.h
index 815810cbbed..1a97af31ef1 100644
--- a/arch/ia64/include/asm/pgtable.h
+++ b/arch/ia64/include/asm/pgtable.h
@@ -16,6 +16,7 @@
 #include <asm/mman.h>
 #include <asm/page.h>
 #include <asm/processor.h>
+#include <asm/system.h>
 #include <asm/types.h>
 
 #define IA64_MAX_PHYS_BITS      50      /* max. number of physical address bits (architected) */
diff --git a/arch/ia64/include/asm/processor.h b/arch/ia64/include/asm/processor.h
index e0a899a1a8a..d9f397fae03 100644
--- a/arch/ia64/include/asm/processor.h
+++ b/arch/ia64/include/asm/processor.h
@@ -19,9 +19,6 @@
 #include <asm/ptrace.h>
 #include <asm/ustack.h>
 
-#define __ARCH_WANT_UNLOCKED_CTXSW
-#define ARCH_HAS_PREFETCH_SWITCH_STACK
-
 #define IA64_NUM_PHYS_STACK_REG 96
 #define IA64_NUM_DBG_REGS       8
 
@@ -34,7 +31,8 @@
  * each (assuming 8KB page size), for a total of 8TB of user virtual
  * address space.
  */
-#define TASK_SIZE               DEFAULT_TASK_SIZE
+#define TASK_SIZE_OF(tsk)       ((tsk)->thread.task_size)
+#define TASK_SIZE               TASK_SIZE_OF(current)
 
 /*
  * This decides where the kernel will search for a free chunk of vm
@@ -279,6 +277,7 @@ struct thread_struct {
         __u8 pad[3];
         __u64 ksp;                      /* kernel stack pointer */
         __u64 map_base;                 /* base address for get_unmapped_area() */
+        __u64 task_size;                /* limit for task size */
         __u64 rbs_bot;                  /* the base address for the RBS */
         int last_fph_cpu;               /* CPU that may hold the contents of f32-f127 */
 
@@ -301,6 +300,7 @@ struct thread_struct {
         .ksp =          0,                                      \
         .map_base =     DEFAULT_MAP_BASE,                       \
         .rbs_bot =      STACK_TOP - DEFAULT_USER_STACK_SIZE,    \
+        .task_size =    DEFAULT_TASK_SIZE,                      \
         .last_fph_cpu =  -1,                                    \
         INIT_THREAD_PM                                          \
         .dbr =          {0, },                                  \
@@ -309,6 +309,7 @@ struct thread_struct {
 }
 
 #define start_thread(regs,new_ip,new_sp) do {                                                   \
+        set_fs(USER_DS);                                                                        \
         regs->cr_ipsr = ((regs->cr_ipsr | (IA64_PSR_BITS_TO_SET | IA64_PSR_CPL))                \
                          & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_RI | IA64_PSR_IS));              \
         regs->cr_iip = new_ip;                                                                  \
@@ -340,6 +341,25 @@ struct task_struct;
  */
 #define release_thread(dead_task)
 
+/* Prepare to copy thread state - unlazy all lazy status */
+#define prepare_to_copy(tsk)    do { } while (0)
+
+/*
+ * This is the mechanism for creating a new kernel thread.
+ *
+ * NOTE 1: Only a kernel-only process (ie the swapper or direct
+ * descendants who haven't done an "execve()") should use this: it
+ * will work within a system call from a "real" process, but the
+ * process memory space will not be free'd until both the parent and
+ * the child have exited.
+ *
+ * NOTE 2: This MUST NOT be an inlined function.  Otherwise, we get
+ * into trouble in init/main.c when the child thread returns to
+ * do_basic_setup() and the timing is such that free_initmem() has
+ * been called already.
+ */
+extern pid_t kernel_thread (int (*fn)(void *), void *arg, unsigned long flags);
+
 /* Get wait channel for task P.  */
 extern unsigned long get_wchan (struct task_struct *p);
 
@@ -701,10 +721,6 @@ extern unsigned long boot_option_idle_override;
 enum idle_boot_override {IDLE_NO_OVERRIDE=0, IDLE_HALT, IDLE_FORCE_MWAIT,
                          IDLE_NOMWAIT, IDLE_POLL};
 
-void default_idle(void);
-
-#define ia64_platform_is(x) (strcmp(x, ia64_platform_name) == 0)
-
 #endif /* !__ASSEMBLY__ */
 
 #endif /* _ASM_IA64_PROCESSOR_H */
diff --git a/arch/ia64/include/asm/ptrace.h b/arch/ia64/include/asm/ptrace.h
index 845143990a1..f5cb27614e3 100644
--- a/arch/ia64/include/asm/ptrace.h
+++ b/arch/ia64/include/asm/ptrace.h
@@ -1,3 +1,6 @@
+#ifndef _ASM_IA64_PTRACE_H
+#define _ASM_IA64_PTRACE_H
+
 /*
  * Copyright (C) 1998-2004 Hewlett-Packard Co
  *      David Mosberger-Tang <davidm@hpl.hp.com>
@@ -12,13 +15,52 @@
  *  6/17/99     D. Mosberger    added second unat member to "struct switch_stack"
  *
  */
-#ifndef _ASM_IA64_PTRACE_H
-#define _ASM_IA64_PTRACE_H
+/*
+ * When a user process is blocked, its state looks as follows:
+ *
+ *            +----------------------+  ------- IA64_STK_OFFSET
+ *            |                      |   ^
+ *            | struct pt_regs       |   |
+ *            |                      |   |
+ *            +----------------------+   |
+ *            |                      |   |
+ *            |    memory stack      |   |
+ *            | (growing downwards)  |   |
+ *            //.....................//  |
+ *                                       |
+ *            //.....................//  |
+ *            |                      |   |
+ *            +----------------------+   |
+ *            | struct switch_stack  |   |
+ *            |                      |   |
+ *            +----------------------+   |
+ *            |                      |   |
+ *            //.....................//  |
+ *                                       |
+ *            //.....................//  |
+ *            |                      |   |
+ *            |  register stack      |   |
+ *            | (growing upwards)    |   |
+ *            |                      |   |
+ *            +----------------------+   |  --- IA64_RBS_OFFSET
+ *            |  struct thread_info  |   |  ^
+ *            +----------------------+   |  |
+ *            |                      |   |  |
+ *            |  struct task_struct  |   |  |
+ * current -> |                      |   |  |
+ *            +----------------------+ -------
+ *
+ * Note that ar.ec is not saved explicitly in pt_reg or switch_stack.
+ * This is because ar.ec is saved as part of ar.pfs.
+ */
+
+
+#include <asm/fpu.h>
 
+#ifdef __KERNEL__
 #ifndef ASM_OFFSETS_C
 #include <asm/asm-offsets.h>
 #endif
-#include <uapi/asm/ptrace.h>
 
 /*
  * Base-2 logarithm of number of pages to allocate per task structure
@@ -39,8 +81,155 @@
 
 #define KERNEL_STACK_SIZE               IA64_STK_OFFSET
 
+#endif /* __KERNEL__ */
+
 #ifndef __ASSEMBLY__
 
+/*
+ * This struct defines the way the registers are saved on system
+ * calls.
+ *
+ * We don't save all floating point register because the kernel
+ * is compiled to use only a very small subset, so the other are
+ * untouched.
+ *
+ * THIS STRUCTURE MUST BE A MULTIPLE 16-BYTE IN SIZE
+ * (because the memory stack pointer MUST ALWAYS be aligned this way)
+ *
+ */
+struct pt_regs {
+        /* The following registers are saved by SAVE_MIN: */
+        unsigned long b6;               /* scratch */
+        unsigned long b7;               /* scratch */
+
+        unsigned long ar_csd;           /* used by cmp8xchg16 (scratch) */
+        unsigned long ar_ssd;           /* reserved for future use (scratch) */
+
+        unsigned long r8;               /* scratch (return value register 0) */
+        unsigned long r9;               /* scratch (return value register 1) */
+        unsigned long r10;              /* scratch (return value register 2) */
+        unsigned long r11;              /* scratch (return value register 3) */
+
+        unsigned long cr_ipsr;          /* interrupted task's psr */
+        unsigned long cr_iip;           /* interrupted task's instruction pointer */
+        /*
+         * interrupted task's function state; if bit 63 is cleared, it
+         * contains syscall's ar.pfs.pfm:
+         */
+        unsigned long cr_ifs;
+
+        unsigned long ar_unat;          /* interrupted task's NaT register (preserved) */
+        unsigned long ar_pfs;           /* prev function state  */
+        unsigned long ar_rsc;           /* RSE configuration */
+        /* The following two are valid only if cr_ipsr.cpl > 0 || ti->flags & _TIF_MCA_INIT */
+        unsigned long ar_rnat;          /* RSE NaT */
+        unsigned long ar_bspstore;      /* RSE bspstore */
+
+        unsigned long pr;               /* 64 predicate registers (1 bit each) */
+        unsigned long b0;               /* return pointer (bp) */
+        unsigned long loadrs;           /* size of dirty partition << 16 */
+
+        unsigned long r1;               /* the gp pointer */
+        unsigned long r12;              /* interrupted task's memory stack pointer */
+        unsigned long r13;              /* thread pointer */
+
+        unsigned long ar_fpsr;          /* floating point status (preserved) */
+        unsigned long r15;              /* scratch */
+
+        /* The remaining registers are NOT saved for system calls.  */
+
+        unsigned long r14;              /* scratch */
+        unsigned long r2;               /* scratch */
+        unsigned long r3;               /* scratch */
+
+        /* The following registers are saved by SAVE_REST: */
+        unsigned long r16;              /* scratch */
+        unsigned long r17;              /* scratch */
+        unsigned long r18;              /* scratch */
+        unsigned long r19;              /* scratch */
+        unsigned long r20;              /* scratch */
+        unsigned long r21;              /* scratch */
+        unsigned long r22;              /* scratch */
+        unsigned long r23;              /* scratch */
+        unsigned long r24;              /* scratch */
+        unsigned long r25;              /* scratch */
+        unsigned long r26;              /* scratch */
+        unsigned long r27;              /* scratch */
+        unsigned long r28;              /* scratch */
+        unsigned long r29;              /* scratch */
+        unsigned long r30;              /* scratch */
+        unsigned long r31;              /* scratch */
+
+        unsigned long ar_ccv;           /* compare/exchange value (scratch) */
+
+        /*
+         * Floating point registers that the kernel considers scratch:
+         */
+        struct ia64_fpreg f6;           /* scratch */
+        struct ia64_fpreg f7;           /* scratch */
+        struct ia64_fpreg f8;           /* scratch */
+        struct ia64_fpreg f9;           /* scratch */
+        struct ia64_fpreg f10;          /* scratch */
+        struct ia64_fpreg f11;          /* scratch */
+};
+
+/*
+ * This structure contains the addition registers that need to
+ * preserved across a context switch.  This generally consists of
+ * "preserved" registers.
+ */
+struct switch_stack {
+        unsigned long caller_unat;      /* user NaT collection register (preserved) */
+        unsigned long ar_fpsr;          /* floating-point status register */
+
+        struct ia64_fpreg f2;           /* preserved */
+        struct ia64_fpreg f3;           /* preserved */
+        struct ia64_fpreg f4;           /* preserved */
+        struct ia64_fpreg f5;           /* preserved */
+
+        struct ia64_fpreg f12;          /* scratch, but untouched by kernel */
+        struct ia64_fpreg f13;          /* scratch, but untouched by kernel */
+        struct ia64_fpreg f14;          /* scratch, but untouched by kernel */
+        struct ia64_fpreg f15;          /* scratch, but untouched by kernel */
+        struct ia64_fpreg f16;          /* preserved */
+        struct ia64_fpreg f17;          /* preserved */
+        struct ia64_fpreg f18;          /* preserved */
+        struct ia64_fpreg f19;          /* preserved */
+        struct ia64_fpreg f20;          /* preserved */
+        struct ia64_fpreg f21;          /* preserved */
+        struct ia64_fpreg f22;          /* preserved */
+        struct ia64_fpreg f23;          /* preserved */
+        struct ia64_fpreg f24;          /* preserved */
+        struct ia64_fpreg f25;          /* preserved */
+        struct ia64_fpreg f26;          /* preserved */
+        struct ia64_fpreg f27;          /* preserved */
+        struct ia64_fpreg f28;          /* preserved */
+        struct ia64_fpreg f29;          /* preserved */
+        struct ia64_fpreg f30;          /* preserved */
+        struct ia64_fpreg f31;          /* preserved */
+
+        unsigned long r4;               /* preserved */
+        unsigned long r5;               /* preserved */
+        unsigned long r6;               /* preserved */
+        unsigned long r7;               /* preserved */
+
+        unsigned long b0;               /* so we can force a direct return in copy_thread */
+        unsigned long b1;
+        unsigned long b2;
+        unsigned long b3;
+        unsigned long b4;
+        unsigned long b5;
+
+        unsigned long ar_pfs;           /* previous function state */
+        unsigned long ar_lc;            /* loop counter (preserved) */
+        unsigned long ar_unat;          /* NaT bits for r4-r7 */
+        unsigned long ar_rnat;          /* RSE NaT collection register */
+        unsigned long ar_bspstore;      /* RSE dirty base (preserved) */
+        unsigned long pr;               /* 64 predicate registers (1 bit each) */
+};
+
+#ifdef __KERNEL__
+
 #include <asm/current.h>
 #include <asm/page.h>
 
@@ -57,18 +246,7 @@ static inline unsigned long user_stack_pointer(struct pt_regs *regs)
         return regs->ar_bspstore;
 }
 
-static inline int is_syscall_success(struct pt_regs *regs)
-{
-        return regs->r10 != -1;
-}
-
-static inline long regs_return_value(struct pt_regs *regs)
-{
-        if (is_syscall_success(regs))
-                return regs->r8;
-        else
-                return -regs->r8;
-}
+#define regs_return_value(regs) ((regs)->r8)
 
 /* Conserve space in histogram by encoding slot bits in address
  * bits 2 and 3 rather than bits 0 and 1.
@@ -78,11 +256,6 @@ static inline long regs_return_value(struct pt_regs *regs)
         unsigned long __ip = instruction_pointer(regs);                 \
         (__ip & ~3UL) + ((__ip & 3UL) << 2);                            \
 })
-/*
- * Why not default?  Because user_stack_pointer() on ia64 gives register
- * stack backing store instead...
- */
-#define current_user_stack_pointer() (current_pt_regs()->r12)
 
   /* given a pointer to a task_struct, return the user's pt_regs */
 # define task_pt_regs(t)                (((struct pt_regs *) ((char *) (t) + IA64_STK_OFFSET)) - 1)
@@ -147,5 +320,46 @@ static inline long regs_return_value(struct pt_regs *regs)
   #define arch_has_single_step()  (1)
   #define arch_has_block_step()   (1)
 
+#endif /* !__KERNEL__ */
+
+/* pt_all_user_regs is used for PTRACE_GETREGS PTRACE_SETREGS */
+struct pt_all_user_regs {
+        unsigned long nat;
+        unsigned long cr_iip;
+        unsigned long cfm;
+        unsigned long cr_ipsr;
+        unsigned long pr;
+
+        unsigned long gr[32];
+        unsigned long br[8];
+        unsigned long ar[128];
+        struct ia64_fpreg fr[128];
+};
+
 #endif /* !__ASSEMBLY__ */
+
+/* indices to application-registers array in pt_all_user_regs */
+#define PT_AUR_RSC      16
+#define PT_AUR_BSP      17
+#define PT_AUR_BSPSTORE 18
+#define PT_AUR_RNAT     19
+#define PT_AUR_CCV      32
+#define PT_AUR_UNAT     36
+#define PT_AUR_FPSR     40
+#define PT_AUR_PFS      64
+#define PT_AUR_LC       65
+#define PT_AUR_EC       66
+
+/*
+ * The numbers chosen here are somewhat arbitrary but absolutely MUST
+ * not overlap with any of the number assigned in <linux/ptrace.h>.
+ */
+#define PTRACE_SINGLEBLOCK      12      /* resume execution until next branch */
+#define PTRACE_OLD_GETSIGINFO   13      /* (replaced by PTRACE_GETSIGINFO in <linux/ptrace.h>)  */
+#define PTRACE_OLD_SETSIGINFO   14      /* (replaced by PTRACE_SETSIGINFO in <linux/ptrace.h>)  */
+#define PTRACE_GETREGS          18      /* get all registers (pt_all_user_regs) in one shot */
+#define PTRACE_SETREGS          19      /* set all registers (pt_all_user_regs) in one shot */
+
+#define PTRACE_OLDSETOPTIONS    21
+
 #endif /* _ASM_IA64_PTRACE_H */
diff --git a/arch/ia64/include/asm/sal.h b/arch/ia64/include/asm/sal.h
index e504f382115..d19ddba4e32 100644
--- a/arch/ia64/include/asm/sal.h
+++ b/arch/ia64/include/asm/sal.h
@@ -40,6 +40,7 @@
 #include <linux/efi.h>
 
 #include <asm/pal.h>
+#include <asm/system.h>
 #include <asm/fpu.h>
 
 extern spinlock_t sal_lock;
diff --git a/arch/ia64/include/asm/siginfo.h b/arch/ia64/include/asm/siginfo.h
index 6f2e2dd0f28..c8fcaa2ac48 100644
--- a/arch/ia64/include/asm/siginfo.h
+++ b/arch/ia64/include/asm/siginfo.h
@@ -1,14 +1,124 @@
+#ifndef _ASM_IA64_SIGINFO_H
+#define _ASM_IA64_SIGINFO_H
+
 /*
  * Based on <asm-i386/siginfo.h>.
  *
  * Modified 1998-2002
  *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
  */
-#ifndef _ASM_IA64_SIGINFO_H
-#define _ASM_IA64_SIGINFO_H
 
+#define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int))
+
+#define HAVE_ARCH_SIGINFO_T
+#define HAVE_ARCH_COPY_SIGINFO
+#define HAVE_ARCH_COPY_SIGINFO_TO_USER
+
+#include <asm-generic/siginfo.h>
+
+typedef struct siginfo {
+        int si_signo;
+        int si_errno;
+        int si_code;
+        int __pad0;
+
+        union {
+                int _pad[SI_PAD_SIZE];
+
+                /* kill() */
+                struct {
+                        pid_t _pid;             /* sender's pid */
+                        uid_t _uid;             /* sender's uid */
+                } _kill;
+
+                /* POSIX.1b timers */
+                struct {
+                        timer_t _tid;           /* timer id */
+                        int _overrun;           /* overrun count */
+                        char _pad[sizeof(__ARCH_SI_UID_T) - sizeof(int)];
+                        sigval_t _sigval;       /* must overlay ._rt._sigval! */
+                        int _sys_private;       /* not to be passed to user */
+                } _timer;
+
+                /* POSIX.1b signals */
+                struct {
+                        pid_t _pid;             /* sender's pid */
+                        uid_t _uid;             /* sender's uid */
+                        sigval_t _sigval;
+                } _rt;
+
+                /* SIGCHLD */
+                struct {
+                        pid_t _pid;             /* which child */
+                        uid_t _uid;             /* sender's uid */
+                        int _status;            /* exit code */
+                        clock_t _utime;
+                        clock_t _stime;
+                } _sigchld;
+
+                /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+                struct {
+                        void __user *_addr;     /* faulting insn/memory ref. */
+                        int _imm;               /* immediate value for "break" */
+                        unsigned int _flags;    /* see below */
+                        unsigned long _isr;     /* isr */
+                        short _addr_lsb;        /* lsb of faulting address */
+                } _sigfault;
+
+                /* SIGPOLL */
+                struct {
+                        long _band;     /* POLL_IN, POLL_OUT, POLL_MSG (XPG requires a "long") */
+                        int _fd;
+                } _sigpoll;
+        } _sifields;
+} siginfo_t;
+
+#define si_imm          _sifields._sigfault._imm        /* as per UNIX SysV ABI spec */
+#define si_flags        _sifields._sigfault._flags
+/*
+ * si_isr is valid for SIGILL, SIGFPE, SIGSEGV, SIGBUS, and SIGTRAP provided that
+ * si_code is non-zero and __ISR_VALID is set in si_flags.
+ */
+#define si_isr          _sifields._sigfault._isr
+
+/*
+ * Flag values for si_flags:
+ */
+#define __ISR_VALID_BIT 0
+#define __ISR_VALID     (1 << __ISR_VALID_BIT)
+
+/*
+ * SIGILL si_codes
+ */
+#define ILL_BADIADDR    (__SI_FAULT|9)  /* unimplemented instruction address */
+#define __ILL_BREAK     (__SI_FAULT|10) /* illegal break */
+#define __ILL_BNDMOD    (__SI_FAULT|11) /* bundle-update (modification) in progress */
+#undef NSIGILL
+#define NSIGILL         11
+
+/*
+ * SIGFPE si_codes
+ */
+#define __FPE_DECOVF    (__SI_FAULT|9)  /* decimal overflow */
+#define __FPE_DECDIV    (__SI_FAULT|10) /* decimal division by zero */
+#define __FPE_DECERR    (__SI_FAULT|11) /* packed decimal error */
+#define __FPE_INVASC    (__SI_FAULT|12) /* invalid ASCII digit */
+#define __FPE_INVDEC    (__SI_FAULT|13) /* invalid decimal digit */
+#undef NSIGFPE
+#define NSIGFPE         13
+
+/*
+ * SIGSEGV si_codes
+ */
+#define __SEGV_PSTKOVF  (__SI_FAULT|3)  /* paragraph stack overflow */
+#undef NSIGSEGV
+#define NSIGSEGV        3
+
+#undef NSIGTRAP
+#define NSIGTRAP        4
+
+#ifdef __KERNEL__
 #include <linux/string.h>
-#include <uapi/asm/siginfo.h>
 
 static inline void
 copy_siginfo (siginfo_t *to, siginfo_t *from)
@@ -20,4 +130,6 @@ copy_siginfo (siginfo_t *to, siginfo_t *from)
                 memcpy(to, from, 4*sizeof(int) + sizeof(from->_sifields._sigchld));
 }
 
+#endif /* __KERNEL__ */
+
 #endif /* _ASM_IA64_SIGINFO_H */
diff --git a/arch/ia64/include/asm/signal.h b/arch/ia64/include/asm/signal.h
index 3a1b20e74c5..b166248d49a 100644
--- a/arch/ia64/include/asm/signal.h
+++ b/arch/ia64/include/asm/signal.h
@@ -1,3 +1,6 @@
+#ifndef _ASM_IA64_SIGNAL_H
+#define _ASM_IA64_SIGNAL_H
+
 /*
  * Modified 1998-2001, 2003
  *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
@@ -5,18 +8,129 @@
  * Unfortunately, this file is being included by bits/signal.h in
  * glibc-2.x.  Hence the #ifdef __KERNEL__ ugliness.
  */
-#ifndef _ASM_IA64_SIGNAL_H
-#define _ASM_IA64_SIGNAL_H
 
-#include <uapi/asm/signal.h>
+#define SIGHUP           1
+#define SIGINT           2
+#define SIGQUIT          3
+#define SIGILL           4
+#define SIGTRAP          5
+#define SIGABRT          6
+#define SIGIOT           6
+#define SIGBUS           7
+#define SIGFPE           8
+#define SIGKILL          9
+#define SIGUSR1         10
+#define SIGSEGV         11
+#define SIGUSR2         12
+#define SIGPIPE         13
+#define SIGALRM         14
+#define SIGTERM         15
+#define SIGSTKFLT       16
+#define SIGCHLD         17
+#define SIGCONT         18
+#define SIGSTOP         19
+#define SIGTSTP         20
+#define SIGTTIN         21
+#define SIGTTOU         22
+#define SIGURG          23
+#define SIGXCPU         24
+#define SIGXFSZ         25
+#define SIGVTALRM       26
+#define SIGPROF         27
+#define SIGWINCH        28
+#define SIGIO           29
+#define SIGPOLL         SIGIO
+/*
+#define SIGLOST         29
+*/
+#define SIGPWR          30
+#define SIGSYS          31
+/* signal 31 is no longer "unused", but the SIGUNUSED macro remains for backwards compatibility */
+#define SIGUNUSED       31
+
+/* These should not be considered constants from userland.  */
+#define SIGRTMIN        32
+#define SIGRTMAX        _NSIG
+
+/*
+ * SA_FLAGS values:
+ *
+ * SA_ONSTACK indicates that a registered stack_t will be used.
+ * SA_RESTART flag to get restarting signals (which were the default long ago)
+ * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
+ * SA_RESETHAND clears the handler when the signal is delivered.
+ * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
+ * SA_NODEFER prevents the current signal from being masked in the handler.
+ *
+ * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
+ * Unix names RESETHAND and NODEFER respectively.
+ */
+#define SA_NOCLDSTOP    0x00000001
+#define SA_NOCLDWAIT    0x00000002
+#define SA_SIGINFO      0x00000004
+#define SA_ONSTACK      0x08000000
+#define SA_RESTART      0x10000000
+#define SA_NODEFER      0x40000000
+#define SA_RESETHAND    0x80000000
+
+#define SA_NOMASK       SA_NODEFER
+#define SA_ONESHOT      SA_RESETHAND
+
+#define SA_RESTORER     0x04000000
 
+/*
+ * sigaltstack controls
+ */
+#define SS_ONSTACK      1
+#define SS_DISABLE      2
+
+/*
+ * The minimum stack size needs to be fairly large because we want to
+ * be sure that an app compiled for today's CPUs will continue to run
+ * on all future CPU models.  The CPU model matters because the signal
+ * frame needs to have space for the complete machine state, including
+ * all physical stacked registers.  The number of physical stacked
+ * registers is CPU model dependent, but given that the width of
+ * ar.rsc.loadrs is 14 bits, we can assume that they'll never take up
+ * more than 16KB of space.
+ */
+#if 1
+  /*
+   * This is a stupid typo: the value was _meant_ to be 131072 (0x20000), but I typed it
+   * in wrong. ;-(  To preserve backwards compatibility, we leave the kernel at the
+   * incorrect value and fix libc only.
+   */
+# define MINSIGSTKSZ    131027  /* min. stack size for sigaltstack() */
+#else
+# define MINSIGSTKSZ    131072  /* min. stack size for sigaltstack() */
+#endif
+#define SIGSTKSZ        262144  /* default stack size for sigaltstack() */
+
+#ifdef __KERNEL__
 
 #define _NSIG           64
 #define _NSIG_BPW       64
 #define _NSIG_WORDS     (_NSIG / _NSIG_BPW)
 
+#endif /* __KERNEL__ */
+
+#include <asm-generic/signal-defs.h>
+
 # ifndef __ASSEMBLY__
 
+#  include <linux/types.h>
+
+/* Avoid too many header ordering problems.  */
+struct siginfo;
+
+typedef struct sigaltstack {
+        void __user *ss_sp;
+        int ss_flags;
+        size_t ss_size;
+} stack_t;
+
+#ifdef __KERNEL__
+
 /* Most things should be clean enough to redefine this at will, if care
    is taken to make libc match.  */
 
@@ -38,5 +152,9 @@ struct k_sigaction {
 
 #  include <asm/sigcontext.h>
 
+#define ptrace_signal_deliver(regs, cookie) do { } while (0)
+
+#endif /* __KERNEL__ */
+
 # endif /* !__ASSEMBLY__ */
 #endif /* _ASM_IA64_SIGNAL_H */
diff --git a/arch/ia64/include/asm/smp.h b/arch/ia64/include/asm/smp.h
index fea21e98602..0b3b3997dec 100644
--- a/arch/ia64/include/asm/smp.h
+++ b/arch/ia64/include/asm/smp.h
@@ -55,7 +55,7 @@ extern struct smp_boot_data {
         int cpu_phys_id[NR_CPUS];
 } smp_boot_data __initdata;
 
-extern char no_int_routing;
+extern char no_int_routing __devinitdata;
 
 extern cpumask_t cpu_core_map[NR_CPUS];
 DECLARE_PER_CPU_SHARED_ALIGNED(cpumask_t, cpu_sibling_map);
diff --git a/arch/ia64/include/asm/sn/pda.h b/arch/ia64/include/asm/sn/pda.h
index 22ae358c8d1..1c5108d44d8 100644
--- a/arch/ia64/include/asm/sn/pda.h
+++ b/arch/ia64/include/asm/sn/pda.h
@@ -10,6 +10,7 @@
 
 #include <linux/cache.h>
 #include <asm/percpu.h>
+#include <asm/system.h>
 
 
 /*
diff --git a/arch/ia64/include/asm/spinlock.h b/arch/ia64/include/asm/spinlock.h
index 54ff557d474..b77768d35f9 100644
--- a/arch/ia64/include/asm/spinlock.h
+++ b/arch/ia64/include/asm/spinlock.h
@@ -15,6 +15,7 @@
 
 #include <linux/atomic.h>
 #include <asm/intrinsics.h>
+#include <asm/system.h>
 
 #define arch_spin_lock_init(x)                  ((x)->lock = 0)
 
diff --git a/arch/ia64/include/asm/switch_to.h b/arch/ia64/include/asm/switch_to.h
deleted file mode 100644
index d38c7ea5eea..00000000000
--- a/arch/ia64/include/asm/switch_to.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Low-level task switching. This is based on information published in
- * the Processor Abstraction Layer and the System Abstraction Layer
- * manual.
- *
- * Copyright (C) 1998-2003 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- * Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>
- * Copyright (C) 1999 Don Dugger <don.dugger@intel.com>
- */
-#ifndef _ASM_IA64_SWITCH_TO_H
-#define _ASM_IA64_SWITCH_TO_H
-
-#include <linux/percpu.h>
-
-struct task_struct;
-
-/*
- * Context switch from one thread to another.  If the two threads have
- * different address spaces, schedule() has already taken care of
- * switching to the new address space by calling switch_mm().
- *
- * Disabling access to the fph partition and the debug-register
- * context switch MUST be done before calling ia64_switch_to() since a
- * newly created thread returns directly to
- * ia64_ret_from_syscall_clear_r8.
- */
-extern struct task_struct *ia64_switch_to (void *next_task);
-
-extern void ia64_save_extra (struct task_struct *task);
-extern void ia64_load_extra (struct task_struct *task);
-
-#ifdef CONFIG_PERFMON
-  DECLARE_PER_CPU(unsigned long, pfm_syst_info);
-# define PERFMON_IS_SYSWIDE() (__get_cpu_var(pfm_syst_info) & 0x1)
-#else
-# define PERFMON_IS_SYSWIDE() (0)
-#endif
-
-#define IA64_HAS_EXTRA_STATE(t)                                                 \
-        ((t)->thread.flags & (IA64_THREAD_DBG_VALID|IA64_THREAD_PM_VALID)       \
-         || PERFMON_IS_SYSWIDE())
-
-#define __switch_to(prev,next,last) do {                                                         \
-        if (IA64_HAS_EXTRA_STATE(prev))                                                          \
-                ia64_save_extra(prev);                                                           \
-        if (IA64_HAS_EXTRA_STATE(next))                                                          \
-                ia64_load_extra(next);                                                           \
-        ia64_psr(task_pt_regs(next))->dfh = !ia64_is_local_fpu_owner(next);                      \
-        (last) = ia64_switch_to((next));                                                         \
-} while (0)
-
-#ifdef CONFIG_SMP
-/*
- * In the SMP case, we save the fph state when context-switching away from a thread that
- * modified fph.  This way, when the thread gets scheduled on another CPU, the CPU can
- * pick up the state from task->thread.fph, avoiding the complication of having to fetch
- * the latest fph state from another CPU.  In other words: eager save, lazy restore.
- */
-# define switch_to(prev,next,last) do {                                         \
-        if (ia64_psr(task_pt_regs(prev))->mfh && ia64_is_local_fpu_owner(prev)) {                               \
-                ia64_psr(task_pt_regs(prev))->mfh = 0;                  \
-                (prev)->thread.flags |= IA64_THREAD_FPH_VALID;                  \
-                __ia64_save_fpu((prev)->thread.fph);                            \
-        }                                                                       \
-        __switch_to(prev, next, last);                                          \
-        /* "next" in old context is "current" in new context */                 \
-        if (unlikely((current->thread.flags & IA64_THREAD_MIGRATION) &&        \
-                     (task_cpu(current) !=                                     \
-                                      task_thread_info(current)->last_cpu))) { \
-                platform_migrate(current);                                     \
-                task_thread_info(current)->last_cpu = task_cpu(current);       \
-        }                                                                      \
-} while (0)
-#else
-# define switch_to(prev,next,last)      __switch_to(prev, next, last)
-#endif
-
-#endif /* _ASM_IA64_SWITCH_TO_H */
diff --git a/arch/ia64/include/asm/termios.h b/arch/ia64/include/asm/termios.h
index a42f870ca4f..689d218c0c2 100644
--- a/arch/ia64/include/asm/termios.h
+++ b/arch/ia64/include/asm/termios.h
@@ -1,14 +1,52 @@
+#ifndef _ASM_IA64_TERMIOS_H
+#define _ASM_IA64_TERMIOS_H
+
 /*
  * Modified 1999
  *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
  *
  * 99/01/28     Added N_IRDA and N_SMSBLOCK
  */
-#ifndef _ASM_IA64_TERMIOS_H
-#define _ASM_IA64_TERMIOS_H
 
-#include <uapi/asm/termios.h>
+#include <asm/termbits.h>
+#include <asm/ioctls.h>
 
+struct winsize {
+        unsigned short ws_row;
+        unsigned short ws_col;
+        unsigned short ws_xpixel;
+        unsigned short ws_ypixel;
+};
+
+#define NCC 8
+struct termio {
+        unsigned short c_iflag;         /* input mode flags */
+        unsigned short c_oflag;         /* output mode flags */
+        unsigned short c_cflag;         /* control mode flags */
+        unsigned short c_lflag;         /* local mode flags */
+        unsigned char c_line;           /* line discipline */
+        unsigned char c_cc[NCC];        /* control characters */
+};
+
+/* modem lines */
+#define TIOCM_LE        0x001
+#define TIOCM_DTR       0x002
+#define TIOCM_RTS       0x004
+#define TIOCM_ST        0x008
+#define TIOCM_SR        0x010
+#define TIOCM_CTS       0x020
+#define TIOCM_CAR       0x040
+#define TIOCM_RNG       0x080
+#define TIOCM_DSR       0x100
+#define TIOCM_CD        TIOCM_CAR
+#define TIOCM_RI        TIOCM_RNG
+#define TIOCM_OUT1      0x2000
+#define TIOCM_OUT2      0x4000
+#define TIOCM_LOOP      0x8000
+
+/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
+
+# ifdef __KERNEL__
 
 /*      intr=^C         quit=^\         erase=del       kill=^U
         eof=^D          vtime=\0        vmin=\1         sxtc=\0
@@ -54,4 +92,6 @@
 #define user_termios_to_kernel_termios_1(k, u) copy_from_user(k, u, sizeof(struct termios))
 #define kernel_termios_to_user_termios_1(u, k) copy_to_user(u, k, sizeof(struct termios))
 
+# endif /* __KERNEL__ */
+
 #endif /* _ASM_IA64_TERMIOS_H */
diff --git a/arch/ia64/include/asm/thread_info.h b/arch/ia64/include/asm/thread_info.h
index ff2ae413658..ff0cc84e7bc 100644
--- a/arch/ia64/include/asm/thread_info.h
+++ b/arch/ia64/include/asm/thread_info.h
@@ -54,6 +54,8 @@ struct thread_info {
         },                                      \
 }
 
+#define __HAVE_ARCH_THREAD_INFO_ALLOCATOR
+
 #ifndef ASM_OFFSETS_C
 /* how to get the thread information struct from C */
 #define current_thread_info()   ((struct thread_info *) ((char *) current + IA64_TASK_SIZE))
@@ -82,6 +84,7 @@ struct thread_info {
 #endif
 #define end_of_stack(p) (unsigned long *)((void *)(p) + IA64_RBS_OFFSET)
 
+#define __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
 #define alloc_task_struct_node(node)                                            \
 ({                                                                              \
         struct page *page = alloc_pages_node(node, GFP_KERNEL | __GFP_COMP,     \
@@ -106,9 +109,11 @@ struct thread_info {
 #define TIF_SYSCALL_AUDIT       3       /* syscall auditing active */
 #define TIF_SINGLESTEP          4       /* restore singlestep on return to user mode */
 #define TIF_NOTIFY_RESUME       6       /* resumption notification requested */
+#define TIF_POLLING_NRFLAG      16      /* true if poll_idle() is polling TIF_NEED_RESCHED */
 #define TIF_MEMDIE              17      /* is terminating due to OOM killer */
 #define TIF_MCA_INIT            18      /* this task is processing MCA or INIT */
 #define TIF_DB_DISABLED         19      /* debug trap disabled for fsyscall */
+#define TIF_FREEZE              20      /* is freezing for suspend */
 #define TIF_RESTORE_RSE         21      /* user RBS is newer than kernel RBS */
 
 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
@@ -118,8 +123,10 @@ struct thread_info {
 #define _TIF_NOTIFY_RESUME      (1 << TIF_NOTIFY_RESUME)
 #define _TIF_SIGPENDING         (1 << TIF_SIGPENDING)
 #define _TIF_NEED_RESCHED       (1 << TIF_NEED_RESCHED)
+#define _TIF_POLLING_NRFLAG     (1 << TIF_POLLING_NRFLAG)
 #define _TIF_MCA_INIT           (1 << TIF_MCA_INIT)
 #define _TIF_DB_DISABLED        (1 << TIF_DB_DISABLED)
+#define _TIF_FREEZE             (1 << TIF_FREEZE)
 #define _TIF_RESTORE_RSE        (1 << TIF_RESTORE_RSE)
 
 /* "work to do on user-return" bits */
@@ -139,23 +146,7 @@ static inline void set_restore_sigmask(void)
 {
         struct thread_info *ti = current_thread_info();
         ti->status |= TS_RESTORE_SIGMASK;
-        WARN_ON(!test_bit(TIF_SIGPENDING, &ti->flags));
-}
-static inline void clear_restore_sigmask(void)
-{
-        current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
-}
-static inline bool test_restore_sigmask(void)
-{
-        return current_thread_info()->status & TS_RESTORE_SIGMASK;
-}
-static inline bool test_and_clear_restore_sigmask(void)
-{
-        struct thread_info *ti = current_thread_info();
-        if (!(ti->status & TS_RESTORE_SIGMASK))
-                return false;
-        ti->status &= ~TS_RESTORE_SIGMASK;
-        return true;
+        set_bit(TIF_SIGPENDING, &ti->flags);
 }
 #endif  /* !__ASSEMBLY__ */
 
diff --git a/arch/ia64/include/asm/topology.h b/arch/ia64/include/asm/topology.h
index a2496e449b7..09f646753d1 100644
--- a/arch/ia64/include/asm/topology.h
+++ b/arch/ia64/include/asm/topology.h
@@ -70,6 +70,31 @@ void build_cpu_to_node_map(void);
         .nr_balance_failed      = 0,                    \
 }
 
+/* sched_domains SD_NODE_INIT for IA64 NUMA machines */
+#define SD_NODE_INIT (struct sched_domain) {            \
+        .parent                 = NULL,                 \
+        .child                  = NULL,                 \
+        .groups                 = NULL,                 \
+        .min_interval           = 8,                    \
+        .max_interval           = 8*(min(num_online_cpus(), 32U)), \
+        .busy_factor            = 64,                   \
+        .imbalance_pct          = 125,                  \
+        .cache_nice_tries       = 2,                    \
+        .busy_idx               = 3,                    \
+        .idle_idx               = 2,                    \
+        .newidle_idx            = 0,                    \
+        .wake_idx               = 0,                    \
+        .forkexec_idx           = 0,                    \
+        .flags                  = SD_LOAD_BALANCE       \
+                                | SD_BALANCE_NEWIDLE    \
+                                | SD_BALANCE_EXEC       \
+                                | SD_BALANCE_FORK       \
+                                | SD_SERIALIZE,         \
+        .last_balance           = jiffies,              \
+        .balance_interval       = 64,                   \
+        .nr_balance_failed      = 0,                    \
+}
+
 #endif /* CONFIG_NUMA */
 
 #ifdef CONFIG_SMP
diff --git a/arch/ia64/include/asm/types.h b/arch/ia64/include/asm/types.h
index 4c351b169da..82b3939d271 100644
--- a/arch/ia64/include/asm/types.h
+++ b/arch/ia64/include/asm/types.h
@@ -1,3 +1,6 @@
+#ifndef _ASM_IA64_TYPES_H
+#define _ASM_IA64_TYPES_H
+
 /*
  * This file is never included by application software unless explicitly
  * requested (e.g., via linux/types.h) in which case the application is
@@ -10,22 +13,34 @@
  * Modified 1998-2000, 2002
  *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
  */
-#ifndef _ASM_IA64_TYPES_H
-#define _ASM_IA64_TYPES_H
 
+#ifdef __KERNEL__
 #include <asm-generic/int-ll64.h>
-#include <uapi/asm/types.h>
+#else
+#include <asm-generic/int-l64.h>
+#endif
 
 #ifdef __ASSEMBLY__
+# define __IA64_UL(x)           (x)
+# define __IA64_UL_CONST(x)     x
+
 #else
+# define __IA64_UL(x)           ((unsigned long)(x))
+# define __IA64_UL_CONST(x)     x##UL
+
+typedef unsigned int umode_t;
+
 /*
  * These aren't exported outside the kernel to avoid name space clashes
  */
+# ifdef __KERNEL__
 
 struct fnptr {
         unsigned long ip;
         unsigned long gp;
 };
 
+# endif /* __KERNEL__ */
 #endif /* !__ASSEMBLY__ */
+
 #endif /* _ASM_IA64_TYPES_H */
diff --git a/arch/ia64/include/asm/unistd.h b/arch/ia64/include/asm/unistd.h
index c3cc42a15af..7c928da35b1 100644
--- a/arch/ia64/include/asm/unistd.h
+++ b/arch/ia64/include/asm/unistd.h
@@ -1,17 +1,331 @@
+#ifndef _ASM_IA64_UNISTD_H
+#define _ASM_IA64_UNISTD_H
+
 /*
  * IA-64 Linux syscall numbers and inline-functions.
  *
  * Copyright (C) 1998-2005 Hewlett-Packard Co
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  */
-#ifndef _ASM_IA64_UNISTD_H
-#define _ASM_IA64_UNISTD_H
 
-#include <uapi/asm/unistd.h>
+#include <asm/break.h>
+
+#define __BREAK_SYSCALL                 __IA64_BREAK_SYSCALL
+
+#define __NR_ni_syscall                 1024
+#define __NR_exit                       1025
+#define __NR_read                       1026
+#define __NR_write                      1027
+#define __NR_open                       1028
+#define __NR_close                      1029
+#define __NR_creat                      1030
+#define __NR_link                       1031
+#define __NR_unlink                     1032
+#define __NR_execve                     1033
+#define __NR_chdir                      1034
+#define __NR_fchdir                     1035
+#define __NR_utimes                     1036
+#define __NR_mknod                      1037
+#define __NR_chmod                      1038
+#define __NR_chown                      1039
+#define __NR_lseek                      1040
+#define __NR_getpid                     1041
+#define __NR_getppid                    1042
+#define __NR_mount                      1043
+#define __NR_umount                     1044
+#define __NR_setuid                     1045
+#define __NR_getuid                     1046
+#define __NR_geteuid                    1047
+#define __NR_ptrace                     1048
+#define __NR_access                     1049
+#define __NR_sync                       1050
+#define __NR_fsync                      1051
+#define __NR_fdatasync                  1052
+#define __NR_kill                       1053
+#define __NR_rename                     1054
+#define __NR_mkdir                      1055
+#define __NR_rmdir                      1056
+#define __NR_dup                        1057
+#define __NR_pipe                       1058
+#define __NR_times                      1059
+#define __NR_brk                        1060
+#define __NR_setgid                     1061
+#define __NR_getgid                     1062
+#define __NR_getegid                    1063
+#define __NR_acct                       1064
+#define __NR_ioctl                      1065
+#define __NR_fcntl                      1066
+#define __NR_umask                      1067
+#define __NR_chroot                     1068
+#define __NR_ustat                      1069
+#define __NR_dup2                       1070
+#define __NR_setreuid                   1071
+#define __NR_setregid                   1072
+#define __NR_getresuid                  1073
+#define __NR_setresuid                  1074
+#define __NR_getresgid                  1075
+#define __NR_setresgid                  1076
+#define __NR_getgroups                  1077
+#define __NR_setgroups                  1078
+#define __NR_getpgid                    1079
+#define __NR_setpgid                    1080
+#define __NR_setsid                     1081
+#define __NR_getsid                     1082
+#define __NR_sethostname                1083
+#define __NR_setrlimit                  1084
+#define __NR_getrlimit                  1085
+#define __NR_getrusage                  1086
+#define __NR_gettimeofday               1087
+#define __NR_settimeofday               1088
+#define __NR_select                     1089
+#define __NR_poll                       1090
+#define __NR_symlink                    1091
+#define __NR_readlink                   1092
+#define __NR_uselib                     1093
+#define __NR_swapon                     1094
+#define __NR_swapoff                    1095
+#define __NR_reboot                     1096
+#define __NR_truncate                   1097
+#define __NR_ftruncate                  1098
+#define __NR_fchmod                     1099
+#define __NR_fchown                     1100
+#define __NR_getpriority                1101
+#define __NR_setpriority                1102
+#define __NR_statfs                     1103
+#define __NR_fstatfs                    1104
+#define __NR_gettid                     1105
+#define __NR_semget                     1106
+#define __NR_semop                      1107
+#define __NR_semctl                     1108
+#define __NR_msgget                     1109
+#define __NR_msgsnd                     1110
+#define __NR_msgrcv                     1111
+#define __NR_msgctl                     1112
+#define __NR_shmget                     1113
+#define __NR_shmat                      1114
+#define __NR_shmdt                      1115
+#define __NR_shmctl                     1116
+/* also known as klogctl() in GNU libc: */
+#define __NR_syslog                     1117
+#define __NR_setitimer                  1118
+#define __NR_getitimer                  1119
+/* 1120 was __NR_old_stat */
+/* 1121 was __NR_old_lstat */
+/* 1122 was __NR_old_fstat */
+#define __NR_vhangup                    1123
+#define __NR_lchown                     1124
+#define __NR_remap_file_pages           1125
+#define __NR_wait4                      1126
+#define __NR_sysinfo                    1127
+#define __NR_clone                      1128
+#define __NR_setdomainname              1129
+#define __NR_uname                      1130
+#define __NR_adjtimex                   1131
+/* 1132 was __NR_create_module */
+#define __NR_init_module                1133
+#define __NR_delete_module              1134
+/* 1135 was __NR_get_kernel_syms */
+/* 1136 was __NR_query_module */
+#define __NR_quotactl                   1137
+#define __NR_bdflush                    1138
+#define __NR_sysfs                      1139
+#define __NR_personality                1140
+#define __NR_afs_syscall                1141
+#define __NR_setfsuid                   1142
+#define __NR_setfsgid                   1143
+#define __NR_getdents                   1144
+#define __NR_flock                      1145
+#define __NR_readv                      1146
+#define __NR_writev                     1147
+#define __NR_pread64                    1148
+#define __NR_pwrite64                   1149
+#define __NR__sysctl                    1150
+#define __NR_mmap                       1151
+#define __NR_munmap                     1152
+#define __NR_mlock                      1153
+#define __NR_mlockall                   1154
+#define __NR_mprotect                   1155
+#define __NR_mremap                     1156
+#define __NR_msync                      1157
+#define __NR_munlock                    1158
+#define __NR_munlockall                 1159
+#define __NR_sched_getparam             1160
+#define __NR_sched_setparam             1161
+#define __NR_sched_getscheduler         1162
+#define __NR_sched_setscheduler         1163
+#define __NR_sched_yield                1164
+#define __NR_sched_get_priority_max     1165
+#define __NR_sched_get_priority_min     1166
+#define __NR_sched_rr_get_interval      1167
+#define __NR_nanosleep                  1168
+#define __NR_nfsservctl                 1169
+#define __NR_prctl                      1170
+/* 1171 is reserved for backwards compatibility with old __NR_getpagesize */
+#define __NR_mmap2                      1172
+#define __NR_pciconfig_read             1173
+#define __NR_pciconfig_write            1174
+#define __NR_perfmonctl                 1175
+#define __NR_sigaltstack                1176
+#define __NR_rt_sigaction               1177
+#define __NR_rt_sigpending              1178
+#define __NR_rt_sigprocmask             1179
+#define __NR_rt_sigqueueinfo            1180
+#define __NR_rt_sigreturn               1181
+#define __NR_rt_sigsuspend              1182
+#define __NR_rt_sigtimedwait            1183
+#define __NR_getcwd                     1184
+#define __NR_capget                     1185
+#define __NR_capset                     1186
+#define __NR_sendfile                   1187
+#define __NR_getpmsg                    1188
+#define __NR_putpmsg                    1189
+#define __NR_socket                     1190
+#define __NR_bind                       1191
+#define __NR_connect                    1192
+#define __NR_listen                     1193
+#define __NR_accept                     1194
+#define __NR_getsockname                1195
+#define __NR_getpeername                1196
+#define __NR_socketpair                 1197
+#define __NR_send                       1198
+#define __NR_sendto                     1199
+#define __NR_recv                       1200
+#define __NR_recvfrom                   1201
+#define __NR_shutdown                   1202
+#define __NR_setsockopt                 1203
+#define __NR_getsockopt                 1204
+#define __NR_sendmsg                    1205
+#define __NR_recvmsg                    1206
+#define __NR_pivot_root                 1207
+#define __NR_mincore                    1208
+#define __NR_madvise                    1209
+#define __NR_stat                       1210
+#define __NR_lstat                      1211
+#define __NR_fstat                      1212
+#define __NR_clone2                     1213
+#define __NR_getdents64                 1214
+#define __NR_getunwind                  1215
+#define __NR_readahead                  1216
+#define __NR_setxattr                   1217
+#define __NR_lsetxattr                  1218
+#define __NR_fsetxattr                  1219
+#define __NR_getxattr                   1220
+#define __NR_lgetxattr                  1221
+#define __NR_fgetxattr                  1222
+#define __NR_listxattr                  1223
+#define __NR_llistxattr                 1224
+#define __NR_flistxattr                 1225
+#define __NR_removexattr                1226
+#define __NR_lremovexattr               1227
+#define __NR_fremovexattr               1228
+#define __NR_tkill                      1229
+#define __NR_futex                      1230
+#define __NR_sched_setaffinity          1231
+#define __NR_sched_getaffinity          1232
+#define __NR_set_tid_address            1233
+#define __NR_fadvise64                  1234
+#define __NR_tgkill                     1235
+#define __NR_exit_group                 1236
+#define __NR_lookup_dcookie             1237
+#define __NR_io_setup                   1238
+#define __NR_io_destroy                 1239
+#define __NR_io_getevents               1240
+#define __NR_io_submit                  1241
+#define __NR_io_cancel                  1242
+#define __NR_epoll_create               1243
+#define __NR_epoll_ctl                  1244
+#define __NR_epoll_wait                 1245
+#define __NR_restart_syscall            1246
+#define __NR_semtimedop                 1247
+#define __NR_timer_create               1248
+#define __NR_timer_settime              1249
+#define __NR_timer_gettime              1250
+#define __NR_timer_getoverrun           1251
+#define __NR_timer_delete               1252
+#define __NR_clock_settime              1253
+#define __NR_clock_gettime              1254
+#define __NR_clock_getres               1255
+#define __NR_clock_nanosleep            1256
+#define __NR_fstatfs64                  1257
+#define __NR_statfs64                   1258
+#define __NR_mbind                      1259
+#define __NR_get_mempolicy              1260
+#define __NR_set_mempolicy              1261
+#define __NR_mq_open                    1262
+#define __NR_mq_unlink                  1263
+#define __NR_mq_timedsend               1264
+#define __NR_mq_timedreceive            1265
+#define __NR_mq_notify                  1266
+#define __NR_mq_getsetattr              1267
+#define __NR_kexec_load                 1268
+#define __NR_vserver                    1269
+#define __NR_waitid                     1270
+#define __NR_add_key                    1271
+#define __NR_request_key                1272
+#define __NR_keyctl                     1273
+#define __NR_ioprio_set                 1274
+#define __NR_ioprio_get                 1275
+#define __NR_move_pages                 1276
+#define __NR_inotify_init               1277
+#define __NR_inotify_add_watch          1278
+#define __NR_inotify_rm_watch           1279
+#define __NR_migrate_pages              1280
+#define __NR_openat                     1281
+#define __NR_mkdirat                    1282
+#define __NR_mknodat                    1283
+#define __NR_fchownat                   1284
+#define __NR_futimesat                  1285
+#define __NR_newfstatat                 1286
+#define __NR_unlinkat                   1287
+#define __NR_renameat                   1288
+#define __NR_linkat                     1289
+#define __NR_symlinkat                  1290
+#define __NR_readlinkat                 1291
+#define __NR_fchmodat                   1292
+#define __NR_faccessat                  1293
+#define __NR_pselect6                   1294
+#define __NR_ppoll                      1295
+#define __NR_unshare                    1296
+#define __NR_splice                     1297
+#define __NR_set_robust_list            1298
+#define __NR_get_robust_list            1299
+#define __NR_sync_file_range            1300
+#define __NR_tee                        1301
+#define __NR_vmsplice                   1302
+#define __NR_fallocate                  1303
+#define __NR_getcpu                     1304
+#define __NR_epoll_pwait                1305
+#define __NR_utimensat                  1306
+#define __NR_signalfd                   1307
+#define __NR_timerfd                    1308
+#define __NR_eventfd                    1309
+#define __NR_timerfd_create             1310
+#define __NR_timerfd_settime            1311
+#define __NR_timerfd_gettime            1312
+#define __NR_signalfd4                  1313
+#define __NR_eventfd2                   1314
+#define __NR_epoll_create1              1315
+#define __NR_dup3                       1316
+#define __NR_pipe2                      1317
+#define __NR_inotify_init1              1318
+#define __NR_preadv                     1319
+#define __NR_pwritev                    1320
+#define __NR_rt_tgsigqueueinfo          1321
+#define __NR_recvmmsg                   1322
+#define __NR_fanotify_init              1323
+#define __NR_fanotify_mark              1324
+#define __NR_prlimit64                  1325
+#define __NR_name_to_handle_at          1326
+#define __NR_open_by_handle_at          1327
+#define __NR_clock_adjtime              1328
+#define __NR_syncfs                     1329
+#define __NR_setns                      1330
+#define __NR_sendmmsg                   1331
 
+#ifdef __KERNEL__
 
 
-#define NR_syscalls                     312 /* length of syscall table */
+#define NR_syscalls                     308 /* length of syscall table */
 
 /*
  * The following defines stop scripts/checksyscalls.sh from complaining about
@@ -65,4 +379,5 @@ asmlinkage long sys_rt_sigaction(int sig,
 #define cond_syscall(x) asmlinkage long x (void) __attribute__((weak,alias("sys_ni_syscall")))
 
 #endif /* !__ASSEMBLY__ */
+#endif /* __KERNEL__ */
 #endif /* _ASM_IA64_UNISTD_H */
diff --git a/arch/ia64/include/asm/ustack.h b/arch/ia64/include/asm/ustack.h
index b275401b96d..504167c35b8 100644
--- a/arch/ia64/include/asm/ustack.h
+++ b/arch/ia64/include/asm/ustack.h
@@ -1,11 +1,20 @@
 #ifndef _ASM_IA64_USTACK_H
 #define _ASM_IA64_USTACK_H
 
+/*
+ * Constants for the user stack size
+ */
+
+#ifdef __KERNEL__
 #include <asm/page.h>
-#include <uapi/asm/ustack.h>
 
 /* The absolute hard limit for stack size is 1/2 of the mappable space in the region */
 #define MAX_USER_STACK_SIZE     (RGN_MAP_LIMIT/2)
 #define STACK_TOP               (0x6000000000000000UL + RGN_MAP_LIMIT)
 #define STACK_TOP_MAX           STACK_TOP
+#endif
+
+/* Make a default stack size of 2GiB */
+#define DEFAULT_USER_STACK_SIZE (1UL << 31)
+
 #endif /* _ASM_IA64_USTACK_H */
diff --git a/arch/ia64/include/asm/uv/uv.h b/arch/ia64/include/asm/uv/uv.h
index 8f6cbaa742e..61b5bdfd980 100644
--- a/arch/ia64/include/asm/uv/uv.h
+++ b/arch/ia64/include/asm/uv/uv.h
@@ -1,6 +1,7 @@
 #ifndef _ASM_IA64_UV_UV_H
 #define _ASM_IA64_UV_UV_H
 
+#include <asm/system.h>
 #include <asm/sn/simulator.h>
 
 static inline int is_uv_system(void)
diff --git a/arch/ia64/include/asm/xen/interface.h b/arch/ia64/include/asm/xen/interface.h
index e88c5de2741..e951e740bdf 100644
--- a/arch/ia64/include/asm/xen/interface.h
+++ b/arch/ia64/include/asm/xen/interface.h
@@ -67,23 +67,17 @@
 #define set_xen_guest_handle(hnd, val)  do { (hnd).p = val; } while (0)
 
 #ifndef __ASSEMBLY__
-/* Explicitly size integers that represent pfns in the public interface
- * with Xen so that we could have one ABI that works for 32 and 64 bit
- * guests. */
-typedef unsigned long xen_pfn_t;
-typedef unsigned long xen_ulong_t;
 /* Guest handles for primitive C types. */
 __DEFINE_GUEST_HANDLE(uchar, unsigned char);
 __DEFINE_GUEST_HANDLE(uint, unsigned int);
 __DEFINE_GUEST_HANDLE(ulong, unsigned long);
-
+__DEFINE_GUEST_HANDLE(u64, unsigned long);
 DEFINE_GUEST_HANDLE(char);
 DEFINE_GUEST_HANDLE(int);
 DEFINE_GUEST_HANDLE(long);
 DEFINE_GUEST_HANDLE(void);
-DEFINE_GUEST_HANDLE(uint64_t);
-DEFINE_GUEST_HANDLE(uint32_t);
 
+typedef unsigned long xen_pfn_t;
 DEFINE_GUEST_HANDLE(xen_pfn_t);
 #define PRI_xen_pfn     "lx"
 #endif
@@ -269,8 +263,6 @@ typedef struct xen_callback xen_callback_t;
 
 #endif /* !__ASSEMBLY__ */
 
-#include <asm/pvclock-abi.h>
-
 /* Size of the shared_info area (this is not related to page size).  */
 #define XSI_SHIFT                       14
 #define XSI_SIZE                        (1 << XSI_SHIFT)
diff --git a/arch/ia64/include/uapi/asm/Kbuild b/arch/ia64/include/uapi/asm/Kbuild
deleted file mode 100644
index 1b3f5eb5fcd..00000000000
--- a/arch/ia64/include/uapi/asm/Kbuild
+++ /dev/null
@@ -1,50 +0,0 @@
-# UAPI Header export list
-include include/uapi/asm-generic/Kbuild.asm
-
-generic-y += kvm_para.h
-
-header-y += auxvec.h
-header-y += bitsperlong.h
-header-y += break.h
-header-y += byteorder.h
-header-y += cmpxchg.h
-header-y += errno.h
-header-y += fcntl.h
-header-y += fpu.h
-header-y += gcc_intrin.h
-header-y += ia64regs.h
-header-y += intel_intrin.h
-header-y += intrinsics.h
-header-y += ioctl.h
-header-y += ioctls.h
-header-y += ipcbuf.h
-header-y += kvm.h
-header-y += kvm_para.h
-header-y += mman.h
-header-y += msgbuf.h
-header-y += param.h
-header-y += perfmon.h
-header-y += perfmon_default_smpl.h
-header-y += poll.h
-header-y += posix_types.h
-header-y += ptrace.h
-header-y += ptrace_offsets.h
-header-y += resource.h
-header-y += rse.h
-header-y += sembuf.h
-header-y += setup.h
-header-y += shmbuf.h
-header-y += sigcontext.h
-header-y += siginfo.h
-header-y += signal.h
-header-y += socket.h
-header-y += sockios.h
-header-y += stat.h
-header-y += statfs.h
-header-y += swab.h
-header-y += termbits.h
-header-y += termios.h
-header-y += types.h
-header-y += ucontext.h
-header-y += unistd.h
-header-y += ustack.h
diff --git a/arch/ia64/include/uapi/asm/auxvec.h b/arch/ia64/include/uapi/asm/auxvec.h
deleted file mode 100644
index 58277fc650e..00000000000
--- a/arch/ia64/include/uapi/asm/auxvec.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef _ASM_IA64_AUXVEC_H
-#define _ASM_IA64_AUXVEC_H
-
-/*
- * Architecture-neutral AT_ values are in the range 0-17.  Leave some room for more of
- * them, start the architecture-specific ones at 32.
- */
-#define AT_SYSINFO      32
-#define AT_SYSINFO_EHDR 33
-
-#define AT_VECTOR_SIZE_ARCH 2 /* entries in ARCH_DLINFO */
-
-#endif /* _ASM_IA64_AUXVEC_H */
diff --git a/arch/ia64/include/uapi/asm/bitsperlong.h b/arch/ia64/include/uapi/asm/bitsperlong.h
deleted file mode 100644
index ec4db3c970b..00000000000
--- a/arch/ia64/include/uapi/asm/bitsperlong.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef __ASM_IA64_BITSPERLONG_H
-#define __ASM_IA64_BITSPERLONG_H
-
-#define __BITS_PER_LONG 64
-
-#include <asm-generic/bitsperlong.h>
-
-#endif /* __ASM_IA64_BITSPERLONG_H */
diff --git a/arch/ia64/include/uapi/asm/break.h b/arch/ia64/include/uapi/asm/break.h
deleted file mode 100644
index e90c40ec9ed..00000000000
--- a/arch/ia64/include/uapi/asm/break.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef _ASM_IA64_BREAK_H
-#define _ASM_IA64_BREAK_H
-
-/*
- * IA-64 Linux break numbers.
- *
- * Copyright (C) 1999 Hewlett-Packard Co
- * Copyright (C) 1999 David Mosberger-Tang <davidm@hpl.hp.com>
- */
-
-/*
- * OS-specific debug break numbers:
- */
-#define __IA64_BREAK_KDB                0x80100
-#define __IA64_BREAK_KPROBE             0x81000 /* .. 0x81fff */
-#define __IA64_BREAK_JPROBE             0x82000
-
-/*
- * OS-specific break numbers:
- */
-#define __IA64_BREAK_SYSCALL            0x100000
-
-/*
- * Xen specific break numbers:
- */
-#define __IA64_XEN_HYPERCALL            0x1000
-/* [__IA64_XEN_HYPERPRIVOP_START, __IA64_XEN_HYPERPRIVOP_MAX] is used
-   for xen hyperprivops */
-#define __IA64_XEN_HYPERPRIVOP_START    0x1
-#define __IA64_XEN_HYPERPRIVOP_MAX      0x1a
-
-#endif /* _ASM_IA64_BREAK_H */
diff --git a/arch/ia64/include/uapi/asm/byteorder.h b/arch/ia64/include/uapi/asm/byteorder.h
deleted file mode 100644
index a8dd7355815..00000000000
--- a/arch/ia64/include/uapi/asm/byteorder.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef _ASM_IA64_BYTEORDER_H
-#define _ASM_IA64_BYTEORDER_H
-
-#include <linux/byteorder/little_endian.h>
-
-#endif /* _ASM_IA64_BYTEORDER_H */
diff --git a/arch/ia64/include/uapi/asm/cmpxchg.h b/arch/ia64/include/uapi/asm/cmpxchg.h
deleted file mode 100644
index 4f37dbbb864..00000000000
--- a/arch/ia64/include/uapi/asm/cmpxchg.h
+++ /dev/null
@@ -1,147 +0,0 @@
-#ifndef _ASM_IA64_CMPXCHG_H
-#define _ASM_IA64_CMPXCHG_H
-
-/*
- * Compare/Exchange, forked from asm/intrinsics.h
- * which was:
- *
- *      Copyright (C) 2002-2003 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- */
-
-#ifndef __ASSEMBLY__
-
-#include <linux/types.h>
-/* include compiler specific intrinsics */
-#include <asm/ia64regs.h>
-#ifdef __INTEL_COMPILER
-# include <asm/intel_intrin.h>
-#else
-# include <asm/gcc_intrin.h>
-#endif
-
-/*
- * This function doesn't exist, so you'll get a linker error if
- * something tries to do an invalid xchg().
- */
-extern void ia64_xchg_called_with_bad_pointer(void);
-
-#define __xchg(x, ptr, size)                                            \
-({                                                                      \
-        unsigned long __xchg_result;                                    \
-                                                                        \
-        switch (size) {                                                 \
-        case 1:                                                         \
-                __xchg_result = ia64_xchg1((__u8 *)ptr, x);             \
-                break;                                                  \
-                                                                        \
-        case 2:                                                         \
-                __xchg_result = ia64_xchg2((__u16 *)ptr, x);            \
-                break;                                                  \
-                                                                        \
-        case 4:                                                         \
-                __xchg_result = ia64_xchg4((__u32 *)ptr, x);            \
-                break;                                                  \
-                                                                        \
-        case 8:                                                         \
-                __xchg_result = ia64_xchg8((__u64 *)ptr, x);            \
-                break;                                                  \
-        default:                                                        \
-                ia64_xchg_called_with_bad_pointer();                    \
-        }                                                               \
-        __xchg_result;                                                  \
-})
-
-#define xchg(ptr, x)                                                    \
-((__typeof__(*(ptr))) __xchg((unsigned long) (x), (ptr), sizeof(*(ptr))))
-
-/*
- * Atomic compare and exchange.  Compare OLD with MEM, if identical,
- * store NEW in MEM.  Return the initial value in MEM.  Success is
- * indicated by comparing RETURN with OLD.
- */
-
-#define __HAVE_ARCH_CMPXCHG 1
-
-/*
- * This function doesn't exist, so you'll get a linker error
- * if something tries to do an invalid cmpxchg().
- */
-extern long ia64_cmpxchg_called_with_bad_pointer(void);
-
-#define ia64_cmpxchg(sem, ptr, old, new, size)                          \
-({                                                                      \
-        __u64 _o_, _r_;                                                 \
-                                                                        \
-        switch (size) {                                                 \
-        case 1:                                                         \
-                _o_ = (__u8) (long) (old);                              \
-                break;                                                  \
-        case 2:                                                         \
-                _o_ = (__u16) (long) (old);                             \
-                break;                                                  \
-        case 4:                                                         \
-                _o_ = (__u32) (long) (old);                             \
-                break;                                                  \
-        case 8:                                                         \
-                _o_ = (__u64) (long) (old);                             \
-                break;                                                  \
-        default:                                                        \
-                break;                                                  \
-        }                                                               \
-        switch (size) {                                                 \
-        case 1:                                                         \
-                _r_ = ia64_cmpxchg1_##sem((__u8 *) ptr, new, _o_);      \
-                break;                                                  \
-                                                                        \
-        case 2:                                                         \
-                _r_ = ia64_cmpxchg2_##sem((__u16 *) ptr, new, _o_);     \
-                break;                                                  \
-                                                                        \
-        case 4:                                                         \
-                _r_ = ia64_cmpxchg4_##sem((__u32 *) ptr, new, _o_);     \
-                break;                                                  \
-                                                                        \
-        case 8:                                                         \
-                _r_ = ia64_cmpxchg8_##sem((__u64 *) ptr, new, _o_);     \
-                break;                                                  \
-                                                                        \
-        default:                                                        \
-                _r_ = ia64_cmpxchg_called_with_bad_pointer();           \
-                break;                                                  \
-        }                                                               \
-        (__typeof__(old)) _r_;                                          \
-})
-
-#define cmpxchg_acq(ptr, o, n)  \
-        ia64_cmpxchg(acq, (ptr), (o), (n), sizeof(*(ptr)))
-#define cmpxchg_rel(ptr, o, n)  \
-        ia64_cmpxchg(rel, (ptr), (o), (n), sizeof(*(ptr)))
-
-/* for compatibility with other platforms: */
-#define cmpxchg(ptr, o, n)      cmpxchg_acq((ptr), (o), (n))
-#define cmpxchg64(ptr, o, n)    cmpxchg_acq((ptr), (o), (n))
-
-#define cmpxchg_local           cmpxchg
-#define cmpxchg64_local         cmpxchg64
-
-#ifdef CONFIG_IA64_DEBUG_CMPXCHG
-# define CMPXCHG_BUGCHECK_DECL  int _cmpxchg_bugcheck_count = 128;
-# define CMPXCHG_BUGCHECK(v)                                            \
-do {                                                                    \
-        if (_cmpxchg_bugcheck_count-- <= 0) {                           \
-                void *ip;                                               \
-                extern int printk(const char *fmt, ...);                \
-                ip = (void *) ia64_getreg(_IA64_REG_IP);                \
-                printk("CMPXCHG_BUGCHECK: stuck at %p on word %p\n", ip, (v));\
-                break;                                                  \
-        }                                                               \
-} while (0)
-#else /* !CONFIG_IA64_DEBUG_CMPXCHG */
-# define CMPXCHG_BUGCHECK_DECL
-# define CMPXCHG_BUGCHECK(v)
-#endif /* !CONFIG_IA64_DEBUG_CMPXCHG */
-
-#endif /* !__ASSEMBLY__ */
-
-#endif /* _ASM_IA64_CMPXCHG_H */
diff --git a/arch/ia64/include/uapi/asm/errno.h b/arch/ia64/include/uapi/asm/errno.h
deleted file mode 100644
index 4c82b503d92..00000000000
--- a/arch/ia64/include/uapi/asm/errno.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <asm-generic/errno.h>
diff --git a/arch/ia64/include/uapi/asm/fcntl.h b/arch/ia64/include/uapi/asm/fcntl.h
deleted file mode 100644
index 1dd275dc8f6..00000000000
--- a/arch/ia64/include/uapi/asm/fcntl.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef _ASM_IA64_FCNTL_H
-#define _ASM_IA64_FCNTL_H
-/*
- * Modified 1998-2000
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co.
- */
-
-#define force_o_largefile()     \
-                (personality(current->personality) != PER_LINUX32)
-
-#include <asm-generic/fcntl.h>
-
-#endif /* _ASM_IA64_FCNTL_H */
diff --git a/arch/ia64/include/uapi/asm/fpu.h b/arch/ia64/include/uapi/asm/fpu.h
deleted file mode 100644
index b6395ad1500..00000000000
--- a/arch/ia64/include/uapi/asm/fpu.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef _ASM_IA64_FPU_H
-#define _ASM_IA64_FPU_H
-
-/*
- * Copyright (C) 1998, 1999, 2002, 2003 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- */
-
-#include <linux/types.h>
-
-/* floating point status register: */
-#define FPSR_TRAP_VD    (1 << 0)        /* invalid op trap disabled */
-#define FPSR_TRAP_DD    (1 << 1)        /* denormal trap disabled */
-#define FPSR_TRAP_ZD    (1 << 2)        /* zero-divide trap disabled */
-#define FPSR_TRAP_OD    (1 << 3)        /* overflow trap disabled */
-#define FPSR_TRAP_UD    (1 << 4)        /* underflow trap disabled */
-#define FPSR_TRAP_ID    (1 << 5)        /* inexact trap disabled */
-#define FPSR_S0(x)      ((x) <<  6)
-#define FPSR_S1(x)      ((x) << 19)
-#define FPSR_S2(x)      (__IA64_UL(x) << 32)
-#define FPSR_S3(x)      (__IA64_UL(x) << 45)
-
-/* floating-point status field controls: */
-#define FPSF_FTZ        (1 << 0)                /* flush-to-zero */
-#define FPSF_WRE        (1 << 1)                /* widest-range exponent */
-#define FPSF_PC(x)      (((x) & 0x3) << 2)      /* precision control */
-#define FPSF_RC(x)      (((x) & 0x3) << 4)      /* rounding control */
-#define FPSF_TD         (1 << 6)                /* trap disabled */
-
-/* floating-point status field flags: */
-#define FPSF_V          (1 <<  7)               /* invalid operation flag */
-#define FPSF_D          (1 <<  8)               /* denormal/unnormal operand flag */
-#define FPSF_Z          (1 <<  9)               /* zero divide (IEEE) flag */
-#define FPSF_O          (1 << 10)               /* overflow (IEEE) flag */
-#define FPSF_U          (1 << 11)               /* underflow (IEEE) flag */
-#define FPSF_I          (1 << 12)               /* inexact (IEEE) flag) */
-
-/* floating-point rounding control: */
-#define FPRC_NEAREST    0x0
-#define FPRC_NEGINF     0x1
-#define FPRC_POSINF     0x2
-#define FPRC_TRUNC      0x3
-
-#define FPSF_DEFAULT    (FPSF_PC (0x3) | FPSF_RC (FPRC_NEAREST))
-
-/* This default value is the same as HP-UX uses.  Don't change it
-   without a very good reason.  */
-#define FPSR_DEFAULT    (FPSR_TRAP_VD | FPSR_TRAP_DD | FPSR_TRAP_ZD     \
-                         | FPSR_TRAP_OD | FPSR_TRAP_UD | FPSR_TRAP_ID   \
-                         | FPSR_S0 (FPSF_DEFAULT)                       \
-                         | FPSR_S1 (FPSF_DEFAULT | FPSF_TD | FPSF_WRE)  \
-                         | FPSR_S2 (FPSF_DEFAULT | FPSF_TD)             \
-                         | FPSR_S3 (FPSF_DEFAULT | FPSF_TD))
-
-# ifndef __ASSEMBLY__
-
-struct ia64_fpreg {
-        union {
-                unsigned long bits[2];
-                long double __dummy;    /* force 16-byte alignment */
-        } u;
-};
-
-# endif /* __ASSEMBLY__ */
-
-#endif /* _ASM_IA64_FPU_H */
diff --git a/arch/ia64/include/uapi/asm/gcc_intrin.h b/arch/ia64/include/uapi/asm/gcc_intrin.h
deleted file mode 100644
index 61d0d011197..00000000000
--- a/arch/ia64/include/uapi/asm/gcc_intrin.h
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
- *
- * Copyright (C) 2002,2003 Jun Nakajima <jun.nakajima@intel.com>
- * Copyright (C) 2002,2003 Suresh Siddha <suresh.b.siddha@intel.com>
- */
-#ifndef _UAPI_ASM_IA64_GCC_INTRIN_H
-#define _UAPI_ASM_IA64_GCC_INTRIN_H
-
-#include <linux/types.h>
-#include <linux/compiler.h>
-
-/* define this macro to get some asm stmts included in 'c' files */
-#define ASM_SUPPORTED
-
-/* Optimization barrier */
-/* The "volatile" is due to gcc bugs */
-#define ia64_barrier()  asm volatile ("":::"memory")
-
-#define ia64_stop()     asm volatile (";;"::)
-
-#define ia64_invala_gr(regnum)  asm volatile ("invala.e r%0" :: "i"(regnum))
-
-#define ia64_invala_fr(regnum)  asm volatile ("invala.e f%0" :: "i"(regnum))
-
-#define ia64_flushrs() asm volatile ("flushrs;;":::"memory")
-
-#define ia64_loadrs() asm volatile ("loadrs;;":::"memory")
-
-extern void ia64_bad_param_for_setreg (void);
-extern void ia64_bad_param_for_getreg (void);
-
-
-#define ia64_native_setreg(regnum, val)                                         \
-({                                                                              \
-        switch (regnum) {                                                       \
-            case _IA64_REG_PSR_L:                                               \
-                    asm volatile ("mov psr.l=%0" :: "r"(val) : "memory");       \
-                    break;                                                      \
-            case _IA64_REG_AR_KR0 ... _IA64_REG_AR_EC:                          \
-                    asm volatile ("mov ar%0=%1" ::                              \
-                                          "i" (regnum - _IA64_REG_AR_KR0),      \
-                                          "r"(val): "memory");                  \
-                    break;                                                      \
-            case _IA64_REG_CR_DCR ... _IA64_REG_CR_LRR1:                        \
-                    asm volatile ("mov cr%0=%1" ::                              \
-                                          "i" (regnum - _IA64_REG_CR_DCR),      \
-                                          "r"(val): "memory" );                 \
-                    break;                                                      \
-            case _IA64_REG_SP:                                                  \
-                    asm volatile ("mov r12=%0" ::                               \
-                                          "r"(val): "memory");                  \
-                    break;                                                      \
-            case _IA64_REG_GP:                                                  \
-                    asm volatile ("mov gp=%0" :: "r"(val) : "memory");          \
-                break;                                                          \
-            default:                                                            \
-                    ia64_bad_param_for_setreg();                                \
-                    break;                                                      \
-        }                                                                       \
-})
-
-#define ia64_native_getreg(regnum)                                              \
-({                                                                              \
-        __u64 ia64_intri_res;                                                   \
-                                                                                \
-        switch (regnum) {                                                       \
-        case _IA64_REG_GP:                                                      \
-                asm volatile ("mov %0=gp" : "=r"(ia64_intri_res));              \
-                break;                                                          \
-        case _IA64_REG_IP:                                                      \
-                asm volatile ("mov %0=ip" : "=r"(ia64_intri_res));              \
-                break;                                                          \
-        case _IA64_REG_PSR:                                                     \
-                asm volatile ("mov %0=psr" : "=r"(ia64_intri_res));             \
-                break;                                                          \
-        case _IA64_REG_TP:      /* for current() */                             \
-                ia64_intri_res = ia64_r13;                                      \
-                break;                                                          \
-        case _IA64_REG_AR_KR0 ... _IA64_REG_AR_EC:                              \
-                asm volatile ("mov %0=ar%1" : "=r" (ia64_intri_res)             \
-                                      : "i"(regnum - _IA64_REG_AR_KR0));        \
-                break;                                                          \
-        case _IA64_REG_CR_DCR ... _IA64_REG_CR_LRR1:                            \
-                asm volatile ("mov %0=cr%1" : "=r" (ia64_intri_res)             \
-                                      : "i" (regnum - _IA64_REG_CR_DCR));       \
-                break;                                                          \
-        case _IA64_REG_SP:                                                      \
-                asm volatile ("mov %0=sp" : "=r" (ia64_intri_res));             \
-                break;                                                          \
-        default:                                                                \
-                ia64_bad_param_for_getreg();                                    \
-                break;                                                          \
-        }                                                                       \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_hint_pause 0
-
-#define ia64_hint(mode)                                         \
-({                                                              \
-        switch (mode) {                                         \
-        case ia64_hint_pause:                                   \
-                asm volatile ("hint @pause" ::: "memory");      \
-                break;                                          \
-        }                                                       \
-})
-
-
-/* Integer values for mux1 instruction */
-#define ia64_mux1_brcst 0
-#define ia64_mux1_mix   8
-#define ia64_mux1_shuf  9
-#define ia64_mux1_alt  10
-#define ia64_mux1_rev  11
-
-#define ia64_mux1(x, mode)                                                      \
-({                                                                              \
-        __u64 ia64_intri_res;                                                   \
-                                                                                \
-        switch (mode) {                                                         \
-        case ia64_mux1_brcst:                                                   \
-                asm ("mux1 %0=%1,@brcst" : "=r" (ia64_intri_res) : "r" (x));    \
-                break;                                                          \
-        case ia64_mux1_mix:                                                     \
-                asm ("mux1 %0=%1,@mix" : "=r" (ia64_intri_res) : "r" (x));      \
-                break;                                                          \
-        case ia64_mux1_shuf:                                                    \
-                asm ("mux1 %0=%1,@shuf" : "=r" (ia64_intri_res) : "r" (x));     \
-                break;                                                          \
-        case ia64_mux1_alt:                                                     \
-                asm ("mux1 %0=%1,@alt" : "=r" (ia64_intri_res) : "r" (x));      \
-                break;                                                          \
-        case ia64_mux1_rev:                                                     \
-                asm ("mux1 %0=%1,@rev" : "=r" (ia64_intri_res) : "r" (x));      \
-                break;                                                          \
-        }                                                                       \
-        ia64_intri_res;                                                         \
-})
-
-#if __GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-# define ia64_popcnt(x)         __builtin_popcountl(x)
-#else
-# define ia64_popcnt(x)                                         \
-  ({                                                            \
-        __u64 ia64_intri_res;                                   \
-        asm ("popcnt %0=%1" : "=r" (ia64_intri_res) : "r" (x)); \
-                                                                \
-        ia64_intri_res;                                         \
-  })
-#endif
-
-#define ia64_getf_exp(x)                                        \
-({                                                              \
-        long ia64_intri_res;                                    \
-                                                                \
-        asm ("getf.exp %0=%1" : "=r"(ia64_intri_res) : "f"(x)); \
-                                                                \
-        ia64_intri_res;                                         \
-})
-
-#define ia64_shrp(a, b, count)                                                          \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm ("shrp %0=%1,%2,%3" : "=r"(ia64_intri_res) : "r"(a), "r"(b), "i"(count));   \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_ldfs(regnum, x)                                    \
-({                                                              \
-        register double __f__ asm ("f"#regnum);                 \
-        asm volatile ("ldfs %0=[%1]" :"=f"(__f__): "r"(x));     \
-})
-
-#define ia64_ldfd(regnum, x)                                    \
-({                                                              \
-        register double __f__ asm ("f"#regnum);                 \
-        asm volatile ("ldfd %0=[%1]" :"=f"(__f__): "r"(x));     \
-})
-
-#define ia64_ldfe(regnum, x)                                    \
-({                                                              \
-        register double __f__ asm ("f"#regnum);                 \
-        asm volatile ("ldfe %0=[%1]" :"=f"(__f__): "r"(x));     \
-})
-
-#define ia64_ldf8(regnum, x)                                    \
-({                                                              \
-        register double __f__ asm ("f"#regnum);                 \
-        asm volatile ("ldf8 %0=[%1]" :"=f"(__f__): "r"(x));     \
-})
-
-#define ia64_ldf_fill(regnum, x)                                \
-({                                                              \
-        register double __f__ asm ("f"#regnum);                 \
-        asm volatile ("ldf.fill %0=[%1]" :"=f"(__f__): "r"(x)); \
-})
-
-#define ia64_st4_rel_nta(m, val)                                        \
-({                                                                      \
-        asm volatile ("st4.rel.nta [%0] = %1\n\t" :: "r"(m), "r"(val)); \
-})
-
-#define ia64_stfs(x, regnum)                                            \
-({                                                                      \
-        register double __f__ asm ("f"#regnum);                         \
-        asm volatile ("stfs [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
-})
-
-#define ia64_stfd(x, regnum)                                            \
-({                                                                      \
-        register double __f__ asm ("f"#regnum);                         \
-        asm volatile ("stfd [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
-})
-
-#define ia64_stfe(x, regnum)                                            \
-({                                                                      \
-        register double __f__ asm ("f"#regnum);                         \
-        asm volatile ("stfe [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
-})
-
-#define ia64_stf8(x, regnum)                                            \
-({                                                                      \
-        register double __f__ asm ("f"#regnum);                         \
-        asm volatile ("stf8 [%0]=%1" :: "r"(x), "f"(__f__) : "memory"); \
-})
-
-#define ia64_stf_spill(x, regnum)                                               \
-({                                                                              \
-        register double __f__ asm ("f"#regnum);                                 \
-        asm volatile ("stf.spill [%0]=%1" :: "r"(x), "f"(__f__) : "memory");    \
-})
-
-#define ia64_fetchadd4_acq(p, inc)                                              \
-({                                                                              \
-                                                                                \
-        __u64 ia64_intri_res;                                                   \
-        asm volatile ("fetchadd4.acq %0=[%1],%2"                                \
-                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
-                                : "memory");                                    \
-                                                                                \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_fetchadd4_rel(p, inc)                                              \
-({                                                                              \
-        __u64 ia64_intri_res;                                                   \
-        asm volatile ("fetchadd4.rel %0=[%1],%2"                                \
-                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
-                                : "memory");                                    \
-                                                                                \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_fetchadd8_acq(p, inc)                                              \
-({                                                                              \
-                                                                                \
-        __u64 ia64_intri_res;                                                   \
-        asm volatile ("fetchadd8.acq %0=[%1],%2"                                \
-                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
-                                : "memory");                                    \
-                                                                                \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_fetchadd8_rel(p, inc)                                              \
-({                                                                              \
-        __u64 ia64_intri_res;                                                   \
-        asm volatile ("fetchadd8.rel %0=[%1],%2"                                \
-                                : "=r"(ia64_intri_res) : "r"(p), "i" (inc)      \
-                                : "memory");                                    \
-                                                                                \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_xchg1(ptr,x)                                                       \
-({                                                                              \
-        __u64 ia64_intri_res;                                                   \
-        asm volatile ("xchg1 %0=[%1],%2"                                        \
-                      : "=r" (ia64_intri_res) : "r" (ptr), "r" (x) : "memory"); \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_xchg2(ptr,x)                                               \
-({                                                                      \
-        __u64 ia64_intri_res;                                           \
-        asm volatile ("xchg2 %0=[%1],%2" : "=r" (ia64_intri_res)        \
-                      : "r" (ptr), "r" (x) : "memory");                 \
-        ia64_intri_res;                                                 \
-})
-
-#define ia64_xchg4(ptr,x)                                               \
-({                                                                      \
-        __u64 ia64_intri_res;                                           \
-        asm volatile ("xchg4 %0=[%1],%2" : "=r" (ia64_intri_res)        \
-                      : "r" (ptr), "r" (x) : "memory");                 \
-        ia64_intri_res;                                                 \
-})
-
-#define ia64_xchg8(ptr,x)                                               \
-({                                                                      \
-        __u64 ia64_intri_res;                                           \
-        asm volatile ("xchg8 %0=[%1],%2" : "=r" (ia64_intri_res)        \
-                      : "r" (ptr), "r" (x) : "memory");                 \
-        ia64_intri_res;                                                 \
-})
-
-#define ia64_cmpxchg1_acq(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-        asm volatile ("cmpxchg1.acq %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg1_rel(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-        asm volatile ("cmpxchg1.rel %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg2_acq(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-        asm volatile ("cmpxchg2.acq %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg2_rel(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-                                                                                        \
-        asm volatile ("cmpxchg2.rel %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg4_acq(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-        asm volatile ("cmpxchg4.acq %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg4_rel(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-        asm volatile ("cmpxchg4.rel %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg8_acq(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-        asm volatile ("cmpxchg8.acq %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_cmpxchg8_rel(ptr, new, old)                                                \
-({                                                                                      \
-        __u64 ia64_intri_res;                                                           \
-        asm volatile ("mov ar.ccv=%0;;" :: "rO"(old));                                  \
-                                                                                        \
-        asm volatile ("cmpxchg8.rel %0=[%1],%2,ar.ccv":                                 \
-                              "=r"(ia64_intri_res) : "r"(ptr), "r"(new) : "memory");    \
-        ia64_intri_res;                                                                 \
-})
-
-#define ia64_mf()       asm volatile ("mf" ::: "memory")
-#define ia64_mfa()      asm volatile ("mf.a" ::: "memory")
-
-#define ia64_invala() asm volatile ("invala" ::: "memory")
-
-#define ia64_native_thash(addr)                                                 \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("thash %0=%1" : "=r"(ia64_intri_res) : "r" (addr));       \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_srlz_i()   asm volatile (";; srlz.i ;;" ::: "memory")
-#define ia64_srlz_d()   asm volatile (";; srlz.d" ::: "memory");
-
-#ifdef HAVE_SERIALIZE_DIRECTIVE
-# define ia64_dv_serialize_data()               asm volatile (".serialize.data");
-# define ia64_dv_serialize_instruction()        asm volatile (".serialize.instruction");
-#else
-# define ia64_dv_serialize_data()
-# define ia64_dv_serialize_instruction()
-#endif
-
-#define ia64_nop(x)     asm volatile ("nop %0"::"i"(x));
-
-#define ia64_itci(addr) asm volatile ("itc.i %0;;" :: "r"(addr) : "memory")
-
-#define ia64_itcd(addr) asm volatile ("itc.d %0;;" :: "r"(addr) : "memory")
-
-
-#define ia64_itri(trnum, addr) asm volatile ("itr.i itr[%0]=%1"                         \
-                                             :: "r"(trnum), "r"(addr) : "memory")
-
-#define ia64_itrd(trnum, addr) asm volatile ("itr.d dtr[%0]=%1"                         \
-                                             :: "r"(trnum), "r"(addr) : "memory")
-
-#define ia64_tpa(addr)                                                          \
-({                                                                              \
-        unsigned long ia64_pa;                                                  \
-        asm volatile ("tpa %0 = %1" : "=r"(ia64_pa) : "r"(addr) : "memory");    \
-        ia64_pa;                                                                \
-})
-
-#define __ia64_set_dbr(index, val)                                              \
-        asm volatile ("mov dbr[%0]=%1" :: "r"(index), "r"(val) : "memory")
-
-#define ia64_set_ibr(index, val)                                                \
-        asm volatile ("mov ibr[%0]=%1" :: "r"(index), "r"(val) : "memory")
-
-#define ia64_set_pkr(index, val)                                                \
-        asm volatile ("mov pkr[%0]=%1" :: "r"(index), "r"(val) : "memory")
-
-#define ia64_set_pmc(index, val)                                                \
-        asm volatile ("mov pmc[%0]=%1" :: "r"(index), "r"(val) : "memory")
-
-#define ia64_set_pmd(index, val)                                                \
-        asm volatile ("mov pmd[%0]=%1" :: "r"(index), "r"(val) : "memory")
-
-#define ia64_native_set_rr(index, val)                                                  \
-        asm volatile ("mov rr[%0]=%1" :: "r"(index), "r"(val) : "memory");
-
-#define ia64_native_get_cpuid(index)                                                    \
-({                                                                                      \
-        unsigned long ia64_intri_res;                                                   \
-        asm volatile ("mov %0=cpuid[%r1]" : "=r"(ia64_intri_res) : "rO"(index));        \
-        ia64_intri_res;                                                                 \
-})
-
-#define __ia64_get_dbr(index)                                                   \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("mov %0=dbr[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_get_ibr(index)                                                     \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("mov %0=ibr[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_get_pkr(index)                                                     \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("mov %0=pkr[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_get_pmc(index)                                                     \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("mov %0=pmc[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
-        ia64_intri_res;                                                         \
-})
-
-
-#define ia64_native_get_pmd(index)                                              \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("mov %0=pmd[%1]" : "=r"(ia64_intri_res) : "r"(index));    \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_native_get_rr(index)                                               \
-({                                                                              \
-        unsigned long ia64_intri_res;                                           \
-        asm volatile ("mov %0=rr[%1]" : "=r"(ia64_intri_res) : "r" (index));    \
-        ia64_intri_res;                                                         \
-})
-
-#define ia64_native_fc(addr)    asm volatile ("fc %0" :: "r"(addr) : "memory")
-
-
-#define ia64_sync_i()   asm volatile (";; sync.i" ::: "memory")
-
-#define ia64_native_ssm(mask)   asm volatile ("ssm %0":: "i"((mask)) : "memory")
-#define ia64_native_rsm(mask)   asm volatile ("rsm %0":: "i"((mask)) : "memory")
-#define ia64_sum(mask)  asm volatile ("sum %0":: "i"((mask)) : "memory")
-#define ia64_rum(mask)  asm volatile ("rum %0":: "i"((mask)) : "memory")
-
-#define ia64_ptce(addr) asm volatile ("ptc.e %0" :: "r"(addr))
-
-#define ia64_native_ptcga(addr, size)                                           \
-do {                                                                            \
-        asm volatile ("ptc.ga %0,%1" :: "r"(addr), "r"(size) : "memory");       \
-        ia64_dv_serialize_data();                                               \
-} while (0)
-
-#define ia64_ptcl(addr, size)                                                   \
-do {                                                                            \
-        asm volatile ("ptc.l %0,%1" :: "r"(addr), "r"(size) : "memory");        \
-        ia64_dv_serialize_data();                                               \
-} while (0)
-
-#define ia64_ptri(addr, size)                                           \
-        asm volatile ("ptr.i %0,%1" :: "r"(addr), "r"(size) : "memory")
-
-#define ia64_ptrd(addr, size)                                           \
-        asm volatile ("ptr.d %0,%1" :: "r"(addr), "r"(size) : "memory")
-
-#define ia64_ttag(addr)                                                 \
-({                                                                        \
-        __u64 ia64_intri_res;                                              \
-        asm volatile ("ttag %0=%1" : "=r"(ia64_intri_res) : "r" (addr));   \
-        ia64_intri_res;                                                  \
-})
-
-
-/* Values for lfhint in ia64_lfetch and ia64_lfetch_fault */
-
-#define ia64_lfhint_none   0
-#define ia64_lfhint_nt1    1
-#define ia64_lfhint_nt2    2
-#define ia64_lfhint_nta    3
-
-#define ia64_lfetch(lfhint, y)                                  \
-({                                                              \
-        switch (lfhint) {                                       \
-        case ia64_lfhint_none:                                  \
-                asm volatile ("lfetch [%0]" : : "r"(y));        \
-                break;                                          \
-        case ia64_lfhint_nt1:                                   \
-                asm volatile ("lfetch.nt1 [%0]" : : "r"(y));    \
-                break;                                          \
-        case ia64_lfhint_nt2:                                   \
-                asm volatile ("lfetch.nt2 [%0]" : : "r"(y));    \
-                break;                                          \
-        case ia64_lfhint_nta:                                   \
-                asm volatile ("lfetch.nta [%0]" : : "r"(y));    \
-                break;                                          \
-        }                                                       \
-})
-
-#define ia64_lfetch_excl(lfhint, y)                                     \
-({                                                                      \
-        switch (lfhint) {                                               \
-        case ia64_lfhint_none:                                          \
-                asm volatile ("lfetch.excl [%0]" :: "r"(y));            \
-                break;                                                  \
-        case ia64_lfhint_nt1:                                           \
-                asm volatile ("lfetch.excl.nt1 [%0]" :: "r"(y));        \
-                break;                                                  \
-        case ia64_lfhint_nt2:                                           \
-                asm volatile ("lfetch.excl.nt2 [%0]" :: "r"(y));        \
-                break;                                                  \
-        case ia64_lfhint_nta:                                           \
-                asm volatile ("lfetch.excl.nta [%0]" :: "r"(y));        \
-                break;                                                  \
-        }                                                               \
-})
-
-#define ia64_lfetch_fault(lfhint, y)                                    \
-({                                                                      \
-        switch (lfhint) {                                               \
-        case ia64_lfhint_none:                                          \
-                asm volatile ("lfetch.fault [%0]" : : "r"(y));          \
-                break;                                                  \
-        case ia64_lfhint_nt1:                                           \
-                asm volatile ("lfetch.fault.nt1 [%0]" : : "r"(y));      \
-                break;                                                  \
-        case ia64_lfhint_nt2:                                           \
-                asm volatile ("lfetch.fault.nt2 [%0]" : : "r"(y));      \
-                break;                                                  \
-        case ia64_lfhint_nta:                                           \
-                asm volatile ("lfetch.fault.nta [%0]" : : "r"(y));      \
-                break;                                                  \
-        }                                                               \
-})
-
-#define ia64_lfetch_fault_excl(lfhint, y)                               \
-({                                                                      \
-        switch (lfhint) {                                               \
-        case ia64_lfhint_none:                                          \
-                asm volatile ("lfetch.fault.excl [%0]" :: "r"(y));      \
-                break;                                                  \
-        case ia64_lfhint_nt1:                                           \
-                asm volatile ("lfetch.fault.excl.nt1 [%0]" :: "r"(y));  \
-                break;                                                  \
-        case ia64_lfhint_nt2:                                           \
-                asm volatile ("lfetch.fault.excl.nt2 [%0]" :: "r"(y));  \
-                break;                                                  \
-        case ia64_lfhint_nta:                                           \
-                asm volatile ("lfetch.fault.excl.nta [%0]" :: "r"(y));  \
-                break;                                                  \
-        }                                                               \
-})
-
-#define ia64_native_intrin_local_irq_restore(x)                 \
-do {                                                            \
-        asm volatile (";;   cmp.ne p6,p7=%0,r0;;"               \
-                      "(p6) ssm psr.i;"                         \
-                      "(p7) rsm psr.i;;"                        \
-                      "(p6) srlz.d"                             \
-                      :: "r"((x)) : "p6", "p7", "memory");      \
-} while (0)
-
-#endif /* _UAPI_ASM_IA64_GCC_INTRIN_H */
diff --git a/arch/ia64/include/uapi/asm/ia64regs.h b/arch/ia64/include/uapi/asm/ia64regs.h
deleted file mode 100644
index 1757f1c11ad..00000000000
--- a/arch/ia64/include/uapi/asm/ia64regs.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2002,2003 Intel Corp.
- *      Jun Nakajima <jun.nakajima@intel.com>
- *      Suresh Siddha <suresh.b.siddha@intel.com>
- */
-
-#ifndef _ASM_IA64_IA64REGS_H
-#define _ASM_IA64_IA64REGS_H
-
-/*
- * Register Names for getreg() and setreg().
- *
- * The "magic" numbers happen to match the values used by the Intel compiler's
- * getreg()/setreg() intrinsics.
- */
-
-/* Special Registers */
-
-#define _IA64_REG_IP            1016    /* getreg only */
-#define _IA64_REG_PSR           1019
-#define _IA64_REG_PSR_L         1019
-
-/* General Integer Registers */
-
-#define _IA64_REG_GP            1025    /* R1 */
-#define _IA64_REG_R8            1032    /* R8 */
-#define _IA64_REG_R9            1033    /* R9 */
-#define _IA64_REG_SP            1036    /* R12 */
-#define _IA64_REG_TP            1037    /* R13 */
-
-/* Application Registers */
-
-#define _IA64_REG_AR_KR0        3072
-#define _IA64_REG_AR_KR1        3073
-#define _IA64_REG_AR_KR2        3074
-#define _IA64_REG_AR_KR3        3075
-#define _IA64_REG_AR_KR4        3076
-#define _IA64_REG_AR_KR5        3077
-#define _IA64_REG_AR_KR6        3078
-#define _IA64_REG_AR_KR7        3079
-#define _IA64_REG_AR_RSC        3088
-#define _IA64_REG_AR_BSP        3089
-#define _IA64_REG_AR_BSPSTORE   3090
-#define _IA64_REG_AR_RNAT       3091
-#define _IA64_REG_AR_FCR        3093
-#define _IA64_REG_AR_EFLAG      3096
-#define _IA64_REG_AR_CSD        3097
-#define _IA64_REG_AR_SSD        3098
-#define _IA64_REG_AR_CFLAG      3099
-#define _IA64_REG_AR_FSR        3100
-#define _IA64_REG_AR_FIR        3101
-#define _IA64_REG_AR_FDR        3102
-#define _IA64_REG_AR_CCV        3104
-#define _IA64_REG_AR_UNAT       3108
-#define _IA64_REG_AR_FPSR       3112
-#define _IA64_REG_AR_ITC        3116
-#define _IA64_REG_AR_PFS        3136
-#define _IA64_REG_AR_LC         3137
-#define _IA64_REG_AR_EC         3138
-
-/* Control Registers */
-
-#define _IA64_REG_CR_DCR        4096
-#define _IA64_REG_CR_ITM        4097
-#define _IA64_REG_CR_IVA        4098
-#define _IA64_REG_CR_PTA        4104
-#define _IA64_REG_CR_IPSR       4112
-#define _IA64_REG_CR_ISR        4113
-#define _IA64_REG_CR_IIP        4115
-#define _IA64_REG_CR_IFA        4116
-#define _IA64_REG_CR_ITIR       4117
-#define _IA64_REG_CR_IIPA       4118
-#define _IA64_REG_CR_IFS        4119
-#define _IA64_REG_CR_IIM        4120
-#define _IA64_REG_CR_IHA        4121
-#define _IA64_REG_CR_LID        4160
-#define _IA64_REG_CR_IVR        4161    /* getreg only */
-#define _IA64_REG_CR_TPR        4162
-#define _IA64_REG_CR_EOI        4163
-#define _IA64_REG_CR_IRR0       4164    /* getreg only */
-#define _IA64_REG_CR_IRR1       4165    /* getreg only */
-#define _IA64_REG_CR_IRR2       4166    /* getreg only */
-#define _IA64_REG_CR_IRR3       4167    /* getreg only */
-#define _IA64_REG_CR_ITV        4168
-#define _IA64_REG_CR_PMV        4169
-#define _IA64_REG_CR_CMCV       4170
-#define _IA64_REG_CR_LRR0       4176
-#define _IA64_REG_CR_LRR1       4177
-
-/* Indirect Registers for getindreg() and setindreg() */
-
-#define _IA64_REG_INDR_CPUID    9000    /* getindreg only */
-#define _IA64_REG_INDR_DBR      9001
-#define _IA64_REG_INDR_IBR      9002
-#define _IA64_REG_INDR_PKR      9003
-#define _IA64_REG_INDR_PMC      9004
-#define _IA64_REG_INDR_PMD      9005
-#define _IA64_REG_INDR_RR       9006
-
-#endif /* _ASM_IA64_IA64REGS_H */
diff --git a/arch/ia64/include/uapi/asm/intel_intrin.h b/arch/ia64/include/uapi/asm/intel_intrin.h
deleted file mode 100644
index 53cec577558..00000000000
--- a/arch/ia64/include/uapi/asm/intel_intrin.h
+++ /dev/null
@@ -1,161 +0,0 @@
-#ifndef _ASM_IA64_INTEL_INTRIN_H
-#define _ASM_IA64_INTEL_INTRIN_H
-/*
- * Intel Compiler Intrinsics
- *
- * Copyright (C) 2002,2003 Jun Nakajima <jun.nakajima@intel.com>
- * Copyright (C) 2002,2003 Suresh Siddha <suresh.b.siddha@intel.com>
- * Copyright (C) 2005,2006 Hongjiu Lu <hongjiu.lu@intel.com>
- *
- */
-#include <ia64intrin.h>
-
-#define ia64_barrier()          __memory_barrier()
-
-#define ia64_stop()     /* Nothing: As of now stop bit is generated for each
-                         * intrinsic
-                         */
-
-#define ia64_native_getreg      __getReg
-#define ia64_native_setreg      __setReg
-
-#define ia64_hint               __hint
-#define ia64_hint_pause         __hint_pause
-
-#define ia64_mux1_brcst         _m64_mux1_brcst
-#define ia64_mux1_mix           _m64_mux1_mix
-#define ia64_mux1_shuf          _m64_mux1_shuf
-#define ia64_mux1_alt           _m64_mux1_alt
-#define ia64_mux1_rev           _m64_mux1_rev
-
-#define ia64_mux1(x,v)          _m_to_int64(_m64_mux1(_m_from_int64(x), (v)))
-#define ia64_popcnt             _m64_popcnt
-#define ia64_getf_exp           __getf_exp
-#define ia64_shrp               _m64_shrp
-
-#define ia64_tpa                __tpa
-#define ia64_invala             __invala
-#define ia64_invala_gr          __invala_gr
-#define ia64_invala_fr          __invala_fr
-#define ia64_nop                __nop
-#define ia64_sum                __sum
-#define ia64_native_ssm         __ssm
-#define ia64_rum                __rum
-#define ia64_native_rsm         __rsm
-#define ia64_native_fc          __fc
-
-#define ia64_ldfs               __ldfs
-#define ia64_ldfd               __ldfd
-#define ia64_ldfe               __ldfe
-#define ia64_ldf8               __ldf8
-#define ia64_ldf_fill           __ldf_fill
-
-#define ia64_stfs               __stfs
-#define ia64_stfd               __stfd
-#define ia64_stfe               __stfe
-#define ia64_stf8               __stf8
-#define ia64_stf_spill          __stf_spill
-
-#define ia64_mf                 __mf
-#define ia64_mfa                __mfa
-
-#define ia64_fetchadd4_acq      __fetchadd4_acq
-#define ia64_fetchadd4_rel      __fetchadd4_rel
-#define ia64_fetchadd8_acq      __fetchadd8_acq
-#define ia64_fetchadd8_rel      __fetchadd8_rel
-
-#define ia64_xchg1              _InterlockedExchange8
-#define ia64_xchg2              _InterlockedExchange16
-#define ia64_xchg4              _InterlockedExchange
-#define ia64_xchg8              _InterlockedExchange64
-
-#define ia64_cmpxchg1_rel       _InterlockedCompareExchange8_rel
-#define ia64_cmpxchg1_acq       _InterlockedCompareExchange8_acq
-#define ia64_cmpxchg2_rel       _InterlockedCompareExchange16_rel
-#define ia64_cmpxchg2_acq       _InterlockedCompareExchange16_acq
-#define ia64_cmpxchg4_rel       _InterlockedCompareExchange_rel
-#define ia64_cmpxchg4_acq       _InterlockedCompareExchange_acq
-#define ia64_cmpxchg8_rel       _InterlockedCompareExchange64_rel
-#define ia64_cmpxchg8_acq       _InterlockedCompareExchange64_acq
-
-#define __ia64_set_dbr(index, val)      \
-                __setIndReg(_IA64_REG_INDR_DBR, index, val)
-#define ia64_set_ibr(index, val)        \
-                __setIndReg(_IA64_REG_INDR_IBR, index, val)
-#define ia64_set_pkr(index, val)        \
-                __setIndReg(_IA64_REG_INDR_PKR, index, val)
-#define ia64_set_pmc(index, val)        \
-                __setIndReg(_IA64_REG_INDR_PMC, index, val)
-#define ia64_set_pmd(index, val)        \
-                __setIndReg(_IA64_REG_INDR_PMD, index, val)
-#define ia64_native_set_rr(index, val)  \
-                __setIndReg(_IA64_REG_INDR_RR, index, val)
-
-#define ia64_native_get_cpuid(index)    \
-                __getIndReg(_IA64_REG_INDR_CPUID, index)
-#define __ia64_get_dbr(index)           __getIndReg(_IA64_REG_INDR_DBR, index)
-#define ia64_get_ibr(index)             __getIndReg(_IA64_REG_INDR_IBR, index)
-#define ia64_get_pkr(index)             __getIndReg(_IA64_REG_INDR_PKR, index)
-#define ia64_get_pmc(index)             __getIndReg(_IA64_REG_INDR_PMC, index)
-#define ia64_native_get_pmd(index)      __getIndReg(_IA64_REG_INDR_PMD, index)
-#define ia64_native_get_rr(index)       __getIndReg(_IA64_REG_INDR_RR, index)
-
-#define ia64_srlz_d             __dsrlz
-#define ia64_srlz_i             __isrlz
-
-#define ia64_dv_serialize_data()
-#define ia64_dv_serialize_instruction()
-
-#define ia64_st1_rel            __st1_rel
-#define ia64_st2_rel            __st2_rel
-#define ia64_st4_rel            __st4_rel
-#define ia64_st8_rel            __st8_rel
-
-/* FIXME: need st4.rel.nta intrinsic */
-#define ia64_st4_rel_nta        __st4_rel
-
-#define ia64_ld1_acq            __ld1_acq
-#define ia64_ld2_acq            __ld2_acq
-#define ia64_ld4_acq            __ld4_acq
-#define ia64_ld8_acq            __ld8_acq
-
-#define ia64_sync_i             __synci
-#define ia64_native_thash       __thash
-#define ia64_native_ttag        __ttag
-#define ia64_itcd               __itcd
-#define ia64_itci               __itci
-#define ia64_itrd               __itrd
-#define ia64_itri               __itri
-#define ia64_ptce               __ptce
-#define ia64_ptcl               __ptcl
-#define ia64_native_ptcg        __ptcg
-#define ia64_native_ptcga       __ptcga
-#define ia64_ptri               __ptri
-#define ia64_ptrd               __ptrd
-#define ia64_dep_mi             _m64_dep_mi
-
-/* Values for lfhint in __lfetch and __lfetch_fault */
-
-#define ia64_lfhint_none        __lfhint_none
-#define ia64_lfhint_nt1         __lfhint_nt1
-#define ia64_lfhint_nt2         __lfhint_nt2
-#define ia64_lfhint_nta         __lfhint_nta
-
-#define ia64_lfetch             __lfetch
-#define ia64_lfetch_excl        __lfetch_excl
-#define ia64_lfetch_fault       __lfetch_fault
-#define ia64_lfetch_fault_excl  __lfetch_fault_excl
-
-#define ia64_native_intrin_local_irq_restore(x)         \
-do {                                                    \
-        if ((x) != 0) {                                 \
-                ia64_native_ssm(IA64_PSR_I);            \
-                ia64_srlz_d();                          \
-        } else {                                        \
-                ia64_native_rsm(IA64_PSR_I);            \
-        }                                               \
-} while (0)
-
-#define __builtin_trap()        __break(0);
-
-#endif /* _ASM_IA64_INTEL_INTRIN_H */
diff --git a/arch/ia64/include/uapi/asm/intrinsics.h b/arch/ia64/include/uapi/asm/intrinsics.h
deleted file mode 100644
index 5829978ff46..00000000000
--- a/arch/ia64/include/uapi/asm/intrinsics.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Compiler-dependent intrinsics.
- *
- * Copyright (C) 2002-2003 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- */
-#ifndef _UAPI_ASM_IA64_INTRINSICS_H
-#define _UAPI_ASM_IA64_INTRINSICS_H
-
-
-#ifndef __ASSEMBLY__
-
-#include <linux/types.h>
-/* include compiler specific intrinsics */
-#include <asm/ia64regs.h>
-#ifdef __INTEL_COMPILER
-# include <asm/intel_intrin.h>
-#else
-# include <asm/gcc_intrin.h>
-#endif
-#include <asm/cmpxchg.h>
-
-#define ia64_native_get_psr_i() (ia64_native_getreg(_IA64_REG_PSR) & IA64_PSR_I)
-
-#define ia64_native_set_rr0_to_rr4(val0, val1, val2, val3, val4)        \
-do {                                                                    \
-        ia64_native_set_rr(0x0000000000000000UL, (val0));               \
-        ia64_native_set_rr(0x2000000000000000UL, (val1));               \
-        ia64_native_set_rr(0x4000000000000000UL, (val2));               \
-        ia64_native_set_rr(0x6000000000000000UL, (val3));               \
-        ia64_native_set_rr(0x8000000000000000UL, (val4));               \
-} while (0)
-
-/*
- * Force an unresolved reference if someone tries to use
- * ia64_fetch_and_add() with a bad value.
- */
-extern unsigned long __bad_size_for_ia64_fetch_and_add (void);
-extern unsigned long __bad_increment_for_ia64_fetch_and_add (void);
-
-#define IA64_FETCHADD(tmp,v,n,sz,sem)                                           \
-({                                                                              \
-        switch (sz) {                                                           \
-              case 4:                                                           \
-                tmp = ia64_fetchadd4_##sem((unsigned int *) v, n);              \
-                break;                                                          \
-                                                                                \
-              case 8:                                                           \
-                tmp = ia64_fetchadd8_##sem((unsigned long *) v, n);             \
-                break;                                                          \
-                                                                                \
-              default:                                                          \
-                __bad_size_for_ia64_fetch_and_add();                            \
-        }                                                                       \
-})
-
-#define ia64_fetchadd(i,v,sem)                                                          \
-({                                                                                      \
-        __u64 _tmp;                                                                     \
-        volatile __typeof__(*(v)) *_v = (v);                                            \
-        /* Can't use a switch () here: gcc isn't always smart enough for that... */     \
-        if ((i) == -16)                                                                 \
-                IA64_FETCHADD(_tmp, _v, -16, sizeof(*(v)), sem);                        \
-        else if ((i) == -8)                                                             \
-                IA64_FETCHADD(_tmp, _v, -8, sizeof(*(v)), sem);                         \
-        else if ((i) == -4)                                                             \
-                IA64_FETCHADD(_tmp, _v, -4, sizeof(*(v)), sem);                         \
-        else if ((i) == -1)                                                             \
-                IA64_FETCHADD(_tmp, _v, -1, sizeof(*(v)), sem);                         \
-        else if ((i) == 1)                                                              \
-                IA64_FETCHADD(_tmp, _v, 1, sizeof(*(v)), sem);                          \
-        else if ((i) == 4)                                                              \
-                IA64_FETCHADD(_tmp, _v, 4, sizeof(*(v)), sem);                          \
-        else if ((i) == 8)                                                              \
-                IA64_FETCHADD(_tmp, _v, 8, sizeof(*(v)), sem);                          \
-        else if ((i) == 16)                                                             \
-                IA64_FETCHADD(_tmp, _v, 16, sizeof(*(v)), sem);                         \
-        else                                                                            \
-                _tmp = __bad_increment_for_ia64_fetch_and_add();                        \
-        (__typeof__(*(v))) (_tmp);      /* return old value */                          \
-})
-
-#define ia64_fetch_and_add(i,v) (ia64_fetchadd(i, v, rel) + (i)) /* return new value */
-
-#endif
-
-
-#ifndef __ASSEMBLY__
-
-#define IA64_INTRINSIC_API(name)        ia64_native_ ## name
-#define IA64_INTRINSIC_MACRO(name)      ia64_native_ ## name
-
-
-/************************************************/
-/* Instructions paravirtualized for correctness */
-/************************************************/
-/* fc, thash, get_cpuid, get_pmd, get_eflags, set_eflags */
-/* Note that "ttag" and "cover" are also privilege-sensitive; "ttag"
- * is not currently used (though it may be in a long-format VHPT system!)
- */
-#define ia64_fc                         IA64_INTRINSIC_API(fc)
-#define ia64_thash                      IA64_INTRINSIC_API(thash)
-#define ia64_get_cpuid                  IA64_INTRINSIC_API(get_cpuid)
-#define ia64_get_pmd                    IA64_INTRINSIC_API(get_pmd)
-
-
-/************************************************/
-/* Instructions paravirtualized for performance */
-/************************************************/
-#define ia64_ssm                        IA64_INTRINSIC_MACRO(ssm)
-#define ia64_rsm                        IA64_INTRINSIC_MACRO(rsm)
-#define ia64_getreg                     IA64_INTRINSIC_MACRO(getreg)
-#define ia64_setreg                     IA64_INTRINSIC_API(setreg)
-#define ia64_set_rr                     IA64_INTRINSIC_API(set_rr)
-#define ia64_get_rr                     IA64_INTRINSIC_API(get_rr)
-#define ia64_ptcga                      IA64_INTRINSIC_API(ptcga)
-#define ia64_get_psr_i                  IA64_INTRINSIC_API(get_psr_i)
-#define ia64_intrin_local_irq_restore   \
-        IA64_INTRINSIC_API(intrin_local_irq_restore)
-#define ia64_set_rr0_to_rr4             IA64_INTRINSIC_API(set_rr0_to_rr4)
-
-#endif /* !__ASSEMBLY__ */
-
-#endif /* _UAPI_ASM_IA64_INTRINSICS_H */
diff --git a/arch/ia64/include/uapi/asm/ioctl.h b/arch/ia64/include/uapi/asm/ioctl.h
deleted file mode 100644
index b279fe06dfe..00000000000
--- a/arch/ia64/include/uapi/asm/ioctl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <asm-generic/ioctl.h>
diff --git a/arch/ia64/include/uapi/asm/ioctls.h b/arch/ia64/include/uapi/asm/ioctls.h
deleted file mode 100644
index f3aab5512e9..00000000000
--- a/arch/ia64/include/uapi/asm/ioctls.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef _ASM_IA64_IOCTLS_H
-#define _ASM_IA64_IOCTLS_H
-
-#include <asm-generic/ioctls.h>
-
-#endif /* _ASM_IA64_IOCTLS_H */
diff --git a/arch/ia64/include/uapi/asm/ipcbuf.h b/arch/ia64/include/uapi/asm/ipcbuf.h
deleted file mode 100644
index 84c7e51cb6d..00000000000
--- a/arch/ia64/include/uapi/asm/ipcbuf.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <asm-generic/ipcbuf.h>
diff --git a/arch/ia64/include/uapi/asm/kvm.h b/arch/ia64/include/uapi/asm/kvm.h
deleted file mode 100644
index ec6c6b30123..00000000000
--- a/arch/ia64/include/uapi/asm/kvm.h
+++ /dev/null
@@ -1,269 +0,0 @@
-#ifndef __ASM_IA64_KVM_H
-#define __ASM_IA64_KVM_H
-
-/*
- * kvm structure definitions  for ia64
- *
- * Copyright (C) 2007 Xiantao Zhang <xiantao.zhang@intel.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
- * Place - Suite 330, Boston, MA 02111-1307 USA.
- *
- */
-
-#include <linux/types.h>
-#include <linux/ioctl.h>
-
-/* Select x86 specific features in <linux/kvm.h> */
-#define __KVM_HAVE_IOAPIC
-#define __KVM_HAVE_IRQ_LINE
-#define __KVM_HAVE_DEVICE_ASSIGNMENT
-
-/* Architectural interrupt line count. */
-#define KVM_NR_INTERRUPTS 256
-
-#define KVM_IOAPIC_NUM_PINS  48
-
-struct kvm_ioapic_state {
-        __u64 base_address;
-        __u32 ioregsel;
-        __u32 id;
-        __u32 irr;
-        __u32 pad;
-        union {
-                __u64 bits;
-                struct {
-                        __u8 vector;
-                        __u8 delivery_mode:3;
-                        __u8 dest_mode:1;
-                        __u8 delivery_status:1;
-                        __u8 polarity:1;
-                        __u8 remote_irr:1;
-                        __u8 trig_mode:1;
-                        __u8 mask:1;
-                        __u8 reserve:7;
-                        __u8 reserved[4];
-                        __u8 dest_id;
-                } fields;
-        } redirtbl[KVM_IOAPIC_NUM_PINS];
-};
-
-#define KVM_IRQCHIP_PIC_MASTER   0
-#define KVM_IRQCHIP_PIC_SLAVE    1
-#define KVM_IRQCHIP_IOAPIC       2
-#define KVM_NR_IRQCHIPS          3
-
-#define KVM_CONTEXT_SIZE        8*1024
-
-struct kvm_fpreg {
-        union {
-                unsigned long bits[2];
-                long double __dummy;    /* force 16-byte alignment */
-        } u;
-};
-
-union context {
-        /* 8K size */
-        char    dummy[KVM_CONTEXT_SIZE];
-        struct {
-                unsigned long       psr;
-                unsigned long       pr;
-                unsigned long       caller_unat;
-                unsigned long       pad;
-                unsigned long       gr[32];
-                unsigned long       ar[128];
-                unsigned long       br[8];
-                unsigned long       cr[128];
-                unsigned long       rr[8];
-                unsigned long       ibr[8];
-                unsigned long       dbr[8];
-                unsigned long       pkr[8];
-                struct kvm_fpreg   fr[128];
-        };
-};
-
-struct thash_data {
-        union {
-                struct {
-                        unsigned long p    :  1; /* 0 */
-                        unsigned long rv1  :  1; /* 1 */
-                        unsigned long ma   :  3; /* 2-4 */
-                        unsigned long a    :  1; /* 5 */
-                        unsigned long d    :  1; /* 6 */
-                        unsigned long pl   :  2; /* 7-8 */
-                        unsigned long ar   :  3; /* 9-11 */
-                        unsigned long ppn  : 38; /* 12-49 */
-                        unsigned long rv2  :  2; /* 50-51 */
-                        unsigned long ed   :  1; /* 52 */
-                        unsigned long ig1  : 11; /* 53-63 */
-                };
-                struct {
-                        unsigned long __rv1 : 53;     /* 0-52 */
-                        unsigned long contiguous : 1; /*53 */
-                        unsigned long tc : 1;         /* 54 TR or TC */
-                        unsigned long cl : 1;
-                        /* 55 I side or D side cache line */
-                        unsigned long len  :  4;      /* 56-59 */
-                        unsigned long io  : 1;  /* 60 entry is for io or not */
-                        unsigned long nomap : 1;
-                        /* 61 entry cann't be inserted into machine TLB.*/
-                        unsigned long checked : 1;
-                        /* 62 for VTLB/VHPT sanity check */
-                        unsigned long invalid : 1;
-                        /* 63 invalid entry */
-                };
-                unsigned long page_flags;
-        };                  /* same for VHPT and TLB */
-
-        union {
-                struct {
-                        unsigned long rv3  :  2;
-                        unsigned long ps   :  6;
-                        unsigned long key  : 24;
-                        unsigned long rv4  : 32;
-                };
-                unsigned long itir;
-        };
-        union {
-                struct {
-                        unsigned long ig2  :  12;
-                        unsigned long vpn  :  49;
-                        unsigned long vrn  :   3;
-                };
-                unsigned long ifa;
-                unsigned long vadr;
-                struct {
-                        unsigned long tag  :  63;
-                        unsigned long ti   :  1;
-                };
-                unsigned long etag;
-        };
-        union {
-                struct thash_data *next;
-                unsigned long rid;
-                unsigned long gpaddr;
-        };
-};
-
-#define NITRS   8
-#define NDTRS   8
-
-struct saved_vpd {
-        unsigned long  vhpi;
-        unsigned long  vgr[16];
-        unsigned long  vbgr[16];
-        unsigned long  vnat;
-        unsigned long  vbnat;
-        unsigned long  vcpuid[5];
-        unsigned long  vpsr;
-        unsigned long  vpr;
-        union {
-                unsigned long  vcr[128];
-                struct {
-                        unsigned long dcr;
-                        unsigned long itm;
-                        unsigned long iva;
-                        unsigned long rsv1[5];
-                        unsigned long pta;
-                        unsigned long rsv2[7];
-                        unsigned long ipsr;
-                        unsigned long isr;
-                        unsigned long rsv3;
-                        unsigned long iip;
-                        unsigned long ifa;
-                        unsigned long itir;
-                        unsigned long iipa;
-                        unsigned long ifs;
-                        unsigned long iim;
-                        unsigned long iha;
-                        unsigned long rsv4[38];
-                        unsigned long lid;
-                        unsigned long ivr;
-                        unsigned long tpr;
-                        unsigned long eoi;
-                        unsigned long irr[4];
-                        unsigned long itv;
-                        unsigned long pmv;
-                        unsigned long cmcv;
-                        unsigned long rsv5[5];
-                        unsigned long lrr0;
-                        unsigned long lrr1;
-                        unsigned long rsv6[46];
-                };
-        };
-};
-
-struct kvm_regs {
-        struct saved_vpd vpd;
-        /*Arch-regs*/
-        int mp_state;
-        unsigned long vmm_rr;
-        /* TR and TC.  */
-        struct thash_data itrs[NITRS];
-        struct thash_data dtrs[NDTRS];
-        /* Bit is set if there is a tr/tc for the region.  */
-        unsigned char itr_regions;
-        unsigned char dtr_regions;
-        unsigned char tc_regions;
-
-        char irq_check;
-        unsigned long saved_itc;
-        unsigned long itc_check;
-        unsigned long timer_check;
-        unsigned long timer_pending;
-        unsigned long last_itc;
-
-        unsigned long vrr[8];
-        unsigned long ibr[8];
-        unsigned long dbr[8];
-        unsigned long insvc[4];         /* Interrupt in service.  */
-        unsigned long xtp;
-
-        unsigned long metaphysical_rr0; /* from kvm_arch (so is pinned) */
-        unsigned long metaphysical_rr4; /* from kvm_arch (so is pinned) */
-        unsigned long metaphysical_saved_rr0; /* from kvm_arch          */
-        unsigned long metaphysical_saved_rr4; /* from kvm_arch          */
-        unsigned long fp_psr;       /*used for lazy float register */
-        unsigned long saved_gp;
-        /*for phycial  emulation */
-
-        union context saved_guest;
-
-        unsigned long reserved[64];     /* for future use */
-};
-
-struct kvm_sregs {
-};
-
-struct kvm_fpu {
-};
-
-#define KVM_IA64_VCPU_STACK_SHIFT       16
-#define KVM_IA64_VCPU_STACK_SIZE        (1UL << KVM_IA64_VCPU_STACK_SHIFT)
-
-struct kvm_ia64_vcpu_stack {
-        unsigned char stack[KVM_IA64_VCPU_STACK_SIZE];
-};
-
-struct kvm_debug_exit_arch {
-};
-
-/* for KVM_SET_GUEST_DEBUG */
-struct kvm_guest_debug_arch {
-};
-
-/* definition of registers in kvm_run */
-struct kvm_sync_regs {
-};
-
-#endif
diff --git a/arch/ia64/include/uapi/asm/mman.h b/arch/ia64/include/uapi/asm/mman.h
deleted file mode 100644
index 8740819adc5..00000000000
--- a/arch/ia64/include/uapi/asm/mman.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * Based on <asm-i386/mman.h>.
- *
- * Modified 1998-2000, 2002
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-#ifndef _UAPI_ASM_IA64_MMAN_H
-#define _UAPI_ASM_IA64_MMAN_H
-
-
-#include <asm-generic/mman.h>
-
-#define MAP_GROWSUP     0x0200          /* register stack-like segment */
-
-
-#endif /* _UAPI_ASM_IA64_MMAN_H */
diff --git a/arch/ia64/include/uapi/asm/msgbuf.h b/arch/ia64/include/uapi/asm/msgbuf.h
deleted file mode 100644
index 6c64c0d2aae..00000000000
--- a/arch/ia64/include/uapi/asm/msgbuf.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef _ASM_IA64_MSGBUF_H
-#define _ASM_IA64_MSGBUF_H
-
-/*
- * The msqid64_ds structure for IA-64 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 2 miscellaneous 64-bit values
- */
-
-struct msqid64_ds {
-        struct ipc64_perm msg_perm;
-        __kernel_time_t msg_stime;      /* last msgsnd time */
-        __kernel_time_t msg_rtime;      /* last msgrcv time */
-        __kernel_time_t msg_ctime;      /* last change time */
-        unsigned long  msg_cbytes;      /* current number of bytes on queue */
-        unsigned long  msg_qnum;        /* number of messages in queue */
-        unsigned long  msg_qbytes;      /* max number of bytes on queue */
-        __kernel_pid_t msg_lspid;       /* pid of last msgsnd */
-        __kernel_pid_t msg_lrpid;       /* last receive pid */
-        unsigned long  __unused1;
-        unsigned long  __unused2;
-};
-
-#endif /* _ASM_IA64_MSGBUF_H */
diff --git a/arch/ia64/include/uapi/asm/param.h b/arch/ia64/include/uapi/asm/param.h
deleted file mode 100644
index d7da41d9497..00000000000
--- a/arch/ia64/include/uapi/asm/param.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Fundamental kernel parameters.
- *
- * Based on <asm-i386/param.h>.
- *
- * Modified 1998, 1999, 2002-2003
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-#ifndef _UAPI_ASM_IA64_PARAM_H
-#define _UAPI_ASM_IA64_PARAM_H
-
-
-#define EXEC_PAGESIZE   65536
-
-#ifndef NOGROUP
-# define NOGROUP        (-1)
-#endif
-
-#define MAXHOSTNAMELEN  64      /* max length of hostname */
-
-#ifndef __KERNEL__
-   /*
-    * Technically, this is wrong, but some old apps still refer to it.  The proper way to
-    * get the HZ value is via sysconf(_SC_CLK_TCK).
-    */
-# define HZ 1024
-#endif
-
-#endif /* _UAPI_ASM_IA64_PARAM_H */
diff --git a/arch/ia64/include/uapi/asm/perfmon.h b/arch/ia64/include/uapi/asm/perfmon.h
deleted file mode 100644
index 1a10a2dd58a..00000000000
--- a/arch/ia64/include/uapi/asm/perfmon.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (C) 2001-2003 Hewlett-Packard Co
- *               Stephane Eranian <eranian@hpl.hp.com>
- */
-
-#ifndef _UAPI_ASM_IA64_PERFMON_H
-#define _UAPI_ASM_IA64_PERFMON_H
-
-/*
- * perfmon commands supported on all CPU models
- */
-#define PFM_WRITE_PMCS          0x01
-#define PFM_WRITE_PMDS          0x02
-#define PFM_READ_PMDS           0x03
-#define PFM_STOP                0x04
-#define PFM_START               0x05
-#define PFM_ENABLE              0x06 /* obsolete */
-#define PFM_DISABLE             0x07 /* obsolete */
-#define PFM_CREATE_CONTEXT      0x08
-#define PFM_DESTROY_CONTEXT     0x09 /* obsolete use close() */
-#define PFM_RESTART             0x0a
-#define PFM_PROTECT_CONTEXT     0x0b /* obsolete */
-#define PFM_GET_FEATURES        0x0c
-#define PFM_DEBUG               0x0d
-#define PFM_UNPROTECT_CONTEXT   0x0e /* obsolete */
-#define PFM_GET_PMC_RESET_VAL   0x0f
-#define PFM_LOAD_CONTEXT        0x10
-#define PFM_UNLOAD_CONTEXT      0x11
-
-/*
- * PMU model specific commands (may not be supported on all PMU models)
- */
-#define PFM_WRITE_IBRS          0x20
-#define PFM_WRITE_DBRS          0x21
-
-/*
- * context flags
- */
-#define PFM_FL_NOTIFY_BLOCK      0x01   /* block task on user level notifications */
-#define PFM_FL_SYSTEM_WIDE       0x02   /* create a system wide context */
-#define PFM_FL_OVFL_NO_MSG       0x80   /* do not post overflow/end messages for notification */
-
-/*
- * event set flags
- */
-#define PFM_SETFL_EXCL_IDLE      0x01   /* exclude idle task (syswide only) XXX: DO NOT USE YET */
-
-/*
- * PMC flags
- */
-#define PFM_REGFL_OVFL_NOTIFY   0x1     /* send notification on overflow */
-#define PFM_REGFL_RANDOM        0x2     /* randomize sampling interval   */
-
-/*
- * PMD/PMC/IBR/DBR return flags (ignored on input)
- *
- * Those flags are used on output and must be checked in case EAGAIN is returned
- * by any of the calls using a pfarg_reg_t or pfarg_dbreg_t structure.
- */
-#define PFM_REG_RETFL_NOTAVAIL  (1UL<<31) /* set if register is implemented but not available */
-#define PFM_REG_RETFL_EINVAL    (1UL<<30) /* set if register entry is invalid */
-#define PFM_REG_RETFL_MASK      (PFM_REG_RETFL_NOTAVAIL|PFM_REG_RETFL_EINVAL)
-
-#define PFM_REG_HAS_ERROR(flag) (((flag) & PFM_REG_RETFL_MASK) != 0)
-
-typedef unsigned char pfm_uuid_t[16];   /* custom sampling buffer identifier type */
-
-/*
- * Request structure used to define a context
- */
-typedef struct {
-        pfm_uuid_t     ctx_smpl_buf_id;  /* which buffer format to use (if needed) */
-        unsigned long  ctx_flags;        /* noblock/block */
-        unsigned short ctx_nextra_sets;  /* number of extra event sets (you always get 1) */
-        unsigned short ctx_reserved1;    /* for future use */
-        int            ctx_fd;           /* return arg: unique identification for context */
-        void           *ctx_smpl_vaddr;  /* return arg: virtual address of sampling buffer, is used */
-        unsigned long  ctx_reserved2[11];/* for future use */
-} pfarg_context_t;
-
-/*
- * Request structure used to write/read a PMC or PMD
- */
-typedef struct {
-        unsigned int    reg_num;           /* which register */
-        unsigned short  reg_set;           /* event set for this register */
-        unsigned short  reg_reserved1;     /* for future use */
-
-        unsigned long   reg_value;         /* initial pmc/pmd value */
-        unsigned long   reg_flags;         /* input: pmc/pmd flags, return: reg error */
-
-        unsigned long   reg_long_reset;    /* reset after buffer overflow notification */
-        unsigned long   reg_short_reset;   /* reset after counter overflow */
-
-        unsigned long   reg_reset_pmds[4]; /* which other counters to reset on overflow */
-        unsigned long   reg_random_seed;   /* seed value when randomization is used */
-        unsigned long   reg_random_mask;   /* bitmask used to limit random value */
-        unsigned long   reg_last_reset_val;/* return: PMD last reset value */
-
-        unsigned long   reg_smpl_pmds[4];  /* which pmds are accessed when PMC overflows */
-        unsigned long   reg_smpl_eventid;  /* opaque sampling event identifier */
-
-        unsigned long   reg_reserved2[3];   /* for future use */
-} pfarg_reg_t;
-
-typedef struct {
-        unsigned int    dbreg_num;              /* which debug register */
-        unsigned short  dbreg_set;              /* event set for this register */
-        unsigned short  dbreg_reserved1;        /* for future use */
-        unsigned long   dbreg_value;            /* value for debug register */
-        unsigned long   dbreg_flags;            /* return: dbreg error */
-        unsigned long   dbreg_reserved2[1];     /* for future use */
-} pfarg_dbreg_t;
-
-typedef struct {
-        unsigned int    ft_version;     /* perfmon: major [16-31], minor [0-15] */
-        unsigned int    ft_reserved;    /* reserved for future use */
-        unsigned long   reserved[4];    /* for future use */
-} pfarg_features_t;
-
-typedef struct {
-        pid_t           load_pid;          /* process to load the context into */
-        unsigned short  load_set;          /* first event set to load */
-        unsigned short  load_reserved1;    /* for future use */
-        unsigned long   load_reserved2[3]; /* for future use */
-} pfarg_load_t;
-
-typedef struct {
-        int             msg_type;               /* generic message header */
-        int             msg_ctx_fd;             /* generic message header */
-        unsigned long   msg_ovfl_pmds[4];       /* which PMDs overflowed */
-        unsigned short  msg_active_set;         /* active set at the time of overflow */
-        unsigned short  msg_reserved1;          /* for future use */
-        unsigned int    msg_reserved2;          /* for future use */
-        unsigned long   msg_tstamp;             /* for perf tuning/debug */
-} pfm_ovfl_msg_t;
-
-typedef struct {
-        int             msg_type;               /* generic message header */
-        int             msg_ctx_fd;             /* generic message header */
-        unsigned long   msg_tstamp;             /* for perf tuning */
-} pfm_end_msg_t;
-
-typedef struct {
-        int             msg_type;               /* type of the message */
-        int             msg_ctx_fd;             /* unique identifier for the context */
-        unsigned long   msg_tstamp;             /* for perf tuning */
-} pfm_gen_msg_t;
-
-#define PFM_MSG_OVFL    1       /* an overflow happened */
-#define PFM_MSG_END     2       /* task to which context was attached ended */
-
-typedef union {
-        pfm_ovfl_msg_t  pfm_ovfl_msg;
-        pfm_end_msg_t   pfm_end_msg;
-        pfm_gen_msg_t   pfm_gen_msg;
-} pfm_msg_t;
-
-/*
- * Define the version numbers for both perfmon as a whole and the sampling buffer format.
- */
-#define PFM_VERSION_MAJ          2U
-#define PFM_VERSION_MIN          0U
-#define PFM_VERSION              (((PFM_VERSION_MAJ&0xffff)<<16)|(PFM_VERSION_MIN & 0xffff))
-#define PFM_VERSION_MAJOR(x)     (((x)>>16) & 0xffff)
-#define PFM_VERSION_MINOR(x)     ((x) & 0xffff)
-
-
-/*
- * miscellaneous architected definitions
- */
-#define PMU_FIRST_COUNTER       4       /* first counting monitor (PMC/PMD) */
-#define PMU_MAX_PMCS            256     /* maximum architected number of PMC registers */
-#define PMU_MAX_PMDS            256     /* maximum architected number of PMD registers */
-
-
-#endif /* _UAPI_ASM_IA64_PERFMON_H */
diff --git a/arch/ia64/include/uapi/asm/perfmon_default_smpl.h b/arch/ia64/include/uapi/asm/perfmon_default_smpl.h
deleted file mode 100644
index a2d560c6723..00000000000
--- a/arch/ia64/include/uapi/asm/perfmon_default_smpl.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2002-2003 Hewlett-Packard Co
- *               Stephane Eranian <eranian@hpl.hp.com>
- *
- * This file implements the default sampling buffer format
- * for Linux/ia64 perfmon subsystem.
- */
-#ifndef __PERFMON_DEFAULT_SMPL_H__
-#define __PERFMON_DEFAULT_SMPL_H__ 1
-
-#define PFM_DEFAULT_SMPL_UUID { \
-                0x4d, 0x72, 0xbe, 0xc0, 0x06, 0x64, 0x41, 0x43, 0x82, 0xb4, 0xd3, 0xfd, 0x27, 0x24, 0x3c, 0x97}
-
-/*
- * format specific parameters (passed at context creation)
- */
-typedef struct {
-        unsigned long buf_size;         /* size of the buffer in bytes */
-        unsigned int  flags;            /* buffer specific flags */
-        unsigned int  res1;             /* for future use */
-        unsigned long reserved[2];      /* for future use */
-} pfm_default_smpl_arg_t;
-
-/*
- * combined context+format specific structure. Can be passed
- * to PFM_CONTEXT_CREATE
- */
-typedef struct {
-        pfarg_context_t         ctx_arg;
-        pfm_default_smpl_arg_t  buf_arg;
-} pfm_default_smpl_ctx_arg_t;
-
-/*
- * This header is at the beginning of the sampling buffer returned to the user.
- * It is directly followed by the first record.
- */
-typedef struct {
-        unsigned long   hdr_count;              /* how many valid entries */
-        unsigned long   hdr_cur_offs;           /* current offset from top of buffer */
-        unsigned long   hdr_reserved2;          /* reserved for future use */
-
-        unsigned long   hdr_overflows;          /* how many times the buffer overflowed */
-        unsigned long   hdr_buf_size;           /* how many bytes in the buffer */
-
-        unsigned int    hdr_version;            /* contains perfmon version (smpl format diffs) */
-        unsigned int    hdr_reserved1;          /* for future use */
-        unsigned long   hdr_reserved[10];       /* for future use */
-} pfm_default_smpl_hdr_t;
-
-/*
- * Entry header in the sampling buffer.  The header is directly followed
- * with the values of the PMD registers of interest saved in increasing 
- * index order: PMD4, PMD5, and so on. How many PMDs are present depends 
- * on how the session was programmed.
- *
- * In the case where multiple counters overflow at the same time, multiple
- * entries are written consecutively.
- *
- * last_reset_value member indicates the initial value of the overflowed PMD. 
- */
-typedef struct {
-        int             pid;                    /* thread id (for NPTL, this is gettid()) */
-        unsigned char   reserved1[3];           /* reserved for future use */
-        unsigned char   ovfl_pmd;               /* index of overflowed PMD */
-
-        unsigned long   last_reset_val;         /* initial value of overflowed PMD */
-        unsigned long   ip;                     /* where did the overflow interrupt happened  */
-        unsigned long   tstamp;                 /* ar.itc when entering perfmon intr. handler */
-
-        unsigned short  cpu;                    /* cpu on which the overflow occurred */
-        unsigned short  set;                    /* event set active when overflow occurred   */
-        int             tgid;                   /* thread group id (for NPTL, this is getpid()) */
-} pfm_default_smpl_entry_t;
-
-#define PFM_DEFAULT_MAX_PMDS            64 /* how many pmds supported by data structures (sizeof(unsigned long) */
-#define PFM_DEFAULT_MAX_ENTRY_SIZE      (sizeof(pfm_default_smpl_entry_t)+(sizeof(unsigned long)*PFM_DEFAULT_MAX_PMDS))
-#define PFM_DEFAULT_SMPL_MIN_BUF_SIZE   (sizeof(pfm_default_smpl_hdr_t)+PFM_DEFAULT_MAX_ENTRY_SIZE)
-
-#define PFM_DEFAULT_SMPL_VERSION_MAJ    2U
-#define PFM_DEFAULT_SMPL_VERSION_MIN    0U
-#define PFM_DEFAULT_SMPL_VERSION        (((PFM_DEFAULT_SMPL_VERSION_MAJ&0xffff)<<16)|(PFM_DEFAULT_SMPL_VERSION_MIN & 0xffff))
-
-#endif /* __PERFMON_DEFAULT_SMPL_H__ */
diff --git a/arch/ia64/include/uapi/asm/poll.h b/arch/ia64/include/uapi/asm/poll.h
deleted file mode 100644
index c98509d3149..00000000000
--- a/arch/ia64/include/uapi/asm/poll.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <asm-generic/poll.h>
diff --git a/arch/ia64/include/uapi/asm/posix_types.h b/arch/ia64/include/uapi/asm/posix_types.h
deleted file mode 100644
index 99ee1d6510c..00000000000
--- a/arch/ia64/include/uapi/asm/posix_types.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef _ASM_IA64_POSIX_TYPES_H
-#define _ASM_IA64_POSIX_TYPES_H
-
-typedef unsigned long   __kernel_sigset_t;      /* at least 32 bits */
-
-#include <asm-generic/posix_types.h>
-
-#endif /* _ASM_IA64_POSIX_TYPES_H */
diff --git a/arch/ia64/include/uapi/asm/ptrace.h b/arch/ia64/include/uapi/asm/ptrace.h
deleted file mode 100644
index 0a02f634e12..00000000000
--- a/arch/ia64/include/uapi/asm/ptrace.h
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright (C) 1998-2004 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- *      Stephane Eranian <eranian@hpl.hp.com>
- * Copyright (C) 2003 Intel Co
- *      Suresh Siddha <suresh.b.siddha@intel.com>
- *      Fenghua Yu <fenghua.yu@intel.com>
- *      Arun Sharma <arun.sharma@intel.com>
- *
- * 12/07/98     S. Eranian      added pt_regs & switch_stack
- * 12/21/98     D. Mosberger    updated to match latest code
- *  6/17/99     D. Mosberger    added second unat member to "struct switch_stack"
- *
- */
-#ifndef _UAPI_ASM_IA64_PTRACE_H
-#define _UAPI_ASM_IA64_PTRACE_H
-
-/*
- * When a user process is blocked, its state looks as follows:
- *
- *            +----------------------+  ------- IA64_STK_OFFSET
- *            |                      |   ^
- *            | struct pt_regs       |   |
- *            |                      |   |
- *            +----------------------+   |
- *            |                      |   |
- *            |    memory stack      |   |
- *            | (growing downwards)  |   |
- *            //.....................//  |
- *                                       |
- *            //.....................//  |
- *            |                      |   |
- *            +----------------------+   |
- *            | struct switch_stack  |   |
- *            |                      |   |
- *            +----------------------+   |
- *            |                      |   |
- *            //.....................//  |
- *                                       |
- *            //.....................//  |
- *            |                      |   |
- *            |  register stack      |   |
- *            | (growing upwards)    |   |
- *            |                      |   |
- *            +----------------------+   |  --- IA64_RBS_OFFSET
- *            |  struct thread_info  |   |  ^
- *            +----------------------+   |  |
- *            |                      |   |  |
- *            |  struct task_struct  |   |  |
- * current -> |                      |   |  |
- *            +----------------------+ -------
- *
- * Note that ar.ec is not saved explicitly in pt_reg or switch_stack.
- * This is because ar.ec is saved as part of ar.pfs.
- */
-
-
-#include <asm/fpu.h>
-
-
-#ifndef __ASSEMBLY__
-
-/*
- * This struct defines the way the registers are saved on system
- * calls.
- *
- * We don't save all floating point register because the kernel
- * is compiled to use only a very small subset, so the other are
- * untouched.
- *
- * THIS STRUCTURE MUST BE A MULTIPLE 16-BYTE IN SIZE
- * (because the memory stack pointer MUST ALWAYS be aligned this way)
- *
- */
-struct pt_regs {
-        /* The following registers are saved by SAVE_MIN: */
-        unsigned long b6;               /* scratch */
-        unsigned long b7;               /* scratch */
-
-        unsigned long ar_csd;           /* used by cmp8xchg16 (scratch) */
-        unsigned long ar_ssd;           /* reserved for future use (scratch) */
-
-        unsigned long r8;               /* scratch (return value register 0) */
-        unsigned long r9;               /* scratch (return value register 1) */
-        unsigned long r10;              /* scratch (return value register 2) */
-        unsigned long r11;              /* scratch (return value register 3) */
-
-        unsigned long cr_ipsr;          /* interrupted task's psr */
-        unsigned long cr_iip;           /* interrupted task's instruction pointer */
-        /*
-         * interrupted task's function state; if bit 63 is cleared, it
-         * contains syscall's ar.pfs.pfm:
-         */
-        unsigned long cr_ifs;
-
-        unsigned long ar_unat;          /* interrupted task's NaT register (preserved) */
-        unsigned long ar_pfs;           /* prev function state  */
-        unsigned long ar_rsc;           /* RSE configuration */
-        /* The following two are valid only if cr_ipsr.cpl > 0 || ti->flags & _TIF_MCA_INIT */
-        unsigned long ar_rnat;          /* RSE NaT */
-        unsigned long ar_bspstore;      /* RSE bspstore */
-
-        unsigned long pr;               /* 64 predicate registers (1 bit each) */
-        unsigned long b0;               /* return pointer (bp) */
-        unsigned long loadrs;           /* size of dirty partition << 16 */
-
-        unsigned long r1;               /* the gp pointer */
-        unsigned long r12;              /* interrupted task's memory stack pointer */
-        unsigned long r13;              /* thread pointer */
-
-        unsigned long ar_fpsr;          /* floating point status (preserved) */
-        unsigned long r15;              /* scratch */
-
-        /* The remaining registers are NOT saved for system calls.  */
-
-        unsigned long r14;              /* scratch */
-        unsigned long r2;               /* scratch */
-        unsigned long r3;               /* scratch */
-
-        /* The following registers are saved by SAVE_REST: */
-        unsigned long r16;              /* scratch */
-        unsigned long r17;              /* scratch */
-        unsigned long r18;              /* scratch */
-        unsigned long r19;              /* scratch */
-        unsigned long r20;              /* scratch */
-        unsigned long r21;              /* scratch */
-        unsigned long r22;              /* scratch */
-        unsigned long r23;              /* scratch */
-        unsigned long r24;              /* scratch */
-        unsigned long r25;              /* scratch */
-        unsigned long r26;              /* scratch */
-        unsigned long r27;              /* scratch */
-        unsigned long r28;              /* scratch */
-        unsigned long r29;              /* scratch */
-        unsigned long r30;              /* scratch */
-        unsigned long r31;              /* scratch */
-
-        unsigned long ar_ccv;           /* compare/exchange value (scratch) */
-
-        /*
-         * Floating point registers that the kernel considers scratch:
-         */
-        struct ia64_fpreg f6;           /* scratch */
-        struct ia64_fpreg f7;           /* scratch */
-        struct ia64_fpreg f8;           /* scratch */
-        struct ia64_fpreg f9;           /* scratch */
-        struct ia64_fpreg f10;          /* scratch */
-        struct ia64_fpreg f11;          /* scratch */
-};
-
-/*
- * This structure contains the addition registers that need to
- * preserved across a context switch.  This generally consists of
- * "preserved" registers.
- */
-struct switch_stack {
-        unsigned long caller_unat;      /* user NaT collection register (preserved) */
-        unsigned long ar_fpsr;          /* floating-point status register */
-
-        struct ia64_fpreg f2;           /* preserved */
-        struct ia64_fpreg f3;           /* preserved */
-        struct ia64_fpreg f4;           /* preserved */
-        struct ia64_fpreg f5;           /* preserved */
-
-        struct ia64_fpreg f12;          /* scratch, but untouched by kernel */
-        struct ia64_fpreg f13;          /* scratch, but untouched by kernel */
-        struct ia64_fpreg f14;          /* scratch, but untouched by kernel */
-        struct ia64_fpreg f15;          /* scratch, but untouched by kernel */
-        struct ia64_fpreg f16;          /* preserved */
-        struct ia64_fpreg f17;          /* preserved */
-        struct ia64_fpreg f18;          /* preserved */
-        struct ia64_fpreg f19;          /* preserved */
-        struct ia64_fpreg f20;          /* preserved */
-        struct ia64_fpreg f21;          /* preserved */
-        struct ia64_fpreg f22;          /* preserved */
-        struct ia64_fpreg f23;          /* preserved */
-        struct ia64_fpreg f24;          /* preserved */
-        struct ia64_fpreg f25;          /* preserved */
-        struct ia64_fpreg f26;          /* preserved */
-        struct ia64_fpreg f27;          /* preserved */
-        struct ia64_fpreg f28;          /* preserved */
-        struct ia64_fpreg f29;          /* preserved */
-        struct ia64_fpreg f30;          /* preserved */
-        struct ia64_fpreg f31;          /* preserved */
-
-        unsigned long r4;               /* preserved */
-        unsigned long r5;               /* preserved */
-        unsigned long r6;               /* preserved */
-        unsigned long r7;               /* preserved */
-
-        unsigned long b0;               /* so we can force a direct return in copy_thread */
-        unsigned long b1;
-        unsigned long b2;
-        unsigned long b3;
-        unsigned long b4;
-        unsigned long b5;
-
-        unsigned long ar_pfs;           /* previous function state */
-        unsigned long ar_lc;            /* loop counter (preserved) */
-        unsigned long ar_unat;          /* NaT bits for r4-r7 */
-        unsigned long ar_rnat;          /* RSE NaT collection register */
-        unsigned long ar_bspstore;      /* RSE dirty base (preserved) */
-        unsigned long pr;               /* 64 predicate registers (1 bit each) */
-};
-
-
-/* pt_all_user_regs is used for PTRACE_GETREGS PTRACE_SETREGS */
-struct pt_all_user_regs {
-        unsigned long nat;
-        unsigned long cr_iip;
-        unsigned long cfm;
-        unsigned long cr_ipsr;
-        unsigned long pr;
-
-        unsigned long gr[32];
-        unsigned long br[8];
-        unsigned long ar[128];
-        struct ia64_fpreg fr[128];
-};
-
-#endif /* !__ASSEMBLY__ */
-
-/* indices to application-registers array in pt_all_user_regs */
-#define PT_AUR_RSC      16
-#define PT_AUR_BSP      17
-#define PT_AUR_BSPSTORE 18
-#define PT_AUR_RNAT     19
-#define PT_AUR_CCV      32
-#define PT_AUR_UNAT     36
-#define PT_AUR_FPSR     40
-#define PT_AUR_PFS      64
-#define PT_AUR_LC       65
-#define PT_AUR_EC       66
-
-/*
- * The numbers chosen here are somewhat arbitrary but absolutely MUST
- * not overlap with any of the number assigned in <linux/ptrace.h>.
- */
-#define PTRACE_SINGLEBLOCK      12      /* resume execution until next branch */
-#define PTRACE_OLD_GETSIGINFO   13      /* (replaced by PTRACE_GETSIGINFO in <linux/ptrace.h>)  */
-#define PTRACE_OLD_SETSIGINFO   14      /* (replaced by PTRACE_SETSIGINFO in <linux/ptrace.h>)  */
-#define PTRACE_GETREGS          18      /* get all registers (pt_all_user_regs) in one shot */
-#define PTRACE_SETREGS          19      /* set all registers (pt_all_user_regs) in one shot */
-
-#define PTRACE_OLDSETOPTIONS    21
-
-#endif /* _UAPI_ASM_IA64_PTRACE_H */
diff --git a/arch/ia64/include/uapi/asm/ptrace_offsets.h b/arch/ia64/include/uapi/asm/ptrace_offsets.h
deleted file mode 100644
index b712773c759..00000000000
--- a/arch/ia64/include/uapi/asm/ptrace_offsets.h
+++ /dev/null
@@ -1,268 +0,0 @@
-#ifndef _ASM_IA64_PTRACE_OFFSETS_H
-#define _ASM_IA64_PTRACE_OFFSETS_H
-
-/*
- * Copyright (C) 1999, 2003 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- */
-/*
- * The "uarea" that can be accessed via PEEKUSER and POKEUSER is a
- * virtual structure that would have the following definition:
- *
- *      struct uarea {
- *              struct ia64_fpreg fph[96];              // f32-f127
- *              unsigned long nat_bits;
- *              unsigned long empty1;
- *              struct ia64_fpreg f2;                   // f2-f5
- *                      :
- *              struct ia64_fpreg f5;
- *              struct ia64_fpreg f10;                  // f10-f31
- *                      :
- *              struct ia64_fpreg f31;
- *              unsigned long r4;                       // r4-r7
- *                      :
- *              unsigned long r7;
- *              unsigned long b1;                       // b1-b5
- *                      :
- *              unsigned long b5;
- *              unsigned long ar_ec;
- *              unsigned long ar_lc;
- *              unsigned long empty2[5];
- *              unsigned long cr_ipsr;
- *              unsigned long cr_iip;
- *              unsigned long cfm;
- *              unsigned long ar_unat;
- *              unsigned long ar_pfs;
- *              unsigned long ar_rsc;
- *              unsigned long ar_rnat;
- *              unsigned long ar_bspstore;
- *              unsigned long pr;
- *              unsigned long b6;
- *              unsigned long ar_bsp;
- *              unsigned long r1;
- *              unsigned long r2;
- *              unsigned long r3;
- *              unsigned long r12;
- *              unsigned long r13;
- *              unsigned long r14;
- *              unsigned long r15;
- *              unsigned long r8;
- *              unsigned long r9;
- *              unsigned long r10;
- *              unsigned long r11;
- *              unsigned long r16;
- *                      :
- *              unsigned long r31;
- *              unsigned long ar_ccv;
- *              unsigned long ar_fpsr;
- *              unsigned long b0;
- *              unsigned long b7;
- *              unsigned long f6;
- *              unsigned long f7;
- *              unsigned long f8;
- *              unsigned long f9;
- *              unsigned long ar_csd;
- *              unsigned long ar_ssd;
- *              unsigned long rsvd1[710];
- *              unsigned long dbr[8];
- *              unsigned long rsvd2[504];
- *              unsigned long ibr[8];
- *              unsigned long rsvd3[504];
- *              unsigned long pmd[4];
- *      }
- */
-
-/* fph: */
-#define PT_F32                  0x0000
-#define PT_F33                  0x0010
-#define PT_F34                  0x0020
-#define PT_F35                  0x0030
-#define PT_F36                  0x0040
-#define PT_F37                  0x0050
-#define PT_F38                  0x0060
-#define PT_F39                  0x0070
-#define PT_F40                  0x0080
-#define PT_F41                  0x0090
-#define PT_F42                  0x00a0
-#define PT_F43                  0x00b0
-#define PT_F44                  0x00c0
-#define PT_F45                  0x00d0
-#define PT_F46                  0x00e0
-#define PT_F47                  0x00f0
-#define PT_F48                  0x0100
-#define PT_F49                  0x0110
-#define PT_F50                  0x0120
-#define PT_F51                  0x0130
-#define PT_F52                  0x0140
-#define PT_F53                  0x0150
-#define PT_F54                  0x0160
-#define PT_F55                  0x0170
-#define PT_F56                  0x0180
-#define PT_F57                  0x0190
-#define PT_F58                  0x01a0
-#define PT_F59                  0x01b0
-#define PT_F60                  0x01c0
-#define PT_F61                  0x01d0
-#define PT_F62                  0x01e0
-#define PT_F63                  0x01f0
-#define PT_F64                  0x0200
-#define PT_F65                  0x0210
-#define PT_F66                  0x0220
-#define PT_F67                  0x0230
-#define PT_F68                  0x0240
-#define PT_F69                  0x0250
-#define PT_F70                  0x0260
-#define PT_F71                  0x0270
-#define PT_F72                  0x0280
-#define PT_F73                  0x0290
-#define PT_F74                  0x02a0
-#define PT_F75                  0x02b0
-#define PT_F76                  0x02c0
-#define PT_F77                  0x02d0
-#define PT_F78                  0x02e0
-#define PT_F79                  0x02f0
-#define PT_F80                  0x0300
-#define PT_F81                  0x0310
-#define PT_F82                  0x0320
-#define PT_F83                  0x0330
-#define PT_F84                  0x0340
-#define PT_F85                  0x0350
-#define PT_F86                  0x0360
-#define PT_F87                  0x0370
-#define PT_F88                  0x0380
-#define PT_F89                  0x0390
-#define PT_F90                  0x03a0
-#define PT_F91                  0x03b0
-#define PT_F92                  0x03c0
-#define PT_F93                  0x03d0
-#define PT_F94                  0x03e0
-#define PT_F95                  0x03f0
-#define PT_F96                  0x0400
-#define PT_F97                  0x0410
-#define PT_F98                  0x0420
-#define PT_F99                  0x0430
-#define PT_F100                 0x0440
-#define PT_F101                 0x0450
-#define PT_F102                 0x0460
-#define PT_F103                 0x0470
-#define PT_F104                 0x0480
-#define PT_F105                 0x0490
-#define PT_F106                 0x04a0
-#define PT_F107                 0x04b0
-#define PT_F108                 0x04c0
-#define PT_F109                 0x04d0
-#define PT_F110                 0x04e0
-#define PT_F111                 0x04f0
-#define PT_F112                 0x0500
-#define PT_F113                 0x0510
-#define PT_F114                 0x0520
-#define PT_F115                 0x0530
-#define PT_F116                 0x0540
-#define PT_F117                 0x0550
-#define PT_F118                 0x0560
-#define PT_F119                 0x0570
-#define PT_F120                 0x0580
-#define PT_F121                 0x0590
-#define PT_F122                 0x05a0
-#define PT_F123                 0x05b0
-#define PT_F124                 0x05c0
-#define PT_F125                 0x05d0
-#define PT_F126                 0x05e0
-#define PT_F127                 0x05f0
-
-#define PT_NAT_BITS             0x0600
-
-#define PT_F2                   0x0610
-#define PT_F3                   0x0620
-#define PT_F4                   0x0630
-#define PT_F5                   0x0640
-#define PT_F10                  0x0650
-#define PT_F11                  0x0660
-#define PT_F12                  0x0670
-#define PT_F13                  0x0680
-#define PT_F14                  0x0690
-#define PT_F15                  0x06a0
-#define PT_F16                  0x06b0
-#define PT_F17                  0x06c0
-#define PT_F18                  0x06d0
-#define PT_F19                  0x06e0
-#define PT_F20                  0x06f0
-#define PT_F21                  0x0700
-#define PT_F22                  0x0710
-#define PT_F23                  0x0720
-#define PT_F24                  0x0730
-#define PT_F25                  0x0740
-#define PT_F26                  0x0750
-#define PT_F27                  0x0760
-#define PT_F28                  0x0770
-#define PT_F29                  0x0780
-#define PT_F30                  0x0790
-#define PT_F31                  0x07a0
-#define PT_R4                   0x07b0
-#define PT_R5                   0x07b8
-#define PT_R6                   0x07c0
-#define PT_R7                   0x07c8
-
-#define PT_B1                   0x07d8
-#define PT_B2                   0x07e0
-#define PT_B3                   0x07e8
-#define PT_B4                   0x07f0
-#define PT_B5                   0x07f8
-
-#define PT_AR_EC                0x0800
-#define PT_AR_LC                0x0808
-
-#define PT_CR_IPSR              0x0830
-#define PT_CR_IIP               0x0838
-#define PT_CFM                  0x0840
-#define PT_AR_UNAT              0x0848
-#define PT_AR_PFS               0x0850
-#define PT_AR_RSC               0x0858
-#define PT_AR_RNAT              0x0860
-#define PT_AR_BSPSTORE          0x0868
-#define PT_PR                   0x0870
-#define PT_B6                   0x0878
-#define PT_AR_BSP               0x0880  /* note: this points to the *end* of the backing store! */
-#define PT_R1                   0x0888
-#define PT_R2                   0x0890
-#define PT_R3                   0x0898
-#define PT_R12                  0x08a0
-#define PT_R13                  0x08a8
-#define PT_R14                  0x08b0
-#define PT_R15                  0x08b8
-#define PT_R8                   0x08c0
-#define PT_R9                   0x08c8
-#define PT_R10                  0x08d0
-#define PT_R11                  0x08d8
-#define PT_R16                  0x08e0
-#define PT_R17                  0x08e8
-#define PT_R18                  0x08f0
-#define PT_R19                  0x08f8
-#define PT_R20                  0x0900
-#define PT_R21                  0x0908
-#define PT_R22                  0x0910
-#define PT_R23                  0x0918
-#define PT_R24                  0x0920
-#define PT_R25                  0x0928
-#define PT_R26                  0x0930
-#define PT_R27                  0x0938
-#define PT_R28                  0x0940
-#define PT_R29                  0x0948
-#define PT_R30                  0x0950
-#define PT_R31                  0x0958
-#define PT_AR_CCV               0x0960
-#define PT_AR_FPSR              0x0968
-#define PT_B0                   0x0970
-#define PT_B7                   0x0978
-#define PT_F6                   0x0980
-#define PT_F7                   0x0990
-#define PT_F8                   0x09a0
-#define PT_F9                   0x09b0
-#define PT_AR_CSD               0x09c0
-#define PT_AR_SSD               0x09c8
-
-#define PT_DBR                  0x2000  /* data breakpoint registers */
-#define PT_IBR                  0x3000  /* instruction breakpoint registers */
-#define PT_PMD                  0x4000  /* performance monitoring counters */
-
-#endif /* _ASM_IA64_PTRACE_OFFSETS_H */
diff --git a/arch/ia64/include/uapi/asm/resource.h b/arch/ia64/include/uapi/asm/resource.h
deleted file mode 100644
index ba2272a87fc..00000000000
--- a/arch/ia64/include/uapi/asm/resource.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef _ASM_IA64_RESOURCE_H
-#define _ASM_IA64_RESOURCE_H
-
-#include <asm/ustack.h>
-#include <asm-generic/resource.h>
-
-#endif /* _ASM_IA64_RESOURCE_H */
diff --git a/arch/ia64/include/uapi/asm/rse.h b/arch/ia64/include/uapi/asm/rse.h
deleted file mode 100644
index 02830a3b019..00000000000
--- a/arch/ia64/include/uapi/asm/rse.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef _ASM_IA64_RSE_H
-#define _ASM_IA64_RSE_H
-
-/*
- * Copyright (C) 1998, 1999 Hewlett-Packard Co
- * Copyright (C) 1998, 1999 David Mosberger-Tang <davidm@hpl.hp.com>
- *
- * Register stack engine related helper functions.  This file may be
- * used in applications, so be careful about the name-space and give
- * some consideration to non-GNU C compilers (though __inline__ is
- * fine).
- */
-
-static __inline__ unsigned long
-ia64_rse_slot_num (unsigned long *addr)
-{
-        return (((unsigned long) addr) >> 3) & 0x3f;
-}
-
-/*
- * Return TRUE if ADDR is the address of an RNAT slot.
- */
-static __inline__ unsigned long
-ia64_rse_is_rnat_slot (unsigned long *addr)
-{
-        return ia64_rse_slot_num(addr) == 0x3f;
-}
-
-/*
- * Returns the address of the RNAT slot that covers the slot at
- * address SLOT_ADDR.
- */
-static __inline__ unsigned long *
-ia64_rse_rnat_addr (unsigned long *slot_addr)
-{
-        return (unsigned long *) ((unsigned long) slot_addr | (0x3f << 3));
-}
-
-/*
- * Calculate the number of registers in the dirty partition starting at BSPSTORE and
- * ending at BSP.  This isn't simply (BSP-BSPSTORE)/8 because every 64th slot stores
- * ar.rnat.
- */
-static __inline__ unsigned long
-ia64_rse_num_regs (unsigned long *bspstore, unsigned long *bsp)
-{
-        unsigned long slots = (bsp - bspstore);
-
-        return slots - (ia64_rse_slot_num(bspstore) + slots)/0x40;
-}
-
-/*
- * The inverse of the above: given bspstore and the number of
- * registers, calculate ar.bsp.
- */
-static __inline__ unsigned long *
-ia64_rse_skip_regs (unsigned long *addr, long num_regs)
-{
-        long delta = ia64_rse_slot_num(addr) + num_regs;
-
-        if (num_regs < 0)
-                delta -= 0x3e;
-        return addr + num_regs + delta/0x3f;
-}
-
-#endif /* _ASM_IA64_RSE_H */
diff --git a/arch/ia64/include/uapi/asm/sembuf.h b/arch/ia64/include/uapi/asm/sembuf.h
deleted file mode 100644
index 1340fbc04d3..00000000000
--- a/arch/ia64/include/uapi/asm/sembuf.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef _ASM_IA64_SEMBUF_H
-#define _ASM_IA64_SEMBUF_H
-
-/*
- * The semid64_ds structure for IA-64 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 2 miscellaneous 64-bit values
- */
-
-struct semid64_ds {
-        struct ipc64_perm sem_perm;             /* permissions .. see ipc.h */
-        __kernel_time_t sem_otime;              /* last semop time */
-        __kernel_time_t sem_ctime;              /* last change time */
-        unsigned long   sem_nsems;              /* no. of semaphores in array */
-        unsigned long   __unused1;
-        unsigned long   __unused2;
-};
-
-#endif /* _ASM_IA64_SEMBUF_H */
diff --git a/arch/ia64/include/uapi/asm/setup.h b/arch/ia64/include/uapi/asm/setup.h
deleted file mode 100644
index 8d56458310b..00000000000
--- a/arch/ia64/include/uapi/asm/setup.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef __IA64_SETUP_H
-#define __IA64_SETUP_H
-
-#define COMMAND_LINE_SIZE       2048
-
-extern struct ia64_boot_param {
-        __u64 command_line;             /* physical address of command line arguments */
-        __u64 efi_systab;               /* physical address of EFI system table */
-        __u64 efi_memmap;               /* physical address of EFI memory map */
-        __u64 efi_memmap_size;          /* size of EFI memory map */
-        __u64 efi_memdesc_size;         /* size of an EFI memory map descriptor */
-        __u32 efi_memdesc_version;      /* memory descriptor version */
-        struct {
-                __u16 num_cols; /* number of columns on console output device */
-                __u16 num_rows; /* number of rows on console output device */
-                __u16 orig_x;   /* cursor's x position */
-                __u16 orig_y;   /* cursor's y position */
-        } console_info;
-        __u64 fpswa;            /* physical address of the fpswa interface */
-        __u64 initrd_start;
-        __u64 initrd_size;
-} *ia64_boot_param;
-
-#endif
diff --git a/arch/ia64/include/uapi/asm/shmbuf.h b/arch/ia64/include/uapi/asm/shmbuf.h
deleted file mode 100644
index 585002a77ac..00000000000
--- a/arch/ia64/include/uapi/asm/shmbuf.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef _ASM_IA64_SHMBUF_H
-#define _ASM_IA64_SHMBUF_H
-
-/*
- * The shmid64_ds structure for IA-64 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 2 miscellaneous 64-bit values
- */
-
-struct shmid64_ds {
-        struct ipc64_perm       shm_perm;       /* operation perms */
-        size_t                  shm_segsz;      /* size of segment (bytes) */
-        __kernel_time_t         shm_atime;      /* last attach time */
-        __kernel_time_t         shm_dtime;      /* last detach time */
-        __kernel_time_t         shm_ctime;      /* last change time */
-        __kernel_pid_t          shm_cpid;       /* pid of creator */
-        __kernel_pid_t          shm_lpid;       /* pid of last operator */
-        unsigned long           shm_nattch;     /* no. of current attaches */
-        unsigned long           __unused1;
-        unsigned long           __unused2;
-};
-
-struct shminfo64 {
-        unsigned long   shmmax;
-        unsigned long   shmmin;
-        unsigned long   shmmni;
-        unsigned long   shmseg;
-        unsigned long   shmall;
-        unsigned long   __unused1;
-        unsigned long   __unused2;
-        unsigned long   __unused3;
-        unsigned long   __unused4;
-};
-
-#endif /* _ASM_IA64_SHMBUF_H */
diff --git a/arch/ia64/include/uapi/asm/sigcontext.h b/arch/ia64/include/uapi/asm/sigcontext.h
deleted file mode 100644
index 57ff777bcc4..00000000000
--- a/arch/ia64/include/uapi/asm/sigcontext.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef _ASM_IA64_SIGCONTEXT_H
-#define _ASM_IA64_SIGCONTEXT_H
-
-/*
- * Copyright (C) 1998, 1999, 2001 Hewlett-Packard Co
- * Copyright (C) 1998, 1999, 2001 David Mosberger-Tang <davidm@hpl.hp.com>
- */
-
-#include <asm/fpu.h>
-
-#define IA64_SC_FLAG_ONSTACK_BIT                0       /* is handler running on signal stack? */
-#define IA64_SC_FLAG_IN_SYSCALL_BIT             1       /* did signal interrupt a syscall? */
-#define IA64_SC_FLAG_FPH_VALID_BIT              2       /* is state in f[32]-f[127] valid? */
-
-#define IA64_SC_FLAG_ONSTACK            (1 << IA64_SC_FLAG_ONSTACK_BIT)
-#define IA64_SC_FLAG_IN_SYSCALL         (1 << IA64_SC_FLAG_IN_SYSCALL_BIT)
-#define IA64_SC_FLAG_FPH_VALID          (1 << IA64_SC_FLAG_FPH_VALID_BIT)
-
-# ifndef __ASSEMBLY__
-
-/*
- * Note on handling of register backing store: sc_ar_bsp contains the address that would
- * be found in ar.bsp after executing a "cover" instruction the context in which the
- * signal was raised.  If signal delivery required switching to an alternate signal stack
- * (sc_rbs_base is not NULL), the "dirty" partition (as it would exist after executing the
- * imaginary "cover" instruction) is backed by the *alternate* signal stack, not the
- * original one.  In this case, sc_rbs_base contains the base address of the new register
- * backing store.  The number of registers in the dirty partition can be calculated as:
- *
- *   ndirty = ia64_rse_num_regs(sc_rbs_base, sc_rbs_base + (sc_loadrs >> 16))
- *
- */
-
-struct sigcontext {
-        unsigned long           sc_flags;       /* see manifest constants above */
-        unsigned long           sc_nat;         /* bit i == 1 iff scratch reg gr[i] is a NaT */
-        stack_t                 sc_stack;       /* previously active stack */
-
-        unsigned long           sc_ip;          /* instruction pointer */
-        unsigned long           sc_cfm;         /* current frame marker */
-        unsigned long           sc_um;          /* user mask bits */
-        unsigned long           sc_ar_rsc;      /* register stack configuration register */
-        unsigned long           sc_ar_bsp;      /* backing store pointer */
-        unsigned long           sc_ar_rnat;     /* RSE NaT collection register */
-        unsigned long           sc_ar_ccv;      /* compare and exchange compare value register */
-        unsigned long           sc_ar_unat;     /* ar.unat of interrupted context */
-        unsigned long           sc_ar_fpsr;     /* floating-point status register */
-        unsigned long           sc_ar_pfs;      /* previous function state */
-        unsigned long           sc_ar_lc;       /* loop count register */
-        unsigned long           sc_pr;          /* predicate registers */
-        unsigned long           sc_br[8];       /* branch registers */
-        /* Note: sc_gr[0] is used as the "uc_link" member of ucontext_t */
-        unsigned long           sc_gr[32];      /* general registers (static partition) */
-        struct ia64_fpreg       sc_fr[128];     /* floating-point registers */
-
-        unsigned long           sc_rbs_base;    /* NULL or new base of sighandler's rbs */
-        unsigned long           sc_loadrs;      /* see description above */
-
-        unsigned long           sc_ar25;        /* cmp8xchg16 uses this */
-        unsigned long           sc_ar26;        /* rsvd for scratch use */
-        unsigned long           sc_rsvd[12];    /* reserved for future use */
-        /*
-         * The mask must come last so we can increase _NSIG_WORDS
-         * without breaking binary compatibility.
-         */
-        sigset_t                sc_mask;        /* signal mask to restore after handler returns */
-};
-
-# endif /* __ASSEMBLY__ */
-#endif /* _ASM_IA64_SIGCONTEXT_H */
diff --git a/arch/ia64/include/uapi/asm/siginfo.h b/arch/ia64/include/uapi/asm/siginfo.h
deleted file mode 100644
index 4ea6225196b..00000000000
--- a/arch/ia64/include/uapi/asm/siginfo.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Based on <asm-i386/siginfo.h>.
- *
- * Modified 1998-2002
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-#ifndef _UAPI_ASM_IA64_SIGINFO_H
-#define _UAPI_ASM_IA64_SIGINFO_H
-
-
-#define __ARCH_SI_PREAMBLE_SIZE (4 * sizeof(int))
-
-#define HAVE_ARCH_SIGINFO_T
-#define HAVE_ARCH_COPY_SIGINFO
-#define HAVE_ARCH_COPY_SIGINFO_TO_USER
-
-#include <asm-generic/siginfo.h>
-
-typedef struct siginfo {
-        int si_signo;
-        int si_errno;
-        int si_code;
-        int __pad0;
-
-        union {
-                int _pad[SI_PAD_SIZE];
-
-                /* kill() */
-                struct {
-                        pid_t _pid;             /* sender's pid */
-                        uid_t _uid;             /* sender's uid */
-                } _kill;
-
-                /* POSIX.1b timers */
-                struct {
-                        timer_t _tid;           /* timer id */
-                        int _overrun;           /* overrun count */
-                        char _pad[sizeof(__ARCH_SI_UID_T) - sizeof(int)];
-                        sigval_t _sigval;       /* must overlay ._rt._sigval! */
-                        int _sys_private;       /* not to be passed to user */
-                } _timer;
-
-                /* POSIX.1b signals */
-                struct {
-                        pid_t _pid;             /* sender's pid */
-                        uid_t _uid;             /* sender's uid */
-                        sigval_t _sigval;
-                } _rt;
-
-                /* SIGCHLD */
-                struct {
-                        pid_t _pid;             /* which child */
-                        uid_t _uid;             /* sender's uid */
-                        int _status;            /* exit code */
-                        clock_t _utime;
-                        clock_t _stime;
-                } _sigchld;
-
-                /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
-                struct {
-                        void __user *_addr;     /* faulting insn/memory ref. */
-                        int _imm;               /* immediate value for "break" */
-                        unsigned int _flags;    /* see below */
-                        unsigned long _isr;     /* isr */
-                        short _addr_lsb;        /* lsb of faulting address */
-                } _sigfault;
-
-                /* SIGPOLL */
-                struct {
-                        long _band;     /* POLL_IN, POLL_OUT, POLL_MSG (XPG requires a "long") */
-                        int _fd;
-                } _sigpoll;
-        } _sifields;
-} siginfo_t;
-
-#define si_imm          _sifields._sigfault._imm        /* as per UNIX SysV ABI spec */
-#define si_flags        _sifields._sigfault._flags
-/*
- * si_isr is valid for SIGILL, SIGFPE, SIGSEGV, SIGBUS, and SIGTRAP provided that
- * si_code is non-zero and __ISR_VALID is set in si_flags.
- */
-#define si_isr          _sifields._sigfault._isr
-
-/*
- * Flag values for si_flags:
- */
-#define __ISR_VALID_BIT 0
-#define __ISR_VALID     (1 << __ISR_VALID_BIT)
-
-/*
- * SIGILL si_codes
- */
-#define ILL_BADIADDR    (__SI_FAULT|9)  /* unimplemented instruction address */
-#define __ILL_BREAK     (__SI_FAULT|10) /* illegal break */
-#define __ILL_BNDMOD    (__SI_FAULT|11) /* bundle-update (modification) in progress */
-#undef NSIGILL
-#define NSIGILL         11
-
-/*
- * SIGFPE si_codes
- */
-#define __FPE_DECOVF    (__SI_FAULT|9)  /* decimal overflow */
-#define __FPE_DECDIV    (__SI_FAULT|10) /* decimal division by zero */
-#define __FPE_DECERR    (__SI_FAULT|11) /* packed decimal error */
-#define __FPE_INVASC    (__SI_FAULT|12) /* invalid ASCII digit */
-#define __FPE_INVDEC    (__SI_FAULT|13) /* invalid decimal digit */
-#undef NSIGFPE
-#define NSIGFPE         13
-
-/*
- * SIGSEGV si_codes
- */
-#define __SEGV_PSTKOVF  (__SI_FAULT|3)  /* paragraph stack overflow */
-#undef NSIGSEGV
-#define NSIGSEGV        3
-
-#undef NSIGTRAP
-#define NSIGTRAP        4
-
-
-#endif /* _UAPI_ASM_IA64_SIGINFO_H */
diff --git a/arch/ia64/include/uapi/asm/signal.h b/arch/ia64/include/uapi/asm/signal.h
deleted file mode 100644
index c0ea2855e96..00000000000
--- a/arch/ia64/include/uapi/asm/signal.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Modified 1998-2001, 2003
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- *
- * Unfortunately, this file is being included by bits/signal.h in
- * glibc-2.x.  Hence the #ifdef __KERNEL__ ugliness.
- */
-#ifndef _UAPI_ASM_IA64_SIGNAL_H
-#define _UAPI_ASM_IA64_SIGNAL_H
-
-
-#define SIGHUP           1
-#define SIGINT           2
-#define SIGQUIT          3
-#define SIGILL           4
-#define SIGTRAP          5
-#define SIGABRT          6
-#define SIGIOT           6
-#define SIGBUS           7
-#define SIGFPE           8
-#define SIGKILL          9
-#define SIGUSR1         10
-#define SIGSEGV         11
-#define SIGUSR2         12
-#define SIGPIPE         13
-#define SIGALRM         14
-#define SIGTERM         15
-#define SIGSTKFLT       16
-#define SIGCHLD         17
-#define SIGCONT         18
-#define SIGSTOP         19
-#define SIGTSTP         20
-#define SIGTTIN         21
-#define SIGTTOU         22
-#define SIGURG          23
-#define SIGXCPU         24
-#define SIGXFSZ         25
-#define SIGVTALRM       26
-#define SIGPROF         27
-#define SIGWINCH        28
-#define SIGIO           29
-#define SIGPOLL         SIGIO
-/*
-#define SIGLOST         29
-*/
-#define SIGPWR          30
-#define SIGSYS          31
-/* signal 31 is no longer "unused", but the SIGUNUSED macro remains for backwards compatibility */
-#define SIGUNUSED       31
-
-/* These should not be considered constants from userland.  */
-#define SIGRTMIN        32
-#define SIGRTMAX        _NSIG
-
-/*
- * SA_FLAGS values:
- *
- * SA_ONSTACK indicates that a registered stack_t will be used.
- * SA_RESTART flag to get restarting signals (which were the default long ago)
- * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
- * SA_RESETHAND clears the handler when the signal is delivered.
- * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
- * SA_NODEFER prevents the current signal from being masked in the handler.
- *
- * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
- * Unix names RESETHAND and NODEFER respectively.
- */
-#define SA_NOCLDSTOP    0x00000001
-#define SA_NOCLDWAIT    0x00000002
-#define SA_SIGINFO      0x00000004
-#define SA_ONSTACK      0x08000000
-#define SA_RESTART      0x10000000
-#define SA_NODEFER      0x40000000
-#define SA_RESETHAND    0x80000000
-
-#define SA_NOMASK       SA_NODEFER
-#define SA_ONESHOT      SA_RESETHAND
-
-#define SA_RESTORER     0x04000000
-
-/*
- * The minimum stack size needs to be fairly large because we want to
- * be sure that an app compiled for today's CPUs will continue to run
- * on all future CPU models.  The CPU model matters because the signal
- * frame needs to have space for the complete machine state, including
- * all physical stacked registers.  The number of physical stacked
- * registers is CPU model dependent, but given that the width of
- * ar.rsc.loadrs is 14 bits, we can assume that they'll never take up
- * more than 16KB of space.
- */
-#if 1
-  /*
-   * This is a stupid typo: the value was _meant_ to be 131072 (0x20000), but I typed it
-   * in wrong. ;-(  To preserve backwards compatibility, we leave the kernel at the
-   * incorrect value and fix libc only.
-   */
-# define MINSIGSTKSZ    131027  /* min. stack size for sigaltstack() */
-#else
-# define MINSIGSTKSZ    131072  /* min. stack size for sigaltstack() */
-#endif
-#define SIGSTKSZ        262144  /* default stack size for sigaltstack() */
-
-
-#include <asm-generic/signal-defs.h>
-
-# ifndef __ASSEMBLY__
-
-#  include <linux/types.h>
-
-/* Avoid too many header ordering problems.  */
-struct siginfo;
-
-typedef struct sigaltstack {
-        void __user *ss_sp;
-        int ss_flags;
-        size_t ss_size;
-} stack_t;
-
-
-# endif /* !__ASSEMBLY__ */
-#endif /* _UAPI_ASM_IA64_SIGNAL_H */
diff --git a/arch/ia64/include/uapi/asm/socket.h b/arch/ia64/include/uapi/asm/socket.h
deleted file mode 100644
index 23d6759bb57..00000000000
--- a/arch/ia64/include/uapi/asm/socket.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef _ASM_IA64_SOCKET_H
-#define _ASM_IA64_SOCKET_H
-
-/*
- * Socket related defines.
- *
- * Based on <asm-i386/socket.h>.
- *
- * Modified 1998-2000
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-
-#include <asm/sockios.h>
-
-/* For setsockopt(2) */
-#define SOL_SOCKET      1
-
-#define SO_DEBUG        1
-#define SO_REUSEADDR    2
-#define SO_TYPE         3
-#define SO_ERROR        4
-#define SO_DONTROUTE    5
-#define SO_BROADCAST    6
-#define SO_SNDBUF       7
-#define SO_RCVBUF       8
-#define SO_SNDBUFFORCE  32
-#define SO_RCVBUFFORCE  33
-#define SO_KEEPALIVE    9
-#define SO_OOBINLINE    10
-#define SO_NO_CHECK     11
-#define SO_PRIORITY     12
-#define SO_LINGER       13
-#define SO_BSDCOMPAT    14
-/* To add :#define SO_REUSEPORT 15 */
-#define SO_PASSCRED     16
-#define SO_PEERCRED     17
-#define SO_RCVLOWAT     18
-#define SO_SNDLOWAT     19
-#define SO_RCVTIMEO     20
-#define SO_SNDTIMEO     21
-
-/* Security levels - as per NRL IPv6 - don't actually do anything */
-#define SO_SECURITY_AUTHENTICATION              22
-#define SO_SECURITY_ENCRYPTION_TRANSPORT        23
-#define SO_SECURITY_ENCRYPTION_NETWORK          24
-
-#define SO_BINDTODEVICE         25
-
-/* Socket filtering */
-#define SO_ATTACH_FILTER        26
-#define SO_DETACH_FILTER        27
-#define SO_GET_FILTER           SO_ATTACH_FILTER
-
-#define SO_PEERNAME             28
-#define SO_TIMESTAMP            29
-#define SCM_TIMESTAMP           SO_TIMESTAMP
-
-#define SO_ACCEPTCONN           30
-
-#define SO_PEERSEC             31
-#define SO_PASSSEC              34
-#define SO_TIMESTAMPNS          35
-#define SCM_TIMESTAMPNS         SO_TIMESTAMPNS
-
-#define SO_MARK                 36
-
-#define SO_TIMESTAMPING         37
-#define SCM_TIMESTAMPING        SO_TIMESTAMPING
-
-#define SO_PROTOCOL             38
-#define SO_DOMAIN               39
-
-#define SO_RXQ_OVFL             40
-
-#define SO_WIFI_STATUS          41
-#define SCM_WIFI_STATUS         SO_WIFI_STATUS
-#define SO_PEEK_OFF             42
-
-/* Instruct lower device to use last 4-bytes of skb data as FCS */
-#define SO_NOFCS                43
-
-#endif /* _ASM_IA64_SOCKET_H */
diff --git a/arch/ia64/include/uapi/asm/sockios.h b/arch/ia64/include/uapi/asm/sockios.h
deleted file mode 100644
index 15c92468ad3..00000000000
--- a/arch/ia64/include/uapi/asm/sockios.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef _ASM_IA64_SOCKIOS_H
-#define _ASM_IA64_SOCKIOS_H
-
-/*
- * Socket-level I/O control calls.
- *
- * Based on <asm-i386/sockios.h>.
- *
- * Modified 1998, 1999
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-#define FIOSETOWN       0x8901
-#define SIOCSPGRP       0x8902
-#define FIOGETOWN       0x8903
-#define SIOCGPGRP       0x8904
-#define SIOCATMARK      0x8905
-#define SIOCGSTAMP      0x8906          /* Get stamp (timeval) */
-#define SIOCGSTAMPNS    0x8907          /* Get stamp (timespec) */
-
-#endif /* _ASM_IA64_SOCKIOS_H */
diff --git a/arch/ia64/include/uapi/asm/stat.h b/arch/ia64/include/uapi/asm/stat.h
deleted file mode 100644
index 367bb90cdff..00000000000
--- a/arch/ia64/include/uapi/asm/stat.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef _ASM_IA64_STAT_H
-#define _ASM_IA64_STAT_H
-
-/*
- * Modified 1998, 1999
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-
-struct stat {
-        unsigned long   st_dev;
-        unsigned long   st_ino;
-        unsigned long   st_nlink;
-        unsigned int    st_mode;
-        unsigned int    st_uid;
-        unsigned int    st_gid;
-        unsigned int    __pad0;
-        unsigned long   st_rdev;
-        unsigned long   st_size;
-        unsigned long   st_atime;
-        unsigned long   st_atime_nsec;
-        unsigned long   st_mtime;
-        unsigned long   st_mtime_nsec;
-        unsigned long   st_ctime;
-        unsigned long   st_ctime_nsec;
-        unsigned long   st_blksize;
-        long            st_blocks;
-        unsigned long   __unused[3];
-};
-
-#define STAT_HAVE_NSEC 1
-
-struct ia64_oldstat {
-        unsigned int    st_dev;
-        unsigned int    st_ino;
-        unsigned int    st_mode;
-        unsigned int    st_nlink;
-        unsigned int    st_uid;
-        unsigned int    st_gid;
-        unsigned int    st_rdev;
-        unsigned int    __pad1;
-        unsigned long   st_size;
-        unsigned long   st_atime;
-        unsigned long   st_mtime;
-        unsigned long   st_ctime;
-        unsigned int    st_blksize;
-        int             st_blocks;
-        unsigned int    __unused1;
-        unsigned int    __unused2;
-};
-
-#endif /* _ASM_IA64_STAT_H */
diff --git a/arch/ia64/include/uapi/asm/statfs.h b/arch/ia64/include/uapi/asm/statfs.h
deleted file mode 100644
index 1e589669de5..00000000000
--- a/arch/ia64/include/uapi/asm/statfs.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef _ASM_IA64_STATFS_H
-#define _ASM_IA64_STATFS_H
-
-/*
- * Based on <asm-i386/statfs.h>.
- *
- * Modified 1998, 1999, 2003
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-
-/*
- * We need compat_statfs64 to be packed, because the i386 ABI won't
- * add padding at the end to bring it to a multiple of 8 bytes, but
- * the IA64 ABI will.
- */
-#define ARCH_PACK_COMPAT_STATFS64 __attribute__((packed,aligned(4)))
-
-#include <asm-generic/statfs.h>
-
-#endif /* _ASM_IA64_STATFS_H */
diff --git a/arch/ia64/include/uapi/asm/swab.h b/arch/ia64/include/uapi/asm/swab.h
deleted file mode 100644
index c89a8cb5d8a..00000000000
--- a/arch/ia64/include/uapi/asm/swab.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef _ASM_IA64_SWAB_H
-#define _ASM_IA64_SWAB_H
-
-/*
- * Modified 1998, 1999
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co.
- */
-
-#include <linux/types.h>
-#include <asm/intrinsics.h>
-#include <linux/compiler.h>
-
-static __inline__ __attribute_const__ __u64 __arch_swab64(__u64 x)
-{
-        __u64 result;
-
-        result = ia64_mux1(x, ia64_mux1_rev);
-        return result;
-}
-#define __arch_swab64 __arch_swab64
-
-static __inline__ __attribute_const__ __u32 __arch_swab32(__u32 x)
-{
-        return __arch_swab64(x) >> 32;
-}
-#define __arch_swab32 __arch_swab32
-
-static __inline__ __attribute_const__ __u16 __arch_swab16(__u16 x)
-{
-        return __arch_swab64(x) >> 48;
-}
-#define __arch_swab16 __arch_swab16
-
-#endif /* _ASM_IA64_SWAB_H */
diff --git a/arch/ia64/include/uapi/asm/termbits.h b/arch/ia64/include/uapi/asm/termbits.h
deleted file mode 100644
index c009b94e58d..00000000000
--- a/arch/ia64/include/uapi/asm/termbits.h
+++ /dev/null
@@ -1,208 +0,0 @@
-#ifndef _ASM_IA64_TERMBITS_H
-#define _ASM_IA64_TERMBITS_H
-
-/*
- * Based on <asm-i386/termbits.h>.
- *
- * Modified 1999
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- *
- * 99/01/28     Added new baudrates
- */
-
-#include <linux/posix_types.h>
-
-typedef unsigned char   cc_t;
-typedef unsigned int    speed_t;
-typedef unsigned int    tcflag_t;
-
-#define NCCS 19
-struct termios {
-        tcflag_t c_iflag;               /* input mode flags */
-        tcflag_t c_oflag;               /* output mode flags */
-        tcflag_t c_cflag;               /* control mode flags */
-        tcflag_t c_lflag;               /* local mode flags */
-        cc_t c_line;                    /* line discipline */
-        cc_t c_cc[NCCS];                /* control characters */
-};
-
-struct termios2 {
-        tcflag_t c_iflag;               /* input mode flags */
-        tcflag_t c_oflag;               /* output mode flags */
-        tcflag_t c_cflag;               /* control mode flags */
-        tcflag_t c_lflag;               /* local mode flags */
-        cc_t c_line;                    /* line discipline */
-        cc_t c_cc[NCCS];                /* control characters */
-        speed_t c_ispeed;               /* input speed */
-        speed_t c_ospeed;               /* output speed */
-};
-
-struct ktermios {
-        tcflag_t c_iflag;               /* input mode flags */
-        tcflag_t c_oflag;               /* output mode flags */
-        tcflag_t c_cflag;               /* control mode flags */
-        tcflag_t c_lflag;               /* local mode flags */
-        cc_t c_line;                    /* line discipline */
-        cc_t c_cc[NCCS];                /* control characters */
-        speed_t c_ispeed;               /* input speed */
-        speed_t c_ospeed;               /* output speed */
-};
-
-/* c_cc characters */
-#define VINTR 0
-#define VQUIT 1
-#define VERASE 2
-#define VKILL 3
-#define VEOF 4
-#define VTIME 5
-#define VMIN 6
-#define VSWTC 7
-#define VSTART 8
-#define VSTOP 9
-#define VSUSP 10
-#define VEOL 11
-#define VREPRINT 12
-#define VDISCARD 13
-#define VWERASE 14
-#define VLNEXT 15
-#define VEOL2 16
-
-/* c_iflag bits */
-#define IGNBRK  0000001
-#define BRKINT  0000002
-#define IGNPAR  0000004
-#define PARMRK  0000010
-#define INPCK   0000020
-#define ISTRIP  0000040
-#define INLCR   0000100
-#define IGNCR   0000200
-#define ICRNL   0000400
-#define IUCLC   0001000
-#define IXON    0002000
-#define IXANY   0004000
-#define IXOFF   0010000
-#define IMAXBEL 0020000
-#define IUTF8   0040000
-
-/* c_oflag bits */
-#define OPOST   0000001
-#define OLCUC   0000002
-#define ONLCR   0000004
-#define OCRNL   0000010
-#define ONOCR   0000020
-#define ONLRET  0000040
-#define OFILL   0000100
-#define OFDEL   0000200
-#define NLDLY   0000400
-#define   NL0   0000000
-#define   NL1   0000400
-#define CRDLY   0003000
-#define   CR0   0000000
-#define   CR1   0001000
-#define   CR2   0002000
-#define   CR3   0003000
-#define TABDLY  0014000
-#define   TAB0  0000000
-#define   TAB1  0004000
-#define   TAB2  0010000
-#define   TAB3  0014000
-#define   XTABS 0014000
-#define BSDLY   0020000
-#define   BS0   0000000
-#define   BS1   0020000
-#define VTDLY   0040000
-#define   VT0   0000000
-#define   VT1   0040000
-#define FFDLY   0100000
-#define   FF0   0000000
-#define   FF1   0100000
-
-/* c_cflag bit meaning */
-#define CBAUD   0010017
-#define  B0     0000000         /* hang up */
-#define  B50    0000001
-#define  B75    0000002
-#define  B110   0000003
-#define  B134   0000004
-#define  B150   0000005
-#define  B200   0000006
-#define  B300   0000007
-#define  B600   0000010
-#define  B1200  0000011
-#define  B1800  0000012
-#define  B2400  0000013
-#define  B4800  0000014
-#define  B9600  0000015
-#define  B19200 0000016
-#define  B38400 0000017
-#define EXTA B19200
-#define EXTB B38400
-#define CSIZE   0000060
-#define   CS5   0000000
-#define   CS6   0000020
-#define   CS7   0000040
-#define   CS8   0000060
-#define CSTOPB  0000100
-#define CREAD   0000200
-#define PARENB  0000400
-#define PARODD  0001000
-#define HUPCL   0002000
-#define CLOCAL  0004000
-#define CBAUDEX 0010000
-#define    BOTHER 0010000
-#define    B57600 0010001
-#define   B115200 0010002
-#define   B230400 0010003
-#define   B460800 0010004
-#define   B500000 0010005
-#define   B576000 0010006
-#define   B921600 0010007
-#define  B1000000 0010010
-#define  B1152000 0010011
-#define  B1500000 0010012
-#define  B2000000 0010013
-#define  B2500000 0010014
-#define  B3000000 0010015
-#define  B3500000 0010016
-#define  B4000000 0010017
-#define CIBAUD    002003600000          /* input baud rate */
-#define CMSPAR    010000000000          /* mark or space (stick) parity */
-#define CRTSCTS   020000000000          /* flow control */
-
-#define IBSHIFT 16              /* Shift from CBAUD to CIBAUD */
-
-/* c_lflag bits */
-#define ISIG    0000001
-#define ICANON  0000002
-#define XCASE   0000004
-#define ECHO    0000010
-#define ECHOE   0000020
-#define ECHOK   0000040
-#define ECHONL  0000100
-#define NOFLSH  0000200
-#define TOSTOP  0000400
-#define ECHOCTL 0001000
-#define ECHOPRT 0002000
-#define ECHOKE  0004000
-#define FLUSHO  0010000
-#define PENDIN  0040000
-#define IEXTEN  0100000
-#define EXTPROC 0200000
-
-/* tcflow() and TCXONC use these */
-#define TCOOFF          0
-#define TCOON           1
-#define TCIOFF          2
-#define TCION           3
-
-/* tcflush() and TCFLSH use these */
-#define TCIFLUSH        0
-#define TCOFLUSH        1
-#define TCIOFLUSH       2
-
-/* tcsetattr uses these */
-#define TCSANOW         0
-#define TCSADRAIN       1
-#define TCSAFLUSH       2
-
-#endif /* _ASM_IA64_TERMBITS_H */
diff --git a/arch/ia64/include/uapi/asm/termios.h b/arch/ia64/include/uapi/asm/termios.h
deleted file mode 100644
index d59b48c307f..00000000000
--- a/arch/ia64/include/uapi/asm/termios.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Modified 1999
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- *
- * 99/01/28     Added N_IRDA and N_SMSBLOCK
- */
-#ifndef _UAPI_ASM_IA64_TERMIOS_H
-#define _UAPI_ASM_IA64_TERMIOS_H
-
-
-#include <asm/termbits.h>
-#include <asm/ioctls.h>
-
-struct winsize {
-        unsigned short ws_row;
-        unsigned short ws_col;
-        unsigned short ws_xpixel;
-        unsigned short ws_ypixel;
-};
-
-#define NCC 8
-struct termio {
-        unsigned short c_iflag;         /* input mode flags */
-        unsigned short c_oflag;         /* output mode flags */
-        unsigned short c_cflag;         /* control mode flags */
-        unsigned short c_lflag;         /* local mode flags */
-        unsigned char c_line;           /* line discipline */
-        unsigned char c_cc[NCC];        /* control characters */
-};
-
-/* modem lines */
-#define TIOCM_LE        0x001
-#define TIOCM_DTR       0x002
-#define TIOCM_RTS       0x004
-#define TIOCM_ST        0x008
-#define TIOCM_SR        0x010
-#define TIOCM_CTS       0x020
-#define TIOCM_CAR       0x040
-#define TIOCM_RNG       0x080
-#define TIOCM_DSR       0x100
-#define TIOCM_CD        TIOCM_CAR
-#define TIOCM_RI        TIOCM_RNG
-#define TIOCM_OUT1      0x2000
-#define TIOCM_OUT2      0x4000
-#define TIOCM_LOOP      0x8000
-
-/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
-
-
-#endif /* _UAPI_ASM_IA64_TERMIOS_H */
diff --git a/arch/ia64/include/uapi/asm/types.h b/arch/ia64/include/uapi/asm/types.h
deleted file mode 100644
index 321193b05ee..00000000000
--- a/arch/ia64/include/uapi/asm/types.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * This file is never included by application software unless explicitly
- * requested (e.g., via linux/types.h) in which case the application is
- * Linux specific so (user-) name space pollution is not a major issue.
- * However, for interoperability, libraries still need to be careful to
- * avoid naming clashes.
- *
- * Based on <asm-alpha/types.h>.
- *
- * Modified 1998-2000, 2002
- *      David Mosberger-Tang <davidm@hpl.hp.com>, Hewlett-Packard Co
- */
-#ifndef _UAPI_ASM_IA64_TYPES_H
-#define _UAPI_ASM_IA64_TYPES_H
-
-
-#ifndef __KERNEL__
-#include <asm-generic/int-l64.h>
-#endif
-
-#ifdef __ASSEMBLY__
-# define __IA64_UL(x)           (x)
-# define __IA64_UL_CONST(x)     x
-
-#else
-# define __IA64_UL(x)           ((unsigned long)(x))
-# define __IA64_UL_CONST(x)     x##UL
-
-#endif /* !__ASSEMBLY__ */
-
-#endif /* _UAPI_ASM_IA64_TYPES_H */
diff --git a/arch/ia64/include/uapi/asm/ucontext.h b/arch/ia64/include/uapi/asm/ucontext.h
deleted file mode 100644
index bf573dc8ca6..00000000000
--- a/arch/ia64/include/uapi/asm/ucontext.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef _ASM_IA64_UCONTEXT_H
-#define _ASM_IA64_UCONTEXT_H
-
-struct ucontext {
-        struct sigcontext uc_mcontext;
-};
-
-#define uc_link         uc_mcontext.sc_gr[0]    /* wrong type; nobody cares */
-#define uc_sigmask      uc_mcontext.sc_sigmask
-#define uc_stack        uc_mcontext.sc_stack
-
-#endif /* _ASM_IA64_UCONTEXT_H */
diff --git a/arch/ia64/include/uapi/asm/unistd.h b/arch/ia64/include/uapi/asm/unistd.h
deleted file mode 100644
index 34fd6fe46da..00000000000
--- a/arch/ia64/include/uapi/asm/unistd.h
+++ /dev/null
@@ -1,329 +0,0 @@
-/*
- * IA-64 Linux syscall numbers and inline-functions.
- *
- * Copyright (C) 1998-2005 Hewlett-Packard Co
- *      David Mosberger-Tang <davidm@hpl.hp.com>
- */
-#ifndef _UAPI_ASM_IA64_UNISTD_H
-#define _UAPI_ASM_IA64_UNISTD_H
-
-
-#include <asm/break.h>
-
-#define __BREAK_SYSCALL                 __IA64_BREAK_SYSCALL
-
-#define __NR_ni_syscall                 1024
-#define __NR_exit                       1025
-#define __NR_read                       1026
-#define __NR_write                      1027
-#define __NR_open                       1028
-#define __NR_close                      1029
-#define __NR_creat                      1030
-#define __NR_link                       1031
-#define __NR_unlink                     1032
-#define __NR_execve                     1033
-#define __NR_chdir                      1034
-#define __NR_fchdir                     1035
-#define __NR_utimes                     1036
-#define __NR_mknod                      1037
-#define __NR_chmod                      1038
-#define __NR_chown                      1039
-#define __NR_lseek                      1040
-#define __NR_getpid                     1041
-#define __NR_getppid                    1042
-#define __NR_mount                      1043
-#define __NR_umount                     1044
-#define __NR_setuid                     1045
-#define __NR_getuid                     1046
-#define __NR_geteuid                    1047
-#define __NR_ptrace                     1048
-#define __NR_access                     1049
-#define __NR_sync                       1050
-#define __NR_fsync                      1051
-#define __NR_fdatasync                  1052
-#define __NR_kill                       1053
-#define __NR_rename                     1054
-#define __NR_mkdir                      1055
-#define __NR_rmdir                      1056
-#define __NR_dup                        1057
-#define __NR_pipe                       1058
-#define __NR_times                      1059
-#define __NR_brk                        1060
-#define __NR_setgid                     1061
-#define __NR_getgid                     1062
-#define __NR_getegid                    1063
-#define __NR_acct                       1064
-#define __NR_ioctl                      1065
-#define __NR_fcntl                      1066
-#define __NR_umask                      1067
-#define __NR_chroot                     1068
-#define __NR_ustat                      1069
-#define __NR_dup2                       1070
-#define __NR_setreuid                   1071
-#define __NR_setregid                   1072
-#define __NR_getresuid                  1073
-#define __NR_setresuid                  1074
-#define __NR_getresgid                  1075
-#define __NR_setresgid                  1076
-#define __NR_getgroups                  1077
-#define __NR_setgroups                  1078
-#define __NR_getpgid                    1079
-#define __NR_setpgid                    1080
-#define __NR_setsid                     1081
-#define __NR_getsid                     1082
-#define __NR_sethostname                1083
-#define __NR_setrlimit                  1084
-#define __NR_getrlimit                  1085
-#define __NR_getrusage                  1086
-#define __NR_gettimeofday               1087
-#define __NR_settimeofday               1088
-#define __NR_select                     1089
-#define __NR_poll                       1090
-#define __NR_symlink                    1091
-#define __NR_readlink                   1092
-#define __NR_uselib                     1093
-#define __NR_swapon                     1094
-#define __NR_swapoff                    1095
-#define __NR_reboot                     1096
-#define __NR_truncate                   1097
-#define __NR_ftruncate                  1098
-#define __NR_fchmod                     1099
-#define __NR_fchown                     1100
-#define __NR_getpriority                1101
-#define __NR_setpriority                1102
-#define __NR_statfs                     1103
-#define __NR_fstatfs                    1104
-#define __NR_gettid                     1105
-#define __NR_semget                     1106
-#define __NR_semop                      1107
-#define __NR_semctl                     1108
-#define __NR_msgget                     1109
-#define __NR_msgsnd                     1110
-#define __NR_msgrcv                     1111
-#define __NR_msgctl                     1112
-#define __NR_shmget                     1113
-#define __NR_shmat                      1114
-#define __NR_shmdt                      1115
-#define __NR_shmctl                     1116
-/* also known as klogctl() in GNU libc: */
-#define __NR_syslog                     1117
-#define __NR_setitimer                  1118
-#define __NR_getitimer                  1119
-/* 1120 was __NR_old_stat */
-/* 1121 was __NR_old_lstat */
-/* 1122 was __NR_old_fstat */
-#define __NR_vhangup                    1123
-#define __NR_lchown                     1124
-#define __NR_remap_file_pages           1125
-#define __NR_wait4                      1126
-#define __NR_sysinfo                    1127
-#define __NR_clone                      1128
-#define __NR_setdomainname              1129
-#define __NR_uname                      1130
-#define __NR_adjtimex                   1131
-/* 1132 was __NR_create_module */
-#define __NR_init_module                1133
-#define __NR_delete_module              1134
-/* 1135 was __NR_get_kernel_syms */
-/* 1136 was __NR_query_module */
-#define __NR_quotactl                   1137
-#define __NR_bdflush                    1138
-#define __NR_sysfs                      1139
-#define __NR_personality                1140
-#define __NR_afs_syscall                1141
-#define __NR_setfsuid                   1142
-#define __NR_setfsgid                   1143
-#define __NR_getdents                   1144
-#define __NR_flock                      1145
-#define __NR_readv                      1146
-#define __NR_writev                     1147
-#define __NR_pread64                    1148
-#define __NR_pwrite64                   1149
-#define __NR__sysctl                    1150
-#define __NR_mmap                       1151
-#define __NR_munmap                     1152
-#define __NR_mlock                      1153
-#define __NR_mlockall                   1154
-#define __NR_mprotect                   1155
-#define __NR_mremap                     1156
-#define __NR_msync                      1157
-#define __NR_munlock                    1158
-#define __NR_munlockall                 1159
-#define __NR_sched_getparam             1160
-#define __NR_sched_setparam             1161
-#define __NR_sched_getscheduler         1162
-#define __NR_sched_setscheduler         1163
-#define __NR_sched_yield                1164
-#define __NR_sched_get_priority_max     1165
-#define __NR_sched_get_priority_min     1166
-#define __NR_sched_rr_get_interval      1167
-#define __NR_nanosleep                  1168
-#define __NR_nfsservctl                 1169
-#define __NR_prctl                      1170
-/* 1171 is reserved for backwards compatibility with old __NR_getpagesize */
-#define __NR_mmap2                      1172
-#define __NR_pciconfig_read             1173
-#define __NR_pciconfig_write            1174
-#define __NR_perfmonctl                 1175
-#define __NR_sigaltstack                1176
-#define __NR_rt_sigaction               1177
-#define __NR_rt_sigpending              1178
-#define __NR_rt_sigprocmask             1179
-#define __NR_rt_sigqueueinfo            1180
-#define __NR_rt_sigreturn               1181
-#define __NR_rt_sigsuspend              1182
-#define __NR_rt_sigtimedwait            1183
-#define __NR_getcwd                     1184
-#define __NR_capget                     1185
-#define __NR_capset                     1186
-#define __NR_sendfile                   1187
-#define __NR_getpmsg                    1188
-#define __NR_putpmsg                    1189
-#define __NR_socket                     1190
-#define __NR_bind                       1191
-#define __NR_connect                    1192
-#define __NR_listen                     1193
-#define __NR_accept                     1194
-#define __NR_getsockname                1195
-#define __NR_getpeername                1196
-#define __NR_socketpair                 1197
-#define __NR_send                       1198
-#define __NR_sendto                     1199
-#define __NR_recv                       1200
-#define __NR_recvfrom                   1201
-#define __NR_shutdown                   1202
-#define __NR_setsockopt                 1203
-#define __NR_getsockopt                 1204
-#define __NR_sendmsg                    1205
-#define __NR_recvmsg                    1206
-#define __NR_pivot_root                 1207
-#define __NR_mincore                    1208
-#define __NR_madvise                    1209
-#define __NR_stat                       1210
-#define __NR_lstat                      1211
-#define __NR_fstat                      1212
-#define __NR_clone2                     1213
-#define __NR_getdents64                 1214
-#define __NR_getunwind                  1215
-#define __NR_readahead                  1216
-#define __NR_setxattr                   1217
-#define __NR_lsetxattr                  1218
-#define __NR_fsetxattr                  1219
-#define __NR_getxattr                   1220
-#define __NR_lgetxattr                  1221
-#define __NR_fgetxattr                  1222
-#define __NR_listxattr                  1223
-#define __NR_llistxattr                 1224
-#define __NR_flistxattr                 1225
-#define __NR_removexattr                1226
-#define __NR_lremovexattr               1227
-#define __NR_fremovexattr               1228
-#define __NR_tkill                      1229
-#define __NR_futex                      1230
-#define __NR_sched_setaffinity          1231
-#define __NR_sched_getaffinity          1232
-#define __NR_set_tid_address            1233
-#define __NR_fadvise64                  1234
-#define __NR_tgkill                     1235
-#define __NR_exit_group                 1236
-#define __NR_lookup_dcookie             1237
-#define __NR_io_setup                   1238
-#define __NR_io_destroy                 1239
-#define __NR_io_getevents               1240
-#define __NR_io_submit                  1241
-#define __NR_io_cancel                  1242
-#define __NR_epoll_create               1243
-#define __NR_epoll_ctl                  1244
-#define __NR_epoll_wait                 1245
-#define __NR_restart_syscall            1246
-#define __NR_semtimedop                 1247
-#define __NR_timer_create               1248
-#define __NR_timer_settime              1249
-#define __NR_timer_gettime              1250
-#define __NR_timer_getoverrun           1251
-#define __NR_timer_delete               1252
-#define __NR_clock_settime              1253
-#define __NR_clock_gettime              1254
-#define __NR_clock_getres               1255
-#define __NR_clock_nanosleep            1256
-#define __NR_fstatfs64                  1257
-#define __NR_statfs64                   1258
-#define __NR_mbind                      1259
-#define __NR_get_mempolicy              1260
-#define __NR_set_mempolicy              1261
-#define __NR_mq_open                    1262
-#define __NR_mq_unlink                  1263
-#define __NR_mq_timedsend               1264
-#define __NR_mq_timedreceive            1265
-#define __NR_mq_notify                  1266
-#define __NR_mq_getsetattr              1267
-#define __NR_kexec_load                 1268
-#define __NR_vserver                    1269
-#define __NR_waitid                     1270
-#define __NR_add_key                    1271
-#define __NR_request_key                1272
-#define __NR_keyctl                     1273
-#define __NR_ioprio_set                 1274
-#define __NR_ioprio_get                 1275
-#define __NR_move_pages                 1276
-#define __NR_inotify_init               1277
-#define __NR_inotify_add_watch          1278
-#define __NR_inotify_rm_watch           1279
-#define __NR_migrate_pages              1280
-#define __NR_openat                     1281
-#define __NR_mkdirat                    1282
-#define __NR_mknodat                    1283
-#define __NR_fchownat                   1284
-#define __NR_futimesat                  1285
-#define __NR_newfstatat                 1286
-#define __NR_unlinkat                   1287
-#define __NR_renameat                   1288
-#define __NR_linkat                     1289
-#define __NR_symlinkat                  1290
-#define __NR_readlinkat                 1291
-#define __NR_fchmodat                   1292
-#define __NR_faccessat                  1293
-#define __NR_pselect6                   1294
-#define __NR_ppoll                      1295
-#define __NR_unshare                    1296
-#define __NR_splice                     1297
-#define __NR_set_robust_list            1298
-#define __NR_get_robust_list            1299
-#define __NR_sync_file_range            1300
-#define __NR_tee                        1301
-#define __NR_vmsplice                   1302
-#define __NR_fallocate                  1303
-#define __NR_getcpu                     1304
-#define __NR_epoll_pwait                1305
-#define __NR_utimensat                  1306
-#define __NR_signalfd                   1307
-#define __NR_timerfd                    1308
-#define __NR_eventfd                    1309
-#define __NR_timerfd_create             1310
-#define __NR_timerfd_settime            1311
-#define __NR_timerfd_gettime            1312
-#define __NR_signalfd4                  1313
-#define __NR_eventfd2                   1314
-#define __NR_epoll_create1              1315
-#define __NR_dup3                       1316
-#define __NR_pipe2                      1317
-#define __NR_inotify_init1              1318
-#define __NR_preadv                     1319
-#define __NR_pwritev                    1320
-#define __NR_rt_tgsigqueueinfo          1321
-#define __NR_recvmmsg                   1322
-#define __NR_fanotify_init              1323
-#define __NR_fanotify_mark              1324
-#define __NR_prlimit64                  1325
-#define __NR_name_to_handle_at          1326
-#define __NR_open_by_handle_at          1327
-#define __NR_clock_adjtime              1328
-#define __NR_syncfs                     1329
-#define __NR_setns                      1330
-#define __NR_sendmmsg                   1331
-#define __NR_process_vm_readv           1332
-#define __NR_process_vm_writev          1333
-#define __NR_accept4                    1334
-#define __NR_finit_module               1335
-
-#endif /* _UAPI_ASM_IA64_UNISTD_H */
diff --git a/arch/ia64/include/uapi/asm/ustack.h b/arch/ia64/include/uapi/asm/ustack.h
deleted file mode 100644
index 1dfebc62269..00000000000
--- a/arch/ia64/include/uapi/asm/ustack.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef _UAPI_ASM_IA64_USTACK_H
-#define _UAPI_ASM_IA64_USTACK_H
-
-/*
- * Constants for the user stack size
- */
-
-
-/* Make a default stack size of 2GiB */
-#define DEFAULT_USER_STACK_SIZE (1UL << 31)
-
-#endif /* _UAPI_ASM_IA64_USTACK_H */
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 335eb07480f..bfb4d01e0e5 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -50,6 +50,7 @@
 #include <asm/iosapic.h>
 #include <asm/machvec.h>
 #include <asm/page.h>
+#include <asm/system.h>
 #include <asm/numa.h>
 #include <asm/sal.h>
 #include <asm/cyclone.h>
@@ -348,11 +349,11 @@ acpi_parse_int_src_ovr(struct acpi_subtable_header * header,
 
         iosapic_override_isa_irq(p->source_irq, p->global_irq,
                                  ((p->inti_flags & ACPI_MADT_POLARITY_MASK) ==
-                                  ACPI_MADT_POLARITY_ACTIVE_LOW) ?
-                                 IOSAPIC_POL_LOW : IOSAPIC_POL_HIGH,
+                                  ACPI_MADT_POLARITY_ACTIVE_HIGH) ?
+                                 IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
                                  ((p->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
-                                 ACPI_MADT_TRIGGER_LEVEL) ?
-                                 IOSAPIC_LEVEL : IOSAPIC_EDGE);
+                                 ACPI_MADT_TRIGGER_EDGE) ?
+                                 IOSAPIC_EDGE : IOSAPIC_LEVEL);
         return 0;
 }
 
@@ -422,30 +423,28 @@ static int __init acpi_parse_madt(struct acpi_table_header *table)
 #define PXM_FLAG_LEN ((MAX_PXM_DOMAINS + 1)/32)
 
 static int __initdata srat_num_cpus;    /* number of cpus */
-static u32 pxm_flag[PXM_FLAG_LEN];
+static u32 __devinitdata pxm_flag[PXM_FLAG_LEN];
 #define pxm_bit_set(bit)        (set_bit(bit,(void *)pxm_flag))
 #define pxm_bit_test(bit)       (test_bit(bit,(void *)pxm_flag))
 static struct acpi_table_slit __initdata *slit_table;
 cpumask_t early_cpu_possible_map = CPU_MASK_NONE;
 
-static int __init
-get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
+static int get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
 {
         int pxm;
 
         pxm = pa->proximity_domain_lo;
-        if (ia64_platform_is("sn2") || acpi_srat_revision >= 2)
+        if (ia64_platform_is("sn2"))
                 pxm += pa->proximity_domain_hi[0] << 8;
         return pxm;
 }
 
-static int __init
-get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
+static int get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
 {
         int pxm;
 
         pxm = ma->proximity_domain;
-        if (!ia64_platform_is("sn2") && acpi_srat_revision <= 1)
+        if (!ia64_platform_is("sn2"))
                 pxm &= 0xff;
 
         return pxm;
@@ -497,7 +496,7 @@ acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
         srat_num_cpus++;
 }
 
-int __init
+void __init
 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 {
         unsigned long paddr, size;
@@ -512,7 +511,7 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 
         /* Ignore disabled entries */
         if (!(ma->flags & ACPI_SRAT_MEM_ENABLED))
-                return -1;
+                return;
 
         /* record this node in proximity bitmap */
         pxm_bit_set(pxm);
@@ -531,7 +530,6 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
         p->size = size;
         p->nid = pxm;
         num_node_memblks++;
-        return 0;
 }
 
 void __init acpi_numa_arch_fixup(void)
@@ -633,7 +631,6 @@ int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
                                       ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
                                      IOSAPIC_LEVEL);
 }
-EXPORT_SYMBOL_GPL(acpi_register_gsi);
 
 void acpi_unregister_gsi(u32 gsi)
 {
@@ -645,7 +642,6 @@ void acpi_unregister_gsi(u32 gsi)
 
         iosapic_unregister_intr(gsi);
 }
-EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
 
 static int __init acpi_parse_fadt(struct acpi_table_header *table)
 {
@@ -842,11 +838,11 @@ static __init int setup_additional_cpus(char *s)
 early_param("additional_cpus", setup_additional_cpus);
 
 /*
- * cpu_possible_mask should be static, it cannot change as CPUs
+ * cpu_possible_map should be static, it cannot change as CPUs
  * are onlined, or offlined. The reason is per-cpu data-structures
  * are allocated by some modules at init time, and dont expect to
  * do this dynamically on cpu arrival/departure.
- * cpu_present_mask on the other hand can change dynamically.
+ * cpu_present_map on the other hand can change dynamically.
  * In case when cpu_hotplug is not compiled, then we resort to current
  * behaviour, which is cpu_possible == cpu_present.
  * - Ashok Raj
@@ -924,7 +920,7 @@ static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu)
 
         acpi_map_cpu2node(handle, cpu, physid);
 
-        set_cpu_present(cpu, true);
+        cpu_set(cpu, cpu_present_map);
         ia64_cpu_to_sapicid[cpu] = physid;
 
         acpi_processor_set_pdc(handle);
@@ -943,7 +939,7 @@ EXPORT_SYMBOL(acpi_map_lsapic);
 int acpi_unmap_lsapic(int cpu)
 {
         ia64_cpu_to_sapicid[cpu] = -1;
-        set_cpu_present(cpu, false);
+        cpu_clear(cpu, cpu_present_map);
 
 #ifdef CONFIG_ACPI_NUMA
         /* NUMA specific cleanup's */
@@ -956,8 +952,8 @@ EXPORT_SYMBOL(acpi_unmap_lsapic);
 #endif                          /* CONFIG_ACPI_HOTPLUG_CPU */
 
 #ifdef CONFIG_ACPI_NUMA
-static acpi_status acpi_map_iosapic(acpi_handle handle, u32 depth,
-                                    void *context, void **ret)
+static acpi_status __devinit
+acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *obj;
diff --git a/arch/ia64/kernel/asm-offsets.c b/arch/ia64/kernel/asm-offsets.c
index a48bd9a9927..af565016904 100644
--- a/arch/ia64/kernel/asm-offsets.c
+++ b/arch/ia64/kernel/asm-offsets.c
@@ -269,8 +269,8 @@ void foo(void)
         BLANK();
 
         /* used by fsys_gettimeofday in arch/ia64/kernel/fsys.S */
-        DEFINE(IA64_GTOD_SEQ_OFFSET,
-               offsetof (struct fsyscall_gtod_data_t, seq));
+        DEFINE(IA64_GTOD_LOCK_OFFSET,
+                offsetof (struct fsyscall_gtod_data_t, lock));
         DEFINE(IA64_GTOD_WALL_TIME_OFFSET,
                 offsetof (struct fsyscall_gtod_data_t, wall_time));
         DEFINE(IA64_GTOD_MONO_TIME_OFFSET,
diff --git a/arch/ia64/kernel/dma-mapping.c b/arch/ia64/kernel/dma-mapping.c
index 7f791623820..f2c1600da09 100644
--- a/arch/ia64/kernel/dma-mapping.c
+++ b/arch/ia64/kernel/dma-mapping.c
@@ -1,5 +1,4 @@
 #include <linux/dma-mapping.h>
-#include <linux/export.h>
 
 /* Set this to 1 if there is a HW IOMMU in the system */
 int iommu_detected __read_mostly;
diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index f034563aeae..c38d22e5e90 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -39,7 +39,6 @@
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/mca.h>
-#include <asm/setup.h>
 #include <asm/tlbflush.h>
 
 #define EFI_DEBUG       0
@@ -870,7 +869,7 @@ kern_mem_attribute (unsigned long phys_addr, unsigned long size)
 EXPORT_SYMBOL(kern_mem_attribute);
 
 int
-valid_phys_addr_range (phys_addr_t phys_addr, unsigned long size)
+valid_phys_addr_range (unsigned long phys_addr, unsigned long size)
 {
         u64 attr;
 
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index 6bfd8429ee0..198c753d100 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -61,13 +61,14 @@ ENTRY(ia64_execve)
          * Allocate 8 input registers since ptrace() may clobber them
          */
         .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(8)
-        alloc loc1=ar.pfs,8,2,3,0
+        alloc loc1=ar.pfs,8,2,4,0
         mov loc0=rp
         .body
         mov out0=in0                    // filename
         ;;                              // stop bit between alloc and call
         mov out1=in1                    // argv
         mov out2=in2                    // envp
+        add out3=16,sp                  // regs
         br.call.sptk.many rp=sys_execve
 .ret0:
         cmp4.ge p6,p7=r8,r0
@@ -75,6 +76,7 @@ ENTRY(ia64_execve)
         sxt4 r8=r8                      // return 64-bit result
         ;;
         stf.spill [sp]=f0
+(p6)    cmp.ne pKStk,pUStk=r0,r0        // a successful execve() lands us in user-mode...
         mov rp=loc0
 (p6)    mov ar.pfs=r0                   // clear ar.pfs on success
 (p7)    br.ret.sptk.many rp
@@ -116,12 +118,13 @@ GLOBAL_ENTRY(sys_clone2)
         mov loc1=r16                            // save ar.pfs across do_fork
         .body
         mov out1=in1
-        mov out2=in2
+        mov out3=in2
         tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-        mov out3=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
+        mov out4=in3    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
         ;;
 (p6)    st8 [r2]=in5                            // store TLS in r16 for copy_thread()
-        mov out4=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        mov out5=in4    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
         mov out0=in0                            // out0 = clone_flags
         br.call.sptk.many rp=do_fork
 .ret1:  .restore sp
@@ -147,12 +150,13 @@ GLOBAL_ENTRY(sys_clone)
         mov loc1=r16                            // save ar.pfs across do_fork
         .body
         mov out1=in1
-        mov out2=16                             // stacksize (compensates for 16-byte scratch area)
+        mov out3=16                             // stacksize (compensates for 16-byte scratch area)
         tbit.nz p6,p0=in0,CLONE_SETTLS_BIT
-        mov out3=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
+        mov out4=in2    // parent_tidptr: valid only w/CLONE_PARENT_SETTID
         ;;
 (p6)    st8 [r2]=in4                            // store TLS in r13 (tp)
-        mov out4=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        mov out5=in3    // child_tidptr:  valid only w/CLONE_CHILD_SETTID or CLONE_CHILD_CLEARTID
+        adds out2=IA64_SWITCH_STACK_SIZE+16,sp  // out2 = &regs
         mov out0=in0                            // out0 = clone_flags
         br.call.sptk.many rp=do_fork
 .ret2:  .restore sp
@@ -480,6 +484,19 @@ GLOBAL_ENTRY(prefetch_stack)
         br.ret.sptk.many rp
 END(prefetch_stack)
 
+GLOBAL_ENTRY(kernel_execve)
+        rum psr.ac
+        mov r15=__NR_execve                     // put syscall number in place
+        break __BREAK_SYSCALL
+        br.ret.sptk.many rp
+END(kernel_execve)
+
+GLOBAL_ENTRY(clone)
+        mov r15=__NR_clone                      // put syscall number in place
+        break __BREAK_SYSCALL
+        br.ret.sptk.many rp
+END(clone)
+
         /*
          * Invoke a system call, but do some tracing before and after the call.
          * We MUST preserve the current register frame throughout this routine
@@ -583,27 +600,6 @@ GLOBAL_ENTRY(ia64_strace_leave_kernel)
 .ret4:  br.cond.sptk ia64_leave_kernel
 END(ia64_strace_leave_kernel)
 
-ENTRY(call_payload)
-        .prologue ASM_UNW_PRLG_RP|ASM_UNW_PRLG_PFS, ASM_UNW_PRLG_GRSAVE(0)
-        /* call the kernel_thread payload; fn is in r4, arg - in r5 */
-        alloc loc1=ar.pfs,0,3,1,0
-        mov loc0=rp
-        mov loc2=gp
-        mov out0=r5             // arg
-        ld8 r14 = [r4], 8       // fn.address
-        ;;
-        mov b6 = r14
-        ld8 gp = [r4]           // fn.gp
-        ;;
-        br.call.sptk.many rp=b6 // fn(arg)
-.ret12: mov gp=loc2
-        mov rp=loc0
-        mov ar.pfs=loc1
-        /* ... and if it has returned, we are going to userland */
-        cmp.ne pKStk,pUStk=r0,r0
-        br.ret.sptk.many rp
-END(call_payload)
-
 GLOBAL_ENTRY(ia64_ret_from_clone)
         PT_REGS_UNWIND_INFO(0)
 {       /*
@@ -620,7 +616,6 @@ GLOBAL_ENTRY(ia64_ret_from_clone)
         br.call.sptk.many rp=ia64_invoke_schedule_tail
 }
 .ret8:
-(pKStk) br.call.sptk.many rp=call_payload
         adds r2=TI_FLAGS+IA64_TASK_SIZE,r13
         ;;
         ld4 r2=[r2]
@@ -1782,10 +1777,6 @@ sys_call_table:
         data8 sys_syncfs
         data8 sys_setns                         // 1330
         data8 sys_sendmmsg
-        data8 sys_process_vm_readv
-        data8 sys_process_vm_writev
-        data8 sys_accept4
-        data8 sys_finit_module                  // 1335
 
         .org sys_call_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
 #endif /* __IA64_ASM_PARAVIRTUALIZED_NATIVE */
diff --git a/arch/ia64/kernel/err_inject.c b/arch/ia64/kernel/err_inject.c
index 2d67317a1ec..c539c689493 100644
--- a/arch/ia64/kernel/err_inject.c
+++ b/arch/ia64/kernel/err_inject.c
@@ -24,7 +24,7 @@
  * Copyright (C) 2006, Intel Corp.  All rights reserved.
  *
  */
-#include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>
@@ -35,10 +35,10 @@
 #define ERR_DATA_BUFFER_SIZE 3          // Three 8-byte;
 
 #define define_one_ro(name)                                             \
-static DEVICE_ATTR(name, 0444, show_##name, NULL)
+static SYSDEV_ATTR(name, 0444, show_##name, NULL)
 
 #define define_one_rw(name)                                             \
-static DEVICE_ATTR(name, 0644, show_##name, store_##name)
+static SYSDEV_ATTR(name, 0644, show_##name, store_##name)
 
 static u64 call_start[NR_CPUS];
 static u64 phys_addr[NR_CPUS];
@@ -55,7 +55,7 @@ static u64 resources[NR_CPUS];
 
 #define show(name)                                                      \
 static ssize_t                                                          \
-show_##name(struct device *dev, struct device_attribute *attr,  \
+show_##name(struct sys_device *dev, struct sysdev_attribute *attr,      \
                 char *buf)                                              \
 {                                                                       \
         u32 cpu=dev->id;                                                \
@@ -64,7 +64,7 @@ show_##name(struct device *dev, struct device_attribute *attr,	\
 
 #define store(name)                                                     \
 static ssize_t                                                          \
-store_##name(struct device *dev, struct device_attribute *attr, \
+store_##name(struct sys_device *dev, struct sysdev_attribute *attr,     \
                                         const char *buf, size_t size)   \
 {                                                                       \
         unsigned int cpu=dev->id;                                       \
@@ -78,7 +78,7 @@ show(call_start)
  * processor. The cpu number in driver is only used for storing data.
  */
 static ssize_t
-store_call_start(struct device *dev, struct device_attribute *attr,
+store_call_start(struct sys_device *dev, struct sysdev_attribute *attr,
                 const char *buf, size_t size)
 {
         unsigned int cpu=dev->id;
@@ -127,7 +127,7 @@ show(err_type_info)
 store(err_type_info)
 
 static ssize_t
-show_virtual_to_phys(struct device *dev, struct device_attribute *attr,
+show_virtual_to_phys(struct sys_device *dev, struct sysdev_attribute *attr,
                         char *buf)
 {
         unsigned int cpu=dev->id;
@@ -135,7 +135,7 @@ show_virtual_to_phys(struct device *dev, struct device_attribute *attr,
 }
 
 static ssize_t
-store_virtual_to_phys(struct device *dev, struct device_attribute *attr,
+store_virtual_to_phys(struct sys_device *dev, struct sysdev_attribute *attr,
                         const char *buf, size_t size)
 {
         unsigned int cpu=dev->id;
@@ -159,8 +159,8 @@ show(err_struct_info)
 store(err_struct_info)
 
 static ssize_t
-show_err_data_buffer(struct device *dev,
-                        struct device_attribute *attr, char *buf)
+show_err_data_buffer(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         unsigned int cpu=dev->id;
 
@@ -171,8 +171,8 @@ show_err_data_buffer(struct device *dev,
 }
 
 static ssize_t
-store_err_data_buffer(struct device *dev,
-                        struct device_attribute *attr,
+store_err_data_buffer(struct sys_device *dev,
+                        struct sysdev_attribute *attr,
                         const char *buf, size_t size)
 {
         unsigned int cpu=dev->id;
@@ -209,14 +209,14 @@ define_one_ro(capabilities);
 define_one_ro(resources);
 
 static struct attribute *default_attrs[] = {
-        &dev_attr_call_start.attr,
-        &dev_attr_virtual_to_phys.attr,
-        &dev_attr_err_type_info.attr,
-        &dev_attr_err_struct_info.attr,
-        &dev_attr_err_data_buffer.attr,
-        &dev_attr_status.attr,
-        &dev_attr_capabilities.attr,
-        &dev_attr_resources.attr,
+        &attr_call_start.attr,
+        &attr_virtual_to_phys.attr,
+        &attr_err_type_info.attr,
+        &attr_err_struct_info.attr,
+        &attr_err_data_buffer.attr,
+        &attr_status.attr,
+        &attr_capabilities.attr,
+        &attr_resources.attr,
         NULL
 };
 
@@ -225,12 +225,12 @@ static struct attribute_group err_inject_attr_group = {
         .name = "err_inject"
 };
 /* Add/Remove err_inject interface for CPU device */
-static int __cpuinit err_inject_add_dev(struct device * sys_dev)
+static int __cpuinit err_inject_add_dev(struct sys_device * sys_dev)
 {
         return sysfs_create_group(&sys_dev->kobj, &err_inject_attr_group);
 }
 
-static int __cpuinit err_inject_remove_dev(struct device * sys_dev)
+static int __cpuinit err_inject_remove_dev(struct sys_device * sys_dev)
 {
         sysfs_remove_group(&sys_dev->kobj, &err_inject_attr_group);
         return 0;
@@ -239,9 +239,9 @@ static int __cpuinit err_inject_cpu_callback(struct notifier_block *nfb,
                 unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
-        struct device *sys_dev;
+        struct sys_device *sys_dev;
 
-        sys_dev = get_cpu_device(cpu);
+        sys_dev = get_cpu_sysdev(cpu);
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
@@ -283,13 +283,13 @@ static void __exit
 err_inject_exit(void)
 {
         int i;
-        struct device *sys_dev;
+        struct sys_device *sys_dev;
 
 #ifdef ERR_INJ_DEBUG
         printk(KERN_INFO "Exit error injection driver.\n");
 #endif
         for_each_online_cpu(i) {
-                sys_dev = get_cpu_device(i);
+                sys_dev = get_cpu_sysdev(i);
                 sysfs_remove_group(&sys_dev->kobj, &err_inject_attr_group);
         }
         unregister_hotcpu_notifier(&err_inject_cpu_notifier);
diff --git a/arch/ia64/kernel/fsys.S b/arch/ia64/kernel/fsys.S
index e662f178b99..331d42bda77 100644
--- a/arch/ia64/kernel/fsys.S
+++ b/arch/ia64/kernel/fsys.S
@@ -21,6 +21,7 @@
 #include <asm/thread_info.h>
 #include <asm/sal.h>
 #include <asm/signal.h>
+#include <asm/system.h>
 #include <asm/unistd.h>
 
 #include "entry.h"
@@ -173,7 +174,7 @@ ENTRY(fsys_set_tid_address)
         FSYS_RETURN
 END(fsys_set_tid_address)
 
-#if IA64_GTOD_SEQ_OFFSET !=0
+#if IA64_GTOD_LOCK_OFFSET !=0
 #error fsys_gettimeofday incompatible with changes to struct fsyscall_gtod_data_t
 #endif
 #if IA64_ITC_JITTER_OFFSET !=0
@@ -372,6 +373,175 @@ ENTRY(fsys_clock_gettime)
 END(fsys_clock_gettime)
 
 /*
+ * long fsys_rt_sigprocmask (int how, sigset_t *set, sigset_t *oset, size_t sigsetsize).
+ */
+#if _NSIG_WORDS != 1
+# error Sorry, fsys_rt_sigprocmask() needs to be updated for _NSIG_WORDS != 1.
+#endif
+ENTRY(fsys_rt_sigprocmask)
+        .prologue
+        .altrp b6
+        .body
+
+        add r2=IA64_TASK_BLOCKED_OFFSET,r16
+        add r9=TI_FLAGS+IA64_TASK_SIZE,r16
+        cmp4.ltu p6,p0=SIG_SETMASK,r32
+
+        cmp.ne p15,p0=r0,r34                    // oset != NULL?
+        tnat.nz p8,p0=r34
+        add r31=IA64_TASK_SIGHAND_OFFSET,r16
+        ;;
+        ld8 r3=[r2]                             // read/prefetch current->blocked
+        ld4 r9=[r9]
+        tnat.nz.or p6,p0=r35
+
+        cmp.ne.or p6,p0=_NSIG_WORDS*8,r35
+        tnat.nz.or p6,p0=r32
+(p6)    br.spnt.few .fail_einval                // fail with EINVAL
+        ;;
+#ifdef CONFIG_SMP
+        ld8 r31=[r31]                           // r31 <- current->sighand
+#endif
+        and r9=TIF_ALLWORK_MASK,r9
+        tnat.nz.or p8,p0=r33
+        ;;
+        cmp.ne p7,p0=0,r9
+        cmp.eq p6,p0=r0,r33                     // set == NULL?
+        add r31=IA64_SIGHAND_SIGLOCK_OFFSET,r31 // r31 <- current->sighand->siglock
+(p8)    br.spnt.few .fail_efault                // fail with EFAULT
+(p7)    br.spnt.many fsys_fallback_syscall      // got pending kernel work...
+(p6)    br.dpnt.many .store_mask                // -> short-circuit to just reading the signal mask
+
+        /* Argh, we actually have to do some work and _update_ the signal mask: */
+
+EX(.fail_efault, probe.r.fault r33, 3)          // verify user has read-access to *set
+EX(.fail_efault, ld8 r14=[r33])                 // r14 <- *set
+        mov r17=(1 << (SIGKILL - 1)) | (1 << (SIGSTOP - 1))
+        ;;
+
+        RSM_PSR_I(p0, r18, r19)                 // mask interrupt delivery
+        andcm r14=r14,r17                       // filter out SIGKILL & SIGSTOP
+        mov r8=EINVAL                   // default to EINVAL
+
+#ifdef CONFIG_SMP
+        // __ticket_spin_trylock(r31)
+        ld4 r17=[r31]
+        ;;
+        mov.m ar.ccv=r17
+        extr.u r9=r17,17,15
+        adds r19=1,r17
+        extr.u r18=r17,0,15
+        ;;
+        cmp.eq p6,p7=r9,r18
+        ;;
+(p6)    cmpxchg4.acq r9=[r31],r19,ar.ccv
+(p6)    dep.z r20=r19,1,15              // next serving ticket for unlock
+(p7)    br.cond.spnt.many .lock_contention
+        ;;
+        cmp4.eq p0,p7=r9,r17
+        adds r31=2,r31
+(p7)    br.cond.spnt.many .lock_contention
+        ld8 r3=[r2]                     // re-read current->blocked now that we hold the lock
+        ;;
+#else
+        ld8 r3=[r2]                     // re-read current->blocked now that we hold the lock
+#endif
+        add r18=IA64_TASK_PENDING_OFFSET+IA64_SIGPENDING_SIGNAL_OFFSET,r16
+        add r19=IA64_TASK_SIGNAL_OFFSET,r16
+        cmp4.eq p6,p0=SIG_BLOCK,r32
+        ;;
+        ld8 r19=[r19]                   // r19 <- current->signal
+        cmp4.eq p7,p0=SIG_UNBLOCK,r32
+        cmp4.eq p8,p0=SIG_SETMASK,r32
+        ;;
+        ld8 r18=[r18]                   // r18 <- current->pending.signal
+        .pred.rel.mutex p6,p7,p8
+(p6)    or r14=r3,r14                   // SIG_BLOCK
+(p7)    andcm r14=r3,r14                // SIG_UNBLOCK
+
+(p8)    mov r14=r14                     // SIG_SETMASK
+(p6)    mov r8=0                        // clear error code
+        // recalc_sigpending()
+        add r17=IA64_SIGNAL_GROUP_STOP_COUNT_OFFSET,r19
+
+        add r19=IA64_SIGNAL_SHARED_PENDING_OFFSET+IA64_SIGPENDING_SIGNAL_OFFSET,r19
+        ;;
+        ld4 r17=[r17]           // r17 <- current->signal->group_stop_count
+(p7)    mov r8=0                // clear error code
+
+        ld8 r19=[r19]           // r19 <- current->signal->shared_pending
+        ;;
+        cmp4.gt p6,p7=r17,r0    // p6/p7 <- (current->signal->group_stop_count > 0)?
+(p8)    mov r8=0                // clear error code
+
+        or r18=r18,r19          // r18 <- current->pending | current->signal->shared_pending
+        ;;
+        // r18 <- (current->pending | current->signal->shared_pending) & ~current->blocked:
+        andcm r18=r18,r14
+        add r9=TI_FLAGS+IA64_TASK_SIZE,r16
+        ;;
+
+(p7)    cmp.ne.or.andcm p6,p7=r18,r0            // p6/p7 <- signal pending
+        mov r19=0                                       // i must not leak kernel bits...
+(p6)    br.cond.dpnt.many .sig_pending
+        ;;
+
+1:      ld4 r17=[r9]                            // r17 <- current->thread_info->flags
+        ;;
+        mov ar.ccv=r17
+        and r18=~_TIF_SIGPENDING,r17            // r18 <- r17 & ~(1 << TIF_SIGPENDING)
+        ;;
+
+        st8 [r2]=r14                            // update current->blocked with new mask
+        cmpxchg4.acq r8=[r9],r18,ar.ccv         // current->thread_info->flags <- r18
+        ;;
+        cmp.ne p6,p0=r17,r8                     // update failed?
+(p6)    br.cond.spnt.few 1b                     // yes -> retry
+
+#ifdef CONFIG_SMP
+        // __ticket_spin_unlock(r31)
+        st2.rel [r31]=r20
+        mov r20=0                                       // i must not leak kernel bits...
+#endif
+        SSM_PSR_I(p0, p9, r31)
+        ;;
+
+        srlz.d                                  // ensure psr.i is set again
+        mov r18=0                                       // i must not leak kernel bits...
+
+.store_mask:
+EX(.fail_efault, (p15) probe.w.fault r34, 3)    // verify user has write-access to *oset
+EX(.fail_efault, (p15) st8 [r34]=r3)
+        mov r2=0                                        // i must not leak kernel bits...
+        mov r3=0                                        // i must not leak kernel bits...
+        mov r8=0                                // return 0
+        mov r9=0                                        // i must not leak kernel bits...
+        mov r14=0                                       // i must not leak kernel bits...
+        mov r17=0                                       // i must not leak kernel bits...
+        mov r31=0                                       // i must not leak kernel bits...
+        FSYS_RETURN
+
+.sig_pending:
+#ifdef CONFIG_SMP
+        // __ticket_spin_unlock(r31)
+        st2.rel [r31]=r20                       // release the lock
+#endif
+        SSM_PSR_I(p0, p9, r17)
+        ;;
+        srlz.d
+        br.sptk.many fsys_fallback_syscall      // with signal pending, do the heavy-weight syscall
+
+#ifdef CONFIG_SMP
+.lock_contention:
+        /* Rather than spinning here, fall back on doing a heavy-weight syscall.  */
+        SSM_PSR_I(p0, p9, r17)
+        ;;
+        srlz.d
+        br.sptk.many fsys_fallback_syscall
+#endif
+END(fsys_rt_sigprocmask)
+
+/*
  * fsys_getcpu doesn't use the third parameter in this implementation. It reads
  * current_thread_info()->cpu and corresponding node in cpu_to_node_map.
  */
@@ -390,15 +560,11 @@ ENTRY(fsys_getcpu)
         ;;
         tnat.nz p7,p0 = r33                     // I guard against NaT argument
 (p7)    br.cond.spnt.few .fail_einval           // B
-        ;;
-        cmp.ne p6,p0=r32,r0
-        cmp.ne p7,p0=r33,r0
-        ;;
 #ifdef CONFIG_NUMA
         movl r17=cpu_to_node_map
         ;;
-EX(.fail_efault, (p6) probe.w.fault r32, 3)             // M This takes 5 cycles
-EX(.fail_efault, (p7) probe.w.fault r33, 3)             // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r32, 3)          // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r33, 3)          // M This takes 5 cycles
         shladd r18=r3,1,r17
         ;;
         ld2 r20=[r18]                           // r20 = cpu_to_node_map[cpu]
@@ -408,20 +574,20 @@ EX(.fail_efault, (p7) probe.w.fault r33, 3)		// M This takes 5 cycles
 (p8)    br.spnt.many fsys_fallback_syscall
         ;;
         ;;
-EX(.fail_efault, (p6) st4 [r32] = r3)
-EX(.fail_efault, (p7) st2 [r33] = r20)
+EX(.fail_efault, st4 [r32] = r3)
+EX(.fail_efault, st2 [r33] = r20)
         mov r8=0
         ;;
 #else
-EX(.fail_efault, (p6) probe.w.fault r32, 3)             // M This takes 5 cycles
-EX(.fail_efault, (p7) probe.w.fault r33, 3)             // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r32, 3)          // M This takes 5 cycles
+EX(.fail_efault, probe.w.fault r33, 3)          // M This takes 5 cycles
         and r2 = TIF_ALLWORK_MASK,r2
         ;;
         cmp.ne p8,p0=0,r2
 (p8)    br.spnt.many fsys_fallback_syscall
         ;;
-EX(.fail_efault, (p6) st4 [r32] = r3)
-EX(.fail_efault, (p7) st2 [r33] = r0)
+EX(.fail_efault, st4 [r32] = r3)
+EX(.fail_efault, st2 [r33] = r0)
         mov r8=0
         ;;
 #endif
@@ -751,7 +917,7 @@ paravirt_fsyscall_table:
         data8 0                         // sigaltstack
         data8 0                         // rt_sigaction
         data8 0                         // rt_sigpending
-        data8 0                         // rt_sigprocmask
+        data8 fsys_rt_sigprocmask       // rt_sigprocmask
         data8 0                         // rt_sigqueueinfo      // 1180
         data8 0                         // rt_sigreturn
         data8 0                         // rt_sigsuspend
diff --git a/arch/ia64/kernel/fsyscall_gtod_data.h b/arch/ia64/kernel/fsyscall_gtod_data.h
index 146b15b5fec..57d2ee6c83e 100644
--- a/arch/ia64/kernel/fsyscall_gtod_data.h
+++ b/arch/ia64/kernel/fsyscall_gtod_data.h
@@ -6,7 +6,7 @@
  */
 
 struct fsyscall_gtod_data_t {
-        seqcount_t      seq;
+        seqlock_t       lock;
         struct timespec wall_time;
         struct timespec monotonic_time;
         cycle_t         clk_mask;
diff --git a/arch/ia64/kernel/gate.S b/arch/ia64/kernel/gate.S
index b5f8bdd8618..245d3e1ec7e 100644
--- a/arch/ia64/kernel/gate.S
+++ b/arch/ia64/kernel/gate.S
@@ -11,9 +11,8 @@
 #include <asm/errno.h>
 #include <asm/asm-offsets.h>
 #include <asm/sigcontext.h>
+#include <asm/system.h>
 #include <asm/unistd.h>
-#include <asm/kregs.h>
-#include <asm/page.h>
 #include "paravirt_inst.h"
 
 /*
diff --git a/arch/ia64/kernel/gate.lds.S b/arch/ia64/kernel/gate.lds.S
index e518f7902af..d32b0855110 100644
--- a/arch/ia64/kernel/gate.lds.S
+++ b/arch/ia64/kernel/gate.lds.S
@@ -5,7 +5,8 @@
  * its layout.
  */
 
-#include <asm/page.h>
+
+#include <asm/system.h>
 #include "paravirt_patchlist.h"
 
 SECTIONS
diff --git a/arch/ia64/kernel/head.S b/arch/ia64/kernel/head.S
index 4738ff7bd66..17a9fba3893 100644
--- a/arch/ia64/kernel/head.S
+++ b/arch/ia64/kernel/head.S
@@ -30,6 +30,7 @@
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/mca_asm.h>
 #include <linux/init.h>
 #include <linux/linkage.h>
@@ -1093,6 +1094,19 @@ GLOBAL_ENTRY(cycle_to_cputime)
 END(cycle_to_cputime)
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
 
+GLOBAL_ENTRY(start_kernel_thread)
+        .prologue
+        .save rp, r0                            // this is the end of the call-chain
+        .body
+        alloc r2 = ar.pfs, 0, 0, 2, 0
+        mov out0 = r9
+        mov out1 = r11;;
+        br.call.sptk.many rp = kernel_thread_helper;;
+        mov out0 = r8
+        br.call.sptk.many rp = sys_exit;;
+1:      br.sptk.few 1b                          // not reached
+END(start_kernel_thread)
+
 #ifdef CONFIG_IA64_BRL_EMU
 
 /*
diff --git a/arch/ia64/kernel/ia64_ksyms.c b/arch/ia64/kernel/ia64_ksyms.c
index 5b7791dd396..7f4a0ed2415 100644
--- a/arch/ia64/kernel/ia64_ksyms.c
+++ b/arch/ia64/kernel/ia64_ksyms.c
@@ -12,7 +12,7 @@ EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(strlen);
 
-#include <asm/pgtable.h>
+#include<asm/pgtable.h>
 EXPORT_SYMBOL_GPL(empty_zero_page);
 
 #include <asm/checksum.h>
diff --git a/arch/ia64/kernel/iosapic.c b/arch/ia64/kernel/iosapic.c
index ee33c3aaa2f..b0f9afebb14 100644
--- a/arch/ia64/kernel/iosapic.c
+++ b/arch/ia64/kernel/iosapic.c
@@ -98,6 +98,7 @@
 #include <asm/machvec.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 
 #undef DEBUG_INTERRUPT_ROUTING
 
@@ -147,7 +148,7 @@ static struct iosapic_intr_info {
         unsigned char   trigger : 1;    /* trigger mode (see iosapic.h) */
 } iosapic_intr_info[NR_IRQS];
 
-static unsigned char pcat_compat;       /* 8259 compatibility flag */
+static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */
 
 static inline void
 iosapic_write(struct iosapic *iosapic, unsigned int reg, u32 val)
@@ -914,8 +915,10 @@ iosapic_register_platform_intr (u32 int_type, unsigned int gsi,
 /*
  * ACPI calls this when it finds an entry for a legacy ISA IRQ override.
  */
-void iosapic_override_isa_irq(unsigned int isa_irq, unsigned int gsi,
-                              unsigned long polarity, unsigned long trigger)
+void __devinit
+iosapic_override_isa_irq (unsigned int isa_irq, unsigned int gsi,
+                          unsigned long polarity,
+                          unsigned long trigger)
 {
         int vector, irq;
         unsigned int dest = cpu_physical_id(smp_processor_id());
@@ -1010,7 +1013,8 @@ iosapic_check_gsi_range (unsigned int gsi_base, unsigned int ver)
         return 0;
 }
 
-int iosapic_init(unsigned long phys_addr, unsigned int gsi_base)
+int __devinit
+iosapic_init (unsigned long phys_addr, unsigned int gsi_base)
 {
         int num_rte, err, index;
         unsigned int isa_irq, ver;
@@ -1067,7 +1071,9 @@ int iosapic_init(unsigned long phys_addr, unsigned int gsi_base)
         return 0;
 }
 
-int iosapic_remove(unsigned int gsi_base)
+#ifdef CONFIG_HOTPLUG
+int
+iosapic_remove (unsigned int gsi_base)
 {
         int index, err = 0;
         unsigned long flags;
@@ -1093,9 +1099,11 @@ int iosapic_remove(unsigned int gsi_base)
         spin_unlock_irqrestore(&iosapic_lock, flags);
         return err;
 }
+#endif /* CONFIG_HOTPLUG */
 
 #ifdef CONFIG_NUMA
-void map_iosapic_to_node(unsigned int gsi_base, int node)
+void __devinit
+map_iosapic_to_node(unsigned int gsi_base, int node)
 {
         int index;
 
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index 1034884b77d..782c3a357f2 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -23,6 +23,7 @@
 #include <linux/ioport.h>
 #include <linux/kernel_stat.h>
 #include <linux/ptrace.h>
+#include <linux/random.h>       /* for rand_initialize_irq() */
 #include <linux/signal.h>
 #include <linux/smp.h>
 #include <linux/threads.h>
@@ -38,6 +39,7 @@
 #include <asm/hw_irq.h>
 #include <asm/machvec.h>
 #include <asm/pgtable.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 
 #ifdef CONFIG_PERFMON
@@ -116,7 +118,7 @@ static inline int find_unassigned_vector(cpumask_t domain)
         cpumask_t mask;
         int pos, vector;
 
-        cpumask_and(&mask, &domain, cpu_online_mask);
+        cpus_and(mask, domain, cpu_online_map);
         if (cpus_empty(mask))
                 return -EINVAL;
 
@@ -139,7 +141,7 @@ static int __bind_irq_vector(int irq, int vector, cpumask_t domain)
         BUG_ON((unsigned)irq >= NR_IRQS);
         BUG_ON((unsigned)vector >= IA64_NUM_VECTORS);
 
-        cpumask_and(&mask, &domain, cpu_online_mask);
+        cpus_and(mask, domain, cpu_online_map);
         if (cpus_empty(mask))
                 return -EINVAL;
         if ((cfg->vector == vector) && cpus_equal(cfg->domain, domain))
@@ -177,7 +179,7 @@ static void __clear_irq_vector(int irq)
         BUG_ON(cfg->vector == IRQ_VECTOR_UNASSIGNED);
         vector = cfg->vector;
         domain = cfg->domain;
-        cpumask_and(&mask, &cfg->domain, cpu_online_mask);
+        cpus_and(mask, cfg->domain, cpu_online_map);
         for_each_cpu_mask(cpu, mask)
                 per_cpu(vector_irq, cpu)[vector] = -1;
         cfg->vector = IRQ_VECTOR_UNASSIGNED;
@@ -320,7 +322,7 @@ void irq_complete_move(unsigned irq)
         if (unlikely(cpu_isset(smp_processor_id(), cfg->old_domain)))
                 return;
 
-        cpumask_and(&cleanup_mask, &cfg->old_domain, cpu_online_mask);
+        cpus_and(cleanup_mask, cfg->old_domain, cpu_online_map);
         cfg->move_cleanup_count = cpus_weight(cleanup_mask);
         for_each_cpu_mask(i, cleanup_mask)
                 platform_send_ipi(i, IA64_IRQ_MOVE_VECTOR, IA64_IPI_DM_INT, 0);
diff --git a/arch/ia64/kernel/ivt.S b/arch/ia64/kernel/ivt.S
index fa25689fc45..d93e396bf59 100644
--- a/arch/ia64/kernel/ivt.S
+++ b/arch/ia64/kernel/ivt.S
@@ -54,6 +54,7 @@
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/thread_info.h>
 #include <asm/unistd.h>
 #include <asm/errno.h>
diff --git a/arch/ia64/kernel/machine_kexec.c b/arch/ia64/kernel/machine_kexec.c
index 5151a649c96..3d3aeef4694 100644
--- a/arch/ia64/kernel/machine_kexec.c
+++ b/arch/ia64/kernel/machine_kexec.c
@@ -27,11 +27,11 @@
 #include <asm/sal.h>
 #include <asm/mca.h>
 
-typedef void (*relocate_new_kernel_t)(
+typedef NORET_TYPE void (*relocate_new_kernel_t)(
                                         unsigned long indirection_page,
                                         unsigned long start_address,
                                         struct ia64_boot_param *boot_param,
-                                        unsigned long pal_addr) __noreturn;
+                                        unsigned long pal_addr) ATTRIB_NORET;
 
 struct kimage *ia64_kimage;
 
@@ -85,13 +85,12 @@ static void ia64_machine_kexec(struct unw_frame_info *info, void *arg)
         struct kimage *image = arg;
         relocate_new_kernel_t rnk;
         void *pal_addr = efi_get_pal_addr();
-        unsigned long code_addr;
+        unsigned long code_addr = (unsigned long)page_address(image->control_code_page);
         int ii;
         u64 fp, gp;
         ia64_fptr_t *init_handler = (ia64_fptr_t *)ia64_os_init_on_kdump;
 
         BUG_ON(!image);
-        code_addr = (unsigned long)page_address(image->control_code_page);
         if (image->type == KEXEC_TYPE_CRASH) {
                 crash_save_this_cpu();
                 current->thread.ksp = (__u64)info->sw - 16;
@@ -158,7 +157,7 @@ void arch_crash_save_vmcoreinfo(void)
 #endif
 #ifdef CONFIG_PGTABLE_3
         VMCOREINFO_CONFIG(PGTABLE_3);
-#elif defined(CONFIG_PGTABLE_4)
+#elif  CONFIG_PGTABLE_4
         VMCOREINFO_CONFIG(PGTABLE_4);
 #endif
 }
diff --git a/arch/ia64/kernel/machvec.c b/arch/ia64/kernel/machvec.c
index f5a1e5246b3..d41a40ef80c 100644
--- a/arch/ia64/kernel/machvec.c
+++ b/arch/ia64/kernel/machvec.c
@@ -1,6 +1,7 @@
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
 #include <asm/machvec.h>
+#include <asm/system.h>
 
 #ifdef CONFIG_IA64_GENERIC
 
diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
index 65bf9cd3904..84fb405eee8 100644
--- a/arch/ia64/kernel/mca.c
+++ b/arch/ia64/kernel/mca.c
@@ -92,6 +92,7 @@
 #include <asm/meminit.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/sal.h>
 #include <asm/mca.h>
 #include <asm/kexec.h>
@@ -1446,8 +1447,6 @@ out:
         /* Get the CMC error record and log it */
         ia64_mca_log_sal_error_record(SAL_INFO_TYPE_CMC);
 
-        local_irq_disable();
-
         return IRQ_HANDLED;
 }
 
@@ -1514,8 +1513,7 @@ static void
 ia64_mca_cmc_poll (unsigned long dummy)
 {
         /* Trigger a CMC interrupt cascade  */
-        platform_send_ipi(cpumask_first(cpu_online_mask), IA64_CMCP_VECTOR,
-                                                        IA64_IPI_DM_INT, 0);
+        platform_send_ipi(first_cpu(cpu_online_map), IA64_CMCP_VECTOR, IA64_IPI_DM_INT, 0);
 }
 
 /*
@@ -1591,8 +1589,7 @@ static void
 ia64_mca_cpe_poll (unsigned long dummy)
 {
         /* Trigger a CPE interrupt cascade  */
-        platform_send_ipi(cpumask_first(cpu_online_mask), IA64_CPEP_VECTOR,
-                                                        IA64_IPI_DM_INT, 0);
+        platform_send_ipi(first_cpu(cpu_online_map), IA64_CPEP_VECTOR, IA64_IPI_DM_INT, 0);
 }
 
 #endif /* CONFIG_ACPI */
diff --git a/arch/ia64/kernel/mca_drv.c b/arch/ia64/kernel/mca_drv.c
index 9392e021c93..09b4d6828c4 100644
--- a/arch/ia64/kernel/mca_drv.c
+++ b/arch/ia64/kernel/mca_drv.c
@@ -28,6 +28,7 @@
 #include <asm/machvec.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/sal.h>
 #include <asm/mca.h>
 
@@ -158,8 +159,7 @@ mca_handler_bh(unsigned long paddr, void *iip, unsigned long ipsr)
         ia64_mlogbuf_dump();
         printk(KERN_ERR "OS_MCA: process [cpu %d, pid: %d, uid: %d, "
                 "iip: %p, psr: 0x%lx,paddr: 0x%lx](%s) encounters MCA.\n",
-               raw_smp_processor_id(), current->pid,
-                from_kuid(&init_user_ns, current_uid()),
+               raw_smp_processor_id(), current->pid, current_uid(),
                 iip, ipsr, paddr, current->comm);
 
         spin_lock(&mca_bh_lock);
diff --git a/arch/ia64/kernel/msi_ia64.c b/arch/ia64/kernel/msi_ia64.c
index fb2f1e62287..94e0db72d4a 100644
--- a/arch/ia64/kernel/msi_ia64.c
+++ b/arch/ia64/kernel/msi_ia64.c
@@ -57,7 +57,7 @@ int ia64_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
                 return irq;
 
         irq_set_msi_desc(irq, desc);
-        cpumask_and(&mask, &(irq_to_domain(irq)), cpu_online_mask);
+        cpus_and(mask, irq_to_domain(irq), cpu_online_map);
         dest_phys_id = cpu_physical_id(first_cpu(mask));
         vector = irq_to_vector(irq);
 
@@ -179,7 +179,7 @@ msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_msg *msg)
         unsigned dest;
         cpumask_t mask;
 
-        cpumask_and(&mask, &(irq_to_domain(irq)), cpu_online_mask);
+        cpus_and(mask, irq_to_domain(irq), cpu_online_map);
         dest = cpu_physical_id(first_cpu(mask));
 
         msg->address_hi = 0;
diff --git a/arch/ia64/kernel/paravirt.c b/arch/ia64/kernel/paravirt.c
index 1b22f6de293..100868216c5 100644
--- a/arch/ia64/kernel/paravirt.c
+++ b/arch/ia64/kernel/paravirt.c
@@ -634,8 +634,8 @@ struct pv_irq_ops pv_irq_ops = {
  * pv_time_ops
  * time operations
  */
-struct static_key paravirt_steal_enabled;
-struct static_key paravirt_steal_rq_enabled;
+struct jump_label_key paravirt_steal_enabled;
+struct jump_label_key paravirt_steal_rq_enabled;
 
 static int
 ia64_native_do_steal_accounting(unsigned long *new_itm)
diff --git a/arch/ia64/kernel/patch.c b/arch/ia64/kernel/patch.c
index 1cf09179371..68a1311db80 100644
--- a/arch/ia64/kernel/patch.c
+++ b/arch/ia64/kernel/patch.c
@@ -11,6 +11,7 @@
 #include <asm/patch.h>
 #include <asm/processor.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 #include <asm/unistd.h>
 
 /*
diff --git a/arch/ia64/kernel/pci-dma.c b/arch/ia64/kernel/pci-dma.c
index 1ddcfe5ef35..eb117572005 100644
--- a/arch/ia64/kernel/pci-dma.c
+++ b/arch/ia64/kernel/pci-dma.c
@@ -12,6 +12,7 @@
 #include <asm/machvec.h>
 #include <linux/dma-mapping.h>
 
+#include <asm/system.h>
 
 #ifdef CONFIG_INTEL_IOMMU
 
@@ -32,6 +33,7 @@ int force_iommu __read_mostly;
 #endif
 
 int iommu_pass_through;
+int iommu_group_mf;
 
 /* Dummy device used for NULL arguments (normally ISA). Better would
    be probably a smaller DMA mask, but this is bug-to-bug compatible
diff --git a/arch/ia64/kernel/pci-swiotlb.c b/arch/ia64/kernel/pci-swiotlb.c
index 939260aeac9..d9485d952ed 100644
--- a/arch/ia64/kernel/pci-swiotlb.c
+++ b/arch/ia64/kernel/pci-swiotlb.c
@@ -15,24 +15,16 @@ int swiotlb __read_mostly;
 EXPORT_SYMBOL(swiotlb);
 
 static void *ia64_swiotlb_alloc_coherent(struct device *dev, size_t size,
-                                         dma_addr_t *dma_handle, gfp_t gfp,
-                                         struct dma_attrs *attrs)
+                                         dma_addr_t *dma_handle, gfp_t gfp)
 {
         if (dev->coherent_dma_mask != DMA_BIT_MASK(64))
                 gfp |= GFP_DMA;
         return swiotlb_alloc_coherent(dev, size, dma_handle, gfp);
 }
 
-static void ia64_swiotlb_free_coherent(struct device *dev, size_t size,
-                                       void *vaddr, dma_addr_t dma_addr,
-                                       struct dma_attrs *attrs)
-{
-        swiotlb_free_coherent(dev, size, vaddr, dma_addr);
-}
-
 struct dma_map_ops swiotlb_dma_ops = {
-        .alloc = ia64_swiotlb_alloc_coherent,
-        .free = ia64_swiotlb_free_coherent,
+        .alloc_coherent = ia64_swiotlb_alloc_coherent,
+        .free_coherent = swiotlb_free_coherent,
         .map_page = swiotlb_map_page,
         .unmap_page = swiotlb_unmap_page,
         .map_sg = swiotlb_map_sg_attrs,
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index ea39eba61ef..89accc626b8 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -49,6 +49,7 @@
 #include <asm/perfmon.h>
 #include <asm/processor.h>
 #include <asm/signal.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/delay.h>
 
@@ -604,6 +605,18 @@ pfm_unprotect_ctx_ctxsw(pfm_context_t *x, unsigned long f)
         spin_unlock(&(x)->ctx_lock);
 }
 
+static inline unsigned int
+pfm_do_munmap(struct mm_struct *mm, unsigned long addr, size_t len, int acct)
+{
+        return do_munmap(mm, addr, len);
+}
+
+static inline unsigned long 
+pfm_get_unmapped_area(struct file *file, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags, unsigned long exec)
+{
+        return get_unmapped_area(file, addr, len, pgoff, flags);
+}
+
 /* forward declaration */
 static const struct dentry_operations pfmfs_dentry_operations;
 
@@ -1446,9 +1459,8 @@ pfm_unreserve_session(pfm_context_t *ctx, int is_syswide, unsigned int cpu)
  * a PROTECT_CTX() section.
  */
 static int
-pfm_remove_smpl_mapping(void *vaddr, unsigned long size)
+pfm_remove_smpl_mapping(struct task_struct *task, void *vaddr, unsigned long size)
 {
-        struct task_struct *task = current;
         int r;
 
         /* sanity checks */
@@ -1462,8 +1474,13 @@ pfm_remove_smpl_mapping(void *vaddr, unsigned long size)
         /*
          * does the actual unmapping
          */
-        r = vm_munmap((unsigned long)vaddr, size);
+        down_write(&task->mm->mmap_sem);
+
+        DPRINT(("down_write done smpl_vaddr=%p size=%lu\n", vaddr, size));
+
+        r = pfm_do_munmap(task->mm, (unsigned long)vaddr, size, 0);
 
+        up_write(&task->mm->mmap_sem);
         if (r !=0) {
                 printk(KERN_ERR "perfmon: [%d] unable to unmap sampling buffer @%p size=%lu\n", task_pid_nr(task), vaddr, size);
         }
@@ -1929,7 +1946,7 @@ pfm_flush(struct file *filp, fl_owner_t id)
          * because some VM function reenables interrupts.
          *
          */
-        if (smpl_buf_vaddr) pfm_remove_smpl_mapping(smpl_buf_vaddr, smpl_buf_size);
+        if (smpl_buf_vaddr) pfm_remove_smpl_mapping(current, smpl_buf_vaddr, smpl_buf_size);
 
         return 0;
 }
@@ -2211,7 +2228,7 @@ pfm_alloc_file(pfm_context_t *ctx)
         /*
          * allocate a new dcache entry
          */
-        path.dentry = d_alloc(pfmfs_mnt->mnt_root, &this);
+        path.dentry = d_alloc(pfmfs_mnt->mnt_sb->s_root, &this);
         if (!path.dentry) {
                 iput(inode);
                 return ERR_PTR(-ENOMEM);
@@ -2306,8 +2323,8 @@ pfm_smpl_buffer_alloc(struct task_struct *task, struct file *filp, pfm_context_t
          * partially initialize the vma for the sampling buffer
          */
         vma->vm_mm           = mm;
-        vma->vm_file         = get_file(filp);
-        vma->vm_flags        = VM_READ|VM_MAYREAD|VM_DONTEXPAND|VM_DONTDUMP;
+        vma->vm_file         = filp;
+        vma->vm_flags        = VM_READ| VM_MAYREAD |VM_RESERVED;
         vma->vm_page_prot    = PAGE_READONLY; /* XXX may need to change */
 
         /*
@@ -2327,8 +2344,8 @@ pfm_smpl_buffer_alloc(struct task_struct *task, struct file *filp, pfm_context_t
         down_write(&task->mm->mmap_sem);
 
         /* find some free area in address space, must have mmap sem held */
-        vma->vm_start = get_unmapped_area(NULL, 0, size, 0, MAP_PRIVATE|MAP_ANONYMOUS);
-        if (IS_ERR_VALUE(vma->vm_start)) {
+        vma->vm_start = pfm_get_unmapped_area(NULL, 0, size, 0, MAP_PRIVATE|MAP_ANONYMOUS, 0);
+        if (vma->vm_start == 0UL) {
                 DPRINT(("Cannot find unmapped area for size %ld\n", size));
                 up_write(&task->mm->mmap_sem);
                 goto error;
@@ -2345,12 +2362,15 @@ pfm_smpl_buffer_alloc(struct task_struct *task, struct file *filp, pfm_context_t
                 goto error;
         }
 
+        get_file(filp);
+
         /*
          * now insert the vma in the vm list for the process, must be
          * done with mmap lock held
          */
         insert_vm_struct(mm, vma);
 
+        mm->total_vm  += size >> PAGE_SHIFT;
         vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
                                                         vma_pages(vma));
         up_write(&task->mm->mmap_sem);
@@ -2378,8 +2398,8 @@ static int
 pfm_bad_permissions(struct task_struct *task)
 {
         const struct cred *tcred;
-        kuid_t uid = current_uid();
-        kgid_t gid = current_gid();
+        uid_t uid = current_uid();
+        gid_t gid = current_gid();
         int ret;
 
         rcu_read_lock();
@@ -2387,20 +2407,20 @@ pfm_bad_permissions(struct task_struct *task)
 
         /* inspired by ptrace_attach() */
         DPRINT(("cur: uid=%d gid=%d task: euid=%d suid=%d uid=%d egid=%d sgid=%d\n",
-                from_kuid(&init_user_ns, uid),
-                from_kgid(&init_user_ns, gid),
-                from_kuid(&init_user_ns, tcred->euid),
-                from_kuid(&init_user_ns, tcred->suid),
-                from_kuid(&init_user_ns, tcred->uid),
-                from_kgid(&init_user_ns, tcred->egid),
-                from_kgid(&init_user_ns, tcred->sgid)));
-
-        ret = ((!uid_eq(uid, tcred->euid))
-               || (!uid_eq(uid, tcred->suid))
-               || (!uid_eq(uid, tcred->uid))
-               || (!gid_eq(gid, tcred->egid))
-               || (!gid_eq(gid, tcred->sgid))
-               || (!gid_eq(gid, tcred->gid))) && !capable(CAP_SYS_PTRACE);
+                uid,
+                gid,
+                tcred->euid,
+                tcred->suid,
+                tcred->uid,
+                tcred->egid,
+                tcred->sgid));
+
+        ret = ((uid != tcred->euid)
+               || (uid != tcred->suid)
+               || (uid != tcred->uid)
+               || (gid != tcred->egid)
+               || (gid != tcred->sgid)
+               || (gid != tcred->gid)) && !capable(CAP_SYS_PTRACE);
 
         rcu_read_unlock();
         return ret;
@@ -4780,7 +4800,7 @@ recheck:
 asmlinkage long
 sys_perfmonctl (int fd, int cmd, void __user *arg, int count)
 {
-        struct fd f = {NULL, 0};
+        struct file *file = NULL;
         pfm_context_t *ctx = NULL;
         unsigned long flags = 0UL;
         void *args_k = NULL;
@@ -4877,17 +4897,17 @@ restart_args:
 
         ret = -EBADF;
 
-        f = fdget(fd);
-        if (unlikely(f.file == NULL)) {
+        file = fget(fd);
+        if (unlikely(file == NULL)) {
                 DPRINT(("invalid fd %d\n", fd));
                 goto error_args;
         }
-        if (unlikely(PFM_IS_FILE(f.file) == 0)) {
+        if (unlikely(PFM_IS_FILE(file) == 0)) {
                 DPRINT(("fd %d not related to perfmon\n", fd));
                 goto error_args;
         }
 
-        ctx = f.file->private_data;
+        ctx = file->private_data;
         if (unlikely(ctx == NULL)) {
                 DPRINT(("no context for fd %d\n", fd));
                 goto error_args;
@@ -4917,8 +4937,8 @@ abort_locked:
         if (call_made && PFM_CMD_RW_ARG(cmd) && copy_to_user(arg, args_k, base_sz*count)) ret = -EFAULT;
 
 error_args:
-        if (f.file)
-                fdput(f);
+        if (file)
+                fput(file);
 
         kfree(args_k);
 
diff --git a/arch/ia64/kernel/process.c b/arch/ia64/kernel/process.c
index 31360cbbd5f..6d33c5cc94f 100644
--- a/arch/ia64/kernel/process.c
+++ b/arch/ia64/kernel/process.c
@@ -29,7 +29,6 @@
 #include <linux/kdebug.h>
 #include <linux/utsname.h>
 #include <linux/tracehook.h>
-#include <linux/rcupdate.h>
 
 #include <asm/cpu.h>
 #include <asm/delay.h>
@@ -39,7 +38,6 @@
 #include <asm/pgalloc.h>
 #include <asm/processor.h>
 #include <asm/sal.h>
-#include <asm/switch_to.h>
 #include <asm/tlbflush.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
@@ -197,9 +195,11 @@ do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
                 ia64_do_signal(scr, in_syscall);
         }
 
-        if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME)) {
-                local_irq_enable();     /* force interrupt enable */
+        if (test_thread_flag(TIF_NOTIFY_RESUME)) {
+                clear_thread_flag(TIF_NOTIFY_RESUME);
                 tracehook_notify_resume(&scr->pt);
+                if (current->replacement_session_keyring)
+                        key_replace_session_keyring();
         }
 
         /* copy user rbs to kernel rbs */
@@ -272,6 +272,26 @@ static inline void play_dead(void)
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 
+static void do_nothing(void *unused)
+{
+}
+
+/*
+ * cpu_idle_wait - Used to ensure that all the CPUs discard old value of
+ * pm_idle and update to new pm_idle value. Required while changing pm_idle
+ * handler on SMP systems.
+ *
+ * Caller must have changed pm_idle to the new value before the call. Old
+ * pm_idle value will not be used by any CPU after the return of this function.
+ */
+void cpu_idle_wait(void)
+{
+        smp_mb();
+        /* kick all the CPUs so that they exit out of pm_idle */
+        smp_call_function(do_nothing, NULL, 1);
+}
+EXPORT_SYMBOL_GPL(cpu_idle_wait);
+
 void __attribute__((noreturn))
 cpu_idle (void)
 {
@@ -280,7 +300,6 @@ cpu_idle (void)
 
         /* endless idle loop with no priority at all */
         while (1) {
-                rcu_idle_enter();
                 if (can_do_pal_halt) {
                         current_thread_info()->status &= ~TS_POLLING;
                         /*
@@ -311,8 +330,9 @@ cpu_idle (void)
                         normal_xtp();
 #endif
                 }
-                rcu_idle_exit();
-                schedule_preempt_disabled();
+                preempt_enable_no_resched();
+                schedule();
+                preempt_disable();
                 check_pgt_cache();
                 if (cpu_is_offline(cpu))
                         play_dead();
@@ -393,24 +413,72 @@ ia64_load_extra (struct task_struct *task)
 int
 copy_thread(unsigned long clone_flags,
              unsigned long user_stack_base, unsigned long user_stack_size,
-             struct task_struct *p)
+             struct task_struct *p, struct pt_regs *regs)
 {
         extern char ia64_ret_from_clone;
         struct switch_stack *child_stack, *stack;
         unsigned long rbs, child_rbs, rbs_size;
         struct pt_regs *child_ptregs;
-        struct pt_regs *regs = current_pt_regs();
         int retval = 0;
 
+#ifdef CONFIG_SMP
+        /*
+         * For SMP idle threads, fork_by_hand() calls do_fork with
+         * NULL regs.
+         */
+        if (!regs)
+                return 0;
+#endif
+
+        stack = ((struct switch_stack *) regs) - 1;
+
         child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
         child_stack = (struct switch_stack *) child_ptregs - 1;
 
+        /* copy parent's switch_stack & pt_regs to child: */
+        memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
+
         rbs = (unsigned long) current + IA64_RBS_OFFSET;
         child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
+        rbs_size = stack->ar_bspstore - rbs;
+
+        /* copy the parent's register backing store to the child: */
+        memcpy((void *) child_rbs, (void *) rbs, rbs_size);
+
+        if (likely(user_mode(child_ptregs))) {
+                if (clone_flags & CLONE_SETTLS)
+                        child_ptregs->r13 = regs->r16;  /* see sys_clone2() in entry.S */
+                if (user_stack_base) {
+                        child_ptregs->r12 = user_stack_base + user_stack_size - 16;
+                        child_ptregs->ar_bspstore = user_stack_base;
+                        child_ptregs->ar_rnat = 0;
+                        child_ptregs->loadrs = 0;
+                }
+        } else {
+                /*
+                 * Note: we simply preserve the relative position of
+                 * the stack pointer here.  There is no need to
+                 * allocate a scratch area here, since that will have
+                 * been taken care of by the caller of sys_clone()
+                 * already.
+                 */
+                child_ptregs->r12 = (unsigned long) child_ptregs - 16; /* kernel sp */
+                child_ptregs->r13 = (unsigned long) p;          /* set `current' pointer */
+        }
+        child_stack->ar_bspstore = child_rbs + rbs_size;
+        child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
 
         /* copy parts of thread_struct: */
         p->thread.ksp = (unsigned long) child_stack - 16;
 
+        /* stop some PSR bits from being inherited.
+         * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
+         * therefore we must specify them explicitly here and not include them in
+         * IA64_PSR_BITS_TO_CLEAR.
+         */
+        child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
+                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
+
         /*
          * NOTE: The calling convention considers all floating point
          * registers in the high partition (fph) to be scratch.  Since
@@ -432,66 +500,8 @@ copy_thread(unsigned long clone_flags,
 #       define THREAD_FLAGS_TO_SET      0
         p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
                            | THREAD_FLAGS_TO_SET);
-
         ia64_drop_fpu(p);       /* don't pick up stale state from a CPU's fph */
 
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                if (unlikely(!user_stack_base)) {
-                        /* fork_idle() called us */
-                        return 0;
-                }
-                memset(child_stack, 0, sizeof(*child_ptregs) + sizeof(*child_stack));
-                child_stack->r4 = user_stack_base;      /* payload */
-                child_stack->r5 = user_stack_size;      /* argument */
-                /*
-                 * Preserve PSR bits, except for bits 32-34 and 37-45,
-                 * which we can't read.
-                 */
-                child_ptregs->cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
-                /* mark as valid, empty frame */
-                child_ptregs->cr_ifs = 1UL << 63;
-                child_stack->ar_fpsr = child_ptregs->ar_fpsr
-                        = ia64_getreg(_IA64_REG_AR_FPSR);
-                child_stack->pr = (1 << PRED_KERNEL_STACK);
-                child_stack->ar_bspstore = child_rbs;
-                child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
-
-                /* stop some PSR bits from being inherited.
-                 * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
-                 * therefore we must specify them explicitly here and not include them in
-                 * IA64_PSR_BITS_TO_CLEAR.
-                 */
-                child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
-                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
-
-                return 0;
-        }
-        stack = ((struct switch_stack *) regs) - 1;
-        /* copy parent's switch_stack & pt_regs to child: */
-        memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
-
-        /* copy the parent's register backing store to the child: */
-        rbs_size = stack->ar_bspstore - rbs;
-        memcpy((void *) child_rbs, (void *) rbs, rbs_size);
-        if (clone_flags & CLONE_SETTLS)
-                child_ptregs->r13 = regs->r16;  /* see sys_clone2() in entry.S */
-        if (user_stack_base) {
-                child_ptregs->r12 = user_stack_base + user_stack_size - 16;
-                child_ptregs->ar_bspstore = user_stack_base;
-                child_ptregs->ar_rnat = 0;
-                child_ptregs->loadrs = 0;
-        }
-        child_stack->ar_bspstore = child_rbs + rbs_size;
-        child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
-
-        /* stop some PSR bits from being inherited.
-         * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
-         * therefore we must specify them explicitly here and not include them in
-         * IA64_PSR_BITS_TO_CLEAR.
-         */
-        child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
-                                 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
-
 #ifdef CONFIG_PERFMON
         if (current->thread.pfm_context)
                 pfm_inherit(p, child_ptregs);
@@ -618,6 +628,57 @@ dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
         return 1;       /* f0-f31 are always valid so we always return 1 */
 }
 
+long
+sys_execve (const char __user *filename,
+            const char __user *const __user *argv,
+            const char __user *const __user *envp,
+            struct pt_regs *regs)
+{
+        char *fname;
+        int error;
+
+        fname = getname(filename);
+        error = PTR_ERR(fname);
+        if (IS_ERR(fname))
+                goto out;
+        error = do_execve(fname, argv, envp, regs);
+        putname(fname);
+out:
+        return error;
+}
+
+pid_t
+kernel_thread (int (*fn)(void *), void *arg, unsigned long flags)
+{
+        extern void start_kernel_thread (void);
+        unsigned long *helper_fptr = (unsigned long *) &start_kernel_thread;
+        struct {
+                struct switch_stack sw;
+                struct pt_regs pt;
+        } regs;
+
+        memset(&regs, 0, sizeof(regs));
+        regs.pt.cr_iip = helper_fptr[0];        /* set entry point (IP) */
+        regs.pt.r1 = helper_fptr[1];            /* set GP */
+        regs.pt.r9 = (unsigned long) fn;        /* 1st argument */
+        regs.pt.r11 = (unsigned long) arg;      /* 2nd argument */
+        /* Preserve PSR bits, except for bits 32-34 and 37-45, which we can't read.  */
+        regs.pt.cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
+        regs.pt.cr_ifs = 1UL << 63;             /* mark as valid, empty frame */
+        regs.sw.ar_fpsr = regs.pt.ar_fpsr = ia64_getreg(_IA64_REG_AR_FPSR);
+        regs.sw.ar_bspstore = (unsigned long) current + IA64_RBS_OFFSET;
+        regs.sw.pr = (1 << PRED_KERNEL_STACK);
+        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs.pt, 0, NULL, NULL);
+}
+EXPORT_SYMBOL(kernel_thread);
+
+/* This gets called from kernel_thread() via ia64_invoke_thread_helper().  */
+int
+kernel_thread_helper (int (*fn)(void *), void *arg)
+{
+        return (*fn)(arg);
+}
+
 /*
  * Flush thread state.  This is called when a thread does an execve().
  */
diff --git a/arch/ia64/kernel/ptrace.c b/arch/ia64/kernel/ptrace.c
index 4265ff64219..8848f43d819 100644
--- a/arch/ia64/kernel/ptrace.c
+++ b/arch/ia64/kernel/ptrace.c
@@ -26,6 +26,7 @@
 #include <asm/processor.h>
 #include <asm/ptrace_offsets.h>
 #include <asm/rse.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
 #ifdef CONFIG_PERFMON
@@ -1245,8 +1246,15 @@ syscall_trace_enter (long arg0, long arg1, long arg2, long arg3,
         if (test_thread_flag(TIF_RESTORE_RSE))
                 ia64_sync_krbs();
 
+        if (unlikely(current->audit_context)) {
+                long syscall;
+                int arch;
 
-        audit_syscall_entry(AUDIT_ARCH_IA64, regs.r15, arg0, arg1, arg2, arg3);
+                syscall = regs.r15;
+                arch = AUDIT_ARCH_IA64;
+
+                audit_syscall_entry(arch, syscall, arg0, arg1, arg2, arg3);
+        }
 
         return 0;
 }
@@ -1260,7 +1268,14 @@ syscall_trace_leave (long arg0, long arg1, long arg2, long arg3,
 {
         int step;
 
-        audit_syscall_exit(&regs);
+        if (unlikely(current->audit_context)) {
+                int success = AUDITSC_RESULT(regs.r10);
+                long result = regs.r8;
+
+                if (success != AUDITSC_SUCCESS)
+                        result = -result;
+                audit_syscall_exit(success, result);
+        }
 
         step = test_thread_flag(TIF_SINGLESTEP);
         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
index aaefd9b94f2..5e2c72498c5 100644
--- a/arch/ia64/kernel/setup.c
+++ b/arch/ia64/kernel/setup.c
@@ -59,6 +59,7 @@
 #include <asm/sections.h>
 #include <asm/setup.h>
 #include <asm/smp.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/unistd.h>
 #include <asm/hpsim.h>
@@ -219,23 +220,6 @@ sort_regions (struct rsvd_region *rsvd_region, int max)
         }
 }
 
-/* merge overlaps */
-static int __init
-merge_regions (struct rsvd_region *rsvd_region, int max)
-{
-        int i;
-        for (i = 1; i < max; ++i) {
-                if (rsvd_region[i].start >= rsvd_region[i-1].end)
-                        continue;
-                if (rsvd_region[i].end > rsvd_region[i-1].end)
-                        rsvd_region[i-1].end = rsvd_region[i].end;
-                --max;
-                memmove(&rsvd_region[i], &rsvd_region[i+1],
-                        (max - i) * sizeof(struct rsvd_region));
-        }
-        return max;
-}
-
 /*
  * Request address space for all standard resources
  */
@@ -286,7 +270,6 @@ static void __init setup_crashkernel(unsigned long total, int *n)
         if (ret == 0 && size > 0) {
                 if (!base) {
                         sort_regions(rsvd_region, *n);
-                        *n = merge_regions(rsvd_region, *n);
                         base = kdump_find_rsvd_region(size,
                                         rsvd_region, *n);
                 }
@@ -390,7 +373,6 @@ reserve_memory (void)
         BUG_ON(IA64_MAX_RSVD_REGIONS + 1 < n);
 
         sort_regions(rsvd_region, num_rsvd_regions);
-        num_rsvd_regions = merge_regions(rsvd_region, num_rsvd_regions);
 }
 
 
@@ -485,7 +467,7 @@ mark_bsp_online (void)
 {
 #ifdef CONFIG_SMP
         /* If we register an early console, allow CPU 0 to printk */
-        set_cpu_online(smp_processor_id(), true);
+        cpu_set(smp_processor_id(), cpu_online_map);
 #endif
 }
 
diff --git a/arch/ia64/kernel/signal.c b/arch/ia64/kernel/signal.c
index 680b73786be..7bdafc8788b 100644
--- a/arch/ia64/kernel/signal.c
+++ b/arch/ia64/kernel/signal.c
@@ -30,6 +30,7 @@
 
 #define DEBUG_SIG       0
 #define STACK_ALIGN     16              /* minimal alignment for stack pointer */
+#define _BLOCKABLE      (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
 #if _NSIG_WORDS > 1
 # define PUT_SIGSET(k,u)        __copy_to_user((u)->sig, (k)->sig, sizeof(sigset_t))
@@ -199,7 +200,14 @@ ia64_rt_sigreturn (struct sigscratch *scr)
         if (GET_SIGSET(&set, &sc->sc_mask))
                 goto give_sigsegv;
 
-        set_current_blocked(&set);
+        sigdelsetmask(&set, ~_BLOCKABLE);
+
+        spin_lock_irq(&current->sighand->siglock);
+        {
+                current->blocked = set;
+                recalc_sigpending();
+        }
+        spin_unlock_irq(&current->sighand->siglock);
 
         if (restore_sigcontext(sc, scr))
                 goto give_sigsegv;
@@ -220,7 +228,7 @@ ia64_rt_sigreturn (struct sigscratch *scr)
         si.si_errno = 0;
         si.si_code = SI_KERNEL;
         si.si_pid = task_pid_vnr(current);
-        si.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+        si.si_uid = current_uid();
         si.si_addr = sc;
         force_sig_info(SIGSEGV, &si, current);
         return retval;
@@ -317,7 +325,7 @@ force_sigsegv_info (int sig, void __user *addr)
         si.si_errno = 0;
         si.si_code = SI_KERNEL;
         si.si_pid = task_pid_vnr(current);
-        si.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+        si.si_uid = current_uid();
         si.si_addr = addr;
         force_sig_info(SIGSEGV, &si, current);
         return 0;
@@ -413,13 +421,23 @@ setup_frame (int sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *set,
 }
 
 static long
-handle_signal (unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
+handle_signal (unsigned long sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *oldset,
                struct sigscratch *scr)
 {
-        if (!setup_frame(sig, ka, info, sigmask_to_save(), scr))
+        if (!setup_frame(sig, ka, info, oldset, scr))
                 return 0;
 
-        signal_delivered(sig, info, ka, &scr->pt,
+        spin_lock_irq(&current->sighand->siglock);
+        sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
+        if (!(ka->sa.sa_flags & SA_NODEFER))
+                sigaddset(&current->blocked, sig);
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+
+        /*
+         * Let tracing know that we've done the handler setup.
+         */
+        tracehook_signal_handler(sig, info, ka, &scr->pt,
                                  test_thread_flag(TIF_SINGLESTEP));
 
         return 1;
@@ -433,11 +451,25 @@ void
 ia64_do_signal (struct sigscratch *scr, long in_syscall)
 {
         struct k_sigaction ka;
+        sigset_t *oldset;
         siginfo_t info;
         long restart = in_syscall;
         long errno = scr->pt.r8;
 
         /*
+         * In the ia64_leave_kernel code path, we want the common case to go fast, which
+         * is why we may in certain cases get here from kernel mode. Just return without
+         * doing anything if so.
+         */
+        if (!user_mode(&scr->pt))
+                return;
+
+        if (current_thread_info()->status & TS_RESTORE_SIGMASK)
+                oldset = &current->saved_sigmask;
+        else
+                oldset = &current->blocked;
+
+        /*
          * This only loops in the rare cases of handle_signal() failing, in which case we
          * need to push through a forced SIGSEGV.
          */
@@ -486,8 +518,16 @@ ia64_do_signal (struct sigscratch *scr, long in_syscall)
                  * Whee!  Actually deliver the signal.  If the delivery failed, we need to
                  * continue to iterate in this loop so we can deliver the SIGSEGV...
                  */
-                if (handle_signal(signr, &ka, &info, scr))
+                if (handle_signal(signr, &ka, &info, oldset, scr)) {
+                        /*
+                         * A signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TS_RESTORE_SIGMASK flag.
+                         */
+                        current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
                         return;
+                }
         }
 
         /* Did we come from a system call? */
@@ -509,5 +549,8 @@ ia64_do_signal (struct sigscratch *scr, long in_syscall)
 
         /* if there's no signal to deliver, we just put the saved sigmask
          * back */
-        restore_saved_sigmask();
+        if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
+                current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
diff --git a/arch/ia64/kernel/smp.c b/arch/ia64/kernel/smp.c
index 9fcd4e63048..0bd537b4ea6 100644
--- a/arch/ia64/kernel/smp.c
+++ b/arch/ia64/kernel/smp.c
@@ -44,6 +44,7 @@
 #include <asm/processor.h>
 #include <asm/ptrace.h>
 #include <asm/sal.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/unistd.h>
 #include <asm/mca.h>
@@ -76,7 +77,7 @@ stop_this_cpu(void)
         /*
          * Remove this CPU:
          */
-        set_cpu_online(smp_processor_id(), false);
+        cpu_clear(smp_processor_id(), cpu_online_map);
         max_xtp();
         local_irq_disable();
         cpu_halt();
diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
index 500f1e4d9f9..55909798667 100644
--- a/arch/ia64/kernel/smpboot.c
+++ b/arch/ia64/kernel/smpboot.c
@@ -55,6 +55,7 @@
 #include <asm/processor.h>
 #include <asm/ptrace.h>
 #include <asm/sal.h>
+#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/unistd.h>
 #include <asm/sn/arch.h>
@@ -75,6 +76,13 @@
 #endif
 
 /*
+ * Store all idle threads, this can be reused instead of creating
+ * a new thread. Also avoids complicated thread destroy functionality
+ * for idle threads.
+ */
+struct task_struct *idle_thread_array[NR_CPUS];
+
+/*
  * Global array allocated for NR_CPUS at boot time
  */
 struct sal_to_os_boot sal_boot_rendez_state[NR_CPUS];
@@ -87,7 +95,13 @@ struct sal_to_os_boot *sal_state_for_booting_cpu = &sal_boot_rendez_state[0];
 
 #define set_brendez_area(x) (sal_state_for_booting_cpu = &sal_boot_rendez_state[(x)]);
 
+#define get_idle_for_cpu(x)             (idle_thread_array[(x)])
+#define set_idle_for_cpu(x,p)   (idle_thread_array[(x)] = (p))
+
 #else
+
+#define get_idle_for_cpu(x)             (NULL)
+#define set_idle_for_cpu(x,p)
 #define set_brendez_area(x)
 #endif
 
@@ -347,7 +361,8 @@ ia64_sync_itc (unsigned int master)
 /*
  * Ideally sets up per-cpu profiling hooks.  Doesn't do much now...
  */
-static inline void smp_setup_percpu_timer(void)
+static inline void __devinit
+smp_setup_percpu_timer (void)
 {
 }
 
@@ -381,13 +396,15 @@ smp_callin (void)
         set_numa_node(cpu_to_node_map[cpuid]);
         set_numa_mem(local_memory_node(cpu_to_node_map[cpuid]));
 
+        ipi_call_lock_irq();
         spin_lock(&vector_lock);
         /* Setup the per cpu irq handling data structures */
         __setup_vector_irq(cpuid);
         notify_cpu_starting(cpuid);
-        set_cpu_online(cpuid, true);
+        cpu_set(cpuid, cpu_online_map);
         per_cpu(cpu_state, cpuid) = CPU_ONLINE;
         spin_unlock(&vector_lock);
+        ipi_call_unlock_irq();
 
         smp_setup_percpu_timer();
 
@@ -459,12 +476,59 @@ start_secondary (void *unused)
         return 0;
 }
 
+struct pt_regs * __cpuinit idle_regs(struct pt_regs *regs)
+{
+        return NULL;
+}
+
+struct create_idle {
+        struct work_struct work;
+        struct task_struct *idle;
+        struct completion done;
+        int cpu;
+};
+
+void __cpuinit
+do_fork_idle(struct work_struct *work)
+{
+        struct create_idle *c_idle =
+                container_of(work, struct create_idle, work);
+
+        c_idle->idle = fork_idle(c_idle->cpu);
+        complete(&c_idle->done);
+}
+
 static int __cpuinit
-do_boot_cpu (int sapicid, int cpu, struct task_struct *idle)
+do_boot_cpu (int sapicid, int cpu)
 {
         int timeout;
+        struct create_idle c_idle = {
+                .work = __WORK_INITIALIZER(c_idle.work, do_fork_idle),
+                .cpu    = cpu,
+                .done   = COMPLETION_INITIALIZER(c_idle.done),
+        };
+
+        /*
+         * We can't use kernel_thread since we must avoid to
+         * reschedule the child.
+         */
+        c_idle.idle = get_idle_for_cpu(cpu);
+        if (c_idle.idle) {
+                init_idle(c_idle.idle, cpu);
+                goto do_rest;
+        }
+
+        schedule_work(&c_idle.work);
+        wait_for_completion(&c_idle.done);
+
+        if (IS_ERR(c_idle.idle))
+                panic("failed fork for CPU %d", cpu);
+
+        set_idle_for_cpu(cpu, c_idle.idle);
+
+do_rest:
+        task_for_booting_cpu = c_idle.idle;
 
-        task_for_booting_cpu = idle;
         Dprintk("Sending wakeup vector %lu to AP 0x%x/0x%x.\n", ap_wakeup_vector, cpu, sapicid);
 
         set_brendez_area(cpu);
@@ -484,7 +548,7 @@ do_boot_cpu (int sapicid, int cpu, struct task_struct *idle)
         if (!cpu_isset(cpu, cpu_callin_map)) {
                 printk(KERN_ERR "Processor 0x%x/0x%x is stuck.\n", cpu, sapicid);
                 ia64_cpu_to_sapicid[cpu] = -1;
-                set_cpu_online(cpu, false);  /* was set in smp_callin() */
+                cpu_clear(cpu, cpu_online_map);  /* was set in smp_callin() */
                 return -EINVAL;
         }
         return 0;
@@ -514,7 +578,8 @@ smp_build_cpu_map (void)
         }
 
         ia64_cpu_to_sapicid[0] = boot_cpu_id;
-        init_cpu_present(cpumask_of(0));
+        cpus_clear(cpu_present_map);
+        set_cpu_present(0, true);
         set_cpu_possible(0, true);
         for (cpu = 1, i = 0; i < smp_boot_data.cpu_count; i++) {
                 sapicid = smp_boot_data.cpu_phys_id[i];
@@ -541,6 +606,10 @@ smp_prepare_cpus (unsigned int max_cpus)
 
         smp_setup_percpu_timer();
 
+        /*
+         * We have the boot CPU online for sure.
+         */
+        cpu_set(0, cpu_online_map);
         cpu_set(0, cpu_callin_map);
 
         local_cpu_data->loops_per_jiffy = loops_per_jiffy;
@@ -562,9 +631,9 @@ smp_prepare_cpus (unsigned int max_cpus)
         }
 }
 
-void smp_prepare_boot_cpu(void)
+void __devinit smp_prepare_boot_cpu(void)
 {
-        set_cpu_online(smp_processor_id(), true);
+        cpu_set(smp_processor_id(), cpu_online_map);
         cpu_set(smp_processor_id(), cpu_callin_map);
         set_numa_node(cpu_to_node_map[smp_processor_id()]);
         per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
@@ -621,7 +690,7 @@ int migrate_platform_irqs(unsigned int cpu)
                         /*
                          * Now re-target the CPEI to a different processor
                          */
-                        new_cpei_cpu = cpumask_any(cpu_online_mask);
+                        new_cpei_cpu = any_online_cpu(cpu_online_map);
                         mask = cpumask_of(new_cpei_cpu);
                         set_cpei_target_cpu(new_cpei_cpu);
                         data = irq_get_irq_data(ia64_cpe_irq);
@@ -663,10 +732,10 @@ int __cpu_disable(void)
                         return -EBUSY;
         }
 
-        set_cpu_online(cpu, false);
+        cpu_clear(cpu, cpu_online_map);
 
         if (migrate_platform_irqs(cpu)) {
-                set_cpu_online(cpu, true);
+                cpu_set(cpu, cpu_online_map);
                 return -EBUSY;
         }
 
@@ -712,7 +781,8 @@ smp_cpus_done (unsigned int dummy)
                (int)num_online_cpus(), bogosum/(500000/HZ), (bogosum/(5000/HZ))%100);
 }
 
-static inline void set_cpu_sibling_map(int cpu)
+static inline void __devinit
+set_cpu_sibling_map(int cpu)
 {
         int i;
 
@@ -729,7 +799,7 @@ static inline void set_cpu_sibling_map(int cpu)
 }
 
 int __cpuinit
-__cpu_up(unsigned int cpu, struct task_struct *tidle)
+__cpu_up (unsigned int cpu)
 {
         int ret;
         int sapicid;
@@ -747,7 +817,7 @@ __cpu_up(unsigned int cpu, struct task_struct *tidle)
 
         per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
         /* Processor goes to start_secondary(), sets online flag */
-        ret = do_boot_cpu(sapicid, cpu, tidle);
+        ret = do_boot_cpu(sapicid, cpu);
         if (ret < 0)
                 return ret;
 
@@ -791,7 +861,8 @@ init_smp_config(void)
  * identify_siblings(cpu) gets called from identify_cpu. This populates the 
  * information related to logical execution units in per_cpu_data structure.
  */
-void identify_siblings(struct cpuinfo_ia64 *c)
+void __devinit
+identify_siblings(struct cpuinfo_ia64 *c)
 {
         long status;
         u16 pltid;
diff --git a/arch/ia64/kernel/sys_ia64.c b/arch/ia64/kernel/sys_ia64.c
index d9439ef2f66..609d50056a6 100644
--- a/arch/ia64/kernel/sys_ia64.c
+++ b/arch/ia64/kernel/sys_ia64.c
@@ -171,9 +171,22 @@ asmlinkage unsigned long
 ia64_mremap (unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags,
              unsigned long new_addr)
 {
-        addr = sys_mremap(addr, old_len, new_len, flags, new_addr);
-        if (!IS_ERR((void *) addr))
-                force_successful_syscall_return();
+        extern unsigned long do_mremap (unsigned long addr,
+                                        unsigned long old_len,
+                                        unsigned long new_len,
+                                        unsigned long flags,
+                                        unsigned long new_addr);
+
+        down_write(&current->mm->mmap_sem);
+        {
+                addr = do_mremap(addr, old_len, new_len, flags, new_addr);
+        }
+        up_write(&current->mm->mmap_sem);
+
+        if (IS_ERR((void *) addr))
+                return addr;
+
+        force_successful_syscall_return();
         return addr;
 }
 
diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index 88a794536bc..43920de425f 100644
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -19,7 +19,7 @@
 #include <linux/interrupt.h>
 #include <linux/efi.h>
 #include <linux/timex.h>
-#include <linux/timekeeper_internal.h>
+#include <linux/clocksource.h>
 #include <linux/platform_device.h>
 
 #include <asm/machvec.h>
@@ -29,12 +29,15 @@
 #include <asm/ptrace.h>
 #include <asm/sal.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 
 #include "fsyscall_gtod_data.h"
 
 static cycle_t itc_get_cycles(struct clocksource *cs);
 
-struct fsyscall_gtod_data_t fsyscall_gtod_data;
+struct fsyscall_gtod_data_t fsyscall_gtod_data = {
+        .lock = __SEQLOCK_UNLOCKED(fsyscall_gtod_data.lock),
+};
 
 struct itc_jitter_data_t itc_jitter_data;
 
@@ -83,29 +86,32 @@ static struct clocksource *itc_clocksource;
 
 extern cputime_t cycle_to_cputime(u64 cyc);
 
-void vtime_account_user(struct task_struct *tsk)
-{
-        cputime_t delta_utime;
-        struct thread_info *ti = task_thread_info(tsk);
-
-        if (ti->ac_utime) {
-                delta_utime = cycle_to_cputime(ti->ac_utime);
-                account_user_time(tsk, delta_utime, delta_utime);
-                ti->ac_utime = 0;
-        }
-}
-
 /*
  * Called from the context switch with interrupts disabled, to charge all
  * accumulated times to the current process, and to prepare accounting on
  * the next process.
  */
-void arch_vtime_task_switch(struct task_struct *prev)
+void ia64_account_on_switch(struct task_struct *prev, struct task_struct *next)
 {
         struct thread_info *pi = task_thread_info(prev);
-        struct thread_info *ni = task_thread_info(current);
+        struct thread_info *ni = task_thread_info(next);
+        cputime_t delta_stime, delta_utime;
+        __u64 now;
+
+        now = ia64_get_itc();
+
+        delta_stime = cycle_to_cputime(pi->ac_stime + (now - pi->ac_stamp));
+        if (idle_task(smp_processor_id()) != prev)
+                account_system_time(prev, 0, delta_stime, delta_stime);
+        else
+                account_idle_time(delta_stime);
 
-        pi->ac_stamp = ni->ac_stamp;
+        if (pi->ac_utime) {
+                delta_utime = cycle_to_cputime(pi->ac_utime);
+                account_user_time(prev, delta_utime, delta_utime);
+        }
+
+        pi->ac_stamp = ni->ac_stamp = now;
         ni->ac_stime = ni->ac_utime = 0;
 }
 
@@ -113,33 +119,44 @@ void arch_vtime_task_switch(struct task_struct *prev)
  * Account time for a transition between system, hard irq or soft irq state.
  * Note that this function is called with interrupts enabled.
  */
-static cputime_t vtime_delta(struct task_struct *tsk)
+void account_system_vtime(struct task_struct *tsk)
 {
         struct thread_info *ti = task_thread_info(tsk);
+        unsigned long flags;
         cputime_t delta_stime;
         __u64 now;
 
-        WARN_ON_ONCE(!irqs_disabled());
+        local_irq_save(flags);
 
         now = ia64_get_itc();
 
         delta_stime = cycle_to_cputime(ti->ac_stime + (now - ti->ac_stamp));
+        if (irq_count() || idle_task(smp_processor_id()) != tsk)
+                account_system_time(tsk, 0, delta_stime, delta_stime);
+        else
+                account_idle_time(delta_stime);
         ti->ac_stime = 0;
+
         ti->ac_stamp = now;
 
-        return delta_stime;
+        local_irq_restore(flags);
 }
+EXPORT_SYMBOL_GPL(account_system_vtime);
 
-void vtime_account_system(struct task_struct *tsk)
+/*
+ * Called from the timer interrupt handler to charge accumulated user time
+ * to the current process.  Must be called with interrupts disabled.
+ */
+void account_process_tick(struct task_struct *p, int user_tick)
 {
-        cputime_t delta = vtime_delta(tsk);
-
-        account_system_time(tsk, 0, delta, delta);
-}
+        struct thread_info *ti = task_thread_info(p);
+        cputime_t delta_utime;
 
-void vtime_account_idle(struct task_struct *tsk)
-{
-        account_idle_time(vtime_delta(tsk));
+        if (ti->ac_utime) {
+                delta_utime = cycle_to_cputime(ti->ac_utime);
+                account_user_time(p, delta_utime, delta_utime);
+                ti->ac_utime = 0;
+        }
 }
 
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING */
@@ -243,7 +260,8 @@ static int __init nojitter_setup(char *str)
 __setup("nojitter", nojitter_setup);
 
 
-void ia64_init_itm(void)
+void __devinit
+ia64_init_itm (void)
 {
         unsigned long platform_base_freq, itc_freq;
         struct pal_freq_ratio itc_ratio, proc_ratio;
@@ -439,10 +457,12 @@ void update_vsyscall_tz(void)
 {
 }
 
-void update_vsyscall_old(struct timespec *wall, struct timespec *wtm,
+void update_vsyscall(struct timespec *wall, struct timespec *wtm,
                         struct clocksource *c, u32 mult)
 {
-        write_seqcount_begin(&fsyscall_gtod_data.seq);
+        unsigned long flags;
+
+        write_seqlock_irqsave(&fsyscall_gtod_data.lock, flags);
 
         /* copy fsyscall clock data */
         fsyscall_gtod_data.clk_mask = c->mask;
@@ -465,6 +485,6 @@ void update_vsyscall_old(struct timespec *wall, struct timespec *wtm,
                 fsyscall_gtod_data.monotonic_time.tv_sec++;
         }
 
-        write_seqcount_end(&fsyscall_gtod_data.seq);
+        write_sequnlock_irqrestore(&fsyscall_gtod_data.lock, flags);
 }
 
diff --git a/arch/ia64/kernel/topology.c b/arch/ia64/kernel/topology.c
index dc00b2c1b42..0e0e0cc9e39 100644
--- a/arch/ia64/kernel/topology.c
+++ b/arch/ia64/kernel/topology.c
@@ -22,7 +22,6 @@
 #include <linux/bootmem.h>
 #include <linux/nodemask.h>
 #include <linux/notifier.h>
-#include <linux/export.h>
 #include <asm/mmzone.h>
 #include <asm/numa.h>
 #include <asm/cpu.h>
@@ -220,8 +219,7 @@ static ssize_t show_shared_cpu_map(struct cache_info *this_leaf, char *buf)
         ssize_t len;
         cpumask_t shared_cpu_map;
 
-        cpumask_and(&shared_cpu_map,
-                                &this_leaf->shared_cpu_map, cpu_online_mask);
+        cpus_and(shared_cpu_map, this_leaf->shared_cpu_map, cpu_online_map);
         len = cpumask_scnprintf(buf, NR_CPUS+1, &shared_cpu_map);
         len += sprintf(buf+len, "\n");
         return len;
@@ -275,7 +273,7 @@ static struct attribute * cache_default_attrs[] = {
 #define to_object(k) container_of(k, struct cache_info, kobj)
 #define to_attr(a) container_of(a, struct cache_attr, attr)
 
-static ssize_t ia64_cache_show(struct kobject * kobj, struct attribute * attr, char * buf)
+static ssize_t cache_show(struct kobject * kobj, struct attribute * attr, char * buf)
 {
         struct cache_attr *fattr = to_attr(attr);
         struct cache_info *this_leaf = to_object(kobj);
@@ -286,7 +284,7 @@ static ssize_t ia64_cache_show(struct kobject * kobj, struct attribute * attr, c
 }
 
 static const struct sysfs_ops cache_sysfs_ops = {
-        .show   = ia64_cache_show
+        .show   = cache_show
 };
 
 static struct kobj_type cache_ktype = {
@@ -351,7 +349,7 @@ static int __cpuinit cpu_cache_sysfs_init(unsigned int cpu)
 }
 
 /* Add cache interface for CPU device */
-static int __cpuinit cache_add_dev(struct device * sys_dev)
+static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
 {
         unsigned int cpu = sys_dev->id;
         unsigned long i, j;
@@ -401,7 +399,7 @@ static int __cpuinit cache_add_dev(struct device * sys_dev)
 }
 
 /* Remove cache interface for CPU device */
-static int __cpuinit cache_remove_dev(struct device * sys_dev)
+static int __cpuinit cache_remove_dev(struct sys_device * sys_dev)
 {
         unsigned int cpu = sys_dev->id;
         unsigned long i;
@@ -429,9 +427,9 @@ static int __cpuinit cache_cpu_callback(struct notifier_block *nfb,
                 unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
-        struct device *sys_dev;
+        struct sys_device *sys_dev;
 
-        sys_dev = get_cpu_device(cpu);
+        sys_dev = get_cpu_sysdev(cpu);
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
@@ -455,7 +453,7 @@ static int __init cache_sysfs_init(void)
         int i;
 
         for_each_online_cpu(i) {
-                struct device *sys_dev = get_cpu_device((unsigned int)i);
+                struct sys_device *sys_dev = get_cpu_sysdev((unsigned int)i);
                 cache_add_dev(sys_dev);
         }
 
diff --git a/arch/ia64/kernel/traps.c b/arch/ia64/kernel/traps.c
index bd42b76000d..fd80e70018a 100644
--- a/arch/ia64/kernel/traps.c
+++ b/arch/ia64/kernel/traps.c
@@ -22,7 +22,6 @@
 #include <asm/intrinsics.h>
 #include <asm/processor.h>
 #include <asm/uaccess.h>
-#include <asm/setup.h>
 
 fpswa_interface_t *fpswa_interface;
 EXPORT_SYMBOL(fpswa_interface);
diff --git a/arch/ia64/kernel/uncached.c b/arch/ia64/kernel/uncached.c
index a96bcf83a73..6a867dc45c0 100644
--- a/arch/ia64/kernel/uncached.c
+++ b/arch/ia64/kernel/uncached.c
@@ -23,6 +23,7 @@
 #include <linux/gfp.h>
 #include <asm/page.h>
 #include <asm/pal.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 #include <linux/atomic.h>
 #include <asm/tlbflush.h>
diff --git a/arch/ia64/kernel/unwind.c b/arch/ia64/kernel/unwind.c
index 8f66195999e..fed6afa2e8a 100644
--- a/arch/ia64/kernel/unwind.c
+++ b/arch/ia64/kernel/unwind.c
@@ -41,6 +41,7 @@
 #include <asm/ptrace_offsets.h>
 #include <asm/rse.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 
 #include "entry.h"
diff --git a/arch/ia64/kernel/vmlinux.lds.S b/arch/ia64/kernel/vmlinux.lds.S
index 0ccb28fab27..53c0ba004e9 100644
--- a/arch/ia64/kernel/vmlinux.lds.S
+++ b/arch/ia64/kernel/vmlinux.lds.S
@@ -1,6 +1,7 @@
 
 #include <asm/cache.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 
 #include <asm-generic/vmlinux.lds.h>
diff --git a/arch/ia64/kvm/Kconfig b/arch/ia64/kvm/Kconfig
index e7947528aee..9806e55f91b 100644
--- a/arch/ia64/kvm/Kconfig
+++ b/arch/ia64/kvm/Kconfig
@@ -19,11 +19,9 @@ if VIRTUALIZATION
 
 config KVM
         tristate "Kernel-based Virtual Machine (KVM) support"
-        depends on BROKEN
         depends on HAVE_KVM && MODULES && EXPERIMENTAL
         # for device assignment:
         depends on PCI
-        depends on BROKEN
         select PREEMPT_NOTIFIERS
         select ANON_INODES
         select HAVE_KVM_IRQCHIP
diff --git a/arch/ia64/kvm/kvm-ia64.c b/arch/ia64/kvm/kvm-ia64.c
index bd1c5155503..43f4c92816e 100644
--- a/arch/ia64/kvm/kvm-ia64.c
+++ b/arch/ia64/kvm/kvm-ia64.c
@@ -1,5 +1,5 @@
 /*
- * kvm_ia64.c: Basic KVM support On Itanium series processors
+ * kvm_ia64.c: Basic KVM suppport On Itanium series processors
  *
  *
  *      Copyright (C) 2007, Intel Corporation.
@@ -232,12 +232,12 @@ static int handle_mmio(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         if ((p->addr & PAGE_MASK) == IOAPIC_DEFAULT_BASE_ADDRESS)
                 goto mmio;
         vcpu->mmio_needed = 1;
-        vcpu->mmio_fragments[0].gpa = kvm_run->mmio.phys_addr = p->addr;
-        vcpu->mmio_fragments[0].len = kvm_run->mmio.len = p->size;
+        vcpu->mmio_phys_addr = kvm_run->mmio.phys_addr = p->addr;
+        vcpu->mmio_size = kvm_run->mmio.len = p->size;
         vcpu->mmio_is_write = kvm_run->mmio.is_write = !p->dir;
 
         if (vcpu->mmio_is_write)
-                memcpy(vcpu->arch.mmio_data, &p->data, p->size);
+                memcpy(vcpu->mmio_data, &p->data, p->size);
         memcpy(kvm_run->mmio.data, &p->data, p->size);
         kvm_run->exit_reason = KVM_EXIT_MMIO;
         return 0;
@@ -719,7 +719,7 @@ static void kvm_set_mmio_data(struct kvm_vcpu *vcpu)
         struct kvm_mmio_req *p = kvm_get_vcpu_ioreq(vcpu);
 
         if (!vcpu->mmio_is_write)
-                memcpy(&p->data, vcpu->arch.mmio_data, 8);
+                memcpy(&p->data, vcpu->mmio_data, 8);
         p->state = STATE_IORESP_READY;
 }
 
@@ -739,7 +739,7 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         }
 
         if (vcpu->mmio_needed) {
-                memcpy(vcpu->arch.mmio_data, kvm_run->mmio.data, 8);
+                memcpy(vcpu->mmio_data, kvm_run->mmio.data, 8);
                 kvm_set_mmio_data(vcpu);
                 vcpu->mmio_read_completed = 1;
                 vcpu->mmio_needed = 0;
@@ -774,13 +774,13 @@ struct kvm *kvm_arch_alloc_vm(void)
         return kvm;
 }
 
-struct kvm_ia64_io_range {
+struct kvm_io_range {
         unsigned long start;
         unsigned long size;
         unsigned long type;
 };
 
-static const struct kvm_ia64_io_range io_ranges[] = {
+static const struct kvm_io_range io_ranges[] = {
         {VGA_IO_START, VGA_IO_SIZE, GPFN_FRAME_BUFFER},
         {MMIO_START, MMIO_SIZE, GPFN_LOW_MMIO},
         {LEGACY_IO_START, LEGACY_IO_SIZE, GPFN_LEGACY_IO},
@@ -809,13 +809,10 @@ static void kvm_build_io_pmt(struct kvm *kvm)
 #define GUEST_PHYSICAL_RR4      0x2739
 #define VMM_INIT_RR             0x1660
 
-int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
+int kvm_arch_init_vm(struct kvm *kvm)
 {
         BUG_ON(!kvm);
 
-        if (type)
-                return -EINVAL;
-
         kvm->arch.is_sn2 = ia64_platform_is("sn2");
 
         kvm->arch.metaphysical_rr0 = GUEST_PHYSICAL_RR0;
@@ -924,16 +921,6 @@ int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
         return 0;
 }
 
-int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_event)
-{
-        if (!irqchip_in_kernel(kvm))
-                return -ENXIO;
-
-        irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID,
-                                        irq_event->irq, irq_event->level);
-        return 0;
-}
-
 long kvm_arch_vm_ioctl(struct file *filp,
                 unsigned int ioctl, unsigned long arg)
 {
@@ -973,6 +960,29 @@ long kvm_arch_vm_ioctl(struct file *filp,
                         goto out;
                 }
                 break;
+        case KVM_IRQ_LINE_STATUS:
+        case KVM_IRQ_LINE: {
+                struct kvm_irq_level irq_event;
+
+                r = -EFAULT;
+                if (copy_from_user(&irq_event, argp, sizeof irq_event))
+                        goto out;
+                r = -ENXIO;
+                if (irqchip_in_kernel(kvm)) {
+                        __s32 status;
+                        status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID,
+                                    irq_event.irq, irq_event.level);
+                        if (ioctl == KVM_IRQ_LINE_STATUS) {
+                                r = -EFAULT;
+                                irq_event.status = status;
+                                if (copy_to_user(argp, &irq_event,
+                                                        sizeof irq_event))
+                                        goto out;
+                        }
+                        r = 0;
+                }
+                break;
+                }
         case KVM_GET_IRQCHIP: {
                 /* 0: PIC master, 1: PIC slave, 2: IOAPIC */
                 struct kvm_irqchip chip;
@@ -1159,11 +1169,6 @@ out:
 
 #define PALE_RESET_ENTRY    0x80000000ffffffb0UL
 
-bool kvm_vcpu_compatible(struct kvm_vcpu *vcpu)
-{
-        return irqchip_in_kernel(vcpu->kvm) == (vcpu->arch.apic != NULL);
-}
-
 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
 {
         struct kvm_vcpu *v;
@@ -1330,11 +1335,6 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
         return 0;
 }
 
-int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
-{
-        return 0;
-}
-
 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
 {
         return -EINVAL;
@@ -1366,10 +1366,14 @@ static void kvm_release_vm_pages(struct kvm *kvm)
 {
         struct kvm_memslots *slots;
         struct kvm_memory_slot *memslot;
-        int j;
+        int i, j;
+        unsigned long base_gfn;
 
         slots = kvm_memslots(kvm);
-        kvm_for_each_memslot(memslot, slots) {
+        for (i = 0; i < slots->nmemslots; i++) {
+                memslot = &slots->memslots[i];
+                base_gfn = memslot->base_gfn;
+
                 for (j = 0; j < memslot->npages; j++) {
                         if (memslot->rmap[j])
                                 put_page((struct page *)memslot->rmap[j]);
@@ -1561,21 +1565,6 @@ out:
         return r;
 }
 
-int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
-{
-        return VM_FAULT_SIGBUS;
-}
-
-void kvm_arch_free_memslot(struct kvm_memory_slot *free,
-                           struct kvm_memory_slot *dont)
-{
-}
-
-int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
-{
-        return 0;
-}
-
 int kvm_arch_prepare_memory_region(struct kvm *kvm,
                 struct kvm_memory_slot *memslot,
                 struct kvm_memory_slot old,
@@ -1616,17 +1605,11 @@ void kvm_arch_commit_memory_region(struct kvm *kvm,
         return;
 }
 
-void kvm_arch_flush_shadow_all(struct kvm *kvm)
+void kvm_arch_flush_shadow(struct kvm *kvm)
 {
         kvm_flush_remote_tlbs(kvm);
 }
 
-void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
-                                   struct kvm_memory_slot *slot)
-{
-        kvm_arch_flush_shadow_all();
-}
-
 long kvm_arch_dev_ioctl(struct file *filp,
                         unsigned int ioctl, unsigned long arg)
 {
@@ -1837,7 +1820,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
         if (log->slot >= KVM_MEMORY_SLOTS)
                 goto out;
 
-        memslot = id_to_memslot(kvm->memslots, log->slot);
+        memslot = &kvm->memslots->memslots[log->slot];
         r = -ENOENT;
         if (!memslot->dirty_bitmap)
                 goto out;
@@ -1868,6 +1851,21 @@ void kvm_arch_hardware_unsetup(void)
 {
 }
 
+void kvm_vcpu_kick(struct kvm_vcpu *vcpu)
+{
+        int me;
+        int cpu = vcpu->cpu;
+
+        if (waitqueue_active(&vcpu->wq))
+                wake_up_interruptible(&vcpu->wq);
+
+        me = get_cpu();
+        if (cpu != me && (unsigned) cpu < nr_cpu_ids && cpu_online(cpu))
+                if (!test_and_set_bit(KVM_REQ_KICK, &vcpu->requests))
+                        smp_send_reschedule(cpu);
+        put_cpu();
+}
+
 int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq)
 {
         return __apic_accept_irq(vcpu, irq->vector);
@@ -1937,11 +1935,6 @@ int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
                 (kvm_highest_pending_irq(vcpu) != -1);
 }
 
-int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
-{
-        return (!test_and_set_bit(KVM_REQ_KICK, &vcpu->requests));
-}
-
 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
                                     struct kvm_mp_state *mp_state)
 {
diff --git a/arch/ia64/kvm/vmm.c b/arch/ia64/kvm/vmm.c
index 176a12cd56d..f0b9cac8241 100644
--- a/arch/ia64/kvm/vmm.c
+++ b/arch/ia64/kvm/vmm.c
@@ -20,9 +20,9 @@
  */
 
 
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <asm/fpswa.h>
+#include<linux/kernel.h>
+#include<linux/module.h>
+#include<asm/fpswa.h>
 
 #include "vcpu.h"
 
diff --git a/arch/ia64/mm/contig.c b/arch/ia64/mm/contig.c
index 1516d1dc11f..f114a3b14c6 100644
--- a/arch/ia64/mm/contig.c
+++ b/arch/ia64/mm/contig.c
@@ -16,7 +16,6 @@
  */
 #include <linux/bootmem.h>
 #include <linux/efi.h>
-#include <linux/memblock.h>
 #include <linux/mm.h>
 #include <linux/nmi.h>
 #include <linux/swap.h>
@@ -349,7 +348,7 @@ paging_init (void)
                 printk("Virtual mem_map starts at 0x%p\n", mem_map);
         }
 #else /* !CONFIG_VIRTUAL_MEM_MAP */
-        memblock_add_node(0, PFN_PHYS(max_low_pfn), 0);
+        add_active_range(0, 0, max_low_pfn);
         free_area_init_nodes(max_zone_pfns);
 #endif /* !CONFIG_VIRTUAL_MEM_MAP */
         zero_page_memmap_ptr = virt_to_page(ia64_imva(empty_zero_page));
diff --git a/arch/ia64/mm/fault.c b/arch/ia64/mm/fault.c
index 6cf0341f978..20b35937612 100644
--- a/arch/ia64/mm/fault.c
+++ b/arch/ia64/mm/fault.c
@@ -14,6 +14,7 @@
 
 #include <asm/pgtable.h>
 #include <asm/processor.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 
 extern int die(char *, struct pt_regs *, long);
@@ -72,10 +73,6 @@ mapped_kernel_page_is_present (unsigned long address)
         return pte_present(pte);
 }
 
-#       define VM_READ_BIT      0
-#       define VM_WRITE_BIT     1
-#       define VM_EXEC_BIT      2
-
 void __kprobes
 ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *regs)
 {
@@ -85,12 +82,6 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re
         struct siginfo si;
         unsigned long mask;
         int fault;
-        unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
-
-        mask = ((((isr >> IA64_ISR_X_BIT) & 1UL) << VM_EXEC_BIT)
-                | (((isr >> IA64_ISR_W_BIT) & 1UL) << VM_WRITE_BIT));
-
-        flags |= ((mask & VM_WRITE) ? FAULT_FLAG_WRITE : 0);
 
         /* mmap_sem is performance critical.... */
         prefetchw(&mm->mmap_sem);
@@ -119,7 +110,6 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re
         if (notify_page_fault(regs, TRAP_BRKPT))
                 return;
 
-retry:
         down_read(&mm->mmap_sem);
 
         vma = find_vma_prev(mm, address, &prev_vma);
@@ -141,6 +131,10 @@ retry:
 
         /* OK, we've got a good vm_area for this memory area.  Check the access permissions: */
 
+#       define VM_READ_BIT      0
+#       define VM_WRITE_BIT     1
+#       define VM_EXEC_BIT      2
+
 #       if (((1 << VM_READ_BIT) != VM_READ || (1 << VM_WRITE_BIT) != VM_WRITE) \
             || (1 << VM_EXEC_BIT) != VM_EXEC)
 #               error File is out of sync with <linux/mm.h>.  Please update.
@@ -149,6 +143,9 @@ retry:
         if (((isr >> IA64_ISR_R_BIT) & 1UL) && (!(vma->vm_flags & (VM_READ | VM_WRITE))))
                 goto bad_area;
 
+        mask = (  (((isr >> IA64_ISR_X_BIT) & 1UL) << VM_EXEC_BIT)
+                | (((isr >> IA64_ISR_W_BIT) & 1UL) << VM_WRITE_BIT));
+
         if ((vma->vm_flags & mask) != mask)
                 goto bad_area;
 
@@ -157,11 +154,7 @@ retry:
          * sure we exit gracefully rather than endlessly redo the
          * fault.
          */
-        fault = handle_mm_fault(mm, vma, address, flags);
-
-        if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
-                return;
-
+        fault = handle_mm_fault(mm, vma, address, (mask & VM_WRITE) ? FAULT_FLAG_WRITE : 0);
         if (unlikely(fault & VM_FAULT_ERROR)) {
                 /*
                  * We ran out of memory, or some other thing happened
@@ -176,25 +169,10 @@ retry:
                 }
                 BUG();
         }
-
-        if (flags & FAULT_FLAG_ALLOW_RETRY) {
-                if (fault & VM_FAULT_MAJOR)
-                        current->maj_flt++;
-                else
-                        current->min_flt++;
-                if (fault & VM_FAULT_RETRY) {
-                        flags &= ~FAULT_FLAG_ALLOW_RETRY;
-                        flags |= FAULT_FLAG_TRIED;
-
-                         /* No need to up_read(&mm->mmap_sem) as we would
-                         * have already released it in __lock_page_or_retry
-                         * in mm/filemap.c.
-                         */
-
-                        goto retry;
-                }
-        }
-
+        if (fault & VM_FAULT_MAJOR)
+                current->maj_flt++;
+        else
+                current->min_flt++;
         up_read(&mm->mmap_sem);
         return;
 
diff --git a/arch/ia64/mm/init.c b/arch/ia64/mm/init.c
index b755ea92aea..00cb0e26c64 100644
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -10,7 +10,6 @@
 #include <linux/bootmem.h>
 #include <linux/efi.h>
 #include <linux/elf.h>
-#include <linux/memblock.h>
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 #include <linux/module.h>
@@ -30,6 +29,7 @@
 #include <asm/pgalloc.h>
 #include <asm/sal.h>
 #include <asm/sections.h>
+#include <asm/system.h>
 #include <asm/tlb.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -138,8 +138,7 @@ ia64_init_addr_space (void)
                         vma->vm_mm = current->mm;
                         vma->vm_end = PAGE_SIZE;
                         vma->vm_page_prot = __pgprot(pgprot_val(PAGE_READONLY) | _PAGE_MA_NAT);
-                        vma->vm_flags = VM_READ | VM_MAYREAD | VM_IO |
-                                        VM_DONTEXPAND | VM_DONTDUMP;
+                        vma->vm_flags = VM_READ | VM_MAYREAD | VM_IO | VM_RESERVED;
                         down_write(&current->mm->mmap_sem);
                         if (insert_vm_struct(current->mm, vma)) {
                                 up_write(&current->mm->mmap_sem);
@@ -294,10 +293,11 @@ setup_gate (void)
         ia64_patch_gate();
 }
 
-void ia64_mmu_init(void *my_cpu_data)
+void __devinit
+ia64_mmu_init (void *my_cpu_data)
 {
         unsigned long pta, impl_va_bits;
-        extern void tlb_init(void);
+        extern void __devinit tlb_init (void);
 
 #ifdef CONFIG_DISABLE_VHPT
 #       define VHPT_ENABLE_BIT  0
@@ -557,7 +557,8 @@ int __init register_active_ranges(u64 start, u64 len, int nid)
 #endif
 
         if (start < end)
-                memblock_add_node(__pa(start), end - start, nid);
+                add_active_range(nid, __pa(start) >> PAGE_SHIFT,
+                        __pa(end) >> PAGE_SHIFT);
         return 0;
 }
 
diff --git a/arch/ia64/mm/tlb.c b/arch/ia64/mm/tlb.c
index ed612976868..7b3cdc6c6d9 100644
--- a/arch/ia64/mm/tlb.c
+++ b/arch/ia64/mm/tlb.c
@@ -337,7 +337,8 @@ flush_tlb_range (struct vm_area_struct *vma, unsigned long start,
 }
 EXPORT_SYMBOL(flush_tlb_range);
 
-void ia64_tlb_init(void)
+void __devinit
+ia64_tlb_init (void)
 {
         ia64_ptce_info_t uninitialized_var(ptce_info); /* GCC be quiet */
         u64 tr_pgbits;
diff --git a/arch/ia64/oprofile/backtrace.c b/arch/ia64/oprofile/backtrace.c
index 6a219a94605..f7b798993ce 100644
--- a/arch/ia64/oprofile/backtrace.c
+++ b/arch/ia64/oprofile/backtrace.c
@@ -14,6 +14,7 @@
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <asm/ptrace.h>
+#include <asm/system.h>
 
 /*
  * For IA64 we need to perform a complex little dance to get both
diff --git a/arch/ia64/pci/fixup.c b/arch/ia64/pci/fixup.c
index 5dc969dd4ac..f5959c0c181 100644
--- a/arch/ia64/pci/fixup.c
+++ b/arch/ia64/pci/fixup.c
@@ -24,14 +24,14 @@
  * video device at this point.
  */
 
-static void pci_fixup_video(struct pci_dev *pdev)
+static void __devinit pci_fixup_video(struct pci_dev *pdev)
 {
         struct pci_dev *bridge;
         struct pci_bus *bus;
         u16 config;
 
-        if ((strcmp(ia64_platform_name, "dig") != 0)
-            && (strcmp(ia64_platform_name, "hpzx1")  != 0))
+        if ((strcmp(platform_name, "dig") != 0)
+            && (strcmp(platform_name, "hpzx1")  != 0))
                 return;
         /* Maybe, this machine supports legacy memory map. */
 
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index 55b72ad5732..aa2533ae7e9 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -20,10 +20,10 @@
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/bootmem.h>
-#include <linux/export.h>
 
 #include <asm/machvec.h>
 #include <asm/page.h>
+#include <asm/system.h>
 #include <asm/io.h>
 #include <asm/sal.h>
 #include <asm/smp.h>
@@ -116,7 +116,8 @@ struct pci_ops pci_root_ops = {
 
 /* Called by ACPI when it finds a new root bus.  */
 
-static struct pci_controller *alloc_pci_controller(int seg)
+static struct pci_controller * __devinit
+alloc_pci_controller (int seg)
 {
         struct pci_controller *controller;
 
@@ -132,7 +133,6 @@ static struct pci_controller *alloc_pci_controller(int seg)
 struct pci_root_info {
         struct acpi_device *bridge;
         struct pci_controller *controller;
-        struct list_head resources;
         char *name;
 };
 
@@ -164,8 +164,8 @@ new_space (u64 phys_base, int sparse)
         return i;
 }
 
-static u64 add_io_space(struct pci_root_info *info,
-                        struct acpi_resource_address64 *addr)
+static u64 __devinit
+add_io_space (struct pci_root_info *info, struct acpi_resource_address64 *addr)
 {
         struct resource *resource;
         char *name;
@@ -225,8 +225,8 @@ out:
         return ~0;
 }
 
-static acpi_status resource_to_window(struct acpi_resource *resource,
-                                      struct acpi_resource_address64 *addr)
+static acpi_status __devinit resource_to_window(struct acpi_resource *resource,
+        struct acpi_resource_address64 *addr)
 {
         acpi_status status;
 
@@ -248,7 +248,8 @@ static acpi_status resource_to_window(struct acpi_resource *resource,
         return AE_ERROR;
 }
 
-static acpi_status count_window(struct acpi_resource *resource, void *data)
+static acpi_status __devinit
+count_window (struct acpi_resource *resource, void *data)
 {
         unsigned int *windows = (unsigned int *) data;
         struct acpi_resource_address64 addr;
@@ -261,7 +262,7 @@ static acpi_status count_window(struct acpi_resource *resource, void *data)
         return AE_OK;
 }
 
-static acpi_status add_window(struct acpi_resource *res, void *data)
+static __devinit acpi_status add_window(struct acpi_resource *res, void *data)
 {
         struct pci_root_info *info = data;
         struct pci_window *window;
@@ -293,6 +294,7 @@ static acpi_status add_window(struct acpi_resource *res, void *data)
         window->resource.flags = flags;
         window->resource.start = addr.minimum + offset;
         window->resource.end = window->resource.start + addr.address_length - 1;
+        window->resource.child = NULL;
         window->offset = offset;
 
         if (insert_resource(root, &window->resource)) {
@@ -312,24 +314,34 @@ static acpi_status add_window(struct acpi_resource *res, void *data)
                                  &window->resource);
         }
 
-        /* HP's firmware has a hack to work around a Windows bug.
-         * Ignore these tiny memory ranges */
-        if (!((window->resource.flags & IORESOURCE_MEM) &&
-              (window->resource.end - window->resource.start < 16)))
-                pci_add_resource_offset(&info->resources, &window->resource,
-                                        window->offset);
-
         return AE_OK;
 }
 
-struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
+static void __devinit
+pcibios_setup_root_windows(struct pci_bus *bus, struct pci_controller *ctrl)
+{
+        int i;
+
+        pci_bus_remove_resources(bus);
+        for (i = 0; i < ctrl->windows; i++) {
+                struct resource *res = &ctrl->window[i].resource;
+                /* HP's firmware has a hack to work around a Windows bug.
+                 * Ignore these tiny memory ranges */
+                if ((res->flags & IORESOURCE_MEM) &&
+                    (res->end - res->start < 16))
+                        continue;
+                pci_bus_add_resource(bus, res, 0);
+        }
+}
+
+struct pci_bus * __devinit
+pci_acpi_scan_root(struct acpi_pci_root *root)
 {
         struct acpi_device *device = root->device;
         int domain = root->segment;
         int bus = root->secondary.start;
         struct pci_controller *controller;
         unsigned int windows = 0;
-        struct pci_root_info info;
         struct pci_bus *pbus;
         char *name;
         int pxm;
@@ -346,14 +358,13 @@ struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
                 controller->node = pxm_to_node(pxm);
 #endif
 
-        INIT_LIST_HEAD(&info.resources);
-        /* insert busn resource at first */
-        pci_add_resource(&info.resources, &root->secondary);
         acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_window,
                         &windows);
         if (windows) {
+                struct pci_root_info info;
+
                 controller->window =
-                        kzalloc_node(sizeof(*controller->window) * windows,
+                        kmalloc_node(sizeof(*controller->window) * windows,
                                      GFP_KERNEL, controller->node);
                 if (!controller->window)
                         goto out2;
@@ -375,14 +386,8 @@ struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
          * should handle the case here, but it appears that IA64 hasn't
          * such quirk. So we just ignore the case now.
          */
-        pbus = pci_create_root_bus(NULL, bus, &pci_root_ops, controller,
-                                   &info.resources);
-        if (!pbus) {
-                pci_free_resource_list(&info.resources);
-                return NULL;
-        }
+        pbus = pci_scan_bus_parented(NULL, bus, &pci_root_ops, controller);
 
-        pci_scan_child_bus(pbus);
         return pbus;
 
 out3:
@@ -393,7 +398,55 @@ out1:
         return NULL;
 }
 
-static int is_valid_resource(struct pci_dev *dev, int idx)
+void pcibios_resource_to_bus(struct pci_dev *dev,
+                struct pci_bus_region *region, struct resource *res)
+{
+        struct pci_controller *controller = PCI_CONTROLLER(dev);
+        unsigned long offset = 0;
+        int i;
+
+        for (i = 0; i < controller->windows; i++) {
+                struct pci_window *window = &controller->window[i];
+                if (!(window->resource.flags & res->flags))
+                        continue;
+                if (window->resource.start > res->start)
+                        continue;
+                if (window->resource.end < res->end)
+                        continue;
+                offset = window->offset;
+                break;
+        }
+
+        region->start = res->start - offset;
+        region->end = res->end - offset;
+}
+EXPORT_SYMBOL(pcibios_resource_to_bus);
+
+void pcibios_bus_to_resource(struct pci_dev *dev,
+                struct resource *res, struct pci_bus_region *region)
+{
+        struct pci_controller *controller = PCI_CONTROLLER(dev);
+        unsigned long offset = 0;
+        int i;
+
+        for (i = 0; i < controller->windows; i++) {
+                struct pci_window *window = &controller->window[i];
+                if (!(window->resource.flags & res->flags))
+                        continue;
+                if (window->resource.start - window->offset > region->start)
+                        continue;
+                if (window->resource.end - window->offset < region->end)
+                        continue;
+                offset = window->offset;
+                break;
+        }
+
+        res->start = region->start + offset;
+        res->end = region->end + offset;
+}
+EXPORT_SYMBOL(pcibios_bus_to_resource);
+
+static int __devinit is_valid_resource(struct pci_dev *dev, int idx)
 {
         unsigned int i, type_mask = IORESOURCE_IO | IORESOURCE_MEM;
         struct resource *devr = &dev->resource[idx], *busr;
@@ -411,25 +464,30 @@ static int is_valid_resource(struct pci_dev *dev, int idx)
         return 0;
 }
 
-static void pcibios_fixup_resources(struct pci_dev *dev, int start, int limit)
+static void __devinit
+pcibios_fixup_resources(struct pci_dev *dev, int start, int limit)
 {
+        struct pci_bus_region region;
         int i;
 
         for (i = start; i < limit; i++) {
                 if (!dev->resource[i].flags)
                         continue;
+                region.start = dev->resource[i].start;
+                region.end = dev->resource[i].end;
+                pcibios_bus_to_resource(dev, &dev->resource[i], &region);
                 if ((is_valid_resource(dev, i)))
                         pci_claim_resource(dev, i);
         }
 }
 
-void pcibios_fixup_device_resources(struct pci_dev *dev)
+void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
 {
         pcibios_fixup_resources(dev, 0, PCI_BRIDGE_RESOURCES);
 }
 EXPORT_SYMBOL_GPL(pcibios_fixup_device_resources);
 
-static void pcibios_fixup_bridge_resources(struct pci_dev *dev)
+static void __devinit pcibios_fixup_bridge_resources(struct pci_dev *dev)
 {
         pcibios_fixup_resources(dev, PCI_BRIDGE_RESOURCES, PCI_NUM_RESOURCES);
 }
@@ -437,22 +495,30 @@ static void pcibios_fixup_bridge_resources(struct pci_dev *dev)
 /*
  *  Called after each bus is probed, but before its children are examined.
  */
-void pcibios_fixup_bus(struct pci_bus *b)
+void __devinit
+pcibios_fixup_bus (struct pci_bus *b)
 {
         struct pci_dev *dev;
 
         if (b->self) {
                 pci_read_bridge_bases(b);
                 pcibios_fixup_bridge_resources(b->self);
+        } else {
+                pcibios_setup_root_windows(b, b->sysdata);
         }
         list_for_each_entry(dev, &b->devices, bus_list)
                 pcibios_fixup_device_resources(dev);
         platform_pci_fixup_bus(b);
+
+        return;
 }
 
-void pcibios_set_master (struct pci_dev *dev)
+void __devinit
+pcibios_update_irq (struct pci_dev *dev, int irq)
 {
-        /* No special bus mastering setup handling */
+        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
+
+        /* ??? FIXME -- record old value for shutdown.  */
 }
 
 int
@@ -484,6 +550,15 @@ pcibios_align_resource (void *data, const struct resource *res,
         return res->start;
 }
 
+/*
+ * PCI BIOS setup, always defaults to SAL interface
+ */
+char * __init
+pcibios_setup (char *str)
+{
+        return str;
+}
+
 int
 pci_mmap_page_range (struct pci_dev *dev, struct vm_area_struct *vma,
                      enum pci_mmap_state mmap_state, int write_combine)
diff --git a/arch/ia64/sn/kernel/huberror.c b/arch/ia64/sn/kernel/huberror.c
index f925dec2da9..08b0d9bb62e 100644
--- a/arch/ia64/sn/kernel/huberror.c
+++ b/arch/ia64/sn/kernel/huberror.c
@@ -192,7 +192,6 @@ void hub_error_init(struct hubdev_info *hubdev_info)
                     hubdev_info);
                 return;
         }
-        irq_set_handler(SGI_II_ERROR, handle_level_irq);
         sn_set_err_irq_affinity(SGI_II_ERROR);
 }
 
@@ -214,7 +213,6 @@ void ice_error_init(struct hubdev_info *hubdev_info)
                        hubdev_info);
                 return;
         }
-        irq_set_handler(SGI_TIO_ERROR, handle_level_irq);
         sn_set_err_irq_affinity(SGI_TIO_ERROR);
 }
 
diff --git a/arch/ia64/sn/kernel/io_acpi_init.c b/arch/ia64/sn/kernel/io_acpi_init.c
index b1725398b5a..8cdcb173a13 100644
--- a/arch/ia64/sn/kernel/io_acpi_init.c
+++ b/arch/ia64/sn/kernel/io_acpi_init.c
@@ -14,7 +14,6 @@
 #include "xtalk/hubdev.h"
 #include <linux/acpi.h>
 #include <linux/slab.h>
-#include <linux/export.h>
 
 
 /*
diff --git a/arch/ia64/sn/kernel/io_common.c b/arch/ia64/sn/kernel/io_common.c
index 11f2275570f..4433dd019d3 100644
--- a/arch/ia64/sn/kernel/io_common.c
+++ b/arch/ia64/sn/kernel/io_common.c
@@ -7,7 +7,6 @@
  */
 
 #include <linux/bootmem.h>
-#include <linux/export.h>
 #include <linux/slab.h>
 #include <asm/sn/types.h>
 #include <asm/sn/addrs.h>
@@ -229,6 +228,7 @@ void sn_pci_fixup_slot(struct pci_dev *dev, struct pcidev_info *pcidev_info,
 {
         int segment = pci_domain_nr(dev->bus);
         struct pcibus_bussoft *bs;
+        struct pci_bus *host_pci_bus;
         struct pci_dev *host_pci_dev;
         unsigned int bus_no, devfn;
 
@@ -244,7 +244,8 @@ void sn_pci_fixup_slot(struct pci_dev *dev, struct pcidev_info *pcidev_info,
 
         bus_no = (pcidev_info->pdi_slot_host_handle >> 32) & 0xff;
         devfn = pcidev_info->pdi_slot_host_handle & 0xffffffff;
-        host_pci_dev = pci_get_domain_bus_and_slot(segment, bus_no, devfn);
+        host_pci_bus = pci_find_bus(segment, bus_no);
+        host_pci_dev = pci_get_slot(host_pci_bus, devfn);
 
         pcidev_info->host_pci_dev = host_pci_dev;
         pcidev_info->pdi_linux_pcidev = dev;
@@ -435,7 +436,8 @@ void sn_generate_path(struct pci_bus *pci_bus, char *address)
                                                 geo_slot(geoid));
 }
 
-void sn_pci_fixup_bus(struct pci_bus *bus)
+void __devinit
+sn_pci_fixup_bus(struct pci_bus *bus)
 {
 
         if (SN_ACPI_BASE_SUPPORT())
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 238e2c511d9..98079f29d9a 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -7,7 +7,6 @@
  */
 
 #include <linux/slab.h>
-#include <linux/export.h>
 #include <asm/sn/types.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/io.h>
@@ -297,8 +296,7 @@ sn_pci_controller_fixup(int segment, int busnum, struct pci_bus *bus)
         s64 status = 0;
         struct pci_controller *controller;
         struct pcibus_bussoft *prom_bussoft_ptr;
-        LIST_HEAD(resources);
-        int i;
+
 
         status = sal_get_pcibus_info((u64) segment, (u64) busnum,
                                      (u64) ia64_tpa(&prom_bussoft_ptr));
@@ -316,15 +314,7 @@ sn_pci_controller_fixup(int segment, int busnum, struct pci_bus *bus)
          */
         controller->platform_data = prom_bussoft_ptr;
 
-        sn_legacy_pci_window_fixup(controller,
-                                   prom_bussoft_ptr->bs_legacy_io,
-                                   prom_bussoft_ptr->bs_legacy_mem);
-        for (i = 0; i < controller->windows; i++)
-                pci_add_resource_offset(&resources,
-                                        &controller->window[i].resource,
-                                        controller->window[i].offset);
-        bus = pci_scan_root_bus(NULL, busnum, &pci_root_ops, controller,
-                                &resources);
+        bus = pci_scan_bus(busnum, &pci_root_ops, controller);
         if (bus == NULL)
                 goto error_return; /* error, or bus already scanned */
 
@@ -357,6 +347,9 @@ sn_bus_fixup(struct pci_bus *bus)
                         return;
                 }
                 sn_common_bus_fixup(bus, prom_bussoft_ptr);
+                sn_legacy_pci_window_fixup(PCI_CONTROLLER(bus),
+                                           prom_bussoft_ptr->bs_legacy_io,
+                                           prom_bussoft_ptr->bs_legacy_mem);
         }
         list_for_each_entry(pci_dev, &bus->devices, bus_list) {
                 sn_io_slot_fixup(pci_dev);
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index 62cf4dde6a0..485c42d97e8 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -150,11 +150,12 @@ struct sn_irq_info *sn_retarget_vector(struct sn_irq_info *sn_irq_info,
          * PROM does not support SAL_INTR_REDIRECT, or it failed.
          * Revert to old method.
          */
-        new_irq_info = kmemdup(sn_irq_info, sizeof(struct sn_irq_info),
-                               GFP_ATOMIC);
+        new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
         if (new_irq_info == NULL)
                 return NULL;
 
+        memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
+
         /* Free the old PROM new_irq_info structure */
         sn_intr_free(local_nasid, local_widget, new_irq_info);
         unregister_intr_pda(new_irq_info);
@@ -352,8 +353,6 @@ void sn_irq_fixup(struct pci_dev *pci_dev, struct sn_irq_info *sn_irq_info)
         spin_lock(&sn_irq_info_lock);
         list_add_rcu(&sn_irq_info->list, sn_irq_lh[sn_irq_info->irq_irq]);
         reserve_irq_vector(sn_irq_info->irq_irq);
-        if (sn_irq_info->irq_int_bit != -1)
-                irq_set_handler(sn_irq_info->irq_irq, handle_level_irq);
         spin_unlock(&sn_irq_info_lock);
 
         register_intr_pda(sn_irq_info);
diff --git a/arch/ia64/sn/kernel/setup.c b/arch/ia64/sn/kernel/setup.c
index f82e7b462b7..77db0b514fa 100644
--- a/arch/ia64/sn/kernel/setup.c
+++ b/arch/ia64/sn/kernel/setup.c
@@ -33,9 +33,9 @@
 #include <asm/io.h>
 #include <asm/sal.h>
 #include <asm/machvec.h>
+#include <asm/system.h>
 #include <asm/processor.h>
 #include <asm/vga.h>
-#include <asm/setup.h>
 #include <asm/sn/arch.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/pda.h>
diff --git a/arch/ia64/sn/kernel/sn2/prominfo_proc.c b/arch/ia64/sn/kernel/sn2/prominfo_proc.c
index 20b88cb1881..e6332881864 100644
--- a/arch/ia64/sn/kernel/sn2/prominfo_proc.c
+++ b/arch/ia64/sn/kernel/sn2/prominfo_proc.c
@@ -12,6 +12,7 @@
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/nodemask.h>
+#include <asm/system.h>
 #include <asm/io.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/sn_cpuid.h>
diff --git a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c
index 68c84541162..e884ba4e031 100644
--- a/arch/ia64/sn/kernel/sn2/sn2_smp.c
+++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c
@@ -26,6 +26,7 @@
 #include <asm/processor.h>
 #include <asm/irq.h>
 #include <asm/sal.h>
+#include <asm/system.h>
 #include <asm/delay.h>
 #include <asm/io.h>
 #include <asm/smp.h>
diff --git a/arch/ia64/sn/kernel/sn2/sn_hwperf.c b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
index b9992571c03..30862c0358c 100644
--- a/arch/ia64/sn/kernel/sn2/sn_hwperf.c
+++ b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
@@ -25,7 +25,6 @@
 
 #include <linux/fs.h>
 #include <linux/slab.h>
-#include <linux/export.h>
 #include <linux/vmalloc.h>
 #include <linux/seq_file.h>
 #include <linux/miscdevice.h>
@@ -616,15 +615,11 @@ static int sn_hwperf_op_cpu(struct sn_hwperf_op_info *op_info)
                 }
         }
 
-        if (cpu == SN_HWPERF_ARG_ANY_CPU) {
-                /* don't care which cpu */
+        if (cpu == SN_HWPERF_ARG_ANY_CPU || cpu == get_cpu()) {
+                /* don't care, or already on correct cpu */
                 sn_hwperf_call_sal(op_info);
-        } else if (cpu == get_cpu()) {
-                /* already on correct cpu */
-                sn_hwperf_call_sal(op_info);
-                put_cpu();
-        } else {
-                put_cpu();
+        }
+        else {
                 if (use_ipi) {
                         /* use an interprocessor interrupt to call SAL */
                         smp_call_function_single(cpu, sn_hwperf_call_sal,
@@ -977,7 +972,7 @@ int sn_hwperf_get_nearest_node(cnodeid_t node,
         return e;
 }
 
-static int sn_hwperf_misc_register_init(void)
+static int __devinit sn_hwperf_misc_register_init(void)
 {
         int e;
 
diff --git a/arch/ia64/sn/kernel/sn2/timer.c b/arch/ia64/sn/kernel/sn2/timer.c
index abab8f99e91..0f8844e4936 100644
--- a/arch/ia64/sn/kernel/sn2/timer.c
+++ b/arch/ia64/sn/kernel/sn2/timer.c
@@ -14,6 +14,7 @@
 #include <linux/clocksource.h>
 
 #include <asm/hw_irq.h>
+#include <asm/system.h>
 #include <asm/timex.h>
 
 #include <asm/sn/leds.h>
diff --git a/arch/ia64/sn/kernel/tiocx.c b/arch/ia64/sn/kernel/tiocx.c
index 14c1711238c..c1bd1cfda32 100644
--- a/arch/ia64/sn/kernel/tiocx.c
+++ b/arch/ia64/sn/kernel/tiocx.c
@@ -14,6 +14,7 @@
 #include <linux/capability.h>
 #include <linux/device.h>
 #include <linux/delay.h>
+#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/addrs.h>
@@ -190,7 +191,6 @@ cx_device_register(nasid_t nasid, int part_num, int mfg_num,
                    struct hubdev_info *hubdev, int bt)
 {
         struct cx_dev *cx_dev;
-        int r;
 
         cx_dev = kzalloc(sizeof(struct cx_dev), GFP_KERNEL);
         DBG("cx_dev= 0x%p\n", cx_dev);
@@ -207,11 +207,7 @@ cx_device_register(nasid_t nasid, int part_num, int mfg_num,
         cx_dev->dev.bus = &tiocx_bus_type;
         cx_dev->dev.release = tiocx_bus_release;
         dev_set_name(&cx_dev->dev, "%d", cx_dev->cx_id.nasid);
-        r = device_register(&cx_dev->dev);
-        if (r) {
-                kfree(cx_dev);
-                return r;
-        }
+        device_register(&cx_dev->dev);
         get_device(&cx_dev->dev);
 
         device_create_file(&cx_dev->dev, &dev_attr_cxdev_control);
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 3290d6e00c3..a9d310de57d 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -76,8 +76,7 @@ EXPORT_SYMBOL(sn_dma_set_mask);
  * more information.
  */
 static void *sn_dma_alloc_coherent(struct device *dev, size_t size,
-                                   dma_addr_t * dma_handle, gfp_t flags,
-                                   struct dma_attrs *attrs)
+                                   dma_addr_t * dma_handle, gfp_t flags)
 {
         void *cpuaddr;
         unsigned long phys_addr;
@@ -138,7 +137,7 @@ static void *sn_dma_alloc_coherent(struct device *dev, size_t size,
  * any associated IOMMU mappings.
  */
 static void sn_dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
-                                 dma_addr_t dma_handle, struct dma_attrs *attrs)
+                                 dma_addr_t dma_handle)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
@@ -467,8 +466,8 @@ int sn_pci_legacy_write(struct pci_bus *bus, u16 port, u32 val, u8 size)
 }
 
 static struct dma_map_ops sn_dma_ops = {
-        .alloc                  = sn_dma_alloc_coherent,
-        .free                   = sn_dma_free_coherent,
+        .alloc_coherent         = sn_dma_alloc_coherent,
+        .free_coherent          = sn_dma_free_coherent,
         .map_page               = sn_dma_map_page,
         .unmap_page             = sn_dma_unmap_page,
         .map_sg                 = sn_dma_map_sg,
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_dma.c b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
index 1e863b277ac..33def666a66 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_dma.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
@@ -8,7 +8,6 @@
 
 #include <linux/types.h>
 #include <linux/pci.h>
-#include <linux/export.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/geo.h>
 #include <asm/sn/pcibr_provider.h>
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_provider.c b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
index 8dbbef4a4f4..3cb5cf37764 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_provider.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
@@ -10,7 +10,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
-#include <linux/export.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/geo.h>
 #include <asm/sn/pcibr_provider.h>
@@ -127,11 +126,12 @@ pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
          * Allocate kernel bus soft and copy from prom.
          */
 
-        soft = kmemdup(prom_bussoft, sizeof(struct pcibus_info), GFP_KERNEL);
+        soft = kmalloc(sizeof(struct pcibus_info), GFP_KERNEL);
         if (!soft) {
                 return NULL;
         }
 
+        memcpy(soft, prom_bussoft, sizeof(struct pcibus_info));
         soft->pbi_buscommon.bs_base = (unsigned long)
                 ioremap(REGION_OFFSET(soft->pbi_buscommon.bs_base),
                         sizeof(struct pic));
@@ -146,7 +146,6 @@ pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
                 printk(KERN_WARNING
                        "pcibr cannot allocate interrupt for error handler\n");
         }
-        irq_set_handler(SGI_PCIASIC_ERROR, handle_level_irq);
         sn_set_err_irq_affinity(SGI_PCIASIC_ERROR);
 
         /* 
diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
index a70b11fd57d..9c271be9919 100644
--- a/arch/ia64/sn/pci/tioca_provider.c
+++ b/arch/ia64/sn/pci/tioca_provider.c
@@ -11,7 +11,6 @@
 #include <linux/pci.h>
 #include <linux/bitmap.h>
 #include <linux/slab.h>
-#include <linux/export.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/io.h>
@@ -600,11 +599,11 @@ tioca_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
          * Allocate kernel bus soft and copy from prom.
          */
 
-        tioca_common = kmemdup(prom_bussoft, sizeof(struct tioca_common),
-                               GFP_KERNEL);
+        tioca_common = kzalloc(sizeof(struct tioca_common), GFP_KERNEL);
         if (!tioca_common)
                 return NULL;
 
+        memcpy(tioca_common, prom_bussoft, sizeof(struct tioca_common));
         tioca_common->ca_common.bs_base = (unsigned long)
                 ioremap(REGION_OFFSET(tioca_common->ca_common.bs_base),
                         sizeof(struct tioca_common));
@@ -649,7 +648,6 @@ tioca_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
                        __func__, SGI_TIOCA_ERROR,
                        (int)tioca_common->ca_common.bs_persist_busnum);
 
-        irq_set_handler(SGI_TIOCA_ERROR, handle_level_irq);
         sn_set_err_irq_affinity(SGI_TIOCA_ERROR);
 
         /* Setup locality information */
diff --git a/arch/ia64/sn/pci/tioce_provider.c b/arch/ia64/sn/pci/tioce_provider.c
index 46d3df4b03a..27faba035f3 100644
--- a/arch/ia64/sn/pci/tioce_provider.c
+++ b/arch/ia64/sn/pci/tioce_provider.c
@@ -1037,7 +1037,6 @@ tioce_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
                        tioce_common->ce_pcibus.bs_persist_segment,
                        tioce_common->ce_pcibus.bs_persist_busnum);
 
-        irq_set_handler(SGI_PCIASIC_ERROR, handle_level_irq);
         sn_set_err_irq_affinity(SGI_PCIASIC_ERROR);
         return tioce_common;
 }
diff --git a/arch/ia64/xen/grant-table.c b/arch/ia64/xen/grant-table.c
index c18281332f8..48cca37625e 100644
--- a/arch/ia64/xen/grant-table.c
+++ b/arch/ia64/xen/grant-table.c
@@ -31,6 +31,68 @@
 
 #include <asm/xen/hypervisor.h>
 
+struct vm_struct *xen_alloc_vm_area(unsigned long size)
+{
+        int order;
+        unsigned long virt;
+        unsigned long nr_pages;
+        struct vm_struct *area;
+
+        order = get_order(size);
+        virt = __get_free_pages(GFP_KERNEL, order);
+        if (virt == 0)
+                goto err0;
+        nr_pages = 1 << order;
+        scrub_pages(virt, nr_pages);
+
+        area = kmalloc(sizeof(*area), GFP_KERNEL);
+        if (area == NULL)
+                goto err1;
+
+        area->flags = VM_IOREMAP;
+        area->addr = (void *)virt;
+        area->size = size;
+        area->pages = NULL;
+        area->nr_pages = nr_pages;
+        area->phys_addr = 0;    /* xenbus_map_ring_valloc uses this field!  */
+
+        return area;
+
+err1:
+        free_pages(virt, order);
+err0:
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(xen_alloc_vm_area);
+
+void xen_free_vm_area(struct vm_struct *area)
+{
+        unsigned int order = get_order(area->size);
+        unsigned long i;
+        unsigned long phys_addr = __pa(area->addr);
+
+        /* This area is used for foreign page mappping.
+         * So underlying machine page may not be assigned. */
+        for (i = 0; i < (1 << order); i++) {
+                unsigned long ret;
+                unsigned long gpfn = (phys_addr >> PAGE_SHIFT) + i;
+                struct xen_memory_reservation reservation = {
+                        .nr_extents   = 1,
+                        .address_bits = 0,
+                        .extent_order = 0,
+                        .domid        = DOMID_SELF
+                };
+                set_xen_guest_handle(reservation.extent_start, &gpfn);
+                ret = HYPERVISOR_memory_op(XENMEM_populate_physmap,
+                                           &reservation);
+                BUG_ON(ret != 1);
+        }
+        free_pages((unsigned long)area->addr, order);
+        kfree(area);
+}
+EXPORT_SYMBOL_GPL(xen_free_vm_area);
+
+
 /****************************************************************************
  * grant table hack
  * cmd: GNTTABOP_xxx
diff --git a/arch/ia64/xen/hypervisor.c b/arch/ia64/xen/hypervisor.c
index 52172eee859..cac4d97c0b5 100644
--- a/arch/ia64/xen/hypervisor.c
+++ b/arch/ia64/xen/hypervisor.c
@@ -21,7 +21,6 @@
  */
 
 #include <linux/efi.h>
-#include <linux/export.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/privop.h>
 
diff --git a/arch/ia64/xen/irq_xen.c b/arch/ia64/xen/irq_xen.c
index efb74dafec4..b279e142c63 100644
--- a/arch/ia64/xen/irq_xen.c
+++ b/arch/ia64/xen/irq_xen.c
@@ -58,7 +58,7 @@ xen_free_irq_vector(int vector)
 
         irq_op.vector = vector;
         if (HYPERVISOR_physdev_op(PHYSDEVOP_free_irq_vector, &irq_op))
-                printk(KERN_WARNING "%s: xen_free_irq_vector fail vector=%d\n",
+                printk(KERN_WARNING "%s: xen_free_irq_vecotr fail vector=%d\n",
                        __func__, vector);
 }
 
@@ -273,8 +273,9 @@ xen_bind_early_percpu_irq(void)
  */
 
 #ifdef CONFIG_HOTPLUG_CPU
-static int unbind_evtchn_callback(struct notifier_block *nfb,
-                                  unsigned long action, void *hcpu)
+static int __devinit
+unbind_evtchn_callback(struct notifier_block *nfb,
+                       unsigned long action, void *hcpu)
 {
         unsigned int cpu = (unsigned long)hcpu;
 
@@ -432,7 +433,7 @@ xen_resend_irq(unsigned int vector)
         (void)resend_irq_on_evtchn(vector);
 }
 
-const struct pv_irq_ops xen_irq_ops __initconst = {
+const struct pv_irq_ops xen_irq_ops __initdata = {
         .register_ipi = xen_register_ipi,
 
         .assign_irq_vector = xen_assign_irq_vector,
diff --git a/arch/ia64/xen/irq_xen.h b/arch/ia64/xen/irq_xen.h
index 1778517b90f..26110f330c8 100644
--- a/arch/ia64/xen/irq_xen.h
+++ b/arch/ia64/xen/irq_xen.h
@@ -27,7 +27,7 @@ extern void (*late_time_init)(void);
 extern char xen_event_callback;
 void __init xen_init_IRQ(void);
 
-extern const struct pv_irq_ops xen_irq_ops __initconst;
+extern const struct pv_irq_ops xen_irq_ops __initdata;
 extern void xen_smp_intr_init(void);
 extern void xen_send_ipi(int cpu, int vec);
 
diff --git a/arch/ia64/xen/xencomm.c b/arch/ia64/xen/xencomm.c
index 73d903ca2d6..1f5d7ac82e9 100644
--- a/arch/ia64/xen/xencomm.c
+++ b/arch/ia64/xen/xencomm.c
@@ -17,7 +17,6 @@
  */
 
 #include <linux/mm.h>
-#include <linux/err.h>
 
 static unsigned long kernel_virtual_offset;
 static int is_xencomm_initialized;
@@ -99,7 +98,7 @@ xencomm_vtop(unsigned long vaddr)
 
         /* We assume the page is modified.  */
         page = follow_page(vma, vaddr, FOLL_WRITE | FOLL_TOUCH);
-        if (IS_ERR_OR_NULL(page))
+        if (!page)
                 return ~0UL;
 
         return (page_to_pfn(page) << PAGE_SHIFT) | (vaddr & ~PAGE_MASK);
diff --git a/arch/ia64/xen/xensetup.S b/arch/ia64/xen/xensetup.S
index e29519ebe2d..b820ed02ab9 100644
--- a/arch/ia64/xen/xensetup.S
+++ b/arch/ia64/xen/xensetup.S
@@ -7,6 +7,7 @@
 #include <asm/processor.h>
 #include <asm/asmmacro.h>
 #include <asm/pgtable.h>
+#include <asm/system.h>
 #include <asm/paravirt.h>
 #include <asm/xen/privop.h>
 #include <linux/elfnote.h>