321 files changed, 2827 insertions, 1202 deletions
diff --git a/Documentation/DocBook/Makefile b/Documentation/DocBook/Makefile
index 5a2882d275ba..66e1cf733571 100644
--- a/Documentation/DocBook/Makefile
+++ b/Documentation/DocBook/Makefile
@@ -10,7 +10,8 @@ DOCBOOKS := wanbook.xml z8530book.xml mcabook.xml videobook.xml \
            kernel-hacking.xml kernel-locking.xml deviceiobook.xml \
            procfs-guide.xml writing_usb_driver.xml \
            kernel-api.xml journal-api.xml lsm.xml usb.xml \
-            gadget.xml libata.xml mtdnand.xml librs.xml rapidio.xml
+            gadget.xml libata.xml mtdnand.xml librs.xml rapidio.xml \
+            genericirq.xml
 ###
 # The build process is as follows (targets):
diff --git a/Documentation/DocBook/genericirq.tmpl b/Documentation/DocBook/genericirq.tmpl
new file mode 100644
index 000000000000..0f4a4b6321e4
--- /dev/null
+++ b/Documentation/DocBook/genericirq.tmpl
@@ -0,0 +1,474 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
+        "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []>
+<book id="Generic-IRQ-Guide">
+ <bookinfo>
+  <title>Linux generic IRQ handling</title>
+  <authorgroup>
+   <author>
+    <firstname>Thomas</firstname>
+    <surname>Gleixner</surname>
+    <affiliation>
+     <address>
+      <email>tglx@linutronix.de</email>
+     </address>
+    </affiliation>
+   </author>
+   <author>
+    <firstname>Ingo</firstname>
+    <surname>Molnar</surname>
+    <affiliation>
+     <address>
+      <email>mingo@elte.hu</email>
+     </address>
+    </affiliation>
+   </author>
+  </authorgroup>
+  <copyright>
+   <year>2005-2006</year>
+   <holder>Thomas Gleixner</holder>
+  </copyright>
+  <copyright>
+   <year>2005-2006</year>
+   <holder>Ingo Molnar</holder>
+  </copyright>
+  <legalnotice>
+   <para>
+     This documentation is free software; you can redistribute
+     it and/or modify it under the terms of the GNU General Public
+     License version 2 as published by the Free Software Foundation.
+   </para>
+   <para>
+     This program is distributed in the hope that it will be
+     useful, but WITHOUT ANY WARRANTY; without even the implied
+     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+     See the GNU General Public License for more details.
+   </para>
+   <para>
+     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
+   </para>
+   <para>
+     For more details see the file COPYING in the source
+     distribution of Linux.
+   </para>
+  </legalnotice>
+ </bookinfo>
+<toc></toc>
+  <chapter id="intro">
+    <title>Introduction</title>
+    <para>
+        The generic interrupt handling layer is designed to provide a
+        complete abstraction of interrupt handling for device drivers.
+        It is able to handle all the different types of interrupt controller
+        hardware. Device drivers use generic API functions to request, enable,
+        disable and free interrupts. The drivers do not have to know anything
+        about interrupt hardware details, so they can be used on different
+        platforms without code changes.
+    </para>
+    <para>
+        This documentation is provided to developers who want to implement
+        an interrupt subsystem based for their architecture, with the help
+        of the generic IRQ handling layer.
+    </para>
+  </chapter>
+  <chapter id="rationale">
+    <title>Rationale</title>
+        <para>
+        The original implementation of interrupt handling in Linux is using
+        the __do_IRQ() super-handler, which is able to deal with every
+        type of interrupt logic.
+        </para>
+        <para>
+        Originally, Russell King identified different types of handlers to
+        build a quite universal set for the ARM interrupt handler
+        implementation in Linux 2.5/2.6. He distinguished between:
+        <itemizedlist>
+          <listitem><para>Level type</para></listitem>
+          <listitem><para>Edge type</para></listitem>
+          <listitem><para>Simple type</para></listitem>
+        </itemizedlist>
+        In the SMP world of the __do_IRQ() super-handler another type
+        was identified:
+        <itemizedlist>
+          <listitem><para>Per CPU type</para></listitem>
+        </itemizedlist>
+        </para>
+        <para>
+        This split implementation of highlevel IRQ handlers allows us to
+        optimize the flow of the interrupt handling for each specific
+        interrupt type. This reduces complexity in that particular codepath
+        and allows the optimized handling of a given type.
+        </para>
+        <para>
+        The original general IRQ implementation used hw_interrupt_type
+        structures and their ->ack(), ->end() [etc.] callbacks to
+        differentiate the flow control in the super-handler. This leads to
+        a mix of flow logic and lowlevel hardware logic, and it also leads
+        to unnecessary code duplication: for example in i386, there is a
+        ioapic_level_irq and a ioapic_edge_irq irq-type which share many
+        of the lowlevel details but have different flow handling.
+        </para>
+        <para>
+        A more natural abstraction is the clean separation of the
+        'irq flow' and the 'chip details'.
+        </para>
+        <para>
+        Analysing a couple of architecture's IRQ subsystem implementations
+        reveals that most of them can use a generic set of 'irq flow'
+        methods and only need to add the chip level specific code.
+        The separation is also valuable for (sub)architectures
+        which need specific quirks in the irq flow itself but not in the
+        chip-details - and thus provides a more transparent IRQ subsystem
+        design.
+        </para>
+        <para>
+        Each interrupt descriptor is assigned its own highlevel flow
+        handler, which is normally one of the generic
+        implementations. (This highlevel flow handler implementation also
+        makes it simple to provide demultiplexing handlers which can be
+        found in embedded platforms on various architectures.)
+        </para>
+        <para>
+        The separation makes the generic interrupt handling layer more
+        flexible and extensible. For example, an (sub)architecture can
+        use a generic irq-flow implementation for 'level type' interrupts
+        and add a (sub)architecture specific 'edge type' implementation.
+        </para>
+        <para>
+        To make the transition to the new model easier and prevent the
+        breakage of existing implementations, the __do_IRQ() super-handler
+        is still available. This leads to a kind of duality for the time
+        being. Over time the new model should be used in more and more
+        architectures, as it enables smaller and cleaner IRQ subsystems.
+        </para>
+  </chapter>
+  <chapter id="bugs">
+    <title>Known Bugs And Assumptions</title>
+    <para>
+        None (knock on wood).
+    </para>
+  </chapter>
+  <chapter id="Abstraction">
+    <title>Abstraction layers</title>
+    <para>
+        There are three main levels of abstraction in the interrupt code:
+        <orderedlist>
+          <listitem><para>Highlevel driver API</para></listitem>
+          <listitem><para>Highlevel IRQ flow handlers</para></listitem>
+          <listitem><para>Chiplevel hardware encapsulation</para></listitem>
+        </orderedlist>
+    </para>
+    <sect1>
+        <title>Interrupt control flow</title>
+        <para>
+        Each interrupt is described by an interrupt descriptor structure
+        irq_desc. The interrupt is referenced by an 'unsigned int' numeric
+        value which selects the corresponding interrupt decription structure
+        in the descriptor structures array.
+        The descriptor structure contains status information and pointers
+        to the interrupt flow method and the interrupt chip structure
+        which are assigned to this interrupt.
+        </para>
+        <para>
+        Whenever an interrupt triggers, the lowlevel arch code calls into
+        the generic interrupt code by calling desc->handle_irq().
+        This highlevel IRQ handling function only uses desc->chip primitives
+        referenced by the assigned chip descriptor structure.
+        </para>
+    </sect1>
+    <sect1>
+        <title>Highlevel Driver API</title>
+        <para>
+          The highlevel Driver API consists of following functions:
+          <itemizedlist>
+          <listitem><para>request_irq()</para></listitem>
+          <listitem><para>free_irq()</para></listitem>
+          <listitem><para>disable_irq()</para></listitem>
+          <listitem><para>enable_irq()</para></listitem>
+          <listitem><para>disable_irq_nosync() (SMP only)</para></listitem>
+          <listitem><para>synchronize_irq() (SMP only)</para></listitem>
+          <listitem><para>set_irq_type()</para></listitem>
+          <listitem><para>set_irq_wake()</para></listitem>
+          <listitem><para>set_irq_data()</para></listitem>
+          <listitem><para>set_irq_chip()</para></listitem>
+          <listitem><para>set_irq_chip_data()</para></listitem>
+          </itemizedlist>
+          See the autogenerated function documentation for details.
+        </para>
+    </sect1>
+    <sect1>
+        <title>Highlevel IRQ flow handlers</title>
+        <para>
+          The generic layer provides a set of pre-defined irq-flow methods:
+          <itemizedlist>
+          <listitem><para>handle_level_irq</para></listitem>
+          <listitem><para>handle_edge_irq</para></listitem>
+          <listitem><para>handle_simple_irq</para></listitem>
+          <listitem><para>handle_percpu_irq</para></listitem>
+          </itemizedlist>
+          The interrupt flow handlers (either predefined or architecture
+          specific) are assigned to specific interrupts by the architecture
+          either during bootup or during device initialization.
+        </para>
+        <sect2>
+        <title>Default flow implementations</title>
+            <sect3>
+                <title>Helper functions</title>
+                <para>
+                The helper functions call the chip primitives and
+                are used by the default flow implementations.
+                The following helper functions are implemented (simplified excerpt):
+                <programlisting>
+default_enable(irq)
+{
+        desc->chip->unmask(irq);
+}
+default_disable(irq)
+{
+        if (!delay_disable(irq))
+                desc->chip->mask(irq);
+}
+default_ack(irq)
+{
+        chip->ack(irq);
+}
+default_mask_ack(irq)
+{
+        if (chip->mask_ack) {
+                chip->mask_ack(irq);
+        } else {
+                chip->mask(irq);
+                chip->ack(irq);
+        }
+}
+noop(irq)
+{
+}
+                </programlisting>
+                </para>
+            </sect3>
+        </sect2>
+        <sect2>
+        <title>Default flow handler implementations</title>
+            <sect3>
+                <title>Default Level IRQ flow handler</title>
+                <para>
+                handle_level_irq provides a generic implementation
+                for level-triggered interrupts.
+                </para>
+                <para>
+                The following control flow is implemented (simplified excerpt):
+                <programlisting>
+desc->chip->start();
+handle_IRQ_event(desc->action);
+desc->chip->end();
+                </programlisting>
+                </para>
+            </sect3>
+            <sect3>
+                <title>Default Edge IRQ flow handler</title>
+                <para>
+                handle_edge_irq provides a generic implementation
+                for edge-triggered interrupts.
+                </para>
+                <para>
+                The following control flow is implemented (simplified excerpt):
+                <programlisting>
+if (desc->status &amp; running) {
+        desc->chip->hold();
+        desc->status |= pending | masked;
+        return;
+}
+desc->chip->start();
+desc->status |= running;
+do {
+        if (desc->status &amp; masked)
+                desc->chip->enable();
+        desc-status &amp;= ~pending;
+        handle_IRQ_event(desc->action);
+} while (status &amp; pending);
+desc-status &amp;= ~running;
+desc->chip->end();
+                </programlisting>
+                </para>
+            </sect3>
+            <sect3>
+                <title>Default simple IRQ flow handler</title>
+                <para>
+                handle_simple_irq provides a generic implementation
+                for simple interrupts.
+                </para>
+                <para>
+                Note: The simple flow handler does not call any
+                handler/chip primitives.
+                </para>
+                <para>
+                The following control flow is implemented (simplified excerpt):
+                <programlisting>
+handle_IRQ_event(desc->action);
+                </programlisting>
+                </para>
+            </sect3>
+            <sect3>
+                <title>Default per CPU flow handler</title>
+                <para>
+                handle_percpu_irq provides a generic implementation
+                for per CPU interrupts.
+                </para>
+                <para>
+                Per CPU interrupts are only available on SMP and
+                the handler provides a simplified version without
+                locking.
+                </para>
+                <para>
+                The following control flow is implemented (simplified excerpt):
+                <programlisting>
+desc->chip->start();
+handle_IRQ_event(desc->action);
+desc->chip->end();
+                </programlisting>
+                </para>
+            </sect3>
+        </sect2>
+        <sect2>
+        <title>Quirks and optimizations</title>
+        <para>
+        The generic functions are intended for 'clean' architectures and chips,
+        which have no platform-specific IRQ handling quirks. If an architecture
+        needs to implement quirks on the 'flow' level then it can do so by
+        overriding the highlevel irq-flow handler.
+        </para>
+        </sect2>
+        <sect2>
+        <title>Delayed interrupt disable</title>
+        <para>
+        This per interrupt selectable feature, which was introduced by Russell
+        King in the ARM interrupt implementation, does not mask an interrupt
+        at the hardware level when disable_irq() is called. The interrupt is
+        kept enabled and is masked in the flow handler when an interrupt event
+        happens. This prevents losing edge interrupts on hardware which does
+        not store an edge interrupt event while the interrupt is disabled at
+        the hardware level. When an interrupt arrives while the IRQ_DISABLED
+        flag is set, then the interrupt is masked at the hardware level and
+        the IRQ_PENDING bit is set. When the interrupt is re-enabled by
+        enable_irq() the pending bit is checked and if it is set, the
+        interrupt is resent either via hardware or by a software resend
+        mechanism. (It's necessary to enable CONFIG_HARDIRQS_SW_RESEND when
+        you want to use the delayed interrupt disable feature and your
+        hardware is not capable of retriggering an interrupt.)
+        The delayed interrupt disable can be runtime enabled, per interrupt,
+        by setting the IRQ_DELAYED_DISABLE flag in the irq_desc status field.
+        </para>
+        </sect2>
+    </sect1>
+    <sect1>
+        <title>Chiplevel hardware encapsulation</title>
+        <para>
+        The chip level hardware descriptor structure irq_chip
+        contains all the direct chip relevant functions, which
+        can be utilized by the irq flow implementations.
+          <itemizedlist>
+          <listitem><para>ack()</para></listitem>
+          <listitem><para>mask_ack() - Optional, recommended for performance</para></listitem>
+          <listitem><para>mask()</para></listitem>
+          <listitem><para>unmask()</para></listitem>
+          <listitem><para>retrigger() - Optional</para></listitem>
+          <listitem><para>set_type() - Optional</para></listitem>
+          <listitem><para>set_wake() - Optional</para></listitem>
+          </itemizedlist>
+        These primitives are strictly intended to mean what they say: ack means
+        ACK, masking means masking of an IRQ line, etc. It is up to the flow
+        handler(s) to use these basic units of lowlevel functionality.
+        </para>
+    </sect1>
+  </chapter>
+  <chapter id="doirq">
+     <title>__do_IRQ entry point</title>
+     <para>
+        The original implementation __do_IRQ() is an alternative entry
+        point for all types of interrupts.
+     </para>
+     <para>
+        This handler turned out to be not suitable for all
+        interrupt hardware and was therefore reimplemented with split
+        functionality for egde/level/simple/percpu interrupts. This is not
+        only a functional optimization. It also shortens code paths for
+        interrupts.
+      </para>
+      <para>
+        To make use of the split implementation, replace the call to
+        __do_IRQ by a call to desc->chip->handle_irq() and associate
+        the appropriate handler function to desc->chip->handle_irq().
+        In most cases the generic handler implementations should
+        be sufficient.
+     </para>
+  </chapter>
+  <chapter id="locking">
+     <title>Locking on SMP</title>
+     <para>
+        The locking of chip registers is up to the architecture that
+        defines the chip primitives. There is a chip->lock field that can be used
+        for serialization, but the generic layer does not touch it. The per-irq
+        structure is protected via desc->lock, by the generic layer.
+     </para>
+  </chapter>
+  <chapter id="structs">
+     <title>Structures</title>
+     <para>
+     This chapter contains the autogenerated documentation of the structures which are
+     used in the generic IRQ layer.
+     </para>
+!Iinclude/linux/irq.h
+  </chapter>
+  <chapter id="pubfunctions">
+     <title>Public Functions Provided</title>
+     <para>
+     This chapter contains the autogenerated documentation of the kernel API functions
+      which are exported.
+     </para>
+!Ekernel/irq/manage.c
+!Ekernel/irq/chip.c
+  </chapter>
+  <chapter id="intfunctions">
+     <title>Internal Functions Provided</title>
+     <para>
+     This chapter contains the autogenerated documentation of the internal functions.
+     </para>
+!Ikernel/irq/handle.c
+!Ikernel/irq/chip.c
+  </chapter>
+  <chapter id="credits">
+     <title>Credits</title>
+        <para>
+                The following people have contributed to this document:
+                <orderedlist>
+                        <listitem><para>Thomas Gleixner<email>tglx@linutronix.de</email></para></listitem>
+                        <listitem><para>Ingo Molnar<email>mingo@elte.hu</email></para></listitem>
+                </orderedlist>
+        </para>
+  </chapter>
+</book>
diff --git a/Documentation/IRQ.txt b/Documentation/IRQ.txt
new file mode 100644
index 000000000000..1011e7175021
--- /dev/null
+++ b/Documentation/IRQ.txt
@@ -0,0 +1,22 @@
+What is an IRQ?
+An IRQ is an interrupt request from a device.
+Currently they can come in over a pin, or over a packet.
+Several devices may be connected to the same pin thus
+sharing an IRQ.
+An IRQ number is a kernel identifier used to talk about a hardware
+interrupt source.  Typically this is an index into the global irq_desc
+array, but except for what linux/interrupt.h implements the details
+are architecture specific.
+An IRQ number is an enumeration of the possible interrupt sources on a
+machine.  Typically what is enumerated is the number of input pins on
+all of the interrupt controller in the system.  In the case of ISA
+what is enumerated are the 16 input pins on the two i8259 interrupt
+controllers.
+Architectures can assign additional meaning to the IRQ numbers, and
+are encouraged to in the case  where there is any manual configuration
+of the hardware involved.  The ISA IRQs are a classic example of
+assigning this kind of additional meaning.
diff --git a/Documentation/keys-request-key.txt b/Documentation/keys-request-key.txt
index 22488d791168..c1f64fdf84cb 100644
--- a/Documentation/keys-request-key.txt
+++ b/Documentation/keys-request-key.txt
@@ -3,16 +3,23 @@
                              ===================
 The key request service is part of the key retention service (refer to
-Documentation/keys.txt). This document explains more fully how that the
+Documentation/keys.txt).  This document explains more fully how the requesting
-requesting algorithm works.
+algorithm works.
 The process starts by either the kernel requesting a service by calling
-request_key():
+request_key*():
        struct key *request_key(const struct key_type *type,
                                const char *description,
                                const char *callout_string);
+or:
+        struct key *request_key_with_auxdata(const struct key_type *type,
+                                             const char *description,
+                                             const char *callout_string,
+                                             void *aux);
 Or by userspace invoking the request_key system call:
        key_serial_t request_key(const char *type,
@@ -20,16 +27,26 @@ Or by userspace invoking the request_key system call:
                                 const char *callout_info,
                                 key_serial_t dest_keyring);
-The main difference between the two access points is that the in-kernel
+The main difference between the access points is that the in-kernel interface
-interface does not need to link the key to a keyring to prevent it from being
+does not need to link the key to a keyring to prevent it from being immediately
-immediately destroyed. The kernel interface returns a pointer directly to the
+destroyed.  The kernel interface returns a pointer directly to the key, and
-key, and it's up to the caller to destroy the key.
+it's up to the caller to destroy the key.
+The request_key_with_auxdata() call is like the in-kernel request_key() call,
+except that it permits auxiliary data to be passed to the upcaller (the default
+is NULL).  This is only useful for those key types that define their own upcall
+mechanism rather than using /sbin/request-key.
 The userspace interface links the key to a keyring associated with the process
 to prevent the key from going away, and returns the serial number of the key to
 the caller.
+The following example assumes that the key types involved don't define their
+own upcall mechanisms.  If they do, then those should be substituted for the
+forking and execution of /sbin/request-key.
 ===========
 THE PROCESS
 ===========
@@ -40,8 +57,8 @@ A request proceeds in the following manner:
     interface].
 (2) request_key() searches the process's subscribed keyrings to see if there's
-     a suitable key there. If there is, it returns the key. If there isn't, and
+     a suitable key there.  If there is, it returns the key.  If there isn't,
-     callout_info is not set, an error is returned. Otherwise the process
+     and callout_info is not set, an error is returned.  Otherwise the process
     proceeds to the next step.
 (3) request_key() sees that A doesn't have the desired key yet, so it creates
@@ -62,7 +79,7 @@ A request proceeds in the following manner:
     instantiation.
 (7) The program may want to access another key from A's context (say a
-     Kerberos TGT key). It just requests the appropriate key, and the keyring
+     Kerberos TGT key).  It just requests the appropriate key, and the keyring
     search notes that the session keyring has auth key V in its bottom level.
     This will permit it to then search the keyrings of process A with the
@@ -79,10 +96,11 @@ A request proceeds in the following manner:
 (10) The program then exits 0 and request_key() deletes key V and returns key
     U to the caller.
-This also extends further. If key W (step 7 above) didn't exist, key W would be
+This also extends further.  If key W (step 7 above) didn't exist, key W would
-created uninstantiated, another auth key (X) would be created (as per step 3)
+be created uninstantiated, another auth key (X) would be created (as per step
-and another copy of /sbin/request-key spawned (as per step 4); but the context
+3) and another copy of /sbin/request-key spawned (as per step 4); but the
-specified by auth key X will still be process A, as it was in auth key V.
+context specified by auth key X will still be process A, as it was in auth key
+V.
 This is because process A's keyrings can't simply be attached to
 /sbin/request-key at the appropriate places because (a) execve will discard two
@@ -118,17 +136,17 @@ A search of any particular keyring proceeds in the following fashion:
 (2) It considers all the non-keyring keys within that keyring and, if any key
     matches the criteria specified, calls key_permission(SEARCH) on it to see
-     if the key is allowed to be found. If it is, that key is returned; if
+     if the key is allowed to be found.  If it is, that key is returned; if
     not, the search continues, and the error code is retained if of higher
     priority than the one currently set.
 (3) It then considers all the keyring-type keys in the keyring it's currently
-     searching. It calls key_permission(SEARCH) on each keyring, and if this
+     searching.  It calls key_permission(SEARCH) on each keyring, and if this
     grants permission, it recurses, executing steps (2) and (3) on that
     keyring.
 The process stops immediately a valid key is found with permission granted to
-use it. Any error from a previous match attempt is discarded and the key is
+use it.  Any error from a previous match attempt is discarded and the key is
 returned.
 When search_process_keyrings() is invoked, it performs the following searches
@@ -153,7 +171,7 @@ The moment one succeeds, all pending errors are discarded and the found key is
 returned.
 Only if all these fail does the whole thing fail with the highest priority
-error. Note that several errors may have come from LSM.
+error.  Note that several errors may have come from LSM.
 The error priority is:
diff --git a/Documentation/keys.txt b/Documentation/keys.txt
index 61c0fad2fe2f..e373f0212843 100644
--- a/Documentation/keys.txt
+++ b/Documentation/keys.txt
@@ -780,6 +780,17 @@ payload contents" for more information.
    See also Documentation/keys-request-key.txt.
+(*) To search for a key, passing auxiliary data to the upcaller, call:
+        struct key *request_key_with_auxdata(const struct key_type *type,
+                                             const char *description,
+                                             const char *callout_string,
+                                             void *aux);
+    This is identical to request_key(), except that the auxiliary data is
+    passed to the key_type->request_key() op if it exists.
 (*) When it is no longer required, the key should be released using:
        void key_put(struct key *key);
@@ -1031,6 +1042,24 @@ The structure has a number of fields, some of which are mandatory:
     as might happen when the userspace buffer is accessed.
+ (*) int (*request_key)(struct key *key, struct key *authkey, const char *op,
+                        void *aux);
+     This method is optional.  If provided, request_key() and
+     request_key_with_auxdata() will invoke this function rather than
+     upcalling to /sbin/request-key to operate upon a key of this type.
+     The aux parameter is as passed to request_key_with_auxdata() or is NULL
+     otherwise.  Also passed are the key to be operated upon, the
+     authorisation key for this operation and the operation type (currently
+     only "create").
+     This function should return only when the upcall is complete.  Upon return
+     the authorisation key will be revoked, and the target key will be
+     negatively instantiated if it is still uninstantiated.  The error will be
+     returned to the caller of request_key*().
 ============================
 REQUEST-KEY CALLBACK SERVICE
 ============================
diff --git a/arch/alpha/kernel/irq.c b/arch/alpha/kernel/irq.c
index da677f829f76..63af36cf7f6e 100644
--- a/arch/alpha/kernel/irq.c
+++ b/arch/alpha/kernel/irq.c
@@ -49,15 +49,15 @@ select_smp_affinity(unsigned int irq)
        static int last_cpu;
        int cpu = last_cpu + 1;
-        if (!irq_desc[irq].handler->set_affinity || irq_user_affinity[irq])
+        if (!irq_desc[irq].chip->set_affinity || irq_user_affinity[irq])
                return 1;
        while (!cpu_possible(cpu))
                cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
        last_cpu = cpu;
-        irq_affinity[irq] = cpumask_of_cpu(cpu);
+        irq_desc[irq].affinity = cpumask_of_cpu(cpu);
-        irq_desc[irq].handler->set_affinity(irq, cpumask_of_cpu(cpu));
+        irq_desc[irq].chip->set_affinity(irq, cpumask_of_cpu(cpu));
        return 0;
 }
 #endif /* CONFIG_SMP */
@@ -93,7 +93,7 @@ show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[irq]);
 #endif
-                seq_printf(p, " %14s", irq_desc[irq].handler->typename);
+                seq_printf(p, " %14s", irq_desc[irq].chip->typename);
                seq_printf(p, "  %c%s",
                        (action->flags & SA_INTERRUPT)?'+':' ',
                        action->name);
diff --git a/arch/alpha/kernel/irq_alpha.c b/arch/alpha/kernel/irq_alpha.c
index 9d34ce26e5ef..f20f2dff9c43 100644
--- a/arch/alpha/kernel/irq_alpha.c
+++ b/arch/alpha/kernel/irq_alpha.c
@@ -233,7 +233,7 @@ void __init
 init_rtc_irq(void)
 {
        irq_desc[RTC_IRQ].status = IRQ_DISABLED;
-        irq_desc[RTC_IRQ].handler = &rtc_irq_type;
+        irq_desc[RTC_IRQ].chip = &rtc_irq_type;
        setup_irq(RTC_IRQ, &timer_irqaction);
 }
diff --git a/arch/alpha/kernel/irq_i8259.c b/arch/alpha/kernel/irq_i8259.c
index b188683b83fd..ac893bd48036 100644
--- a/arch/alpha/kernel/irq_i8259.c
+++ b/arch/alpha/kernel/irq_i8259.c
@@ -109,7 +109,7 @@ init_i8259a_irqs(void)
        for (i = 0; i < 16; i++) {
                irq_desc[i].status = IRQ_DISABLED;
-                irq_desc[i].handler = &i8259a_irq_type;
+                irq_desc[i].chip = &i8259a_irq_type;
        }
        setup_irq(2, &cascade);
diff --git a/arch/alpha/kernel/irq_pyxis.c b/arch/alpha/kernel/irq_pyxis.c
index 146a20b9e3d5..3b581415bab0 100644
--- a/arch/alpha/kernel/irq_pyxis.c
+++ b/arch/alpha/kernel/irq_pyxis.c
@@ -120,7 +120,7 @@ init_pyxis_irqs(unsigned long ignore_mask)
                if ((ignore_mask >> i) & 1)
                        continue;
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &pyxis_irq_type;
+                irq_desc[i].chip = &pyxis_irq_type;
        }
        setup_irq(16+7, &isa_cascade_irqaction);
diff --git a/arch/alpha/kernel/irq_srm.c b/arch/alpha/kernel/irq_srm.c
index 0a87e466918c..8e4d121f84cc 100644
--- a/arch/alpha/kernel/irq_srm.c
+++ b/arch/alpha/kernel/irq_srm.c
@@ -67,7 +67,7 @@ init_srm_irqs(long max, unsigned long ignore_mask)
                if (i < 64 && ((ignore_mask >> i) & 1))
                        continue;
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &srm_irq_type;
+                irq_desc[i].chip = &srm_irq_type;
        }
 }
diff --git a/arch/alpha/kernel/pci.c b/arch/alpha/kernel/pci.c
index 2a8b364c822e..4ea6711e55aa 100644
--- a/arch/alpha/kernel/pci.c
+++ b/arch/alpha/kernel/pci.c
@@ -124,12 +124,12 @@ DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_final);
 void
 pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long size, unsigned long align)
+                       resource_size_t size, resource_size_t align)
 {
        struct pci_dev *dev = data;
        struct pci_controller *hose = dev->sysdata;
        unsigned long alignto;
-        unsigned long start = res->start;
+        resource_size_t start = res->start;
        if (res->flags & IORESOURCE_IO) {
                /* Make sure we start at our min on all hoses */
diff --git a/arch/alpha/kernel/sys_alcor.c b/arch/alpha/kernel/sys_alcor.c
index d7f0e97fe56f..1a1a2c7a3d94 100644
--- a/arch/alpha/kernel/sys_alcor.c
+++ b/arch/alpha/kernel/sys_alcor.c
@@ -144,7 +144,7 @@ alcor_init_irq(void)
                if (i >= 16+20 && i <= 16+30)
                        continue;
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &alcor_irq_type;
+                irq_desc[i].chip = &alcor_irq_type;
        }
        i8259a_irq_type.ack = alcor_isa_mask_and_ack_irq;
diff --git a/arch/alpha/kernel/sys_cabriolet.c b/arch/alpha/kernel/sys_cabriolet.c
index 8e3374d34c95..8c9e443d93ad 100644
--- a/arch/alpha/kernel/sys_cabriolet.c
+++ b/arch/alpha/kernel/sys_cabriolet.c
@@ -124,7 +124,7 @@ common_init_irq(void (*srm_dev_int)(unsigned long v, struct pt_regs *r))
                for (i = 16; i < 35; ++i) {
                        irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                        irq_desc[i].handler = &cabriolet_irq_type;
+                        irq_desc[i].chip = &cabriolet_irq_type;
                }
        }
diff --git a/arch/alpha/kernel/sys_dp264.c b/arch/alpha/kernel/sys_dp264.c
index d5da6b1b28ee..b28c8f1c6e10 100644
--- a/arch/alpha/kernel/sys_dp264.c
+++ b/arch/alpha/kernel/sys_dp264.c
@@ -300,7 +300,7 @@ init_tsunami_irqs(struct hw_interrupt_type * ops, int imin, int imax)
        long i;
        for (i = imin; i <= imax; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = ops;
+                irq_desc[i].chip = ops;
        }
 }
diff --git a/arch/alpha/kernel/sys_eb64p.c b/arch/alpha/kernel/sys_eb64p.c
index 61a79c354f0b..aeb8e0277905 100644
--- a/arch/alpha/kernel/sys_eb64p.c
+++ b/arch/alpha/kernel/sys_eb64p.c
@@ -137,7 +137,7 @@ eb64p_init_irq(void)
        for (i = 16; i < 32; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &eb64p_irq_type;
+                irq_desc[i].chip = &eb64p_irq_type;
        }               
        common_init_isa_dma();
diff --git a/arch/alpha/kernel/sys_eiger.c b/arch/alpha/kernel/sys_eiger.c
index bd6e5f0e43c7..64a785baf53a 100644
--- a/arch/alpha/kernel/sys_eiger.c
+++ b/arch/alpha/kernel/sys_eiger.c
@@ -154,7 +154,7 @@ eiger_init_irq(void)
        for (i = 16; i < 128; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &eiger_irq_type;
+                irq_desc[i].chip = &eiger_irq_type;
        }
 }
diff --git a/arch/alpha/kernel/sys_jensen.c b/arch/alpha/kernel/sys_jensen.c
index fcabb7c96a16..0148e095638f 100644
--- a/arch/alpha/kernel/sys_jensen.c
+++ b/arch/alpha/kernel/sys_jensen.c
@@ -206,11 +206,11 @@ jensen_init_irq(void)
 {
        init_i8259a_irqs();
-        irq_desc[1].handler = &jensen_local_irq_type;
+        irq_desc[1].chip = &jensen_local_irq_type;
-        irq_desc[4].handler = &jensen_local_irq_type;
+        irq_desc[4].chip = &jensen_local_irq_type;
-        irq_desc[3].handler = &jensen_local_irq_type;
+        irq_desc[3].chip = &jensen_local_irq_type;
-        irq_desc[7].handler = &jensen_local_irq_type;
+        irq_desc[7].chip = &jensen_local_irq_type;
-        irq_desc[9].handler = &jensen_local_irq_type;
+        irq_desc[9].chip = &jensen_local_irq_type;
        common_init_isa_dma();
 }
diff --git a/arch/alpha/kernel/sys_marvel.c b/arch/alpha/kernel/sys_marvel.c
index e32fee505220..36d215954376 100644
--- a/arch/alpha/kernel/sys_marvel.c
+++ b/arch/alpha/kernel/sys_marvel.c
@@ -303,7 +303,7 @@ init_io7_irqs(struct io7 *io7,
        /* Set up the lsi irqs.  */
        for (i = 0; i < 128; ++i) {
                irq_desc[base + i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[base + i].handler = lsi_ops;
+                irq_desc[base + i].chip = lsi_ops;
        }
        /* Disable the implemented irqs in hardware.  */
@@ -317,7 +317,7 @@ init_io7_irqs(struct io7 *io7,
        /* Set up the msi irqs.  */
        for (i = 128; i < (128 + 512); ++i) {
                irq_desc[base + i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[base + i].handler = msi_ops;
+                irq_desc[base + i].chip = msi_ops;
        }
        for (i = 0; i < 16; ++i)
@@ -335,7 +335,7 @@ marvel_init_irq(void)
        /* Reserve the legacy irqs.  */
        for (i = 0; i < 16; ++i) {
                irq_desc[i].status = IRQ_DISABLED;
-                irq_desc[i].handler = &marvel_legacy_irq_type;
+                irq_desc[i].chip = &marvel_legacy_irq_type;
        }
        /* Init the io7 irqs.  */
diff --git a/arch/alpha/kernel/sys_mikasa.c b/arch/alpha/kernel/sys_mikasa.c
index d78a0daa6168..b741600e3761 100644
--- a/arch/alpha/kernel/sys_mikasa.c
+++ b/arch/alpha/kernel/sys_mikasa.c
@@ -117,7 +117,7 @@ mikasa_init_irq(void)
        for (i = 16; i < 32; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &mikasa_irq_type;
+                irq_desc[i].chip = &mikasa_irq_type;
        }
        init_i8259a_irqs();
diff --git a/arch/alpha/kernel/sys_noritake.c b/arch/alpha/kernel/sys_noritake.c
index 65061f5d7410..55db02d318d7 100644
--- a/arch/alpha/kernel/sys_noritake.c
+++ b/arch/alpha/kernel/sys_noritake.c
@@ -139,7 +139,7 @@ noritake_init_irq(void)
        for (i = 16; i < 48; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &noritake_irq_type;
+                irq_desc[i].chip = &noritake_irq_type;
        }
        init_i8259a_irqs();
diff --git a/arch/alpha/kernel/sys_rawhide.c b/arch/alpha/kernel/sys_rawhide.c
index 05888a02a604..949607e3d6fb 100644
--- a/arch/alpha/kernel/sys_rawhide.c
+++ b/arch/alpha/kernel/sys_rawhide.c
@@ -180,7 +180,7 @@ rawhide_init_irq(void)
        for (i = 16; i < 128; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &rawhide_irq_type;
+                irq_desc[i].chip = &rawhide_irq_type;
        }
        init_i8259a_irqs();
diff --git a/arch/alpha/kernel/sys_rx164.c b/arch/alpha/kernel/sys_rx164.c
index 58404243057b..6ae506052635 100644
--- a/arch/alpha/kernel/sys_rx164.c
+++ b/arch/alpha/kernel/sys_rx164.c
@@ -117,7 +117,7 @@ rx164_init_irq(void)
        rx164_update_irq_hw(0);
        for (i = 16; i < 40; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &rx164_irq_type;
+                irq_desc[i].chip = &rx164_irq_type;
        }
        init_i8259a_irqs();
diff --git a/arch/alpha/kernel/sys_sable.c b/arch/alpha/kernel/sys_sable.c
index a7ff84474ace..24dea40c9bfe 100644
--- a/arch/alpha/kernel/sys_sable.c
+++ b/arch/alpha/kernel/sys_sable.c
@@ -537,7 +537,7 @@ sable_lynx_init_irq(int nr_irqs)
        for (i = 0; i < nr_irqs; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &sable_lynx_irq_type;
+                irq_desc[i].chip = &sable_lynx_irq_type;
        }
        common_init_isa_dma();
diff --git a/arch/alpha/kernel/sys_takara.c b/arch/alpha/kernel/sys_takara.c
index 7955bdfc2db0..2c75cd1fd81a 100644
--- a/arch/alpha/kernel/sys_takara.c
+++ b/arch/alpha/kernel/sys_takara.c
@@ -154,7 +154,7 @@ takara_init_irq(void)
        for (i = 16; i < 128; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = &takara_irq_type;
+                irq_desc[i].chip = &takara_irq_type;
        }
        common_init_isa_dma();
diff --git a/arch/alpha/kernel/sys_titan.c b/arch/alpha/kernel/sys_titan.c
index 2551fb49ae09..13f3ed8ed7ac 100644
--- a/arch/alpha/kernel/sys_titan.c
+++ b/arch/alpha/kernel/sys_titan.c
@@ -189,7 +189,7 @@ init_titan_irqs(struct hw_interrupt_type * ops, int imin, int imax)
        long i;
        for (i = imin; i <= imax; ++i) {
                irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i].handler = ops;
+                irq_desc[i].chip = ops;
        }
 }
diff --git a/arch/alpha/kernel/sys_wildfire.c b/arch/alpha/kernel/sys_wildfire.c
index 1553f470246e..22c5798fe083 100644
--- a/arch/alpha/kernel/sys_wildfire.c
+++ b/arch/alpha/kernel/sys_wildfire.c
@@ -199,14 +199,14 @@ wildfire_init_irq_per_pca(int qbbno, int pcano)
                if (i == 2)
                        continue;
                irq_desc[i+irq_bias].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i+irq_bias].handler = &wildfire_irq_type;
+                irq_desc[i+irq_bias].chip = &wildfire_irq_type;
        }
        irq_desc[36+irq_bias].status = IRQ_DISABLED | IRQ_LEVEL;
-        irq_desc[36+irq_bias].handler = &wildfire_irq_type;
+        irq_desc[36+irq_bias].chip = &wildfire_irq_type;
        for (i = 40; i < 64; ++i) {
                irq_desc[i+irq_bias].status = IRQ_DISABLED | IRQ_LEVEL;
-                irq_desc[i+irq_bias].handler = &wildfire_irq_type;
+                irq_desc[i+irq_bias].chip = &wildfire_irq_type;
        }
        setup_irq(32+irq_bias, &isa_enable);    
diff --git a/arch/arm/kernel/bios32.c b/arch/arm/kernel/bios32.c
index 302fc1401547..45da06fc1ba1 100644
--- a/arch/arm/kernel/bios32.c
+++ b/arch/arm/kernel/bios32.c
@@ -304,7 +304,7 @@ static inline int pdev_bad_for_parity(struct pci_dev *dev)
 static void __devinit
 pdev_fixup_device_resources(struct pci_sys_data *root, struct pci_dev *dev)
 {
-        unsigned long offset;
+        resource_size_t offset;
        int i;
        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
@@ -634,9 +634,9 @@ char * __init pcibios_setup(char *str)
 * which might be mirrored at 0x0100-0x03ff..
 */
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
-        unsigned long start = res->start;
+        resource_size_t start = res->start;
        if (res->flags & IORESOURCE_IO && start & 0x300)
                start = (start + 0x3ff) & ~0x3ff;
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 093ccba0503c..6bdf70def01f 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -119,9 +119,24 @@ DEFINE_PER_CPU(struct cpuinfo_arm, cpu_data);
 * Standard memory resources
 */
 static struct resource mem_res[] = {
-        { "Video RAM",   0,     0,     IORESOURCE_MEM                   },
+        {
-        { "Kernel text", 0,     0,     IORESOURCE_MEM                   },
+                .name = "Video RAM",
-        { "Kernel data", 0,     0,     IORESOURCE_MEM                   }
+                .start = 0,
+                .end = 0,
+                .flags = IORESOURCE_MEM
+        },
+        {
+                .name = "Kernel text",
+                .start = 0,
+                .end = 0,
+                .flags = IORESOURCE_MEM
+        },
+        {
+                .name = "Kernel data",
+                .start = 0,
+                .end = 0,
+                .flags = IORESOURCE_MEM
+        }
 };
 #define video_ram   mem_res[0]
@@ -129,9 +144,24 @@ static struct resource mem_res[] = {
 #define kernel_data mem_res[2]
 static struct resource io_res[] = {
-        { "reserved",    0x3bc, 0x3be, IORESOURCE_IO | IORESOURCE_BUSY },
+        {
-        { "reserved",    0x378, 0x37f, IORESOURCE_IO | IORESOURCE_BUSY },
+                .name = "reserved",
-        { "reserved",    0x278, 0x27f, IORESOURCE_IO | IORESOURCE_BUSY }
+                .start = 0x3bc,
+                .end = 0x3be,
+                .flags = IORESOURCE_IO | IORESOURCE_BUSY
+        },
+        {
+                .name = "reserved",
+                .start = 0x378,
+                .end = 0x37f,
+                .flags = IORESOURCE_IO | IORESOURCE_BUSY
+        },
+        {
+                .name = "reserved",
+                .start = 0x278,
+                .end = 0x27f,
+                .flags = IORESOURCE_IO | IORESOURCE_BUSY
+        }
 };
 #define lp0 io_res[0]
diff --git a/arch/cris/Kconfig b/arch/cris/Kconfig
index 856b665020e7..6a1238a29d6c 100644
--- a/arch/cris/Kconfig
+++ b/arch/cris/Kconfig
@@ -28,6 +28,10 @@ config GENERIC_CALIBRATE_DELAY
        bool
        default y
+config IRQ_PER_CPU
+        bool
+        default y
 config CRIS
        bool
        default y
diff --git a/arch/cris/arch-v10/kernel/irq.c b/arch/cris/arch-v10/kernel/irq.c
index 4b368a122015..2d5be93b5197 100644
--- a/arch/cris/arch-v10/kernel/irq.c
+++ b/arch/cris/arch-v10/kernel/irq.c
@@ -172,7 +172,7 @@ init_IRQ(void)
        /* Initialize IRQ handler descriptiors. */
        for(i = 2; i < NR_IRQS; i++) {
-                irq_desc[i].handler = &crisv10_irq_type;
+                irq_desc[i].chip = &crisv10_irq_type;
                set_int_vector(i, interrupt[i]);
        }
diff --git a/arch/cris/arch-v32/drivers/pci/bios.c b/arch/cris/arch-v32/drivers/pci/bios.c
index 1e9d062103ae..a2b9c60c2777 100644
--- a/arch/cris/arch-v32/drivers/pci/bios.c
+++ b/arch/cris/arch-v32/drivers/pci/bios.c
@@ -43,10 +43,10 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
 void
 pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long size, unsigned long align)
+                       resource_size_t size, resource_size_t align)
 {
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (start & 0x300) {
                        start = (start + 0x3ff) & ~0x3ff;
diff --git a/arch/cris/arch-v32/kernel/irq.c b/arch/cris/arch-v32/kernel/irq.c
index c78cc2685133..06260874f018 100644
--- a/arch/cris/arch-v32/kernel/irq.c
+++ b/arch/cris/arch-v32/kernel/irq.c
@@ -369,7 +369,7 @@ init_IRQ(void)
        /* Point all IRQ's to bad handlers. */
        for (i = FIRST_IRQ, j = 0; j < NR_IRQS; i++, j++) {
-                irq_desc[j].handler = &crisv32_irq_type;
+                irq_desc[j].chip = &crisv32_irq_type;
                set_exception_vector(i, interrupt[j]);
        }
diff --git a/arch/cris/kernel/irq.c b/arch/cris/kernel/irq.c
index b504def3e346..6547bb646364 100644
--- a/arch/cris/kernel/irq.c
+++ b/arch/cris/kernel/irq.c
@@ -69,7 +69,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
diff --git a/arch/frv/mb93090-mb00/pci-frv.c b/arch/frv/mb93090-mb00/pci-frv.c
index 0a26bf6f1cd4..4f165c93be42 100644
--- a/arch/frv/mb93090-mb00/pci-frv.c
+++ b/arch/frv/mb93090-mb00/pci-frv.c
@@ -64,10 +64,10 @@ pcibios_update_resource(struct pci_dev *dev, struct resource *root,
 */
 void
 pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long size, unsigned long align)
+                       resource_size_t size, resource_size_t align)
 {
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (start & 0x300) {
                        start = (start + 0x3ff) & ~0x3ff;
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index 3bb221db164a..0463f6335905 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -529,6 +529,7 @@ config X86_PAE
        bool
        depends on HIGHMEM64G
        default y
+        select RESOURCES_64BIT
 # Common NUMA Features
 config NUMA
@@ -794,6 +795,9 @@ config COMPAT_VDSO
 endmenu
+config ARCH_ENABLE_MEMORY_HOTPLUG
+        def_bool y
+        depends on HIGHMEM
 menu "Power management options (ACPI, APM)"
        depends on !X86_VOYAGER
diff --git a/arch/i386/kernel/efi.c b/arch/i386/kernel/efi.c
index 9202b67c4b2e..8beb0f07d999 100644
--- a/arch/i386/kernel/efi.c
+++ b/arch/i386/kernel/efi.c
@@ -601,8 +601,10 @@ efi_initialize_iomem_resources(struct resource *code_resource,
                res->end = res->start + ((md->num_pages << EFI_PAGE_SHIFT) - 1);
                res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
                if (request_resource(&iomem_resource, res) < 0)
-                        printk(KERN_ERR PFX "Failed to allocate res %s : 0x%lx-0x%lx\n",
+                        printk(KERN_ERR PFX "Failed to allocate res %s : "
-                                res->name, res->start, res->end);
+                                "0x%llx-0x%llx\n", res->name,
+                                (unsigned long long)res->start,
+                                (unsigned long long)res->end);
                /*
                 * We don't know which region contains kernel data so we try
                 * it repeatedly and let the resource manager test it.
diff --git a/arch/i386/kernel/i8259.c b/arch/i386/kernel/i8259.c
index c1a42feba286..3c6063671a9f 100644
--- a/arch/i386/kernel/i8259.c
+++ b/arch/i386/kernel/i8259.c
@@ -132,7 +132,7 @@ void make_8259A_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
        io_apic_irqs &= ~(1<<irq);
-        irq_desc[irq].handler = &i8259A_irq_type;
+        irq_desc[irq].chip = &i8259A_irq_type;
        enable_irq(irq);
 }
@@ -386,12 +386,12 @@ void __init init_ISA_irqs (void)
                        /*
                         * 16 old-style INTA-cycle interrupts:
                         */
-                        irq_desc[i].handler = &i8259A_irq_type;
+                        irq_desc[i].chip = &i8259A_irq_type;
                } else {
                        /*
                         * 'high' PCI IRQs filled in on demand
                         */
-                        irq_desc[i].handler = &no_irq_type;
+                        irq_desc[i].chip = &no_irq_type;
                }
        }
 }
diff --git a/arch/i386/kernel/io_apic.c b/arch/i386/kernel/io_apic.c
index 72ae414e4d49..ec9ea0269d36 100644
--- a/arch/i386/kernel/io_apic.c
+++ b/arch/i386/kernel/io_apic.c
@@ -581,7 +581,7 @@ static int balanced_irq(void *unused)
        
        /* push everything to CPU 0 to give us a starting point.  */
        for (i = 0 ; i < NR_IRQS ; i++) {
-                pending_irq_cpumask[i] = cpumask_of_cpu(0);
+                irq_desc[i].pending_mask = cpumask_of_cpu(0);
                set_pending_irq(i, cpumask_of_cpu(0));
        }
@@ -1205,15 +1205,17 @@ static struct hw_interrupt_type ioapic_edge_type;
 #define IOAPIC_EDGE     0
 #define IOAPIC_LEVEL    1
-static inline void ioapic_register_intr(int irq, int vector, unsigned long trigger)
+static void ioapic_register_intr(int irq, int vector, unsigned long trigger)
 {
-        unsigned idx = use_pci_vector() && !platform_legacy_irq(irq) ? vector : irq;
+        unsigned idx;
+        idx = use_pci_vector() && !platform_legacy_irq(irq) ? vector : irq;
        if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
                        trigger == IOAPIC_LEVEL)
-                irq_desc[idx].handler = &ioapic_level_type;
+                irq_desc[idx].chip = &ioapic_level_type;
        else
-                irq_desc[idx].handler = &ioapic_edge_type;
+                irq_desc[idx].chip = &ioapic_edge_type;
        set_intr_gate(vector, interrupt[idx]);
 }
@@ -1325,7 +1327,7 @@ static void __init setup_ExtINT_IRQ0_pin(unsigned int apic, unsigned int pin, in
         * The timer IRQ doesn't have to know that behind the
         * scene we have a 8259A-master in AEOI mode ...
         */
-        irq_desc[0].handler = &ioapic_edge_type;
+        irq_desc[0].chip = &ioapic_edge_type;
        /*
         * Add it to the IO-APIC irq-routing table:
@@ -2069,6 +2071,13 @@ static void set_ioapic_affinity_vector (unsigned int vector,
 #endif
 #endif
+static int ioapic_retrigger(unsigned int irq)
+{
+        send_IPI_self(IO_APIC_VECTOR(irq));
+        return 1;
+}
 /*
 * Level and edge triggered IO-APIC interrupts need different handling,
 * so we use two separate IRQ descriptors. Edge triggered IRQs can be
@@ -2088,6 +2097,7 @@ static struct hw_interrupt_type ioapic_edge_type __read_mostly = {
 #ifdef CONFIG_SMP
        .set_affinity   = set_ioapic_affinity,
 #endif
+        .retrigger      = ioapic_retrigger,
 };
 static struct hw_interrupt_type ioapic_level_type __read_mostly = {
@@ -2101,6 +2111,7 @@ static struct hw_interrupt_type ioapic_level_type __read_mostly = {
 #ifdef CONFIG_SMP
        .set_affinity   = set_ioapic_affinity,
 #endif
+        .retrigger      = ioapic_retrigger,
 };
 static inline void init_IO_APIC_traps(void)
@@ -2135,7 +2146,7 @@ static inline void init_IO_APIC_traps(void)
                                make_8259A_irq(irq);
                        else
                                /* Strange. Oh, well.. */
-                                irq_desc[irq].handler = &no_irq_type;
+                                irq_desc[irq].chip = &no_irq_type;
                }
        }
 }
@@ -2351,7 +2362,7 @@ static inline void check_timer(void)
        printk(KERN_INFO "...trying to set up timer as Virtual Wire IRQ...");
        disable_8259A_irq(0);
-        irq_desc[0].handler = &lapic_irq_type;
+        irq_desc[0].chip = &lapic_irq_type;
        apic_write_around(APIC_LVT0, APIC_DM_FIXED | vector);   /* Fixed mode */
        enable_8259A_irq(0);
diff --git a/arch/i386/kernel/irq.c b/arch/i386/kernel/irq.c
index 9eec9435318e..16b491703967 100644
--- a/arch/i386/kernel/irq.c
+++ b/arch/i386/kernel/irq.c
@@ -82,6 +82,10 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
        }
 #endif
+        if (!irq_desc[irq].handle_irq) {
+                __do_IRQ(irq, regs);
+                goto out_exit;
+        }
 #ifdef CONFIG_4KSTACKS
        curctx = (union irq_ctx *) current_thread_info();
@@ -121,6 +125,7 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
 #endif
                __do_IRQ(irq, regs);
+out_exit:
        irq_exit();
        return 1;
@@ -249,7 +254,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -291,13 +296,13 @@ void fixup_irqs(cpumask_t map)
                if (irq == 2)
                        continue;
-                cpus_and(mask, irq_affinity[irq], map);
+                cpus_and(mask, irq_desc[irq].affinity, map);
                if (any_online_cpu(mask) == NR_CPUS) {
                        printk("Breaking affinity for irq %i\n", irq);
                        mask = map;
                }
-                if (irq_desc[irq].handler->set_affinity)
+                if (irq_desc[irq].chip->set_affinity)
-                        irq_desc[irq].handler->set_affinity(irq, mask);
+                        irq_desc[irq].chip->set_affinity(irq, mask);
                else if (irq_desc[irq].action && !(warned++))
                        printk("Cannot set affinity for irq %i\n", irq);
        }
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index 4a65040cc624..6712f0d2eb37 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -1314,8 +1314,10 @@ legacy_init_iomem_resources(struct resource *code_resource, struct resource *dat
        probe_roms();
        for (i = 0; i < e820.nr_map; i++) {
                struct resource *res;
+#ifndef CONFIG_RESOURCES_64BIT
                if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
                        continue;
+#endif
                res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
                switch (e820.map[i].type) {
                case E820_RAM:  res->name = "System RAM"; break;
diff --git a/arch/i386/mach-visws/setup.c b/arch/i386/mach-visws/setup.c
index 8a9e1a6f745d..1f84cdb24779 100644
--- a/arch/i386/mach-visws/setup.c
+++ b/arch/i386/mach-visws/setup.c
@@ -140,8 +140,8 @@ void __init time_init_hook(void)
 #define MB (1024 * 1024)
-static unsigned long sgivwfb_mem_phys;
+unsigned long sgivwfb_mem_phys;
-static unsigned long sgivwfb_mem_size;
+unsigned long sgivwfb_mem_size;
 long long mem_size __initdata = 0;
@@ -177,8 +177,4 @@ char * __init machine_specific_memory_setup(void)
        add_memory_region(sgivwfb_mem_phys, sgivwfb_mem_size, E820_RESERVED);
        return "PROM";
-        /* Remove gcc warnings */
-        (void) sanitize_e820_map(NULL, NULL);
-        (void) copy_e820_map(NULL, 0);
 }
diff --git a/arch/i386/mach-visws/visws_apic.c b/arch/i386/mach-visws/visws_apic.c
index 3e64fb721291..c418521dd554 100644
--- a/arch/i386/mach-visws/visws_apic.c
+++ b/arch/i386/mach-visws/visws_apic.c
@@ -278,22 +278,22 @@ void init_VISWS_APIC_irqs(void)
                irq_desc[i].depth = 1;
                if (i == 0) {
-                        irq_desc[i].handler = &cobalt_irq_type;
+                        irq_desc[i].chip = &cobalt_irq_type;
                }
                else if (i == CO_IRQ_IDE0) {
-                        irq_desc[i].handler = &cobalt_irq_type;
+                        irq_desc[i].chip = &cobalt_irq_type;
                }
                else if (i == CO_IRQ_IDE1) {
-                        irq_desc[i].handler = &cobalt_irq_type;
+                        irq_desc[i].chip = &cobalt_irq_type;
                }
                else if (i == CO_IRQ_8259) {
-                        irq_desc[i].handler = &piix4_master_irq_type;
+                        irq_desc[i].chip = &piix4_master_irq_type;
                }
                else if (i < CO_IRQ_APIC0) {
-                        irq_desc[i].handler = &piix4_virtual_irq_type;
+                        irq_desc[i].chip = &piix4_virtual_irq_type;
                }
                else if (IS_CO_APIC(i)) {
-                        irq_desc[i].handler = &cobalt_irq_type;
+                        irq_desc[i].chip = &cobalt_irq_type;
                }
        }
diff --git a/arch/i386/mach-voyager/voyager_smp.c b/arch/i386/mach-voyager/voyager_smp.c
index 8242af9ebc6f..5b8b579a079f 100644
--- a/arch/i386/mach-voyager/voyager_smp.c
+++ b/arch/i386/mach-voyager/voyager_smp.c
@@ -1419,7 +1419,7 @@ smp_intr_init(void)
         * This is for later: first 16 correspond to PC IRQs; next 16
         * are Primary MC IRQs and final 16 are Secondary MC IRQs */
        for(i = 0; i < 48; i++)
-                irq_desc[i].handler = &vic_irq_type;
+                irq_desc[i].chip = &vic_irq_type;
 }
 /* send a CPI at level cpi to a set of cpus in cpuset (set 1 bit per
diff --git a/arch/i386/pci/i386.c b/arch/i386/pci/i386.c
index a151f7a99f5e..10154a2cac68 100644
--- a/arch/i386/pci/i386.c
+++ b/arch/i386/pci/i386.c
@@ -48,10 +48,10 @@
 */
 void
 pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long size, unsigned long align)
+                        resource_size_t size, resource_size_t align)
 {
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (start & 0x300) {
                        start = (start + 0x3ff) & ~0x3ff;
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index a56df7bf022d..b487e227a1f7 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -271,6 +271,9 @@ config HOTPLUG_CPU
          can be controlled through /sys/devices/system/cpu/cpu#.
          Say N if you want to disable CPU hotplug.
+config ARCH_ENABLE_MEMORY_HOTPLUG
+        def_bool y
 config SCHED_SMT
        bool "SMT scheduler support"
        depends on SMP
@@ -489,6 +492,10 @@ config GENERIC_PENDING_IRQ
        depends on GENERIC_HARDIRQS && SMP
        default y
+config IRQ_PER_CPU
+        bool
+        default y
 source "arch/ia64/hp/sim/Kconfig"
 menu "Instrumentation Support"
diff --git a/arch/ia64/hp/sim/hpsim_irq.c b/arch/ia64/hp/sim/hpsim_irq.c
index c0d25a2a3e9c..8145547bb52d 100644
--- a/arch/ia64/hp/sim/hpsim_irq.c
+++ b/arch/ia64/hp/sim/hpsim_irq.c
@@ -44,8 +44,8 @@ hpsim_irq_init (void)
        int i;
        for (i = 0; i < NR_IRQS; ++i) {
-                idesc = irq_descp(i);
+                idesc = irq_desc + i;
-                if (idesc->handler == &no_irq_type)
+                if (idesc->chip == &no_irq_type)
-                        idesc->handler = &irq_type_hp_sim;
+                        idesc->chip = &irq_type_hp_sim;
        }
 }
diff --git a/arch/ia64/kernel/iosapic.c b/arch/ia64/kernel/iosapic.c
index d58c1c5c903a..efc7df4b0fd2 100644
--- a/arch/ia64/kernel/iosapic.c
+++ b/arch/ia64/kernel/iosapic.c
@@ -456,7 +456,7 @@ iosapic_startup_edge_irq (unsigned int irq)
 static void
 iosapic_ack_edge_irq (unsigned int irq)
 {
-        irq_desc_t *idesc = irq_descp(irq);
+        irq_desc_t *idesc = irq_desc + irq;
        move_native_irq(irq);
        /*
@@ -659,14 +659,14 @@ register_intr (unsigned int gsi, int vector, unsigned char delivery,
        else
                irq_type = &irq_type_iosapic_level;
-        idesc = irq_descp(vector);
+        idesc = irq_desc + vector;
-        if (idesc->handler != irq_type) {
+        if (idesc->chip != irq_type) {
-                if (idesc->handler != &no_irq_type)
+                if (idesc->chip != &no_irq_type)
                        printk(KERN_WARNING
                               "%s: changing vector %d from %s to %s\n",
                               __FUNCTION__, vector,
-                               idesc->handler->typename, irq_type->typename);
+                               idesc->chip->typename, irq_type->typename);
-                idesc->handler = irq_type;
+                idesc->chip = irq_type;
        }
        return 0;
 }
@@ -793,14 +793,14 @@ again:
                        return -ENOSPC;
        }
-        spin_lock_irqsave(&irq_descp(vector)->lock, flags);
+        spin_lock_irqsave(&irq_desc[vector].lock, flags);
        spin_lock(&iosapic_lock);
        {
                if (gsi_to_vector(gsi) > 0) {
                        if (list_empty(&iosapic_intr_info[vector].rtes))
                                free_irq_vector(vector);
                        spin_unlock(&iosapic_lock);
-                        spin_unlock_irqrestore(&irq_descp(vector)->lock,
+                        spin_unlock_irqrestore(&irq_desc[vector].lock,
                                               flags);
                        goto again;
                }
@@ -810,7 +810,7 @@ again:
                              polarity, trigger);
                if (err < 0) {
                        spin_unlock(&iosapic_lock);
-                        spin_unlock_irqrestore(&irq_descp(vector)->lock,
+                        spin_unlock_irqrestore(&irq_desc[vector].lock,
                                               flags);
                        return err;
                }
@@ -825,7 +825,7 @@ again:
                set_rte(gsi, vector, dest, mask);
        }
        spin_unlock(&iosapic_lock);
-        spin_unlock_irqrestore(&irq_descp(vector)->lock, flags);
+        spin_unlock_irqrestore(&irq_desc[vector].lock, flags);
        printk(KERN_INFO "GSI %u (%s, %s) -> CPU %d (0x%04x) vector %d\n",
               gsi, (trigger == IOSAPIC_EDGE ? "edge" : "level"),
@@ -860,7 +860,7 @@ iosapic_unregister_intr (unsigned int gsi)
        }
        vector = irq_to_vector(irq);
-        idesc = irq_descp(irq);
+        idesc = irq_desc + irq;
        spin_lock_irqsave(&idesc->lock, flags);
        spin_lock(&iosapic_lock);
        {
@@ -903,7 +903,7 @@ iosapic_unregister_intr (unsigned int gsi)
                        BUG_ON(iosapic_intr_info[vector].count);
                        /* Clear the interrupt controller descriptor */
-                        idesc->handler = &no_irq_type;
+                        idesc->chip = &no_irq_type;
                        /* Clear the interrupt information */
                        memset(&iosapic_intr_info[vector], 0,
diff --git a/arch/ia64/kernel/irq.c b/arch/ia64/kernel/irq.c
index 9c72ea3f6432..7852382de2fa 100644
--- a/arch/ia64/kernel/irq.c
+++ b/arch/ia64/kernel/irq.c
@@ -76,7 +76,7 @@ int show_interrupts(struct seq_file *p, void *v)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
                }
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -100,7 +100,7 @@ void set_irq_affinity_info (unsigned int irq, int hwid, int redir)
        cpu_set(cpu_logical_id(hwid), mask);
        if (irq < NR_IRQS) {
-                irq_affinity[irq] = mask;
+                irq_desc[irq].affinity = mask;
                irq_redir[irq] = (char) (redir & 0xff);
        }
 }
@@ -120,7 +120,7 @@ static void migrate_irqs(void)
        int             irq, new_cpu;
        for (irq=0; irq < NR_IRQS; irq++) {
-                desc = irq_descp(irq);
+                desc = irq_desc + irq;
                /*
                 * No handling for now.
@@ -131,7 +131,7 @@ static void migrate_irqs(void)
                if (desc->status == IRQ_PER_CPU)
                        continue;
-                cpus_and(mask, irq_affinity[irq], cpu_online_map);
+                cpus_and(mask, irq_desc[irq].affinity, cpu_online_map);
                if (any_online_cpu(mask) == NR_CPUS) {
                        /*
                         * Save it for phase 2 processing
@@ -144,15 +144,15 @@ static void migrate_irqs(void)
                        /*
                         * Al three are essential, currently WARN_ON.. maybe panic?
                         */
-                        if (desc->handler && desc->handler->disable &&
+                        if (desc->chip && desc->chip->disable &&
-                                desc->handler->enable && desc->handler->set_affinity) {
+                                desc->chip->enable && desc->chip->set_affinity) {
-                                desc->handler->disable(irq);
+                                desc->chip->disable(irq);
-                                desc->handler->set_affinity(irq, mask);
+                                desc->chip->set_affinity(irq, mask);
-                                desc->handler->enable(irq);
+                                desc->chip->enable(irq);
                        } else {
-                                WARN_ON((!(desc->handler) || !(desc->handler->disable) ||
+                                WARN_ON((!(desc->chip) || !(desc->chip->disable) ||
-                                                !(desc->handler->enable) ||
+                                                !(desc->chip->enable) ||
-                                                !(desc->handler->set_affinity)));
+                                                !(desc->chip->set_affinity)));
                        }
                }
        }
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index ef9a2b49307a..f5035304594e 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -249,9 +249,9 @@ register_percpu_irq (ia64_vector vec, struct irqaction *action)
        for (irq = 0; irq < NR_IRQS; ++irq)
                if (irq_to_vector(irq) == vec) {
-                        desc = irq_descp(irq);
+                        desc = irq_desc + irq;
                        desc->status |= IRQ_PER_CPU;
-                        desc->handler = &irq_type_ia64_lsapic;
+                        desc->chip = &irq_type_ia64_lsapic;
                        if (action)
                                setup_irq(irq, action);
                }
diff --git a/arch/ia64/kernel/irq_lsapic.c b/arch/ia64/kernel/irq_lsapic.c
index ea14e6a04409..1ab58b09f3d7 100644
--- a/arch/ia64/kernel/irq_lsapic.c
+++ b/arch/ia64/kernel/irq_lsapic.c
@@ -26,6 +26,13 @@ lsapic_noop (unsigned int irq)
        /* nuthing to do... */
 }
+static int lsapic_retrigger(unsigned int irq)
+{
+        ia64_resend_irq(irq);
+        return 1;
+}
 struct hw_interrupt_type irq_type_ia64_lsapic = {
        .typename =     "LSAPIC",
        .startup =      lsapic_noop_startup,
@@ -33,5 +40,6 @@ struct hw_interrupt_type irq_type_ia64_lsapic = {
        .enable =       lsapic_noop,
        .disable =      lsapic_noop,
        .ack =          lsapic_noop,
-        .end =          lsapic_noop
+        .end =          lsapic_noop,
+        .retrigger =    lsapic_retrigger,
 };
diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
index 6a0880639bc9..d7dc5e63de63 100644
--- a/arch/ia64/kernel/mca.c
+++ b/arch/ia64/kernel/mca.c
@@ -1788,7 +1788,7 @@ ia64_mca_late_init(void)
                        cpe_poll_enabled = 0;
                        for (irq = 0; irq < NR_IRQS; ++irq)
                                if (irq_to_vector(irq) == cpe_vector) {
-                                        desc = irq_descp(irq);
+                                        desc = irq_desc + irq;
                                        desc->status |= IRQ_PER_CPU;
                                        setup_irq(irq, &mca_cpe_irqaction);
                                        ia64_cpe_irq = irq;
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index 6d7bc8ff7b3a..a0055d3d695c 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -6165,7 +6165,7 @@ pfm_load_regs (struct task_struct *task)
                /*
                 * will replay the PMU interrupt
                 */
-                if (need_irq_resend) hw_resend_irq(NULL, IA64_PERFMON_VECTOR);
+                if (need_irq_resend) ia64_resend_irq(IA64_PERFMON_VECTOR);
                pfm_stats[smp_processor_id()].pfm_replay_ovfl_intr_count++;
        }
@@ -6305,7 +6305,7 @@ pfm_load_regs (struct task_struct *task)
                /*
                 * will replay the PMU interrupt
                 */
-                if (need_irq_resend) hw_resend_irq(NULL, IA64_PERFMON_VECTOR);
+                if (need_irq_resend) ia64_resend_irq(IA64_PERFMON_VECTOR);
                pfm_stats[smp_processor_id()].pfm_replay_ovfl_intr_count++;
        }
diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
index 44e9547878ac..5203df78f150 100644
--- a/arch/ia64/kernel/smpboot.c
+++ b/arch/ia64/kernel/smpboot.c
@@ -677,16 +677,16 @@ int migrate_platform_irqs(unsigned int cpu)
                        new_cpei_cpu = any_online_cpu(cpu_online_map);
                        mask = cpumask_of_cpu(new_cpei_cpu);
                        set_cpei_target_cpu(new_cpei_cpu);
-                        desc = irq_descp(ia64_cpe_irq);
+                        desc = irq_desc + ia64_cpe_irq;
                        /*
                         * Switch for now, immediatly, we need to do fake intr
                         * as other interrupts, but need to study CPEI behaviour with
                         * polling before making changes.
                         */
                        if (desc) {
-                                desc->handler->disable(ia64_cpe_irq);
+                                desc->chip->disable(ia64_cpe_irq);
-                                desc->handler->set_affinity(ia64_cpe_irq, mask);
+                                desc->chip->set_affinity(ia64_cpe_irq, mask);
-                                desc->handler->enable(ia64_cpe_irq);
+                                desc->chip->enable(ia64_cpe_irq);
                                printk ("Re-targetting CPEI to cpu %d\n", new_cpei_cpu);
                        }
                }
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index 77375a55da31..5bef0e3603f2 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -568,7 +568,7 @@ pcibios_disable_device (struct pci_dev *dev)
 void
 pcibios_align_resource (void *data, struct resource *res,
-                        unsigned long size, unsigned long align)
+                        resource_size_t size, resource_size_t align)
 {
 }
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index 677c6c0fd661..7bb6ad188ba3 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -225,8 +225,8 @@ void sn_irq_init(void)
        ia64_last_device_vector = IA64_SN2_LAST_DEVICE_VECTOR;
        for (i = 0; i < NR_IRQS; i++) {
-                if (base_desc[i].handler == &no_irq_type) {
+                if (base_desc[i].chip == &no_irq_type) {
-                        base_desc[i].handler = &irq_type_sn;
+                        base_desc[i].chip = &irq_type_sn;
                }
        }
 }
diff --git a/arch/m32r/kernel/irq.c b/arch/m32r/kernel/irq.c
index a4634b06f675..3841861df6a2 100644
--- a/arch/m32r/kernel/irq.c
+++ b/arch/m32r/kernel/irq.c
@@ -54,7 +54,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
diff --git a/arch/m32r/kernel/setup_m32104ut.c b/arch/m32r/kernel/setup_m32104ut.c
index 6328e1357a80..f9f56c270195 100644
--- a/arch/m32r/kernel/setup_m32104ut.c
+++ b/arch/m32r/kernel/setup_m32104ut.c
@@ -87,7 +87,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SMC91X)
        /* INT#0: LAN controller on M32104UT-LAN (SMC91C111)*/
        irq_desc[M32R_IRQ_INT0].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT0].handler = &m32104ut_irq_type;
+        irq_desc[M32R_IRQ_INT0].chip = &m32104ut_irq_type;
        irq_desc[M32R_IRQ_INT0].action = 0;
        irq_desc[M32R_IRQ_INT0].depth = 1;
        icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN | M32R_ICUCR_ISMOD11; /* "H" level sense */
@@ -96,7 +96,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &m32104ut_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &m32104ut_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -105,7 +105,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_SIO
        /* SIO0_R : uart receive data */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &m32104ut_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &m32104ut_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = M32R_ICUCR_IEN;
@@ -113,7 +113,7 @@ void __init init_IRQ(void)
        /* SIO0_S : uart send data */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &m32104ut_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &m32104ut_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = M32R_ICUCR_IEN;
diff --git a/arch/m32r/kernel/setup_m32700ut.c b/arch/m32r/kernel/setup_m32700ut.c
index fad1fc99bb27..b6ab00eff580 100644
--- a/arch/m32r/kernel/setup_m32700ut.c
+++ b/arch/m32r/kernel/setup_m32700ut.c
@@ -301,7 +301,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SMC91X)
        /* INT#0: LAN controller on M32700UT-LAN (SMC91C111)*/
        irq_desc[M32700UT_LAN_IRQ_LAN].status = IRQ_DISABLED;
-        irq_desc[M32700UT_LAN_IRQ_LAN].handler = &m32700ut_lanpld_irq_type;
+        irq_desc[M32700UT_LAN_IRQ_LAN].chip = &m32700ut_lanpld_irq_type;
        irq_desc[M32700UT_LAN_IRQ_LAN].action = 0;
        irq_desc[M32700UT_LAN_IRQ_LAN].depth = 1;       /* disable nested irq */
        lanpld_icu_data[irq2lanpldirq(M32700UT_LAN_IRQ_LAN)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD02;   /* "H" edge sense */
@@ -310,7 +310,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -318,7 +318,7 @@ void __init init_IRQ(void)
        /* SIO0 : receive */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -326,7 +326,7 @@ void __init init_IRQ(void)
        /* SIO0 : send */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
@@ -334,7 +334,7 @@ void __init init_IRQ(void)
        /* SIO1 : receive */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -342,7 +342,7 @@ void __init init_IRQ(void)
        /* SIO1 : send */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
@@ -350,7 +350,7 @@ void __init init_IRQ(void)
        /* DMA1 : */
        irq_desc[M32R_IRQ_DMA1].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_DMA1].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_DMA1].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_DMA1].action = 0;
        irq_desc[M32R_IRQ_DMA1].depth = 1;
        icu_data[M32R_IRQ_DMA1].icucr = 0;
@@ -359,7 +359,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_PLDSIO
        /* INT#1: SIO0 Receive on PLD */
        irq_desc[PLD_IRQ_SIO0_RCV].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_SIO0_RCV].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_SIO0_RCV].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_SIO0_RCV].action = 0;
        irq_desc[PLD_IRQ_SIO0_RCV].depth = 1;   /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_SIO0_RCV)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD03;
@@ -367,7 +367,7 @@ void __init init_IRQ(void)
        /* INT#1: SIO0 Send on PLD */
        irq_desc[PLD_IRQ_SIO0_SND].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_SIO0_SND].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_SIO0_SND].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_SIO0_SND].action = 0;
        irq_desc[PLD_IRQ_SIO0_SND].depth = 1;   /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_SIO0_SND)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD03;
@@ -376,7 +376,7 @@ void __init init_IRQ(void)
        /* INT#1: CFC IREQ on PLD */
        irq_desc[PLD_IRQ_CFIREQ].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFIREQ].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_CFIREQ].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_CFIREQ].action = 0;
        irq_desc[PLD_IRQ_CFIREQ].depth = 1;     /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_CFIREQ)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD01;       /* 'L' level sense */
@@ -384,7 +384,7 @@ void __init init_IRQ(void)
        /* INT#1: CFC Insert on PLD */
        irq_desc[PLD_IRQ_CFC_INSERT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_INSERT].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_CFC_INSERT].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_CFC_INSERT].action = 0;
        irq_desc[PLD_IRQ_CFC_INSERT].depth = 1; /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_CFC_INSERT)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD00;   /* 'L' edge sense */
@@ -392,7 +392,7 @@ void __init init_IRQ(void)
        /* INT#1: CFC Eject on PLD */
        irq_desc[PLD_IRQ_CFC_EJECT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_EJECT].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_CFC_EJECT].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_CFC_EJECT].action = 0;
        irq_desc[PLD_IRQ_CFC_EJECT].depth = 1;  /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_CFC_EJECT)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD02;    /* 'H' edge sense */
@@ -416,7 +416,7 @@ void __init init_IRQ(void)
        outw(USBCR_OTGS, USBCR);        /* USBCR: non-OTG */
    irq_desc[M32700UT_LCD_IRQ_USB_INT1].status = IRQ_DISABLED;
-    irq_desc[M32700UT_LCD_IRQ_USB_INT1].handler = &m32700ut_lcdpld_irq_type;
+    irq_desc[M32700UT_LCD_IRQ_USB_INT1].chip = &m32700ut_lcdpld_irq_type;
    irq_desc[M32700UT_LCD_IRQ_USB_INT1].action = 0;
    irq_desc[M32700UT_LCD_IRQ_USB_INT1].depth = 1;
    lcdpld_icu_data[irq2lcdpldirq(M32700UT_LCD_IRQ_USB_INT1)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD01;  /* "L" level sense */
@@ -434,7 +434,7 @@ void __init init_IRQ(void)
         * INT3# is used for AR
         */
        irq_desc[M32R_IRQ_INT3].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT3].handler = &m32700ut_irq_type;
+        irq_desc[M32R_IRQ_INT3].chip = &m32700ut_irq_type;
        irq_desc[M32R_IRQ_INT3].action = 0;
        irq_desc[M32R_IRQ_INT3].depth = 1;
        icu_data[M32R_IRQ_INT3].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
diff --git a/arch/m32r/kernel/setup_mappi.c b/arch/m32r/kernel/setup_mappi.c
index 00f253209cb3..c268044185f5 100644
--- a/arch/m32r/kernel/setup_mappi.c
+++ b/arch/m32r/kernel/setup_mappi.c
@@ -86,7 +86,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_NE2000
        /* INT0 : LAN controller (RTL8019AS) */
        irq_desc[M32R_IRQ_INT0].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT0].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_INT0].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_INT0].action = 0;
        irq_desc[M32R_IRQ_INT0].depth = 1;
        icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
@@ -95,7 +95,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -104,7 +104,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_SIO
        /* SIO0_R : uart receive data */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -112,7 +112,7 @@ void __init init_IRQ(void)
        /* SIO0_S : uart send data */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
@@ -120,7 +120,7 @@ void __init init_IRQ(void)
        /* SIO1_R : uart receive data */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -128,7 +128,7 @@ void __init init_IRQ(void)
        /* SIO1_S : uart send data */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
@@ -138,7 +138,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_M32R_PCC)
        /* INT1 : pccard0 interrupt */
        irq_desc[M32R_IRQ_INT1].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT1].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_INT1].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_INT1].action = 0;
        irq_desc[M32R_IRQ_INT1].depth = 1;
        icu_data[M32R_IRQ_INT1].icucr = M32R_ICUCR_IEN | M32R_ICUCR_ISMOD00;
@@ -146,7 +146,7 @@ void __init init_IRQ(void)
        /* INT2 : pccard1 interrupt */
        irq_desc[M32R_IRQ_INT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT2].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_INT2].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_INT2].action = 0;
        irq_desc[M32R_IRQ_INT2].depth = 1;
        icu_data[M32R_IRQ_INT2].icucr = M32R_ICUCR_IEN | M32R_ICUCR_ISMOD00;
diff --git a/arch/m32r/kernel/setup_mappi2.c b/arch/m32r/kernel/setup_mappi2.c
index eebc9d8b4e72..bd2327d5cca2 100644
--- a/arch/m32r/kernel/setup_mappi2.c
+++ b/arch/m32r/kernel/setup_mappi2.c
@@ -87,7 +87,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SMC91X)
        /* INT0 : LAN controller (SMC91111) */
        irq_desc[M32R_IRQ_INT0].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT0].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_INT0].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_INT0].action = 0;
        irq_desc[M32R_IRQ_INT0].depth = 1;
        icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
@@ -96,7 +96,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -105,7 +105,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_SIO
        /* SIO0_R : uart receive data */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -113,14 +113,14 @@ void __init init_IRQ(void)
        /* SIO0_S : uart send data */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
        disable_mappi2_irq(M32R_IRQ_SIO0_S);
        /* SIO1_R : uart receive data */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -128,7 +128,7 @@ void __init init_IRQ(void)
        /* SIO1_S : uart send data */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
@@ -138,7 +138,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_USB)
        /* INT1 : USB Host controller interrupt */
        irq_desc[M32R_IRQ_INT1].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT1].handler = &mappi2_irq_type;
+        irq_desc[M32R_IRQ_INT1].chip = &mappi2_irq_type;
        irq_desc[M32R_IRQ_INT1].action = 0;
        irq_desc[M32R_IRQ_INT1].depth = 1;
        icu_data[M32R_IRQ_INT1].icucr = M32R_ICUCR_ISMOD01;
@@ -147,7 +147,7 @@ void __init init_IRQ(void)
        /* ICUCR40: CFC IREQ */
        irq_desc[PLD_IRQ_CFIREQ].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFIREQ].handler = &mappi2_irq_type;
+        irq_desc[PLD_IRQ_CFIREQ].chip = &mappi2_irq_type;
        irq_desc[PLD_IRQ_CFIREQ].action = 0;
        irq_desc[PLD_IRQ_CFIREQ].depth = 1;     /* disable nested irq */
        icu_data[PLD_IRQ_CFIREQ].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD01;
@@ -156,7 +156,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_M32R_CFC)
        /* ICUCR41: CFC Insert */
        irq_desc[PLD_IRQ_CFC_INSERT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_INSERT].handler = &mappi2_irq_type;
+        irq_desc[PLD_IRQ_CFC_INSERT].chip = &mappi2_irq_type;
        irq_desc[PLD_IRQ_CFC_INSERT].action = 0;
        irq_desc[PLD_IRQ_CFC_INSERT].depth = 1; /* disable nested irq */
        icu_data[PLD_IRQ_CFC_INSERT].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD00;
@@ -164,7 +164,7 @@ void __init init_IRQ(void)
        /* ICUCR42: CFC Eject */
        irq_desc[PLD_IRQ_CFC_EJECT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_EJECT].handler = &mappi2_irq_type;
+        irq_desc[PLD_IRQ_CFC_EJECT].chip = &mappi2_irq_type;
        irq_desc[PLD_IRQ_CFC_EJECT].action = 0;
        irq_desc[PLD_IRQ_CFC_EJECT].depth = 1;  /* disable nested irq */
        icu_data[PLD_IRQ_CFC_EJECT].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
diff --git a/arch/m32r/kernel/setup_mappi3.c b/arch/m32r/kernel/setup_mappi3.c
index d2ff021e2d3d..014b51d17505 100644
--- a/arch/m32r/kernel/setup_mappi3.c
+++ b/arch/m32r/kernel/setup_mappi3.c
@@ -87,7 +87,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SMC91X)
        /* INT0 : LAN controller (SMC91111) */
        irq_desc[M32R_IRQ_INT0].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT0].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_INT0].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_INT0].action = 0;
        irq_desc[M32R_IRQ_INT0].depth = 1;
        icu_data[M32R_IRQ_INT0].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
@@ -96,7 +96,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -105,7 +105,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_SIO
        /* SIO0_R : uart receive data */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -113,14 +113,14 @@ void __init init_IRQ(void)
        /* SIO0_S : uart send data */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
        disable_mappi3_irq(M32R_IRQ_SIO0_S);
        /* SIO1_R : uart receive data */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -128,7 +128,7 @@ void __init init_IRQ(void)
        /* SIO1_S : uart send data */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
@@ -138,7 +138,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_USB)
        /* INT1 : USB Host controller interrupt */
        irq_desc[M32R_IRQ_INT1].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT1].handler = &mappi3_irq_type;
+        irq_desc[M32R_IRQ_INT1].chip = &mappi3_irq_type;
        irq_desc[M32R_IRQ_INT1].action = 0;
        irq_desc[M32R_IRQ_INT1].depth = 1;
        icu_data[M32R_IRQ_INT1].icucr = M32R_ICUCR_ISMOD01;
@@ -147,7 +147,7 @@ void __init init_IRQ(void)
        /* CFC IREQ */
        irq_desc[PLD_IRQ_CFIREQ].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFIREQ].handler = &mappi3_irq_type;
+        irq_desc[PLD_IRQ_CFIREQ].chip = &mappi3_irq_type;
        irq_desc[PLD_IRQ_CFIREQ].action = 0;
        irq_desc[PLD_IRQ_CFIREQ].depth = 1;     /* disable nested irq */
        icu_data[PLD_IRQ_CFIREQ].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD01;
@@ -156,7 +156,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_M32R_CFC)
        /* ICUCR41: CFC Insert & eject */
        irq_desc[PLD_IRQ_CFC_INSERT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_INSERT].handler = &mappi3_irq_type;
+        irq_desc[PLD_IRQ_CFC_INSERT].chip = &mappi3_irq_type;
        irq_desc[PLD_IRQ_CFC_INSERT].action = 0;
        irq_desc[PLD_IRQ_CFC_INSERT].depth = 1; /* disable nested irq */
        icu_data[PLD_IRQ_CFC_INSERT].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD00;
@@ -166,7 +166,7 @@ void __init init_IRQ(void)
        /* IDE IREQ */
        irq_desc[PLD_IRQ_IDEIREQ].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_IDEIREQ].handler = &mappi3_irq_type;
+        irq_desc[PLD_IRQ_IDEIREQ].chip = &mappi3_irq_type;
        irq_desc[PLD_IRQ_IDEIREQ].action = 0;
        irq_desc[PLD_IRQ_IDEIREQ].depth = 1;    /* disable nested irq */
        icu_data[PLD_IRQ_IDEIREQ].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
diff --git a/arch/m32r/kernel/setup_oaks32r.c b/arch/m32r/kernel/setup_oaks32r.c
index 0e9e63538c0f..ea64831aef7a 100644
--- a/arch/m32r/kernel/setup_oaks32r.c
+++ b/arch/m32r/kernel/setup_oaks32r.c
@@ -85,7 +85,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_NE2000
        /* INT3 : LAN controller (RTL8019AS) */
        irq_desc[M32R_IRQ_INT3].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT3].handler = &oaks32r_irq_type;
+        irq_desc[M32R_IRQ_INT3].chip = &oaks32r_irq_type;
        irq_desc[M32R_IRQ_INT3].action = 0;
        irq_desc[M32R_IRQ_INT3].depth = 1;
        icu_data[M32R_IRQ_INT3].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
@@ -94,7 +94,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &oaks32r_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &oaks32r_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -103,7 +103,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_SIO
        /* SIO0_R : uart receive data */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &oaks32r_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &oaks32r_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -111,7 +111,7 @@ void __init init_IRQ(void)
        /* SIO0_S : uart send data */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &oaks32r_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &oaks32r_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
@@ -119,7 +119,7 @@ void __init init_IRQ(void)
        /* SIO1_R : uart receive data */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &oaks32r_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &oaks32r_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -127,7 +127,7 @@ void __init init_IRQ(void)
        /* SIO1_S : uart send data */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &oaks32r_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &oaks32r_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
diff --git a/arch/m32r/kernel/setup_opsput.c b/arch/m32r/kernel/setup_opsput.c
index 548e8fc7949b..55e8972d455a 100644
--- a/arch/m32r/kernel/setup_opsput.c
+++ b/arch/m32r/kernel/setup_opsput.c
@@ -302,7 +302,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SMC91X)
        /* INT#0: LAN controller on OPSPUT-LAN (SMC91C111)*/
        irq_desc[OPSPUT_LAN_IRQ_LAN].status = IRQ_DISABLED;
-        irq_desc[OPSPUT_LAN_IRQ_LAN].handler = &opsput_lanpld_irq_type;
+        irq_desc[OPSPUT_LAN_IRQ_LAN].chip = &opsput_lanpld_irq_type;
        irq_desc[OPSPUT_LAN_IRQ_LAN].action = 0;
        irq_desc[OPSPUT_LAN_IRQ_LAN].depth = 1; /* disable nested irq */
        lanpld_icu_data[irq2lanpldirq(OPSPUT_LAN_IRQ_LAN)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD02;     /* "H" edge sense */
@@ -311,7 +311,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -319,7 +319,7 @@ void __init init_IRQ(void)
        /* SIO0 : receive */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -327,7 +327,7 @@ void __init init_IRQ(void)
        /* SIO0 : send */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
@@ -335,7 +335,7 @@ void __init init_IRQ(void)
        /* SIO1 : receive */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -343,7 +343,7 @@ void __init init_IRQ(void)
        /* SIO1 : send */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
@@ -351,7 +351,7 @@ void __init init_IRQ(void)
        /* DMA1 : */
        irq_desc[M32R_IRQ_DMA1].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_DMA1].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_DMA1].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_DMA1].action = 0;
        irq_desc[M32R_IRQ_DMA1].depth = 1;
        icu_data[M32R_IRQ_DMA1].icucr = 0;
@@ -360,7 +360,7 @@ void __init init_IRQ(void)
 #ifdef CONFIG_SERIAL_M32R_PLDSIO
        /* INT#1: SIO0 Receive on PLD */
        irq_desc[PLD_IRQ_SIO0_RCV].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_SIO0_RCV].handler = &opsput_pld_irq_type;
+        irq_desc[PLD_IRQ_SIO0_RCV].chip = &opsput_pld_irq_type;
        irq_desc[PLD_IRQ_SIO0_RCV].action = 0;
        irq_desc[PLD_IRQ_SIO0_RCV].depth = 1;   /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_SIO0_RCV)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD03;
@@ -368,7 +368,7 @@ void __init init_IRQ(void)
        /* INT#1: SIO0 Send on PLD */
        irq_desc[PLD_IRQ_SIO0_SND].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_SIO0_SND].handler = &opsput_pld_irq_type;
+        irq_desc[PLD_IRQ_SIO0_SND].chip = &opsput_pld_irq_type;
        irq_desc[PLD_IRQ_SIO0_SND].action = 0;
        irq_desc[PLD_IRQ_SIO0_SND].depth = 1;   /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_SIO0_SND)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD03;
@@ -378,7 +378,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_M32R_CFC)
        /* INT#1: CFC IREQ on PLD */
        irq_desc[PLD_IRQ_CFIREQ].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFIREQ].handler = &opsput_pld_irq_type;
+        irq_desc[PLD_IRQ_CFIREQ].chip = &opsput_pld_irq_type;
        irq_desc[PLD_IRQ_CFIREQ].action = 0;
        irq_desc[PLD_IRQ_CFIREQ].depth = 1;     /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_CFIREQ)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD01;       /* 'L' level sense */
@@ -386,7 +386,7 @@ void __init init_IRQ(void)
        /* INT#1: CFC Insert on PLD */
        irq_desc[PLD_IRQ_CFC_INSERT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_INSERT].handler = &opsput_pld_irq_type;
+        irq_desc[PLD_IRQ_CFC_INSERT].chip = &opsput_pld_irq_type;
        irq_desc[PLD_IRQ_CFC_INSERT].action = 0;
        irq_desc[PLD_IRQ_CFC_INSERT].depth = 1; /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_CFC_INSERT)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD00;   /* 'L' edge sense */
@@ -394,7 +394,7 @@ void __init init_IRQ(void)
        /* INT#1: CFC Eject on PLD */
        irq_desc[PLD_IRQ_CFC_EJECT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_CFC_EJECT].handler = &opsput_pld_irq_type;
+        irq_desc[PLD_IRQ_CFC_EJECT].chip = &opsput_pld_irq_type;
        irq_desc[PLD_IRQ_CFC_EJECT].action = 0;
        irq_desc[PLD_IRQ_CFC_EJECT].depth = 1;  /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_CFC_EJECT)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD02;    /* 'H' edge sense */
@@ -420,7 +420,7 @@ void __init init_IRQ(void)
        outw(USBCR_OTGS, USBCR);        /* USBCR: non-OTG */
    irq_desc[OPSPUT_LCD_IRQ_USB_INT1].status = IRQ_DISABLED;
-    irq_desc[OPSPUT_LCD_IRQ_USB_INT1].handler = &opsput_lcdpld_irq_type;
+    irq_desc[OPSPUT_LCD_IRQ_USB_INT1].chip = &opsput_lcdpld_irq_type;
    irq_desc[OPSPUT_LCD_IRQ_USB_INT1].action = 0;
    irq_desc[OPSPUT_LCD_IRQ_USB_INT1].depth = 1;
    lcdpld_icu_data[irq2lcdpldirq(OPSPUT_LCD_IRQ_USB_INT1)].icucr = PLD_ICUCR_IEN|PLD_ICUCR_ISMOD01;    /* "L" level sense */
@@ -438,7 +438,7 @@ void __init init_IRQ(void)
         * INT3# is used for AR
         */
        irq_desc[M32R_IRQ_INT3].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_INT3].handler = &opsput_irq_type;
+        irq_desc[M32R_IRQ_INT3].chip = &opsput_irq_type;
        irq_desc[M32R_IRQ_INT3].action = 0;
        irq_desc[M32R_IRQ_INT3].depth = 1;
        icu_data[M32R_IRQ_INT3].icucr = M32R_ICUCR_IEN|M32R_ICUCR_ISMOD10;
diff --git a/arch/m32r/kernel/setup_usrv.c b/arch/m32r/kernel/setup_usrv.c
index 64be659a23e7..7fa12d8f66b4 100644
--- a/arch/m32r/kernel/setup_usrv.c
+++ b/arch/m32r/kernel/setup_usrv.c
@@ -158,7 +158,7 @@ void __init init_IRQ(void)
        /* MFT2 : system timer */
        irq_desc[M32R_IRQ_MFT2].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_MFT2].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_MFT2].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_MFT2].action = 0;
        irq_desc[M32R_IRQ_MFT2].depth = 1;
        icu_data[M32R_IRQ_MFT2].icucr = M32R_ICUCR_IEN;
@@ -167,7 +167,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SERIAL_M32R_SIO)
        /* SIO0_R : uart receive data */
        irq_desc[M32R_IRQ_SIO0_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_R].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO0_R].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO0_R].action = 0;
        irq_desc[M32R_IRQ_SIO0_R].depth = 1;
        icu_data[M32R_IRQ_SIO0_R].icucr = 0;
@@ -175,7 +175,7 @@ void __init init_IRQ(void)
        /* SIO0_S : uart send data */
        irq_desc[M32R_IRQ_SIO0_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO0_S].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO0_S].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO0_S].action = 0;
        irq_desc[M32R_IRQ_SIO0_S].depth = 1;
        icu_data[M32R_IRQ_SIO0_S].icucr = 0;
@@ -183,7 +183,7 @@ void __init init_IRQ(void)
        /* SIO1_R : uart receive data */
        irq_desc[M32R_IRQ_SIO1_R].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_R].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO1_R].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO1_R].action = 0;
        irq_desc[M32R_IRQ_SIO1_R].depth = 1;
        icu_data[M32R_IRQ_SIO1_R].icucr = 0;
@@ -191,7 +191,7 @@ void __init init_IRQ(void)
        /* SIO1_S : uart send data */
        irq_desc[M32R_IRQ_SIO1_S].status = IRQ_DISABLED;
-        irq_desc[M32R_IRQ_SIO1_S].handler = &mappi_irq_type;
+        irq_desc[M32R_IRQ_SIO1_S].chip = &mappi_irq_type;
        irq_desc[M32R_IRQ_SIO1_S].action = 0;
        irq_desc[M32R_IRQ_SIO1_S].depth = 1;
        icu_data[M32R_IRQ_SIO1_S].icucr = 0;
@@ -201,7 +201,7 @@ void __init init_IRQ(void)
        /* INT#67-#71: CFC#0 IREQ on PLD */
        for (i = 0 ; i < CONFIG_CFC_NUM ; i++ ) {
                irq_desc[PLD_IRQ_CF0 + i].status = IRQ_DISABLED;
-                irq_desc[PLD_IRQ_CF0 + i].handler = &m32700ut_pld_irq_type;
+                irq_desc[PLD_IRQ_CF0 + i].chip = &m32700ut_pld_irq_type;
                irq_desc[PLD_IRQ_CF0 + i].action = 0;
                irq_desc[PLD_IRQ_CF0 + i].depth = 1;    /* disable nested irq */
                pld_icu_data[irq2pldirq(PLD_IRQ_CF0 + i)].icucr
@@ -212,7 +212,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_SERIAL_8250) || defined(CONFIG_SERIAL_8250_MODULE)
        /* INT#76: 16552D#0 IREQ on PLD */
        irq_desc[PLD_IRQ_UART0].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_UART0].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_UART0].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_UART0].action = 0;
        irq_desc[PLD_IRQ_UART0].depth = 1;      /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_UART0)].icucr
@@ -221,7 +221,7 @@ void __init init_IRQ(void)
        /* INT#77: 16552D#1 IREQ on PLD */
        irq_desc[PLD_IRQ_UART1].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_UART1].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_UART1].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_UART1].action = 0;
        irq_desc[PLD_IRQ_UART1].depth = 1;      /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_UART1)].icucr
@@ -232,7 +232,7 @@ void __init init_IRQ(void)
 #if defined(CONFIG_IDC_AK4524) || defined(CONFIG_IDC_AK4524_MODULE)
        /* INT#80: AK4524 IREQ on PLD */
        irq_desc[PLD_IRQ_SNDINT].status = IRQ_DISABLED;
-        irq_desc[PLD_IRQ_SNDINT].handler = &m32700ut_pld_irq_type;
+        irq_desc[PLD_IRQ_SNDINT].chip = &m32700ut_pld_irq_type;
        irq_desc[PLD_IRQ_SNDINT].action = 0;
        irq_desc[PLD_IRQ_SNDINT].depth = 1;     /* disable nested irq */
        pld_icu_data[irq2pldirq(PLD_IRQ_SNDINT)].icucr
diff --git a/arch/m68knommu/kernel/comempci.c b/arch/m68knommu/kernel/comempci.c
index 8670938f1107..db7a0c1cebae 100644
--- a/arch/m68knommu/kernel/comempci.c
+++ b/arch/m68knommu/kernel/comempci.c
@@ -357,7 +357,8 @@ void pcibios_fixup_bus(struct pci_bus *b)
 /*****************************************************************************/
-void pcibios_align_resource(void *data, struct resource *res, unsigned long size, unsigned long align)
+void pcibios_align_resource(void *data, struct resource *res,
+                                resource_size_t size, resource_size_t align)
 {
 }
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 35e038a974c6..08c2ece4ae40 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -1618,6 +1618,11 @@ config GENERIC_IRQ_PROBE
        bool
        default y
+config IRQ_PER_CPU
+        depends on SMP
+        bool
+        default y
 #
 # - Highmem only makes sense for the 32-bit kernel.
 # - The current highmem code will only work properly on physically indexed
diff --git a/arch/mips/au1000/common/irq.c b/arch/mips/au1000/common/irq.c
index afe05ec12c27..da74ac21954b 100644
--- a/arch/mips/au1000/common/irq.c
+++ b/arch/mips/au1000/common/irq.c
@@ -333,31 +333,31 @@ static void setup_local_irq(unsigned int irq_nr, int type, int int_req)
                                au_writel(1<<(irq_nr-32), IC1_CFG2CLR);
                                au_writel(1<<(irq_nr-32), IC1_CFG1CLR);
                                au_writel(1<<(irq_nr-32), IC1_CFG0SET);
-                                irq_desc[irq_nr].handler = &rise_edge_irq_type;
+                                irq_desc[irq_nr].chip = &rise_edge_irq_type;
                                break;
                        case INTC_INT_FALL_EDGE: /* 0:1:0 */
                                au_writel(1<<(irq_nr-32), IC1_CFG2CLR);
                                au_writel(1<<(irq_nr-32), IC1_CFG1SET);
                                au_writel(1<<(irq_nr-32), IC1_CFG0CLR);
-                                irq_desc[irq_nr].handler = &fall_edge_irq_type;
+                                irq_desc[irq_nr].chip = &fall_edge_irq_type;
                                break;
                        case INTC_INT_RISE_AND_FALL_EDGE: /* 0:1:1 */
                                au_writel(1<<(irq_nr-32), IC1_CFG2CLR);
                                au_writel(1<<(irq_nr-32), IC1_CFG1SET);
                                au_writel(1<<(irq_nr-32), IC1_CFG0SET);
-                                irq_desc[irq_nr].handler = &either_edge_irq_type;
+                                irq_desc[irq_nr].chip = &either_edge_irq_type;
                                break;
                        case INTC_INT_HIGH_LEVEL: /* 1:0:1 */
                                au_writel(1<<(irq_nr-32), IC1_CFG2SET);
                                au_writel(1<<(irq_nr-32), IC1_CFG1CLR);
                                au_writel(1<<(irq_nr-32), IC1_CFG0SET);
-                                irq_desc[irq_nr].handler = &level_irq_type;
+                                irq_desc[irq_nr].chip = &level_irq_type;
                                break;
                        case INTC_INT_LOW_LEVEL: /* 1:1:0 */
                                au_writel(1<<(irq_nr-32), IC1_CFG2SET);
                                au_writel(1<<(irq_nr-32), IC1_CFG1SET);
                                au_writel(1<<(irq_nr-32), IC1_CFG0CLR);
-                                irq_desc[irq_nr].handler = &level_irq_type;
+                                irq_desc[irq_nr].chip = &level_irq_type;
                                break;
                        case INTC_INT_DISABLED: /* 0:0:0 */
                                au_writel(1<<(irq_nr-32), IC1_CFG0CLR);
@@ -385,31 +385,31 @@ static void setup_local_irq(unsigned int irq_nr, int type, int int_req)
                                au_writel(1<<irq_nr, IC0_CFG2CLR);
                                au_writel(1<<irq_nr, IC0_CFG1CLR);
                                au_writel(1<<irq_nr, IC0_CFG0SET);
-                                irq_desc[irq_nr].handler = &rise_edge_irq_type;
+                                irq_desc[irq_nr].chip = &rise_edge_irq_type;
                                break;
                        case INTC_INT_FALL_EDGE: /* 0:1:0 */
                                au_writel(1<<irq_nr, IC0_CFG2CLR);
                                au_writel(1<<irq_nr, IC0_CFG1SET);
                                au_writel(1<<irq_nr, IC0_CFG0CLR);
-                                irq_desc[irq_nr].handler = &fall_edge_irq_type;
+                                irq_desc[irq_nr].chip = &fall_edge_irq_type;
                                break;
                        case INTC_INT_RISE_AND_FALL_EDGE: /* 0:1:1 */
                                au_writel(1<<irq_nr, IC0_CFG2CLR);
                                au_writel(1<<irq_nr, IC0_CFG1SET);
                                au_writel(1<<irq_nr, IC0_CFG0SET);
-                                irq_desc[irq_nr].handler = &either_edge_irq_type;
+                                irq_desc[irq_nr].chip = &either_edge_irq_type;
                                break;
                        case INTC_INT_HIGH_LEVEL: /* 1:0:1 */
                                au_writel(1<<irq_nr, IC0_CFG2SET);
                                au_writel(1<<irq_nr, IC0_CFG1CLR);
                                au_writel(1<<irq_nr, IC0_CFG0SET);
-                                irq_desc[irq_nr].handler = &level_irq_type;
+                                irq_desc[irq_nr].chip = &level_irq_type;
                                break;
                        case INTC_INT_LOW_LEVEL: /* 1:1:0 */
                                au_writel(1<<irq_nr, IC0_CFG2SET);
                                au_writel(1<<irq_nr, IC0_CFG1SET);
                                au_writel(1<<irq_nr, IC0_CFG0CLR);
-                                irq_desc[irq_nr].handler = &level_irq_type;
+                                irq_desc[irq_nr].chip = &level_irq_type;
                                break;
                        case INTC_INT_DISABLED: /* 0:0:0 */
                                au_writel(1<<irq_nr, IC0_CFG0CLR);
diff --git a/arch/mips/au1000/pb1200/irqmap.c b/arch/mips/au1000/pb1200/irqmap.c
index bacc0c6bfe67..5dd164fc1889 100644
--- a/arch/mips/au1000/pb1200/irqmap.c
+++ b/arch/mips/au1000/pb1200/irqmap.c
@@ -172,7 +172,7 @@ void _board_init_irq(void)
        for (irq_nr = PB1200_INT_BEGIN; irq_nr <= PB1200_INT_END; irq_nr++)
        {
-                irq_desc[irq_nr].handler = &external_irq_type;
+                irq_desc[irq_nr].chip = &external_irq_type;
                pb1200_disable_irq(irq_nr);
        }
diff --git a/arch/mips/ddb5xxx/ddb5477/irq_5477.c b/arch/mips/ddb5xxx/ddb5477/irq_5477.c
index 5fcd5f070cdc..63c3d6534b3a 100644
--- a/arch/mips/ddb5xxx/ddb5477/irq_5477.c
+++ b/arch/mips/ddb5xxx/ddb5477/irq_5477.c
@@ -107,7 +107,7 @@ void __init vrc5477_irq_init(u32 irq_base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &vrc5477_irq_controller;
+                irq_desc[i].chip = &vrc5477_irq_controller;
        }
        vrc5477_irq_base = irq_base;
diff --git a/arch/mips/dec/ioasic-irq.c b/arch/mips/dec/ioasic-irq.c
index d5bca5d233b6..da2dbb42f913 100644
--- a/arch/mips/dec/ioasic-irq.c
+++ b/arch/mips/dec/ioasic-irq.c
@@ -144,13 +144,13 @@ void __init init_ioasic_irqs(int base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &ioasic_irq_type;
+                irq_desc[i].chip = &ioasic_irq_type;
        }
        for (; i < base + IO_IRQ_LINES; i++) {
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &ioasic_dma_irq_type;
+                irq_desc[i].chip = &ioasic_dma_irq_type;
        }
        ioasic_irq_base = base;
diff --git a/arch/mips/dec/kn02-irq.c b/arch/mips/dec/kn02-irq.c
index 898bed502a34..d44c00d9e80f 100644
--- a/arch/mips/dec/kn02-irq.c
+++ b/arch/mips/dec/kn02-irq.c
@@ -123,7 +123,7 @@ void __init init_kn02_irqs(int base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &kn02_irq_type;
+                irq_desc[i].chip = &kn02_irq_type;
        }
        kn02_irq_base = base;
diff --git a/arch/mips/gt64120/ev64120/irq.c b/arch/mips/gt64120/ev64120/irq.c
index 46c468b26b30..f489a8067a93 100644
--- a/arch/mips/gt64120/ev64120/irq.c
+++ b/arch/mips/gt64120/ev64120/irq.c
@@ -138,7 +138,7 @@ void __init arch_init_irq(void)
        /*  Let's initialize our IRQ descriptors  */
        for (i = 0; i < NR_IRQS; i++) {
                irq_desc[i].status = 0;
-                irq_desc[i].handler = &no_irq_type;
+                irq_desc[i].chip = &no_irq_type;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 0;
                spin_lock_init(&irq_desc[i].lock);
diff --git a/arch/mips/ite-boards/generic/irq.c b/arch/mips/ite-boards/generic/irq.c
index 77be7216bdd0..a6749c56fe38 100644
--- a/arch/mips/ite-boards/generic/irq.c
+++ b/arch/mips/ite-boards/generic/irq.c
@@ -208,10 +208,10 @@ void __init arch_init_irq(void)
 #endif
        for (i = 0; i <= IT8172_LAST_IRQ; i++) {
-                irq_desc[i].handler = &it8172_irq_type;
+                irq_desc[i].chip = &it8172_irq_type;
                spin_lock_init(&irq_desc[i].lock);
        }
-        irq_desc[MIPS_CPU_TIMER_IRQ].handler = &cp0_irq_type;
+        irq_desc[MIPS_CPU_TIMER_IRQ].chip = &cp0_irq_type;
        set_c0_status(ALLINTS_NOTIMER);
 }
diff --git a/arch/mips/jazz/irq.c b/arch/mips/jazz/irq.c
index becc9accd495..478be9858a1e 100644
--- a/arch/mips/jazz/irq.c
+++ b/arch/mips/jazz/irq.c
@@ -73,7 +73,7 @@ void __init init_r4030_ints(void)
                irq_desc[i].status     = IRQ_DISABLED;
                irq_desc[i].action     = 0;
                irq_desc[i].depth      = 1;
-                irq_desc[i].handler    = &r4030_irq_type;
+                irq_desc[i].chip    = &r4030_irq_type;
        }
        r4030_write_reg16(JAZZ_IO_IRQ_ENABLE, 0);
diff --git a/arch/mips/jmr3927/rbhma3100/irq.c b/arch/mips/jmr3927/rbhma3100/irq.c
index 11304d1354f4..380046ea1db5 100644
--- a/arch/mips/jmr3927/rbhma3100/irq.c
+++ b/arch/mips/jmr3927/rbhma3100/irq.c
@@ -435,7 +435,7 @@ void jmr3927_irq_init(u32 irq_base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &jmr3927_irq_controller;
+                irq_desc[i].chip = &jmr3927_irq_controller;
        }
        jmr3927_irq_base = irq_base;
diff --git a/arch/mips/kernel/i8259.c b/arch/mips/kernel/i8259.c
index 0cb8ed5662f3..91ffb1233cad 100644
--- a/arch/mips/kernel/i8259.c
+++ b/arch/mips/kernel/i8259.c
@@ -120,7 +120,7 @@ int i8259A_irq_pending(unsigned int irq)
 void make_8259A_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &i8259A_irq_type;
+        irq_desc[irq].chip = &i8259A_irq_type;
        enable_irq(irq);
 }
@@ -327,7 +327,7 @@ void __init init_i8259_irqs (void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &i8259A_irq_type;
+                irq_desc[i].chip = &i8259A_irq_type;
        }
        setup_irq(2, &irq2);
diff --git a/arch/mips/kernel/irq-msc01.c b/arch/mips/kernel/irq-msc01.c
index 97ebdc754b9e..f8cd1ac64d88 100644
--- a/arch/mips/kernel/irq-msc01.c
+++ b/arch/mips/kernel/irq-msc01.c
@@ -174,14 +174,14 @@ void __init init_msc_irqs(unsigned int base, msc_irqmap_t *imp, int nirq)
                switch (imp->im_type) {
                case MSC01_IRQ_EDGE:
-                        irq_desc[base+n].handler = &msc_edgeirq_type;
+                        irq_desc[base+n].chip = &msc_edgeirq_type;
                        if (cpu_has_veic)
                                MSCIC_WRITE(MSC01_IC_SUP+n*8, MSC01_IC_SUP_EDGE_BIT);
                        else
                                MSCIC_WRITE(MSC01_IC_SUP+n*8, MSC01_IC_SUP_EDGE_BIT | imp->im_lvl);
                        break;
                case MSC01_IRQ_LEVEL:
-                        irq_desc[base+n].handler = &msc_levelirq_type;
+                        irq_desc[base+n].chip = &msc_levelirq_type;
                        if (cpu_has_veic)
                                MSCIC_WRITE(MSC01_IC_SUP+n*8, 0);
                        else
diff --git a/arch/mips/kernel/irq-mv6434x.c b/arch/mips/kernel/irq-mv6434x.c
index 0613f1f36b1b..f9c763a65547 100644
--- a/arch/mips/kernel/irq-mv6434x.c
+++ b/arch/mips/kernel/irq-mv6434x.c
@@ -155,7 +155,7 @@ void __init mv64340_irq_init(unsigned int base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 2;
-                irq_desc[i].handler = &mv64340_irq_type;
+                irq_desc[i].chip = &mv64340_irq_type;
        }
        irq_base = base;
diff --git a/arch/mips/kernel/irq-rm7000.c b/arch/mips/kernel/irq-rm7000.c
index 0b130c5ac5d9..121da385a94d 100644
--- a/arch/mips/kernel/irq-rm7000.c
+++ b/arch/mips/kernel/irq-rm7000.c
@@ -91,7 +91,7 @@ void __init rm7k_cpu_irq_init(int base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &rm7k_irq_controller;
+                irq_desc[i].chip = &rm7k_irq_controller;
        }
        irq_base = base;
diff --git a/arch/mips/kernel/irq-rm9000.c b/arch/mips/kernel/irq-rm9000.c
index 9b5f20c32acb..25109c103e44 100644
--- a/arch/mips/kernel/irq-rm9000.c
+++ b/arch/mips/kernel/irq-rm9000.c
@@ -139,11 +139,11 @@ void __init rm9k_cpu_irq_init(int base)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &rm9k_irq_controller;
+                irq_desc[i].chip = &rm9k_irq_controller;
        }
        rm9000_perfcount_irq = base + 1;
-        irq_desc[rm9000_perfcount_irq].handler = &rm9k_perfcounter_irq;
+        irq_desc[rm9000_perfcount_irq].chip = &rm9k_perfcounter_irq;
        irq_base = base;
 }
diff --git a/arch/mips/kernel/irq.c b/arch/mips/kernel/irq.c
index 3dce742e716f..5c9dcd5eed59 100644
--- a/arch/mips/kernel/irq.c
+++ b/arch/mips/kernel/irq.c
@@ -95,7 +95,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -137,7 +137,7 @@ void __init init_IRQ(void)
                irq_desc[i].status  = IRQ_DISABLED;
                irq_desc[i].action  = NULL;
                irq_desc[i].depth   = 1;
-                irq_desc[i].handler = &no_irq_type;
+                irq_desc[i].chip = &no_irq_type;
                spin_lock_init(&irq_desc[i].lock);
 #ifdef CONFIG_MIPS_MT_SMTC
                irq_hwmask[i] = 0;
diff --git a/arch/mips/kernel/irq_cpu.c b/arch/mips/kernel/irq_cpu.c
index 5db67e31ec1a..0e455a8ad860 100644
--- a/arch/mips/kernel/irq_cpu.c
+++ b/arch/mips/kernel/irq_cpu.c
@@ -167,14 +167,14 @@ void __init mips_cpu_irq_init(int irq_base)
                        irq_desc[i].status = IRQ_DISABLED;
                        irq_desc[i].action = NULL;
                        irq_desc[i].depth = 1;
-                        irq_desc[i].handler = &mips_mt_cpu_irq_controller;
+                        irq_desc[i].chip = &mips_mt_cpu_irq_controller;
                }
        for (i = irq_base + 2; i < irq_base + 8; i++) {
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &mips_cpu_irq_controller;
+                irq_desc[i].chip = &mips_cpu_irq_controller;
        }
        mips_cpu_irq_base = irq_base;
diff --git a/arch/mips/lasat/interrupt.c b/arch/mips/lasat/interrupt.c
index 2d3472b21ebb..9316a024a818 100644
--- a/arch/mips/lasat/interrupt.c
+++ b/arch/mips/lasat/interrupt.c
@@ -156,6 +156,6 @@ void __init arch_init_irq(void)
                irq_desc[i].status      = IRQ_DISABLED;
                irq_desc[i].action      = 0;
                irq_desc[i].depth       = 1;
-                irq_desc[i].handler     = &lasat_irq_type;
+                irq_desc[i].chip        = &lasat_irq_type;
        }
 }
diff --git a/arch/mips/mips-boards/atlas/atlas_int.c b/arch/mips/mips-boards/atlas/atlas_int.c
index db53950b7cfb..9dd6b8925581 100644
--- a/arch/mips/mips-boards/atlas/atlas_int.c
+++ b/arch/mips/mips-boards/atlas/atlas_int.c
@@ -215,7 +215,7 @@ void __init arch_init_irq(void)
                irq_desc[i].status      = IRQ_DISABLED;
                irq_desc[i].action      = 0;
                irq_desc[i].depth       = 1;
-                irq_desc[i].handler     = &atlas_irq_type;
+                irq_desc[i].chip        = &atlas_irq_type;
                spin_lock_init(&irq_desc[i].lock);
        }
 }
diff --git a/arch/mips/momentum/ocelot_c/cpci-irq.c b/arch/mips/momentum/ocelot_c/cpci-irq.c
index bd885785e2f9..31d179c4673f 100644
--- a/arch/mips/momentum/ocelot_c/cpci-irq.c
+++ b/arch/mips/momentum/ocelot_c/cpci-irq.c
@@ -147,6 +147,6 @@ void cpci_irq_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 2;
-                irq_desc[i].handler = &cpci_irq_type;
+                irq_desc[i].chip = &cpci_irq_type;
        }
 }
diff --git a/arch/mips/momentum/ocelot_c/uart-irq.c b/arch/mips/momentum/ocelot_c/uart-irq.c
index 755bde5146be..852265026fd1 100644
--- a/arch/mips/momentum/ocelot_c/uart-irq.c
+++ b/arch/mips/momentum/ocelot_c/uart-irq.c
@@ -137,10 +137,10 @@ void uart_irq_init(void)
        irq_desc[80].status = IRQ_DISABLED;
        irq_desc[80].action = 0;
        irq_desc[80].depth = 2;
-        irq_desc[80].handler = &uart_irq_type;
+        irq_desc[80].chip = &uart_irq_type;
        irq_desc[81].status = IRQ_DISABLED;
        irq_desc[81].action = 0;
        irq_desc[81].depth = 2;
-        irq_desc[81].handler = &uart_irq_type;
+        irq_desc[81].chip = &uart_irq_type;
 }
diff --git a/arch/mips/pci/pci.c b/arch/mips/pci/pci.c
index 4dfce154d4af..ba66f8c9bd4e 100644
--- a/arch/mips/pci/pci.c
+++ b/arch/mips/pci/pci.c
@@ -51,11 +51,11 @@ unsigned long PCIBIOS_MIN_MEM	= 0;
 */
 void
 pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long size, unsigned long align)
+                       resource_size_t size, resource_size_t align)
 {
        struct pci_dev *dev = data;
        struct pci_controller *hose = dev->sysdata;
-        unsigned long start = res->start;
+        resource_size_t start = res->start;
        if (res->flags & IORESOURCE_IO) {
                /* Make sure we start at our min on all hoses */
diff --git a/arch/mips/philips/pnx8550/common/int.c b/arch/mips/philips/pnx8550/common/int.c
index 39ee6314f627..8f18764a2359 100644
--- a/arch/mips/philips/pnx8550/common/int.c
+++ b/arch/mips/philips/pnx8550/common/int.c
@@ -236,7 +236,7 @@ void __init arch_init_irq(void)
        int configPR;
        for (i = 0; i < PNX8550_INT_CP0_TOTINT; i++) {
-                irq_desc[i].handler = &level_irq_type;
+                irq_desc[i].chip = &level_irq_type;
                pnx8550_ack(i); /* mask the irq just in case  */
        }
@@ -273,7 +273,7 @@ void __init arch_init_irq(void)
                /* mask/priority is still 0 so we will not get any
                 * interrupts until it is unmasked */
-                irq_desc[i].handler = &level_irq_type;
+                irq_desc[i].chip = &level_irq_type;
        }
        /* Priority level 0 */
@@ -282,12 +282,12 @@ void __init arch_init_irq(void)
        /* Set int vector table address */
        PNX8550_GIC_VECTOR_0 = PNX8550_GIC_VECTOR_1 = 0;
-        irq_desc[MIPS_CPU_GIC_IRQ].handler = &level_irq_type;
+        irq_desc[MIPS_CPU_GIC_IRQ].chip = &level_irq_type;
        setup_irq(MIPS_CPU_GIC_IRQ, &gic_action);
        /* init of Timer interrupts */
        for (i = PNX8550_INT_TIMER_MIN; i <= PNX8550_INT_TIMER_MAX; i++) {
-                irq_desc[i].handler = &level_irq_type;
+                irq_desc[i].chip = &level_irq_type;
        }
        /* Stop Timer 1-3 */
@@ -295,7 +295,7 @@ void __init arch_init_irq(void)
        configPR |= 0x00000038;
        write_c0_config7(configPR);
-        irq_desc[MIPS_CPU_TIMER_IRQ].handler = &level_irq_type;
+        irq_desc[MIPS_CPU_TIMER_IRQ].chip = &level_irq_type;
        setup_irq(MIPS_CPU_TIMER_IRQ, &timer_action);
 }
diff --git a/arch/mips/pmc-sierra/yosemite/ht.c b/arch/mips/pmc-sierra/yosemite/ht.c
index 54b65a80abf5..fb523ebcafa8 100644
--- a/arch/mips/pmc-sierra/yosemite/ht.c
+++ b/arch/mips/pmc-sierra/yosemite/ht.c
@@ -383,12 +383,12 @@ void pcibios_update_resource(struct pci_dev *dev, struct resource *root,
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
        struct pci_dev *dev = data;
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                /* We need to avoid collisions with `mirrored' VGA ports
                   and other strange ISA hardware, so we always want the
diff --git a/arch/mips/sgi-ip22/ip22-eisa.c b/arch/mips/sgi-ip22/ip22-eisa.c
index b19820110aa3..989167b49ce9 100644
--- a/arch/mips/sgi-ip22/ip22-eisa.c
+++ b/arch/mips/sgi-ip22/ip22-eisa.c
@@ -279,9 +279,9 @@ int __init ip22_eisa_init(void)
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
                if (i < (SGINT_EISA + 8))
-                        irq_desc[i].handler = &ip22_eisa1_irq_type;
+                        irq_desc[i].chip = &ip22_eisa1_irq_type;
                else
-                        irq_desc[i].handler = &ip22_eisa2_irq_type;
+                        irq_desc[i].chip = &ip22_eisa2_irq_type;
        }
        /* Cannot use request_irq because of kmalloc not being ready at such
diff --git a/arch/mips/sgi-ip22/ip22-int.c b/arch/mips/sgi-ip22/ip22-int.c
index fc6a7e2b189c..18906af69691 100644
--- a/arch/mips/sgi-ip22/ip22-int.c
+++ b/arch/mips/sgi-ip22/ip22-int.c
@@ -436,7 +436,7 @@ void __init arch_init_irq(void)
                irq_desc[i].status      = IRQ_DISABLED;
                irq_desc[i].action      = 0;
                irq_desc[i].depth       = 1;
-                irq_desc[i].handler     = handler;
+                irq_desc[i].chip        = handler;
        }
        /* vector handler. this register the IRQ as non-sharable */
diff --git a/arch/mips/sgi-ip27/ip27-irq.c b/arch/mips/sgi-ip27/ip27-irq.c
index 0b61a39ce2bb..869566c360ae 100644
--- a/arch/mips/sgi-ip27/ip27-irq.c
+++ b/arch/mips/sgi-ip27/ip27-irq.c
@@ -386,7 +386,7 @@ void __devinit register_bridge_irq(unsigned int irq)
        irq_desc[irq].status    = IRQ_DISABLED;
        irq_desc[irq].action    = 0;
        irq_desc[irq].depth     = 1;
-        irq_desc[irq].handler   = &bridge_irq_type;
+        irq_desc[irq].chip      = &bridge_irq_type;
 }
 int __devinit request_bridge_irq(struct bridge_controller *bc)
diff --git a/arch/mips/sgi-ip32/ip32-irq.c b/arch/mips/sgi-ip32/ip32-irq.c
index 8ba08047d164..00b94aaf6371 100644
--- a/arch/mips/sgi-ip32/ip32-irq.c
+++ b/arch/mips/sgi-ip32/ip32-irq.c
@@ -591,7 +591,7 @@ void __init arch_init_irq(void)
                irq_desc[irq].status = IRQ_DISABLED;
                irq_desc[irq].action = 0;
                irq_desc[irq].depth = 0;
-                irq_desc[irq].handler = controller;
+                irq_desc[irq].chip = controller;
        }
        setup_irq(CRIME_MEMERR_IRQ, &memerr_irq);
        setup_irq(CRIME_CPUERR_IRQ, &cpuerr_irq);
diff --git a/arch/mips/sibyte/bcm1480/irq.c b/arch/mips/sibyte/bcm1480/irq.c
index e61760b14d99..610df40cb820 100644
--- a/arch/mips/sibyte/bcm1480/irq.c
+++ b/arch/mips/sibyte/bcm1480/irq.c
@@ -276,10 +276,10 @@ void __init init_bcm1480_irqs(void)
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
                if (i < BCM1480_NR_IRQS) {
-                        irq_desc[i].handler = &bcm1480_irq_type;
+                        irq_desc[i].chip = &bcm1480_irq_type;
                        bcm1480_irq_owner[i] = 0;
                } else {
-                        irq_desc[i].handler = &no_irq_type;
+                        irq_desc[i].chip = &no_irq_type;
                }
        }
 }
diff --git a/arch/mips/sibyte/sb1250/irq.c b/arch/mips/sibyte/sb1250/irq.c
index f853c32f60a0..fcc61940f1ff 100644
--- a/arch/mips/sibyte/sb1250/irq.c
+++ b/arch/mips/sibyte/sb1250/irq.c
@@ -246,10 +246,10 @@ void __init init_sb1250_irqs(void)
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
                if (i < SB1250_NR_IRQS) {
-                        irq_desc[i].handler = &sb1250_irq_type;
+                        irq_desc[i].chip = &sb1250_irq_type;
                        sb1250_irq_owner[i] = 0;
                } else {
-                        irq_desc[i].handler = &no_irq_type;
+                        irq_desc[i].chip = &no_irq_type;
                }
        }
 }
diff --git a/arch/mips/sni/irq.c b/arch/mips/sni/irq.c
index 7365b4853ddb..c19e158ec402 100644
--- a/arch/mips/sni/irq.c
+++ b/arch/mips/sni/irq.c
@@ -203,7 +203,7 @@ void __init arch_init_irq(void)
                irq_desc[i].status     = IRQ_DISABLED;
                irq_desc[i].action     = 0;
                irq_desc[i].depth      = 1;
-                irq_desc[i].handler    = &pciasic_irq_type;
+                irq_desc[i].chip    = &pciasic_irq_type;
        }
        change_c0_status(ST0_IM, IE_IRQ1|IE_IRQ2|IE_IRQ3|IE_IRQ4);
diff --git a/arch/mips/tx4927/common/tx4927_irq.c b/arch/mips/tx4927/common/tx4927_irq.c
index 8ca68015cf40..a42be00483e6 100644
--- a/arch/mips/tx4927/common/tx4927_irq.c
+++ b/arch/mips/tx4927/common/tx4927_irq.c
@@ -227,7 +227,7 @@ static void __init tx4927_irq_cp0_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &tx4927_irq_cp0_type;
+                irq_desc[i].chip = &tx4927_irq_cp0_type;
        }
        return;
@@ -435,7 +435,7 @@ static void __init tx4927_irq_pic_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 2;
-                irq_desc[i].handler = &tx4927_irq_pic_type;
+                irq_desc[i].chip = &tx4927_irq_pic_type;
        }
        setup_irq(TX4927_IRQ_NEST_PIC_ON_CP0, &tx4927_irq_pic_action);
diff --git a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_irq.c b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_irq.c
index aee07ff2212a..c67978b6dae4 100644
--- a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_irq.c
+++ b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_irq.c
@@ -368,7 +368,7 @@ static void __init toshiba_rbtx4927_irq_ioc_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 3;
-                irq_desc[i].handler = &toshiba_rbtx4927_irq_ioc_type;
+                irq_desc[i].chip = &toshiba_rbtx4927_irq_ioc_type;
        }
        setup_irq(TOSHIBA_RBTX4927_IRQ_NEST_IOC_ON_PIC,
@@ -526,7 +526,7 @@ static void __init toshiba_rbtx4927_irq_isa_init(void)
                irq_desc[i].action = 0;
                irq_desc[i].depth =
                    ((i < TOSHIBA_RBTX4927_IRQ_ISA_MID) ? (4) : (5));
-                irq_desc[i].handler = &toshiba_rbtx4927_irq_isa_type;
+                irq_desc[i].chip = &toshiba_rbtx4927_irq_isa_type;
        }
        setup_irq(TOSHIBA_RBTX4927_IRQ_NEST_ISA_ON_IOC,
@@ -692,13 +692,13 @@ void toshiba_rbtx4927_irq_dump(char *key)
        {
                u32 i, j = 0;
                for (i = 0; i < NR_IRQS; i++) {
-                        if (strcmp(irq_desc[i].handler->typename, "none")
+                        if (strcmp(irq_desc[i].chip->typename, "none")
                            == 0)
                                continue;
                        if ((i >= 1)
-                            && (irq_desc[i - 1].handler->typename ==
+                            && (irq_desc[i - 1].chip->typename ==
-                                irq_desc[i].handler->typename)) {
+                                irq_desc[i].chip->typename)) {
                                j++;
                        } else {
                                j = 0;
@@ -707,12 +707,12 @@ void toshiba_rbtx4927_irq_dump(char *key)
                            (TOSHIBA_RBTX4927_IRQ_INFO,
                             "%s irq=0x%02x/%3d s=0x%08x h=0x%08x a=0x%08x ah=0x%08x d=%1d n=%s/%02d\n",
                             key, i, i, irq_desc[i].status,
-                             (u32) irq_desc[i].handler,
+                             (u32) irq_desc[i].chip,
                             (u32) irq_desc[i].action,
                             (u32) (irq_desc[i].action ? irq_desc[i].
                                    action->handler : 0),
                             irq_desc[i].depth,
-                             irq_desc[i].handler->typename, j);
+                             irq_desc[i].chip->typename, j);
                }
        }
 #endif
diff --git a/arch/mips/tx4938/common/irq.c b/arch/mips/tx4938/common/irq.c
index 873805178d8e..0b2f8c849218 100644
--- a/arch/mips/tx4938/common/irq.c
+++ b/arch/mips/tx4938/common/irq.c
@@ -102,7 +102,7 @@ tx4938_irq_cp0_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &tx4938_irq_cp0_type;
+                irq_desc[i].chip = &tx4938_irq_cp0_type;
        }
        return;
@@ -306,7 +306,7 @@ tx4938_irq_pic_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 2;
-                irq_desc[i].handler = &tx4938_irq_pic_type;
+                irq_desc[i].chip = &tx4938_irq_pic_type;
        }
        setup_irq(TX4938_IRQ_NEST_PIC_ON_CP0, &tx4938_irq_pic_action);
diff --git a/arch/mips/tx4938/toshiba_rbtx4938/irq.c b/arch/mips/tx4938/toshiba_rbtx4938/irq.c
index 9cd9c0fe2265..3b8245dc5bd3 100644
--- a/arch/mips/tx4938/toshiba_rbtx4938/irq.c
+++ b/arch/mips/tx4938/toshiba_rbtx4938/irq.c
@@ -146,7 +146,7 @@ toshiba_rbtx4938_irq_ioc_init(void)
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = 0;
                irq_desc[i].depth = 3;
-                irq_desc[i].handler = &toshiba_rbtx4938_irq_ioc_type;
+                irq_desc[i].chip = &toshiba_rbtx4938_irq_ioc_type;
        }
        setup_irq(RBTX4938_IRQ_IOCINT,
diff --git a/arch/mips/vr41xx/common/icu.c b/arch/mips/vr41xx/common/icu.c
index 07ae19cf0c29..b9323302cc4e 100644
--- a/arch/mips/vr41xx/common/icu.c
+++ b/arch/mips/vr41xx/common/icu.c
@@ -722,10 +722,10 @@ static int __init vr41xx_icu_init(void)
        icu2_write(MGIUINTHREG, 0xffff);
        for (i = SYSINT1_IRQ_BASE; i <= SYSINT1_IRQ_LAST; i++)
-                irq_desc[i].handler = &sysint1_irq_type;
+                irq_desc[i].chip = &sysint1_irq_type;
        for (i = SYSINT2_IRQ_BASE; i <= SYSINT2_IRQ_LAST; i++)
-                irq_desc[i].handler = &sysint2_irq_type;
+                irq_desc[i].chip = &sysint2_irq_type;
        cascade_irq(INT0_IRQ, icu_get_irq);
        cascade_irq(INT1_IRQ, icu_get_irq);
diff --git a/arch/mips/vr41xx/common/irq.c b/arch/mips/vr41xx/common/irq.c
index 86796bb63c3c..66aa50802deb 100644
--- a/arch/mips/vr41xx/common/irq.c
+++ b/arch/mips/vr41xx/common/irq.c
@@ -73,13 +73,13 @@ static void irq_dispatch(unsigned int irq, struct pt_regs *regs)
        if (cascade->get_irq != NULL) {
                unsigned int source_irq = irq;
                desc = irq_desc + source_irq;
-                desc->handler->ack(source_irq);
+                desc->chip->ack(source_irq);
                irq = cascade->get_irq(irq, regs);
                if (irq < 0)
                        atomic_inc(&irq_err_count);
                else
                        irq_dispatch(irq, regs);
-                desc->handler->end(source_irq);
+                desc->chip->end(source_irq);
        } else
                do_IRQ(irq, regs);
 }
diff --git a/arch/mips/vr41xx/common/vrc4173.c b/arch/mips/vr41xx/common/vrc4173.c
index 3e31f8193d21..2d287b8893d9 100644
--- a/arch/mips/vr41xx/common/vrc4173.c
+++ b/arch/mips/vr41xx/common/vrc4173.c
@@ -483,7 +483,7 @@ static inline int vrc4173_icu_init(int cascade_irq)
        vr41xx_set_irq_level(GIU_IRQ_TO_PIN(cascade_irq), LEVEL_LOW);
        for (i = VRC4173_IRQ_BASE; i <= VRC4173_IRQ_LAST; i++)
-                irq_desc[i].handler = &vrc4173_irq_type;
+                irq_desc[i].chip = &vrc4173_irq_type;
        return 0;
 }
diff --git a/arch/mips/vr41xx/nec-cmbvr4133/irq.c b/arch/mips/vr41xx/nec-cmbvr4133/irq.c
index 31db6b61a39e..7b2511ca0a61 100644
--- a/arch/mips/vr41xx/nec-cmbvr4133/irq.c
+++ b/arch/mips/vr41xx/nec-cmbvr4133/irq.c
@@ -104,7 +104,7 @@ void __init rockhopper_init_irq(void)
        }
        for (i = I8259_IRQ_BASE; i <= I8259_IRQ_LAST; i++)
-                irq_desc[i].handler = &i8259_irq_type;
+                irq_desc[i].chip = &i8259_irq_type;
        setup_irq(I8259_SLAVE_IRQ, &i8259_slave_cascade);
diff --git a/arch/parisc/Kconfig b/arch/parisc/Kconfig
index 910fb3afc0b5..6dd0ea8f88e0 100644
--- a/arch/parisc/Kconfig
+++ b/arch/parisc/Kconfig
@@ -51,6 +51,10 @@ config GENERIC_HARDIRQS
 config GENERIC_IRQ_PROBE
        def_bool y
+config IRQ_PER_CPU
+        bool
+        default y
 # unless you want to implement ACPI on PA-RISC ... ;-)
 config PM
        bool
diff --git a/arch/parisc/kernel/irq.c b/arch/parisc/kernel/irq.c
index 197936d9359a..82fe6ba29727 100644
--- a/arch/parisc/kernel/irq.c
+++ b/arch/parisc/kernel/irq.c
@@ -94,7 +94,7 @@ int cpu_check_affinity(unsigned int irq, cpumask_t *dest)
        if (irq == TIMER_IRQ || irq == IPI_IRQ) {
                /* Bad linux design decision.  The mask has already
                 * been set; we must reset it */
-                irq_affinity[irq] = CPU_MASK_ALL;
+                irq_desc[irq].affinity = CPU_MASK_ALL;
                return -EINVAL;
        }
@@ -110,7 +110,7 @@ static void cpu_set_affinity_irq(unsigned int irq, cpumask_t dest)
        if (cpu_check_affinity(irq, &dest))
                return;
-        irq_affinity[irq] = dest;
+        irq_desc[irq].affinity = dest;
 }
 #endif
@@ -125,6 +125,10 @@ static struct hw_interrupt_type cpu_interrupt_type = {
 #ifdef CONFIG_SMP
        .set_affinity   = cpu_set_affinity_irq,
 #endif
+        /* XXX: Needs to be written.  We managed without it so far, but
+         * we really ought to write it.
+         */
+        .retrigger      = NULL,
 };
 int show_interrupts(struct seq_file *p, void *v)
@@ -158,7 +162,7 @@ int show_interrupts(struct seq_file *p, void *v)
                seq_printf(p, "%10u ", kstat_irqs(i));
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
 #ifndef PARISC_IRQ_CR16_COUNTS
                seq_printf(p, "  %s", action->name);
@@ -210,12 +214,12 @@ int cpu_claim_irq(unsigned int irq, struct hw_interrupt_type *type, void *data)
 {
        if (irq_desc[irq].action)
                return -EBUSY;
-        if (irq_desc[irq].handler != &cpu_interrupt_type)
+        if (irq_desc[irq].chip != &cpu_interrupt_type)
                return -EBUSY;
        if (type) {
-                irq_desc[irq].handler = type;
+                irq_desc[irq].chip = type;
-                irq_desc[irq].handler_data = data;
+                irq_desc[irq].chip_data = data;
                cpu_interrupt_type.enable(irq);
        }
        return 0;
@@ -265,7 +269,7 @@ int txn_alloc_irq(unsigned int bits_wide)
 unsigned long txn_affinity_addr(unsigned int irq, int cpu)
 {
 #ifdef CONFIG_SMP
-        irq_affinity[irq] = cpumask_of_cpu(cpu);
+        irq_desc[irq].affinity = cpumask_of_cpu(cpu);
 #endif
        return cpu_data[cpu].txn_addr;
@@ -326,7 +330,7 @@ void do_cpu_irq_mask(struct pt_regs *regs)
                /* Work our way from MSb to LSb...same order we alloc EIRs */
                for (irq = TIMER_IRQ; eirr_val && bit; bit>>=1, irq++) {
 #ifdef CONFIG_SMP
-                        cpumask_t dest = irq_affinity[irq];
+                        cpumask_t dest = irq_desc[irq].affinity;
 #endif
                        if (!(bit & eirr_val))
                                continue;
@@ -378,7 +382,7 @@ static void claim_cpu_irqs(void)
 {
        int i;
        for (i = CPU_IRQ_BASE; i <= CPU_IRQ_MAX; i++) {
-                irq_desc[i].handler = &cpu_interrupt_type;
+                irq_desc[i].chip = &cpu_interrupt_type;
        }
        irq_desc[TIMER_IRQ].action = &timer_action;
@@ -404,13 +408,6 @@ void __init init_IRQ(void)
 }
-void hw_resend_irq(struct hw_interrupt_type *type, unsigned int irq)
-{
-        /* XXX: Needs to be written.  We managed without it so far, but
-         * we really ought to write it.
-         */
-}
 void ack_bad_irq(unsigned int irq)
 {
        printk("unexpected IRQ %d\n", irq);
diff --git a/arch/parisc/kernel/pci.c b/arch/parisc/kernel/pci.c
index 79c7db2705fd..7d6967ee367c 100644
--- a/arch/parisc/kernel/pci.c
+++ b/arch/parisc/kernel/pci.c
@@ -289,7 +289,7 @@ EXPORT_SYMBOL(pcibios_bus_to_resource);
 * than res->start.
 */
 void pcibios_align_resource(void *data, struct resource *res,
-                                unsigned long size, unsigned long alignment)
+                                resource_size_t size, resource_size_t alignment)
 {
        unsigned long mask, align;
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index e922a88b2bad..d43e4521abf2 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -30,6 +30,10 @@ config GENERIC_HARDIRQS
        bool
        default y
+config IRQ_PER_CPU
+        bool
+        default y
 config RWSEM_GENERIC_SPINLOCK
        bool
@@ -618,6 +622,9 @@ config HOTPLUG_CPU
          Say N if you are unsure.
+config ARCH_ENABLE_MEMORY_HOTPLUG
+        def_bool y
 config KEXEC
        bool "kexec system call (EXPERIMENTAL)"
        depends on PPC_MULTIPLATFORM && EXPERIMENTAL
diff --git a/arch/powerpc/kernel/crash.c b/arch/powerpc/kernel/crash.c
index e253a45dcf10..22ceba844bf4 100644
--- a/arch/powerpc/kernel/crash.c
+++ b/arch/powerpc/kernel/crash.c
@@ -190,13 +190,13 @@ void default_machine_crash_shutdown(struct pt_regs *regs)
        local_irq_disable();
        for_each_irq(irq) {
-                struct irq_desc *desc = irq_descp(irq);
+                struct irq_desc *desc = irq_desc + irq;
                if (desc->status & IRQ_INPROGRESS)
-                        desc->handler->end(irq);
+                        desc->chip->end(irq);
                if (!(desc->status & IRQ_DISABLED))
-                        desc->handler->disable(irq);
+                        desc->chip->disable(irq);
        }
        if (ppc_md.kexec_cpu_down)
diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 40d4c14fde8f..24f6050aa4ab 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -120,8 +120,8 @@ int show_interrupts(struct seq_file *p, void *v)
 #else
                seq_printf(p, "%10u ", kstat_irqs(i));
 #endif /* CONFIG_SMP */
-                if (desc->handler)
+                if (desc->chip)
-                        seq_printf(p, " %s ", desc->handler->typename);
+                        seq_printf(p, " %s ", desc->chip->typename);
                else
                        seq_puts(p, "  None      ");
                seq_printf(p, "%s", (desc->status & IRQ_LEVEL) ? "Level " : "Edge  ");
@@ -164,13 +164,13 @@ void fixup_irqs(cpumask_t map)
                if (irq_desc[irq].status & IRQ_PER_CPU)
                        continue;
-                cpus_and(mask, irq_affinity[irq], map);
+                cpus_and(mask, irq_desc[irq].affinity, map);
                if (any_online_cpu(mask) == NR_CPUS) {
                        printk("Breaking affinity for irq %i\n", irq);
                        mask = map;
                }
-                if (irq_desc[irq].handler->set_affinity)
+                if (irq_desc[irq].chip->set_affinity)
-                        irq_desc[irq].handler->set_affinity(irq, mask);
+                        irq_desc[irq].chip->set_affinity(irq, mask);
                else if (irq_desc[irq].action && !(warned++))
                        printk("Cannot set affinity for irq %i\n", irq);
        }
diff --git a/arch/powerpc/kernel/pci_32.c b/arch/powerpc/kernel/pci_32.c
index b5431ccf1147..8474355a1a4f 100644
--- a/arch/powerpc/kernel/pci_32.c
+++ b/arch/powerpc/kernel/pci_32.c
@@ -99,7 +99,7 @@ pcibios_fixup_resources(struct pci_dev *dev)
                if (!res->flags)
                        continue;
                if (res->end == 0xffffffff) {
-                        DBG("PCI:%s Resource %d [%08lx-%08lx] is unassigned\n",
+                        DBG("PCI:%s Resource %d [%016llx-%016llx] is unassigned\n",
                            pci_name(dev), i, res->start, res->end);
                        res->end -= res->start;
                        res->start = 0;
@@ -117,7 +117,7 @@ pcibios_fixup_resources(struct pci_dev *dev)
                        res->start += offset;
                        res->end += offset;
 #ifdef DEBUG
-                        printk("Fixup res %d (%lx) of dev %s: %lx -> %lx\n",
+                        printk("Fixup res %d (%lx) of dev %s: %llx -> %llx\n",
                               i, res->flags, pci_name(dev),
                               res->start - offset, res->start);
 #endif
@@ -173,18 +173,18 @@ EXPORT_SYMBOL(pcibios_bus_to_resource);
 * but we want to try to avoid allocating at 0x2900-0x2bff
 * which might have be mirrored at 0x0100-0x03ff..
 */
-void pcibios_align_resource(void *data, struct resource *res, unsigned long size,
+void pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long align)
+                                resource_size_t size, resource_size_t align)
 {
        struct pci_dev *dev = data;
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (size > 0x100) {
                        printk(KERN_ERR "PCI: I/O Region %s/%d too large"
-                               " (%ld bytes)\n", pci_name(dev),
+                               " (%lld bytes)\n", pci_name(dev),
-                               dev->resource - res, size);
+                               dev->resource - res, (unsigned long long)size);
                }
                if (start & 0x300) {
@@ -255,8 +255,8 @@ pcibios_allocate_bus_resources(struct list_head *bus_list)
                                }
                        }
-                        DBG("PCI: bridge rsrc %lx..%lx (%lx), parent %p\n",
+                        DBG("PCI: bridge rsrc %llx..%llx (%lx), parent %p\n",
-                            res->start, res->end, res->flags, pr);
+                                res->start, res->end, res->flags, pr);
                        if (pr) {
                                if (request_resource(pr, res) == 0)
                                        continue;
@@ -306,7 +306,7 @@ reparent_resources(struct resource *parent, struct resource *res)
        *pp = NULL;
        for (p = res->child; p != NULL; p = p->sibling) {
                p->parent = res;
-                DBG(KERN_INFO "PCI: reparented %s [%lx..%lx] under %s\n",
+                DBG(KERN_INFO "PCI: reparented %s [%llx..%llx] under %s\n",
                    p->name, p->start, p->end, res->name);
        }
        return 0;
@@ -362,13 +362,14 @@ pci_relocate_bridge_resource(struct pci_bus *bus, int i)
                try = conflict->start - 1;
        }
        if (request_resource(pr, res)) {
-                DBG(KERN_ERR "PCI: huh? couldn't move to %lx..%lx\n",
+                DBG(KERN_ERR "PCI: huh? couldn't move to %llx..%llx\n",
                    res->start, res->end);
                return -1;              /* "can't happen" */
        }
        update_bridge_base(bus, i);
-        printk(KERN_INFO "PCI: bridge %d resource %d moved to %lx..%lx\n",
+        printk(KERN_INFO "PCI: bridge %d resource %d moved to %llx..%llx\n",
-               bus->number, i, res->start, res->end);
+               bus->number, i, (unsigned long long)res->start,
+               (unsigned long long)res->end);
        return 0;
 }
@@ -479,14 +480,14 @@ static inline void alloc_resource(struct pci_dev *dev, int idx)
 {
        struct resource *pr, *r = &dev->resource[idx];
-        DBG("PCI:%s: Resource %d: %08lx-%08lx (f=%lx)\n",
+        DBG("PCI:%s: Resource %d: %016llx-%016llx (f=%lx)\n",
            pci_name(dev), idx, r->start, r->end, r->flags);
        pr = pci_find_parent_resource(dev, r);
        if (!pr || request_resource(pr, r) < 0) {
                printk(KERN_ERR "PCI: Cannot allocate resource region %d"
                       " of device %s\n", idx, pci_name(dev));
                if (pr)
-                        DBG("PCI:  parent is %p: %08lx-%08lx (f=%lx)\n",
+                        DBG("PCI:  parent is %p: %016llx-%016llx (f=%lx)\n",
                            pr, pr->start, pr->end, pr->flags);
                /* We'll assign a new address later */
                r->flags |= IORESOURCE_UNSET;
@@ -956,7 +957,7 @@ pci_process_bridge_OF_ranges(struct pci_controller *hose,
                        res = &hose->io_resource;
                        res->flags = IORESOURCE_IO;
                        res->start = ranges[2];
-                        DBG("PCI: IO 0x%lx -> 0x%lx\n",
+                        DBG("PCI: IO 0x%llx -> 0x%llx\n",
                                    res->start, res->start + size - 1);
                        break;
                case 2:         /* memory space */
@@ -978,7 +979,7 @@ pci_process_bridge_OF_ranges(struct pci_controller *hose,
                                if(ranges[0] & 0x40000000)
                                        res->flags |= IORESOURCE_PREFETCH;
                                res->start = ranges[na+2];
-                                DBG("PCI: MEM[%d] 0x%lx -> 0x%lx\n", memno,
+                                DBG("PCI: MEM[%d] 0x%llx -> 0x%llx\n", memno,
                                            res->start, res->start + size - 1);
                        }
                        break;
@@ -1074,7 +1075,7 @@ do_update_p2p_io_resource(struct pci_bus *bus, int enable_vga)
        DBG("Remapping Bus %d, bridge: %s\n", bus->number, pci_name(bridge));
        res.start -= ((unsigned long) hose->io_base_virt - isa_io_base);
        res.end -= ((unsigned long) hose->io_base_virt - isa_io_base);
-        DBG("  IO window: %08lx-%08lx\n", res.start, res.end);
+        DBG("  IO window: %016llx-%016llx\n", res.start, res.end);
        /* Set up the top and bottom of the PCI I/O segment for this bus. */
        pci_read_config_dword(bridge, PCI_IO_BASE, &l);
@@ -1223,8 +1224,8 @@ do_fixup_p2p_level(struct pci_bus *bus)
                                        continue;
                                if ((r->flags & IORESOURCE_IO) == 0)
                                        continue;
-                                DBG("Trying to allocate from %08lx, size %08lx from parent"
+                                DBG("Trying to allocate from %016llx, size %016llx from parent"
-                                    " res %d: %08lx -> %08lx\n",
+                                    " res %d: %016llx -> %016llx\n",
                                        res->start, res->end, i, r->start, r->end);
                        
                                if (allocate_resource(r, res, res->end + 1, res->start, max,
@@ -1574,8 +1575,8 @@ static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
        else
                prot |= _PAGE_GUARDED;
-        printk("PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
+        printk("PCI map for %s:%llx, prot: %lx\n", pci_name(dev),
-               prot);
+                (unsigned long long)rp->start, prot);
        return __pgprot(prot);
 }
@@ -1755,7 +1756,7 @@ long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn)
 void pci_resource_to_user(const struct pci_dev *dev, int bar,
                          const struct resource *rsrc,
-                          u64 *start, u64 *end)
+                          resource_size_t *start, resource_size_t *end)
 {
        struct pci_controller *hose = pci_bus_to_hose(dev->bus->number);
        unsigned long offset = 0;
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 247937dd8b73..286aa52aae33 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -138,11 +138,11 @@ EXPORT_SYMBOL(pcibios_bus_to_resource);
 * which might have be mirrored at 0x0100-0x03ff..
 */
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
        struct pci_dev *dev = data;
        struct pci_controller *hose = pci_bus_to_host(dev->bus);
-        unsigned long start = res->start;
+        resource_size_t start = res->start;
        unsigned long alignto;
        if (res->flags & IORESOURCE_IO) {
diff --git a/arch/powerpc/platforms/83xx/pci.c b/arch/powerpc/platforms/83xx/pci.c
index 16f7d3b30e1d..3baceb00fefa 100644
--- a/arch/powerpc/platforms/83xx/pci.c
+++ b/arch/powerpc/platforms/83xx/pci.c
@@ -91,9 +91,10 @@ int __init add_bridge(struct device_node *dev)
                mpc83xx_pci2_busno = hose->first_busno;
        }
-        printk(KERN_INFO "Found MPC83xx PCI host bridge at 0x%08lx. "
+        printk(KERN_INFO "Found MPC83xx PCI host bridge at 0x%016llx. "
               "Firmware bus number: %d->%d\n",
-               rsrc.start, hose->first_busno, hose->last_busno);
+               (unsigned long long)rsrc.start, hose->first_busno,
+               hose->last_busno);
        DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
            hose, hose->cfg_addr, hose->cfg_data);
diff --git a/arch/powerpc/platforms/85xx/pci.c b/arch/powerpc/platforms/85xx/pci.c
index bad290110ed1..48c8849c07ca 100644
--- a/arch/powerpc/platforms/85xx/pci.c
+++ b/arch/powerpc/platforms/85xx/pci.c
@@ -79,9 +79,10 @@ int __init add_bridge(struct device_node *dev)
                mpc85xx_pci2_busno = hose->first_busno;
        }
-        printk(KERN_INFO "Found MPC85xx PCI host bridge at 0x%08lx. "
+        printk(KERN_INFO "Found MPC85xx PCI host bridge at 0x%016llx. "
               "Firmware bus number: %d->%d\n",
-                rsrc.start, hose->first_busno, hose->last_busno);
+                (unsigned long long)rsrc.start, hose->first_busno,
+                hose->last_busno);
        DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
                hose, hose->cfg_addr, hose->cfg_data);
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index 1bbf822b4efc..7bff3cbc5723 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -307,7 +307,7 @@ static void iic_request_ipi(int ipi, const char *name)
        irq = iic_ipi_to_irq(ipi);
        /* IPIs are marked SA_INTERRUPT as they must run with irqs
         * disabled */
-        get_irq_desc(irq)->handler = &iic_pic;
+        get_irq_desc(irq)->chip = &iic_pic;
        get_irq_desc(irq)->status |= IRQ_PER_CPU;
        request_irq(irq, iic_ipi_action, SA_INTERRUPT, name, NULL);
 }
@@ -330,7 +330,7 @@ static void iic_setup_spe_handlers(void)
        for (be=0; be < num_present_cpus() / 2; be++) {
                for (isrc = 0; isrc < IIC_CLASS_STRIDE * 3; isrc++) {
                        int irq = IIC_NODE_STRIDE * be + IIC_SPE_OFFSET + isrc;
-                        get_irq_desc(irq)->handler = &iic_pic;
+                        get_irq_desc(irq)->chip = &iic_pic;
                }
        }
 }
diff --git a/arch/powerpc/platforms/cell/spider-pic.c b/arch/powerpc/platforms/cell/spider-pic.c
index 55cbdd77a62d..7c3a0b6d34fd 100644
--- a/arch/powerpc/platforms/cell/spider-pic.c
+++ b/arch/powerpc/platforms/cell/spider-pic.c
@@ -162,7 +162,7 @@ void spider_init_IRQ_hardcoded(void)
                spider_pics[node] = ioremap(spiderpic, 0x800);
                for (n = 0; n < IIC_NUM_EXT; n++) {
                        int irq = n + IIC_EXT_OFFSET + node * IIC_NODE_STRIDE;
-                        get_irq_desc(irq)->handler = &spider_pic;
+                        get_irq_desc(irq)->chip = &spider_pic;
                }
                /* do not mask any interrupts because of level */
@@ -217,7 +217,7 @@ void spider_init_IRQ(void)
                for (n = 0; n < IIC_NUM_EXT; n++) {
                        int irq = n + IIC_EXT_OFFSET + node * IIC_NODE_STRIDE;
-                        get_irq_desc(irq)->handler = &spider_pic;
+                        get_irq_desc(irq)->chip = &spider_pic;
                }
                /* do not mask any interrupts because of level */
diff --git a/arch/powerpc/platforms/chrp/pci.c b/arch/powerpc/platforms/chrp/pci.c
index ac224876ce59..53515daf01b1 100644
--- a/arch/powerpc/platforms/chrp/pci.c
+++ b/arch/powerpc/platforms/chrp/pci.c
@@ -143,7 +143,7 @@ hydra_init(void)
        if (np == NULL || of_address_to_resource(np, 0, &r))
                return 0;
        Hydra = ioremap(r.start, r.end-r.start);
-        printk("Hydra Mac I/O at %lx\n", r.start);
+        printk("Hydra Mac I/O at %llx\n", (unsigned long long)r.start);
        printk("Hydra Feature_Control was %x",
               in_le32(&Hydra->Feature_Control));
        out_le32(&Hydra->Feature_Control, (HYDRA_FC_SCC_CELL_EN |
@@ -267,7 +267,7 @@ chrp_find_bridges(void)
                               bus_range[0], bus_range[1]);
                printk(" controlled by %s", dev->type);
                if (!is_longtrail)
-                        printk(" at %lx", r.start);
+                        printk(" at %llx", (unsigned long long)r.start);
                printk("\n");
                hose = pcibios_alloc_controller();
diff --git a/arch/powerpc/platforms/iseries/irq.c b/arch/powerpc/platforms/iseries/irq.c
index 62bbbcf5ded3..33bb4aa0e1e8 100644
--- a/arch/powerpc/platforms/iseries/irq.c
+++ b/arch/powerpc/platforms/iseries/irq.c
@@ -242,9 +242,9 @@ void __init iSeries_activate_IRQs()
        for_each_irq (irq) {
                irq_desc_t *desc = get_irq_desc(irq);
-                if (desc && desc->handler && desc->handler->startup) {
+                if (desc && desc->chip && desc->chip->startup) {
                        spin_lock_irqsave(&desc->lock, flags);
-                        desc->handler->startup(irq);
+                        desc->chip->startup(irq);
                        spin_unlock_irqrestore(&desc->lock, flags);
                }
        }
@@ -324,7 +324,7 @@ int __init iSeries_allocate_IRQ(HvBusNumber bus,
                + function;
        virtirq = virt_irq_create_mapping(realirq);
-        irq_desc[virtirq].handler = &iSeries_IRQ_handler;
+        irq_desc[virtirq].chip = &iSeries_IRQ_handler;
        return virtirq;
 }
diff --git a/arch/powerpc/platforms/maple/pci.c b/arch/powerpc/platforms/maple/pci.c
index 9a4efc0c3b29..f7170ff86dab 100644
--- a/arch/powerpc/platforms/maple/pci.c
+++ b/arch/powerpc/platforms/maple/pci.c
@@ -376,9 +376,10 @@ static void __init maple_fixup_phb_resources(void)
                unsigned long offset = (unsigned long)hose->io_base_virt - pci_io_base;
                hose->io_resource.start += offset;
                hose->io_resource.end += offset;
-                printk(KERN_INFO "PCI Host %d, io start: %lx; io end: %lx\n",
+                printk(KERN_INFO "PCI Host %d, io start: %llx; io end: %llx\n",
                       hose->global_number,
-                       hose->io_resource.start, hose->io_resource.end);
+                       (unsigned long long)hose->io_resource.start,
+                       (unsigned long long)hose->io_resource.end);
        }
 }
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index 80035853467b..d524a915aa86 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -939,9 +939,10 @@ static int __init add_bridge(struct device_node *dev)
                disp_name = "Chaos";
                primary = 0;
        }
-        printk(KERN_INFO "Found %s PCI host bridge at 0x%08lx. "
+        printk(KERN_INFO "Found %s PCI host bridge at 0x%016llx. "
               "Firmware bus number: %d->%d\n",
-                disp_name, rsrc.start, hose->first_busno, hose->last_busno);
+                disp_name, (unsigned long long)rsrc.start, hose->first_busno,
+                hose->last_busno);
 #endif /* CONFIG_PPC32 */
        DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
diff --git a/arch/powerpc/platforms/powermac/pic.c b/arch/powerpc/platforms/powermac/pic.c
index 18bf3011d1e3..9f6189af6dd6 100644
--- a/arch/powerpc/platforms/powermac/pic.c
+++ b/arch/powerpc/platforms/powermac/pic.c
@@ -446,7 +446,7 @@ static void __init pmac_pic_probe_oldstyle(void)
        /* Set the handler for the main PIC */
        for ( i = 0; i < max_real_irqs ; i++ )
-                irq_desc[i].handler = &pmac_pic;
+                irq_desc[i].chip = &pmac_pic;
        /* Get addresses of first controller if we have a node for it */
        BUG_ON(of_address_to_resource(master, 0, &r));
@@ -493,7 +493,7 @@ static void __init pmac_pic_probe_oldstyle(void)
        /* Setup handlers for secondary controller and hook cascade irq*/
        if (slave) {
                for ( i = max_real_irqs ; i < max_irqs ; i++ )
-                        irq_desc[i].handler = &gatwick_pic;
+                        irq_desc[i].chip = &gatwick_pic;
                setup_irq(irq_cascade, &gatwick_cascade_action);
        }
        printk(KERN_INFO "irq: System has %d possible interrupts\n", max_irqs);
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index b14f9b5c114e..19c03dd43000 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -238,7 +238,7 @@ static int get_irq_server(unsigned int irq)
 {
        unsigned int server;
        /* For the moment only implement delivery to all cpus or one cpu */
-        cpumask_t cpumask = irq_affinity[irq];
+        cpumask_t cpumask = irq_desc[irq].affinity;
        cpumask_t tmp = CPU_MASK_NONE;
        if (!distribute_irqs)
@@ -558,7 +558,7 @@ nextnode:
        }
        for (i = irq_offset_value(); i < NR_IRQS; ++i)
-                get_irq_desc(i)->handler = &xics_pic;
+                get_irq_desc(i)->chip = &xics_pic;
        xics_setup_cpu();
@@ -701,9 +701,9 @@ void xics_migrate_irqs_away(void)
                        continue;
                /* We only need to migrate enabled IRQS */
-                if (desc == NULL || desc->handler == NULL
+                if (desc == NULL || desc->chip == NULL
                    || desc->action == NULL
-                    || desc->handler->set_affinity == NULL)
+                    || desc->chip->set_affinity == NULL)
                        continue;
                spin_lock_irqsave(&desc->lock, flags);
@@ -728,8 +728,8 @@ void xics_migrate_irqs_away(void)
                       virq, cpu);
                /* Reset affinity to all cpus */
-                desc->handler->set_affinity(virq, CPU_MASK_ALL);
+                desc->chip->set_affinity(virq, CPU_MASK_ALL);
-                irq_affinity[virq] = CPU_MASK_ALL;
+                irq_desc[irq].affinity = CPU_MASK_ALL;
 unlock:
                spin_unlock_irqrestore(&desc->lock, flags);
        }
diff --git a/arch/powerpc/sysdev/i8259.c b/arch/powerpc/sysdev/i8259.c
index b7ac32fdd776..2bff30f6d635 100644
--- a/arch/powerpc/sysdev/i8259.c
+++ b/arch/powerpc/sysdev/i8259.c
@@ -208,7 +208,7 @@ void __init i8259_init(unsigned long intack_addr, int offset)
        spin_unlock_irqrestore(&i8259_lock, flags);
        for (i = 0; i < NUM_ISA_INTERRUPTS; ++i)
-                irq_desc[offset + i].handler = &i8259_pic;
+                irq_desc[offset + i].chip = &i8259_pic;
        /* reserve our resources */
        setup_irq(offset + 2, &i8259_irqaction);
diff --git a/arch/powerpc/sysdev/ipic.c b/arch/powerpc/sysdev/ipic.c
index 8f01e0f1d847..46801f5ec03f 100644
--- a/arch/powerpc/sysdev/ipic.c
+++ b/arch/powerpc/sysdev/ipic.c
@@ -472,7 +472,7 @@ void __init ipic_init(phys_addr_t phys_addr,
        ipic_write(primary_ipic->regs, IPIC_SEMSR, temp);
        for (i = 0 ; i < NR_IPIC_INTS ; i++) {
-                irq_desc[i+irq_offset].handler = &ipic;
+                irq_desc[i+irq_offset].chip = &ipic;
                irq_desc[i+irq_offset].status = IRQ_LEVEL;
        }
diff --git a/arch/powerpc/sysdev/mpic.c b/arch/powerpc/sysdev/mpic.c
index bffe50d02c99..28df9c827ca6 100644
--- a/arch/powerpc/sysdev/mpic.c
+++ b/arch/powerpc/sysdev/mpic.c
@@ -379,14 +379,14 @@ static inline u32 mpic_physmask(u32 cpumask)
 /* Get the mpic structure from the IPI number */
 static inline struct mpic * mpic_from_ipi(unsigned int ipi)
 {
-        return container_of(irq_desc[ipi].handler, struct mpic, hc_ipi);
+        return container_of(irq_desc[ipi].chip, struct mpic, hc_ipi);
 }
 #endif
 /* Get the mpic structure from the irq number */
 static inline struct mpic * mpic_from_irq(unsigned int irq)
 {
-        return container_of(irq_desc[irq].handler, struct mpic, hc_irq);
+        return container_of(irq_desc[irq].chip, struct mpic, hc_irq);
 }
 /* Send an EOI */
@@ -752,7 +752,7 @@ void __init mpic_init(struct mpic *mpic)
                if (!(mpic->flags & MPIC_PRIMARY))
                        continue;
                irq_desc[mpic->ipi_offset+i].status |= IRQ_PER_CPU;
-                irq_desc[mpic->ipi_offset+i].handler = &mpic->hc_ipi;
+                irq_desc[mpic->ipi_offset+i].chip = &mpic->hc_ipi;
 #endif /* CONFIG_SMP */
        }
@@ -813,7 +813,7 @@ void __init mpic_init(struct mpic *mpic)
                /* init linux descriptors */
                if (i < mpic->irq_count) {
                        irq_desc[mpic->irq_offset+i].status = level ? IRQ_LEVEL : 0;
-                        irq_desc[mpic->irq_offset+i].handler = &mpic->hc_irq;
+                        irq_desc[mpic->irq_offset+i].chip = &mpic->hc_irq;
                }
        }
        
@@ -906,7 +906,7 @@ void mpic_setup_this_cpu(void)
        /* let the mpic know we want intrs. default affinity is 0xffffffff
         * until changed via /proc. That's how it's done on x86. If we want
         * it differently, then we should make sure we also change the default
-         * values of irq_affinity in irq.c.
+         * values of irq_desc[].affinity in irq.c.
         */
        if (distribute_irqs) {
                for (i = 0; i < mpic->num_sources ; i++)
diff --git a/arch/ppc/8xx_io/commproc.c b/arch/ppc/8xx_io/commproc.c
index 12b84ca51327..9b3ace26280c 100644
--- a/arch/ppc/8xx_io/commproc.c
+++ b/arch/ppc/8xx_io/commproc.c
@@ -187,7 +187,7 @@ cpm_interrupt_init(void)
         * interrupt vectors
         */
        for ( i = CPM_IRQ_OFFSET ; i < CPM_IRQ_OFFSET + NR_CPM_INTS ; i++ )
-                irq_desc[i].handler = &cpm_pic;
+                irq_desc[i].chip = &cpm_pic;
        /* Set our interrupt handler with the core CPU. */
        if (setup_irq(CPM_INTERRUPT, &cpm_interrupt_irqaction))
diff --git a/arch/ppc/kernel/pci.c b/arch/ppc/kernel/pci.c
index d20accf9650d..242bb052be67 100644
--- a/arch/ppc/kernel/pci.c
+++ b/arch/ppc/kernel/pci.c
@@ -95,8 +95,10 @@ pcibios_fixup_resources(struct pci_dev *dev)
                if (!res->flags)
                        continue;
                if (res->end == 0xffffffff) {
-                        DBG("PCI:%s Resource %d [%08lx-%08lx] is unassigned\n",
+                        DBG("PCI:%s Resource %d [%016llx-%016llx] is unassigned\n",
-                            pci_name(dev), i, res->start, res->end);
+                                pci_name(dev), i,
+                                (unsigned long long)res->start,
+                                (unsigned long long)res->end);
                        res->end -= res->start;
                        res->start = 0;
                        res->flags |= IORESOURCE_UNSET;
@@ -169,18 +171,18 @@ EXPORT_SYMBOL(pcibios_bus_to_resource);
 * but we want to try to avoid allocating at 0x2900-0x2bff
 * which might have be mirrored at 0x0100-0x03ff..
 */
-void pcibios_align_resource(void *data, struct resource *res, unsigned long size,
+void pcibios_align_resource(void *data, struct resource *res,
-                       unsigned long align)
+                                resource_size_t size, resource_size_t align)
 {
        struct pci_dev *dev = data;
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (size > 0x100) {
                        printk(KERN_ERR "PCI: I/O Region %s/%d too large"
-                               " (%ld bytes)\n", pci_name(dev),
+                               " (%lld bytes)\n", pci_name(dev),
-                               dev->resource - res, size);
+                               dev->resource - res, (unsigned long long)size);
                }
                if (start & 0x300) {
@@ -251,8 +253,9 @@ pcibios_allocate_bus_resources(struct list_head *bus_list)
                                }
                        }
-                        DBG("PCI: bridge rsrc %lx..%lx (%lx), parent %p\n",
+                        DBG("PCI: bridge rsrc %llx..%llx (%lx), parent %p\n",
-                            res->start, res->end, res->flags, pr);
+                                (unsigned long long)res->start,
+                                (unsigned long long)res->end, res->flags, pr);
                        if (pr) {
                                if (request_resource(pr, res) == 0)
                                        continue;
@@ -302,8 +305,9 @@ reparent_resources(struct resource *parent, struct resource *res)
        *pp = NULL;
        for (p = res->child; p != NULL; p = p->sibling) {
                p->parent = res;
-                DBG(KERN_INFO "PCI: reparented %s [%lx..%lx] under %s\n",
+                DBG(KERN_INFO "PCI: reparented %s [%llx..%llx] under %s\n",
-                    p->name, p->start, p->end, res->name);
+                        p->name, (unsigned long long)p->start,
+                        (unsigned long long)p->end, res->name);
        }
        return 0;
 }
@@ -358,13 +362,15 @@ pci_relocate_bridge_resource(struct pci_bus *bus, int i)
                try = conflict->start - 1;
        }
        if (request_resource(pr, res)) {
-                DBG(KERN_ERR "PCI: huh? couldn't move to %lx..%lx\n",
+                DBG(KERN_ERR "PCI: huh? couldn't move to %llx..%llx\n",
-                    res->start, res->end);
+                        (unsigned long long)res->start,
+                        (unsigned long long)res->end);
                return -1;              /* "can't happen" */
        }
        update_bridge_base(bus, i);
-        printk(KERN_INFO "PCI: bridge %d resource %d moved to %lx..%lx\n",
+        printk(KERN_INFO "PCI: bridge %d resource %d moved to %llx..%llx\n",
-               bus->number, i, res->start, res->end);
+                bus->number, i, (unsigned long long)res->start,
+                (unsigned long long)res->end);
        return 0;
 }
@@ -475,15 +481,17 @@ static inline void alloc_resource(struct pci_dev *dev, int idx)
 {
        struct resource *pr, *r = &dev->resource[idx];
-        DBG("PCI:%s: Resource %d: %08lx-%08lx (f=%lx)\n",
+        DBG("PCI:%s: Resource %d: %016llx-%016llx (f=%lx)\n",
-            pci_name(dev), idx, r->start, r->end, r->flags);
+            pci_name(dev), idx, (unsigned long long)r->start,
+            (unsigned long long)r->end, r->flags);
        pr = pci_find_parent_resource(dev, r);
        if (!pr || request_resource(pr, r) < 0) {
                printk(KERN_ERR "PCI: Cannot allocate resource region %d"
                       " of device %s\n", idx, pci_name(dev));
                if (pr)
-                        DBG("PCI:  parent is %p: %08lx-%08lx (f=%lx)\n",
+                        DBG("PCI:  parent is %p: %016llx-%016llx (f=%lx)\n",
-                            pr, pr->start, pr->end, pr->flags);
+                                pr, (unsigned long long)pr->start,
+                                (unsigned long long)pr->end, pr->flags);
                /* We'll assign a new address later */
                r->flags |= IORESOURCE_UNSET;
                r->end -= r->start;
@@ -952,8 +960,8 @@ static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
        else
                prot |= _PAGE_GUARDED;
-        printk("PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
+        printk("PCI map for %s:%llx, prot: %lx\n", pci_name(dev),
-               prot);
+                (unsigned long long)rp->start, prot);
        return __pgprot(prot);
 }
@@ -1122,7 +1130,7 @@ long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn)
 void pci_resource_to_user(const struct pci_dev *dev, int bar,
                          const struct resource *rsrc,
-                          u64 *start, u64 *end)
+                          resource_size_t *start, resource_size_t *end)
 {
        struct pci_controller *hose = pci_bus_to_hose(dev->bus->number);
        unsigned long offset = 0;
diff --git a/arch/ppc/platforms/apus_setup.c b/arch/ppc/platforms/apus_setup.c
index fe0cdc04d436..5c4118a459f3 100644
--- a/arch/ppc/platforms/apus_setup.c
+++ b/arch/ppc/platforms/apus_setup.c
@@ -734,9 +734,9 @@ void apus_init_IRQ(void)
        for ( i = 0 ; i < AMI_IRQS; i++ ) {
                irq_desc[i].status = IRQ_LEVEL;
                if (i < IRQ_AMIGA_AUTO) {
-                        irq_desc[i].handler = &amiga_irqctrl;
+                        irq_desc[i].chip = &amiga_irqctrl;
                } else {
-                        irq_desc[i].handler = &amiga_sys_irqctrl;
+                        irq_desc[i].chip = &amiga_sys_irqctrl;
                        action = &amiga_sys_irqaction[i-IRQ_AMIGA_AUTO];
                        if (action->name)
                                setup_irq(i, action);
diff --git a/arch/ppc/platforms/sbc82xx.c b/arch/ppc/platforms/sbc82xx.c
index 866807b4ad0b..41006d2b4b38 100644
--- a/arch/ppc/platforms/sbc82xx.c
+++ b/arch/ppc/platforms/sbc82xx.c
@@ -172,7 +172,7 @@ void __init sbc82xx_init_IRQ(void)
        
        /* Set up the interrupt handlers for the i8259 IRQs */
        for (i = NR_SIU_INTS; i < NR_SIU_INTS + 8; i++) {
-                irq_desc[i].handler = &sbc82xx_i8259_ic;
+                irq_desc[i].chip = &sbc82xx_i8259_ic;
                irq_desc[i].status |= IRQ_LEVEL;
        }
diff --git a/arch/ppc/syslib/cpc700_pic.c b/arch/ppc/syslib/cpc700_pic.c
index 5add0a919ef6..172aa215fdb0 100644
--- a/arch/ppc/syslib/cpc700_pic.c
+++ b/arch/ppc/syslib/cpc700_pic.c
@@ -140,12 +140,12 @@ cpc700_init_IRQ(void)
                                                        /* IRQ 0 is highest */
        for (i = 0; i < 17; i++) {
-                irq_desc[i].handler = &cpc700_pic;
+                irq_desc[i].chip = &cpc700_pic;
                cpc700_pic_init_irq(i);
        }
        for (i = 20; i < 32; i++) {
-                irq_desc[i].handler = &cpc700_pic;
+                irq_desc[i].chip = &cpc700_pic;
                cpc700_pic_init_irq(i);
        }
diff --git a/arch/ppc/syslib/cpm2_pic.c b/arch/ppc/syslib/cpm2_pic.c
index 29d95d415ceb..c0fee0beb815 100644
--- a/arch/ppc/syslib/cpm2_pic.c
+++ b/arch/ppc/syslib/cpm2_pic.c
@@ -171,7 +171,7 @@ void cpm2_init_IRQ(void)
        /* Enable chaining to OpenPIC, and make everything level
         */
        for (i = 0; i < NR_CPM_INTS; i++) {
-                irq_desc[i+CPM_IRQ_OFFSET].handler = &cpm2_pic;
+                irq_desc[i+CPM_IRQ_OFFSET].chip = &cpm2_pic;
                irq_desc[i+CPM_IRQ_OFFSET].status |= IRQ_LEVEL;
        }
 }
diff --git a/arch/ppc/syslib/gt64260_pic.c b/arch/ppc/syslib/gt64260_pic.c
index dc3bd9ecbbf6..91096b38ae70 100644
--- a/arch/ppc/syslib/gt64260_pic.c
+++ b/arch/ppc/syslib/gt64260_pic.c
@@ -98,7 +98,7 @@ gt64260_init_irq(void)
        /* use the gt64260 for all (possible) interrupt sources */
        for (i = gt64260_irq_base; i < (gt64260_irq_base + 96); i++)
-                irq_desc[i].handler = &gt64260_pic;
+                irq_desc[i].chip = &gt64260_pic;
        if (ppc_md.progress)
                ppc_md.progress("gt64260_init_irq: exit", 0x0);
diff --git a/arch/ppc/syslib/m82xx_pci.c b/arch/ppc/syslib/m82xx_pci.c
index 1941a8c7ca9a..63fa5b313396 100644
--- a/arch/ppc/syslib/m82xx_pci.c
+++ b/arch/ppc/syslib/m82xx_pci.c
@@ -159,7 +159,7 @@ pq2pci_init_irq(void)
        immap->im_memctl.memc_or8 = 0xffff8010;
 #endif
        for (irq = NR_CPM_INTS; irq < NR_CPM_INTS + 4; irq++)
-                irq_desc[irq].handler = &pq2pci_ic;
+                irq_desc[irq].chip = &pq2pci_ic;
        /* make PCI IRQ level sensitive */
        immap->im_intctl.ic_siexr &=
diff --git a/arch/ppc/syslib/m8xx_setup.c b/arch/ppc/syslib/m8xx_setup.c
index dae9af78bde1..0c4c0de7c59f 100644
--- a/arch/ppc/syslib/m8xx_setup.c
+++ b/arch/ppc/syslib/m8xx_setup.c
@@ -347,13 +347,13 @@ m8xx_init_IRQ(void)
        int i;
        for (i = SIU_IRQ_OFFSET ; i < SIU_IRQ_OFFSET + NR_SIU_INTS ; i++)
-                irq_desc[i].handler = &ppc8xx_pic;
+                irq_desc[i].chip = &ppc8xx_pic;
        cpm_interrupt_init();
 #if defined(CONFIG_PCI)
        for (i = I8259_IRQ_OFFSET ; i < I8259_IRQ_OFFSET + NR_8259_INTS ; i++)
-                irq_desc[i].handler = &i8259_pic;
+                irq_desc[i].chip = &i8259_pic;
        i8259_pic_irq_offset = I8259_IRQ_OFFSET;
        i8259_init(0);
diff --git a/arch/ppc/syslib/mpc52xx_pic.c b/arch/ppc/syslib/mpc52xx_pic.c
index c4406f9dc6a3..6425b5cee7db 100644
--- a/arch/ppc/syslib/mpc52xx_pic.c
+++ b/arch/ppc/syslib/mpc52xx_pic.c
@@ -204,9 +204,9 @@ mpc52xx_init_irq(void)
        out_be32(&intr->main_pri1, 0);
        out_be32(&intr->main_pri2, 0);
-        /* Initialize irq_desc[i].handler's with mpc52xx_ic. */
+        /* Initialize irq_desc[i].chip's with mpc52xx_ic. */
        for (i = 0; i < NR_IRQS; i++) {
-                irq_desc[i].handler = &mpc52xx_ic;
+                irq_desc[i].chip = &mpc52xx_ic;
                irq_desc[i].status = IRQ_LEVEL;
        }
diff --git a/arch/ppc/syslib/mv64360_pic.c b/arch/ppc/syslib/mv64360_pic.c
index 5a19697060f0..a4244d468381 100644
--- a/arch/ppc/syslib/mv64360_pic.c
+++ b/arch/ppc/syslib/mv64360_pic.c
@@ -119,7 +119,7 @@ mv64360_init_irq(void)
        /* All interrupts are level interrupts */
        for (i = mv64360_irq_base; i < (mv64360_irq_base + 96); i++) {
                irq_desc[i].status |= IRQ_LEVEL;
-                irq_desc[i].handler = &mv64360_pic;
+                irq_desc[i].chip = &mv64360_pic;
        }
        if (ppc_md.progress)
diff --git a/arch/ppc/syslib/open_pic.c b/arch/ppc/syslib/open_pic.c
index 70456c8f998c..767a0bc95817 100644
--- a/arch/ppc/syslib/open_pic.c
+++ b/arch/ppc/syslib/open_pic.c
@@ -373,7 +373,7 @@ void __init openpic_init(int offset)
                                OPENPIC_VEC_IPI+i+offset);
                /* IPIs are per-CPU */
                irq_desc[OPENPIC_VEC_IPI+i+offset].status |= IRQ_PER_CPU;
-                irq_desc[OPENPIC_VEC_IPI+i+offset].handler = &open_pic_ipi;
+                irq_desc[OPENPIC_VEC_IPI+i+offset].chip = &open_pic_ipi;
        }
 #endif
@@ -408,7 +408,7 @@ void __init openpic_init(int offset)
        /* Init descriptors */
        for (i = offset; i < NumSources + offset; i++)
-                irq_desc[i].handler = &open_pic;
+                irq_desc[i].chip = &open_pic;
        /* Initialize the spurious interrupt */
        if (ppc_md.progress) ppc_md.progress("openpic: spurious",0x3bd);
@@ -615,8 +615,8 @@ void __devinit do_openpic_setup_cpu(void)
        /* let the openpic know we want intrs. default affinity
         * is 0xffffffff until changed via /proc
         * That's how it's done on x86. If we want it differently, then
-         * we should make sure we also change the default values of irq_affinity
+         * we should make sure we also change the default values of
-         * in irq.c.
+         * irq_desc[].affinity in irq.c.
         */
        for (i = 0; i < NumSources; i++)
                openpic_mapirq(i, msk, CPU_MASK_ALL);
diff --git a/arch/ppc/syslib/open_pic2.c b/arch/ppc/syslib/open_pic2.c
index bcbe40de26fe..b8154efff6ed 100644
--- a/arch/ppc/syslib/open_pic2.c
+++ b/arch/ppc/syslib/open_pic2.c
@@ -290,7 +290,7 @@ void __init openpic2_init(int offset)
        /* Init descriptors */
        for (i = offset; i < NumSources + offset; i++)
-                irq_desc[i].handler = &open_pic2;
+                irq_desc[i].chip = &open_pic2;
        /* Initialize the spurious interrupt */
        if (ppc_md.progress) ppc_md.progress("openpic2: spurious",0x3bd);
diff --git a/arch/ppc/syslib/ppc403_pic.c b/arch/ppc/syslib/ppc403_pic.c
index c46043c47225..1584c8b1229f 100644
--- a/arch/ppc/syslib/ppc403_pic.c
+++ b/arch/ppc/syslib/ppc403_pic.c
@@ -121,5 +121,5 @@ ppc4xx_pic_init(void)
        ppc_md.get_irq = ppc403_pic_get_irq;
        for (i = 0; i < NR_IRQS; i++)
-                irq_desc[i].handler = &ppc403_aic;
+                irq_desc[i].chip = &ppc403_aic;
 }
diff --git a/arch/ppc/syslib/ppc4xx_pic.c b/arch/ppc/syslib/ppc4xx_pic.c
index fd9af0fc0e9f..e669c1335d47 100644
--- a/arch/ppc/syslib/ppc4xx_pic.c
+++ b/arch/ppc/syslib/ppc4xx_pic.c
@@ -276,7 +276,7 @@ void __init ppc4xx_pic_init(void)
        /* Attach low-level handlers */
        for (i = 0; i < (NR_UICS << 5); ++i) {
-                irq_desc[i].handler = &__uic[i >> 5].decl;
+                irq_desc[i].chip = &__uic[i >> 5].decl;
                if (is_level_sensitive(i))
                        irq_desc[i].status |= IRQ_LEVEL;
        }
diff --git a/arch/ppc/syslib/xilinx_pic.c b/arch/ppc/syslib/xilinx_pic.c
index e672b600f315..39a93dc6375b 100644
--- a/arch/ppc/syslib/xilinx_pic.c
+++ b/arch/ppc/syslib/xilinx_pic.c
@@ -143,7 +143,7 @@ ppc4xx_pic_init(void)
        ppc_md.get_irq = xilinx_pic_get_irq;
        for (i = 0; i < NR_IRQS; ++i) {
-                irq_desc[i].handler = &xilinx_intc;
+                irq_desc[i].chip = &xilinx_intc;
                if (XPAR_INTC_0_KIND_OF_INTR & (0x00000001 << i))
                        irq_desc[i].status &= ~IRQ_LEVEL;
diff --git a/arch/sh/boards/adx/irq_maskreg.c b/arch/sh/boards/adx/irq_maskreg.c
index c0973f8d57ba..357fab1bac2b 100644
--- a/arch/sh/boards/adx/irq_maskreg.c
+++ b/arch/sh/boards/adx/irq_maskreg.c
@@ -102,6 +102,6 @@ static void end_maskreg_irq(unsigned int irq)
 void make_maskreg_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &maskreg_irq_type;
+        irq_desc[irq].chip = &maskreg_irq_type;
        disable_maskreg_irq(irq);
 }
diff --git a/arch/sh/boards/bigsur/irq.c b/arch/sh/boards/bigsur/irq.c
index 6ddbcc77244d..1d32425782c0 100644
--- a/arch/sh/boards/bigsur/irq.c
+++ b/arch/sh/boards/bigsur/irq.c
@@ -253,7 +253,7 @@ static void make_bigsur_l1isr(unsigned int irq) {
        /* sanity check first */
        if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) {
                /* save the handler in the main description table */
-                irq_desc[irq].handler = &bigsur_l1irq_type;
+                irq_desc[irq].chip = &bigsur_l1irq_type;
                irq_desc[irq].status = IRQ_DISABLED;
                irq_desc[irq].action = 0;
                irq_desc[irq].depth = 1;
@@ -270,7 +270,7 @@ static void make_bigsur_l2isr(unsigned int irq) {
        /* sanity check first */
        if(irq >= BIGSUR_2NDLVL_IRQ_LOW && irq < BIGSUR_2NDLVL_IRQ_HIGH) {
                /* save the handler in the main description table */
-                irq_desc[irq].handler = &bigsur_l2irq_type;
+                irq_desc[irq].chip = &bigsur_l2irq_type;
                irq_desc[irq].status = IRQ_DISABLED;
                irq_desc[irq].action = 0;
                irq_desc[irq].depth = 1;
diff --git a/arch/sh/boards/cqreek/irq.c b/arch/sh/boards/cqreek/irq.c
index d1da0d844567..2955adc52310 100644
--- a/arch/sh/boards/cqreek/irq.c
+++ b/arch/sh/boards/cqreek/irq.c
@@ -103,7 +103,7 @@ void __init init_cqreek_IRQ(void)
                cqreek_irq_data[14].stat_port = BRIDGE_IDE_INTR_STAT;
                cqreek_irq_data[14].bit = 1;
-                irq_desc[14].handler = &cqreek_irq_type;
+                irq_desc[14].chip = &cqreek_irq_type;
                irq_desc[14].status = IRQ_DISABLED;
                irq_desc[14].action = 0;
                irq_desc[14].depth = 1;
@@ -117,7 +117,7 @@ void __init init_cqreek_IRQ(void)
                cqreek_irq_data[10].bit = (1 << 10);
                /* XXX: Err... we may need demultiplexer for ISA irq... */
-                irq_desc[10].handler = &cqreek_irq_type;
+                irq_desc[10].chip = &cqreek_irq_type;
                irq_desc[10].status = IRQ_DISABLED;
                irq_desc[10].action = 0;
                irq_desc[10].depth = 1;
diff --git a/arch/sh/boards/dreamcast/setup.c b/arch/sh/boards/dreamcast/setup.c
index 55dece35cde5..0027b80a2343 100644
--- a/arch/sh/boards/dreamcast/setup.c
+++ b/arch/sh/boards/dreamcast/setup.c
@@ -70,7 +70,7 @@ int __init platform_setup(void)
        /* Assign all virtual IRQs to the System ASIC int. handler */
        for (i = HW_EVENT_IRQ_BASE; i < HW_EVENT_IRQ_MAX; i++)
-                irq_desc[i].handler = &systemasic_int;
+                irq_desc[i].chip = &systemasic_int;
        board_time_init = aica_time_init;
diff --git a/arch/sh/boards/ec3104/setup.c b/arch/sh/boards/ec3104/setup.c
index 5130ba2b6ff1..4b3ef16a0e96 100644
--- a/arch/sh/boards/ec3104/setup.c
+++ b/arch/sh/boards/ec3104/setup.c
@@ -63,7 +63,7 @@ int __init platform_setup(void)
                str[i] = ctrl_readb(EC3104_BASE + i);
        for (i = EC3104_IRQBASE; i < EC3104_IRQBASE + 32; i++)
-                irq_desc[i].handler = &ec3104_int;
+                irq_desc[i].chip = &ec3104_int;
        printk("initializing EC3104 \"%.8s\" at %08x, IRQ %d, IRQ base %d\n",
               str, EC3104_BASE, EC3104_IRQ, EC3104_IRQBASE);
diff --git a/arch/sh/boards/harp/irq.c b/arch/sh/boards/harp/irq.c
index 52d0ba39031b..701fa55d5297 100644
--- a/arch/sh/boards/harp/irq.c
+++ b/arch/sh/boards/harp/irq.c
@@ -114,7 +114,7 @@ static void enable_harp_irq(unsigned int irq)
 static void __init make_harp_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &harp_irq_type;
+        irq_desc[irq].chip = &harp_irq_type;
        disable_harp_irq(irq);
 }
diff --git a/arch/sh/boards/mpc1211/pci.c b/arch/sh/boards/mpc1211/pci.c
index ba3a65439752..9f7ccd33ffb6 100644
--- a/arch/sh/boards/mpc1211/pci.c
+++ b/arch/sh/boards/mpc1211/pci.c
@@ -273,9 +273,9 @@ void __init pcibios_fixup_irqs(void)
 }
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
-        unsigned long start = res->start;
+        resource_size_t start = res->start;
        if (res->flags & IORESOURCE_IO) {
                if (start >= 0x10000UL) {
diff --git a/arch/sh/boards/mpc1211/setup.c b/arch/sh/boards/mpc1211/setup.c
index 2bb581b91683..b72f009c52c2 100644
--- a/arch/sh/boards/mpc1211/setup.c
+++ b/arch/sh/boards/mpc1211/setup.c
@@ -194,7 +194,7 @@ static struct hw_interrupt_type mpc1211_irq_type = {
 static void make_mpc1211_irq(unsigned int irq)
 {
-        irq_desc[irq].handler = &mpc1211_irq_type;
+        irq_desc[irq].chip = &mpc1211_irq_type;
        irq_desc[irq].status  = IRQ_DISABLED;
        irq_desc[irq].action  = 0;
        irq_desc[irq].depth   = 1;
diff --git a/arch/sh/boards/overdrive/galileo.c b/arch/sh/boards/overdrive/galileo.c
index 276fa11ee4ce..b055809d2ac1 100644
--- a/arch/sh/boards/overdrive/galileo.c
+++ b/arch/sh/boards/overdrive/galileo.c
@@ -536,7 +536,7 @@ void __init pcibios_fixup_bus(struct pci_bus *bus)
 }
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size)
+                            resource_size_t size)
 {
 }
diff --git a/arch/sh/boards/overdrive/irq.c b/arch/sh/boards/overdrive/irq.c
index 715e8feb3a68..2c13a7de6b22 100644
--- a/arch/sh/boards/overdrive/irq.c
+++ b/arch/sh/boards/overdrive/irq.c
@@ -150,7 +150,7 @@ static void enable_od_irq(unsigned int irq)
 static void __init make_od_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &od_irq_type;
+        irq_desc[irq].chip = &od_irq_type;
        disable_od_irq(irq);
 }
diff --git a/arch/sh/boards/renesas/hs7751rvoip/irq.c b/arch/sh/boards/renesas/hs7751rvoip/irq.c
index ed4c5b50ea45..52a98b524e1f 100644
--- a/arch/sh/boards/renesas/hs7751rvoip/irq.c
+++ b/arch/sh/boards/renesas/hs7751rvoip/irq.c
@@ -86,7 +86,7 @@ static struct hw_interrupt_type hs7751rvoip_irq_type = {
 static void make_hs7751rvoip_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &hs7751rvoip_irq_type;
+        irq_desc[irq].chip = &hs7751rvoip_irq_type;
        disable_hs7751rvoip_irq(irq);
 }
diff --git a/arch/sh/boards/renesas/rts7751r2d/irq.c b/arch/sh/boards/renesas/rts7751r2d/irq.c
index d36c9374aed1..e16915d9cda4 100644
--- a/arch/sh/boards/renesas/rts7751r2d/irq.c
+++ b/arch/sh/boards/renesas/rts7751r2d/irq.c
@@ -100,7 +100,7 @@ static struct hw_interrupt_type rts7751r2d_irq_type = {
 static void make_rts7751r2d_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &rts7751r2d_irq_type;
+        irq_desc[irq].chip = &rts7751r2d_irq_type;
        disable_rts7751r2d_irq(irq);
 }
diff --git a/arch/sh/boards/renesas/systemh/irq.c b/arch/sh/boards/renesas/systemh/irq.c
index 7a2eb10edb56..845979181059 100644
--- a/arch/sh/boards/renesas/systemh/irq.c
+++ b/arch/sh/boards/renesas/systemh/irq.c
@@ -105,7 +105,7 @@ static void end_systemh_irq(unsigned int irq)
 void make_systemh_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &systemh_irq_type;
+        irq_desc[irq].chip = &systemh_irq_type;
        disable_systemh_irq(irq);
 }
diff --git a/arch/sh/boards/se/73180/irq.c b/arch/sh/boards/se/73180/irq.c
index 70f04caad9a4..402735c7c898 100644
--- a/arch/sh/boards/se/73180/irq.c
+++ b/arch/sh/boards/se/73180/irq.c
@@ -85,7 +85,7 @@ void
 make_intreq_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &intreq_irq_type;
+        irq_desc[irq].chip = &intreq_irq_type;
        disable_intreq_irq(irq);
 }
diff --git a/arch/sh/boards/superh/microdev/irq.c b/arch/sh/boards/superh/microdev/irq.c
index efcbd86b7cd2..cb5999425d16 100644
--- a/arch/sh/boards/superh/microdev/irq.c
+++ b/arch/sh/boards/superh/microdev/irq.c
@@ -147,7 +147,7 @@ static void enable_microdev_irq(unsigned int irq)
 static void __init make_microdev_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &microdev_irq_type;
+        irq_desc[irq].chip = &microdev_irq_type;
        disable_microdev_irq(irq);
 }
diff --git a/arch/sh/cchips/hd6446x/hd64461/setup.c b/arch/sh/cchips/hd6446x/hd64461/setup.c
index f014b9bf6922..724db04cb392 100644
--- a/arch/sh/cchips/hd6446x/hd64461/setup.c
+++ b/arch/sh/cchips/hd6446x/hd64461/setup.c
@@ -154,7 +154,7 @@ int __init setup_hd64461(void)
        outw(0xffff, HD64461_NIMR);
        for (i = HD64461_IRQBASE; i < HD64461_IRQBASE + 16; i++) {
-                irq_desc[i].handler = &hd64461_irq_type;
+                irq_desc[i].chip = &hd64461_irq_type;
        }
        setup_irq(CONFIG_HD64461_IRQ, &irq0);
diff --git a/arch/sh/cchips/hd6446x/hd64465/setup.c b/arch/sh/cchips/hd6446x/hd64465/setup.c
index 68e4c4e4283d..cf9142c620b7 100644
--- a/arch/sh/cchips/hd6446x/hd64465/setup.c
+++ b/arch/sh/cchips/hd6446x/hd64465/setup.c
@@ -182,7 +182,7 @@ static int __init setup_hd64465(void)
        outw(0xffff, HD64465_REG_NIMR);         /* mask all interrupts */
        for (i = 0; i < HD64465_IRQ_NUM ; i++) {
-                irq_desc[HD64465_IRQ_BASE + i].handler = &hd64465_irq_type;
+                irq_desc[HD64465_IRQ_BASE + i].chip = &hd64465_irq_type;
        }
        setup_irq(CONFIG_HD64465_IRQ, &irq0);
diff --git a/arch/sh/cchips/voyagergx/irq.c b/arch/sh/cchips/voyagergx/irq.c
index 2ee330b3c38f..892214bade19 100644
--- a/arch/sh/cchips/voyagergx/irq.c
+++ b/arch/sh/cchips/voyagergx/irq.c
@@ -191,7 +191,7 @@ void __init setup_voyagergx_irq(void)
                        flag = 1;
                }
                if (flag == 1)
-                        irq_desc[VOYAGER_IRQ_BASE + i].handler = &voyagergx_irq_type;
+                        irq_desc[VOYAGER_IRQ_BASE + i].chip = &voyagergx_irq_type;
        }
        setup_irq(IRQ_VOYAGER, &irq0);
diff --git a/arch/sh/drivers/pci/pci.c b/arch/sh/drivers/pci/pci.c
index c1669905abe4..3d546ba329cf 100644
--- a/arch/sh/drivers/pci/pci.c
+++ b/arch/sh/drivers/pci/pci.c
@@ -75,7 +75,7 @@ pcibios_update_resource(struct pci_dev *dev, struct resource *root,
 }
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
                            __attribute__ ((weak));
 /*
@@ -85,10 +85,10 @@ void pcibios_align_resource(void *data, struct resource *res,
 * modulo 0x400.
 */
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (start & 0x300) {
                        start = (start + 0x3ff) & ~0x3ff;
diff --git a/arch/sh/kernel/cpu/irq/imask.c b/arch/sh/kernel/cpu/irq/imask.c
index baed9a550d39..a33ae3e0a5a5 100644
--- a/arch/sh/kernel/cpu/irq/imask.c
+++ b/arch/sh/kernel/cpu/irq/imask.c
@@ -105,6 +105,6 @@ static void shutdown_imask_irq(unsigned int irq)
 void make_imask_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &imask_irq_type;
+        irq_desc[irq].chip = &imask_irq_type;
        enable_irq(irq);
 }
diff --git a/arch/sh/kernel/cpu/irq/intc2.c b/arch/sh/kernel/cpu/irq/intc2.c
index 06e8afab32e4..30064bf6e154 100644
--- a/arch/sh/kernel/cpu/irq/intc2.c
+++ b/arch/sh/kernel/cpu/irq/intc2.c
@@ -137,7 +137,7 @@ void make_intc2_irq(unsigned int irq,
        local_irq_restore(flags);
-        irq_desc[irq].handler = &intc2_irq_type;
+        irq_desc[irq].chip = &intc2_irq_type;
        disable_intc2_irq(irq);
 }
diff --git a/arch/sh/kernel/cpu/irq/ipr.c b/arch/sh/kernel/cpu/irq/ipr.c
index e55150ed0856..0373b65c77f9 100644
--- a/arch/sh/kernel/cpu/irq/ipr.c
+++ b/arch/sh/kernel/cpu/irq/ipr.c
@@ -115,7 +115,7 @@ void make_ipr_irq(unsigned int irq, unsigned int addr, int pos, int priority)
        ipr_data[irq].shift = pos*4; /* POSition (0-3) x 4 means shift */
        ipr_data[irq].priority = priority;
-        irq_desc[irq].handler = &ipr_irq_type;
+        irq_desc[irq].chip = &ipr_irq_type;
        disable_ipr_irq(irq);
 }
diff --git a/arch/sh/kernel/cpu/irq/pint.c b/arch/sh/kernel/cpu/irq/pint.c
index 95d6024fe1ae..714963a25bba 100644
--- a/arch/sh/kernel/cpu/irq/pint.c
+++ b/arch/sh/kernel/cpu/irq/pint.c
@@ -85,7 +85,7 @@ static void end_pint_irq(unsigned int irq)
 void make_pint_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &pint_irq_type;
+        irq_desc[irq].chip = &pint_irq_type;
        disable_pint_irq(irq);
 }
diff --git a/arch/sh/kernel/irq.c b/arch/sh/kernel/irq.c
index b56e79632f24..c2e07f7f3496 100644
--- a/arch/sh/kernel/irq.c
+++ b/arch/sh/kernel/irq.c
@@ -47,7 +47,7 @@ int show_interrupts(struct seq_file *p, void *v)
                        goto unlock;
                seq_printf(p, "%3d: ",i);
                seq_printf(p, "%10u ", kstat_irqs(i));
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
diff --git a/arch/sh64/kernel/irq.c b/arch/sh64/kernel/irq.c
index d69879c0e063..675776a5477e 100644
--- a/arch/sh64/kernel/irq.c
+++ b/arch/sh64/kernel/irq.c
@@ -65,7 +65,7 @@ int show_interrupts(struct seq_file *p, void *v)
                        goto unlock;
                seq_printf(p, "%3d: ",i);
                seq_printf(p, "%10u ", kstat_irqs(i));
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
diff --git a/arch/sh64/kernel/irq_intc.c b/arch/sh64/kernel/irq_intc.c
index fc99bf4e362c..fa730f5fe2e6 100644
--- a/arch/sh64/kernel/irq_intc.c
+++ b/arch/sh64/kernel/irq_intc.c
@@ -178,7 +178,7 @@ static void end_intc_irq(unsigned int irq)
 void make_intc_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &intc_irq_type;
+        irq_desc[irq].chip = &intc_irq_type;
        disable_intc_irq(irq);
 }
@@ -208,7 +208,7 @@ void __init init_IRQ(void)
        /* Set default: per-line enable/disable, priority driven ack/eoi */
        for (i = 0; i < NR_INTC_IRQS; i++) {
                if (platform_int_priority[i] != NO_PRIORITY) {
-                        irq_desc[i].handler = &intc_irq_type;
+                        irq_desc[i].chip = &intc_irq_type;
                }
        }
diff --git a/arch/sh64/kernel/pcibios.c b/arch/sh64/kernel/pcibios.c
index 50c61dcb9fae..945920bc24db 100644
--- a/arch/sh64/kernel/pcibios.c
+++ b/arch/sh64/kernel/pcibios.c
@@ -69,10 +69,10 @@ pcibios_update_resource(struct pci_dev *dev, struct resource *root,
 * modulo 0x400.
 */
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (start & 0x300) {
                        start = (start + 0x3ff) & ~0x3ff;
diff --git a/arch/sh64/mach-cayman/irq.c b/arch/sh64/mach-cayman/irq.c
index f797c84bfdd1..05eb7cdc26f0 100644
--- a/arch/sh64/mach-cayman/irq.c
+++ b/arch/sh64/mach-cayman/irq.c
@@ -187,7 +187,7 @@ void init_cayman_irq(void)
        }
        for (i=0; i<NR_EXT_IRQS; i++) {
-                irq_desc[START_EXT_IRQS + i].handler = &cayman_irq_type;
+                irq_desc[START_EXT_IRQS + i].chip = &cayman_irq_type;
        }
        /* Setup the SMSC interrupt */
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index ae4c667c906f..79d177149fdb 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -208,7 +208,7 @@ _sparc_ioremap(struct resource *res, u32 bus, u32 pa, int sz)
        pa &= PAGE_MASK;
        sparc_mapiorange(bus, pa, res->start, res->end - res->start + 1);
-        return (void __iomem *) (res->start + offset);
+        return (void __iomem *)(unsigned long)(res->start + offset);
 }
 /*
@@ -325,7 +325,7 @@ void *sbus_alloc_consistent(struct sbus_dev *sdev, long len, u32 *dma_addrp)
                res->name = sdev->prom_name;
        }
-        return (void *)res->start;
+        return (void *)(unsigned long)res->start;
 err_noiommu:
        release_resource(res);
@@ -819,7 +819,9 @@ _sparc_io_get_info(char *buf, char **start, off_t fpos, int length, int *eof,
                if (p + 32 >= e)        /* Better than nothing */
                        break;
                if ((nm = r->name) == 0) nm = "???";
-                p += sprintf(p, "%08lx-%08lx: %s\n", r->start, r->end, nm);
+                p += sprintf(p, "%016llx-%016llx: %s\n",
+                                (unsigned long long)r->start,
+                                (unsigned long long)r->end, nm);
        }
        return p-buf;
diff --git a/arch/sparc/kernel/pcic.c b/arch/sparc/kernel/pcic.c
index bcfdddd0418a..5df3ebdc0ab1 100644
--- a/arch/sparc/kernel/pcic.c
+++ b/arch/sparc/kernel/pcic.c
@@ -860,7 +860,7 @@ char * __init pcibios_setup(char *str)
 }
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
 }
diff --git a/arch/sparc/kernel/setup.c b/arch/sparc/kernel/setup.c
index a893a9cc9534..2e5d08ce217b 100644
--- a/arch/sparc/kernel/setup.c
+++ b/arch/sparc/kernel/setup.c
@@ -496,7 +496,7 @@ static int __init topology_init(void)
                if (!p)
                        err = -ENOMEM;
                else
-                        register_cpu(p, i, NULL);
+                        register_cpu(p, i);
        }
        return err;
diff --git a/arch/sparc64/kernel/irq.c b/arch/sparc64/kernel/irq.c
index cc89b06d0178..ab9e640df228 100644
--- a/arch/sparc64/kernel/irq.c
+++ b/arch/sparc64/kernel/irq.c
@@ -151,7 +151,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %9s", irq_desc[i].handler->typename);
+                seq_printf(p, " %9s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -224,7 +224,7 @@ static inline struct ino_bucket *virt_irq_to_bucket(unsigned int virt_irq)
 #ifdef CONFIG_SMP
 static int irq_choose_cpu(unsigned int virt_irq)
 {
-        cpumask_t mask = irq_affinity[virt_irq];
+        cpumask_t mask = irq_desc[virt_irq].affinity;
        int cpuid;
        if (cpus_equal(mask, CPU_MASK_ALL)) {
@@ -414,8 +414,8 @@ void irq_install_pre_handler(int virt_irq,
        data->pre_handler_arg1 = arg1;
        data->pre_handler_arg2 = arg2;
-        desc->handler = (desc->handler == &sun4u_irq ?
+        desc->chip = (desc->chip == &sun4u_irq ?
-                         &sun4u_irq_ack : &sun4v_irq_ack);
+                      &sun4u_irq_ack : &sun4v_irq_ack);
 }
 unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap)
@@ -431,7 +431,7 @@ unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap)
        bucket = &ivector_table[ino];
        if (!bucket->virt_irq) {
                bucket->virt_irq = virt_irq_alloc(__irq(bucket));
-                irq_desc[bucket->virt_irq].handler = &sun4u_irq;
+                irq_desc[bucket->virt_irq].chip = &sun4u_irq;
        }
        desc = irq_desc + bucket->virt_irq;
@@ -465,7 +465,7 @@ unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino)
        bucket = &ivector_table[sysino];
        if (!bucket->virt_irq) {
                bucket->virt_irq = virt_irq_alloc(__irq(bucket));
-                irq_desc[bucket->virt_irq].handler = &sun4v_irq;
+                irq_desc[bucket->virt_irq].chip = &sun4v_irq;
        }
        desc = irq_desc + bucket->virt_irq;
diff --git a/arch/sparc64/kernel/pci.c b/arch/sparc64/kernel/pci.c
index 6c9e3e94abaa..20ca9ec8fd3b 100644
--- a/arch/sparc64/kernel/pci.c
+++ b/arch/sparc64/kernel/pci.c
@@ -357,7 +357,7 @@ void pcibios_update_irq(struct pci_dev *pdev, int irq)
 }
 void pcibios_align_resource(void *data, struct resource *res,
-                            unsigned long size, unsigned long align)
+                            resource_size_t size, resource_size_t align)
 {
 }
diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
index 2ffda012385e..fae43a3054a0 100644
--- a/arch/um/kernel/irq.c
+++ b/arch/um/kernel/irq.c
@@ -63,7 +63,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -451,13 +451,13 @@ void __init init_IRQ(void)
        irq_desc[TIMER_IRQ].status = IRQ_DISABLED;
        irq_desc[TIMER_IRQ].action = NULL;
        irq_desc[TIMER_IRQ].depth = 1;
-        irq_desc[TIMER_IRQ].handler = &SIGVTALRM_irq_type;
+        irq_desc[TIMER_IRQ].chip = &SIGVTALRM_irq_type;
        enable_irq(TIMER_IRQ);
        for (i = 1; i < NR_IRQS; i++) {
                irq_desc[i].status = IRQ_DISABLED;
                irq_desc[i].action = NULL;
                irq_desc[i].depth = 1;
-                irq_desc[i].handler = &normal_irq_type;
+                irq_desc[i].chip = &normal_irq_type;
                enable_irq(i);
        }
 }
diff --git a/arch/v850/kernel/irq.c b/arch/v850/kernel/irq.c
index 7a151c26f82e..858c45819aab 100644
--- a/arch/v850/kernel/irq.c
+++ b/arch/v850/kernel/irq.c
@@ -65,10 +65,10 @@ int show_interrupts(struct seq_file *p, void *v)
                        int j;
                        int count = 0;
                        int num = -1;
-                        const char *type_name = irq_desc[irq].handler->typename;
+                        const char *type_name = irq_desc[irq].chip->typename;
                        for (j = 0; j < NR_IRQS; j++)
-                                if (irq_desc[j].handler->typename == type_name){
+                                if (irq_desc[j].chip->typename == type_name){
                                        if (irq == j)
                                                num = count;
                                        count++;
@@ -117,7 +117,7 @@ init_irq_handlers (int base_irq, int num, int interval,
                irq_desc[base_irq].status  = IRQ_DISABLED;
                irq_desc[base_irq].action  = NULL;
                irq_desc[base_irq].depth   = 1;
-                irq_desc[base_irq].handler = irq_type;
+                irq_desc[base_irq].chip = irq_type;
                base_irq += interval;
        }
 }
diff --git a/arch/v850/kernel/rte_mb_a_pci.c b/arch/v850/kernel/rte_mb_a_pci.c
index ffbb6d073bf2..3a7c5c9c3ac6 100644
--- a/arch/v850/kernel/rte_mb_a_pci.c
+++ b/arch/v850/kernel/rte_mb_a_pci.c
@@ -329,7 +329,7 @@ void pcibios_fixup_bus(struct pci_bus *b)
 void
 pcibios_align_resource (void *data, struct resource *res,
-                        unsigned long size, unsigned long align)
+                        resource_size_t size, resource_size_t align)
 {
 }
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig
index ccc4a7fb97a3..91039844820c 100644
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -370,6 +370,8 @@ config HOTPLUG_CPU
                can be controlled through /sys/devices/system/cpu/cpu#.
                Say N if you want to disable CPU hotplug.
+config ARCH_ENABLE_MEMORY_HOTPLUG
+        def_bool y
 config HPET_TIMER
        bool
diff --git a/arch/x86_64/kernel/i8259.c b/arch/x86_64/kernel/i8259.c
index 86b2c1e197aa..3dd1659427dc 100644
--- a/arch/x86_64/kernel/i8259.c
+++ b/arch/x86_64/kernel/i8259.c
@@ -235,7 +235,7 @@ void make_8259A_irq(unsigned int irq)
 {
        disable_irq_nosync(irq);
        io_apic_irqs &= ~(1<<irq);
-        irq_desc[irq].handler = &i8259A_irq_type;
+        irq_desc[irq].chip = &i8259A_irq_type;
        enable_irq(irq);
 }
@@ -468,12 +468,12 @@ void __init init_ISA_irqs (void)
                        /*
                         * 16 old-style INTA-cycle interrupts:
                         */
-                        irq_desc[i].handler = &i8259A_irq_type;
+                        irq_desc[i].chip = &i8259A_irq_type;
                } else {
                        /*
                         * 'high' PCI IRQs filled in on demand
                         */
-                        irq_desc[i].handler = &no_irq_type;
+                        irq_desc[i].chip = &no_irq_type;
                }
        }
 }
diff --git a/arch/x86_64/kernel/io_apic.c b/arch/x86_64/kernel/io_apic.c
index c768d8a036d0..401b687fef21 100644
--- a/arch/x86_64/kernel/io_apic.c
+++ b/arch/x86_64/kernel/io_apic.c
@@ -876,15 +876,17 @@ static struct hw_interrupt_type ioapic_edge_type;
 #define IOAPIC_EDGE     0
 #define IOAPIC_LEVEL    1
-static inline void ioapic_register_intr(int irq, int vector, unsigned long trigger)
+static void ioapic_register_intr(int irq, int vector, unsigned long trigger)
 {
-        unsigned idx = use_pci_vector() && !platform_legacy_irq(irq) ? vector : irq;
+        unsigned idx;
+        idx = use_pci_vector() && !platform_legacy_irq(irq) ? vector : irq;
        if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
                        trigger == IOAPIC_LEVEL)
-                irq_desc[idx].handler = &ioapic_level_type;
+                irq_desc[idx].chip = &ioapic_level_type;
        else
-                irq_desc[idx].handler = &ioapic_edge_type;
+                irq_desc[idx].chip = &ioapic_edge_type;
        set_intr_gate(vector, interrupt[idx]);
 }
@@ -986,7 +988,7 @@ static void __init setup_ExtINT_IRQ0_pin(unsigned int apic, unsigned int pin, in
         * The timer IRQ doesn't have to know that behind the
         * scene we have a 8259A-master in AEOI mode ...
         */
-        irq_desc[0].handler = &ioapic_edge_type;
+        irq_desc[0].chip = &ioapic_edge_type;
        /*
         * Add it to the IO-APIC irq-routing table:
@@ -1616,6 +1618,13 @@ static void set_ioapic_affinity_vector (unsigned int vector,
 #endif // CONFIG_SMP
 #endif // CONFIG_PCI_MSI
+static int ioapic_retrigger(unsigned int irq)
+{
+        send_IPI_self(IO_APIC_VECTOR(irq));
+        return 1;
+}
 /*
 * Level and edge triggered IO-APIC interrupts need different handling,
 * so we use two separate IRQ descriptors. Edge triggered IRQs can be
@@ -1636,6 +1645,7 @@ static struct hw_interrupt_type ioapic_edge_type __read_mostly = {
 #ifdef CONFIG_SMP
        .set_affinity = set_ioapic_affinity,
 #endif
+        .retrigger      = ioapic_retrigger,
 };
 static struct hw_interrupt_type ioapic_level_type __read_mostly = {
@@ -1649,6 +1659,7 @@ static struct hw_interrupt_type ioapic_level_type __read_mostly = {
 #ifdef CONFIG_SMP
        .set_affinity = set_ioapic_affinity,
 #endif
+        .retrigger      = ioapic_retrigger,
 };
 static inline void init_IO_APIC_traps(void)
@@ -1683,7 +1694,7 @@ static inline void init_IO_APIC_traps(void)
                                make_8259A_irq(irq);
                        else
                                /* Strange. Oh, well.. */
-                                irq_desc[irq].handler = &no_irq_type;
+                                irq_desc[irq].chip = &no_irq_type;
                }
        }
 }
@@ -1900,7 +1911,7 @@ static inline void check_timer(void)
        apic_printk(APIC_VERBOSE, KERN_INFO "...trying to set up timer as Virtual Wire IRQ...");
        disable_8259A_irq(0);
-        irq_desc[0].handler = &lapic_irq_type;
+        irq_desc[0].chip = &lapic_irq_type;
        apic_write(APIC_LVT0, APIC_DM_FIXED | vector);  /* Fixed mode */
        enable_8259A_irq(0);
diff --git a/arch/x86_64/kernel/irq.c b/arch/x86_64/kernel/irq.c
index bfa82f52a5cc..a1f1df5f7bfc 100644
--- a/arch/x86_64/kernel/irq.c
+++ b/arch/x86_64/kernel/irq.c
@@ -79,7 +79,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -146,13 +146,13 @@ void fixup_irqs(cpumask_t map)
                if (irq == 2)
                        continue;
-                cpus_and(mask, irq_affinity[irq], map);
+                cpus_and(mask, irq_desc[irq].affinity, map);
                if (any_online_cpu(mask) == NR_CPUS) {
                        printk("Breaking affinity for irq %i\n", irq);
                        mask = map;
                }
-                if (irq_desc[irq].handler->set_affinity)
+                if (irq_desc[irq].chip->set_affinity)
-                        irq_desc[irq].handler->set_affinity(irq, mask);
+                        irq_desc[irq].chip->set_affinity(irq, mask);
                else if (irq_desc[irq].action && !(warned++))
                        printk("Cannot set affinity for irq %i\n", irq);
        }
diff --git a/arch/xtensa/kernel/irq.c b/arch/xtensa/kernel/irq.c
index 51f9bed455fa..1cf744ee0959 100644
--- a/arch/xtensa/kernel/irq.c
+++ b/arch/xtensa/kernel/irq.c
@@ -100,7 +100,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[i].chip->typename);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -181,7 +181,7 @@ void __init init_IRQ(void)
        int i;
        for (i=0; i < XTENSA_NR_IRQS; i++)
-                irq_desc[i].handler = &xtensa_irq_type;
+                irq_desc[i].chip = &xtensa_irq_type;
        cached_irq_mask = 0;
diff --git a/arch/xtensa/kernel/pci.c b/arch/xtensa/kernel/pci.c
index c6f471b9eaa0..eda029fc8972 100644
--- a/arch/xtensa/kernel/pci.c
+++ b/arch/xtensa/kernel/pci.c
@@ -71,13 +71,13 @@ static int pci_bus_count;
 * which might have be mirrored at 0x0100-0x03ff..
 */
 void
-pcibios_align_resource(void *data, struct resource *res, unsigned long size,
+pcibios_align_resource(void *data, struct resource *res, resource_size_t size,
-                       unsigned long align)
+                       resource_size_t align)
 {
        struct pci_dev *dev = data;
        if (res->flags & IORESOURCE_IO) {
-                unsigned long start = res->start;
+                resource_size_t start = res->start;
                if (size > 0x100) {
                        printk(KERN_ERR "PCI: I/O Region %s/%d too large"
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 889855d8d9f9..9e3e2a69c03a 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -180,8 +180,9 @@ static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
 amba_attr(id, "%08x\n", dev->periphid);
 amba_attr(irq0, "%u\n", dev->irq[0]);
 amba_attr(irq1, "%u\n", dev->irq[1]);
-amba_attr(resource, "\t%08lx\t%08lx\t%08lx\n",
+amba_attr(resource, "\t%016llx\t%016llx\t%016lx\n",
-          dev->res.start, dev->res.end, dev->res.flags);
+         (unsigned long long)dev->res.start, (unsigned long long)dev->res.end,
+         dev->res.flags);
 /**
 *      amba_device_register - register an AMBA device
diff --git a/drivers/atm/ambassador.c b/drivers/atm/ambassador.c
index 4b6bf19c39c0..4048681f36d5 100644
--- a/drivers/atm/ambassador.c
+++ b/drivers/atm/ambassador.c
@@ -2257,7 +2257,8 @@ static int __devinit amb_probe(struct pci_dev *pci_dev, const struct pci_device_
        }
        PRINTD (DBG_INFO, "found Madge ATM adapter (amb) at"
-                " IO %lx, IRQ %u, MEM %p", pci_resource_start(pci_dev, 1),
+                " IO %llx, IRQ %u, MEM %p",
+                (unsigned long long)pci_resource_start(pci_dev, 1),
                irq, bus_to_virt(pci_resource_start(pci_dev, 0)));
        // check IO region
diff --git a/drivers/atm/firestream.c b/drivers/atm/firestream.c
index 1bca86edf570..d40605c1af73 100644
--- a/drivers/atm/firestream.c
+++ b/drivers/atm/firestream.c
@@ -1658,9 +1658,10 @@ static int __devinit fs_init (struct fs_dev *dev)
        func_enter ();
        pci_dev = dev->pci_dev;
-        printk (KERN_INFO "found a FireStream %d card, base %08lx, irq%d.\n", 
+        printk (KERN_INFO "found a FireStream %d card, base %16llx, irq%d.\n",
                IS_FS50(dev)?50:155,
-                pci_resource_start(pci_dev, 0), dev->pci_dev->irq);
+                (unsigned long long)pci_resource_start(pci_dev, 0),
+                dev->pci_dev->irq);
        if (fs_debug & FS_DEBUG_INIT)
                my_hd ((unsigned char *) dev, sizeof (*dev));
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 852b564e903a..1a9dee19efcf 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -707,7 +707,7 @@ static int pf_detect(void)
                        if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
                                    conf[D_UNI], conf[D_PRO], conf[D_DLY],
                                    pf_scratch, PI_PF, verbose, pf->name)) {
-                                if (!pf_probe(pf) && pf->disk) {
+                                if (pf->disk && !pf_probe(pf)) {
                                        pf->present = 1;
                                        k++;
                                } else
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 2ae08b343b93..8144ce9f4df0 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -1694,9 +1694,10 @@ static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        DPRINTK("waiting for probe_comp\n");
        wait_for_completion(&host->probe_comp);
-        printk(KERN_INFO "%s: pci %s, ports %d, io %lx, irq %u, major %d\n",
+        printk(KERN_INFO "%s: pci %s, ports %d, io %llx, irq %u, major %d\n",
               host->name, pci_name(pdev), (int) CARM_MAX_PORTS,
-               pci_resource_start(pdev, 0), pdev->irq, host->major);
+               (unsigned long long)pci_resource_start(pdev, 0),
+                   pdev->irq, host->major);
        carm_host_id++;
        pci_set_drvdata(pdev, host);
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 410d70cb76fb..c40e487d9f5c 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -961,6 +961,7 @@ config PC8736x_GPIO
 config NSC_GPIO
        tristate "NatSemi Base GPIO Support"
+        depends on X86_32
        # selected by SCx200_GPIO and PC8736x_GPIO
        # what about 2 selectors differing: m != y
        help
diff --git a/drivers/char/applicom.c b/drivers/char/applicom.c
index 9275d5e52e6d..72fb60765c45 100644
--- a/drivers/char/applicom.c
+++ b/drivers/char/applicom.c
@@ -209,13 +209,16 @@ static int __init applicom_init(void)
                RamIO = ioremap(dev->resource[0].start, LEN_RAM_IO);
                if (!RamIO) {
-                        printk(KERN_INFO "ac.o: Failed to ioremap PCI memory space at 0x%lx\n", dev->resource[0].start);
+                        printk(KERN_INFO "ac.o: Failed to ioremap PCI memory "
+                                "space at 0x%llx\n",
+                                (unsigned long long)dev->resource[0].start);
                        pci_disable_device(dev);
                        return -EIO;
                }
-                printk(KERN_INFO "Applicom %s found at mem 0x%lx, irq %d\n",
+                printk(KERN_INFO "Applicom %s found at mem 0x%llx, irq %d\n",
-                       applicom_pci_devnames[dev->device-1], dev->resource[0].start, 
+                       applicom_pci_devnames[dev->device-1],
+                           (unsigned long long)dev->resource[0].start,
                       dev->irq);
                boardno = ac_register_board(dev->resource[0].start, RamIO,0);
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index 05e6e814d86f..073da48c092e 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -689,9 +689,9 @@ static int __devinit giu_probe(struct platform_device *dev)
        for (i = GIU_IRQ_BASE; i <= GIU_IRQ_LAST; i++) {
                if (i < GIU_IRQ(GIUINT_HIGH_OFFSET))
-                        irq_desc[i].handler = &giuint_low_irq_type;
+                        irq_desc[i].chip = &giuint_low_irq_type;
                else
-                        irq_desc[i].handler = &giuint_high_irq_type;
+                        irq_desc[i].chip = &giuint_high_irq_type;
        }
        return cascade_irq(GIUINT_IRQ, giu_get_irq);
diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index ff0cdc142f17..3edd7060510f 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -254,7 +254,8 @@ static unsigned int __devinit init_chipset_aec62xx(struct pci_dev *dev, const ch
        if (dev->resource[PCI_ROM_RESOURCE].start) {
                pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name, dev->resource[PCI_ROM_RESOURCE].start);
+                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
+                        (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
        }
        if (bus_speed <= 33)
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
index be334da7a754..7da550281cf2 100644
--- a/drivers/ide/pci/hpt34x.c
+++ b/drivers/ide/pci/hpt34x.c
@@ -176,7 +176,7 @@ static unsigned int __devinit init_chipset_hpt34x(struct pci_dev *dev, const cha
                        pci_write_config_dword(dev, PCI_ROM_ADDRESS,
                                dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
                        printk(KERN_INFO "HPT345: ROM enabled at 0x%08lx\n",
-                                dev->resource[PCI_ROM_RESOURCE].start);
+                                (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
                }
                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF0);
        } else {
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index 2c9e938dd1cd..5a8334d134fb 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -313,8 +313,8 @@ static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const cha
        if (dev->resource[PCI_ROM_RESOURCE].start) {
                pci_write_config_dword(dev, PCI_ROM_ADDRESS,
                        dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n",
+                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
-                        name, dev->resource[PCI_ROM_RESOURCE].start);
+                        (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
        }
 #ifdef CONFIG_PPC_PMAC
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index 26bc688a1821..1e209d8f9437 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -490,8 +490,8 @@ static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
        if (dev->resource[PCI_ROM_RESOURCE].start) {
                pci_write_config_dword(dev, PCI_ROM_ADDRESS,
                        dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n",
+                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
-                        name, dev->resource[PCI_ROM_RESOURCE].start);
+                        (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
        }
        return dev->irq;
diff --git a/drivers/ieee1394/ohci1394.c b/drivers/ieee1394/ohci1394.c
index 3d278412e1ca..800c8d518430 100644
--- a/drivers/ieee1394/ohci1394.c
+++ b/drivers/ieee1394/ohci1394.c
@@ -590,11 +590,11 @@ static void ohci_initialize(struct ti_ohci *ohci)
        buf = reg_read(ohci, OHCI1394_Version);
        sprintf (irq_buf, "%d", ohci->dev->irq);
        PRINT(KERN_INFO, "OHCI-1394 %d.%d (PCI): IRQ=[%s]  "
-              "MMIO=[%lx-%lx]  Max Packet=[%d]  IR/IT contexts=[%d/%d]",
+              "MMIO=[%llx-%llx]  Max Packet=[%d]  IR/IT contexts=[%d/%d]",
              ((((buf) >> 16) & 0xf) + (((buf) >> 20) & 0xf) * 10),
              ((((buf) >> 4) & 0xf) + ((buf) & 0xf) * 10), irq_buf,
-              pci_resource_start(ohci->dev, 0),
+              (unsigned long long)pci_resource_start(ohci->dev, 0),
-              pci_resource_start(ohci->dev, 0) + OHCI1394_REGISTER_SIZE - 1,
+              (unsigned long long)pci_resource_start(ohci->dev, 0) + OHCI1394_REGISTER_SIZE - 1,
              ohci->max_packet_size,
              ohci->nb_iso_rcv_ctx, ohci->nb_iso_xmit_ctx);
@@ -3217,7 +3217,7 @@ static int __devinit ohci1394_pci_probe(struct pci_dev *dev,
 {
        struct hpsb_host *host;
        struct ti_ohci *ohci;   /* shortcut to currently handled device */
-        unsigned long ohci_base;
+        resource_size_t ohci_base;
        if (pci_enable_device(dev))
                FAIL(-ENXIO, "Failed to enable OHCI hardware");
@@ -3270,15 +3270,16 @@ static int __devinit ohci1394_pci_probe(struct pci_dev *dev,
         * clearly says it's 2kb, so this shouldn't be a problem. */
        ohci_base = pci_resource_start(dev, 0);
        if (pci_resource_len(dev, 0) < OHCI1394_REGISTER_SIZE)
-                PRINT(KERN_WARNING, "PCI resource length of %lx too small!",
+                PRINT(KERN_WARNING, "PCI resource length of 0x%llx too small!",
-                      pci_resource_len(dev, 0));
+                      (unsigned long long)pci_resource_len(dev, 0));
        /* Seems PCMCIA handles this internally. Not sure why. Seems
         * pretty bogus to force a driver to special case this.  */
 #ifndef PCMCIA
        if (!request_mem_region (ohci_base, OHCI1394_REGISTER_SIZE, OHCI1394_DRIVER_NAME))
-                FAIL(-ENOMEM, "MMIO resource (0x%lx - 0x%lx) unavailable",
+                FAIL(-ENOMEM, "MMIO resource (0x%llx - 0x%llx) unavailable",
-                     ohci_base, ohci_base + OHCI1394_REGISTER_SIZE);
+                        (unsigned long long)ohci_base,
+                        (unsigned long long)ohci_base + OHCI1394_REGISTER_SIZE);
 #endif
        ohci->init_state = OHCI_INIT_HAVE_MEM_REGION;
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index dddcdae736ac..e4b897fa569a 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -460,10 +460,10 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
        for (j = 0; j < 6; j++) {
                if (!pdev->resource[j].start)
                        continue;
-                ipath_cdbg(VERBOSE, "BAR %d start %lx, end %lx, len %lx\n",
+                ipath_cdbg(VERBOSE, "BAR %d start %llx, end %llx, len %llx\n",
-                           j, pdev->resource[j].start,
+                           j, (unsigned long long)pdev->resource[j].start,
-                           pdev->resource[j].end,
+                           (unsigned long long)pdev->resource[j].end,
-                           pci_resource_len(pdev, j));
+                           (unsigned long long)pci_resource_len(pdev, j));
        }
        if (!addr) {
diff --git a/drivers/infiniband/hw/mthca/mthca_main.c b/drivers/infiniband/hw/mthca/mthca_main.c
index 9b9ff7bff357..465fd220569c 100644
--- a/drivers/infiniband/hw/mthca/mthca_main.c
+++ b/drivers/infiniband/hw/mthca/mthca_main.c
@@ -172,8 +172,9 @@ static int __devinit mthca_dev_lim(struct mthca_dev *mdev, struct mthca_dev_lim
        if (dev_lim->uar_size > pci_resource_len(mdev->pdev, 2)) {
                mthca_err(mdev, "HCA reported UAR size of 0x%x bigger than "
-                          "PCI resource 2 size of 0x%lx, aborting.\n",
+                          "PCI resource 2 size of 0x%llx, aborting.\n",
-                          dev_lim->uar_size, pci_resource_len(mdev->pdev, 2));
+                          dev_lim->uar_size,
+                          (unsigned long long)pci_resource_len(mdev->pdev, 2));
                return -ENODEV;
        }
diff --git a/drivers/input/serio/ct82c710.c b/drivers/input/serio/ct82c710.c
index 096b6a0b5cca..1ac739ef2ffa 100644
--- a/drivers/input/serio/ct82c710.c
+++ b/drivers/input/serio/ct82c710.c
@@ -189,7 +189,7 @@ static int __devinit ct82c710_probe(struct platform_device *dev)
        strlcpy(ct82c710_port->name, "C&T 82c710 mouse port",
                sizeof(ct82c710_port->name));
        snprintf(ct82c710_port->phys, sizeof(ct82c710_port->phys),
-                 "isa%04lx/serio0", CT82C710_DATA);
+                 "isa%16llx/serio0", (unsigned long long)CT82C710_DATA);
        serio_register_port(ct82c710_port);
@@ -241,8 +241,8 @@ static int __init ct82c710_init(void)
        serio_register_port(ct82c710_port);
-        printk(KERN_INFO "serio: C&T 82c710 mouse port at %#lx irq %d\n",
+        printk(KERN_INFO "serio: C&T 82c710 mouse port at %#llx irq %d\n",
-                CT82C710_DATA, CT82C710_IRQ);
+                (unsigned long long)CT82C710_DATA, CT82C710_IRQ);
        return 0;
diff --git a/drivers/isdn/hisax/hfc_pci.c b/drivers/isdn/hisax/hfc_pci.c
index 91d25acb5ede..3622720f0505 100644
--- a/drivers/isdn/hisax/hfc_pci.c
+++ b/drivers/isdn/hisax/hfc_pci.c
@@ -1688,7 +1688,7 @@ setup_hfcpci(struct IsdnCard *card)
                                printk(KERN_WARNING "HFC-PCI: No IRQ for PCI card found\n");
                                return (0);
                        }
-                        cs->hw.hfcpci.pci_io = (char *) dev_hfcpci->resource[ 1].start;
+                        cs->hw.hfcpci.pci_io = (char *)(unsigned long)dev_hfcpci->resource[1].start;
                        printk(KERN_INFO "HiSax: HFC-PCI card manufacturer: %s card name: %s\n", id_list[i].vendor_name, id_list[i].card_name);
                } else {
                        printk(KERN_WARNING "HFC-PCI: No PCI card found\n");
diff --git a/drivers/isdn/hisax/telespci.c b/drivers/isdn/hisax/telespci.c
index e2bb4fd8e25e..e82ab2251b82 100644
--- a/drivers/isdn/hisax/telespci.c
+++ b/drivers/isdn/hisax/telespci.c
@@ -311,8 +311,9 @@ setup_telespci(struct IsdnCard *card)
                }
                cs->hw.teles0.membase = ioremap(pci_resource_start(dev_tel, 0),
                        PAGE_SIZE);
-                printk(KERN_INFO "Found: Zoran, base-address: 0x%lx, irq: 0x%x\n",
+                printk(KERN_INFO "Found: Zoran, base-address: 0x%llx, irq: 0x%x\n",
-                        pci_resource_start(dev_tel, 0), dev_tel->irq);
+                        (unsigned long long)pci_resource_start(dev_tel, 0),
+                        dev_tel->irq);
        } else {
                printk(KERN_WARNING "TelesPCI: No PCI card found\n");
                return(0);
diff --git a/drivers/isdn/i4l/isdn_x25iface.c b/drivers/isdn/i4l/isdn_x25iface.c
index 743ac4077f35..8b3efc243161 100644
--- a/drivers/isdn/i4l/isdn_x25iface.c
+++ b/drivers/isdn/i4l/isdn_x25iface.c
@@ -208,7 +208,7 @@ static int isdn_x25iface_receive(struct concap_proto *cprot, struct sk_buff *skb
 */
 static int isdn_x25iface_connect_ind(struct concap_proto *cprot)
 {
-        struct sk_buff * skb = dev_alloc_skb(1);
+        struct sk_buff * skb;
        enum wan_states *state_p 
          = &( ( (ix25_pdata_t*) (cprot->proto_data) ) -> state);
        IX25DEBUG( "isdn_x25iface_connect_ind %s \n"
@@ -220,6 +220,8 @@ static int isdn_x25iface_connect_ind(struct concap_proto *cprot)
                return -1;
        }
        *state_p = WAN_CONNECTED;
+        skb = dev_alloc_skb(1);
        if( skb ){
                *( skb_put(skb, 1) ) = 0x01;
                skb->protocol = x25_type_trans(skb, cprot->net_dev);
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 431bd37225a1..c687ac703941 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -428,10 +428,10 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
        /* MacIO itself has a different reg, we use it's PCI base */
        if (np == chip->of_node) {
-                sprintf(dev->ofdev.dev.bus_id, "%1d.%08lx:%.*s",
+                sprintf(dev->ofdev.dev.bus_id, "%1d.%016llx:%.*s",
                        chip->lbus.index,
 #ifdef CONFIG_PCI
-                        pci_resource_start(chip->lbus.pdev, 0),
+                        (unsigned long long)pci_resource_start(chip->lbus.pdev, 0),
 #else
                        0, /* NuBus may want to do something better here */
 #endif
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index f920e50ea124..837ec4eb3d60 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2827,7 +2827,6 @@ static inline sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *ski
        struct stripe_head *sh;
        int pd_idx;
        int raid_disks = conf->raid_disks;
-        int data_disks = raid_disks - conf->max_degraded;
        sector_t max_sector = mddev->size << 1;
        int sync_blocks;
        int still_degraded = 0;
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 423e954948be..aa3203ae670c 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -4019,8 +4019,9 @@ static int __devinit bttv_probe(struct pci_dev *dev,
        if (!request_mem_region(pci_resource_start(dev,0),
                                pci_resource_len(dev,0),
                                btv->c.name)) {
-                printk(KERN_WARNING "bttv%d: can't request iomem (0x%lx).\n",
+                printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
-                       btv->c.nr, pci_resource_start(dev,0));
+                       btv->c.nr,
+                       (unsigned long long)pci_resource_start(dev,0));
                return -EBUSY;
        }
        pci_set_master(dev);
@@ -4031,8 +4032,9 @@ static int __devinit bttv_probe(struct pci_dev *dev,
        pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
        printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
               bttv_num,btv->id, btv->revision, pci_name(dev));
-        printk("irq: %d, latency: %d, mmio: 0x%lx\n",
+        printk("irq: %d, latency: %d, mmio: 0x%llx\n",
-               btv->c.pci->irq, lat, pci_resource_start(dev,0));
+               btv->c.pci->irq, lat,
+               (unsigned long long)pci_resource_start(dev,0));
        schedule();
        btv->bt848_mmio=ioremap(pci_resource_start(dev,0), 0x1000);
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index 2194cbeca33b..292a5e81eb75 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -712,9 +712,9 @@ static int __devinit snd_cx88_create(struct snd_card *card,
        pci_read_config_byte(pci, PCI_LATENCY_TIMER,  &chip->pci_lat);
        dprintk(1,"ALSA %s/%i: found at %s, rev: %d, irq: %d, "
-               "latency: %d, mmio: 0x%lx\n", core->name, devno,
+               "latency: %d, mmio: 0x%llx\n", core->name, devno,
               pci_name(pci), chip->pci_rev, pci->irq,
-               chip->pci_lat,pci_resource_start(pci,0));
+               chip->pci_lat,(unsigned long long)pci_resource_start(pci,0));
        chip->irq = pci->irq;
        synchronize_irq(chip->irq);
@@ -766,8 +766,8 @@ static int __devinit cx88_audio_initdev(struct pci_dev *pci,
        strcpy (card->driver, "CX88x");
        sprintf(card->shortname, "Conexant CX%x", pci->device);
-        sprintf(card->longname, "%s at %#lx",
+        sprintf(card->longname, "%s at %#llx",
-                card->shortname, pci_resource_start(pci, 0));
+                card->shortname,(unsigned long long)pci_resource_start(pci, 0));
        strcpy (card->mixername, "CX88");
        dprintk (0, "%s/%i: ALSA support for cx2388x boards\n",
diff --git a/drivers/media/video/cx88/cx88-core.c b/drivers/media/video/cx88/cx88-core.c
index 26f4c0fb8c36..973d3f39b2d5 100644
--- a/drivers/media/video/cx88/cx88-core.c
+++ b/drivers/media/video/cx88/cx88-core.c
@@ -1031,8 +1031,8 @@ static int get_ressources(struct cx88_core *core, struct pci_dev *pci)
                               pci_resource_len(pci,0),
                               core->name))
                return 0;
-        printk(KERN_ERR "%s: can't get MMIO memory @ 0x%lx\n",
+        printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
-               core->name,pci_resource_start(pci,0));
+               core->name,(unsigned long long)pci_resource_start(pci,0));
        return -EBUSY;
 }
diff --git a/drivers/media/video/cx88/cx88-mpeg.c b/drivers/media/video/cx88/cx88-mpeg.c
index a9d7795a8e14..2c12aca1b6a3 100644
--- a/drivers/media/video/cx88/cx88-mpeg.c
+++ b/drivers/media/video/cx88/cx88-mpeg.c
@@ -420,9 +420,9 @@ int cx8802_init_common(struct cx8802_dev *dev)
        pci_read_config_byte(dev->pci, PCI_CLASS_REVISION, &dev->pci_rev);
        pci_read_config_byte(dev->pci, PCI_LATENCY_TIMER,  &dev->pci_lat);
        printk(KERN_INFO "%s/2: found at %s, rev: %d, irq: %d, "
-               "latency: %d, mmio: 0x%lx\n", dev->core->name,
+               "latency: %d, mmio: 0x%llx\n", dev->core->name,
               pci_name(dev->pci), dev->pci_rev, dev->pci->irq,
-               dev->pci_lat,pci_resource_start(dev->pci,0));
+               dev->pci_lat,(unsigned long long)pci_resource_start(dev->pci,0));
        /* initialize driver struct */
        spin_lock_init(&dev->slock);
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index dcda5291b990..8d5cf474b68e 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -1847,9 +1847,9 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
        pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
        pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
        printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
-               "latency: %d, mmio: 0x%lx\n", core->name,
+               "latency: %d, mmio: 0x%llx\n", core->name,
               pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
-               dev->pci_lat,pci_resource_start(pci_dev,0));
+               dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
        pci_set_master(pci_dev);
        if (!pci_dma_supported(pci_dev,0xffffffff)) {
diff --git a/drivers/media/video/saa7134/saa7134-core.c b/drivers/media/video/saa7134/saa7134-core.c
index f0c2111f14ad..da3007d2f411 100644
--- a/drivers/media/video/saa7134/saa7134-core.c
+++ b/drivers/media/video/saa7134/saa7134-core.c
@@ -871,9 +871,9 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
        pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
        pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
        printk(KERN_INFO "%s: found at %s, rev: %d, irq: %d, "
-               "latency: %d, mmio: 0x%lx\n", dev->name,
+               "latency: %d, mmio: 0x%llx\n", dev->name,
               pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
-               dev->pci_lat,pci_resource_start(pci_dev,0));
+               dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
        pci_set_master(pci_dev);
        if (!pci_dma_supported(pci_dev, DMA_32BIT_MASK)) {
                printk("%s: Oops: no 32bit PCI DMA ???\n",dev->name);
@@ -905,8 +905,8 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
                                pci_resource_len(pci_dev,0),
                                dev->name)) {
                err = -EBUSY;
-                printk(KERN_ERR "%s: can't get MMIO memory @ 0x%lx\n",
+                printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
-                       dev->name,pci_resource_start(pci_dev,0));
+                       dev->name,(unsigned long long)pci_resource_start(pci_dev,0));
                goto fail1;
        }
        dev->lmmio = ioremap(pci_resource_start(pci_dev,0), 0x1000);
diff --git a/drivers/message/i2o/iop.c b/drivers/message/i2o/iop.c
index c74e5460f834..3305c12372a2 100644
--- a/drivers/message/i2o/iop.c
+++ b/drivers/message/i2o/iop.c
@@ -683,9 +683,10 @@ static int i2o_iop_systab_set(struct i2o_controller *c)
                        c->mem_alloc = 1;
                        sb->current_mem_size = 1 + res->end - res->start;
                        sb->current_mem_base = res->start;
-                        osm_info("%s: allocated %ld bytes of PCI memory at "
+                        osm_info("%s: allocated %llu bytes of PCI memory at "
-                                 "0x%08lX.\n", c->name,
+                                "0x%016llX.\n", c->name,
-                                 1 + res->end - res->start, res->start);
+                                (unsigned long long)(1 + res->end - res->start),
+                                (unsigned long long)res->start);
                }
        }
@@ -704,9 +705,10 @@ static int i2o_iop_systab_set(struct i2o_controller *c)
                        c->io_alloc = 1;
                        sb->current_io_size = 1 + res->end - res->start;
                        sb->current_mem_base = res->start;
-                        osm_info("%s: allocated %ld bytes of PCI I/O at 0x%08lX"
+                        osm_info("%s: allocated %llu bytes of PCI I/O at "
-                                 ".\n", c->name, 1 + res->end - res->start,
+                                "0x%016llX.\n", c->name,
-                                 res->start);
+                                (unsigned long long)(1 + res->end - res->start),
+                                (unsigned long long)res->start);
                }
        }
diff --git a/drivers/mmc/mmci.c b/drivers/mmc/mmci.c
index da8e4d7339cc..8576a65ca1c3 100644
--- a/drivers/mmc/mmci.c
+++ b/drivers/mmc/mmci.c
@@ -546,9 +546,9 @@ static int mmci_probe(struct amba_device *dev, void *id)
        mmc_add_host(mmc);
-        printk(KERN_INFO "%s: MMCI rev %x cfg %02x at 0x%08lx irq %d,%d\n",
+        printk(KERN_INFO "%s: MMCI rev %x cfg %02x at 0x%016llx irq %d,%d\n",
                mmc_hostname(mmc), amba_rev(dev), amba_config(dev),
-                dev->res.start, dev->irq[0], dev->irq[1]);
+                (unsigned long long)dev->res.start, dev->irq[0], dev->irq[1]);
        init_timer(&host->timer);
        host->timer.data = (unsigned long)host;
diff --git a/drivers/mtd/devices/pmc551.c b/drivers/mtd/devices/pmc551.c
index f620d74f1004..30f07b473ae2 100644
--- a/drivers/mtd/devices/pmc551.c
+++ b/drivers/mtd/devices/pmc551.c
@@ -551,11 +551,11 @@ static u32 fixup_pmc551 (struct pci_dev *dev)
        /*
         * Some screen fun
         */
-        printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at 0x%lx\n",
+        printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at 0x%llx\n",
               (size<1024)?size:(size<1048576)?size>>10:size>>20,
               (size<1024)?'B':(size<1048576)?'K':'M',
               size, ((dcmd&(0x1<<3)) == 0)?"non-":"",
-               (dev->resource[0].start)&PCI_BASE_ADDRESS_MEM_MASK );
+               (unsigned long long)((dev->resource[0].start)&PCI_BASE_ADDRESS_MEM_MASK));
        /*
         * Check to see the state of the memory
@@ -685,8 +685,8 @@ static int __init init_pmc551(void)
                        break;
                }
-                printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%lX\n",
+                printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%llx\n",
-                                    PCI_Device->resource[0].start);
+                                    (unsigned long long)PCI_Device->resource[0].start);
                /*
                 * The PMC551 device acts VERY weird if you don't init it
diff --git a/drivers/mtd/maps/amd76xrom.c b/drivers/mtd/maps/amd76xrom.c
index c350878d4592..a50587005263 100644
--- a/drivers/mtd/maps/amd76xrom.c
+++ b/drivers/mtd/maps/amd76xrom.c
@@ -123,9 +123,10 @@ static int __devinit amd76xrom_init_one (struct pci_dev *pdev,
                window->rsrc.parent = NULL;
                printk(KERN_ERR MOD_NAME
                        " %s(): Unable to register resource"
-                        " 0x%.08lx-0x%.08lx - kernel bug?\n",
+                        " 0x%.16llx-0x%.16llx - kernel bug?\n",
                        __func__,
-                        window->rsrc.start, window->rsrc.end);
+                        (unsigned long long)window->rsrc.start,
+                        (unsigned long long)window->rsrc.end);
        }
 #if 0
diff --git a/drivers/mtd/maps/ichxrom.c b/drivers/mtd/maps/ichxrom.c
index ea5073781b3a..16732794edf3 100644
--- a/drivers/mtd/maps/ichxrom.c
+++ b/drivers/mtd/maps/ichxrom.c
@@ -177,9 +177,10 @@ static int __devinit ichxrom_init_one (struct pci_dev *pdev,
                window->rsrc.parent = NULL;
                printk(KERN_DEBUG MOD_NAME
                        ": %s(): Unable to register resource"
-                        " 0x%.08lx-0x%.08lx - kernel bug?\n",
+                        " 0x%.16llx-0x%.16llx - kernel bug?\n",
                        __func__,
-                        window->rsrc.start, window->rsrc.end);
+                        (unsigned long long)window->rsrc.start,
+                        (unsigned long long)window->rsrc.end);
        }
        /* Map the firmware hub into my address space. */
diff --git a/drivers/mtd/maps/scx200_docflash.c b/drivers/mtd/maps/scx200_docflash.c
index 28b8a571a91a..331a15859d71 100644
--- a/drivers/mtd/maps/scx200_docflash.c
+++ b/drivers/mtd/maps/scx200_docflash.c
@@ -164,8 +164,9 @@ static int __init init_scx200_docflash(void)
                outl(pmr, scx200_cb_base + SCx200_PMR);
        }
-        printk(KERN_INFO NAME ": DOCCS mapped at 0x%lx-0x%lx, width %d\n",
+        printk(KERN_INFO NAME ": DOCCS mapped at 0x%llx-0x%llx, width %d\n",
-               docmem.start, docmem.end, width);
+                        (unsigned long long)docmem.start,
+                        (unsigned long long)docmem.end, width);
        scx200_docflash_map.size = size;
        if (width == 8)
diff --git a/drivers/mtd/maps/sun_uflash.c b/drivers/mtd/maps/sun_uflash.c
index 24a03152d196..4db2055cee31 100644
--- a/drivers/mtd/maps/sun_uflash.c
+++ b/drivers/mtd/maps/sun_uflash.c
@@ -62,9 +62,10 @@ int uflash_devinit(struct linux_ebus_device *edev, struct device_node *dp)
                /* Non-CFI userflash device-- once I find one we
                 * can work on supporting it.
                 */
-                printk("%s: unsupported device at 0x%lx (%d regs): " \
+                printk("%s: unsupported device at 0x%llx (%d regs): " \
                        "email ebrower@usa.net\n",
-                       dp->full_name, res->start, edev->num_addrs);
+                       dp->full_name, (unsigned long long)res->start,
+                       edev->num_addrs);
                return -ENODEV;
        }
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index b467c383ae60..d2f808979a2b 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -1407,8 +1407,10 @@ static int __devinit vortex_probe1(struct device *gendev,
                }
                if (print_info) {
-                        printk(KERN_INFO "%s: CardBus functions mapped %8.8lx->%p\n",
+                        printk(KERN_INFO "%s: CardBus functions mapped "
-                                print_name, pci_resource_start(pdev, 2),
+                                "%16.16llx->%p\n",
+                                print_name,
+                                (unsigned long long)pci_resource_start(pdev, 2),
                                vp->cb_fn_base);
                }
                EL3WINDOW(2);
diff --git a/drivers/net/8139cp.c b/drivers/net/8139cp.c
index 0cdc830449d8..d26dd6a7062d 100644
--- a/drivers/net/8139cp.c
+++ b/drivers/net/8139cp.c
@@ -1823,7 +1823,7 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        struct cp_private *cp;
        int rc;
        void __iomem *regs;
-        long pciaddr;
+        resource_size_t pciaddr;
        unsigned int addr_len, i, pci_using_dac;
        u8 pci_rev;
@@ -1883,8 +1883,8 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        }
        if (pci_resource_len(pdev, 1) < CP_REGS_SIZE) {
                rc = -EIO;
-                printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %s\n",
+                printk(KERN_ERR PFX "MMIO resource (%llx) too small on pci dev %s\n",
-                       pci_resource_len(pdev, 1), pci_name(pdev));
+                       (unsigned long long)pci_resource_len(pdev, 1), pci_name(pdev));
                goto err_out_res;
        }
@@ -1916,8 +1916,9 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        regs = ioremap(pciaddr, CP_REGS_SIZE);
        if (!regs) {
                rc = -EIO;
-                printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %s\n",
+                printk(KERN_ERR PFX "Cannot map PCI MMIO (%llx@%llx) on pci dev %s\n",
-                       pci_resource_len(pdev, 1), pciaddr, pci_name(pdev));
+                        (unsigned long long)pci_resource_len(pdev, 1),
+                        (unsigned long long)pciaddr, pci_name(pdev));
                goto err_out_res;
        }
        dev->base_addr = (unsigned long) regs;
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index abd6261465f1..ed2e3c03bc88 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -1341,9 +1341,9 @@ static int rtl8139_open (struct net_device *dev)
        netif_start_queue (dev);
        if (netif_msg_ifup(tp))
-                printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#lx IRQ %d"
+                printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#llx IRQ %d"
-                        " GP Pins %2.2x %s-duplex.\n",
+                        " GP Pins %2.2x %s-duplex.\n", dev->name,
-                        dev->name, pci_resource_start (tp->pci_dev, 1),
+                        (unsigned long long)pci_resource_start (tp->pci_dev, 1),
                        dev->irq, RTL_R8 (MediaStatus),
                        tp->mii.full_duplex ? "full" : "half");
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index f37170cc1a37..93a286570923 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2678,9 +2678,9 @@ static int __devinit e100_probe(struct pci_dev *pdev,
                goto err_out_free;
        }
-        DPRINTK(PROBE, INFO, "addr 0x%lx, irq %d, "
+        DPRINTK(PROBE, INFO, "addr 0x%llx, irq %d, "
                "MAC addr %02X:%02X:%02X:%02X:%02X:%02X\n",
-                pci_resource_start(pdev, 0), pdev->irq,
+                (unsigned long long)pci_resource_start(pdev, 0), pdev->irq,
                netdev->dev_addr[0], netdev->dev_addr[1], netdev->dev_addr[2],
                netdev->dev_addr[3], netdev->dev_addr[4], netdev->dev_addr[5]);
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 19a4a16055dc..1608efab4e3d 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -3354,8 +3354,8 @@ static int __devinit skge_probe(struct pci_dev *pdev,
        if (err)
                goto err_out_free_irq;
-        printk(KERN_INFO PFX DRV_VERSION " addr 0x%lx irq %d chip %s rev %d\n",
+        printk(KERN_INFO PFX DRV_VERSION " addr 0x%llx irq %d chip %s rev %d\n",
-               pci_resource_start(pdev, 0), pdev->irq,
+               (unsigned long long)pci_resource_start(pdev, 0), pdev->irq,
               skge_board_name(hw), hw->chip_rev);
        if ((dev = skge_devinit(hw, 0, using_dac)) == NULL)
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index d3577871be28..e122007e16da 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -3311,9 +3311,9 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
        if (err)
                goto err_out_iounmap;
-        printk(KERN_INFO PFX "v%s addr 0x%lx irq %d Yukon-%s (0x%x) rev %d\n",
+        printk(KERN_INFO PFX "v%s addr 0x%llx irq %d Yukon-%s (0x%x) rev %d\n",
-               DRV_VERSION, pci_resource_start(pdev, 0), pdev->irq,
+               DRV_VERSION, (unsigned long long)pci_resource_start(pdev, 0),
-               yukon2_name[hw->chip_id - CHIP_ID_YUKON_XL],
+               pdev->irq, yukon2_name[hw->chip_id - CHIP_ID_YUKON_XL],
               hw->chip_id, hw->chip_rev);
        dev = sky2_init_netdev(hw, 0, using_dac);
diff --git a/drivers/net/tulip/de2104x.c b/drivers/net/tulip/de2104x.c
index 5f743b972949..fc2468ecce0b 100644
--- a/drivers/net/tulip/de2104x.c
+++ b/drivers/net/tulip/de2104x.c
@@ -2007,8 +2007,8 @@ static int __init de_init_one (struct pci_dev *pdev,
        }
        if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
                rc = -EIO;
-                printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %s\n",
+                printk(KERN_ERR PFX "MMIO resource (%llx) too small on pci dev %s\n",
-                       pci_resource_len(pdev, 1), pci_name(pdev));
+                       (unsigned long long)pci_resource_len(pdev, 1), pci_name(pdev));
                goto err_out_res;
        }
@@ -2016,8 +2016,9 @@ static int __init de_init_one (struct pci_dev *pdev,
        regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
        if (!regs) {
                rc = -EIO;
-                printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %s\n",
+                printk(KERN_ERR PFX "Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
-                       pci_resource_len(pdev, 1), pciaddr, pci_name(pdev));
+                        (unsigned long long)pci_resource_len(pdev, 1),
+                        pciaddr, pci_name(pdev));
                goto err_out_res;
        }
        dev->base_addr = (unsigned long) regs;
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index e0de66739a42..53fd9b56d0bd 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -1350,10 +1350,10 @@ static int __devinit tulip_init_one (struct pci_dev *pdev,
        SET_MODULE_OWNER(dev);
        SET_NETDEV_DEV(dev, &pdev->dev);
        if (pci_resource_len (pdev, 0) < tulip_tbl[chip_idx].io_size) {
-                printk (KERN_ERR PFX "%s: I/O region (0x%lx@0x%lx) too small, "
+                printk (KERN_ERR PFX "%s: I/O region (0x%llx@0x%llx) too small, "
                        "aborting\n", pci_name(pdev),
-                        pci_resource_len (pdev, 0),
+                        (unsigned long long)pci_resource_len (pdev, 0),
-                        pci_resource_start (pdev, 0));
+                        (unsigned long long)pci_resource_start (pdev, 0));
                goto err_out_free_netdev;
        }
diff --git a/drivers/net/typhoon.c b/drivers/net/typhoon.c
index e49e8b520c28..e24d2dafcf6c 100644
--- a/drivers/net/typhoon.c
+++ b/drivers/net/typhoon.c
@@ -2568,9 +2568,10 @@ typhoon_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        pci_set_drvdata(pdev, dev);
-        printk(KERN_INFO "%s: %s at %s 0x%lx, ",
+        printk(KERN_INFO "%s: %s at %s 0x%llx, ",
               dev->name, typhoon_card_info[card_id].name,
-               use_mmio ? "MMIO" : "IO", pci_resource_start(pdev, use_mmio));
+               use_mmio ? "MMIO" : "IO",
+               (unsigned long long)pci_resource_start(pdev, use_mmio));
        for(i = 0; i < 5; i++)
                printk("%2.2x:", dev->dev_addr[i]);
        printk("%2.2x\n", dev->dev_addr[i]);
diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index 4505540e3c59..04a376ec0ed8 100644
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -732,15 +732,15 @@ static int __devinit dscc4_init_one(struct pci_dev *pdev,
        ioaddr = ioremap(pci_resource_start(pdev, 0),
                                        pci_resource_len(pdev, 0));
        if (!ioaddr) {
-                printk(KERN_ERR "%s: cannot remap MMIO region %lx @ %lx\n",
+                printk(KERN_ERR "%s: cannot remap MMIO region %llx @ %llx\n",
-                        DRV_NAME, pci_resource_len(pdev, 0),
+                        DRV_NAME, (unsigned long long)pci_resource_len(pdev, 0),
-                        pci_resource_start(pdev, 0));
+                        (unsigned long long)pci_resource_start(pdev, 0));
                rc = -EIO;
                goto err_free_mmio_regions_2;
        }
-        printk(KERN_DEBUG "Siemens DSCC4, MMIO at %#lx (regs), %#lx (lbi), IRQ %d\n",
+        printk(KERN_DEBUG "Siemens DSCC4, MMIO at %#llx (regs), %#llx (lbi), IRQ %d\n",
-                pci_resource_start(pdev, 0),
+                (unsigned long long)pci_resource_start(pdev, 0),
-                pci_resource_start(pdev, 1), pdev->irq);
+                (unsigned long long)pci_resource_start(pdev, 1), pdev->irq);
        /* Cf errata DS5 p.2 */
        pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0xf8);
diff --git a/drivers/net/wan/pc300_drv.c b/drivers/net/wan/pc300_drv.c
index a3e65d1bc19b..d7897ae89f90 100644
--- a/drivers/net/wan/pc300_drv.c
+++ b/drivers/net/wan/pc300_drv.c
@@ -3445,9 +3445,9 @@ cpc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        card = (pc300_t *) kmalloc(sizeof(pc300_t), GFP_KERNEL);
        if (card == NULL) {
-                printk("PC300 found at RAM 0x%08lx, "
+                printk("PC300 found at RAM 0x%016llx, "
                       "but could not allocate card structure.\n",
-                       pci_resource_start(pdev, 3));
+                       (unsigned long long)pci_resource_start(pdev, 3));
                err = -ENOMEM;
                goto err_disable_dev;
        }
diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
index 6e8ed0c81a6c..ce0a6ebcff15 100644
--- a/drivers/parisc/dino.c
+++ b/drivers/parisc/dino.c
@@ -299,7 +299,7 @@ struct pci_port_ops dino_port_ops = {
 static void dino_disable_irq(unsigned int irq)
 {
-        struct dino_device *dino_dev = irq_desc[irq].handler_data;
+        struct dino_device *dino_dev = irq_desc[irq].chip_data;
        int local_irq = gsc_find_local_irq(irq, dino_dev->global_irq, DINO_LOCAL_IRQS);
        DBG(KERN_WARNING "%s(0x%p, %d)\n", __FUNCTION__, dino_dev, irq);
@@ -311,7 +311,7 @@ static void dino_disable_irq(unsigned int irq)
 static void dino_enable_irq(unsigned int irq)
 {
-        struct dino_device *dino_dev = irq_desc[irq].handler_data;
+        struct dino_device *dino_dev = irq_desc[irq].chip_data;
        int local_irq = gsc_find_local_irq(irq, dino_dev->global_irq, DINO_LOCAL_IRQS);
        u32 tmp;
diff --git a/drivers/parisc/eisa.c b/drivers/parisc/eisa.c
index 9d3bd15bf53b..58f0ce8d78e0 100644
--- a/drivers/parisc/eisa.c
+++ b/drivers/parisc/eisa.c
@@ -350,7 +350,7 @@ static int __devinit eisa_probe(struct parisc_device *dev)
        irq_desc[2].action = &irq2_action;
        
        for (i = 0; i < 16; i++) {
-                irq_desc[i].handler = &eisa_interrupt_type;
+                irq_desc[i].chip = &eisa_interrupt_type;
        }
        
        EISA_bus = 1;
diff --git a/drivers/parisc/gsc.c b/drivers/parisc/gsc.c
index 16d40f95978d..5476ba7709b3 100644
--- a/drivers/parisc/gsc.c
+++ b/drivers/parisc/gsc.c
@@ -109,7 +109,7 @@ int gsc_find_local_irq(unsigned int irq, int *global_irqs, int limit)
 static void gsc_asic_disable_irq(unsigned int irq)
 {
-        struct gsc_asic *irq_dev = irq_desc[irq].handler_data;
+        struct gsc_asic *irq_dev = irq_desc[irq].chip_data;
        int local_irq = gsc_find_local_irq(irq, irq_dev->global_irq, 32);
        u32 imr;
@@ -124,7 +124,7 @@ static void gsc_asic_disable_irq(unsigned int irq)
 static void gsc_asic_enable_irq(unsigned int irq)
 {
-        struct gsc_asic *irq_dev = irq_desc[irq].handler_data;
+        struct gsc_asic *irq_dev = irq_desc[irq].chip_data;
        int local_irq = gsc_find_local_irq(irq, irq_dev->global_irq, 32);
        u32 imr;
@@ -164,8 +164,8 @@ int gsc_assign_irq(struct hw_interrupt_type *type, void *data)
        if (irq > GSC_IRQ_MAX)
                return NO_IRQ;
-        irq_desc[irq].handler = type;
+        irq_desc[irq].chip = type;
-        irq_desc[irq].handler_data = data;
+        irq_desc[irq].chip_data = data;
        return irq++;
 }
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 7a458d5bc751..1fbda77cefc2 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -619,7 +619,7 @@ iosapic_set_irt_data( struct vector_info *vi, u32 *dp0, u32 *dp1)
 static struct vector_info *iosapic_get_vector(unsigned int irq)
 {
-        return irq_desc[irq].handler_data;
+        return irq_desc[irq].chip_data;
 }
 static void iosapic_disable_irq(unsigned int irq)
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index 828eb45062de..a988dc7a9abd 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -360,7 +360,7 @@ int superio_fixup_irq(struct pci_dev *pcidev)
 #endif
        for (i = 0; i < 16; i++) {
-                irq_desc[i].handler = &superio_interrupt_type;
+                irq_desc[i].chip = &superio_interrupt_type;
        }
        /*
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index 723092682023..5f7db9d2436e 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -34,11 +34,11 @@
 */
 int
 pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
-        unsigned long size, unsigned long align, unsigned long min,
+                resource_size_t size, resource_size_t align,
-        unsigned int type_mask,
+                resource_size_t min, unsigned int type_mask,
-        void (*alignf)(void *, struct resource *,
+                void (*alignf)(void *, struct resource *, resource_size_t,
-                        unsigned long, unsigned long),
+                                resource_size_t),
-        void *alignf_data)
+                void *alignf_data)
 {
        int i, ret = -ENOMEM;
diff --git a/drivers/pci/hotplug/cpcihp_zt5550.c b/drivers/pci/hotplug/cpcihp_zt5550.c
index f7cb00da38df..1ec165df8522 100644
--- a/drivers/pci/hotplug/cpcihp_zt5550.c
+++ b/drivers/pci/hotplug/cpcihp_zt5550.c
@@ -95,8 +95,8 @@ static int zt5550_hc_config(struct pci_dev *pdev)
        hc_dev = pdev;
        dbg("hc_dev = %p", hc_dev);
-        dbg("pci resource start %lx", pci_resource_start(hc_dev, 1));
+        dbg("pci resource start %llx", (unsigned long long)pci_resource_start(hc_dev, 1));
-        dbg("pci resource len %lx", pci_resource_len(hc_dev, 1));
+        dbg("pci resource len %llx", (unsigned long long)pci_resource_len(hc_dev, 1));
        if(!request_mem_region(pci_resource_start(hc_dev, 1),
                                pci_resource_len(hc_dev, 1), MY_NAME)) {
@@ -108,8 +108,9 @@ static int zt5550_hc_config(struct pci_dev *pdev)
        hc_registers =
            ioremap(pci_resource_start(hc_dev, 1), pci_resource_len(hc_dev, 1));
        if(!hc_registers) {
-                err("cannot remap MMIO region %lx @ %lx",
+                err("cannot remap MMIO region %llx @ %llx",
-                    pci_resource_len(hc_dev, 1), pci_resource_start(hc_dev, 1));
+                        (unsigned long long)pci_resource_len(hc_dev, 1),
+                        (unsigned long long)pci_resource_start(hc_dev, 1));
                ret = -ENODEV;
                goto exit_release_region;
        }
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 9bc1deb8df52..f8658d63f077 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -1089,8 +1089,8 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        }
        
        dbg("pdev = %p\n", pdev);
-        dbg("pci resource start %lx\n", pci_resource_start(pdev, 0));
+        dbg("pci resource start %llx\n", (unsigned long long)pci_resource_start(pdev, 0));
-        dbg("pci resource len %lx\n", pci_resource_len(pdev, 0));
+        dbg("pci resource len %llx\n", (unsigned long long)pci_resource_len(pdev, 0));
        if (!request_mem_region(pci_resource_start(pdev, 0),
                                pci_resource_len(pdev, 0), MY_NAME)) {
@@ -1102,9 +1102,9 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        ctrl->hpc_reg = ioremap(pci_resource_start(pdev, 0),
                                        pci_resource_len(pdev, 0));
        if (!ctrl->hpc_reg) {
-                err("cannot remap MMIO region %lx @ %lx\n",
+                err("cannot remap MMIO region %llx @ %llx\n",
-                                pci_resource_len(pdev, 0),
+                    (unsigned long long)pci_resource_len(pdev, 0),
-                                pci_resource_start(pdev, 0));
+                    (unsigned long long)pci_resource_start(pdev, 0));
                rc = -ENODEV;
                goto err_free_mem_region;
        }
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index d77138ecb098..11f7858f0064 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -1398,8 +1398,9 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
        for ( rc = 0; rc < DEVICE_COUNT_RESOURCE; rc++)
                if (pci_resource_len(pdev, rc) > 0)
-                        dbg("pci resource[%d] start=0x%lx(len=0x%lx)\n", rc,
+                        dbg("pci resource[%d] start=0x%llx(len=0x%llx)\n", rc,
-                                pci_resource_start(pdev, rc), pci_resource_len(pdev, rc));
+                            (unsigned long long)pci_resource_start(pdev, rc),
+                            (unsigned long long)pci_resource_len(pdev, rc));
        info("HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n", pdev->vendor, pdev->device, 
                pdev->subsystem_vendor, pdev->subsystem_device);
diff --git a/drivers/pci/hotplug/shpchp_sysfs.c b/drivers/pci/hotplug/shpchp_sysfs.c
index f5cfbf2c047c..620e1139e607 100644
--- a/drivers/pci/hotplug/shpchp_sysfs.c
+++ b/drivers/pci/hotplug/shpchp_sysfs.c
@@ -51,8 +51,10 @@ static ssize_t show_ctrl (struct device *dev, struct device_attribute *attr, cha
                res = bus->resource[index];
                if (res && (res->flags & IORESOURCE_MEM) &&
                                !(res->flags & IORESOURCE_PREFETCH)) {
-                        out += sprintf(out, "start = %8.8lx, length = %8.8lx\n",
+                        out += sprintf(out, "start = %8.8llx, "
-                                        res->start, (res->end - res->start));
+                                        "length = %8.8llx\n",
+                                        (unsigned long long)res->start,
+                                        (unsigned long long)(res->end - res->start));
                }
        }
        out += sprintf(out, "Free resources: prefetchable memory\n");
@@ -60,16 +62,20 @@ static ssize_t show_ctrl (struct device *dev, struct device_attribute *attr, cha
                res = bus->resource[index];
                if (res && (res->flags & IORESOURCE_MEM) &&
                               (res->flags & IORESOURCE_PREFETCH)) {
-                        out += sprintf(out, "start = %8.8lx, length = %8.8lx\n",
+                        out += sprintf(out, "start = %8.8llx, "
-                                        res->start, (res->end - res->start));
+                                        "length = %8.8llx\n",
+                                        (unsigned long long)res->start,
+                                        (unsigned long long)(res->end - res->start));
                }
        }
        out += sprintf(out, "Free resources: IO\n");
        for (index = 0; index < PCI_BUS_NUM_RESOURCES; index++) {
                res = bus->resource[index];
                if (res && (res->flags & IORESOURCE_IO)) {
-                        out += sprintf(out, "start = %8.8lx, length = %8.8lx\n",
+                        out += sprintf(out, "start = %8.8llx, "
-                                        res->start, (res->end - res->start));
+                                        "length = %8.8llx\n",
+                                        (unsigned long long)res->start,
+                                        (unsigned long long)(res->end - res->start));
                }
        }
        out += sprintf(out, "Free resources: bus numbers\n");
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 7f8429284fab..76d023d8a33b 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -429,12 +429,12 @@ static void irq_handler_init(int cap_id, int pos, int mask)
        spin_lock_irqsave(&irq_desc[pos].lock, flags);
        if (cap_id == PCI_CAP_ID_MSIX)
-                irq_desc[pos].handler = &msix_irq_type;
+                irq_desc[pos].chip = &msix_irq_type;
        else {
                if (!mask)
-                        irq_desc[pos].handler = &msi_irq_wo_maskbit_type;
+                        irq_desc[pos].chip = &msi_irq_wo_maskbit_type;
                else
-                        irq_desc[pos].handler = &msi_irq_w_maskbit_type;
+                        irq_desc[pos].chip = &msi_irq_w_maskbit_type;
        }
        spin_unlock_irqrestore(&irq_desc[pos].lock, flags);
 }
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index bc405c035ce3..606f9b6f70eb 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -87,7 +87,7 @@ resource_show(struct device * dev, struct device_attribute *attr, char * buf)
        char * str = buf;
        int i;
        int max = 7;
-        u64 start, end;
+        resource_size_t start, end;
        if (pci_dev->subordinate)
                max = DEVICE_COUNT_RESOURCE;
@@ -365,7 +365,7 @@ pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,
                                                       struct device, kobj));
        struct resource *res = (struct resource *)attr->private;
        enum pci_mmap_state mmap_type;
-        u64 start, end;
+        resource_size_t start, end;
        int i;
        for (i = 0; i < PCI_ROM_RESOURCE; i++)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 23d3b17c8cad..cf57d7de3765 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -691,10 +691,12 @@ int pci_request_region(struct pci_dev *pdev, int bar, const char *res_name)
        return 0;
 err_out:
-        printk (KERN_WARNING "PCI: Unable to reserve %s region #%d:%lx@%lx for device %s\n",
+        printk (KERN_WARNING "PCI: Unable to reserve %s region #%d:%llx@%llx "
+                "for device %s\n",
                pci_resource_flags(pdev, bar) & IORESOURCE_IO ? "I/O" : "mem",
                bar + 1, /* PCI BAR # */
-                pci_resource_len(pdev, bar), pci_resource_start(pdev, bar),
+                (unsigned long long)pci_resource_len(pdev, bar),
+                (unsigned long long)pci_resource_start(pdev, bar),
                pci_name(pdev));
        return -EBUSY;
 }
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 29bdeca031a8..9cc842b666eb 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -6,10 +6,10 @@ extern int pci_create_sysfs_dev_files(struct pci_dev *pdev);
 extern void pci_remove_sysfs_dev_files(struct pci_dev *pdev);
 extern void pci_cleanup_rom(struct pci_dev *dev);
 extern int pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
-                                  unsigned long size, unsigned long align,
+                                  resource_size_t size, resource_size_t align,
-                                  unsigned long min, unsigned int type_mask,
+                                  resource_size_t min, unsigned int type_mask,
                                  void (*alignf)(void *, struct resource *,
-                                                 unsigned long, unsigned long),
+                                              resource_size_t, resource_size_t),
                                  void *alignf_data);
 /* Firmware callbacks */
 extern int (*platform_pci_choose_state)(struct pci_dev *dev, pm_message_t state);
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index 54b2ebc9c91a..99cf33379769 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -302,12 +302,6 @@ static struct file_operations proc_bus_pci_operations = {
 #endif /* HAVE_PCI_MMAP */
 };
-#if BITS_PER_LONG == 32
-#define LONG_FORMAT "\t%08lx"
-#else
-#define LONG_FORMAT "\t%16lx"
-#endif
 /* iterator */
 static void *pci_seq_start(struct seq_file *m, loff_t *pos)
 {
@@ -356,18 +350,18 @@ static int show_device(struct seq_file *m, void *v)
                        dev->irq);
        /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
        for (i=0; i<7; i++) {
-                u64 start, end;
+                resource_size_t start, end;
                pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
-                seq_printf(m, LONG_FORMAT,
+                seq_printf(m, "\t%16llx",
-                        ((unsigned long)start) |
+                        (unsigned long long)(start |
-                        (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
+                        (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
        }
        for (i=0; i<7; i++) {
-                u64 start, end;
+                resource_size_t start, end;
                pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
-                seq_printf(m, LONG_FORMAT,
+                seq_printf(m, "\t%16llx",
                        dev->resource[i].start < dev->resource[i].end ?
-                        (unsigned long)(end - start) + 1 : 0);
+                        (unsigned long long)(end - start) + 1 : 0);
        }
        seq_putc(m, '\t');
        if (drv)
diff --git a/drivers/pci/rom.c b/drivers/pci/rom.c
index 598a115cd00e..cbb69cf41311 100644
--- a/drivers/pci/rom.c
+++ b/drivers/pci/rom.c
@@ -80,8 +80,8 @@ void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size)
        } else {
                if (res->flags & IORESOURCE_ROM_COPY) {
                        *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
-                        return (void __iomem *)pci_resource_start(pdev,
+                        return (void __iomem *)(unsigned long)
-                                                             PCI_ROM_RESOURCE);
+                                pci_resource_start(pdev, PCI_ROM_RESOURCE);
                } else {
                        /* assign the ROM an address if it doesn't have one */
                        if (res->parent == NULL &&
@@ -170,11 +170,11 @@ void __iomem *pci_map_rom_copy(struct pci_dev *pdev, size_t *size)
                return rom;
        res->end = res->start + *size;
-        memcpy_fromio((void*)res->start, rom, *size);
+        memcpy_fromio((void*)(unsigned long)res->start, rom, *size);
        pci_unmap_rom(pdev, rom);
        res->flags |= IORESOURCE_ROM_COPY;
-        return (void __iomem *)res->start;
+        return (void __iomem *)(unsigned long)res->start;
 }
 /**
@@ -227,7 +227,7 @@ void pci_cleanup_rom(struct pci_dev *pdev)
 {
        struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
        if (res->flags & IORESOURCE_ROM_COPY) {
-                kfree((void*)res->start);
+                kfree((void*)(unsigned long)res->start);
                res->flags &= ~IORESOURCE_ROM_COPY;
                res->start = 0;
                res->end = 0;
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 35086e80faa9..47c1071ad84e 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -357,8 +357,10 @@ pbus_size_mem(struct pci_bus *bus, unsigned long mask, unsigned long type)
                        order = __ffs(align) - 20;
                        if (order > 11) {
                                printk(KERN_WARNING "PCI: region %s/%d "
-                                       "too large: %lx-%lx\n",
+                                       "too large: %llx-%llx\n",
-                                       pci_name(dev), i, r->start, r->end);
+                                        pci_name(dev), i,
+                                        (unsigned long long)r->start,
+                                        (unsigned long long)r->end);
                                r->flags = 0;
                                continue;
                        }
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 577f4b55c46d..ab78e4bbdd83 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -40,8 +40,9 @@ pci_update_resource(struct pci_dev *dev, struct resource *res, int resno)
        pcibios_resource_to_bus(dev, &region, res);
-        pr_debug("  got res [%lx:%lx] bus [%lx:%lx] flags %lx for "
+        pr_debug("  got res [%llx:%llx] bus [%lx:%lx] flags %lx for "
-                 "BAR %d of %s\n", res->start, res->end,
+                 "BAR %d of %s\n", (unsigned long long)res->start,
+                 (unsigned long long)res->end,
                 region.start, region.end, res->flags, resno, pci_name(dev));
        new = region.start | (res->flags & PCI_REGION_FLAG_MASK);
@@ -104,10 +105,12 @@ pci_claim_resource(struct pci_dev *dev, int resource)
                err = insert_resource(root, res);
        if (err) {
-                printk(KERN_ERR "PCI: %s region %d of %s %s [%lx:%lx]\n",
+                printk(KERN_ERR "PCI: %s region %d of %s %s [%llx:%llx]\n",
-                       root ? "Address space collision on" :
+                        root ? "Address space collision on" :
-                              "No parent found for",
+                                "No parent found for",
-                       resource, dtype, pci_name(dev), res->start, res->end);
+                        resource, dtype, pci_name(dev),
+                        (unsigned long long)res->start,
+                        (unsigned long long)res->end);
        }
        return err;
@@ -118,7 +121,7 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
 {
        struct pci_bus *bus = dev->bus;
        struct resource *res = dev->resource + resno;
-        unsigned long size, min, align;
+        resource_size_t size, min, align;
        int ret;
        size = res->end - res->start + 1;
@@ -145,9 +148,11 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
        }
        if (ret) {
-                printk(KERN_ERR "PCI: Failed to allocate %s resource #%d:%lx@%lx for %s\n",
+                printk(KERN_ERR "PCI: Failed to allocate %s resource "
-                       res->flags & IORESOURCE_IO ? "I/O" : "mem",
+                        "#%d:%llx@%llx for %s\n",
-                       resno, size, res->start, pci_name(dev));
+                        res->flags & IORESOURCE_IO ? "I/O" : "mem",
+                        resno, (unsigned long long)size,
+                        (unsigned long long)res->start, pci_name(dev));
        } else if (resno < PCI_BRIDGE_RESOURCES) {
                pci_update_resource(dev, res, resno);
        }
@@ -204,7 +209,7 @@ pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
                struct resource *r;
                struct resource_list *list, *tmp;
-                unsigned long r_align;
+                resource_size_t r_align;
                r = &dev->resource[i];
                r_align = r->end - r->start;
@@ -213,13 +218,14 @@ pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
                        continue;
                if (!r_align) {
                        printk(KERN_WARNING "PCI: Ignore bogus resource %d "
-                                            "[%lx:%lx] of %s\n",
+                                "[%llx:%llx] of %s\n",
-                                            i, r->start, r->end, pci_name(dev));
+                                i, (unsigned long long)r->start,
+                                (unsigned long long)r->end, pci_name(dev));
                        continue;
                }
                r_align = (i < PCI_BRIDGE_RESOURCES) ? r_align + 1 : r->start;
                for (list = head; ; list = list->next) {
-                        unsigned long align = 0;
+                        resource_size_t align = 0;
                        struct resource_list *ln = list->next;
                        int idx;
diff --git a/drivers/pcmcia/hd64465_ss.c b/drivers/pcmcia/hd64465_ss.c
index b39435bbfaeb..c662e4f89d46 100644
--- a/drivers/pcmcia/hd64465_ss.c
+++ b/drivers/pcmcia/hd64465_ss.c
@@ -244,8 +244,8 @@ static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
        hs_mapped_irq[irq].sock = sp;
        /* insert ourselves as the irq controller */
-        hs_mapped_irq[irq].old_handler = irq_desc[irq].handler;
+        hs_mapped_irq[irq].old_handler = irq_desc[irq].chip;
-        irq_desc[irq].handler = &hd64465_ss_irq_type;
+        irq_desc[irq].chip = &hd64465_ss_irq_type;
 }
@@ -260,7 +260,7 @@ static void hs_unmap_irq(hs_socket_t *sp, unsigned int irq)
            return;
                
        /* restore the original irq controller */
-        irq_desc[irq].handler = hs_mapped_irq[irq].old_handler;
+        irq_desc[irq].chip = hs_mapped_irq[irq].old_handler;
 }
 /*============================================================*/
diff --git a/drivers/pcmcia/i82365.c b/drivers/pcmcia/i82365.c
index a2f05f485156..ff51a65d9433 100644
--- a/drivers/pcmcia/i82365.c
+++ b/drivers/pcmcia/i82365.c
@@ -1084,9 +1084,10 @@ static int i365_set_mem_map(u_short sock, struct pccard_mem_map *mem)
    u_short base, i;
    u_char map;
    
-    debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, %#lx-%#lx, "
+    debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, %#llx-%#llx, "
          "%#x)\n", sock, mem->map, mem->flags, mem->speed,
-          mem->res->start, mem->res->end, mem->card_start);
+          (unsigned long long)mem->res->start,
+          (unsigned long long)mem->res->end, mem->card_start);
    map = mem->map;
    if ((map > 4) || (mem->card_start > 0x3ffffff) ||
diff --git a/drivers/pcmcia/pd6729.c b/drivers/pcmcia/pd6729.c
index 247ab837f841..9ee26c1b8635 100644
--- a/drivers/pcmcia/pd6729.c
+++ b/drivers/pcmcia/pd6729.c
@@ -642,7 +642,8 @@ static int __devinit pd6729_pci_probe(struct pci_dev *dev,
                goto err_out_free_mem;
        printk(KERN_INFO "pd6729: Cirrus PD6729 PCI to PCMCIA Bridge "
-                "at 0x%lx on irq %d\n", pci_resource_start(dev, 0), dev->irq);
+                "at 0x%llx on irq %d\n",
+                (unsigned long long)pci_resource_start(dev, 0), dev->irq);
        /*
         * Since we have no memory BARs some firmware may not
         * have had PCI_COMMAND_MEMORY enabled, yet the device needs it.
diff --git a/drivers/pcmcia/rsrc_nonstatic.c b/drivers/pcmcia/rsrc_nonstatic.c
index 0f8b157c9717..c3176b16b7be 100644
--- a/drivers/pcmcia/rsrc_nonstatic.c
+++ b/drivers/pcmcia/rsrc_nonstatic.c
@@ -72,7 +72,7 @@ static DEFINE_MUTEX(rsrc_mutex);
 ======================================================================*/
 static struct resource *
-make_resource(unsigned long b, unsigned long n, int flags, char *name)
+make_resource(resource_size_t b, resource_size_t n, int flags, char *name)
 {
        struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
@@ -86,8 +86,8 @@ make_resource(unsigned long b, unsigned long n, int flags, char *name)
 }
 static struct resource *
-claim_region(struct pcmcia_socket *s, unsigned long base, unsigned long size,
+claim_region(struct pcmcia_socket *s, resource_size_t base,
-             int type, char *name)
+                resource_size_t size, int type, char *name)
 {
        struct resource *res, *parent;
@@ -519,10 +519,10 @@ struct pcmcia_align_data {
 static void
 pcmcia_common_align(void *align_data, struct resource *res,
-                    unsigned long size, unsigned long align)
+                        resource_size_t size, resource_size_t align)
 {
        struct pcmcia_align_data *data = align_data;
-        unsigned long start;
+        resource_size_t start;
        /*
         * Ensure that we have the correct start address
         */
@@ -533,8 +533,8 @@ pcmcia_common_align(void *align_data, struct resource *res,
 }
 static void
-pcmcia_align(void *align_data, struct resource *res,
+pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
-             unsigned long size, unsigned long align)
+                resource_size_t align)
 {
        struct pcmcia_align_data *data = align_data;
        struct resource_map *m;
@@ -808,8 +808,10 @@ static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
                if (res->flags & IORESOURCE_IO) {
                        if (res == &ioport_resource)
                                continue;
-                        printk(KERN_INFO "pcmcia: parent PCI bridge I/O window: 0x%lx - 0x%lx\n",
+                        printk(KERN_INFO "pcmcia: parent PCI bridge I/O "
-                               res->start, res->end);
+                                "window: 0x%llx - 0x%llx\n",
+                                (unsigned long long)res->start,
+                                (unsigned long long)res->end);
                        if (!adjust_io(s, ADD_MANAGED_RESOURCE, res->start, res->end))
                                done |= IORESOURCE_IO;
@@ -818,8 +820,10 @@ static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
                if (res->flags & IORESOURCE_MEM) {
                        if (res == &iomem_resource)
                                continue;
-                        printk(KERN_INFO "pcmcia: parent PCI bridge Memory window: 0x%lx - 0x%lx\n",
+                        printk(KERN_INFO "pcmcia: parent PCI bridge Memory "
-                               res->start, res->end);
+                                "window: 0x%llx - 0x%llx\n",
+                                (unsigned long long)res->start,
+                                (unsigned long long)res->end);
                        if (!adjust_memory(s, ADD_MANAGED_RESOURCE, res->start, res->end))
                                done |= IORESOURCE_MEM;
                }
diff --git a/drivers/pcmcia/tcic.c b/drivers/pcmcia/tcic.c
index 73bad1d5cb23..65a60671659f 100644
--- a/drivers/pcmcia/tcic.c
+++ b/drivers/pcmcia/tcic.c
@@ -756,8 +756,9 @@ static int tcic_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *m
    u_long base, len, mmap;
    debug(1, "SetMemMap(%d, %d, %#2.2x, %d ns, "
-          "%#lx-%#lx, %#x)\n", psock, mem->map, mem->flags,
+          "%#llx-%#llx, %#x)\n", psock, mem->map, mem->flags,
-          mem->speed, mem->res->start, mem->res->end, mem->card_start);
+          mem->speed, (unsigned long long)mem->res->start,
+          (unsigned long long)mem->res->end, mem->card_start);
    if ((mem->map > 3) || (mem->card_start > 0x3ffffff) ||
        (mem->res->start > 0xffffff) || (mem->res->end > 0xffffff) ||
        (mem->res->start > mem->res->end) || (mem->speed > 1000))
diff --git a/drivers/pnp/interface.c b/drivers/pnp/interface.c
index a2d8ce7fef9c..3163e3d73da1 100644
--- a/drivers/pnp/interface.c
+++ b/drivers/pnp/interface.c
@@ -264,7 +264,7 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
                        if (pnp_port_flags(dev, i) & IORESOURCE_DISABLED)
                                pnp_printf(buffer," disabled\n");
                        else
-                                pnp_printf(buffer," 0x%lx-0x%lx\n",
+                                pnp_printf(buffer," 0x%llx-0x%llx\n",
                                                pnp_port_start(dev, i),
                                                pnp_port_end(dev, i));
                }
@@ -275,7 +275,7 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
                        if (pnp_mem_flags(dev, i) & IORESOURCE_DISABLED)
                                pnp_printf(buffer," disabled\n");
                        else
-                                pnp_printf(buffer," 0x%lx-0x%lx\n",
+                                pnp_printf(buffer," 0x%llx-0x%llx\n",
                                                pnp_mem_start(dev, i),
                                                pnp_mem_end(dev, i));
                }
@@ -286,7 +286,7 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
                        if (pnp_irq_flags(dev, i) & IORESOURCE_DISABLED)
                                pnp_printf(buffer," disabled\n");
                        else
-                                pnp_printf(buffer," %ld\n",
+                                pnp_printf(buffer," %lld\n",
                                                pnp_irq(dev, i));
                }
        }
@@ -296,7 +296,7 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
                        if (pnp_dma_flags(dev, i) & IORESOURCE_DISABLED)
                                pnp_printf(buffer," disabled\n");
                        else
-                                pnp_printf(buffer," %ld\n",
+                                pnp_printf(buffer," %lld\n",
                                                pnp_dma(dev, i));
                }
        }
diff --git a/drivers/pnp/manager.c b/drivers/pnp/manager.c
index 6fff109bdab6..1d7a5b87f4cb 100644
--- a/drivers/pnp/manager.c
+++ b/drivers/pnp/manager.c
@@ -20,7 +20,8 @@ DECLARE_MUTEX(pnp_res_mutex);
 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
 {
-        unsigned long *start, *end, *flags;
+        resource_size_t *start, *end;
+        unsigned long *flags;
        if (!dev || !rule)
                return -EINVAL;
@@ -63,7 +64,8 @@ static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
 static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
 {
-        unsigned long *start, *end, *flags;
+        resource_size_t *start, *end;
+        unsigned long *flags;
        if (!dev || !rule)
                return -EINVAL;
@@ -116,7 +118,8 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
 static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx)
 {
-        unsigned long *start, *end, *flags;
+        resource_size_t *start, *end;
+        unsigned long *flags;
        int i;
        /* IRQ priority: this table is good for i386 */
@@ -168,7 +171,8 @@ static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx)
 static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
 {
-        unsigned long *start, *end, *flags;
+        resource_size_t *start, *end;
+        unsigned long *flags;
        int i;
        /* DMA priority: this table is good for i386 */
@@ -582,7 +586,8 @@ int pnp_disable_dev(struct pnp_dev *dev)
 * @size: size of region
 *
 */
-void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size)
+void pnp_resource_change(struct resource *resource, resource_size_t start,
+                                resource_size_t size)
 {
        if (resource == NULL)
                return;
diff --git a/drivers/pnp/resource.c b/drivers/pnp/resource.c
index 6ded527169f4..7bb892f58cc0 100644
--- a/drivers/pnp/resource.c
+++ b/drivers/pnp/resource.c
@@ -241,7 +241,7 @@ int pnp_check_port(struct pnp_dev * dev, int idx)
 {
        int tmp;
        struct pnp_dev *tdev;
-        unsigned long *port, *end, *tport, *tend;
+        resource_size_t *port, *end, *tport, *tend;
        port = &dev->res.port_resource[idx].start;
        end = &dev->res.port_resource[idx].end;
@@ -297,7 +297,7 @@ int pnp_check_mem(struct pnp_dev * dev, int idx)
 {
        int tmp;
        struct pnp_dev *tdev;
-        unsigned long *addr, *end, *taddr, *tend;
+        resource_size_t *addr, *end, *taddr, *tend;
        addr = &dev->res.mem_resource[idx].start;
        end = &dev->res.mem_resource[idx].end;
@@ -358,7 +358,7 @@ int pnp_check_irq(struct pnp_dev * dev, int idx)
 {
        int tmp;
        struct pnp_dev *tdev;
-        unsigned long * irq = &dev->res.irq_resource[idx].start;
+        resource_size_t * irq = &dev->res.irq_resource[idx].start;
        /* if the resource doesn't exist, don't complain about it */
        if (cannot_compare(dev->res.irq_resource[idx].flags))
@@ -423,7 +423,7 @@ int pnp_check_dma(struct pnp_dev * dev, int idx)
 #ifndef CONFIG_IA64
        int tmp;
        struct pnp_dev *tdev;
-        unsigned long * dma = &dev->res.dma_resource[idx].start;
+        resource_size_t * dma = &dev->res.dma_resource[idx].start;
        /* if the resource doesn't exist, don't complain about it */
        if (cannot_compare(dev->res.dma_resource[idx].flags))
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index 67c3d2999775..501ce1791782 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -335,10 +335,10 @@ static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                if ((pci_resource_start(pdev, i) == 0) ||
                    (pci_resource_len(pdev, i) < bar_sizes[i])) {
                        dev_printk(KERN_ERR, &pdev->dev,
-                                   "invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
+                                "invalid PCI BAR %u (sz 0x%llx, val 0x%llx)\n",
-                                   i,
+                                i,
-                                   pci_resource_start(pdev, i),
+                                (unsigned long long)pci_resource_start(pdev, i),
-                                   pci_resource_len(pdev, i));
+                                (unsigned long long)pci_resource_len(pdev, i));
                        rc = -ENODEV;
                        goto err_out_regions;
                }
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index 94886c000d2a..864ef859be56 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -594,8 +594,8 @@ pci_default_setup(struct serial_private *priv, struct pciserial_board *board,
        else
                offset += idx * board->uart_offset;
-        maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) /
+        maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) >>
-                (8 << board->reg_shift);
+                (board->reg_shift + 3);
        if (board->flags & FL_REGION_SZ_CAP && idx >= maxnr)
                return 1;
diff --git a/drivers/sn/ioc4.c b/drivers/sn/ioc4.c
index 8256a97eb508..8562821e6498 100644
--- a/drivers/sn/ioc4.c
+++ b/drivers/sn/ioc4.c
@@ -438,7 +438,7 @@ static struct pci_device_id ioc4_id_table[] = {
        {0}
 };
-static struct pci_driver __devinitdata ioc4_driver = {
+static struct pci_driver ioc4_driver = {
        .name = "IOC4",
        .id_table = ioc4_id_table,
        .probe = ioc4_probe,
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 6b4bc3f2bd86..89bcda5a3298 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1684,9 +1684,13 @@ sl811h_probe(struct platform_device *dev)
                if (!addr || !data)
                        return -ENODEV;
                ioaddr = 1;
+                /*
-                addr_reg = (void __iomem *) addr->start;
+                 * NOTE: 64-bit resource->start is getting truncated
-                data_reg = (void __iomem *) data->start;
+                 * to avoid compiler warning, assuming that ->start
+                 * is always 32-bit for this case
+                 */
+                addr_reg = (void __iomem *) (unsigned long) addr->start;
+                data_reg = (void __iomem *) (unsigned long) data->start;
        } else {
                addr_reg = ioremap(addr->start, 1);
                if (addr_reg == NULL) {
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index f32b590730f2..01401cd63ac0 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -390,7 +390,7 @@ static const char *vgacon_startup(void)
                vga_video_port_val = VGA_CRT_DM;
                if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
                        static struct resource ega_console_resource =
-                            { "ega", 0x3B0, 0x3BF };
+                            { .name = "ega", .start = 0x3B0, .end = 0x3BF };
                        vga_video_type = VIDEO_TYPE_EGAM;
                        vga_vram_size = 0x8000;
                        display_desc = "EGA+";
@@ -398,9 +398,9 @@ static const char *vgacon_startup(void)
                                         &ega_console_resource);
                } else {
                        static struct resource mda1_console_resource =
-                            { "mda", 0x3B0, 0x3BB };
+                            { .name = "mda", .start = 0x3B0, .end = 0x3BB };
                        static struct resource mda2_console_resource =
-                            { "mda", 0x3BF, 0x3BF };
+                            { .name = "mda", .start = 0x3BF, .end = 0x3BF };
                        vga_video_type = VIDEO_TYPE_MDA;
                        vga_vram_size = 0x2000;
                        display_desc = "*MDA";
@@ -423,14 +423,14 @@ static const char *vgacon_startup(void)
                        if (!ORIG_VIDEO_ISVGA) {
                                static struct resource ega_console_resource
-                                    = { "ega", 0x3C0, 0x3DF };
+                                    = { .name = "ega", .start = 0x3C0, .end = 0x3DF };
                                vga_video_type = VIDEO_TYPE_EGAC;
                                display_desc = "EGA";
                                request_resource(&ioport_resource,
                                                 &ega_console_resource);
                        } else {
                                static struct resource vga_console_resource
-                                    = { "vga+", 0x3C0, 0x3DF };
+                                    = { .name = "vga+", .start = 0x3C0, .end = 0x3DF };
                                vga_video_type = VIDEO_TYPE_VGAC;
                                display_desc = "VGA+";
                                request_resource(&ioport_resource,
@@ -474,7 +474,7 @@ static const char *vgacon_startup(void)
                        }
                } else {
                        static struct resource cga_console_resource =
-                            { "cga", 0x3D4, 0x3D5 };
+                            { .name = "cga", .start = 0x3D4, .end = 0x3D5 };
                        vga_video_type = VIDEO_TYPE_CGA;
                        vga_vram_size = 0x2000;
                        display_desc = "*CGA";
diff --git a/drivers/video/sgivwfb.c b/drivers/video/sgivwfb.c
index 2e6df1fcb2b9..c0cc5e3ba7b5 100644
--- a/drivers/video/sgivwfb.c
+++ b/drivers/video/sgivwfb.c
@@ -23,6 +23,8 @@
 #include <asm/io.h>
 #include <asm/mtrr.h>
+#include <setup_arch.h>
 #define INCLUDE_TIMING_TABLE_DATA
 #define DBE_REG_BASE par->regs
 #include <video/sgivw.h>
@@ -42,10 +44,6 @@ struct sgivw_par {
 *  The default can be overridden if the driver is compiled as a module
 */
-/* set by arch/i386/kernel/setup.c */
-extern unsigned long sgivwfb_mem_phys;
-extern unsigned long sgivwfb_mem_size;
 static int ypan = 0;
 static int ywrap = 0;
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 8e1f90e42040..488b5ff48afb 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -98,7 +98,9 @@ static u64 ufs_frag_map(struct inode *inode, sector_t frag)
        u64 temp = 0L;
        UFSD(": frag = %llu  depth = %d\n", (unsigned long long)frag, depth);
-        UFSD(": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask);
+        UFSD(": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",
+                uspi->s_fpbshift, uspi->s_apbmask,
+                (unsigned long long)mask);
        if (depth == 0)
                return 0;
@@ -429,7 +431,7 @@ int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head
        
        if (!create) {
                phys64 = ufs_frag_map(inode, fragment);
-                UFSD("phys64 = %llu \n",phys64);
+                UFSD("phys64 = %llu\n", (unsigned long long)phys64);
                if (phys64)
                        map_bh(bh_result, sb, phys64);
                return 0;
diff --git a/include/asm-alpha/hw_irq.h b/include/asm-alpha/hw_irq.h
index ca9d43b63502..a37db0f95092 100644
--- a/include/asm-alpha/hw_irq.h
+++ b/include/asm-alpha/hw_irq.h
@@ -2,8 +2,6 @@
 #define _ALPHA_HW_IRQ_H
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
 extern volatile unsigned long irq_err_count;
 #ifdef CONFIG_ALPHA_GENERIC
diff --git a/include/asm-arm/mach/pci.h b/include/asm-arm/mach/pci.h
index 25d540ed0079..923e0ca66200 100644
--- a/include/asm-arm/mach/pci.h
+++ b/include/asm-arm/mach/pci.h
@@ -28,7 +28,7 @@ struct hw_pci {
 struct pci_sys_data {
        struct list_head node;
        int             busnr;          /* primary bus number                   */
-        unsigned long   mem_offset;     /* bus->cpu memory mapping offset       */
+        u64             mem_offset;     /* bus->cpu memory mapping offset       */
        unsigned long   io_offset;      /* bus->cpu IO mapping offset           */
        struct pci_bus  *bus;           /* PCI bus                              */
        struct resource *resource[3];   /* Primary PCI bus resources            */
diff --git a/include/asm-cris/hw_irq.h b/include/asm-cris/hw_irq.h
index 341536a234e9..298066020af2 100644
--- a/include/asm-cris/hw_irq.h
+++ b/include/asm-cris/hw_irq.h
@@ -1,7 +1,5 @@
 #ifndef _ASM_HW_IRQ_H
 #define _ASM_HW_IRQ_H
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
 #endif
diff --git a/include/asm-cris/irq.h b/include/asm-cris/irq.h
index 4b338792218b..998cce9f3200 100644
--- a/include/asm-cris/irq.h
+++ b/include/asm-cris/irq.h
@@ -1,11 +1,6 @@
 #ifndef _ASM_IRQ_H
 #define _ASM_IRQ_H
-/*
- * IRQ line status macro IRQ_PER_CPU is used
- */
-#define ARCH_HAS_IRQ_PER_CPU
 #include <asm/arch/irq.h>
 static inline int irq_canonicalize(int irq)
diff --git a/include/asm-i386/hw_irq.h b/include/asm-i386/hw_irq.h
index a4c0a5a9ffd8..87e5a351d881 100644
--- a/include/asm-i386/hw_irq.h
+++ b/include/asm-i386/hw_irq.h
@@ -69,14 +69,4 @@ extern atomic_t irq_mis_count;
 #define IO_APIC_IRQ(x) (((x) >= 16) || ((1<<(x)) & io_apic_irqs))
-#if defined(CONFIG_X86_IO_APIC)
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
-{
-        if (IO_APIC_IRQ(i))
-                send_IPI_self(IO_APIC_VECTOR(i));
-}
-#else
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
-#endif
 #endif /* _ASM_HW_IRQ_H */
diff --git a/include/asm-i386/mach-visws/setup_arch.h b/include/asm-i386/mach-visws/setup_arch.h
index b92d6d9a4d3c..33f700ef6831 100644
--- a/include/asm-i386/mach-visws/setup_arch.h
+++ b/include/asm-i386/mach-visws/setup_arch.h
@@ -1,5 +1,8 @@
 /* Hook to call BIOS initialisation function */
+extern unsigned long sgivwfb_mem_phys;
+extern unsigned long sgivwfb_mem_size;
 /* no action for visws */
 #define ARCH_SETUP
diff --git a/include/asm-ia64/hw_irq.h b/include/asm-ia64/hw_irq.h
index ea8b8c407ab4..27f9df6b9145 100644
--- a/include/asm-ia64/hw_irq.h
+++ b/include/asm-ia64/hw_irq.h
@@ -97,8 +97,7 @@ extern int reserve_irq_vector (int vector);
 extern void ia64_send_ipi (int cpu, int vector, int delivery_mode, int redirect);
 extern void register_percpu_irq (ia64_vector vec, struct irqaction *action);
-static inline void
+static inline void ia64_resend_irq(unsigned int vector)
-hw_resend_irq (struct hw_interrupt_type *h, unsigned int vector)
 {
        platform_send_ipi(smp_processor_id(), vector, IA64_IPI_DM_INT, 0);
 }
diff --git a/include/asm-ia64/irq.h b/include/asm-ia64/irq.h
index dbe86c0bbce5..79479e2c6966 100644
--- a/include/asm-ia64/irq.h
+++ b/include/asm-ia64/irq.h
@@ -14,11 +14,6 @@
 #define NR_IRQS         256
 #define NR_IRQ_VECTORS  NR_IRQS
-/*
- * IRQ line status macro IRQ_PER_CPU is used
- */
-#define ARCH_HAS_IRQ_PER_CPU
 static __inline__ int
 irq_canonicalize (int irq)
 {
diff --git a/include/asm-m32r/hw_irq.h b/include/asm-m32r/hw_irq.h
index 8d7e9d0e09e8..7138537cda03 100644
--- a/include/asm-m32r/hw_irq.h
+++ b/include/asm-m32r/hw_irq.h
@@ -1,9 +1,4 @@
 #ifndef _ASM_M32R_HW_IRQ_H
 #define _ASM_M32R_HW_IRQ_H
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
-{
-        /* Nothing to do */
-}
 #endif /* _ASM_M32R_HW_IRQ_H */
diff --git a/include/asm-mips/hw_irq.h b/include/asm-mips/hw_irq.h
index c854d017c0e5..458d9fdc76bf 100644
--- a/include/asm-mips/hw_irq.h
+++ b/include/asm-mips/hw_irq.h
@@ -19,9 +19,9 @@ extern void init_8259A(int aeoi);
 extern atomic_t irq_err_count;
-/* This may not be apropriate for all machines, we'll see ...  */
+/*
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
+ * interrupt-retrigger: NOP for now. This may not be apropriate for all
-{
+ * machines, we'll see ...
-}
+ */
 #endif /* __ASM_HW_IRQ_H */
diff --git a/include/asm-mips/mach-mips/irq.h b/include/asm-mips/mach-mips/irq.h
index 083d9c512a04..e994b0c01227 100644
--- a/include/asm-mips/mach-mips/irq.h
+++ b/include/asm-mips/mach-mips/irq.h
@@ -4,10 +4,4 @@
 #define NR_IRQS 256
-#ifdef CONFIG_SMP
-#define ARCH_HAS_IRQ_PER_CPU
-#endif
 #endif /* __ASM_MACH_MIPS_IRQ_H */
diff --git a/include/asm-parisc/hw_irq.h b/include/asm-parisc/hw_irq.h
index 151426e27521..6707f7df3921 100644
--- a/include/asm-parisc/hw_irq.h
+++ b/include/asm-parisc/hw_irq.h
@@ -3,15 +3,6 @@
 /*
 *      linux/include/asm/hw_irq.h
- *
- *      (C) 1992, 1993 Linus Torvalds, (C) 1997 Ingo Molnar
- *
- *      moved some of the old arch/i386/kernel/irq.h to here. VY
- *
- *      IRQ/IPI changes taken from work by Thomas Radke
- *      <tomsoft@informatik.tu-chemnitz.de>
 */
-extern void hw_resend_irq(struct hw_interrupt_type *, unsigned int);
 #endif
diff --git a/include/asm-parisc/irq.h b/include/asm-parisc/irq.h
index 377ba90c7d02..5cae260615a2 100644
--- a/include/asm-parisc/irq.h
+++ b/include/asm-parisc/irq.h
@@ -26,11 +26,6 @@
 #define NR_IRQS         (CPU_IRQ_MAX + 1)
-/*
- * IRQ line status macro IRQ_PER_CPU is used
- */
-#define ARCH_HAS_IRQ_PER_CPU
 static __inline__ int irq_canonicalize(int irq)
 {
        return (irq == 2) ? 9 : irq;
diff --git a/include/asm-powerpc/hw_irq.h b/include/asm-powerpc/hw_irq.h
index ce0f7db63c16..d40359204aba 100644
--- a/include/asm-powerpc/hw_irq.h
+++ b/include/asm-powerpc/hw_irq.h
@@ -86,27 +86,27 @@ static inline void local_irq_save_ptr(unsigned long *flags)
 #define mask_irq(irq)                                           \
        ({                                                      \
                irq_desc_t *desc = get_irq_desc(irq);           \
-                if (desc->handler && desc->handler->disable)    \
+                if (desc->chip && desc->chip->disable)  \
-                        desc->handler->disable(irq);            \
+                        desc->chip->disable(irq);               \
        })
 #define unmask_irq(irq)                                         \
        ({                                                      \
                irq_desc_t *desc = get_irq_desc(irq);           \
-                if (desc->handler && desc->handler->enable)     \
+                if (desc->chip && desc->chip->enable)   \
-                        desc->handler->enable(irq);             \
+                        desc->chip->enable(irq);                \
        })
 #define ack_irq(irq)                                            \
        ({                                                      \
                irq_desc_t *desc = get_irq_desc(irq);           \
-                if (desc->handler && desc->handler->ack)        \
+                if (desc->chip && desc->chip->ack)      \
-                        desc->handler->ack(irq);                \
+                        desc->chip->ack(irq);           \
        })
-/* Should we handle this via lost interrupts and IPIs or should we don't care like
+/*
- * we do now ? --BenH.
+ * interrupt-retrigger: should we handle this via lost interrupts and IPIs
+ * or should we not care like we do now ? --BenH.
 */
 struct hw_interrupt_type;
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
 #endif  /* __KERNEL__ */
 #endif  /* _ASM_POWERPC_HW_IRQ_H */
diff --git a/include/asm-powerpc/irq.h b/include/asm-powerpc/irq.h
index a10feec29d4d..eb5f33e1977a 100644
--- a/include/asm-powerpc/irq.h
+++ b/include/asm-powerpc/irq.h
@@ -30,11 +30,6 @@
 #define IRQ_POLARITY_POSITIVE   0x2     /* high level or low->high edge */
 #define IRQ_POLARITY_NEGATIVE   0x0     /* low level or high->low edge */
-/*
- * IRQ line status macro IRQ_PER_CPU is used
- */
-#define ARCH_HAS_IRQ_PER_CPU
 #define get_irq_desc(irq) (&irq_desc[(irq)])
 /* Define a way to iterate across irqs. */
diff --git a/include/asm-powerpc/pci.h b/include/asm-powerpc/pci.h
index 5d2c9e6c4be2..46afd29b904e 100644
--- a/include/asm-powerpc/pci.h
+++ b/include/asm-powerpc/pci.h
@@ -242,7 +242,7 @@ extern pgprot_t	pci_phys_mem_access_prot(struct file *file,
 #define HAVE_ARCH_PCI_RESOURCE_TO_USER
 extern void pci_resource_to_user(const struct pci_dev *dev, int bar,
                                 const struct resource *rsrc,
-                                 u64 *start, u64 *end);
+                                 resource_size_t *start, resource_size_t *end);
 #endif /* CONFIG_PPC_MULTIPLATFORM || CONFIG_PPC32 */
 #endif  /* __KERNEL__ */
diff --git a/include/asm-ppc/pci.h b/include/asm-ppc/pci.h
index 61434edbad7b..11ffaaa5da16 100644
--- a/include/asm-ppc/pci.h
+++ b/include/asm-ppc/pci.h
@@ -133,7 +133,7 @@ extern pgprot_t	pci_phys_mem_access_prot(struct file *file,
 #define HAVE_ARCH_PCI_RESOURCE_TO_USER
 extern void pci_resource_to_user(const struct pci_dev *dev, int bar,
                                 const struct resource *rsrc,
-                                 u64 *start, u64 *end);
+                                 resource_size_t *start, resource_size_t *end);
 #endif  /* __KERNEL__ */
diff --git a/include/asm-sh/hw_irq.h b/include/asm-sh/hw_irq.h
index 1d934fb2c581..fed26616967a 100644
--- a/include/asm-sh/hw_irq.h
+++ b/include/asm-sh/hw_irq.h
@@ -1,9 +1,4 @@
 #ifndef __ASM_SH_HW_IRQ_H
 #define __ASM_SH_HW_IRQ_H
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
-{
-        /* Nothing to do */
-}
 #endif /* __ASM_SH_HW_IRQ_H */
diff --git a/include/asm-sh64/hw_irq.h b/include/asm-sh64/hw_irq.h
index ae718d1f2d6c..ebb39089b0ac 100644
--- a/include/asm-sh64/hw_irq.h
+++ b/include/asm-sh64/hw_irq.h
@@ -11,6 +11,5 @@
 * Copyright (C) 2000, 2001  Paolo Alberelli
 *
 */
-static __inline__ void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) { /* Nothing to do */ }
 #endif /* __ASM_SH64_HW_IRQ_H */
diff --git a/include/asm-um/hw_irq.h b/include/asm-um/hw_irq.h
index 4ee38c0b6a64..1cf84cf5f21a 100644
--- a/include/asm-um/hw_irq.h
+++ b/include/asm-um/hw_irq.h
@@ -4,7 +4,4 @@
 #include "asm/irq.h"
 #include "asm/archparam.h"
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
-{}
 #endif
diff --git a/include/asm-v850/hw_irq.h b/include/asm-v850/hw_irq.h
index a8aab4342712..043e94bb6bd8 100644
--- a/include/asm-v850/hw_irq.h
+++ b/include/asm-v850/hw_irq.h
@@ -1,8 +1,4 @@
 #ifndef __V850_HW_IRQ_H__
 #define __V850_HW_IRQ_H__
-static inline void hw_resend_irq (struct hw_interrupt_type *h, unsigned int i)
-{
-}
 #endif /* __V850_HW_IRQ_H__ */
diff --git a/include/asm-x86_64/hw_irq.h b/include/asm-x86_64/hw_irq.h
index 931877462788..48a4a5364e85 100644
--- a/include/asm-x86_64/hw_irq.h
+++ b/include/asm-x86_64/hw_irq.h
@@ -127,15 +127,6 @@ __asm__( \
        "push $~(" #nr ") ; " \
        "jmp common_interrupt");
-#if defined(CONFIG_X86_IO_APIC)
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {
-        if (IO_APIC_IRQ(i))
-                send_IPI_self(IO_APIC_VECTOR(i));
-}
-#else
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i) {}
-#endif
 #define platform_legacy_irq(irq)        ((irq) < 16)
 #endif
diff --git a/include/asm-xtensa/hw_irq.h b/include/asm-xtensa/hw_irq.h
index ccf436249eaa..3ddbea759b2b 100644
--- a/include/asm-xtensa/hw_irq.h
+++ b/include/asm-xtensa/hw_irq.h
@@ -11,8 +11,4 @@
 #ifndef _XTENSA_HW_IRQ_H
 #define _XTENSA_HW_IRQ_H
-static inline void hw_resend_irq(struct hw_interrupt_type *h, unsigned int i)
-{
-}
 #endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 70741e170114..db2a63a11633 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -36,6 +36,20 @@ extern void free_irq(unsigned int, void *);
 extern void disable_irq_nosync(unsigned int irq);
 extern void disable_irq(unsigned int irq);
 extern void enable_irq(unsigned int irq);
+/* IRQ wakeup (PM) control: */
+extern int set_irq_wake(unsigned int irq, unsigned int on);
+static inline int enable_irq_wake(unsigned int irq)
+{
+        return set_irq_wake(irq, 1);
+}
+static inline int disable_irq_wake(unsigned int irq)
+{
+        return set_irq_wake(irq, 0);
+}
 #endif
 #ifndef __ARCH_SET_SOFTIRQ_PENDING
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index edfc733b1575..87a9fc039b47 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -9,13 +9,15 @@
 #define _LINUX_IOPORT_H
 #include <linux/compiler.h>
+#include <linux/types.h>
 /*
 * Resources are tree-like, allowing
 * nesting etc..
 */
 struct resource {
+        resource_size_t start;
+        resource_size_t end;
        const char *name;
-        unsigned long start, end;
        unsigned long flags;
        struct resource *parent, *sibling, *child;
 };
@@ -96,14 +98,13 @@ extern struct resource * ____request_resource(struct resource *root, struct reso
 extern int release_resource(struct resource *new);
 extern __deprecated_for_modules int insert_resource(struct resource *parent, struct resource *new);
 extern int allocate_resource(struct resource *root, struct resource *new,
-                             unsigned long size,
+                             resource_size_t size, resource_size_t min,
-                             unsigned long min, unsigned long max,
+                             resource_size_t max, resource_size_t align,
-                             unsigned long align,
                             void (*alignf)(void *, struct resource *,
-                                            unsigned long, unsigned long),
+                                            resource_size_t, resource_size_t),
                             void *alignf_data);
-int adjust_resource(struct resource *res, unsigned long start,
+int adjust_resource(struct resource *res, resource_size_t start,
-                    unsigned long size);
+                    resource_size_t size);
 /* get registered SYSTEM_RAM resources in specified area */
 extern int find_next_system_ram(struct resource *res);
@@ -113,17 +114,21 @@ extern int find_next_system_ram(struct resource *res);
 #define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name))
 #define rename_region(region, newname) do { (region)->name = (newname); } while (0)
-extern struct resource * __request_region(struct resource *, unsigned long start, unsigned long n, const char *name);
+extern struct resource * __request_region(struct resource *,
+                                        resource_size_t start,
+                                        resource_size_t n, const char *name);
 /* Compatibility cruft */
 #define release_region(start,n) __release_region(&ioport_resource, (start), (n))
 #define check_mem_region(start,n)       __check_region(&iomem_resource, (start), (n))
 #define release_mem_region(start,n)     __release_region(&iomem_resource, (start), (n))
-extern int __check_region(struct resource *, unsigned long, unsigned long);
+extern int __check_region(struct resource *, resource_size_t, resource_size_t);
-extern void __release_region(struct resource *, unsigned long, unsigned long);
+extern void __release_region(struct resource *, resource_size_t,
+                                resource_size_t);
-static inline int __deprecated check_region(unsigned long s, unsigned long n)
+static inline int __deprecated check_region(resource_size_t s,
+                                                resource_size_t n)
 {
        return __check_region(&ioport_resource, s, n);
 }
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 676e00dfb21a..0832149cdb18 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -1,5 +1,5 @@
-#ifndef __irq_h
+#ifndef _LINUX_IRQ_H
-#define __irq_h
+#define _LINUX_IRQ_H
 /*
 * Please do not include this file in generic code.  There is currently
@@ -11,7 +11,7 @@
 #include <linux/smp.h>
-#if !defined(CONFIG_S390)
+#ifndef CONFIG_S390
 #include <linux/linkage.h>
 #include <linux/cache.h>
@@ -33,75 +33,160 @@
 #define IRQ_WAITING     32      /* IRQ not yet seen - for autodetection */
 #define IRQ_LEVEL       64      /* IRQ level triggered */
 #define IRQ_MASKED      128     /* IRQ masked - shouldn't be seen again */
-#if defined(ARCH_HAS_IRQ_PER_CPU)
+#ifdef CONFIG_IRQ_PER_CPU
 # define IRQ_PER_CPU    256     /* IRQ is per CPU */
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
 #else
 # define CHECK_IRQ_PER_CPU(var) 0
 #endif
+#define IRQ_NOPROBE     512     /* IRQ is not valid for probing */
+#define IRQ_NOREQUEST   1024    /* IRQ cannot be requested */
+#define IRQ_NOAUTOEN    2048    /* IRQ will not be enabled on request irq */
+#define IRQ_DELAYED_DISABLE \
+                        4096    /* IRQ disable (masking) happens delayed. */
 /*
- * Interrupt controller descriptor. This is all we need
+ * IRQ types, see also include/linux/interrupt.h
- * to describe about the low-level hardware. 
 */
-struct hw_interrupt_type {
+#define IRQ_TYPE_NONE           0x0000          /* Default, unspecified type */
-        const char * typename;
+#define IRQ_TYPE_EDGE_RISING    0x0001          /* Edge rising type */
-        unsigned int (*startup)(unsigned int irq);
+#define IRQ_TYPE_EDGE_FALLING   0x0002          /* Edge falling type */
-        void (*shutdown)(unsigned int irq);
+#define IRQ_TYPE_EDGE_BOTH (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)
-        void (*enable)(unsigned int irq);
+#define IRQ_TYPE_LEVEL_HIGH     0x0004          /* Level high type */
-        void (*disable)(unsigned int irq);
+#define IRQ_TYPE_LEVEL_LOW      0x0008          /* Level low type */
-        void (*ack)(unsigned int irq);
+#define IRQ_TYPE_SENSE_MASK     0x000f          /* Mask of the above */
-        void (*end)(unsigned int irq);
+#define IRQ_TYPE_SIMPLE         0x0010          /* Simple type */
-        void (*set_affinity)(unsigned int irq, cpumask_t dest);
+#define IRQ_TYPE_PERCPU         0x0020          /* Per CPU type */
+#define IRQ_TYPE_PROBE          0x0040          /* Probing in progress */
+struct proc_dir_entry;
+/**
+ * struct irq_chip - hardware interrupt chip descriptor
+ *
+ * @name:               name for /proc/interrupts
+ * @startup:            start up the interrupt (defaults to ->enable if NULL)
+ * @shutdown:           shut down the interrupt (defaults to ->disable if NULL)
+ * @enable:             enable the interrupt (defaults to chip->unmask if NULL)
+ * @disable:            disable the interrupt (defaults to chip->mask if NULL)
+ * @ack:                start of a new interrupt
+ * @mask:               mask an interrupt source
+ * @mask_ack:           ack and mask an interrupt source
+ * @unmask:             unmask an interrupt source
+ * @eoi:                end of interrupt - chip level
+ * @end:                end of interrupt - flow level
+ * @set_affinity:       set the CPU affinity on SMP machines
+ * @retrigger:          resend an IRQ to the CPU
+ * @set_type:           set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
+ * @set_wake:           enable/disable power-management wake-on of an IRQ
+ *
+ * @release:            release function solely used by UML
+ * @typename:           obsoleted by name, kept as migration helper
+ */
+struct irq_chip {
+        const char      *name;
+        unsigned int    (*startup)(unsigned int irq);
+        void            (*shutdown)(unsigned int irq);
+        void            (*enable)(unsigned int irq);
+        void            (*disable)(unsigned int irq);
+        void            (*ack)(unsigned int irq);
+        void            (*mask)(unsigned int irq);
+        void            (*mask_ack)(unsigned int irq);
+        void            (*unmask)(unsigned int irq);
+        void            (*eoi)(unsigned int irq);
+        void            (*end)(unsigned int irq);
+        void            (*set_affinity)(unsigned int irq, cpumask_t dest);
+        int             (*retrigger)(unsigned int irq);
+        int             (*set_type)(unsigned int irq, unsigned int flow_type);
+        int             (*set_wake)(unsigned int irq, unsigned int on);
        /* Currently used only by UML, might disappear one day.*/
 #ifdef CONFIG_IRQ_RELEASE_METHOD
-        void (*release)(unsigned int irq, void *dev_id);
+        void            (*release)(unsigned int irq, void *dev_id);
 #endif
+        /*
+         * For compatibility, ->typename is copied into ->name.
+         * Will disappear.
+         */
+        const char      *typename;
 };
-typedef struct hw_interrupt_type  hw_irq_controller;
+/**
+ * struct irq_desc - interrupt descriptor
-/*
+ *
- * This is the "IRQ descriptor", which contains various information
+ * @handle_irq:         highlevel irq-events handler [if NULL, __do_IRQ()]
- * about the irq, including what kind of hardware handling it has,
+ * @chip:               low level interrupt hardware access
- * whether it is disabled etc etc.
+ * @handler_data:       per-IRQ data for the irq_chip methods
+ * @chip_data:          platform-specific per-chip private data for the chip
+ *                      methods, to allow shared chip implementations
+ * @action:             the irq action chain
+ * @status:             status information
+ * @depth:              disable-depth, for nested irq_disable() calls
+ * @irq_count:          stats field to detect stalled irqs
+ * @irqs_unhandled:     stats field for spurious unhandled interrupts
+ * @lock:               locking for SMP
+ * @affinity:           IRQ affinity on SMP
+ * @cpu:                cpu index useful for balancing
+ * @pending_mask:       pending rebalanced interrupts
+ * @move_irq:           need to re-target IRQ destination
+ * @dir:                /proc/irq/ procfs entry
+ * @affinity_entry:     /proc/irq/smp_affinity procfs entry on SMP
 *
 * Pad this out to 32 bytes for cache and indexing reasons.
 */
-typedef struct irq_desc {
+struct irq_desc {
-        hw_irq_controller *handler;
+        void fastcall           (*handle_irq)(unsigned int irq,
-        void *handler_data;
+                                              struct irq_desc *desc,
-        struct irqaction *action;       /* IRQ action list */
+                                              struct pt_regs *regs);
-        unsigned int status;            /* IRQ status */
+        struct irq_chip         *chip;
-        unsigned int depth;             /* nested irq disables */
+        void                    *handler_data;
-        unsigned int irq_count;         /* For detecting broken interrupts */
+        void                    *chip_data;
-        unsigned int irqs_unhandled;
+        struct irqaction        *action;        /* IRQ action list */
-        spinlock_t lock;
+        unsigned int            status;         /* IRQ status */
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
-        unsigned int move_irq;          /* Flag need to re-target intr dest*/
+        unsigned int            depth;          /* nested irq disables */
+        unsigned int            irq_count;      /* For detecting broken IRQs */
+        unsigned int            irqs_unhandled;
+        spinlock_t              lock;
+#ifdef CONFIG_SMP
+        cpumask_t               affinity;
+        unsigned int            cpu;
+#endif
+#if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
+        cpumask_t               pending_mask;
+        unsigned int            move_irq;       /* need to re-target IRQ dest */
 #endif
-} ____cacheline_aligned irq_desc_t;
+#ifdef CONFIG_PROC_FS
+        struct proc_dir_entry *dir;
+#endif
+} ____cacheline_aligned;
-extern irq_desc_t irq_desc [NR_IRQS];
+extern struct irq_desc irq_desc[NR_IRQS];
-/* Return a pointer to the irq descriptor for IRQ.  */
+/*
-static inline irq_desc_t *
+ * Migration helpers for obsolete names, they will go away:
-irq_descp (int irq)
+ */
-{
+#define hw_interrupt_type       irq_chip
-        return irq_desc + irq;
+typedef struct irq_chip         hw_irq_controller;
-}
+#define no_irq_type             no_irq_chip
+typedef struct irq_desc         irq_desc_t;
-#include <asm/hw_irq.h> /* the arch dependent stuff */
+/*
+ * Pick up the arch-dependent methods:
+ */
+#include <asm/hw_irq.h>
-extern int setup_irq(unsigned int irq, struct irqaction * new);
+extern int setup_irq(unsigned int irq, struct irqaction *new);
 #ifdef CONFIG_GENERIC_HARDIRQS
-extern cpumask_t irq_affinity[NR_IRQS];
 #ifdef CONFIG_SMP
 static inline void set_native_irq_info(int irq, cpumask_t mask)
 {
-        irq_affinity[irq] = mask;
+        irq_desc[irq].affinity = mask;
 }
 #else
 static inline void set_native_irq_info(int irq, cpumask_t mask)
@@ -111,8 +196,7 @@ static inline void set_native_irq_info(int irq, cpumask_t mask)
 #ifdef CONFIG_SMP
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
+#if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
-extern cpumask_t pending_irq_cpumask[NR_IRQS];
 void set_pending_irq(unsigned int irq, cpumask_t mask);
 void move_native_irq(int irq);
@@ -133,7 +217,7 @@ static inline void set_irq_info(int irq, cpumask_t mask)
 {
 }
-#else // CONFIG_PCI_MSI
+#else /* CONFIG_PCI_MSI */
 static inline void move_irq(int irq)
 {
@@ -144,26 +228,36 @@ static inline void set_irq_info(int irq, cpumask_t mask)
 {
        set_native_irq_info(irq, mask);
 }
-#endif // CONFIG_PCI_MSI
-#else   // CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE
+#endif /* CONFIG_PCI_MSI */
+#else /* CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE */
+static inline void move_irq(int irq)
+{
+}
+static inline void move_native_irq(int irq)
+{
+}
+static inline void set_pending_irq(unsigned int irq, cpumask_t mask)
+{
+}
-#define move_irq(x)
-#define move_native_irq(x)
-#define set_pending_irq(x,y)
 static inline void set_irq_info(int irq, cpumask_t mask)
 {
        set_native_irq_info(irq, mask);
 }
-#endif // CONFIG_GENERIC_PENDING_IRQ
+#endif /* CONFIG_GENERIC_PENDING_IRQ */
-#else // CONFIG_SMP
+#else /* CONFIG_SMP */
 #define move_irq(x)
 #define move_native_irq(x)
-#endif // CONFIG_SMP
+#endif /* CONFIG_SMP */
 #ifdef CONFIG_IRQBALANCE
 extern void set_balance_irq_affinity(unsigned int irq, cpumask_t mask);
@@ -173,32 +267,138 @@ static inline void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
 }
 #endif
+#ifdef CONFIG_AUTO_IRQ_AFFINITY
+extern int select_smp_affinity(unsigned int irq);
+#else
+static inline int select_smp_affinity(unsigned int irq)
+{
+        return 1;
+}
+#endif
 extern int no_irq_affinity;
-extern int noirqdebug_setup(char *str);
-extern fastcall irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
+/* Handle irq action chains: */
-                                        struct irqaction *action);
+extern int handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
+                            struct irqaction *action);
+/*
+ * Built-in IRQ handlers for various IRQ types,
+ * callable via desc->chip->handle_irq()
+ */
+extern void fastcall
+handle_level_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs);
+extern void fastcall
+handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc,
+                         struct pt_regs *regs);
+extern void fastcall
+handle_edge_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs);
+extern void fastcall
+handle_simple_irq(unsigned int irq, struct irq_desc *desc,
+                  struct pt_regs *regs);
+extern void fastcall
+handle_percpu_irq(unsigned int irq, struct irq_desc *desc,
+                  struct pt_regs *regs);
+extern void fastcall
+handle_bad_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs);
+/*
+ * Get a descriptive string for the highlevel handler, for
+ * /proc/interrupts output:
+ */
+extern const char *
+handle_irq_name(void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                        struct pt_regs *));
+/*
+ * Monolithic do_IRQ implementation.
+ * (is an explicit fastcall, because i386 4KSTACKS calls it from assembly)
+ */
 extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs);
-extern void note_interrupt(unsigned int irq, irq_desc_t *desc,
-                                        int action_ret, struct pt_regs *regs);
-extern int can_request_irq(unsigned int irq, unsigned long irqflags);
+/*
+ * Architectures call this to let the generic IRQ layer
+ * handle an interrupt. If the descriptor is attached to an
+ * irqchip-style controller then we call the ->handle_irq() handler,
+ * and it calls __do_IRQ() if it's attached to an irqtype-style controller.
+ */
+static inline void generic_handle_irq(unsigned int irq, struct pt_regs *regs)
+{
+        struct irq_desc *desc = irq_desc + irq;
+        if (likely(desc->handle_irq))
+                desc->handle_irq(irq, desc, regs);
+        else
+                __do_IRQ(irq, regs);
+}
+/* Handling of unhandled and spurious interrupts: */
+extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
+                           int action_ret, struct pt_regs *regs);
+/* Resending of interrupts :*/
+void check_irq_resend(struct irq_desc *desc, unsigned int irq);
+/* Initialize /proc/irq/ */
 extern void init_irq_proc(void);
-#ifdef CONFIG_AUTO_IRQ_AFFINITY
+/* Enable/disable irq debugging output: */
-extern int select_smp_affinity(unsigned int irq);
+extern int noirqdebug_setup(char *str);
-#else
-static inline int
+/* Checks whether the interrupt can be requested by request_irq(): */
-select_smp_affinity(unsigned int irq)
+extern int can_request_irq(unsigned int irq, unsigned long irqflags);
+/* Dummy irq-chip implementation: */
+extern struct irq_chip no_irq_chip;
+extern void
+set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
+                         void fastcall (*handle)(unsigned int,
+                                                 struct irq_desc *,
+                                                 struct pt_regs *));
+extern void
+__set_irq_handler(unsigned int irq,
+                  void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                          struct pt_regs *),
+                  int is_chained);
+/*
+ * Set a highlevel flow handler for a given IRQ:
+ */
+static inline void
+set_irq_handler(unsigned int irq,
+                void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                        struct pt_regs *))
 {
-        return 1;
+        __set_irq_handler(irq, handle, 0);
 }
-#endif
-#endif
+/*
+ * Set a highlevel chained flow handler for a given IRQ.
+ * (a chained handler is automatically enabled and set to
+ *  IRQ_NOREQUEST and IRQ_NOPROBE)
+ */
+static inline void
+set_irq_chained_handler(unsigned int irq,
+                        void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                                struct pt_regs *))
+{
+        __set_irq_handler(irq, handle, 1);
+}
-extern hw_irq_controller no_irq_type;  /* needed in every arch ? */
+/* Set/get chip/data for an IRQ: */
-#endif
+extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
+extern int set_irq_data(unsigned int irq, void *data);
+extern int set_irq_chip_data(unsigned int irq, void *data);
+extern int set_irq_type(unsigned int irq, unsigned int type);
+#define get_irq_chip(irq)       (irq_desc[irq].chip)
+#define get_irq_chip_data(irq)  (irq_desc[irq].chip_data)
+#define get_irq_data(irq)       (irq_desc[irq].handler_data)
+#endif /* CONFIG_GENERIC_HARDIRQS */
+#endif /* !CONFIG_S390 */
-#endif /* __irq_h */
+#endif /* _LINUX_IRQ_H */
diff --git a/include/linux/isdn/tpam.h b/include/linux/isdn/tpam.h
deleted file mode 100644
index d18dd0dc570d..000000000000
--- a/include/linux/isdn/tpam.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* $Id: tpam.h,v 1.1.2.1 2001/06/08 08:23:46 kai Exp $
- *
- * Turbo PAM ISDN driver for Linux. (Kernel Driver)
- *
- * Copyright 2001 Stelian Pop <stelian.pop@fr.alcove.com>, Alc�ve
- *
- * For all support questions please contact: <support@auvertech.fr>
- *
- * 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, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-#ifndef _TPAM_H_
-#define _TPAM_H_
-#include <linux/types.h>
-/* IOCTL commands */
-#define TPAM_CMD_DSPLOAD        0x0001
-#define TPAM_CMD_DSPSAVE        0x0002
-#define TPAM_CMD_DSPRUN         0x0003
-#define TPAM_CMD_LOOPMODEON     0x0004
-#define TPAM_CMD_LOOPMODEOFF    0x0005
-/* addresses of debug information zones on board */
-#define TPAM_TRAPAUDIT_REGISTER         0x005493e4
-#define TPAM_NCOAUDIT_REGISTER          0x00500000
-#define TPAM_MSGAUDIT_REGISTER          0x008E30F0
-/* length of debug information zones on board */
-#define TPAM_TRAPAUDIT_LENGTH           10000
-#define TPAM_NCOAUDIT_LENGTH            300000
-#define TPAM_NCOAUDIT_COUNT             30
-#define TPAM_MSGAUDIT_LENGTH            60000
-/* IOCTL load/save parameter */
-typedef struct tpam_dsp_ioctl {
-        __u32 address;  /* address to load/save data */
-        __u32 data_len; /* size of data to be loaded/saved */
-        __u8 data[0];   /* data */
-} tpam_dsp_ioctl;
-#endif /* _TPAM_H_ */
diff --git a/include/linux/key.h b/include/linux/key.h
index e693e729bc92..169f05e4863e 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -177,7 +177,8 @@ struct key {
 /*
 * kernel managed key type definition
 */
-typedef int (*request_key_actor_t)(struct key *key, struct key *authkey, const char *op);
+typedef int (*request_key_actor_t)(struct key *key, struct key *authkey,
+                                   const char *op, void *aux);
 struct key_type {
        /* name of the type */
@@ -285,6 +286,11 @@ extern struct key *request_key(struct key_type *type,
                               const char *description,
                               const char *callout_info);
+extern struct key *request_key_with_auxdata(struct key_type *type,
+                                            const char *description,
+                                            const char *callout_info,
+                                            void *aux);
 extern int key_validate(struct key *key);
 extern key_ref_t key_create_or_update(key_ref_t keyring,
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 62a8c22f5f60..983fca251b25 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -404,8 +404,8 @@ int pcibios_enable_device(struct pci_dev *, int mask);
 char *pcibios_setup (char *str);
 /* Used only when drivers/pci/setup.c is used */
-void pcibios_align_resource(void *, struct resource *,
+void pcibios_align_resource(void *, struct resource *, resource_size_t,
-                            unsigned long, unsigned long);
+                                resource_size_t);
 void pcibios_update_irq(struct pci_dev *, int irq);
 /* Generic PCI functions used internally */
@@ -532,10 +532,10 @@ void pci_release_region(struct pci_dev *, int);
 /* drivers/pci/bus.c */
 int pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
-                           unsigned long size, unsigned long align,
+                           resource_size_t size, resource_size_t align,
-                           unsigned long min, unsigned int type_mask,
+                           resource_size_t min, unsigned int type_mask,
                           void (*alignf)(void *, struct resource *,
-                                          unsigned long, unsigned long),
+                                          resource_size_t, resource_size_t),
                           void *alignf_data);
 void pci_enable_bridges(struct pci_bus *bus);
@@ -730,7 +730,8 @@ static inline char *pci_name(struct pci_dev *pdev)
 */
 #ifndef HAVE_ARCH_PCI_RESOURCE_TO_USER
 static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
-                const struct resource *rsrc, u64 *start, u64 *end)
+                const struct resource *rsrc, resource_size_t *start,
+                resource_size_t *end)
 {
        *start = rsrc->start;
        *end = rsrc->end;
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index 93b0959eb40f..ab8a8dd8d64c 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -389,7 +389,8 @@ int pnp_start_dev(struct pnp_dev *dev);
 int pnp_stop_dev(struct pnp_dev *dev);
 int pnp_activate_dev(struct pnp_dev *dev);
 int pnp_disable_dev(struct pnp_dev *dev);
-void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size);
+void pnp_resource_change(struct resource *resource, resource_size_t start,
+                                resource_size_t size);
 /* protocol helpers */
 int pnp_is_active(struct pnp_dev * dev);
@@ -434,7 +435,9 @@ static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
-static inline void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size) { }
+static inline void pnp_resource_change(struct resource *resource,
+                                        resource_size_t start,
+                                        resource_size_t size) { }
 /* protocol helpers */
 static inline int pnp_is_active(struct pnp_dev * dev) { return 0; }
diff --git a/include/linux/types.h b/include/linux/types.h
index a5e46e783ffa..3f235660a3cd 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -177,8 +177,15 @@ typedef __u64 __bitwise __be64;
 #ifdef __KERNEL__
 typedef unsigned __bitwise__ gfp_t;
+#ifdef CONFIG_RESOURCES_64BIT
+typedef u64 resource_size_t;
+#else
+typedef u32 resource_size_t;
 #endif
+#endif  /* __KERNEL__ */
 struct ustat {
        __kernel_daddr_t        f_tfree;
        __kernel_ino_t          f_tinode;
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index 9f77f50d8143..1dab0ac3f797 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -1,5 +1,5 @@
-obj-y := handle.o manage.o spurious.o
+obj-y := handle.o manage.o spurious.o resend.o chip.o
 obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index 3467097ca61a..533068cfb607 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -11,12 +11,14 @@
 #include <linux/interrupt.h>
 #include <linux/delay.h>
+#include "internals.h"
 /*
 * Autodetection depends on the fact that any interrupt that
 * comes in on to an unassigned handler will get stuck with
 * "IRQ_WAITING" cleared and the interrupt disabled.
 */
-static DECLARE_MUTEX(probe_sem);
+static DEFINE_MUTEX(probing_active);
 /**
 *      probe_irq_on    - begin an interrupt autodetect
@@ -27,11 +29,11 @@ static DECLARE_MUTEX(probe_sem);
 */
 unsigned long probe_irq_on(void)
 {
-        unsigned long val;
+        struct irq_desc *desc;
-        irq_desc_t *desc;
+        unsigned long mask;
        unsigned int i;
-        down(&probe_sem);
+        mutex_lock(&probing_active);
        /*
         * something may have generated an irq long ago and we want to
         * flush such a longstanding irq before considering it as spurious.
@@ -40,8 +42,21 @@ unsigned long probe_irq_on(void)
                desc = irq_desc + i;
                spin_lock_irq(&desc->lock);
-                if (!irq_desc[i].action)
+                if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
-                        irq_desc[i].handler->startup(i);
+                        /*
+                         * An old-style architecture might still have
+                         * the handle_bad_irq handler there:
+                         */
+                        compat_irq_chip_set_default_handler(desc);
+                        /*
+                         * Some chips need to know about probing in
+                         * progress:
+                         */
+                        if (desc->chip->set_type)
+                                desc->chip->set_type(i, IRQ_TYPE_PROBE);
+                        desc->chip->startup(i);
+                }
                spin_unlock_irq(&desc->lock);
        }
@@ -57,9 +72,9 @@ unsigned long probe_irq_on(void)
                desc = irq_desc + i;
                spin_lock_irq(&desc->lock);
-                if (!desc->action) {
+                if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
                        desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
-                        if (desc->handler->startup(i))
+                        if (desc->chip->startup(i))
                                desc->status |= IRQ_PENDING;
                }
                spin_unlock_irq(&desc->lock);
@@ -73,11 +88,11 @@ unsigned long probe_irq_on(void)
        /*
         * Now filter out any obviously spurious interrupts
         */
-        val = 0;
+        mask = 0;
        for (i = 0; i < NR_IRQS; i++) {
-                irq_desc_t *desc = irq_desc + i;
                unsigned int status;
+                desc = irq_desc + i;
                spin_lock_irq(&desc->lock);
                status = desc->status;
@@ -85,17 +100,16 @@ unsigned long probe_irq_on(void)
                        /* It triggered already - consider it spurious. */
                        if (!(status & IRQ_WAITING)) {
                                desc->status = status & ~IRQ_AUTODETECT;
-                                desc->handler->shutdown(i);
+                                desc->chip->shutdown(i);
                        } else
                                if (i < 32)
-                                        val |= 1 << i;
+                                        mask |= 1 << i;
                }
                spin_unlock_irq(&desc->lock);
        }
-        return val;
+        return mask;
 }
 EXPORT_SYMBOL(probe_irq_on);
 /**
@@ -117,7 +131,7 @@ unsigned int probe_irq_mask(unsigned long val)
        mask = 0;
        for (i = 0; i < NR_IRQS; i++) {
-                irq_desc_t *desc = irq_desc + i;
+                struct irq_desc *desc = irq_desc + i;
                unsigned int status;
                spin_lock_irq(&desc->lock);
@@ -128,11 +142,11 @@ unsigned int probe_irq_mask(unsigned long val)
                                mask |= 1 << i;
                        desc->status = status & ~IRQ_AUTODETECT;
-                        desc->handler->shutdown(i);
+                        desc->chip->shutdown(i);
                }
                spin_unlock_irq(&desc->lock);
        }
-        up(&probe_sem);
+        mutex_unlock(&probing_active);
        return mask & val;
 }
@@ -160,7 +174,7 @@ int probe_irq_off(unsigned long val)
        int i, irq_found = 0, nr_irqs = 0;
        for (i = 0; i < NR_IRQS; i++) {
-                irq_desc_t *desc = irq_desc + i;
+                struct irq_desc *desc = irq_desc + i;
                unsigned int status;
                spin_lock_irq(&desc->lock);
@@ -173,16 +187,16 @@ int probe_irq_off(unsigned long val)
                                nr_irqs++;
                        }
                        desc->status = status & ~IRQ_AUTODETECT;
-                        desc->handler->shutdown(i);
+                        desc->chip->shutdown(i);
                }
                spin_unlock_irq(&desc->lock);
        }
-        up(&probe_sem);
+        mutex_unlock(&probing_active);
        if (nr_irqs > 1)
                irq_found = -irq_found;
        return irq_found;
 }
 EXPORT_SYMBOL(probe_irq_off);
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
new file mode 100644
index 000000000000..4a0952d9458b
--- /dev/null
+++ b/kernel/irq/chip.c
@@ -0,0 +1,525 @@
+/*
+ * linux/kernel/irq/chip.c
+ *
+ * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
+ * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
+ *
+ * This file contains the core interrupt handling code, for irq-chip
+ * based architectures.
+ *
+ * Detailed information is available in Documentation/DocBook/genericirq
+ */
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/kernel_stat.h>
+#include "internals.h"
+/**
+ *      set_irq_chip - set the irq chip for an irq
+ *      @irq:   irq number
+ *      @chip:  pointer to irq chip description structure
+ */
+int set_irq_chip(unsigned int irq, struct irq_chip *chip)
+{
+        struct irq_desc *desc;
+        unsigned long flags;
+        if (irq >= NR_IRQS) {
+                printk(KERN_ERR "Trying to install chip for IRQ%d\n", irq);
+                WARN_ON(1);
+                return -EINVAL;
+        }
+        if (!chip)
+                chip = &no_irq_chip;
+        desc = irq_desc + irq;
+        spin_lock_irqsave(&desc->lock, flags);
+        irq_chip_set_defaults(chip);
+        desc->chip = chip;
+        /*
+         * For compatibility only:
+         */
+        desc->chip = chip;
+        spin_unlock_irqrestore(&desc->lock, flags);
+        return 0;
+}
+EXPORT_SYMBOL(set_irq_chip);
+/**
+ *      set_irq_type - set the irq type for an irq
+ *      @irq:   irq number
+ *      @type:  interrupt type - see include/linux/interrupt.h
+ */
+int set_irq_type(unsigned int irq, unsigned int type)
+{
+        struct irq_desc *desc;
+        unsigned long flags;
+        int ret = -ENXIO;
+        if (irq >= NR_IRQS) {
+                printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
+                return -ENODEV;
+        }
+        desc = irq_desc + irq;
+        if (desc->chip->set_type) {
+                spin_lock_irqsave(&desc->lock, flags);
+                ret = desc->chip->set_type(irq, type);
+                spin_unlock_irqrestore(&desc->lock, flags);
+        }
+        return ret;
+}
+EXPORT_SYMBOL(set_irq_type);
+/**
+ *      set_irq_data - set irq type data for an irq
+ *      @irq:   Interrupt number
+ *      @data:  Pointer to interrupt specific data
+ *
+ *      Set the hardware irq controller data for an irq
+ */
+int set_irq_data(unsigned int irq, void *data)
+{
+        struct irq_desc *desc;
+        unsigned long flags;
+        if (irq >= NR_IRQS) {
+                printk(KERN_ERR
+                       "Trying to install controller data for IRQ%d\n", irq);
+                return -EINVAL;
+        }
+        desc = irq_desc + irq;
+        spin_lock_irqsave(&desc->lock, flags);
+        desc->handler_data = data;
+        spin_unlock_irqrestore(&desc->lock, flags);
+        return 0;
+}
+EXPORT_SYMBOL(set_irq_data);
+/**
+ *      set_irq_chip_data - set irq chip data for an irq
+ *      @irq:   Interrupt number
+ *      @data:  Pointer to chip specific data
+ *
+ *      Set the hardware irq chip data for an irq
+ */
+int set_irq_chip_data(unsigned int irq, void *data)
+{
+        struct irq_desc *desc = irq_desc + irq;
+        unsigned long flags;
+        if (irq >= NR_IRQS || !desc->chip) {
+                printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
+                return -EINVAL;
+        }
+        spin_lock_irqsave(&desc->lock, flags);
+        desc->chip_data = data;
+        spin_unlock_irqrestore(&desc->lock, flags);
+        return 0;
+}
+EXPORT_SYMBOL(set_irq_chip_data);
+/*
+ * default enable function
+ */
+static void default_enable(unsigned int irq)
+{
+        struct irq_desc *desc = irq_desc + irq;
+        desc->chip->unmask(irq);
+        desc->status &= ~IRQ_MASKED;
+}
+/*
+ * default disable function
+ */
+static void default_disable(unsigned int irq)
+{
+        struct irq_desc *desc = irq_desc + irq;
+        if (!(desc->status & IRQ_DELAYED_DISABLE))
+                irq_desc[irq].chip->mask(irq);
+}
+/*
+ * default startup function
+ */
+static unsigned int default_startup(unsigned int irq)
+{
+        irq_desc[irq].chip->enable(irq);
+        return 0;
+}
+/*
+ * Fixup enable/disable function pointers
+ */
+void irq_chip_set_defaults(struct irq_chip *chip)
+{
+        if (!chip->enable)
+                chip->enable = default_enable;
+        if (!chip->disable)
+                chip->disable = default_disable;
+        if (!chip->startup)
+                chip->startup = default_startup;
+        if (!chip->shutdown)
+                chip->shutdown = chip->disable;
+        if (!chip->name)
+                chip->name = chip->typename;
+}
+static inline void mask_ack_irq(struct irq_desc *desc, int irq)
+{
+        if (desc->chip->mask_ack)
+                desc->chip->mask_ack(irq);
+        else {
+                desc->chip->mask(irq);
+                desc->chip->ack(irq);
+        }
+}
+/**
+ *      handle_simple_irq - Simple and software-decoded IRQs.
+ *      @irq:   the interrupt number
+ *      @desc:  the interrupt description structure for this irq
+ *      @regs:  pointer to a register structure
+ *
+ *      Simple interrupts are either sent from a demultiplexing interrupt
+ *      handler or come from hardware, where no interrupt hardware control
+ *      is necessary.
+ *
+ *      Note: The caller is expected to handle the ack, clear, mask and
+ *      unmask issues if necessary.
+ */
+void fastcall
+handle_simple_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
+{
+        struct irqaction *action;
+        irqreturn_t action_ret;
+        const unsigned int cpu = smp_processor_id();
+        spin_lock(&desc->lock);
+        if (unlikely(desc->status & IRQ_INPROGRESS))
+                goto out_unlock;
+        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
+        kstat_cpu(cpu).irqs[irq]++;
+        action = desc->action;
+        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
+                goto out_unlock;
+        desc->status |= IRQ_INPROGRESS;
+        spin_unlock(&desc->lock);
+        action_ret = handle_IRQ_event(irq, regs, action);
+        if (!noirqdebug)
+                note_interrupt(irq, desc, action_ret, regs);
+        spin_lock(&desc->lock);
+        desc->status &= ~IRQ_INPROGRESS;
+out_unlock:
+        spin_unlock(&desc->lock);
+}
+/**
+ *      handle_level_irq - Level type irq handler
+ *      @irq:   the interrupt number
+ *      @desc:  the interrupt description structure for this irq
+ *      @regs:  pointer to a register structure
+ *
+ *      Level type interrupts are active as long as the hardware line has
+ *      the active level. This may require to mask the interrupt and unmask
+ *      it after the associated handler has acknowledged the device, so the
+ *      interrupt line is back to inactive.
+ */
+void fastcall
+handle_level_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
+{
+        unsigned int cpu = smp_processor_id();
+        struct irqaction *action;
+        irqreturn_t action_ret;
+        spin_lock(&desc->lock);
+        mask_ack_irq(desc, irq);
+        if (unlikely(desc->status & IRQ_INPROGRESS))
+                goto out;
+        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
+        kstat_cpu(cpu).irqs[irq]++;
+        /*
+         * If its disabled or no action available
+         * keep it masked and get out of here
+         */
+        action = desc->action;
+        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
+                goto out;
+        desc->status |= IRQ_INPROGRESS;
+        spin_unlock(&desc->lock);
+        action_ret = handle_IRQ_event(irq, regs, action);
+        if (!noirqdebug)
+                note_interrupt(irq, desc, action_ret, regs);
+        spin_lock(&desc->lock);
+        desc->status &= ~IRQ_INPROGRESS;
+out:
+        if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
+                desc->chip->unmask(irq);
+        spin_unlock(&desc->lock);
+}
+/**
+ *      handle_fasteoi_irq - irq handler for transparent controllers
+ *      @irq:   the interrupt number
+ *      @desc:  the interrupt description structure for this irq
+ *      @regs:  pointer to a register structure
+ *
+ *      Only a single callback will be issued to the chip: an ->eoi()
+ *      call when the interrupt has been serviced. This enables support
+ *      for modern forms of interrupt handlers, which handle the flow
+ *      details in hardware, transparently.
+ */
+void fastcall
+handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc,
+                   struct pt_regs *regs)
+{
+        unsigned int cpu = smp_processor_id();
+        struct irqaction *action;
+        irqreturn_t action_ret;
+        spin_lock(&desc->lock);
+        if (unlikely(desc->status & IRQ_INPROGRESS))
+                goto out;
+        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
+        kstat_cpu(cpu).irqs[irq]++;
+        /*
+         * If its disabled or no action available
+         * keep it masked and get out of here
+         */
+        action = desc->action;
+        if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
+                desc->status |= IRQ_PENDING;
+                goto out;
+        }
+        desc->status |= IRQ_INPROGRESS;
+        desc->status &= ~IRQ_PENDING;
+        spin_unlock(&desc->lock);
+        action_ret = handle_IRQ_event(irq, regs, action);
+        if (!noirqdebug)
+                note_interrupt(irq, desc, action_ret, regs);
+        spin_lock(&desc->lock);
+        desc->status &= ~IRQ_INPROGRESS;
+out:
+        desc->chip->eoi(irq);
+        spin_unlock(&desc->lock);
+}
+/**
+ *      handle_edge_irq - edge type IRQ handler
+ *      @irq:   the interrupt number
+ *      @desc:  the interrupt description structure for this irq
+ *      @regs:  pointer to a register structure
+ *
+ *      Interrupt occures on the falling and/or rising edge of a hardware
+ *      signal. The occurence is latched into the irq controller hardware
+ *      and must be acked in order to be reenabled. After the ack another
+ *      interrupt can happen on the same source even before the first one
+ *      is handled by the assosiacted event handler. If this happens it
+ *      might be necessary to disable (mask) the interrupt depending on the
+ *      controller hardware. This requires to reenable the interrupt inside
+ *      of the loop which handles the interrupts which have arrived while
+ *      the handler was running. If all pending interrupts are handled, the
+ *      loop is left.
+ */
+void fastcall
+handle_edge_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
+{
+        const unsigned int cpu = smp_processor_id();
+        spin_lock(&desc->lock);
+        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
+        /*
+         * If we're currently running this IRQ, or its disabled,
+         * we shouldn't process the IRQ. Mark it pending, handle
+         * the necessary masking and go out
+         */
+        if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
+                    !desc->action)) {
+                desc->status |= (IRQ_PENDING | IRQ_MASKED);
+                mask_ack_irq(desc, irq);
+                goto out_unlock;
+        }
+        kstat_cpu(cpu).irqs[irq]++;
+        /* Start handling the irq */
+        desc->chip->ack(irq);
+        /* Mark the IRQ currently in progress.*/
+        desc->status |= IRQ_INPROGRESS;
+        do {
+                struct irqaction *action = desc->action;
+                irqreturn_t action_ret;
+                if (unlikely(!action)) {
+                        desc->chip->mask(irq);
+                        goto out_unlock;
+                }
+                /*
+                 * When another irq arrived while we were handling
+                 * one, we could have masked the irq.
+                 * Renable it, if it was not disabled in meantime.
+                 */
+                if (unlikely((desc->status &
+                               (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
+                              (IRQ_PENDING | IRQ_MASKED))) {
+                        desc->chip->unmask(irq);
+                        desc->status &= ~IRQ_MASKED;
+                }
+                desc->status &= ~IRQ_PENDING;
+                spin_unlock(&desc->lock);
+                action_ret = handle_IRQ_event(irq, regs, action);
+                if (!noirqdebug)
+                        note_interrupt(irq, desc, action_ret, regs);
+                spin_lock(&desc->lock);
+        } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
+        desc->status &= ~IRQ_INPROGRESS;
+out_unlock:
+        spin_unlock(&desc->lock);
+}
+#ifdef CONFIG_SMP
+/**
+ *      handle_percpu_IRQ - Per CPU local irq handler
+ *      @irq:   the interrupt number
+ *      @desc:  the interrupt description structure for this irq
+ *      @regs:  pointer to a register structure
+ *
+ *      Per CPU interrupts on SMP machines without locking requirements
+ */
+void fastcall
+handle_percpu_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
+{
+        irqreturn_t action_ret;
+        kstat_this_cpu.irqs[irq]++;
+        if (desc->chip->ack)
+                desc->chip->ack(irq);
+        action_ret = handle_IRQ_event(irq, regs, desc->action);
+        if (!noirqdebug)
+                note_interrupt(irq, desc, action_ret, regs);
+        if (desc->chip->eoi)
+                desc->chip->eoi(irq);
+}
+#endif /* CONFIG_SMP */
+void
+__set_irq_handler(unsigned int irq,
+                  void fastcall (*handle)(unsigned int, irq_desc_t *,
+                                          struct pt_regs *),
+                  int is_chained)
+{
+        struct irq_desc *desc;
+        unsigned long flags;
+        if (irq >= NR_IRQS) {
+                printk(KERN_ERR
+                       "Trying to install type control for IRQ%d\n", irq);
+                return;
+        }
+        desc = irq_desc + irq;
+        if (!handle)
+                handle = handle_bad_irq;
+        if (is_chained && desc->chip == &no_irq_chip)
+                printk(KERN_WARNING "Trying to install "
+                       "chained interrupt type for IRQ%d\n", irq);
+        spin_lock_irqsave(&desc->lock, flags);
+        /* Uninstall? */
+        if (handle == handle_bad_irq) {
+                if (desc->chip != &no_irq_chip) {
+                        desc->chip->mask(irq);
+                        desc->chip->ack(irq);
+                }
+                desc->status |= IRQ_DISABLED;
+                desc->depth = 1;
+        }
+        desc->handle_irq = handle;
+        if (handle != handle_bad_irq && is_chained) {
+                desc->status &= ~IRQ_DISABLED;
+                desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
+                desc->depth = 0;
+                desc->chip->unmask(irq);
+        }
+        spin_unlock_irqrestore(&desc->lock, flags);
+}
+void
+set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
+                         void fastcall (*handle)(unsigned int,
+                                                 struct irq_desc *,
+                                                 struct pt_regs *))
+{
+        set_irq_chip(irq, chip);
+        __set_irq_handler(irq, handle, 0);
+}
+/*
+ * Get a descriptive string for the highlevel handler, for
+ * /proc/interrupts output:
+ */
+const char *
+handle_irq_name(void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                        struct pt_regs *))
+{
+        if (handle == handle_level_irq)
+                return "level  ";
+        if (handle == handle_fasteoi_irq)
+                return "fasteoi";
+        if (handle == handle_edge_irq)
+                return "edge   ";
+        if (handle == handle_simple_irq)
+                return "simple ";
+#ifdef CONFIG_SMP
+        if (handle == handle_percpu_irq)
+                return "percpu ";
+#endif
+        if (handle == handle_bad_irq)
+                return "bad    ";
+        return NULL;
+}
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 0f6530117105..5a360dd4331b 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -1,9 +1,13 @@
 /*
 * linux/kernel/irq/handle.c
 *
- * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
+ * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
+ * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
 *
 * This file contains the core interrupt handling code.
+ *
+ * Detailed information is available in Documentation/DocBook/genericirq
+ *
 */
 #include <linux/irq.h>
@@ -14,11 +18,22 @@
 #include "internals.h"
+/**
+ * handle_bad_irq - handle spurious and unhandled irqs
+ */
+void fastcall
+handle_bad_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
+{
+        print_irq_desc(irq, desc);
+        kstat_this_cpu.irqs[irq]++;
+        ack_bad_irq(irq);
+}
 /*
 * Linux has a controller-independent interrupt architecture.
 * Every controller has a 'controller-template', that is used
 * by the main code to do the right thing. Each driver-visible
- * interrupt source is transparently wired to the apropriate
+ * interrupt source is transparently wired to the appropriate
 * controller. Thus drivers need not be aware of the
 * interrupt-controller.
 *
@@ -28,41 +43,52 @@
 *
 * Controller mappings for all interrupt sources:
 */
-irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned = {
+struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned = {
        [0 ... NR_IRQS-1] = {
                .status = IRQ_DISABLED,
-                .handler = &no_irq_type,
+                .chip = &no_irq_chip,
-                .lock = SPIN_LOCK_UNLOCKED
+                .handle_irq = handle_bad_irq,
+                .depth = 1,
+                .lock = SPIN_LOCK_UNLOCKED,
+#ifdef CONFIG_SMP
+                .affinity = CPU_MASK_ALL
+#endif
        }
 };
 /*
- * Generic 'no controller' code
+ * What should we do if we get a hw irq event on an illegal vector?
+ * Each architecture has to answer this themself.
 */
-static void end_none(unsigned int irq) { }
+static void ack_bad(unsigned int irq)
-static void enable_none(unsigned int irq) { }
-static void disable_none(unsigned int irq) { }
-static void shutdown_none(unsigned int irq) { }
-static unsigned int startup_none(unsigned int irq) { return 0; }
-static void ack_none(unsigned int irq)
 {
-        /*
+        print_irq_desc(irq, irq_desc + irq);
-         * 'what should we do if we get a hw irq event on an illegal vector'.
-         * each architecture has to answer this themself.
-         */
        ack_bad_irq(irq);
 }
-struct hw_interrupt_type no_irq_type = {
+/*
-        .typename =     "none",
+ * NOP functions
-        .startup =      startup_none,
+ */
-        .shutdown =     shutdown_none,
+static void noop(unsigned int irq)
-        .enable =       enable_none,
+{
-        .disable =      disable_none,
+}
-        .ack =          ack_none,
-        .end =          end_none,
+static unsigned int noop_ret(unsigned int irq)
-        .set_affinity = NULL
+{
+        return 0;
+}
+/*
+ * Generic no controller implementation
+ */
+struct irq_chip no_irq_chip = {
+        .name           = "none",
+        .startup        = noop_ret,
+        .shutdown       = noop,
+        .enable         = noop,
+        .disable        = noop,
+        .ack            = ack_bad,
+        .end            = noop,
 };
 /*
@@ -73,11 +99,16 @@ irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs)
        return IRQ_NONE;
 }
-/*
+/**
- * Have got an event to handle:
+ * handle_IRQ_event - irq action chain handler
+ * @irq:        the interrupt number
+ * @regs:       pointer to a register structure
+ * @action:     the interrupt action chain for this irq
+ *
+ * Handles the action chain of an irq event
 */
-fastcall irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
+irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
-                                struct irqaction *action)
+                             struct irqaction *action)
 {
        irqreturn_t ret, retval = IRQ_NONE;
        unsigned int status = 0;
@@ -100,15 +131,22 @@ fastcall irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
        return retval;
 }
-/*
+/**
- * do_IRQ handles all normal device IRQ's (the special
+ * __do_IRQ - original all in one highlevel IRQ handler
+ * @irq:        the interrupt number
+ * @regs:       pointer to a register structure
+ *
+ * __do_IRQ handles all normal device IRQ's (the special
 * SMP cross-CPU interrupts have their own specific
 * handlers).
+ *
+ * This is the original x86 implementation which is used for every
+ * interrupt type.
 */
 fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
 {
-        irq_desc_t *desc = irq_desc + irq;
+        struct irq_desc *desc = irq_desc + irq;
-        struct irqaction * action;
+        struct irqaction *action;
        unsigned int status;
        kstat_this_cpu.irqs[irq]++;
@@ -118,16 +156,16 @@ fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs)
                /*
                 * No locking required for CPU-local interrupts:
                 */
-                if (desc->handler->ack)
+                if (desc->chip->ack)
-                        desc->handler->ack(irq);
+                        desc->chip->ack(irq);
                action_ret = handle_IRQ_event(irq, regs, desc->action);
-                desc->handler->end(irq);
+                desc->chip->end(irq);
                return 1;
        }
        spin_lock(&desc->lock);
-        if (desc->handler->ack)
+        if (desc->chip->ack)
-                desc->handler->ack(irq);
+                desc->chip->ack(irq);
        /*
         * REPLAY is when Linux resends an IRQ that was dropped earlier
         * WAITING is used by probe to mark irqs that are being tested
@@ -187,7 +225,7 @@ out:
         * The ->end() handler has to deal with interrupts which got
         * disabled while the handler was running.
         */
-        desc->handler->end(irq);
+        desc->chip->end(irq);
        spin_unlock(&desc->lock);
        return 1;
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index 46feba630266..08a849a22447 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -4,6 +4,12 @@
 extern int noirqdebug;
+/* Set default functions for irq_chip structures: */
+extern void irq_chip_set_defaults(struct irq_chip *chip);
+/* Set default handler: */
+extern void compat_irq_chip_set_default_handler(struct irq_desc *desc);
 #ifdef CONFIG_PROC_FS
 extern void register_irq_proc(unsigned int irq);
 extern void register_handler_proc(unsigned int irq, struct irqaction *action);
@@ -16,3 +22,43 @@ static inline void unregister_handler_proc(unsigned int irq,
                                           struct irqaction *action) { }
 #endif
+/*
+ * Debugging printout:
+ */
+#include <linux/kallsyms.h>
+#define P(f) if (desc->status & f) printk("%14s set\n", #f)
+static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
+{
+        printk("irq %d, desc: %p, depth: %d, count: %d, unhandled: %d\n",
+                irq, desc, desc->depth, desc->irq_count, desc->irqs_unhandled);
+        printk("->handle_irq():  %p, ", desc->handle_irq);
+        print_symbol("%s\n", (unsigned long)desc->handle_irq);
+        printk("->chip(): %p, ", desc->chip);
+        print_symbol("%s\n", (unsigned long)desc->chip);
+        printk("->action(): %p\n", desc->action);
+        if (desc->action) {
+                printk("->action->handler(): %p, ", desc->action->handler);
+                print_symbol("%s\n", (unsigned long)desc->action->handler);
+        }
+        P(IRQ_INPROGRESS);
+        P(IRQ_DISABLED);
+        P(IRQ_PENDING);
+        P(IRQ_REPLAY);
+        P(IRQ_AUTODETECT);
+        P(IRQ_WAITING);
+        P(IRQ_LEVEL);
+        P(IRQ_MASKED);
+#ifdef CONFIG_IRQ_PER_CPU
+        P(IRQ_PER_CPU);
+#endif
+        P(IRQ_NOPROBE);
+        P(IRQ_NOREQUEST);
+        P(IRQ_NOAUTOEN);
+}
+#undef P
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 1279e3499534..9eb1d518ee1c 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -1,7 +1,8 @@
 /*
 * linux/kernel/irq/manage.c
 *
- * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
+ * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
+ * Copyright (C) 2005-2006 Thomas Gleixner
 *
 * This file contains driver APIs to the irq subsystem.
 */
@@ -16,12 +17,6 @@
 #ifdef CONFIG_SMP
-cpumask_t irq_affinity[NR_IRQS] = { [0 ... NR_IRQS-1] = CPU_MASK_ALL };
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
-cpumask_t __cacheline_aligned pending_irq_cpumask[NR_IRQS];
-#endif
 /**
 *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
 *      @irq: interrupt number to wait for
@@ -42,7 +37,6 @@ void synchronize_irq(unsigned int irq)
        while (desc->status & IRQ_INPROGRESS)
                cpu_relax();
 }
 EXPORT_SYMBOL(synchronize_irq);
 #endif
@@ -60,7 +54,7 @@ EXPORT_SYMBOL(synchronize_irq);
 */
 void disable_irq_nosync(unsigned int irq)
 {
-        irq_desc_t *desc = irq_desc + irq;
+        struct irq_desc *desc = irq_desc + irq;
        unsigned long flags;
        if (irq >= NR_IRQS)
@@ -69,11 +63,10 @@ void disable_irq_nosync(unsigned int irq)
        spin_lock_irqsave(&desc->lock, flags);
        if (!desc->depth++) {
                desc->status |= IRQ_DISABLED;
-                desc->handler->disable(irq);
+                desc->chip->disable(irq);
        }
        spin_unlock_irqrestore(&desc->lock, flags);
 }
 EXPORT_SYMBOL(disable_irq_nosync);
 /**
@@ -90,7 +83,7 @@ EXPORT_SYMBOL(disable_irq_nosync);
 */
 void disable_irq(unsigned int irq)
 {
-        irq_desc_t *desc = irq_desc + irq;
+        struct irq_desc *desc = irq_desc + irq;
        if (irq >= NR_IRQS)
                return;
@@ -99,7 +92,6 @@ void disable_irq(unsigned int irq)
        if (desc->action)
                synchronize_irq(irq);
 }
 EXPORT_SYMBOL(disable_irq);
 /**
@@ -114,7 +106,7 @@ EXPORT_SYMBOL(disable_irq);
 */
 void enable_irq(unsigned int irq)
 {
-        irq_desc_t *desc = irq_desc + irq;
+        struct irq_desc *desc = irq_desc + irq;
        unsigned long flags;
        if (irq >= NR_IRQS)
@@ -123,17 +115,15 @@ void enable_irq(unsigned int irq)
        spin_lock_irqsave(&desc->lock, flags);
        switch (desc->depth) {
        case 0:
+                printk(KERN_WARNING "Unablanced enable_irq(%d)\n", irq);
                WARN_ON(1);
                break;
        case 1: {
                unsigned int status = desc->status & ~IRQ_DISABLED;
-                desc->status = status;
+                /* Prevent probing on this irq: */
-                if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
+                desc->status = status | IRQ_NOPROBE;
-                        desc->status = status | IRQ_REPLAY;
+                check_irq_resend(desc, irq);
-                        hw_resend_irq(desc->handler,irq);
-                }
-                desc->handler->enable(irq);
                /* fall-through */
        }
        default:
@@ -141,9 +131,29 @@ void enable_irq(unsigned int irq)
        }
        spin_unlock_irqrestore(&desc->lock, flags);
 }
 EXPORT_SYMBOL(enable_irq);
+/**
+ *      set_irq_wake - control irq power management wakeup
+ *      @irq:   interrupt to control
+ *      @on:    enable/disable power management wakeup
+ *
+ *      Enable/disable power management wakeup mode
+ */
+int set_irq_wake(unsigned int irq, unsigned int on)
+{
+        struct irq_desc *desc = irq_desc + irq;
+        unsigned long flags;
+        int ret = -ENXIO;
+        spin_lock_irqsave(&desc->lock, flags);
+        if (desc->chip->set_wake)
+                ret = desc->chip->set_wake(irq, on);
+        spin_unlock_irqrestore(&desc->lock, flags);
+        return ret;
+}
+EXPORT_SYMBOL(set_irq_wake);
 /*
 * Internal function that tells the architecture code whether a
 * particular irq has been exclusively allocated or is available
@@ -153,7 +163,7 @@ int can_request_irq(unsigned int irq, unsigned long irqflags)
 {
        struct irqaction *action;
-        if (irq >= NR_IRQS)
+        if (irq >= NR_IRQS || irq_desc[irq].status & IRQ_NOREQUEST)
                return 0;
        action = irq_desc[irq].action;
@@ -164,11 +174,22 @@ int can_request_irq(unsigned int irq, unsigned long irqflags)
        return !action;
 }
+void compat_irq_chip_set_default_handler(struct irq_desc *desc)
+{
+        /*
+         * If the architecture still has not overriden
+         * the flow handler then zap the default. This
+         * should catch incorrect flow-type setting.
+         */
+        if (desc->handle_irq == &handle_bad_irq)
+                desc->handle_irq = NULL;
+}
 /*
 * Internal function to register an irqaction - typically used to
 * allocate special interrupts that are part of the architecture.
 */
-int setup_irq(unsigned int irq, struct irqaction * new)
+int setup_irq(unsigned int irq, struct irqaction *new)
 {
        struct irq_desc *desc = irq_desc + irq;
        struct irqaction *old, **p;
@@ -178,7 +199,7 @@ int setup_irq(unsigned int irq, struct irqaction * new)
        if (irq >= NR_IRQS)
                return -EINVAL;
-        if (desc->handler == &no_irq_type)
+        if (desc->chip == &no_irq_chip)
                return -ENOSYS;
        /*
         * Some drivers like serial.c use request_irq() heavily,
@@ -200,14 +221,21 @@ int setup_irq(unsigned int irq, struct irqaction * new)
        /*
         * The following block of code has to be executed atomically
         */
-        spin_lock_irqsave(&desc->lock,flags);
+        spin_lock_irqsave(&desc->lock, flags);
        p = &desc->action;
-        if ((old = *p) != NULL) {
+        old = *p;
-                /* Can't share interrupts unless both agree to */
+        if (old) {
-                if (!(old->flags & new->flags & SA_SHIRQ))
+                /*
+                 * Can't share interrupts unless both agree to and are
+                 * the same type (level, edge, polarity). So both flag
+                 * fields must have SA_SHIRQ set and the bits which
+                 * set the trigger type must match.
+                 */
+                if (!((old->flags & new->flags) & SA_SHIRQ) ||
+                    ((old->flags ^ new->flags) & SA_TRIGGER_MASK))
                        goto mismatch;
-#if defined(ARCH_HAS_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
+#if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
                /* All handlers must agree on per-cpuness */
                if ((old->flags & IRQ_PER_CPU) != (new->flags & IRQ_PER_CPU))
                        goto mismatch;
@@ -222,20 +250,44 @@ int setup_irq(unsigned int irq, struct irqaction * new)
        }
        *p = new;
-#if defined(ARCH_HAS_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
+#if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
        if (new->flags & SA_PERCPU_IRQ)
                desc->status |= IRQ_PER_CPU;
 #endif
        if (!shared) {
-                desc->depth = 0;
+                irq_chip_set_defaults(desc->chip);
-                desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT |
-                                  IRQ_WAITING | IRQ_INPROGRESS);
+                /* Setup the type (level, edge polarity) if configured: */
-                if (desc->handler->startup)
+                if (new->flags & SA_TRIGGER_MASK) {
-                        desc->handler->startup(irq);
+                        if (desc->chip && desc->chip->set_type)
-                else
+                                desc->chip->set_type(irq,
-                        desc->handler->enable(irq);
+                                                new->flags & SA_TRIGGER_MASK);
+                        else
+                                /*
+                                 * SA_TRIGGER_* but the PIC does not support
+                                 * multiple flow-types?
+                                 */
+                                printk(KERN_WARNING "setup_irq(%d) SA_TRIGGER"
+                                       "set. No set_type function available\n",
+                                       irq);
+                } else
+                        compat_irq_chip_set_default_handler(desc);
+                desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
+                                  IRQ_INPROGRESS);
+                if (!(desc->status & IRQ_NOAUTOEN)) {
+                        desc->depth = 0;
+                        desc->status &= ~IRQ_DISABLED;
+                        if (desc->chip->startup)
+                                desc->chip->startup(irq);
+                        else
+                                desc->chip->enable(irq);
+                } else
+                        /* Undo nested disables: */
+                        desc->depth = 1;
        }
-        spin_unlock_irqrestore(&desc->lock,flags);
+        spin_unlock_irqrestore(&desc->lock, flags);
        new->irq = irq;
        register_irq_proc(irq);
@@ -278,10 +330,10 @@ void free_irq(unsigned int irq, void *dev_id)
                return;
        desc = irq_desc + irq;
-        spin_lock_irqsave(&desc->lock,flags);
+        spin_lock_irqsave(&desc->lock, flags);
        p = &desc->action;
        for (;;) {
-                struct irqaction * action = *p;
+                struct irqaction *action = *p;
                if (action) {
                        struct irqaction **pp = p;
@@ -295,18 +347,18 @@ void free_irq(unsigned int irq, void *dev_id)
                        /* Currently used only by UML, might disappear one day.*/
 #ifdef CONFIG_IRQ_RELEASE_METHOD
-                        if (desc->handler->release)
+                        if (desc->chip->release)
-                                desc->handler->release(irq, dev_id);
+                                desc->chip->release(irq, dev_id);
 #endif
                        if (!desc->action) {
                                desc->status |= IRQ_DISABLED;
-                                if (desc->handler->shutdown)
+                                if (desc->chip->shutdown)
-                                        desc->handler->shutdown(irq);
+                                        desc->chip->shutdown(irq);
                                else
-                                        desc->handler->disable(irq);
+                                        desc->chip->disable(irq);
                        }
-                        spin_unlock_irqrestore(&desc->lock,flags);
+                        spin_unlock_irqrestore(&desc->lock, flags);
                        unregister_handler_proc(irq, action);
                        /* Make sure it's not being used on another CPU */
@@ -314,12 +366,11 @@ void free_irq(unsigned int irq, void *dev_id)
                        kfree(action);
                        return;
                }
-                printk(KERN_ERR "Trying to free free IRQ%d\n",irq);
+                printk(KERN_ERR "Trying to free free IRQ%d\n", irq);
-                spin_unlock_irqrestore(&desc->lock,flags);
+                spin_unlock_irqrestore(&desc->lock, flags);
                return;
        }
 }
 EXPORT_SYMBOL(free_irq);
 /**
@@ -353,9 +404,9 @@ EXPORT_SYMBOL(free_irq);
 */
 int request_irq(unsigned int irq,
                irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                unsigned long irqflags, const char * devname, void *dev_id)
+                unsigned long irqflags, const char *devname, void *dev_id)
 {
-        struct irqaction * action;
+        struct irqaction *action;
        int retval;
        /*
@@ -368,6 +419,8 @@ int request_irq(unsigned int irq,
                return -EINVAL;
        if (irq >= NR_IRQS)
                return -EINVAL;
+        if (irq_desc[irq].status & IRQ_NOREQUEST)
+                return -EINVAL;
        if (!handler)
                return -EINVAL;
@@ -390,6 +443,5 @@ int request_irq(unsigned int irq,
        return retval;
 }
 EXPORT_SYMBOL(request_irq);
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index a12d00eb5e7c..a57ebe9fa6f6 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -3,19 +3,19 @@
 void set_pending_irq(unsigned int irq, cpumask_t mask)
 {
-        irq_desc_t *desc = irq_desc + irq;
+        struct irq_desc *desc = irq_desc + irq;
        unsigned long flags;
        spin_lock_irqsave(&desc->lock, flags);
        desc->move_irq = 1;
-        pending_irq_cpumask[irq] = mask;
+        irq_desc[irq].pending_mask = mask;
        spin_unlock_irqrestore(&desc->lock, flags);
 }
 void move_native_irq(int irq)
 {
+        struct irq_desc *desc = irq_desc + irq;
        cpumask_t tmp;
-        irq_desc_t *desc = irq_descp(irq);
        if (likely(!desc->move_irq))
                return;
@@ -30,15 +30,15 @@ void move_native_irq(int irq)
        desc->move_irq = 0;
-        if (unlikely(cpus_empty(pending_irq_cpumask[irq])))
+        if (unlikely(cpus_empty(irq_desc[irq].pending_mask)))
                return;
-        if (!desc->handler->set_affinity)
+        if (!desc->chip->set_affinity)
                return;
        assert_spin_locked(&desc->lock);
-        cpus_and(tmp, pending_irq_cpumask[irq], cpu_online_map);
+        cpus_and(tmp, irq_desc[irq].pending_mask, cpu_online_map);
        /*
         * If there was a valid mask to work with, please
@@ -51,12 +51,12 @@ void move_native_irq(int irq)
         */
        if (likely(!cpus_empty(tmp))) {
                if (likely(!(desc->status & IRQ_DISABLED)))
-                        desc->handler->disable(irq);
+                        desc->chip->disable(irq);
-                desc->handler->set_affinity(irq,tmp);
+                desc->chip->set_affinity(irq,tmp);
                if (likely(!(desc->status & IRQ_DISABLED)))
-                        desc->handler->enable(irq);
+                        desc->chip->enable(irq);
        }
-        cpus_clear(pending_irq_cpumask[irq]);
+        cpus_clear(irq_desc[irq].pending_mask);
 }
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index afacd6f585fa..607c7809ad01 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -12,15 +12,10 @@
 #include "internals.h"
-static struct proc_dir_entry *root_irq_dir, *irq_dir[NR_IRQS];
+static struct proc_dir_entry *root_irq_dir;
 #ifdef CONFIG_SMP
-/*
- * The /proc/irq/<irq>/smp_affinity values:
- */
-static struct proc_dir_entry *smp_affinity_entry[NR_IRQS];
 #ifdef CONFIG_GENERIC_PENDING_IRQ
 void proc_set_irq_affinity(unsigned int irq, cpumask_t mask_val)
 {
@@ -36,15 +31,15 @@ void proc_set_irq_affinity(unsigned int irq, cpumask_t mask_val)
 void proc_set_irq_affinity(unsigned int irq, cpumask_t mask_val)
 {
        set_balance_irq_affinity(irq, mask_val);
-        irq_affinity[irq] = mask_val;
+        irq_desc[irq].affinity = mask_val;
-        irq_desc[irq].handler->set_affinity(irq, mask_val);
+        irq_desc[irq].chip->set_affinity(irq, mask_val);
 }
 #endif
 static int irq_affinity_read_proc(char *page, char **start, off_t off,
                                  int count, int *eof, void *data)
 {
-        int len = cpumask_scnprintf(page, count, irq_affinity[(long)data]);
+        int len = cpumask_scnprintf(page, count, irq_desc[(long)data].affinity);
        if (count - len < 2)
                return -EINVAL;
@@ -59,7 +54,7 @@ static int irq_affinity_write_proc(struct file *file, const char __user *buffer,
        unsigned int irq = (int)(long)data, full_count = count, err;
        cpumask_t new_value, tmp;
-        if (!irq_desc[irq].handler->set_affinity || no_irq_affinity)
+        if (!irq_desc[irq].chip->set_affinity || no_irq_affinity)
                return -EIO;
        err = cpumask_parse(buffer, count, new_value);
@@ -102,7 +97,7 @@ void register_handler_proc(unsigned int irq, struct irqaction *action)
 {
        char name [MAX_NAMELEN];
-        if (!irq_dir[irq] || action->dir || !action->name ||
+        if (!irq_desc[irq].dir || action->dir || !action->name ||
                                        !name_unique(irq, action))
                return;
@@ -110,7 +105,7 @@ void register_handler_proc(unsigned int irq, struct irqaction *action)
        snprintf(name, MAX_NAMELEN, "%s", action->name);
        /* create /proc/irq/1234/handler/ */
-        action->dir = proc_mkdir(name, irq_dir[irq]);
+        action->dir = proc_mkdir(name, irq_desc[irq].dir);
 }
 #undef MAX_NAMELEN
@@ -122,22 +117,22 @@ void register_irq_proc(unsigned int irq)
        char name [MAX_NAMELEN];
        if (!root_irq_dir ||
-                (irq_desc[irq].handler == &no_irq_type) ||
+                (irq_desc[irq].chip == &no_irq_chip) ||
-                        irq_dir[irq])
+                        irq_desc[irq].dir)
                return;
        memset(name, 0, MAX_NAMELEN);
        sprintf(name, "%d", irq);
        /* create /proc/irq/1234 */
-        irq_dir[irq] = proc_mkdir(name, root_irq_dir);
+        irq_desc[irq].dir = proc_mkdir(name, root_irq_dir);
 #ifdef CONFIG_SMP
        {
                struct proc_dir_entry *entry;
                /* create /proc/irq/<irq>/smp_affinity */
-                entry = create_proc_entry("smp_affinity", 0600, irq_dir[irq]);
+                entry = create_proc_entry("smp_affinity", 0600, irq_desc[irq].dir);
                if (entry) {
                        entry->nlink = 1;
@@ -145,7 +140,6 @@ void register_irq_proc(unsigned int irq)
                        entry->read_proc = irq_affinity_read_proc;
                        entry->write_proc = irq_affinity_write_proc;
                }
-                smp_affinity_entry[irq] = entry;
        }
 #endif
 }
@@ -155,7 +149,7 @@ void register_irq_proc(unsigned int irq)
 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
 {
        if (action->dir)
-                remove_proc_entry(action->dir->name, irq_dir[irq]);
+                remove_proc_entry(action->dir->name, irq_desc[irq].dir);
 }
 void init_irq_proc(void)
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
new file mode 100644
index 000000000000..872f91ba2ce8
--- /dev/null
+++ b/kernel/irq/resend.c
@@ -0,0 +1,78 @@
+/*
+ * linux/kernel/irq/resend.c
+ *
+ * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
+ * Copyright (C) 2005-2006, Thomas Gleixner
+ *
+ * This file contains the IRQ-resend code
+ *
+ * If the interrupt is waiting to be processed, we try to re-run it.
+ * We can't directly run it from here since the caller might be in an
+ * interrupt-protected region. Not all irq controller chips can
+ * retrigger interrupts at the hardware level, so in those cases
+ * we allow the resending of IRQs via a tasklet.
+ */
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/random.h>
+#include <linux/interrupt.h>
+#include "internals.h"
+#ifdef CONFIG_HARDIRQS_SW_RESEND
+/* Bitmap to handle software resend of interrupts: */
+static DECLARE_BITMAP(irqs_resend, NR_IRQS);
+/*
+ * Run software resends of IRQ's
+ */
+static void resend_irqs(unsigned long arg)
+{
+        struct irq_desc *desc;
+        int irq;
+        while (!bitmap_empty(irqs_resend, NR_IRQS)) {
+                irq = find_first_bit(irqs_resend, NR_IRQS);
+                clear_bit(irq, irqs_resend);
+                desc = irq_desc + irq;
+                local_irq_disable();
+                desc->handle_irq(irq, desc, NULL);
+                local_irq_enable();
+        }
+}
+/* Tasklet to handle resend: */
+static DECLARE_TASKLET(resend_tasklet, resend_irqs, 0);
+#endif
+/*
+ * IRQ resend
+ *
+ * Is called with interrupts disabled and desc->lock held.
+ */
+void check_irq_resend(struct irq_desc *desc, unsigned int irq)
+{
+        unsigned int status = desc->status;
+        /*
+         * Make sure the interrupt is enabled, before resending it:
+         */
+        desc->chip->enable(irq);
+        if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
+                desc->status &= ~IRQ_PENDING;
+                desc->status = status | IRQ_REPLAY;
+                if (!desc->chip || !desc->chip->retrigger ||
+                                        !desc->chip->retrigger(irq)) {
+#ifdef CONFIG_HARDIRQS_SW_RESEND
+                        /* Set it pending and activate the softirq: */
+                        set_bit(irq, irqs_resend);
+                        tasklet_schedule(&resend_tasklet);
+#endif
+                }
+        }
+}
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index b2fb3c18d06b..b483deed311c 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -16,22 +16,20 @@ static int irqfixup __read_mostly;
 /*
 * Recovery handler for misrouted interrupts.
 */
 static int misrouted_irq(int irq, struct pt_regs *regs)
 {
        int i;
-        irq_desc_t *desc;
        int ok = 0;
        int work = 0;   /* Did we do work for a real IRQ */
-        for(i = 1; i < NR_IRQS; i++) {
+        for (i = 1; i < NR_IRQS; i++) {
+                struct irq_desc *desc = irq_desc + i;
                struct irqaction *action;
                if (i == irq)   /* Already tried */
                        continue;
-                desc = &irq_desc[i];
                spin_lock(&desc->lock);
-                action = desc->action;
                /* Already running on another processor */
                if (desc->status & IRQ_INPROGRESS) {
                        /*
@@ -45,7 +43,9 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
                }
                /* Honour the normal IRQ locking */
                desc->status |= IRQ_INPROGRESS;
+                action = desc->action;
                spin_unlock(&desc->lock);
                while (action) {
                        /* Only shared IRQ handlers are safe to call */
                        if (action->flags & SA_SHIRQ) {
@@ -62,9 +62,8 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
                /*
                 * While we were looking for a fixup someone queued a real
-                 * IRQ clashing with our walk
+                 * IRQ clashing with our walk:
                 */
                while ((desc->status & IRQ_PENDING) && action) {
                        /*
                         * Perform real IRQ processing for the IRQ we deferred
@@ -80,8 +79,8 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
                 * If we did actual work for the real IRQ line we must let the
                 * IRQ controller clean up too
                 */
-                if(work)
+                if (work && desc->chip && desc->chip->end)
-                        desc->handler->end(i);
+                        desc->chip->end(i);
                spin_unlock(&desc->lock);
        }
        /* So the caller can adjust the irq error counts */
@@ -100,7 +99,8 @@ static int misrouted_irq(int irq, struct pt_regs *regs)
 */
 static void
-__report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
+__report_bad_irq(unsigned int irq, struct irq_desc *desc,
+                 irqreturn_t action_ret)
 {
        struct irqaction *action;
@@ -113,6 +113,7 @@ __report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
        }
        dump_stack();
        printk(KERN_ERR "handlers:\n");
        action = desc->action;
        while (action) {
                printk(KERN_ERR "[<%p>]", action->handler);
@@ -123,7 +124,8 @@ __report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
        }
 }
-static void report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret)
+static void
+report_bad_irq(unsigned int irq, struct irq_desc *desc, irqreturn_t action_ret)
 {
        static int count = 100;
@@ -133,8 +135,8 @@ static void report_bad_irq(unsigned int irq, irq_desc_t *desc, irqreturn_t actio
        }
 }
-void note_interrupt(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret,
+void note_interrupt(unsigned int irq, struct irq_desc *desc,
-                        struct pt_regs *regs)
+                    irqreturn_t action_ret, struct pt_regs *regs)
 {
        if (unlikely(action_ret != IRQ_HANDLED)) {
                desc->irqs_unhandled++;
@@ -166,7 +168,8 @@ void note_interrupt(unsigned int irq, irq_desc_t *desc, irqreturn_t action_ret,
                 */
                printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
                desc->status |= IRQ_DISABLED;
-                desc->handler->disable(irq);
+                desc->depth = 1;
+                desc->chip->disable(irq);
        }
        desc->irqs_unhandled = 0;
 }
@@ -177,6 +180,7 @@ int __init noirqdebug_setup(char *str)
 {
        noirqdebug = 1;
        printk(KERN_INFO "IRQ lockup detection disabled\n");
        return 1;
 }
@@ -187,6 +191,7 @@ static int __init irqfixup_setup(char *str)
        irqfixup = 1;
        printk(KERN_WARNING "Misrouted IRQ fixup support enabled.\n");
        printk(KERN_WARNING "This may impact system performance.\n");
        return 1;
 }
diff --git a/kernel/resource.c b/kernel/resource.c
index 2404f9b0bc47..bf1130d81b7f 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -23,20 +23,18 @@
 struct resource ioport_resource = {
        .name   = "PCI IO",
-        .start  = 0x0000,
+        .start  = 0,
        .end    = IO_SPACE_LIMIT,
        .flags  = IORESOURCE_IO,
 };
 EXPORT_SYMBOL(ioport_resource);
 struct resource iomem_resource = {
        .name   = "PCI mem",
-        .start  = 0UL,
+        .start  = 0,
-        .end    = ~0UL,
+        .end    = -1,
        .flags  = IORESOURCE_MEM,
 };
 EXPORT_SYMBOL(iomem_resource);
 static DEFINE_RWLOCK(resource_lock);
@@ -83,10 +81,10 @@ static int r_show(struct seq_file *m, void *v)
        for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
                if (p->parent == root)
                        break;
-        seq_printf(m, "%*s%0*lx-%0*lx : %s\n",
+        seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
                        depth * 2, "",
-                        width, r->start,
+                        width, (unsigned long long) r->start,
-                        width, r->end,
+                        width, (unsigned long long) r->end,
                        r->name ? r->name : "<BAD>");
        return 0;
 }
@@ -151,8 +149,8 @@ __initcall(ioresources_init);
 /* Return the conflict entry if you can't request it */
 static struct resource * __request_resource(struct resource *root, struct resource *new)
 {
-        unsigned long start = new->start;
+        resource_size_t start = new->start;
-        unsigned long end = new->end;
+        resource_size_t end = new->end;
        struct resource *tmp, **p;
        if (end < start)
@@ -274,11 +272,10 @@ int find_next_system_ram(struct resource *res)
 * Find empty slot in the resource tree given range and alignment.
 */
 static int find_resource(struct resource *root, struct resource *new,
-                         unsigned long size,
+                         resource_size_t size, resource_size_t min,
-                         unsigned long min, unsigned long max,
+                         resource_size_t max, resource_size_t align,
-                         unsigned long align,
                         void (*alignf)(void *, struct resource *,
-                                        unsigned long, unsigned long),
+                                        resource_size_t, resource_size_t),
                         void *alignf_data)
 {
        struct resource *this = root->child;
@@ -320,11 +317,10 @@ static int find_resource(struct resource *root, struct resource *new,
 * Allocate empty slot in the resource tree given range and alignment.
 */
 int allocate_resource(struct resource *root, struct resource *new,
-                      unsigned long size,
+                      resource_size_t size, resource_size_t min,
-                      unsigned long min, unsigned long max,
+                      resource_size_t max, resource_size_t align,
-                      unsigned long align,
                      void (*alignf)(void *, struct resource *,
-                                     unsigned long, unsigned long),
+                                     resource_size_t, resource_size_t),
                      void *alignf_data)
 {
        int err;
@@ -416,10 +412,10 @@ EXPORT_SYMBOL(insert_resource);
 * arguments.  Returns -EBUSY if it can't fit.  Existing children of
 * the resource are assumed to be immutable.
 */
-int adjust_resource(struct resource *res, unsigned long start, unsigned long size)
+int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
 {
        struct resource *tmp, *parent = res->parent;
-        unsigned long end = start + size - 1;
+        resource_size_t end = start + size - 1;
        int result = -EBUSY;
        write_lock(&resource_lock);
@@ -466,7 +462,9 @@ EXPORT_SYMBOL(adjust_resource);
 *
 * Release-region releases a matching busy region.
 */
-struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name)
+struct resource * __request_region(struct resource *parent,
+                                   resource_size_t start, resource_size_t n,
+                                   const char *name)
 {
        struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
@@ -502,7 +500,8 @@ struct resource * __request_region(struct resource *parent, unsigned long start,
 EXPORT_SYMBOL(__request_region);
-int __check_region(struct resource *parent, unsigned long start, unsigned long n)
+int __check_region(struct resource *parent, resource_size_t start,
+                        resource_size_t n)
 {
        struct resource * res;
@@ -517,10 +516,11 @@ int __check_region(struct resource *parent, unsigned long start, unsigned long n
 EXPORT_SYMBOL(__check_region);
-void __release_region(struct resource *parent, unsigned long start, unsigned long n)
+void __release_region(struct resource *parent, resource_size_t start,
+                        resource_size_t n)
 {
        struct resource **p;
-        unsigned long end;
+        resource_size_t end;
        p = &parent->child;
        end = start + n - 1;
@@ -549,7 +549,9 @@ void __release_region(struct resource *parent, unsigned long start, unsigned lon
        write_unlock(&resource_lock);
-        printk(KERN_WARNING "Trying to free nonexistent resource <%08lx-%08lx>\n", start, end);
+        printk(KERN_WARNING "Trying to free nonexistent resource "
+                "<%016llx-%016llx>\n", (unsigned long long)start,
+                (unsigned long long)end);
 }
 EXPORT_SYMBOL(__release_region);
diff --git a/mm/Kconfig b/mm/Kconfig
index e76c023eb0bb..8f5b45615f7b 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -115,7 +115,7 @@ config SPARSEMEM_EXTREME
 # eventually, we can have this option just 'select SPARSEMEM'
 config MEMORY_HOTPLUG
        bool "Allow for memory hot-add"
-        depends on SPARSEMEM && HOTPLUG && !SOFTWARE_SUSPEND
+        depends on SPARSEMEM && HOTPLUG && !SOFTWARE_SUSPEND && ARCH_ENABLE_MEMORY_HOTPLUG
        depends on (IA64 || X86 || PPC64)
 comment "Memory hotplug is currently incompatible with Software Suspend"
@@ -146,3 +146,9 @@ config MIGRATION
          while the virtual addresses are not changed. This is useful for
          example on NUMA systems to put pages nearer to the processors accessing
          the page.
+config RESOURCES_64BIT
+        bool "64 bit Memory and IO resources (EXPERIMENTAL)" if (!64BIT && EXPERIMENTAL)
+        default 64BIT
+        help
+          This option allows memory and IO resources to be 64 bit.
diff --git a/mm/filemap.c b/mm/filemap.c
index 4082b3b3cea7..648f2c0c8e18 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2125,6 +2125,12 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
                        break;
                }
+                if (unlikely(bytes == 0)) {
+                        status = 0;
+                        copied = 0;
+                        goto zero_length_segment;
+                }
                status = a_ops->prepare_write(file, page, offset, offset+bytes);
                if (unlikely(status)) {
                        loff_t isize = i_size_read(inode);
@@ -2154,7 +2160,8 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
                        page_cache_release(page);
                        continue;
                }
-                if (likely(copied > 0)) {
+zero_length_segment:
+                if (likely(copied >= 0)) {
                        if (!status)
                                status = copied;
diff --git a/mm/filemap.h b/mm/filemap.h
index 536979fb4ba7..3f2a343c6015 100644
--- a/mm/filemap.h
+++ b/mm/filemap.h
@@ -88,7 +88,7 @@ filemap_set_next_iovec(const struct iovec **iovp, size_t *basep, size_t bytes)
        const struct iovec *iov = *iovp;
        size_t base = *basep;
-        while (bytes) {
+        do {
                int copy = min(bytes, iov->iov_len - base);
                bytes -= copy;
@@ -97,7 +97,7 @@ filemap_set_next_iovec(const struct iovec **iovp, size_t *basep, size_t bytes)
                        iov++;
                        base = 0;
                }
-        }
+        } while (bytes);
        *iovp = iov;
        *basep = base;
 }
diff --git a/security/keys/internal.h b/security/keys/internal.h
index 3c2877f0663e..1bb416f4bbce 100644
--- a/security/keys/internal.h
+++ b/security/keys/internal.h
@@ -99,6 +99,7 @@ extern int install_process_keyring(struct task_struct *tsk);
 extern struct key *request_key_and_link(struct key_type *type,
                                        const char *description,
                                        const char *callout_info,
+                                        void *aux,
                                        struct key *dest_keyring,
                                        unsigned long flags);
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index 329411cf8768..d9ca15c109cc 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -183,7 +183,7 @@ asmlinkage long sys_request_key(const char __user *_type,
        }
        /* do the search */
-        key = request_key_and_link(ktype, description, callout_info,
+        key = request_key_and_link(ktype, description, callout_info, NULL,
                                   key_ref_to_ptr(dest_ref),
                                   KEY_ALLOC_IN_QUOTA);
        if (IS_ERR(key)) {
diff --git a/security/keys/request_key.c b/security/keys/request_key.c
index 58d1efd4fc2c..f573ac189a0a 100644
--- a/security/keys/request_key.c
+++ b/security/keys/request_key.c
@@ -1,6 +1,6 @@
 /* request_key.c: request a key from userspace
 *
- * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved.
+ * Copyright (C) 2004-6 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
@@ -33,7 +33,8 @@ DECLARE_WAIT_QUEUE_HEAD(request_key_conswq);
 */
 static int call_sbin_request_key(struct key *key,
                                 struct key *authkey,
-                                 const char *op)
+                                 const char *op,
+                                 void *aux)
 {
        struct task_struct *tsk = current;
        key_serial_t prkey, sskey;
@@ -127,6 +128,7 @@ error_alloc:
 static struct key *__request_key_construction(struct key_type *type,
                                              const char *description,
                                              const char *callout_info,
+                                              void *aux,
                                              unsigned long flags)
 {
        request_key_actor_t actor;
@@ -164,7 +166,7 @@ static struct key *__request_key_construction(struct key_type *type,
        actor = call_sbin_request_key;
        if (type->request_key)
                actor = type->request_key;
-        ret = actor(key, authkey, "create");
+        ret = actor(key, authkey, "create", aux);
        if (ret < 0)
                goto request_failed;
@@ -258,8 +260,9 @@ alloc_failed:
 */
 static struct key *request_key_construction(struct key_type *type,
                                            const char *description,
-                                            struct key_user *user,
                                            const char *callout_info,
+                                            void *aux,
+                                            struct key_user *user,
                                            unsigned long flags)
 {
        struct key_construction *pcons;
@@ -284,7 +287,7 @@ static struct key *request_key_construction(struct key_type *type,
        }
        /* see about getting userspace to construct the key */
-        key = __request_key_construction(type, description, callout_info,
+        key = __request_key_construction(type, description, callout_info, aux,
                                         flags);
 error:
        kleave(" = %p", key);
@@ -392,6 +395,7 @@ static void request_key_link(struct key *key, struct key *dest_keyring)
 struct key *request_key_and_link(struct key_type *type,
                                 const char *description,
                                 const char *callout_info,
+                                 void *aux,
                                 struct key *dest_keyring,
                                 unsigned long flags)
 {
@@ -399,8 +403,9 @@ struct key *request_key_and_link(struct key_type *type,
        struct key *key;
        key_ref_t key_ref;
-        kenter("%s,%s,%s,%p,%lx",
+        kenter("%s,%s,%s,%p,%p,%lx",
-               type->name, description, callout_info, dest_keyring, flags);
+               type->name, description, callout_info, aux,
+               dest_keyring, flags);
        /* search all the process keyrings for a key */
        key_ref = search_process_keyrings(type, description, type->match,
@@ -433,8 +438,8 @@ struct key *request_key_and_link(struct key_type *type,
                        /* ask userspace (returns NULL if it waited on a key
                         * being constructed) */
                        key = request_key_construction(type, description,
-                                                       user, callout_info,
+                                                       callout_info, aux,
-                                                       flags);
+                                                       user, flags);
                        if (key)
                                break;
@@ -491,8 +496,27 @@ struct key *request_key(struct key_type *type,
                        const char *callout_info)
 {
        return request_key_and_link(type, description, callout_info, NULL,
-                                    KEY_ALLOC_IN_QUOTA);
+                                    NULL, KEY_ALLOC_IN_QUOTA);
 } /* end request_key() */
 EXPORT_SYMBOL(request_key);
+/*****************************************************************************/
+/*
+ * request a key with auxiliary data for the upcaller
+ * - search the process's keyrings
+ * - check the list of keys being created or updated
+ * - call out to userspace for a key if supplementary info was provided
+ */
+struct key *request_key_with_auxdata(struct key_type *type,
+                                     const char *description,
+                                     const char *callout_info,
+                                     void *aux)
+{
+        return request_key_and_link(type, description, callout_info, aux,
+                                    NULL, KEY_ALLOC_IN_QUOTA);
+} /* end request_key_with_auxdata() */
+EXPORT_SYMBOL(request_key_with_auxdata);
diff --git a/sound/arm/aaci.c b/sound/arm/aaci.c
index 5f22d70fefc0..6b18225672c7 100644
--- a/sound/arm/aaci.c
+++ b/sound/arm/aaci.c
@@ -779,8 +779,9 @@ static struct aaci * __devinit aaci_init_card(struct amba_device *dev)
        strlcpy(card->driver, DRIVER_NAME, sizeof(card->driver));
        strlcpy(card->shortname, "ARM AC'97 Interface", sizeof(card->shortname));
        snprintf(card->longname, sizeof(card->longname),
-                 "%s at 0x%08lx, irq %d",
+                 "%s at 0x%016llx, irq %d",
-                 card->shortname, dev->res.start, dev->irq[0]);
+                 card->shortname, (unsigned long long)dev->res.start,
+                 dev->irq[0]);
        aaci = card->private_data;
        mutex_init(&aaci->ac97_sem);
diff --git a/sound/drivers/mpu401/mpu401.c b/sound/drivers/mpu401/mpu401.c
index d3cbbb047582..8b80024968be 100644
--- a/sound/drivers/mpu401/mpu401.c
+++ b/sound/drivers/mpu401/mpu401.c
@@ -160,8 +160,9 @@ static int __devinit snd_mpu401_pnp(int dev, struct pnp_dev *device,
                return -ENODEV;
        }
        if (pnp_port_len(device, 0) < IO_EXTENT) {
-                snd_printk(KERN_ERR "PnP port length is %ld, expected %d\n",
+                snd_printk(KERN_ERR "PnP port length is %llu, expected %d\n",
-                           pnp_port_len(device, 0), IO_EXTENT);
+                           (unsigned long long)pnp_port_len(device, 0),
+                           IO_EXTENT);
                return -ENODEV;
        }
        port[dev] = pnp_port_start(device, 0);
diff --git a/sound/isa/es18xx.c b/sound/isa/es18xx.c
index e6945db8ed1b..af60b0bc8115 100644
--- a/sound/isa/es18xx.c
+++ b/sound/isa/es18xx.c
@@ -2088,7 +2088,8 @@ static int __devinit snd_audiodrive_pnp(int dev, struct snd_audiodrive *acard,
                kfree(cfg);
                return -EAGAIN;
        }
-        snd_printdd("pnp: port=0x%lx\n", pnp_port_start(acard->devc, 0));
+        snd_printdd("pnp: port=0x%llx\n",
+                        (unsigned long long)pnp_port_start(acard->devc, 0));
        /* PnP initialization */
        pdev = acard->dev;
        pnp_init_resource_table(cfg);
diff --git a/sound/isa/gus/interwave.c b/sound/isa/gus/interwave.c
index 866300f2acbb..c1c86e0fa56d 100644
--- a/sound/isa/gus/interwave.c
+++ b/sound/isa/gus/interwave.c
@@ -611,10 +611,10 @@ static int __devinit snd_interwave_pnp(int dev, struct snd_interwave *iwcard,
        if (dma2[dev] >= 0)
                dma2[dev] = pnp_dma(pdev, 1);
        irq[dev] = pnp_irq(pdev, 0);
-        snd_printdd("isapnp IW: sb port=0x%lx, gf1 port=0x%lx, codec port=0x%lx\n",
+        snd_printdd("isapnp IW: sb port=0x%llx, gf1 port=0x%llx, codec port=0x%llx\n",
-                                pnp_port_start(pdev, 0),
+                        (unsigned long long)pnp_port_start(pdev, 0),
-                                pnp_port_start(pdev, 1),
+                        (unsigned long long)pnp_port_start(pdev, 1),
-                                pnp_port_start(pdev, 2));
+                        (unsigned long long)pnp_port_start(pdev, 2));
        snd_printdd("isapnp IW: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
 #ifdef SNDRV_STB
        /* Tone Control initialization */
diff --git a/sound/isa/sb/sb16.c b/sound/isa/sb/sb16.c
index 7f7f05fa518a..d64e67f2bafa 100644
--- a/sound/isa/sb/sb16.c
+++ b/sound/isa/sb/sb16.c
@@ -327,7 +327,8 @@ static int __devinit snd_card_sb16_pnp(int dev, struct snd_card_sb16 *acard,
                        goto __wt_error; 
                } 
                awe_port[dev] = pnp_port_start(pdev, 0);
-                snd_printdd("pnp SB16: wavetable port=0x%lx\n", pnp_port_start(pdev, 0));
+                snd_printdd("pnp SB16: wavetable port=0x%llx\n",
+                                (unsigned long long)pnp_port_start(pdev, 0));
        } else {
 __wt_error:
                if (pdev) {
diff --git a/sound/oss/Kconfig b/sound/oss/Kconfig
index 3b8cdbca2636..f4980ca5c05c 100644
--- a/sound/oss/Kconfig
+++ b/sound/oss/Kconfig
@@ -493,6 +493,19 @@ config SOUND_CS4232
          See <file:Documentation/sound/oss/CS4232> for more information on
          configuring this card.
+config SOUND_SSCAPE
+        tristate "Ensoniq SoundScape support"
+        depends on SOUND_OSS
+        help
+          Answer Y if you have a sound card based on the Ensoniq SoundScape
+          chipset. Such cards are being manufactured at least by Ensoniq, Spea
+          and Reveal (Reveal makes also other cards).
+          If you compile the driver into the kernel, you have to add
+          "sscape=<io>,<irq>,<dma>,<mpuio>,<mpuirq>" to the kernel command
+          line.
 config SOUND_VMIDI
        tristate "Loopback MIDI device support"
        depends on SOUND_OSS
diff --git a/sound/oss/forte.c b/sound/oss/forte.c
index 0294eec8ad90..44e578098d76 100644
--- a/sound/oss/forte.c
+++ b/sound/oss/forte.c
@@ -2035,8 +2035,9 @@ forte_probe (struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
        
        pci_set_drvdata (pci_dev, chip);
-        printk (KERN_INFO PFX "FM801 chip found at 0x%04lX-0x%04lX IRQ %u\n", 
+        printk (KERN_INFO PFX "FM801 chip found at 0x%04lX-0x%16llX IRQ %u\n",
-                chip->iobase, pci_resource_end (pci_dev, 0), chip->irq);
+                chip->iobase, (unsigned long long)pci_resource_end (pci_dev, 0),
+                chip->irq);
        /* Power it up */
        if ((ret = forte_chip_init (chip)) == 0)
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index c33642d8d9a1..497ed6b20060 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -888,8 +888,9 @@ static int __devinit snd_bt87x_probe(struct pci_dev *pci,
        strcpy(card->driver, "Bt87x");
        sprintf(card->shortname, "Brooktree Bt%x", pci->device);
-        sprintf(card->longname, "%s at %#lx, irq %i",
+        sprintf(card->longname, "%s at %#llx, irq %i",
-                card->shortname, pci_resource_start(pci, 0), chip->irq);
+                card->shortname, (unsigned long long)pci_resource_start(pci, 0),
+                chip->irq);
        strcpy(card->mixername, "Bt87x");
        err = snd_card_register(card);
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index dcf402948347..e5511606af04 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -1441,10 +1441,10 @@ static int __devinit snd_sonic_probe(struct pci_dev *pci,
        strcpy(card->driver, "SonicVibes");
        strcpy(card->shortname, "S3 SonicVibes");
-        sprintf(card->longname, "%s rev %i at 0x%lx, irq %i",
+        sprintf(card->longname, "%s rev %i at 0x%llx, irq %i",
                card->shortname,
                sonic->revision,
-                pci_resource_start(pci, 1),
+                (unsigned long long)pci_resource_start(pci, 1),
                sonic->irq);
        if ((err = snd_sonicvibes_pcm(sonic, 0, NULL)) < 0) {
diff --git a/sound/ppc/pmac.c b/sound/ppc/pmac.c
index b678814975c9..be98f6377339 100644
--- a/sound/ppc/pmac.c
+++ b/sound/ppc/pmac.c
@@ -1170,9 +1170,10 @@ int __init snd_pmac_new(struct snd_card *card, struct snd_pmac **chip_return)
                                               chip->rsrc[i].start + 1,
                                               rnames[i]) == NULL) {
                                printk(KERN_ERR "snd: can't request rsrc "
-                                       " %d (%s: 0x%08lx:%08lx)\n",
+                                       " %d (%s: 0x%016lx:%016lx)\n",
-                                       i, rnames[i], chip->rsrc[i].start,
+                                       i, rnames[i],
-                                       chip->rsrc[i].end);
+                                       (unsigned long long)chip->rsrc[i].start,
+                                       (unsigned long long)chip->rsrc[i].end);
                                err = -ENODEV;
                                goto __error;
                        }
@@ -1201,9 +1202,10 @@ int __init snd_pmac_new(struct snd_card *card, struct snd_pmac **chip_return)
                                               chip->rsrc[i].start + 1,
                                               rnames[i]) == NULL) {
                                printk(KERN_ERR "snd: can't request rsrc "
-                                       " %d (%s: 0x%08lx:%08lx)\n",
+                                       " %d (%s: 0x%016llx:%016llx)\n",
-                                       i, rnames[i], chip->rsrc[i].start,
+                                       i, rnames[i],
-                                       chip->rsrc[i].end);
+                                       (unsigned long long)chip->rsrc[i].start,
+                                       (unsigned long long)chip->rsrc[i].end);
                                err = -ENODEV;
                                goto __error;
                        }
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index da54d04a3e3a..d9d14c2707db 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -2037,10 +2037,10 @@ static int __init cs4231_sbus_attach(struct sbus_dev *sdev)
        if (err)
                return err;
-        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %d",
+        sprintf(card->longname, "%s at 0x%02lx:0x%016lx, irq %d",
                card->shortname,
                rp->flags & 0xffL,
-                rp->start,
+                (unsigned long long)rp->start,
                sdev->irqs[0]);
        if ((err = snd_cs4231_sbus_create(card, sdev, dev, &cp)) < 0) {
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index 5eecdd09a79d..a7489a3dd75a 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -2645,9 +2645,9 @@ static int __init dbri_attach(int prom_node, struct sbus_dev *sdev)
        strcpy(card->driver, "DBRI");
        strcpy(card->shortname, "Sun DBRI");
        rp = &sdev->resource[0];
-        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %d",
+        sprintf(card->longname, "%s at 0x%02lx:0x%016lx, irq %d",
                card->shortname,
-                rp->flags & 0xffL, rp->start, irq.pri);
+                rp->flags & 0xffL, (unsigned long long)rp->start, irq.pri);
        if ((err = snd_dbri_create(card, sdev, &irq, dev)) < 0) {
                snd_card_free(card);