381 files changed, 16467 insertions, 4405 deletions

diff --git a/CREDITS b/CREDITS
index c6d69bf10e15..35850d882c34 100644
--- a/CREDITS
+++ b/CREDITS
@@ -3741,10 +3741,11 @@ D: Mylex DAC960 PCI RAID driver
 D: Miscellaneous kernel fixes
 
 N: Alessandro Zummo
-E: azummo@ita.flashnet.it
-W: http://freepage.logicom.it/azummo/
+E: a.zummo@towertech.it
 D: CMI8330 support is sb_card.c
 D: ISAPnP fixes in sb_card.c
+D: ZyXEL omni.net lcd plus driver
+D: RTC subsystem
 S: Italy
 
 N: Marc Zyngier
diff --git a/Documentation/block/biodoc.txt b/Documentation/block/biodoc.txt
index 8e63831971d5..f989a9e839b4 100644
--- a/Documentation/block/biodoc.txt
+++ b/Documentation/block/biodoc.txt
@@ -132,8 +132,18 @@ Some new queue property settings:
                 limit. No highmem default.
 
         blk_queue_max_sectors(q, max_sectors)
-                Maximum size request you can handle in units of 512 byte
-                sectors. 255 default.
+                Sets two variables that limit the size of the request.
+
+                - The request queue's max_sectors, which is a soft size in
+                in units of 512 byte sectors, and could be dynamically varied
+                by the core kernel.
+
+                - The request queue's max_hw_sectors, which is a hard limit
+                and reflects the maximum size request a driver can handle
+                in units of 512 byte sectors.
+
+                The default for both max_sectors and max_hw_sectors is
+                255. The upper limit of max_sectors is 1024.
 
         blk_queue_max_phys_segments(q, max_segments)
                 Maximum physical segments you can handle in a request. 128
diff --git a/Documentation/pnp.txt b/Documentation/pnp.txt
index af0f6eabfa1c..9529c9c9fd59 100644
--- a/Documentation/pnp.txt
+++ b/Documentation/pnp.txt
@@ -115,6 +115,9 @@ pnp_unregister_protocol
 pnp_register_driver
 - adds a PnP driver to the Plug and Play Layer
 - this includes driver model integration
+- returns zero for success or a negative error number for failure; count
+  calls to the .add() method if you need to know how many devices bind to
+  the driver
 
 pnp_unregister_driver
 - removes a PnP driver from the Plug and Play Layer
diff --git a/Documentation/robust-futex-ABI.txt b/Documentation/robust-futex-ABI.txt
new file mode 100644
index 000000000000..8529a17ffaa1
--- /dev/null
+++ b/Documentation/robust-futex-ABI.txt
@@ -0,0 +1,182 @@
+Started by Paul Jackson <pj@sgi.com>
+
+The robust futex ABI
+--------------------
+
+Robust_futexes provide a mechanism that is used in addition to normal
+futexes, for kernel assist of cleanup of held locks on task exit.
+
+The interesting data as to what futexes a thread is holding is kept on a
+linked list in user space, where it can be updated efficiently as locks
+are taken and dropped, without kernel intervention.  The only additional
+kernel intervention required for robust_futexes above and beyond what is
+required for futexes is:
+
+ 1) a one time call, per thread, to tell the kernel where its list of
+    held robust_futexes begins, and
+ 2) internal kernel code at exit, to handle any listed locks held
+    by the exiting thread.
+
+The existing normal futexes already provide a "Fast Userspace Locking"
+mechanism, which handles uncontested locking without needing a system
+call, and handles contested locking by maintaining a list of waiting
+threads in the kernel.  Options on the sys_futex(2) system call support
+waiting on a particular futex, and waking up the next waiter on a
+particular futex.
+
+For robust_futexes to work, the user code (typically in a library such
+as glibc linked with the application) has to manage and place the
+necessary list elements exactly as the kernel expects them.  If it fails
+to do so, then improperly listed locks will not be cleaned up on exit,
+probably causing deadlock or other such failure of the other threads
+waiting on the same locks.
+
+A thread that anticipates possibly using robust_futexes should first
+issue the system call:
+
+    asmlinkage long
+    sys_set_robust_list(struct robust_list_head __user *head, size_t len);
+
+The pointer 'head' points to a structure in the threads address space
+consisting of three words.  Each word is 32 bits on 32 bit arch's, or 64
+bits on 64 bit arch's, and local byte order.  Each thread should have
+its own thread private 'head'.
+
+If a thread is running in 32 bit compatibility mode on a 64 native arch
+kernel, then it can actually have two such structures - one using 32 bit
+words for 32 bit compatibility mode, and one using 64 bit words for 64
+bit native mode.  The kernel, if it is a 64 bit kernel supporting 32 bit
+compatibility mode, will attempt to process both lists on each task
+exit, if the corresponding sys_set_robust_list() call has been made to
+setup that list.
+
+  The first word in the memory structure at 'head' contains a
+  pointer to a single linked list of 'lock entries', one per lock,
+  as described below.  If the list is empty, the pointer will point
+  to itself, 'head'.  The last 'lock entry' points back to the 'head'.
+
+  The second word, called 'offset', specifies the offset from the
+  address of the associated 'lock entry', plus or minus, of what will
+  be called the 'lock word', from that 'lock entry'.  The 'lock word'
+  is always a 32 bit word, unlike the other words above.  The 'lock
+  word' holds 3 flag bits in the upper 3 bits, and the thread id (TID)
+  of the thread holding the lock in the bottom 29 bits.  See further
+  below for a description of the flag bits.
+
+  The third word, called 'list_op_pending', contains transient copy of
+  the address of the 'lock entry', during list insertion and removal,
+  and is needed to correctly resolve races should a thread exit while
+  in the middle of a locking or unlocking operation.
+
+Each 'lock entry' on the single linked list starting at 'head' consists
+of just a single word, pointing to the next 'lock entry', or back to
+'head' if there are no more entries.  In addition, nearby to each 'lock
+entry', at an offset from the 'lock entry' specified by the 'offset'
+word, is one 'lock word'.
+
+The 'lock word' is always 32 bits, and is intended to be the same 32 bit
+lock variable used by the futex mechanism, in conjunction with
+robust_futexes.  The kernel will only be able to wakeup the next thread
+waiting for a lock on a threads exit if that next thread used the futex
+mechanism to register the address of that 'lock word' with the kernel.
+
+For each futex lock currently held by a thread, if it wants this
+robust_futex support for exit cleanup of that lock, it should have one
+'lock entry' on this list, with its associated 'lock word' at the
+specified 'offset'.  Should a thread die while holding any such locks,
+the kernel will walk this list, mark any such locks with a bit
+indicating their holder died, and wakeup the next thread waiting for
+that lock using the futex mechanism.
+
+When a thread has invoked the above system call to indicate it
+anticipates using robust_futexes, the kernel stores the passed in 'head'
+pointer for that task.  The task may retrieve that value later on by
+using the system call:
+
+    asmlinkage long
+    sys_get_robust_list(int pid, struct robust_list_head __user **head_ptr,
+                        size_t __user *len_ptr);
+
+It is anticipated that threads will use robust_futexes embedded in
+larger, user level locking structures, one per lock.  The kernel
+robust_futex mechanism doesn't care what else is in that structure, so
+long as the 'offset' to the 'lock word' is the same for all
+robust_futexes used by that thread.  The thread should link those locks
+it currently holds using the 'lock entry' pointers.  It may also have
+other links between the locks, such as the reverse side of a double
+linked list, but that doesn't matter to the kernel.
+
+By keeping its locks linked this way, on a list starting with a 'head'
+pointer known to the kernel, the kernel can provide to a thread the
+essential service available for robust_futexes, which is to help clean
+up locks held at the time of (a perhaps unexpectedly) exit.
+
+Actual locking and unlocking, during normal operations, is handled
+entirely by user level code in the contending threads, and by the
+existing futex mechanism to wait for, and wakeup, locks.  The kernels
+only essential involvement in robust_futexes is to remember where the
+list 'head' is, and to walk the list on thread exit, handling locks
+still held by the departing thread, as described below.
+
+There may exist thousands of futex lock structures in a threads shared
+memory, on various data structures, at a given point in time. Only those
+lock structures for locks currently held by that thread should be on
+that thread's robust_futex linked lock list a given time.
+
+A given futex lock structure in a user shared memory region may be held
+at different times by any of the threads with access to that region. The
+thread currently holding such a lock, if any, is marked with the threads
+TID in the lower 29 bits of the 'lock word'.
+
+When adding or removing a lock from its list of held locks, in order for
+the kernel to correctly handle lock cleanup regardless of when the task
+exits (perhaps it gets an unexpected signal 9 in the middle of
+manipulating this list), the user code must observe the following
+protocol on 'lock entry' insertion and removal:
+
+On insertion:
+ 1) set the 'list_op_pending' word to the address of the 'lock word'
+    to be inserted,
+ 2) acquire the futex lock,
+ 3) add the lock entry, with its thread id (TID) in the bottom 29 bits
+    of the 'lock word', to the linked list starting at 'head', and
+ 4) clear the 'list_op_pending' word.
+
+On removal:
+ 1) set the 'list_op_pending' word to the address of the 'lock word'
+    to be removed,
+ 2) remove the lock entry for this lock from the 'head' list,
+ 2) release the futex lock, and
+ 2) clear the 'lock_op_pending' word.
+
+On exit, the kernel will consider the address stored in
+'list_op_pending' and the address of each 'lock word' found by walking
+the list starting at 'head'.  For each such address, if the bottom 29
+bits of the 'lock word' at offset 'offset' from that address equals the
+exiting threads TID, then the kernel will do two things:
+
+ 1) if bit 31 (0x80000000) is set in that word, then attempt a futex
+    wakeup on that address, which will waken the next thread that has
+    used to the futex mechanism to wait on that address, and
+ 2) atomically set  bit 30 (0x40000000) in the 'lock word'.
+
+In the above, bit 31 was set by futex waiters on that lock to indicate
+they were waiting, and bit 30 is set by the kernel to indicate that the
+lock owner died holding the lock.
+
+The kernel exit code will silently stop scanning the list further if at
+any point:
+
+ 1) the 'head' pointer or an subsequent linked list pointer
+    is not a valid address of a user space word
+ 2) the calculated location of the 'lock word' (address plus
+    'offset') is not the valud address of a 32 bit user space
+    word
+ 3) if the list contains more than 1 million (subject to
+    future kernel configuration changes) elements.
+
+When the kernel sees a list entry whose 'lock word' doesn't have the
+current threads TID in the lower 29 bits, it does nothing with that
+entry, and goes on to the next entry.
+
+Bit 29 (0x20000000) of the 'lock word' is reserved for future use.
diff --git a/Documentation/robust-futexes.txt b/Documentation/robust-futexes.txt
new file mode 100644
index 000000000000..df82d75245a0
--- /dev/null
+++ b/Documentation/robust-futexes.txt
@@ -0,0 +1,218 @@
+Started by: Ingo Molnar <mingo@redhat.com>
+
+Background
+----------
+
+what are robust futexes? To answer that, we first need to understand
+what futexes are: normal futexes are special types of locks that in the
+noncontended case can be acquired/released from userspace without having
+to enter the kernel.
+
+A futex is in essence a user-space address, e.g. a 32-bit lock variable
+field. If userspace notices contention (the lock is already owned and
+someone else wants to grab it too) then the lock is marked with a value
+that says "there's a waiter pending", and the sys_futex(FUTEX_WAIT)
+syscall is used to wait for the other guy to release it. The kernel
+creates a 'futex queue' internally, so that it can later on match up the
+waiter with the waker - without them having to know about each other.
+When the owner thread releases the futex, it notices (via the variable
+value) that there were waiter(s) pending, and does the
+sys_futex(FUTEX_WAKE) syscall to wake them up.  Once all waiters have
+taken and released the lock, the futex is again back to 'uncontended'
+state, and there's no in-kernel state associated with it. The kernel
+completely forgets that there ever was a futex at that address. This
+method makes futexes very lightweight and scalable.
+
+"Robustness" is about dealing with crashes while holding a lock: if a
+process exits prematurely while holding a pthread_mutex_t lock that is
+also shared with some other process (e.g. yum segfaults while holding a
+pthread_mutex_t, or yum is kill -9-ed), then waiters for that lock need
+to be notified that the last owner of the lock exited in some irregular
+way.
+
+To solve such types of problems, "robust mutex" userspace APIs were
+created: pthread_mutex_lock() returns an error value if the owner exits
+prematurely - and the new owner can decide whether the data protected by
+the lock can be recovered safely.
+
+There is a big conceptual problem with futex based mutexes though: it is
+the kernel that destroys the owner task (e.g. due to a SEGFAULT), but
+the kernel cannot help with the cleanup: if there is no 'futex queue'
+(and in most cases there is none, futexes being fast lightweight locks)
+then the kernel has no information to clean up after the held lock!
+Userspace has no chance to clean up after the lock either - userspace is
+the one that crashes, so it has no opportunity to clean up. Catch-22.
+
+In practice, when e.g. yum is kill -9-ed (or segfaults), a system reboot
+is needed to release that futex based lock. This is one of the leading
+bugreports against yum.
+
+To solve this problem, the traditional approach was to extend the vma
+(virtual memory area descriptor) concept to have a notion of 'pending
+robust futexes attached to this area'. This approach requires 3 new
+syscall variants to sys_futex(): FUTEX_REGISTER, FUTEX_DEREGISTER and
+FUTEX_RECOVER. At do_exit() time, all vmas are searched to see whether
+they have a robust_head set. This approach has two fundamental problems
+left:
+
+ - it has quite complex locking and race scenarios. The vma-based
+   approach had been pending for years, but they are still not completely
+   reliable.
+
+ - they have to scan _every_ vma at sys_exit() time, per thread!
+
+The second disadvantage is a real killer: pthread_exit() takes around 1
+microsecond on Linux, but with thousands (or tens of thousands) of vmas
+every pthread_exit() takes a millisecond or more, also totally
+destroying the CPU's L1 and L2 caches!
+
+This is very much noticeable even for normal process sys_exit_group()
+calls: the kernel has to do the vma scanning unconditionally! (this is
+because the kernel has no knowledge about how many robust futexes there
+are to be cleaned up, because a robust futex might have been registered
+in another task, and the futex variable might have been simply mmap()-ed
+into this process's address space).
+
+This huge overhead forced the creation of CONFIG_FUTEX_ROBUST so that
+normal kernels can turn it off, but worse than that: the overhead makes
+robust futexes impractical for any type of generic Linux distribution.
+
+So something had to be done.
+
+New approach to robust futexes
+------------------------------
+
+At the heart of this new approach there is a per-thread private list of
+robust locks that userspace is holding (maintained by glibc) - which
+userspace list is registered with the kernel via a new syscall [this
+registration happens at most once per thread lifetime]. At do_exit()
+time, the kernel checks this user-space list: are there any robust futex
+locks to be cleaned up?
+
+In the common case, at do_exit() time, there is no list registered, so
+the cost of robust futexes is just a simple current->robust_list != NULL
+comparison. If the thread has registered a list, then normally the list
+is empty. If the thread/process crashed or terminated in some incorrect
+way then the list might be non-empty: in this case the kernel carefully
+walks the list [not trusting it], and marks all locks that are owned by
+this thread with the FUTEX_OWNER_DEAD bit, and wakes up one waiter (if
+any).
+
+The list is guaranteed to be private and per-thread at do_exit() time,
+so it can be accessed by the kernel in a lockless way.
+
+There is one race possible though: since adding to and removing from the
+list is done after the futex is acquired by glibc, there is a few
+instructions window for the thread (or process) to die there, leaving
+the futex hung. To protect against this possibility, userspace (glibc)
+also maintains a simple per-thread 'list_op_pending' field, to allow the
+kernel to clean up if the thread dies after acquiring the lock, but just
+before it could have added itself to the list. Glibc sets this
+list_op_pending field before it tries to acquire the futex, and clears
+it after the list-add (or list-remove) has finished.
+
+That's all that is needed - all the rest of robust-futex cleanup is done
+in userspace [just like with the previous patches].
+
+Ulrich Drepper has implemented the necessary glibc support for this new
+mechanism, which fully enables robust mutexes.
+
+Key differences of this userspace-list based approach, compared to the
+vma based method:
+
+ - it's much, much faster: at thread exit time, there's no need to loop
+   over every vma (!), which the VM-based method has to do. Only a very
+   simple 'is the list empty' op is done.
+
+ - no VM changes are needed - 'struct address_space' is left alone.
+
+ - no registration of individual locks is needed: robust mutexes dont
+   need any extra per-lock syscalls. Robust mutexes thus become a very
+   lightweight primitive - so they dont force the application designer
+   to do a hard choice between performance and robustness - robust
+   mutexes are just as fast.
+
+ - no per-lock kernel allocation happens.
+
+ - no resource limits are needed.
+
+ - no kernel-space recovery call (FUTEX_RECOVER) is needed.
+
+ - the implementation and the locking is "obvious", and there are no
+   interactions with the VM.
+
+Performance
+-----------
+
+I have benchmarked the time needed for the kernel to process a list of 1
+million (!) held locks, using the new method [on a 2GHz CPU]:
+
+ - with FUTEX_WAIT set [contended mutex]: 130 msecs
+ - without FUTEX_WAIT set [uncontended mutex]: 30 msecs
+
+I have also measured an approach where glibc does the lock notification
+[which it currently does for !pshared robust mutexes], and that took 256
+msecs - clearly slower, due to the 1 million FUTEX_WAKE syscalls
+userspace had to do.
+
+(1 million held locks are unheard of - we expect at most a handful of
+locks to be held at a time. Nevertheless it's nice to know that this
+approach scales nicely.)
+
+Implementation details
+----------------------
+
+The patch adds two new syscalls: one to register the userspace list, and
+one to query the registered list pointer:
+
+ asmlinkage long
+ sys_set_robust_list(struct robust_list_head __user *head,
+                     size_t len);
+
+ asmlinkage long
+ sys_get_robust_list(int pid, struct robust_list_head __user **head_ptr,
+                     size_t __user *len_ptr);
+
+List registration is very fast: the pointer is simply stored in
+current->robust_list. [Note that in the future, if robust futexes become
+widespread, we could extend sys_clone() to register a robust-list head
+for new threads, without the need of another syscall.]
+
+So there is virtually zero overhead for tasks not using robust futexes,
+and even for robust futex users, there is only one extra syscall per
+thread lifetime, and the cleanup operation, if it happens, is fast and
+straightforward. The kernel doesnt have any internal distinction between
+robust and normal futexes.
+
+If a futex is found to be held at exit time, the kernel sets the
+following bit of the futex word:
+
+        #define FUTEX_OWNER_DIED        0x40000000
+
+and wakes up the next futex waiter (if any). User-space does the rest of
+the cleanup.
+
+Otherwise, robust futexes are acquired by glibc by putting the TID into
+the futex field atomically. Waiters set the FUTEX_WAITERS bit:
+
+        #define FUTEX_WAITERS           0x80000000
+
+and the remaining bits are for the TID.
+
+Testing, architecture support
+-----------------------------
+
+i've tested the new syscalls on x86 and x86_64, and have made sure the
+parsing of the userspace list is robust [ ;-) ] even if the list is
+deliberately corrupted.
+
+i386 and x86_64 syscalls are wired up at the moment, and Ulrich has
+tested the new glibc code (on x86_64 and i386), and it works for his
+robust-mutex testcases.
+
+All other architectures should build just fine too - but they wont have
+the new syscalls yet.
+
+Architectures need to implement the new futex_atomic_cmpxchg_inatomic()
+inline function before writing up the syscalls (that function returns
+-ENOSYS right now).
diff --git a/Documentation/rpc-cache.txt b/Documentation/rpc-cache.txt
index 2b5d4434fa5a..5f757c8cf979 100644
--- a/Documentation/rpc-cache.txt
+++ b/Documentation/rpc-cache.txt
@@ -1,4 +1,4 @@
-This document gives a brief introduction to the caching
+        This document gives a brief introduction to the caching
 mechanisms in the sunrpc layer that is used, in particular,
 for NFS authentication.
 
@@ -25,25 +25,17 @@ The common code handles such things as:
    - supporting 'NEGATIVE' as well as positive entries
    - allowing an EXPIRED time on cache items, and removing
      items after they expire, and are no longe in-use.
-
-   Future code extensions are expect to handle
    - making requests to user-space to fill in cache entries
    - allowing user-space to directly set entries in the cache
    - delaying RPC requests that depend on as-yet incomplete
      cache entries, and replaying those requests when the cache entry
      is complete.
-   - maintaining last-access times on cache entries
-   - clean out old entries when the caches become full
-
-The code for performing a cache lookup is also common, but in the form
-of a template.  i.e. a #define.
-Each cache defines a lookup function by using the DefineCacheLookup
-macro, or the simpler DefineSimpleCacheLookup macro
+   - clean out old entries as they expire.
 
 Creating a Cache
 ----------------
 
-1/ A cache needs a datum to cache.  This is in the form of a
+1/ A cache needs a datum to store.  This is in the form of a
    structure definition that must contain a
      struct cache_head
    as an element, usually the first.
@@ -51,35 +43,69 @@ Creating a Cache
    Each cache element is reference counted and contains
    expiry and update times for use in cache management.
 2/ A cache needs a "cache_detail" structure that
-   describes the cache.  This stores the hash table, and some
-   parameters for cache management.
-3/ A cache needs a lookup function.  This is created using
-   the DefineCacheLookup macro.  This lookup function is used both
-   to find entries and to update entries.  The normal mode for
-   updating an entry is to replace the old entry with a new
-   entry.  However it is possible to allow update-in-place
-   for those caches where it makes sense (no atomicity issues
-   or indirect reference counting issue)
-4/ A cache needs to be registered using cache_register().  This
-   includes in on a list of caches that will be regularly
-   cleaned to discard old data.  For this to work, some
-   thread must periodically call cache_clean
-   
+   describes the cache.  This stores the hash table, some
+   parameters for cache management, and some operations detailing how
+   to work with particular cache items.
+   The operations requires are:
+        struct cache_head *alloc(void)
+                This simply allocates appropriate memory and returns
+                a pointer to the cache_detail embedded within the
+                structure
+        void cache_put(struct kref *)
+                This is called when the last reference to an item is
+                is dropped.  The pointer passed is to the 'ref' field
+                in the cache_head.  cache_put should release any
+                references create by 'cache_init' and, if CACHE_VALID
+                is set, any references created by cache_update.
+                It should then release the memory allocated by
+                'alloc'.
+        int match(struct cache_head *orig, struct cache_head *new)
+                test if the keys in the two structures match.  Return
+                1 if they do, 0 if they don't.
+        void init(struct cache_head *orig, struct cache_head *new)
+                Set the 'key' fields in 'new' from 'orig'.  This may
+                include taking references to shared objects.
+        void update(struct cache_head *orig, struct cache_head *new)
+                Set the 'content' fileds in 'new' from 'orig'.
+        int cache_show(struct seq_file *m, struct cache_detail *cd,
+                        struct cache_head *h)
+                Optional.  Used to provide a /proc file that lists the
+                contents of a cache.  This should show one item,
+                usually on just one line.
+        int cache_request(struct cache_detail *cd, struct cache_head *h,
+                char **bpp, int *blen)
+                Format a request to be send to user-space for an item
+                to be instantiated.  *bpp is a buffer of size *blen.
+                bpp should be moved forward over the encoded message,
+                and  *blen should be reduced to show how much free
+                space remains.  Return 0 on success or <0 if not
+                enough room or other problem.
+        int cache_parse(struct cache_detail *cd, char *buf, int len)
+                A message from user space has arrived to fill out a
+                cache entry.  It is in 'buf' of length 'len'.
+                cache_parse should parse this, find the item in the
+                cache with sunrpc_cache_lookup, and update the item
+                with sunrpc_cache_update.
+
+
+3/ A cache needs to be registered using cache_register().  This
+   includes it on a list of caches that will be regularly
+   cleaned to discard old data.
+
 Using a cache
 -------------
 
-To find a value in a cache, call the lookup function passing it a the
-datum which contains key, and possibly content, and a flag saying
-whether to update the cache with new data from the datum.   Depending
-on how the cache lookup function was defined, it may take an extra
-argument to identify the particular cache in question.
+To find a value in a cache, call sunrpc_cache_lookup passing a pointer
+to the cache_head in a sample item with the 'key' fields filled in.
+This will be passed to ->match to identify the target entry.  If no
+entry is found, a new entry will be create, added to the cache, and
+marked as not containing valid data.
 
-Except in cases of kmalloc failure, the lookup function
-will return a new datum which will store the key and
-may contain valid content, or may not.
-This datum is typically passed to cache_check which determines the
-validity of the datum and may later initiate an upcall to fill
-in the data.
+The item returned is typically passed to cache_check which will check
+if the data is valid, and may initiate an up-call to get fresh data.
+cache_check will return -ENOENT in the entry is negative or if an up
+call is needed but not possible, -EAGAIN if an upcall is pending,
+or 0 if the data is valid;
 
 cache_check can be passed a "struct cache_req *".  This structure is
 typically embedded in the actual request and can be used to create a
@@ -90,6 +116,13 @@ item does become valid, the deferred copy of the request will be
 revisited (->revisit).  It is expected that this method will
 reschedule the request for processing.
 
+The value returned by sunrpc_cache_lookup can also be passed to
+sunrpc_cache_update to set the content for the item.  A second item is
+passed which should hold the content.  If the item found by _lookup
+has valid data, then it is discarded and a new item is created.  This
+saves any user of an item from worrying about content changing while
+it is being inspected.  If the item found by _lookup does not contain
+valid data, then the content is copied across and CACHE_VALID is set.
 
 Populating a cache
 ------------------
@@ -114,8 +147,8 @@ should be create or updated to have the given content, and the
 expiry time should be set on that item.
 
 Reading from a channel is a bit more interesting.  When a cache
-lookup fail, or when it suceeds but finds an entry that may soon
-expiry, a request is lodged for that cache item to be updated by
+lookup fails, or when it succeeds but finds an entry that may soon
+expire, a request is lodged for that cache item to be updated by
 user-space.  These requests appear in the channel file.
 
 Successive reads will return successive requests.
@@ -130,7 +163,7 @@ Thus a user-space helper is likely to:
     write a response
   loop.
 
-If it dies and needs to be restarted, any requests that have not be
+If it dies and needs to be restarted, any requests that have not been
 answered will still appear in the file and will be read by the new
 instance of the helper.
 
@@ -142,10 +175,9 @@ Each cache should also define a "cache_request" method which
 takes a cache item and encodes a request into the buffer
 provided.
 
-
 Note: If a cache has no active readers on the channel, and has had not
 active readers for more than 60 seconds, further requests will not be
-added to the channel but instead all looks that do not find a valid
+added to the channel but instead all lookups that do not find a valid
 entry will fail.  This is partly for backward compatibility: The
 previous nfs exports table was deemed to be authoritative and a
 failed lookup meant a definite 'no'.
@@ -154,18 +186,17 @@ request/response format
 -----------------------
 
 While each cache is free to use it's own format for requests
-and responses over channel, the following is recommended are
+and responses over channel, the following is recommended as
 appropriate and support routines are available to help:
 Each request or response record should be printable ASCII
 with precisely one newline character which should be at the end.
 Fields within the record should be separated by spaces, normally one.
 If spaces, newlines, or nul characters are needed in a field they
-much be quotes.  two mechanisms are available:
+much be quoted.  two mechanisms are available:
 1/ If a field begins '\x' then it must contain an even number of
    hex digits, and pairs of these digits provide the bytes in the
    field.
 2/ otherwise a \ in the field must be followed by 3 octal digits
    which give the code for a byte.  Other characters are treated
-   as them selves.  At the very least, space, newlines nul, and
+   as them selves.  At the very least, space, newline, nul, and
    '\' must be quoted in this way.
-   
diff --git a/MAINTAINERS b/MAINTAINERS
index f27846734b06..e5b051f0e27e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2233,6 +2233,12 @@ M:	p_gortmaker@yahoo.com
 L:      linux-kernel@vger.kernel.org
 S:      Maintained
 
+REAL TIME CLOCK (RTC) SUBSYSTEM
+P:      Alessandro Zummo
+M:      a.zummo@towertech.it
+L:      linux-kernel@vger.kernel.org
+S:      Maintained
+
 REISERFS FILE SYSTEM
 P:      Hans Reiser
 M:      reiserfs-dev@namesys.com
diff --git a/arch/alpha/kernel/setup.c b/arch/alpha/kernel/setup.c
index b4e5f8ff2b25..dd8769670596 100644
--- a/arch/alpha/kernel/setup.c
+++ b/arch/alpha/kernel/setup.c
@@ -34,6 +34,7 @@
 #include <linux/root_dev.h>
 #include <linux/initrd.h>
 #include <linux/eisa.h>
+#include <linux/pfn.h>
 #ifdef CONFIG_MAGIC_SYSRQ
 #include <linux/sysrq.h>
 #include <linux/reboot.h>
@@ -42,7 +43,7 @@
 #include <asm/setup.h>
 #include <asm/io.h>
 
-extern struct notifier_block *panic_notifier_list;
+extern struct atomic_notifier_head panic_notifier_list;
 static int alpha_panic_event(struct notifier_block *, unsigned long, void *);
 static struct notifier_block alpha_panic_block = {
         alpha_panic_event,
@@ -241,9 +242,6 @@ reserve_std_resources(void)
                 request_resource(io, standard_io_resources+i);
 }
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 #define PFN_MAX         PFN_DOWN(0x80000000)
 #define for_each_mem_cluster(memdesc, cluster, i)               \
         for ((cluster) = (memdesc)->cluster, (i) = 0;           \
@@ -472,11 +470,6 @@ page_is_ram(unsigned long pfn)
         return 0;
 }
 
-#undef PFN_UP
-#undef PFN_DOWN
-#undef PFN_PHYS
-#undef PFN_MAX
-
 void __init
 setup_arch(char **cmdline_p)
 {
@@ -507,7 +500,8 @@ setup_arch(char **cmdline_p)
         }
 
         /* Register a call for panic conditions. */
-        notifier_chain_register(&panic_notifier_list, &alpha_panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &alpha_panic_block);
 
 #ifdef CONFIG_ALPHA_GENERIC
         /* Assume that we've booted from SRM if we haven't booted from MILO.
diff --git a/arch/alpha/mm/numa.c b/arch/alpha/mm/numa.c
index 6d5251254f68..bf6b65c81bef 100644
--- a/arch/alpha/mm/numa.c
+++ b/arch/alpha/mm/numa.c
@@ -13,6 +13,7 @@
 #include <linux/bootmem.h>
 #include <linux/swap.h>
 #include <linux/initrd.h>
+#include <linux/pfn.h>
 
 #include <asm/hwrpb.h>
 #include <asm/pgalloc.h>
@@ -27,9 +28,6 @@ bootmem_data_t node_bdata[MAX_NUMNODES];
 #define DBGDCONT(args...)
 #endif
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
 #define for_each_mem_cluster(memdesc, cluster, i)               \
         for ((cluster) = (memdesc)->cluster, (i) = 0;           \
              (i) < (memdesc)->numclusters; (i)++, (cluster)++)
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index bf2e72698d02..9731b3f826ab 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -8,6 +8,7 @@ mainmenu "Linux Kernel Configuration"
 config ARM
         bool
         default y
+        select RTC_LIB
         help
           The ARM series is a line of low-power-consumption RISC chip designs
           licensed by ARM Ltd and targeted at embedded applications and
@@ -839,6 +840,8 @@ source "drivers/usb/Kconfig"
 
 source "drivers/mmc/Kconfig"
 
+source "drivers/rtc/Kconfig"
+
 endmenu
 
 source "fs/Kconfig"
diff --git a/arch/arm/common/rtctime.c b/arch/arm/common/rtctime.c
index e851d86c212c..35c9a64ac14c 100644
--- a/arch/arm/common/rtctime.c
+++ b/arch/arm/common/rtctime.c
@@ -20,6 +20,7 @@
 #include <linux/capability.h>
 #include <linux/device.h>
 #include <linux/mutex.h>
+#include <linux/rtc.h>
 
 #include <asm/rtc.h>
 #include <asm/semaphore.h>
@@ -42,89 +43,6 @@ static struct rtc_ops *rtc_ops;
 
 #define rtc_epoch 1900UL
 
-static const unsigned char days_in_month[] = {
-        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
-};
-
-#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
-#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
-
-static int month_days(unsigned int month, unsigned int year)
-{
-        return days_in_month[month] + (LEAP_YEAR(year) && month == 1);
-}
-
-/*
- * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
- */
-void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
-{
-        int days, month, year;
-
-        days = time / 86400;
-        time -= days * 86400;
-
-        tm->tm_wday = (days + 4) % 7;
-
-        year = 1970 + days / 365;
-        days -= (year - 1970) * 365
-                + LEAPS_THRU_END_OF(year - 1)
-                - LEAPS_THRU_END_OF(1970 - 1);
-        if (days < 0) {
-                year -= 1;
-                days += 365 + LEAP_YEAR(year);
-        }
-        tm->tm_year = year - 1900;
-        tm->tm_yday = days + 1;
-
-        for (month = 0; month < 11; month++) {
-                int newdays;
-
-                newdays = days - month_days(month, year);
-                if (newdays < 0)
-                        break;
-                days = newdays;
-        }
-        tm->tm_mon = month;
-        tm->tm_mday = days + 1;
-
-        tm->tm_hour = time / 3600;
-        time -= tm->tm_hour * 3600;
-        tm->tm_min = time / 60;
-        tm->tm_sec = time - tm->tm_min * 60;
-}
-EXPORT_SYMBOL(rtc_time_to_tm);
-
-/*
- * Does the rtc_time represent a valid date/time?
- */
-int rtc_valid_tm(struct rtc_time *tm)
-{
-        if (tm->tm_year < 70 ||
-            tm->tm_mon >= 12 ||
-            tm->tm_mday < 1 ||
-            tm->tm_mday > month_days(tm->tm_mon, tm->tm_year + 1900) ||
-            tm->tm_hour >= 24 ||
-            tm->tm_min >= 60 ||
-            tm->tm_sec >= 60)
-                return -EINVAL;
-
-        return 0;
-}
-EXPORT_SYMBOL(rtc_valid_tm);
-
-/*
- * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
- */
-int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
-{
-        *time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
-                       tm->tm_hour, tm->tm_min, tm->tm_sec);
-
-        return 0;
-}
-EXPORT_SYMBOL(rtc_tm_to_time);
-
 /*
  * Calculate the next alarm time given the requested alarm time mask
  * and the current time.
@@ -151,13 +69,13 @@ void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, struct rtc
         }
 }
 
-static inline int rtc_read_time(struct rtc_ops *ops, struct rtc_time *tm)
+static inline int rtc_arm_read_time(struct rtc_ops *ops, struct rtc_time *tm)
 {
         memset(tm, 0, sizeof(struct rtc_time));
         return ops->read_time(tm);
 }
 
-static inline int rtc_set_time(struct rtc_ops *ops, struct rtc_time *tm)
+static inline int rtc_arm_set_time(struct rtc_ops *ops, struct rtc_time *tm)
 {
         int ret;
 
@@ -168,7 +86,7 @@ static inline int rtc_set_time(struct rtc_ops *ops, struct rtc_time *tm)
         return ret;
 }
 
-static inline int rtc_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
+static inline int rtc_arm_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
 {
         int ret = -EINVAL;
         if (ops->read_alarm) {
@@ -178,7 +96,7 @@ static inline int rtc_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
         return ret;
 }
 
-static inline int rtc_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
+static inline int rtc_arm_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
 {
         int ret = -EINVAL;
         if (ops->set_alarm)
@@ -266,7 +184,7 @@ static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
         switch (cmd) {
         case RTC_ALM_READ:
-                ret = rtc_read_alarm(ops, &alrm);
+                ret = rtc_arm_read_alarm(ops, &alrm);
                 if (ret)
                         break;
                 ret = copy_to_user(uarg, &alrm.time, sizeof(tm));
@@ -288,11 +206,11 @@ static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 alrm.time.tm_wday = -1;
                 alrm.time.tm_yday = -1;
                 alrm.time.tm_isdst = -1;
-                ret = rtc_set_alarm(ops, &alrm);
+                ret = rtc_arm_set_alarm(ops, &alrm);
                 break;
 
         case RTC_RD_TIME:
-                ret = rtc_read_time(ops, &tm);
+                ret = rtc_arm_read_time(ops, &tm);
                 if (ret)
                         break;
                 ret = copy_to_user(uarg, &tm, sizeof(tm));
@@ -310,7 +228,7 @@ static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         ret = -EFAULT;
                         break;
                 }
-                ret = rtc_set_time(ops, &tm);
+                ret = rtc_arm_set_time(ops, &tm);
                 break;
 
         case RTC_EPOCH_SET:
@@ -341,11 +259,11 @@ static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         ret = -EFAULT;
                         break;
                 }
-                ret = rtc_set_alarm(ops, &alrm);
+                ret = rtc_arm_set_alarm(ops, &alrm);
                 break;
 
         case RTC_WKALM_RD:
-                ret = rtc_read_alarm(ops, &alrm);
+                ret = rtc_arm_read_alarm(ops, &alrm);
                 if (ret)
                         break;
                 ret = copy_to_user(uarg, &alrm, sizeof(alrm));
@@ -435,7 +353,7 @@ static int rtc_read_proc(char *page, char **start, off_t off, int count, int *eo
         struct rtc_time tm;
         char *p = page;
 
-        if (rtc_read_time(ops, &tm) == 0) {
+        if (rtc_arm_read_time(ops, &tm) == 0) {
                 p += sprintf(p,
                         "rtc_time\t: %02d:%02d:%02d\n"
                         "rtc_date\t: %04d-%02d-%02d\n"
@@ -445,7 +363,7 @@ static int rtc_read_proc(char *page, char **start, off_t off, int count, int *eo
                         rtc_epoch);
         }
 
-        if (rtc_read_alarm(ops, &alrm) == 0) {
+        if (rtc_arm_read_alarm(ops, &alrm) == 0) {
                 p += sprintf(p, "alrm_time\t: ");
                 if ((unsigned int)alrm.time.tm_hour <= 24)
                         p += sprintf(p, "%02d:", alrm.time.tm_hour);
diff --git a/arch/arm/mach-integrator/time.c b/arch/arm/mach-integrator/time.c
index 3c22c16b38bf..bc07f52a6fd7 100644
--- a/arch/arm/mach-integrator/time.c
+++ b/arch/arm/mach-integrator/time.c
@@ -40,13 +40,13 @@ static int integrator_set_rtc(void)
         return 1;
 }
 
-static int rtc_read_alarm(struct rtc_wkalrm *alrm)
+static int integrator_rtc_read_alarm(struct rtc_wkalrm *alrm)
 {
         rtc_time_to_tm(readl(rtc_base + RTC_MR), &alrm->time);
         return 0;
 }
 
-static inline int rtc_set_alarm(struct rtc_wkalrm *alrm)
+static inline int integrator_rtc_set_alarm(struct rtc_wkalrm *alrm)
 {
         unsigned long time;
         int ret;
@@ -62,7 +62,7 @@ static inline int rtc_set_alarm(struct rtc_wkalrm *alrm)
         return ret;
 }
 
-static int rtc_read_time(struct rtc_time *tm)
+static int integrator_rtc_read_time(struct rtc_time *tm)
 {
         rtc_time_to_tm(readl(rtc_base + RTC_DR), tm);
         return 0;
@@ -76,7 +76,7 @@ static int rtc_read_time(struct rtc_time *tm)
  * edge of the 1Hz clock, we must write the time one second
  * in advance.
  */
-static inline int rtc_set_time(struct rtc_time *tm)
+static inline int integrator_rtc_set_time(struct rtc_time *tm)
 {
         unsigned long time;
         int ret;
@@ -90,10 +90,10 @@ static inline int rtc_set_time(struct rtc_time *tm)
 
 static struct rtc_ops rtc_ops = {
         .owner          = THIS_MODULE,
-        .read_time      = rtc_read_time,
-        .set_time       = rtc_set_time,
-        .read_alarm     = rtc_read_alarm,
-        .set_alarm      = rtc_set_alarm,
+        .read_time      = integrator_rtc_read_time,
+        .set_time       = integrator_rtc_set_time,
+        .read_alarm     = integrator_rtc_read_alarm,
+        .set_alarm      = integrator_rtc_set_alarm,
 };
 
 static irqreturn_t arm_rtc_interrupt(int irq, void *dev_id,
diff --git a/arch/arm/mach-omap1/board-netstar.c b/arch/arm/mach-omap1/board-netstar.c
index 60d5f8a3339c..7520e602d7a2 100644
--- a/arch/arm/mach-omap1/board-netstar.c
+++ b/arch/arm/mach-omap1/board-netstar.c
@@ -141,7 +141,7 @@ static int __init netstar_late_init(void)
         /* TODO: Setup front panel switch here */
 
         /* Setup panic notifier */
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         return 0;
 }
diff --git a/arch/arm/mach-omap1/board-voiceblue.c b/arch/arm/mach-omap1/board-voiceblue.c
index bfd5fdd1a875..52e4a9d69642 100644
--- a/arch/arm/mach-omap1/board-voiceblue.c
+++ b/arch/arm/mach-omap1/board-voiceblue.c
@@ -235,7 +235,7 @@ static struct notifier_block panic_block = {
 static int __init voiceblue_setup(void)
 {
         /* Setup panic notifier */
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         return 0;
 }
diff --git a/arch/arm/mach-pxa/generic.c b/arch/arm/mach-pxa/generic.c
index 9b48a90aefce..5efa84749f37 100644
--- a/arch/arm/mach-pxa/generic.c
+++ b/arch/arm/mach-pxa/generic.c
@@ -319,6 +319,11 @@ void __init pxa_set_ficp_info(struct pxaficp_platform_data *info)
         pxaficp_device.dev.platform_data = info;
 }
 
+static struct platform_device pxartc_device = {
+        .name           = "sa1100-rtc",
+        .id             = -1,
+};
+
 static struct platform_device *devices[] __initdata = {
         &pxamci_device,
         &udc_device,
@@ -329,6 +334,7 @@ static struct platform_device *devices[] __initdata = {
         &pxaficp_device,
         &i2c_device,
         &i2s_device,
+        &pxartc_device,
 };
 
 static int __init pxa_init(void)
diff --git a/arch/arm/mach-sa1100/generic.c b/arch/arm/mach-sa1100/generic.c
index 2abdc419e984..9ea71551fc04 100644
--- a/arch/arm/mach-sa1100/generic.c
+++ b/arch/arm/mach-sa1100/generic.c
@@ -324,6 +324,11 @@ void sa11x0_set_irda_data(struct irda_platform_data *irda)
         sa11x0ir_device.dev.platform_data = irda;
 }
 
+static struct platform_device sa11x0rtc_device = {
+        .name           = "sa1100-rtc",
+        .id             = -1,
+};
+
 static struct platform_device *sa11x0_devices[] __initdata = {
         &sa11x0udc_device,
         &sa11x0uart1_device,
@@ -333,6 +338,7 @@ static struct platform_device *sa11x0_devices[] __initdata = {
         &sa11x0pcmcia_device,
         &sa11x0fb_device,
         &sa11x0mtd_device,
+        &sa11x0rtc_device,
 };
 
 static int __init sa1100_init(void)
diff --git a/arch/arm26/mm/init.c b/arch/arm26/mm/init.c
index e3ecaa453747..7da8a5205678 100644
--- a/arch/arm26/mm/init.c
+++ b/arch/arm26/mm/init.c
@@ -23,6 +23,7 @@
 #include <linux/initrd.h>
 #include <linux/bootmem.h>
 #include <linux/blkdev.h>
+#include <linux/pfn.h>
 
 #include <asm/segment.h>
 #include <asm/mach-types.h>
@@ -101,12 +102,6 @@ struct node_info {
         int bootmap_pages;
 };
 
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_UP(x)       (PAGE_ALIGN(x) >> PAGE_SHIFT)
-#define PFN_SIZE(x)     ((x) >> PAGE_SHIFT)
-#define PFN_RANGE(s,e)  PFN_SIZE(PAGE_ALIGN((unsigned long)(e)) - \
-                                (((unsigned long)(s)) & PAGE_MASK))
-
 /*
  * FIXME: We really want to avoid allocating the bootmap bitmap
  * over the top of the initrd.  Hopefully, this is located towards
diff --git a/arch/cris/kernel/setup.c b/arch/cris/kernel/setup.c
index 1ba57efff60d..619a6eefd893 100644
--- a/arch/cris/kernel/setup.c
+++ b/arch/cris/kernel/setup.c
@@ -18,6 +18,7 @@
 #include <linux/seq_file.h>
 #include <linux/tty.h>
 #include <linux/utsname.h>
+#include <linux/pfn.h>
 
 #include <asm/setup.h>
 
@@ -88,10 +89,6 @@ setup_arch(char **cmdline_p)
         init_mm.end_data =   (unsigned long) &_edata;
         init_mm.brk =        (unsigned long) &_end;
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
-
         /* min_low_pfn points to the start of DRAM, start_pfn points
          * to the first DRAM pages after the kernel, and max_low_pfn
          * to the end of DRAM.
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index f7db71d0b913..f17bd1d2707e 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -231,6 +231,15 @@ config SCHED_SMT
           cost of slightly increased overhead in some places. If unsure say
           N here.
 
+config SCHED_MC
+        bool "Multi-core scheduler support"
+        depends on SMP
+        default y
+        help
+          Multi-core scheduler support improves the CPU scheduler's decision
+          making when dealing with multi-core CPU chips at a cost of slightly
+          increased overhead in some places. If unsure say N here.
+
 source "kernel/Kconfig.preempt"
 
 config X86_UP_APIC
diff --git a/arch/i386/boot/video.S b/arch/i386/boot/video.S
index 2ac40c8244c4..0000a2674537 100644
--- a/arch/i386/boot/video.S
+++ b/arch/i386/boot/video.S
@@ -1924,6 +1924,7 @@ skip10:	movb	%ah, %al
         ret
 
 store_edid:
+#ifdef CONFIG_FB_FIRMWARE_EDID
         pushw   %es                             # just save all registers
         pushw   %ax
         pushw   %bx
@@ -1954,6 +1955,7 @@ store_edid:
         popw    %bx
         popw    %ax
         popw    %es
+#endif
         ret
 
 # VIDEO_SELECT-only variables
diff --git a/arch/i386/kernel/cpu/common.c b/arch/i386/kernel/cpu/common.c
index 7e3d6b6a4e96..a06a49075f10 100644
--- a/arch/i386/kernel/cpu/common.c
+++ b/arch/i386/kernel/cpu/common.c
@@ -266,7 +266,7 @@ static void __init early_cpu_detect(void)
 void __cpuinit generic_identify(struct cpuinfo_x86 * c)
 {
         u32 tfms, xlvl;
-        int junk;
+        int ebx;
 
         if (have_cpuid_p()) {
                 /* Get vendor name */
@@ -282,7 +282,7 @@ void __cpuinit generic_identify(struct cpuinfo_x86 * c)
                 /* Intel-defined flags: level 0x00000001 */
                 if ( c->cpuid_level >= 0x00000001 ) {
                         u32 capability, excap;
-                        cpuid(0x00000001, &tfms, &junk, &excap, &capability);
+                        cpuid(0x00000001, &tfms, &ebx, &excap, &capability);
                         c->x86_capability[0] = capability;
                         c->x86_capability[4] = excap;
                         c->x86 = (tfms >> 8) & 15;
@@ -292,6 +292,11 @@ void __cpuinit generic_identify(struct cpuinfo_x86 * c)
                         if (c->x86 >= 0x6)
                                 c->x86_model += ((tfms >> 16) & 0xF) << 4;
                         c->x86_mask = tfms & 15;
+#ifdef CONFIG_SMP
+                        c->apicid = phys_pkg_id((ebx >> 24) & 0xFF, 0);
+#else
+                        c->apicid = (ebx >> 24) & 0xFF;
+#endif
                 } else {
                         /* Have CPUID level 0 only - unheard of */
                         c->x86 = 4;
@@ -474,7 +479,6 @@ void __cpuinit detect_ht(struct cpuinfo_x86 *c)
 
         cpuid(1, &eax, &ebx, &ecx, &edx);
 
-        c->apicid = phys_pkg_id((ebx >> 24) & 0xFF, 0);
 
         if (!cpu_has(c, X86_FEATURE_HT) || cpu_has(c, X86_FEATURE_CMP_LEGACY))
                 return;
diff --git a/arch/i386/kernel/cpu/intel_cacheinfo.c b/arch/i386/kernel/cpu/intel_cacheinfo.c
index ce61921369e5..9df87b03612c 100644
--- a/arch/i386/kernel/cpu/intel_cacheinfo.c
+++ b/arch/i386/kernel/cpu/intel_cacheinfo.c
@@ -173,6 +173,10 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
         unsigned int trace = 0, l1i = 0, l1d = 0, l2 = 0, l3 = 0; /* Cache sizes */
         unsigned int new_l1d = 0, new_l1i = 0; /* Cache sizes from cpuid(4) */
         unsigned int new_l2 = 0, new_l3 = 0, i; /* Cache sizes from cpuid(4) */
+        unsigned int l2_id = 0, l3_id = 0, num_threads_sharing, index_msb;
+#ifdef CONFIG_SMP
+        unsigned int cpu = (c == &boot_cpu_data) ? 0 : (c - cpu_data);
+#endif
 
         if (c->cpuid_level > 3) {
                 static int is_initialized;
@@ -205,9 +209,15 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
                                         break;
                                     case 2:
                                         new_l2 = this_leaf.size/1024;
+                                        num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
+                                        index_msb = get_count_order(num_threads_sharing);
+                                        l2_id = c->apicid >> index_msb;
                                         break;
                                     case 3:
                                         new_l3 = this_leaf.size/1024;
+                                        num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
+                                        index_msb = get_count_order(num_threads_sharing);
+                                        l3_id = c->apicid >> index_msb;
                                         break;
                                     default:
                                         break;
@@ -215,11 +225,19 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
                         }
                 }
         }
-        if (c->cpuid_level > 1) {
+        /*
+         * Don't use cpuid2 if cpuid4 is supported. For P4, we use cpuid2 for
+         * trace cache
+         */
+        if ((num_cache_leaves == 0 || c->x86 == 15) && c->cpuid_level > 1) {
                 /* supports eax=2  call */
                 int i, j, n;
                 int regs[4];
                 unsigned char *dp = (unsigned char *)regs;
+                int only_trace = 0;
+
+                if (num_cache_leaves != 0 && c->x86 == 15)
+                        only_trace = 1;
 
                 /* Number of times to iterate */
                 n = cpuid_eax(2) & 0xFF;
@@ -241,6 +259,8 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
                                 while (cache_table[k].descriptor != 0)
                                 {
                                         if (cache_table[k].descriptor == des) {
+                                                if (only_trace && cache_table[k].cache_type != LVL_TRACE)
+                                                        break;
                                                 switch (cache_table[k].cache_type) {
                                                 case LVL_1_INST:
                                                         l1i += cache_table[k].size;
@@ -266,34 +286,45 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
                                 }
                         }
                 }
+        }
 
-                if (new_l1d)
-                        l1d = new_l1d;
+        if (new_l1d)
+                l1d = new_l1d;
 
-                if (new_l1i)
-                        l1i = new_l1i;
+        if (new_l1i)
+                l1i = new_l1i;
 
-                if (new_l2)
-                        l2 = new_l2;
+        if (new_l2) {
+                l2 = new_l2;
+#ifdef CONFIG_SMP
+                cpu_llc_id[cpu] = l2_id;
+#endif
+        }
 
-                if (new_l3)
-                        l3 = new_l3;
+        if (new_l3) {
+                l3 = new_l3;
+#ifdef CONFIG_SMP
+                cpu_llc_id[cpu] = l3_id;
+#endif
+        }
 
-                if ( trace )
-                        printk (KERN_INFO "CPU: Trace cache: %dK uops", trace);
-                else if ( l1i )
-                        printk (KERN_INFO "CPU: L1 I cache: %dK", l1i);
-                if ( l1d )
-                        printk(", L1 D cache: %dK\n", l1d);
-                else
-                        printk("\n");
-                if ( l2 )
-                        printk(KERN_INFO "CPU: L2 cache: %dK\n", l2);
-                if ( l3 )
-                        printk(KERN_INFO "CPU: L3 cache: %dK\n", l3);
+        if (trace)
+                printk (KERN_INFO "CPU: Trace cache: %dK uops", trace);
+        else if ( l1i )
+                printk (KERN_INFO "CPU: L1 I cache: %dK", l1i);
 
-                c->x86_cache_size = l3 ? l3 : (l2 ? l2 : (l1i+l1d));
-        }
+        if (l1d)
+                printk(", L1 D cache: %dK\n", l1d);
+        else
+                printk("\n");
+
+        if (l2)
+                printk(KERN_INFO "CPU: L2 cache: %dK\n", l2);
+
+        if (l3)
+                printk(KERN_INFO "CPU: L3 cache: %dK\n", l3);
+
+        c->x86_cache_size = l3 ? l3 : (l2 ? l2 : (l1i+l1d));
 
         return l2;
 }
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index 6917daa159ab..8c08660b4e5d 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -46,6 +46,7 @@
 #include <linux/kexec.h>
 #include <linux/crash_dump.h>
 #include <linux/dmi.h>
+#include <linux/pfn.h>
 
 #include <video/edid.h>
 
diff --git a/arch/i386/kernel/smpboot.c b/arch/i386/kernel/smpboot.c
index 82371d83bfa9..a6969903f2d6 100644
--- a/arch/i386/kernel/smpboot.c
+++ b/arch/i386/kernel/smpboot.c
@@ -72,6 +72,9 @@ int phys_proc_id[NR_CPUS] __read_mostly = {[0 ... NR_CPUS-1] = BAD_APICID};
 /* Core ID of each logical CPU */
 int cpu_core_id[NR_CPUS] __read_mostly = {[0 ... NR_CPUS-1] = BAD_APICID};
 
+/* Last level cache ID of each logical CPU */
+int cpu_llc_id[NR_CPUS] __cpuinitdata = {[0 ... NR_CPUS-1] = BAD_APICID};
+
 /* representing HT siblings of each logical CPU */
 cpumask_t cpu_sibling_map[NR_CPUS] __read_mostly;
 EXPORT_SYMBOL(cpu_sibling_map);
@@ -440,6 +443,18 @@ static void __devinit smp_callin(void)
 
 static int cpucount;
 
+/* maps the cpu to the sched domain representing multi-core */
+cpumask_t cpu_coregroup_map(int cpu)
+{
+        struct cpuinfo_x86 *c = cpu_data + cpu;
+        /*
+         * For perf, we return last level cache shared map.
+         * TBD: when power saving sched policy is added, we will return
+         *      cpu_core_map when power saving policy is enabled
+         */
+        return c->llc_shared_map;
+}
+
 /* representing cpus for which sibling maps can be computed */
 static cpumask_t cpu_sibling_setup_map;
 
@@ -459,12 +474,16 @@ set_cpu_sibling_map(int cpu)
                                 cpu_set(cpu, cpu_sibling_map[i]);
                                 cpu_set(i, cpu_core_map[cpu]);
                                 cpu_set(cpu, cpu_core_map[i]);
+                                cpu_set(i, c[cpu].llc_shared_map);
+                                cpu_set(cpu, c[i].llc_shared_map);
                         }
                 }
         } else {
                 cpu_set(cpu, cpu_sibling_map[cpu]);
         }
 
+        cpu_set(cpu, c[cpu].llc_shared_map);
+
         if (current_cpu_data.x86_max_cores == 1) {
                 cpu_core_map[cpu] = cpu_sibling_map[cpu];
                 c[cpu].booted_cores = 1;
@@ -472,6 +491,11 @@ set_cpu_sibling_map(int cpu)
         }
 
         for_each_cpu_mask(i, cpu_sibling_setup_map) {
+                if (cpu_llc_id[cpu] != BAD_APICID &&
+                    cpu_llc_id[cpu] == cpu_llc_id[i]) {
+                        cpu_set(i, c[cpu].llc_shared_map);
+                        cpu_set(cpu, c[i].llc_shared_map);
+                }
                 if (phys_proc_id[cpu] == phys_proc_id[i]) {
                         cpu_set(i, cpu_core_map[cpu]);
                         cpu_set(cpu, cpu_core_map[i]);
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index ac687d00a1ce..326595f3fa4d 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -310,3 +310,5 @@ ENTRY(sys_call_table)
         .long sys_pselect6
         .long sys_ppoll
         .long sys_unshare               /* 310 */
+        .long sys_set_robust_list
+        .long sys_get_robust_list
diff --git a/arch/i386/kernel/timers/timer_pm.c b/arch/i386/kernel/timers/timer_pm.c
index 264edaaac315..144e94a04933 100644
--- a/arch/i386/kernel/timers/timer_pm.c
+++ b/arch/i386/kernel/timers/timer_pm.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/init.h>
+#include <linux/pci.h>
 #include <asm/types.h>
 #include <asm/timer.h>
 #include <asm/smp.h>
@@ -45,24 +46,31 @@ static seqlock_t monotonic_lock = SEQLOCK_UNLOCKED;
 
 #define ACPI_PM_MASK 0xFFFFFF /* limit it to 24 bits */
 
+static int pmtmr_need_workaround __read_mostly = 1;
+
 /*helper function to safely read acpi pm timesource*/
 static inline u32 read_pmtmr(void)
 {
-        u32 v1=0,v2=0,v3=0;
-        /* It has been reported that because of various broken
-         * chipsets (ICH4, PIIX4 and PIIX4E) where the ACPI PM time
-         * source is not latched, so you must read it multiple
-         * times to insure a safe value is read.
-         */
-        do {
-                v1 = inl(pmtmr_ioport);
-                v2 = inl(pmtmr_ioport);
-                v3 = inl(pmtmr_ioport);
-        } while ((v1 > v2 && v1 < v3) || (v2 > v3 && v2 < v1)
-                        || (v3 > v1 && v3 < v2));
-
-        /* mask the output to 24 bits */
-        return v2 & ACPI_PM_MASK;
+        if (pmtmr_need_workaround) {
+                u32 v1, v2, v3;
+
+                /* It has been reported that because of various broken
+                 * chipsets (ICH4, PIIX4 and PIIX4E) where the ACPI PM time
+                 * source is not latched, so you must read it multiple
+                 * times to insure a safe value is read.
+                 */
+                do {
+                        v1 = inl(pmtmr_ioport);
+                        v2 = inl(pmtmr_ioport);
+                        v3 = inl(pmtmr_ioport);
+                } while ((v1 > v2 && v1 < v3) || (v2 > v3 && v2 < v1)
+                         || (v3 > v1 && v3 < v2));
+
+                /* mask the output to 24 bits */
+                return v2 & ACPI_PM_MASK;
+        }
+
+        return inl(pmtmr_ioport) & ACPI_PM_MASK;
 }
 
 
@@ -263,6 +271,72 @@ struct init_timer_opts __initdata timer_pmtmr_init = {
         .opts = &timer_pmtmr,
 };
 
+#ifdef CONFIG_PCI
+/*
+ * PIIX4 Errata:
+ *
+ * The power management timer may return improper results when read.
+ * Although the timer value settles properly after incrementing,
+ * while incrementing there is a 3 ns window every 69.8 ns where the
+ * timer value is indeterminate (a 4.2% chance that the data will be
+ * incorrect when read). As a result, the ACPI free running count up
+ * timer specification is violated due to erroneous reads.
+ */
+static int __init pmtmr_bug_check(void)
+{
+        static struct pci_device_id gray_list[] __initdata = {
+                /* these chipsets may have bug. */
+                { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
+                                PCI_DEVICE_ID_INTEL_82801DB_0) },
+                { },
+        };
+        struct pci_dev *dev;
+        int pmtmr_has_bug = 0;
+        u8 rev;
+
+        if (cur_timer != &timer_pmtmr || !pmtmr_need_workaround)
+                return 0;
+
+        dev = pci_get_device(PCI_VENDOR_ID_INTEL,
+                             PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
+        if (dev) {
+                pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
+                /* the bug has been fixed in PIIX4M */
+                if (rev < 3) {
+                        printk(KERN_WARNING "* Found PM-Timer Bug on this "
+                                "chipset. Due to workarounds for a bug,\n"
+                                "* this time source is slow.  Consider trying "
+                                "other time sources (clock=)\n");
+                        pmtmr_has_bug = 1;
+                }
+                pci_dev_put(dev);
+        }
+
+        if (pci_dev_present(gray_list)) {
+                printk(KERN_WARNING "* This chipset may have PM-Timer Bug.  Due"
+                        " to workarounds for a bug,\n"
+                        "* this time source is slow. If you are sure your timer"
+                        " does not have\n"
+                        "* this bug, please use \"pmtmr_good\" to disable the "
+                        "workaround\n");
+                pmtmr_has_bug = 1;
+        }
+
+        if (!pmtmr_has_bug)
+                pmtmr_need_workaround = 0;
+
+        return 0;
+}
+device_initcall(pmtmr_bug_check);
+#endif
+
+static int __init pmtr_good_setup(char *__str)
+{
+        pmtmr_need_workaround = 0;
+        return 1;
+}
+__setup("pmtmr_good", pmtr_good_setup);
+
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
 MODULE_DESCRIPTION("Power Management Timer (PMTMR) as primary timing source for x86");
diff --git a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
index 4624f8ca2459..6b63a5aa1e46 100644
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
@@ -92,22 +92,21 @@ asmlinkage void spurious_interrupt_bug(void);
 asmlinkage void machine_check(void);
 
 static int kstack_depth_to_print = 24;
-struct notifier_block *i386die_chain;
-static DEFINE_SPINLOCK(die_notifier_lock);
+ATOMIC_NOTIFIER_HEAD(i386die_chain);
 
 int register_die_notifier(struct notifier_block *nb)
 {
-        int err = 0;
-        unsigned long flags;
-
         vmalloc_sync_all();
-        spin_lock_irqsave(&die_notifier_lock, flags);
-        err = notifier_chain_register(&i386die_chain, nb);
-        spin_unlock_irqrestore(&die_notifier_lock, flags);
-        return err;
+        return atomic_notifier_chain_register(&i386die_chain, nb);
 }
 EXPORT_SYMBOL(register_die_notifier);
 
+int unregister_die_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&i386die_chain, nb);
+}
+EXPORT_SYMBOL(unregister_die_notifier);
+
 static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
 {
         return  p > (void *)tinfo &&
diff --git a/arch/i386/mm/discontig.c b/arch/i386/mm/discontig.c
index c4af9638dbfa..fe6eb901326e 100644
--- a/arch/i386/mm/discontig.c
+++ b/arch/i386/mm/discontig.c
@@ -31,6 +31,7 @@
 #include <linux/nodemask.h>
 #include <linux/module.h>
 #include <linux/kexec.h>
+#include <linux/pfn.h>
 
 #include <asm/e820.h>
 #include <asm/setup.h>
@@ -352,17 +353,6 @@ void __init zone_sizes_init(void)
 {
         int nid;
 
-        /*
-         * Insert nodes into pgdat_list backward so they appear in order.
-         * Clobber node 0's links and NULL out pgdat_list before starting.
-         */
-        pgdat_list = NULL;
-        for (nid = MAX_NUMNODES - 1; nid >= 0; nid--) {
-                if (!node_online(nid))
-                        continue;
-                NODE_DATA(nid)->pgdat_next = pgdat_list;
-                pgdat_list = NODE_DATA(nid);
-        }
 
         for_each_online_node(nid) {
                 unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
diff --git a/arch/i386/mm/pgtable.c b/arch/i386/mm/pgtable.c
index 9db3242103be..2889567e21a1 100644
--- a/arch/i386/mm/pgtable.c
+++ b/arch/i386/mm/pgtable.c
@@ -36,7 +36,7 @@ void show_mem(void)
         printk(KERN_INFO "Mem-info:\n");
         show_free_areas();
         printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 pgdat_resize_lock(pgdat, &flags);
                 for (i = 0; i < pgdat->node_spanned_pages; ++i) {
                         page = pgdat_page_nr(pgdat, i);
diff --git a/arch/ia64/kernel/traps.c b/arch/ia64/kernel/traps.c
index dabd6c32641e..7c1ddc8ac443 100644
--- a/arch/ia64/kernel/traps.c
+++ b/arch/ia64/kernel/traps.c
@@ -30,19 +30,19 @@ extern spinlock_t timerlist_lock;
 fpswa_interface_t *fpswa_interface;
 EXPORT_SYMBOL(fpswa_interface);
 
-struct notifier_block *ia64die_chain;
+ATOMIC_NOTIFIER_HEAD(ia64die_chain);
 
 int
 register_die_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&ia64die_chain, nb);
+        return atomic_notifier_chain_register(&ia64die_chain, nb);
 }
 EXPORT_SYMBOL_GPL(register_die_notifier);
 
 int
 unregister_die_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&ia64die_chain, nb);
+        return atomic_notifier_chain_unregister(&ia64die_chain, nb);
 }
 EXPORT_SYMBOL_GPL(unregister_die_notifier);
 
diff --git a/arch/ia64/mm/discontig.c b/arch/ia64/mm/discontig.c
index 2f5e44862e91..ec9eeb89975d 100644
--- a/arch/ia64/mm/discontig.c
+++ b/arch/ia64/mm/discontig.c
@@ -379,31 +379,6 @@ static void __init *memory_less_node_alloc(int nid, unsigned long pernodesize)
 }
 
 /**
- * pgdat_insert - insert the pgdat into global pgdat_list
- * @pgdat: the pgdat for a node.
- */
-static void __init pgdat_insert(pg_data_t *pgdat)
-{
-        pg_data_t *prev = NULL, *next;
-
-        for_each_pgdat(next)
-                if (pgdat->node_id < next->node_id)
-                        break;
-                else
-                        prev = next;
-
-        if (prev) {
-                prev->pgdat_next = pgdat;
-                pgdat->pgdat_next = next;
-        } else {
-                pgdat->pgdat_next = pgdat_list;
-                pgdat_list = pgdat;
-        }
-
-        return;
-}
-
-/**
  * memory_less_nodes - allocate and initialize CPU only nodes pernode
  *      information.
  */
@@ -560,7 +535,7 @@ void show_mem(void)
         printk("Mem-info:\n");
         show_free_areas();
         printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 unsigned long present;
                 unsigned long flags;
                 int shared = 0, cached = 0, reserved = 0;
@@ -745,11 +720,5 @@ void __init paging_init(void)
                                     pfn_offset, zholes_size);
         }
 
-        /*
-         * Make memory less nodes become a member of the known nodes.
-         */
-        for_each_node_mask(node, memory_less_mask)
-                pgdat_insert(mem_data[node].pgdat);
-
         zero_page_memmap_ptr = virt_to_page(ia64_imva(empty_zero_page));
 }
diff --git a/arch/ia64/mm/init.c b/arch/ia64/mm/init.c
index ff4f31fcd330..2ef1151cde90 100644
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -600,7 +600,7 @@ mem_init (void)
         kclist_add(&kcore_vmem, (void *)VMALLOC_START, VMALLOC_END-VMALLOC_START);
         kclist_add(&kcore_kernel, _stext, _end - _stext);
 
-        for_each_pgdat(pgdat)
+        for_each_online_pgdat(pgdat)
                 if (pgdat->bdata->node_bootmem_map)
                         totalram_pages += free_all_bootmem_node(pgdat);
 
diff --git a/arch/m32r/kernel/setup.c b/arch/m32r/kernel/setup.c
index d742037a7ccb..0d78942b4c76 100644
--- a/arch/m32r/kernel/setup.c
+++ b/arch/m32r/kernel/setup.c
@@ -24,6 +24,7 @@
 #include <linux/tty.h>
 #include <linux/cpu.h>
 #include <linux/nodemask.h>
+#include <linux/pfn.h>
 
 #include <asm/processor.h>
 #include <asm/pgtable.h>
diff --git a/arch/m32r/mm/discontig.c b/arch/m32r/mm/discontig.c
index 08e727955555..cf610a7c5ff0 100644
--- a/arch/m32r/mm/discontig.c
+++ b/arch/m32r/mm/discontig.c
@@ -13,6 +13,7 @@
 #include <linux/initrd.h>
 #include <linux/nodemask.h>
 #include <linux/module.h>
+#include <linux/pfn.h>
 
 #include <asm/setup.h>
 
@@ -137,12 +138,6 @@ unsigned long __init zone_sizes_init(void)
         int nid, i;
         mem_prof_t *mp;
 
-        pgdat_list = NULL;
-        for (nid = num_online_nodes() - 1 ; nid >= 0 ; nid--) {
-                NODE_DATA(nid)->pgdat_next = pgdat_list;
-                pgdat_list = NODE_DATA(nid);
-        }
-
         for_each_online_node(nid) {
                 mp = &mem_prof[nid];
                 for (i = 0 ; i < MAX_NR_ZONES ; i++) {
diff --git a/arch/m32r/mm/init.c b/arch/m32r/mm/init.c
index c9e7dad860b7..b71348fec1f4 100644
--- a/arch/m32r/mm/init.c
+++ b/arch/m32r/mm/init.c
@@ -18,6 +18,7 @@
 #include <linux/highmem.h>
 #include <linux/bitops.h>
 #include <linux/nodemask.h>
+#include <linux/pfn.h>
 #include <asm/types.h>
 #include <asm/processor.h>
 #include <asm/page.h>
@@ -47,7 +48,7 @@ void show_mem(void)
         printk("Mem-info:\n");
         show_free_areas();
         printk("Free swap:       %6ldkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 unsigned long flags;
                 pgdat_resize_lock(pgdat, &flags);
                 for (i = 0; i < pgdat->node_spanned_pages; ++i) {
diff --git a/arch/mips/ddb5xxx/common/rtc_ds1386.c b/arch/mips/ddb5xxx/common/rtc_ds1386.c
index 995896ac0e39..5dc34daa7150 100644
--- a/arch/mips/ddb5xxx/common/rtc_ds1386.c
+++ b/arch/mips/ddb5xxx/common/rtc_ds1386.c
@@ -165,6 +165,6 @@ rtc_ds1386_init(unsigned long base)
         WRITE_RTC(0xB, byte);
 
         /* set the function pointers */
-        rtc_get_time = rtc_ds1386_get_time;
-        rtc_set_time = rtc_ds1386_set_time;
+        rtc_mips_get_time = rtc_ds1386_get_time;
+        rtc_mips_set_time = rtc_ds1386_set_time;
 }
diff --git a/arch/mips/dec/time.c b/arch/mips/dec/time.c
index 174822344131..f17d3378e9a6 100644
--- a/arch/mips/dec/time.c
+++ b/arch/mips/dec/time.c
@@ -193,8 +193,8 @@ static void dec_ioasic_hpt_init(unsigned int count)
 
 void __init dec_time_init(void)
 {
-        rtc_get_time = dec_rtc_get_time;
-        rtc_set_mmss = dec_rtc_set_mmss;
+        rtc_mips_get_time = dec_rtc_get_time;
+        rtc_mips_set_mmss = dec_rtc_set_mmss;
 
         mips_timer_state = dec_timer_state;
         mips_timer_ack = dec_timer_ack;
diff --git a/arch/mips/ite-boards/generic/time.c b/arch/mips/ite-boards/generic/time.c
index f5d67ee21ac6..b79817bb6cce 100644
--- a/arch/mips/ite-boards/generic/time.c
+++ b/arch/mips/ite-boards/generic/time.c
@@ -227,8 +227,8 @@ void __init it8172_time_init(void)
 
         local_irq_restore(flags);
 
-        rtc_get_time = it8172_rtc_get_time;
-        rtc_set_time = it8172_rtc_set_time;
+        rtc_mips_get_time = it8172_rtc_get_time;
+        rtc_mips_set_time = it8172_rtc_set_time;
 }
 
 #define ALLINTS (IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | IE_IRQ3 | IE_IRQ4 | IE_IRQ5)
diff --git a/arch/mips/ite-boards/ivr/init.c b/arch/mips/ite-boards/ivr/init.c
index ea4e1935fec5..b774db035b31 100644
--- a/arch/mips/ite-boards/ivr/init.c
+++ b/arch/mips/ite-boards/ivr/init.c
@@ -45,9 +45,6 @@ extern void  __init prom_init_cmdline(void);
 extern unsigned long __init prom_get_memsize(void);
 extern void __init it8172_init_ram_resource(unsigned long memsize);
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_ALIGN(x)    (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
-
 const char *get_system_type(void)
 {
         return "Globespan IVR";
diff --git a/arch/mips/ite-boards/qed-4n-s01b/init.c b/arch/mips/ite-boards/qed-4n-s01b/init.c
index 56dca7e0c21d..e8ec8be66a80 100644
--- a/arch/mips/ite-boards/qed-4n-s01b/init.c
+++ b/arch/mips/ite-boards/qed-4n-s01b/init.c
@@ -45,9 +45,6 @@ extern void  __init prom_init_cmdline(void);
 extern unsigned long __init prom_get_memsize(void);
 extern void __init it8172_init_ram_resource(unsigned long memsize);
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_ALIGN(x)    (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
-
 const char *get_system_type(void)
 {
         return "ITE QED-4N-S01B";
diff --git a/arch/mips/jmr3927/common/rtc_ds1742.c b/arch/mips/jmr3927/common/rtc_ds1742.c
index 9a8bff153d80..a6bd3f4d3049 100644
--- a/arch/mips/jmr3927/common/rtc_ds1742.c
+++ b/arch/mips/jmr3927/common/rtc_ds1742.c
@@ -159,8 +159,8 @@ rtc_ds1742_init(unsigned long base)
         db_assert((rtc_base & 0xe0000000) == KSEG1);
 
         /* set the function pointers */
-        rtc_get_time = rtc_ds1742_get_time;
-        rtc_set_time = rtc_ds1742_set_time;
+        rtc_mips_get_time = rtc_ds1742_get_time;
+        rtc_mips_set_time = rtc_ds1742_set_time;
 
         /* clear oscillator stop bit */
         CMOS_WRITE(RTC_READ, RTC_CONTROL);
diff --git a/arch/mips/kernel/setup.c b/arch/mips/kernel/setup.c
index 0cb3b6097e0e..dcbfd27071f0 100644
--- a/arch/mips/kernel/setup.c
+++ b/arch/mips/kernel/setup.c
@@ -34,6 +34,7 @@
 #include <linux/highmem.h>
 #include <linux/console.h>
 #include <linux/mmzone.h>
+#include <linux/pfn.h>
 
 #include <asm/addrspace.h>
 #include <asm/bootinfo.h>
@@ -257,10 +258,6 @@ static inline int parse_rd_cmdline(unsigned long* rd_start, unsigned long* rd_en
         return 0;
 }
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
-
 #define MAXMEM          HIGHMEM_START
 #define MAXMEM_PFN      PFN_DOWN(MAXMEM)
 
@@ -493,10 +490,6 @@ static inline void resource_init(void)
         }
 }
 
-#undef PFN_UP
-#undef PFN_DOWN
-#undef PFN_PHYS
-
 #undef MAXMEM
 #undef MAXMEM_PFN
 
diff --git a/arch/mips/kernel/time.c b/arch/mips/kernel/time.c
index 51273b7297a7..5e51a2d8f3f0 100644
--- a/arch/mips/kernel/time.c
+++ b/arch/mips/kernel/time.c
@@ -65,9 +65,9 @@ static int null_rtc_set_time(unsigned long sec)
         return 0;
 }
 
-unsigned long (*rtc_get_time)(void) = null_rtc_get_time;
-int (*rtc_set_time)(unsigned long) = null_rtc_set_time;
-int (*rtc_set_mmss)(unsigned long);
+unsigned long (*rtc_mips_get_time)(void) = null_rtc_get_time;
+int (*rtc_mips_set_time)(unsigned long) = null_rtc_set_time;
+int (*rtc_mips_set_mmss)(unsigned long);
 
 
 /* usecs per counter cycle, shifted to left by 32 bits */
@@ -440,14 +440,14 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
         /*
          * If we have an externally synchronized Linux clock, then update
-         * CMOS clock accordingly every ~11 minutes. rtc_set_time() has to be
+         * CMOS clock accordingly every ~11 minutes. rtc_mips_set_time() has to be
          * called as close as possible to 500 ms before the new second starts.
          */
         if (ntp_synced() &&
             xtime.tv_sec > last_rtc_update + 660 &&
             (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
             (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
-                if (rtc_set_mmss(xtime.tv_sec) == 0) {
+                if (rtc_mips_set_mmss(xtime.tv_sec) == 0) {
                         last_rtc_update = xtime.tv_sec;
                 } else {
                         /* do it again in 60 s */
@@ -565,7 +565,7 @@ asmlinkage void ll_local_timer_interrupt(int irq, struct pt_regs *regs)
  *      b) (optional) calibrate and set the mips_hpt_frequency
  *          (only needed if you intended to use fixed_rate_gettimeoffset
  *           or use cpu counter as timer interrupt source)
- * 2) setup xtime based on rtc_get_time().
+ * 2) setup xtime based on rtc_mips_get_time().
  * 3) choose a appropriate gettimeoffset routine.
  * 4) calculate a couple of cached variables for later usage
  * 5) board_timer_setup() -
@@ -633,10 +633,10 @@ void __init time_init(void)
         if (board_time_init)
                 board_time_init();
 
-        if (!rtc_set_mmss)
-                rtc_set_mmss = rtc_set_time;
+        if (!rtc_mips_set_mmss)
+                rtc_mips_set_mmss = rtc_mips_set_time;
 
-        xtime.tv_sec = rtc_get_time();
+        xtime.tv_sec = rtc_mips_get_time();
         xtime.tv_nsec = 0;
 
         set_normalized_timespec(&wall_to_monotonic,
@@ -772,8 +772,8 @@ void to_tm(unsigned long tim, struct rtc_time *tm)
 
 EXPORT_SYMBOL(rtc_lock);
 EXPORT_SYMBOL(to_tm);
-EXPORT_SYMBOL(rtc_set_time);
-EXPORT_SYMBOL(rtc_get_time);
+EXPORT_SYMBOL(rtc_mips_set_time);
+EXPORT_SYMBOL(rtc_mips_get_time);
 
 unsigned long long sched_clock(void)
 {
diff --git a/arch/mips/lasat/setup.c b/arch/mips/lasat/setup.c
index 83eb08b7a072..bb70a8240e61 100644
--- a/arch/mips/lasat/setup.c
+++ b/arch/mips/lasat/setup.c
@@ -165,7 +165,8 @@ void __init plat_setup(void)
 
         /* Set up panic notifier */
         for (i = 0; i < sizeof(lasat_panic_block) / sizeof(struct notifier_block); i++)
-                notifier_chain_register(&panic_notifier_list, &lasat_panic_block[i]);
+                atomic_notifier_chain_register(&panic_notifier_list,
+                                &lasat_panic_block[i]);
 
         lasat_reboot_setup();
 
@@ -174,8 +175,8 @@ void __init plat_setup(void)
 
 #ifdef CONFIG_DS1603
         ds1603 = &ds_defs[mips_machtype];
-        rtc_get_time = ds1603_read;
-        rtc_set_time = ds1603_set;
+        rtc_mips_get_time = ds1603_read;
+        rtc_mips_set_time = ds1603_set;
 #endif
 
 #ifdef DYNAMIC_SERIAL_INIT
diff --git a/arch/mips/mips-boards/atlas/atlas_setup.c b/arch/mips/mips-boards/atlas/atlas_setup.c
index 873cf3141a31..c20d401ecf80 100644
--- a/arch/mips/mips-boards/atlas/atlas_setup.c
+++ b/arch/mips/mips-boards/atlas/atlas_setup.c
@@ -65,7 +65,7 @@ void __init plat_setup(void)
 
         board_time_init = mips_time_init;
         board_timer_setup = mips_timer_setup;
-        rtc_get_time = mips_rtc_get_time;
+        rtc_mips_get_time = mips_rtc_get_time;
 }
 
 static void __init serial_init(void)
diff --git a/arch/mips/mips-boards/generic/memory.c b/arch/mips/mips-boards/generic/memory.c
index ee5e70c95cf3..32c9210373ac 100644
--- a/arch/mips/mips-boards/generic/memory.c
+++ b/arch/mips/mips-boards/generic/memory.c
@@ -49,9 +49,6 @@ static char *mtypes[3] = {
 /* References to section boundaries */
 extern char _end;
 
-#define PFN_ALIGN(x)    (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
-
-
 struct prom_pmemblock * __init prom_getmdesc(void)
 {
         char *memsize_str;
@@ -109,10 +106,10 @@ struct prom_pmemblock * __init prom_getmdesc(void)
 
         mdesc[3].type = yamon_dontuse;
         mdesc[3].base = 0x00100000;
-        mdesc[3].size = CPHYSADDR(PFN_ALIGN(&_end)) - mdesc[3].base;
+        mdesc[3].size = CPHYSADDR(PAGE_ALIGN(&_end)) - mdesc[3].base;
 
         mdesc[4].type = yamon_free;
-        mdesc[4].base = CPHYSADDR(PFN_ALIGN(&_end));
+        mdesc[4].base = CPHYSADDR(PAGE_ALIGN(&_end));
         mdesc[4].size = memsize - mdesc[4].base;
 
         return &mdesc[0];
diff --git a/arch/mips/mips-boards/malta/malta_setup.c b/arch/mips/mips-boards/malta/malta_setup.c
index 2209e8a9de34..b8488aab6df1 100644
--- a/arch/mips/mips-boards/malta/malta_setup.c
+++ b/arch/mips/mips-boards/malta/malta_setup.c
@@ -225,5 +225,5 @@ void __init plat_setup(void)
 
         board_time_init = mips_time_init;
         board_timer_setup = mips_timer_setup;
-        rtc_get_time = mips_rtc_get_time;
+        rtc_mips_get_time = mips_rtc_get_time;
 }
diff --git a/arch/mips/mips-boards/sim/sim_mem.c b/arch/mips/mips-boards/sim/sim_mem.c
index 1ec4e75656bd..e57f737bab10 100644
--- a/arch/mips/mips-boards/sim/sim_mem.c
+++ b/arch/mips/mips-boards/sim/sim_mem.c
@@ -42,9 +42,6 @@ static char *mtypes[3] = {
 /* References to section boundaries */
 extern char _end;
 
-#define PFN_ALIGN(x)    (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
-
-
 struct prom_pmemblock * __init prom_getmdesc(void)
 {
         unsigned int memsize;
@@ -64,10 +61,10 @@ struct prom_pmemblock * __init prom_getmdesc(void)
 
         mdesc[2].type = simmem_reserved;
         mdesc[2].base = 0x00100000;
-        mdesc[2].size = CPHYSADDR(PFN_ALIGN(&_end)) - mdesc[2].base;
+        mdesc[2].size = CPHYSADDR(PAGE_ALIGN(&_end)) - mdesc[2].base;
 
         mdesc[3].type = simmem_free;
-        mdesc[3].base = CPHYSADDR(PFN_ALIGN(&_end));
+        mdesc[3].base = CPHYSADDR(PAGE_ALIGN(&_end));
         mdesc[3].size = memsize - mdesc[3].base;
 
         return &mdesc[0];
diff --git a/arch/mips/mm/init.c b/arch/mips/mm/init.c
index 52f7d59fe612..ad89c442f299 100644
--- a/arch/mips/mm/init.c
+++ b/arch/mips/mm/init.c
@@ -25,6 +25,7 @@
 #include <linux/highmem.h>
 #include <linux/swap.h>
 #include <linux/proc_fs.h>
+#include <linux/pfn.h>
 
 #include <asm/bootinfo.h>
 #include <asm/cachectl.h>
@@ -177,9 +178,6 @@ void __init paging_init(void)
         free_area_init(zones_size);
 }
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-
 static inline int page_is_ram(unsigned long pagenr)
 {
         int i;
diff --git a/arch/mips/momentum/jaguar_atx/setup.c b/arch/mips/momentum/jaguar_atx/setup.c
index 3784c898db1a..91d9637143d7 100644
--- a/arch/mips/momentum/jaguar_atx/setup.c
+++ b/arch/mips/momentum/jaguar_atx/setup.c
@@ -229,8 +229,8 @@ void momenco_time_init(void)
         mips_hpt_frequency = cpu_clock / 2;
         board_timer_setup = momenco_timer_setup;
 
-        rtc_get_time = m48t37y_get_time;
-        rtc_set_time = m48t37y_set_time;
+        rtc_mips_get_time = m48t37y_get_time;
+        rtc_mips_set_time = m48t37y_set_time;
 }
 
 static struct resource mv_pci_io_mem0_resource = {
diff --git a/arch/mips/momentum/ocelot_3/setup.c b/arch/mips/momentum/ocelot_3/setup.c
index f95677f4f06f..969612eab8a6 100644
--- a/arch/mips/momentum/ocelot_3/setup.c
+++ b/arch/mips/momentum/ocelot_3/setup.c
@@ -215,8 +215,8 @@ void momenco_time_init(void)
         mips_hpt_frequency = cpu_clock / 2;
         board_timer_setup = momenco_timer_setup;
 
-        rtc_get_time = m48t37y_get_time;
-        rtc_set_time = m48t37y_set_time;
+        rtc_mips_get_time = m48t37y_get_time;
+        rtc_mips_set_time = m48t37y_set_time;
 }
 
 /*
diff --git a/arch/mips/momentum/ocelot_c/setup.c b/arch/mips/momentum/ocelot_c/setup.c
index bd02e60d037a..a3e6f5575592 100644
--- a/arch/mips/momentum/ocelot_c/setup.c
+++ b/arch/mips/momentum/ocelot_c/setup.c
@@ -227,8 +227,8 @@ void momenco_time_init(void)
         printk("momenco_time_init cpu_clock=%d\n", cpu_clock);
         board_timer_setup = momenco_timer_setup;
 
-        rtc_get_time = m48t37y_get_time;
-        rtc_set_time = m48t37y_set_time;
+        rtc_mips_get_time = m48t37y_get_time;
+        rtc_mips_set_time = m48t37y_set_time;
 }
 
 void __init plat_setup(void)
diff --git a/arch/mips/pmc-sierra/yosemite/setup.c b/arch/mips/pmc-sierra/yosemite/setup.c
index 8bce711575de..3f724d661bdb 100644
--- a/arch/mips/pmc-sierra/yosemite/setup.c
+++ b/arch/mips/pmc-sierra/yosemite/setup.c
@@ -198,8 +198,8 @@ static void __init py_rtc_setup(void)
         if (!m48t37_base)
                 printk(KERN_ERR "Mapping the RTC failed\n");
 
-        rtc_get_time = m48t37y_get_time;
-        rtc_set_time = m48t37y_set_time;
+        rtc_mips_get_time = m48t37y_get_time;
+        rtc_mips_set_time = m48t37y_set_time;
 
         write_seqlock(&xtime_lock);
         xtime.tv_sec = m48t37y_get_time();
diff --git a/arch/mips/sgi-ip22/ip22-reset.c b/arch/mips/sgi-ip22/ip22-reset.c
index 92a3b3c15ed3..a9c58e067b53 100644
--- a/arch/mips/sgi-ip22/ip22-reset.c
+++ b/arch/mips/sgi-ip22/ip22-reset.c
@@ -238,7 +238,7 @@ static int __init reboot_setup(void)
         request_irq(SGI_PANEL_IRQ, panel_int, 0, "Front Panel", NULL);
         init_timer(&blink_timer);
         blink_timer.function = blink_timeout;
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         return 0;
 }
diff --git a/arch/mips/sgi-ip22/ip22-time.c b/arch/mips/sgi-ip22/ip22-time.c
index b7300cc5c5ad..cca688ad64ad 100644
--- a/arch/mips/sgi-ip22/ip22-time.c
+++ b/arch/mips/sgi-ip22/ip22-time.c
@@ -212,8 +212,8 @@ static void indy_timer_setup(struct irqaction *irq)
 void __init ip22_time_init(void)
 {
         /* setup hookup functions */
-        rtc_get_time = indy_rtc_get_time;
-        rtc_set_time = indy_rtc_set_time;
+        rtc_mips_get_time = indy_rtc_get_time;
+        rtc_mips_set_time = indy_rtc_set_time;
 
         board_time_init = indy_time_init;
         board_timer_setup = indy_timer_setup;
diff --git a/arch/mips/sgi-ip27/ip27-memory.c b/arch/mips/sgi-ip27/ip27-memory.c
index e0d095daa5ed..6c00dce9f73f 100644
--- a/arch/mips/sgi-ip27/ip27-memory.c
+++ b/arch/mips/sgi-ip27/ip27-memory.c
@@ -19,6 +19,7 @@
 #include <linux/nodemask.h>
 #include <linux/swap.h>
 #include <linux/bootmem.h>
+#include <linux/pfn.h>
 #include <asm/page.h>
 #include <asm/sections.h>
 
@@ -28,8 +29,6 @@
 #include <asm/sn/sn_private.h>
 
 
-#define PFN_UP(x)               (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-
 #define SLOT_PFNSHIFT           (SLOT_SHIFT - PAGE_SHIFT)
 #define PFN_NASIDSHFT           (NASID_SHFT - PAGE_SHIFT)
 
diff --git a/arch/mips/sgi-ip32/ip32-reset.c b/arch/mips/sgi-ip32/ip32-reset.c
index 0c948008b023..ab9d9cef089e 100644
--- a/arch/mips/sgi-ip32/ip32-reset.c
+++ b/arch/mips/sgi-ip32/ip32-reset.c
@@ -193,7 +193,7 @@ static __init int ip32_reboot_setup(void)
 
         init_timer(&blink_timer);
         blink_timer.function = blink_timeout;
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         request_irq(MACEISA_RTC_IRQ, ip32_rtc_int, 0, "rtc", NULL);
 
diff --git a/arch/mips/sgi-ip32/ip32-setup.c b/arch/mips/sgi-ip32/ip32-setup.c
index 2f50c79b7887..a2dd8ae1ea8f 100644
--- a/arch/mips/sgi-ip32/ip32-setup.c
+++ b/arch/mips/sgi-ip32/ip32-setup.c
@@ -91,8 +91,8 @@ void __init plat_setup(void)
 {
         board_be_init = ip32_be_init;
 
-        rtc_get_time = mc146818_get_cmos_time;
-        rtc_set_mmss = mc146818_set_rtc_mmss;
+        rtc_mips_get_time = mc146818_get_cmos_time;
+        rtc_mips_set_mmss = mc146818_set_rtc_mmss;
 
         board_time_init = ip32_time_init;
         board_timer_setup = ip32_timer_setup;
diff --git a/arch/mips/sibyte/swarm/setup.c b/arch/mips/sibyte/swarm/setup.c
index b661d2425a36..4b5f74ff3edd 100644
--- a/arch/mips/sibyte/swarm/setup.c
+++ b/arch/mips/sibyte/swarm/setup.c
@@ -121,14 +121,14 @@ void __init plat_setup(void)
 
         if (xicor_probe()) {
                 printk("swarm setup: Xicor 1241 RTC detected.\n");
-                rtc_get_time = xicor_get_time;
-                rtc_set_time = xicor_set_time;
+                rtc_mips_get_time = xicor_get_time;
+                rtc_mips_set_time = xicor_set_time;
         }
 
         if (m41t81_probe()) {
                 printk("swarm setup: M41T81 RTC detected.\n");
-                rtc_get_time = m41t81_get_time;
-                rtc_set_time = m41t81_set_time;
+                rtc_mips_get_time = m41t81_get_time;
+                rtc_mips_set_time = m41t81_set_time;
         }
 
         printk("This kernel optimized for "
diff --git a/arch/mips/sni/setup.c b/arch/mips/sni/setup.c
index 1141fcd13a59..01ba6c581e3d 100644
--- a/arch/mips/sni/setup.c
+++ b/arch/mips/sni/setup.c
@@ -164,8 +164,8 @@ static struct pci_controller sni_controller = {
 
 static inline void sni_pcimt_time_init(void)
 {
-        rtc_get_time = mc146818_get_cmos_time;
-        rtc_set_time = mc146818_set_rtc_mmss;
+        rtc_mips_get_time = mc146818_get_cmos_time;
+        rtc_mips_set_time = mc146818_set_rtc_mmss;
 }
 
 void __init plat_setup(void)
diff --git a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
index 2ad6401d2af4..6dcf077f61a0 100644
--- a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
+++ b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
@@ -1036,8 +1036,8 @@ toshiba_rbtx4927_time_init(void)
 
 #ifdef CONFIG_RTC_DS1742
 
-        rtc_get_time = rtc_ds1742_get_time;
-        rtc_set_time = rtc_ds1742_set_time;
+        rtc_mips_get_time = rtc_ds1742_get_time;
+        rtc_mips_set_time = rtc_ds1742_set_time;
 
         TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_TIME_INIT,
                                        ":rtc_ds1742_init()-\n");
diff --git a/arch/mips/tx4938/common/rtc_rx5c348.c b/arch/mips/tx4938/common/rtc_rx5c348.c
index d249edbb6af4..f74295f28527 100644
--- a/arch/mips/tx4938/common/rtc_rx5c348.c
+++ b/arch/mips/tx4938/common/rtc_rx5c348.c
@@ -197,6 +197,6 @@ rtc_rx5c348_init(int chipid)
                 srtc_24h = 1;
 
         /* set the function pointers */
-        rtc_get_time = rtc_rx5c348_get_time;
-        rtc_set_time = rtc_rx5c348_set_time;
+        rtc_mips_get_time = rtc_rx5c348_get_time;
+        rtc_mips_set_time = rtc_rx5c348_set_time;
 }
diff --git a/arch/parisc/kernel/pdc_chassis.c b/arch/parisc/kernel/pdc_chassis.c
index 2a01fe1bdc98..0cea6958f427 100644
--- a/arch/parisc/kernel/pdc_chassis.c
+++ b/arch/parisc/kernel/pdc_chassis.c
@@ -150,7 +150,8 @@ void __init parisc_pdc_chassis_init(void)
 
                 if (handle) {
                         /* initialize panic notifier chain */
-                        notifier_chain_register(&panic_notifier_list, &pdc_chassis_panic_block);
+                        atomic_notifier_chain_register(&panic_notifier_list,
+                                        &pdc_chassis_panic_block);
 
                         /* initialize reboot notifier chain */
                         register_reboot_notifier(&pdc_chassis_reboot_block);
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index 2f3fdad35594..e20c1fae3423 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -579,7 +579,8 @@ void __init setup_arch(char **cmdline_p)
         panic_timeout = 180;
 
         if (ppc_md.panic)
-                notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);
+                atomic_notifier_chain_register(&panic_notifier_list,
+                                &ppc64_panic_block);
 
         init_mm.start_code = PAGE_OFFSET;
         init_mm.end_code = (unsigned long) _etext;
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 98660aedeeb7..9763faab6739 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -74,19 +74,19 @@ EXPORT_SYMBOL(__debugger_dabr_match);
 EXPORT_SYMBOL(__debugger_fault_handler);
 #endif
 
-struct notifier_block *powerpc_die_chain;
-static DEFINE_SPINLOCK(die_notifier_lock);
+ATOMIC_NOTIFIER_HEAD(powerpc_die_chain);
 
 int register_die_notifier(struct notifier_block *nb)
 {
-        int err = 0;
-        unsigned long flags;
+        return atomic_notifier_chain_register(&powerpc_die_chain, nb);
+}
+EXPORT_SYMBOL(register_die_notifier);
 
-        spin_lock_irqsave(&die_notifier_lock, flags);
-        err = notifier_chain_register(&powerpc_die_chain, nb);
-        spin_unlock_irqrestore(&die_notifier_lock, flags);
-        return err;
+int unregister_die_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&powerpc_die_chain, nb);
 }
+EXPORT_SYMBOL(unregister_die_notifier);
 
 /*
  * Trap & Exception support
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index badac10d700c..5e435a9c3431 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -195,7 +195,7 @@ void show_mem(void)
         printk("Mem-info:\n");
         show_free_areas();
         printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 unsigned long flags;
                 pgdat_resize_lock(pgdat, &flags);
                 for (i = 0; i < pgdat->node_spanned_pages; i++) {
@@ -351,7 +351,7 @@ void __init mem_init(void)
         max_mapnr = max_pfn;
         totalram_pages += free_all_bootmem();
 #endif
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 for (i = 0; i < pgdat->node_spanned_pages; i++) {
                         if (!pfn_valid(pgdat->node_start_pfn + i))
                                 continue;
diff --git a/arch/powerpc/platforms/pseries/reconfig.c b/arch/powerpc/platforms/pseries/reconfig.c
index 86cfa6ecdcf3..5ad90676567a 100644
--- a/arch/powerpc/platforms/pseries/reconfig.c
+++ b/arch/powerpc/platforms/pseries/reconfig.c
@@ -94,16 +94,16 @@ static struct device_node *derive_parent(const char *path)
         return parent;
 }
 
-static struct notifier_block *pSeries_reconfig_chain;
+static BLOCKING_NOTIFIER_HEAD(pSeries_reconfig_chain);
 
 int pSeries_reconfig_notifier_register(struct notifier_block *nb)
 {
-        return notifier_chain_register(&pSeries_reconfig_chain, nb);
+        return blocking_notifier_chain_register(&pSeries_reconfig_chain, nb);
 }
 
 void pSeries_reconfig_notifier_unregister(struct notifier_block *nb)
 {
-        notifier_chain_unregister(&pSeries_reconfig_chain, nb);
+        blocking_notifier_chain_unregister(&pSeries_reconfig_chain, nb);
 }
 
 static int pSeries_reconfig_add_node(const char *path, struct property *proplist)
@@ -131,7 +131,7 @@ static int pSeries_reconfig_add_node(const char *path, struct property *proplist
                 goto out_err;
         }
 
-        err = notifier_call_chain(&pSeries_reconfig_chain,
+        err = blocking_notifier_call_chain(&pSeries_reconfig_chain,
                                   PSERIES_RECONFIG_ADD, np);
         if (err == NOTIFY_BAD) {
                 printk(KERN_ERR "Failed to add device node %s\n", path);
@@ -171,7 +171,7 @@ static int pSeries_reconfig_remove_node(struct device_node *np)
 
         remove_node_proc_entries(np);
 
-        notifier_call_chain(&pSeries_reconfig_chain,
+        blocking_notifier_call_chain(&pSeries_reconfig_chain,
                             PSERIES_RECONFIG_REMOVE, np);
         of_detach_node(np);
 
diff --git a/arch/ppc/platforms/prep_setup.c b/arch/ppc/platforms/prep_setup.c
index a0fc628ffb1e..d95c05d9824d 100644
--- a/arch/ppc/platforms/prep_setup.c
+++ b/arch/ppc/platforms/prep_setup.c
@@ -736,7 +736,7 @@ ibm_statusled_progress(char *s, unsigned short hex)
                 hex = 0xfff;
                 if (!notifier_installed) {
                         ++notifier_installed;
-                        notifier_chain_register(&panic_notifier_list,
+                        atomic_notifier_chain_register(&panic_notifier_list,
                                                 &ibm_statusled_block);
                 }
         }
diff --git a/arch/s390/kernel/process.c b/arch/s390/kernel/process.c
index 99182a415fe7..4a0f5a1551ea 100644
--- a/arch/s390/kernel/process.c
+++ b/arch/s390/kernel/process.c
@@ -76,17 +76,17 @@ unsigned long thread_saved_pc(struct task_struct *tsk)
 /*
  * Need to know about CPUs going idle?
  */
-static struct notifier_block *idle_chain;
+static ATOMIC_NOTIFIER_HEAD(idle_chain);
 
 int register_idle_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&idle_chain, nb);
+        return atomic_notifier_chain_register(&idle_chain, nb);
 }
 EXPORT_SYMBOL(register_idle_notifier);
 
 int unregister_idle_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&idle_chain, nb);
+        return atomic_notifier_chain_unregister(&idle_chain, nb);
 }
 EXPORT_SYMBOL(unregister_idle_notifier);
 
@@ -95,7 +95,7 @@ void do_monitor_call(struct pt_regs *regs, long interruption_code)
         /* disable monitor call class 0 */
         __ctl_clear_bit(8, 15);
 
-        notifier_call_chain(&idle_chain, CPU_NOT_IDLE,
+        atomic_notifier_call_chain(&idle_chain, CPU_NOT_IDLE,
                             (void *)(long) smp_processor_id());
 }
 
@@ -116,7 +116,8 @@ static void default_idle(void)
                 return;
         }
 
-        rc = notifier_call_chain(&idle_chain, CPU_IDLE, (void *)(long) cpu);
+        rc = atomic_notifier_call_chain(&idle_chain,
+                        CPU_IDLE, (void *)(long) cpu);
         if (rc != NOTIFY_OK && rc != NOTIFY_DONE)
                 BUG();
         if (rc != NOTIFY_OK) {
diff --git a/arch/sh/kernel/setup.c b/arch/sh/kernel/setup.c
index c0e79843f580..7ee4ca203616 100644
--- a/arch/sh/kernel/setup.c
+++ b/arch/sh/kernel/setup.c
@@ -20,6 +20,7 @@
 #include <linux/root_dev.h>
 #include <linux/utsname.h>
 #include <linux/cpu.h>
+#include <linux/pfn.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/sections.h>
@@ -275,10 +276,6 @@ void __init setup_arch(char **cmdline_p)
 
         sh_mv_setup(cmdline_p);
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
-
         /*
          * Find the highest page frame number we have available
          */
diff --git a/arch/sh64/kernel/setup.c b/arch/sh64/kernel/setup.c
index c7a7b816a30f..d2711c9c9d13 100644
--- a/arch/sh64/kernel/setup.c
+++ b/arch/sh64/kernel/setup.c
@@ -48,6 +48,7 @@
 #include <linux/root_dev.h>
 #include <linux/cpu.h>
 #include <linux/initrd.h>
+#include <linux/pfn.h>
 #include <asm/processor.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
diff --git a/arch/sparc64/defconfig b/arch/sparc64/defconfig
index f819a9663a8d..900fb0b940d8 100644
--- a/arch/sparc64/defconfig
+++ b/arch/sparc64/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
 # Linux kernel version: 2.6.16
-# Mon Mar 20 01:23:21 2006
+# Sun Mar 26 14:58:11 2006
 #
 CONFIG_SPARC=y
 CONFIG_SPARC64=y
@@ -38,6 +38,7 @@ CONFIG_POSIX_MQUEUE=y
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
 # CONFIG_IKCONFIG is not set
+CONFIG_RELAY=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_UID16=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
@@ -53,10 +54,6 @@ CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
 CONFIG_SHMEM=y
-CONFIG_CC_ALIGN_FUNCTIONS=0
-CONFIG_CC_ALIGN_LABELS=0
-CONFIG_CC_ALIGN_LOOPS=0
-CONFIG_CC_ALIGN_JUMPS=0
 CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
@@ -68,7 +65,6 @@ CONFIG_BASE_SMALL=0
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
-CONFIG_OBSOLETE_MODPARM=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
 CONFIG_KMOD=y
@@ -76,6 +72,7 @@ CONFIG_KMOD=y
 #
 # Block layer
 #
+CONFIG_BLK_DEV_IO_TRACE=y
 
 #
 # IO Schedulers
@@ -111,6 +108,8 @@ CONFIG_CPU_FREQ_GOV_CONSERVATIVE=m
 CONFIG_US3_FREQ=m
 CONFIG_US2E_FREQ=m
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_GENERIC_FIND_NEXT_BIT=y
+CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
 CONFIG_HUGETLB_PAGE_SIZE_4MB=y
 # CONFIG_HUGETLB_PAGE_SIZE_512K is not set
@@ -128,7 +127,6 @@ CONFIG_HAVE_MEMORY_PRESENT=y
 CONFIG_SPARSEMEM_EXTREME=y
 CONFIG_MEMORY_HOTPLUG=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
-CONFIG_MIGRATION=y
 CONFIG_GENERIC_ISA_DMA=y
 CONFIG_SBUS=y
 CONFIG_SBUSCHAR=y
@@ -136,7 +134,6 @@ CONFIG_SUN_AUXIO=y
 CONFIG_SUN_IO=y
 CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
-# CONFIG_PCI_LEGACY_PROC is not set
 # CONFIG_PCI_DEBUG is not set
 CONFIG_SUN_OPENPROMFS=m
 CONFIG_SPARC32_COMPAT=y
@@ -201,6 +198,8 @@ CONFIG_TCP_CONG_VEGAS=m
 CONFIG_TCP_CONG_SCALABLE=m
 CONFIG_IPV6=m
 CONFIG_IPV6_PRIVACY=y
+CONFIG_IPV6_ROUTER_PREF=y
+CONFIG_IPV6_ROUTE_INFO=y
 CONFIG_INET6_AH=m
 CONFIG_INET6_ESP=m
 CONFIG_INET6_IPCOMP=m
@@ -213,10 +212,12 @@ CONFIG_IPV6_TUNNEL=m
 #
 CONFIG_IP_DCCP=m
 CONFIG_INET_DCCP_DIAG=m
+CONFIG_IP_DCCP_ACKVEC=y
 
 #
 # DCCP CCIDs Configuration (EXPERIMENTAL)
 #
+CONFIG_IP_DCCP_CCID2=m
 CONFIG_IP_DCCP_CCID3=m
 CONFIG_IP_DCCP_TFRC_LIB=m
 
@@ -224,7 +225,6 @@ CONFIG_IP_DCCP_TFRC_LIB=m
 # DCCP Kernel Hacking
 #
 # CONFIG_IP_DCCP_DEBUG is not set
-# CONFIG_IP_DCCP_UNLOAD_HACK is not set
 
 #
 # SCTP Configuration (EXPERIMENTAL)
@@ -309,6 +309,7 @@ CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_UB=m
 # CONFIG_BLK_DEV_RAM is not set
 CONFIG_BLK_DEV_RAM_COUNT=16
+# CONFIG_BLK_DEV_INITRD is not set
 CONFIG_CDROM_PKTCDVD=m
 CONFIG_CDROM_PKTCDVD_BUFFERS=8
 CONFIG_CDROM_PKTCDVD_WCACHE=y
@@ -722,7 +723,6 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_PARPORT_LIGHT is not set
 # CONFIG_I2C_PROSAVAGE is not set
 # CONFIG_I2C_SAVAGE4 is not set
-# CONFIG_SCx200_ACB is not set
 # CONFIG_I2C_SIS5595 is not set
 # CONFIG_I2C_SIS630 is not set
 # CONFIG_I2C_SIS96X is not set
@@ -808,10 +808,6 @@ CONFIG_HWMON=y
 #
 
 #
-# Multimedia Capabilities Port drivers
-#
-
-#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
@@ -820,6 +816,7 @@ CONFIG_HWMON=y
 # Digital Video Broadcasting Devices
 #
 # CONFIG_DVB is not set
+# CONFIG_USB_DABUSB is not set
 
 #
 # Graphics support
@@ -901,10 +898,12 @@ CONFIG_SND_SEQ_DUMMY=m
 CONFIG_SND_OSSEMUL=y
 CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
+CONFIG_SND_PCM_OSS_PLUGINS=y
 CONFIG_SND_SEQUENCER_OSS=y
 # CONFIG_SND_RTCTIMER is not set
 # CONFIG_SND_DYNAMIC_MINORS is not set
 CONFIG_SND_SUPPORT_OLD_API=y
+CONFIG_SND_VERBOSE_PROCFS=y
 # CONFIG_SND_VERBOSE_PRINTK is not set
 # CONFIG_SND_DEBUG is not set
 
@@ -987,6 +986,7 @@ CONFIG_SND_SUN_CS4231=m
 #
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB_ARCH_HAS_EHCI=y
 CONFIG_USB=y
 # CONFIG_USB_DEBUG is not set
 
@@ -1014,7 +1014,6 @@ CONFIG_USB_UHCI_HCD=m
 #
 # USB Device Class drivers
 #
-# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
 
@@ -1058,15 +1057,6 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_MICROTEK is not set
 
 #
-# USB Multimedia devices
-#
-# CONFIG_USB_DABUSB is not set
-
-#
-# Video4Linux support is needed for USB Multimedia device support
-#
-
-#
 # USB Network Adapters
 #
 # CONFIG_USB_CATC is not set
@@ -1194,7 +1184,6 @@ CONFIG_TMPFS=y
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
-CONFIG_RELAYFS_FS=m
 # CONFIG_CONFIGFS_FS is not set
 
 #
diff --git a/arch/sparc64/kernel/sparc64_ksyms.c b/arch/sparc64/kernel/sparc64_ksyms.c
index c7fbbcfce824..f5e8db1de76b 100644
--- a/arch/sparc64/kernel/sparc64_ksyms.c
+++ b/arch/sparc64/kernel/sparc64_ksyms.c
@@ -274,18 +274,9 @@ EXPORT_SYMBOL(__prom_getsibling);
 
 /* sparc library symbols */
 EXPORT_SYMBOL(strlen);
-EXPORT_SYMBOL(strnlen);
 EXPORT_SYMBOL(__strlen_user);
 EXPORT_SYMBOL(__strnlen_user);
-EXPORT_SYMBOL(strcpy);
-EXPORT_SYMBOL(strncpy);
-EXPORT_SYMBOL(strcat);
-EXPORT_SYMBOL(strncat);
-EXPORT_SYMBOL(strcmp);
-EXPORT_SYMBOL(strchr);
-EXPORT_SYMBOL(strrchr);
 EXPORT_SYMBOL(strpbrk);
-EXPORT_SYMBOL(strstr);
 
 #ifdef CONFIG_SOLARIS_EMUL_MODULE
 EXPORT_SYMBOL(linux_sparc_syscall);
@@ -319,7 +310,6 @@ EXPORT_SYMBOL(__memscan_zero);
 EXPORT_SYMBOL(__memscan_generic);
 EXPORT_SYMBOL(__memcmp);
 EXPORT_SYMBOL(__memset);
-EXPORT_SYMBOL(memchr);
 
 EXPORT_SYMBOL(csum_partial);
 EXPORT_SYMBOL(csum_partial_copy_nocheck);
diff --git a/arch/sparc64/kernel/traps.c b/arch/sparc64/kernel/traps.c
index df612e4f75f9..ff090bb9734b 100644
--- a/arch/sparc64/kernel/traps.c
+++ b/arch/sparc64/kernel/traps.c
@@ -43,18 +43,19 @@
 #include <linux/kmod.h>
 #endif
 
-struct notifier_block *sparc64die_chain;
-static DEFINE_SPINLOCK(die_notifier_lock);
+ATOMIC_NOTIFIER_HEAD(sparc64die_chain);
 
 int register_die_notifier(struct notifier_block *nb)
 {
-        int err = 0;
-        unsigned long flags;
-        spin_lock_irqsave(&die_notifier_lock, flags);
-        err = notifier_chain_register(&sparc64die_chain, nb);
-        spin_unlock_irqrestore(&die_notifier_lock, flags);
-        return err;
+        return atomic_notifier_chain_register(&sparc64die_chain, nb);
 }
+EXPORT_SYMBOL(register_die_notifier);
+
+int unregister_die_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&sparc64die_chain, nb);
+}
+EXPORT_SYMBOL(unregister_die_notifier);
 
 /* When an irrecoverable trap occurs at tl > 0, the trap entry
  * code logs the trap state registers at every level in the trap
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index 54388d10bcf9..1488816588ea 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -762,7 +762,8 @@ static struct notifier_block panic_exit_notifier = {
 
 static int add_notifier(void)
 {
-        notifier_chain_register(&panic_notifier_list, &panic_exit_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &panic_exit_notifier);
         return(0);
 }
 
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index fa617e0719ab..0336575d2448 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -71,7 +71,7 @@ struct io_thread_req {
         int error;
 };
 
-extern int open_ubd_file(char *file, struct openflags *openflags,
+extern int open_ubd_file(char *file, struct openflags *openflags, int shared,
                          char **backing_file_out, int *bitmap_offset_out,
                          unsigned long *bitmap_len_out, int *data_offset_out,
                          int *create_cow_out);
@@ -137,7 +137,7 @@ static int fake_major = MAJOR_NR;
 
 static struct gendisk *ubd_gendisk[MAX_DEV];
 static struct gendisk *fake_gendisk[MAX_DEV];
- 
+
 #ifdef CONFIG_BLK_DEV_UBD_SYNC
 #define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 1, .c = 0, \
                                          .cl = 1 })
@@ -168,6 +168,7 @@ struct ubd {
         __u64 size;
         struct openflags boot_openflags;
         struct openflags openflags;
+        int shared;
         int no_cow;
         struct cow cow;
         struct platform_device pdev;
@@ -189,6 +190,7 @@ struct ubd {
         .boot_openflags =       OPEN_FLAGS, \
         .openflags =            OPEN_FLAGS, \
         .no_cow =               0, \
+        .shared =               0, \
         .cow =                  DEFAULT_COW, \
 }
 
@@ -305,7 +307,7 @@ static int ubd_setup_common(char *str, int *index_out)
                 }
                 major = simple_strtoul(str, &end, 0);
                 if((*end != '\0') || (end == str)){
-                        printk(KERN_ERR 
+                        printk(KERN_ERR
                                "ubd_setup : didn't parse major number\n");
                         return(1);
                 }
@@ -316,7 +318,7 @@ static int ubd_setup_common(char *str, int *index_out)
                         printk(KERN_ERR "Can't assign a fake major twice\n");
                         goto out1;
                 }
- 
+
                 fake_major = major;
 
                 printk(KERN_INFO "Setting extra ubd major number to %d\n",
@@ -351,7 +353,7 @@ static int ubd_setup_common(char *str, int *index_out)
         if (index_out)
                 *index_out = n;
 
-        for (i = 0; i < 4; i++) {
+        for (i = 0; i < sizeof("rscd="); i++) {
                 switch (*str) {
                 case 'r':
                         flags.w = 0;
@@ -362,11 +364,14 @@ static int ubd_setup_common(char *str, int *index_out)
                 case 'd':
                         dev->no_cow = 1;
                         break;
+                case 'c':
+                        dev->shared = 1;
+                        break;
                 case '=':
                         str++;
                         goto break_loop;
                 default:
-                        printk(KERN_ERR "ubd_setup : Expected '=' or flag letter (r,s or d)\n");
+                        printk(KERN_ERR "ubd_setup : Expected '=' or flag letter (r, s, c, or d)\n");
                         goto out;
                 }
                 str++;
@@ -515,7 +520,7 @@ static void ubd_handler(void)
                 spin_unlock(&ubd_io_lock);
                 return;
         }
-        
+
         ubd_finish(rq, req.error);
         reactivate_fd(thread_fd, UBD_IRQ);      
         do_ubd_request(ubd_queue);
@@ -532,7 +537,7 @@ static int io_pid = -1;
 
 void kill_io_thread(void)
 {
-        if(io_pid != -1) 
+        if(io_pid != -1)
                 os_kill_process(io_pid, 1);
 }
 
@@ -567,14 +572,15 @@ static int ubd_open_dev(struct ubd *dev)
         create_cow = 0;
         create_ptr = (dev->cow.file != NULL) ? &create_cow : NULL;
         back_ptr = dev->no_cow ? NULL : &dev->cow.file;
-        dev->fd = open_ubd_file(dev->file, &dev->openflags, back_ptr,
-                                &dev->cow.bitmap_offset, &dev->cow.bitmap_len, 
-                                &dev->cow.data_offset, create_ptr);
+        dev->fd = open_ubd_file(dev->file, &dev->openflags, dev->shared,
+                                back_ptr, &dev->cow.bitmap_offset,
+                                &dev->cow.bitmap_len, &dev->cow.data_offset,
+                                create_ptr);
 
         if((dev->fd == -ENOENT) && create_cow){
-                dev->fd = create_cow_file(dev->file, dev->cow.file, 
+                dev->fd = create_cow_file(dev->file, dev->cow.file,
                                           dev->openflags, 1 << 9, PAGE_SIZE,
-                                          &dev->cow.bitmap_offset, 
+                                          &dev->cow.bitmap_offset,
                                           &dev->cow.bitmap_len,
                                           &dev->cow.data_offset);
                 if(dev->fd >= 0){
@@ -598,16 +604,16 @@ static int ubd_open_dev(struct ubd *dev)
                 }
                 flush_tlb_kernel_vm();
 
-                err = read_cow_bitmap(dev->fd, dev->cow.bitmap, 
-                                      dev->cow.bitmap_offset, 
+                err = read_cow_bitmap(dev->fd, dev->cow.bitmap,
+                                      dev->cow.bitmap_offset,
                                       dev->cow.bitmap_len);
                 if(err < 0)
                         goto error;
 
                 flags = dev->openflags;
                 flags.w = 0;
-                err = open_ubd_file(dev->cow.file, &flags, NULL, NULL, NULL, 
-                                    NULL, NULL);
+                err = open_ubd_file(dev->cow.file, &flags, dev->shared, NULL,
+                                    NULL, NULL, NULL, NULL);
                 if(err < 0) goto error;
                 dev->cow.fd = err;
         }
@@ -685,11 +691,11 @@ static int ubd_add(int n)
         dev->size = ROUND_BLOCK(dev->size);
 
         err = ubd_new_disk(MAJOR_NR, dev->size, n, &ubd_gendisk[n]);
-        if(err) 
+        if(err)
                 goto out_close;
- 
+
         if(fake_major != MAJOR_NR)
-                ubd_new_disk(fake_major, dev->size, n, 
+                ubd_new_disk(fake_major, dev->size, n,
                              &fake_gendisk[n]);
 
         /* perhaps this should also be under the "if (fake_major)" above */
@@ -854,7 +860,7 @@ int ubd_init(void)
                         return -1;
         }
         platform_driver_register(&ubd_driver);
-        for (i = 0; i < MAX_DEV; i++) 
+        for (i = 0; i < MAX_DEV; i++)
                 ubd_add(i);
         return 0;
 }
@@ -872,16 +878,16 @@ int ubd_driver_init(void){
                  * enough. So use anyway the io thread. */
         }
         stack = alloc_stack(0, 0);
-        io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *), 
+        io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *),
                                  &thread_fd);
         if(io_pid < 0){
-                printk(KERN_ERR 
+                printk(KERN_ERR
                        "ubd : Failed to start I/O thread (errno = %d) - "
                        "falling back to synchronous I/O\n", -io_pid);
                 io_pid = -1;
                 return(0);
         }
-        err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr, 
+        err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr,
                              SA_INTERRUPT, "ubd", ubd_dev);
         if(err != 0)
                 printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
@@ -978,7 +984,7 @@ static void cowify_req(struct io_thread_req *req, unsigned long *bitmap,
         if(req->op == UBD_READ) {
                 for(i = 0; i < req->length >> 9; i++){
                         if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
-                                ubd_set_bit(i, (unsigned char *) 
+                                ubd_set_bit(i, (unsigned char *)
                                             &req->sector_mask);
                 }
         }
@@ -999,7 +1005,7 @@ static int prepare_request(struct request *req, struct io_thread_req *io_req)
 
         /* This should be impossible now */
         if((rq_data_dir(req) == WRITE) && !dev->openflags.w){
-                printk("Write attempted on readonly ubd device %s\n", 
+                printk("Write attempted on readonly ubd device %s\n",
                        disk->disk_name);
                 end_request(req, 0);
                 return(1);
@@ -1182,7 +1188,7 @@ int read_cow_bitmap(int fd, void *buf, int offset, int len)
         return(0);
 }
 
-int open_ubd_file(char *file, struct openflags *openflags,
+int open_ubd_file(char *file, struct openflags *openflags, int shared,
                   char **backing_file_out, int *bitmap_offset_out,
                   unsigned long *bitmap_len_out, int *data_offset_out,
                   int *create_cow_out)
@@ -1206,10 +1212,14 @@ int open_ubd_file(char *file, struct openflags *openflags,
                         return fd;
         }
 
-        err = os_lock_file(fd, openflags->w);
-        if(err < 0){
-                printk("Failed to lock '%s', err = %d\n", file, -err);
-                goto out_close;
+        if(shared)
+                printk("Not locking \"%s\" on the host\n", file);
+        else {
+                err = os_lock_file(fd, openflags->w);
+                if(err < 0){
+                        printk("Failed to lock '%s', err = %d\n", file, -err);
+                        goto out_close;
+                }
         }
 
         /* Succesful return case! */
@@ -1260,7 +1270,7 @@ int create_cow_file(char *cow_file, char *backing_file, struct openflags flags,
         int err, fd;
 
         flags.c = 1;
-        fd = open_ubd_file(cow_file, &flags, NULL, NULL, NULL, NULL, NULL);
+        fd = open_ubd_file(cow_file, &flags, 0, NULL, NULL, NULL, NULL, NULL);
         if(fd < 0){
                 err = fd;
                 printk("Open of COW file '%s' failed, errno = %d\n", cow_file,
diff --git a/arch/um/include/irq_user.h b/arch/um/include/irq_user.h
index b61deb8b362a..69a93c804f0e 100644
--- a/arch/um/include/irq_user.h
+++ b/arch/um/include/irq_user.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -6,6 +6,17 @@
 #ifndef __IRQ_USER_H__
 #define __IRQ_USER_H__
 
+struct irq_fd {
+        struct irq_fd *next;
+        void *id;
+        int fd;
+        int type;
+        int irq;
+        int pid;
+        int events;
+        int current_events;
+};
+
 enum { IRQ_READ, IRQ_WRITE };
 
 extern void sigio_handler(int sig, union uml_pt_regs *regs);
@@ -16,8 +27,6 @@ extern void reactivate_fd(int fd, int irqnum);
 extern void deactivate_fd(int fd, int irqnum);
 extern int deactivate_all_fds(void);
 extern void forward_interrupts(int pid);
-extern void init_irq_signals(int on_sigstack);
-extern void forward_ipi(int fd, int pid);
 extern int activate_ipi(int fd, int pid);
 extern unsigned long irq_lock(void);
 extern void irq_unlock(unsigned long flags);
diff --git a/arch/um/include/kern.h b/arch/um/include/kern.h
index 7d223beccbc0..4ce3fc650e57 100644
--- a/arch/um/include/kern.h
+++ b/arch/um/include/kern.h
@@ -29,7 +29,7 @@ extern int getuid(void);
 extern int getgid(void);
 extern int pause(void);
 extern int write(int, const void *, int);
-extern int exit(int);
+extern void exit(int);
 extern int close(int);
 extern int read(unsigned int, char *, int);
 extern int pipe(int *);
diff --git a/arch/um/include/misc_constants.h b/arch/um/include/misc_constants.h
new file mode 100644
index 000000000000..989bc08de36e
--- /dev/null
+++ b/arch/um/include/misc_constants.h
@@ -0,0 +1,6 @@
+#ifndef __MISC_CONSTANT_H_
+#define __MISC_CONSTANT_H_
+
+#include <user_constants.h>
+
+#endif
diff --git a/arch/um/include/os.h b/arch/um/include/os.h
index 2a1c64d8d0bf..d3d1bc6074ef 100644
--- a/arch/um/include/os.h
+++ b/arch/um/include/os.h
@@ -12,6 +12,7 @@
 #include "sysdep/ptrace.h"
 #include "kern_util.h"
 #include "skas/mm_id.h"
+#include "irq_user.h"
 
 #define OS_TYPE_FILE 1 
 #define OS_TYPE_DIR 2 
@@ -121,6 +122,7 @@ static inline struct openflags of_cloexec(struct openflags flags)
         return(flags); 
 }
   
+/* file.c */
 extern int os_stat_file(const char *file_name, struct uml_stat *buf);
 extern int os_stat_fd(const int fd, struct uml_stat *buf);
 extern int os_access(const char *file, int mode);
@@ -156,10 +158,20 @@ extern int os_connect_socket(char *name);
 extern int os_file_type(char *file);
 extern int os_file_mode(char *file, struct openflags *mode_out);
 extern int os_lock_file(int fd, int excl);
+extern void os_flush_stdout(void);
+extern int os_stat_filesystem(char *path, long *bsize_out,
+                              long long *blocks_out, long long *bfree_out,
+                              long long *bavail_out, long long *files_out,
+                              long long *ffree_out, void *fsid_out,
+                              int fsid_size, long *namelen_out,
+                              long *spare_out);
+extern int os_change_dir(char *dir);
+extern int os_fchange_dir(int fd);
 
 /* start_up.c */
 extern void os_early_checks(void);
 extern int can_do_skas(void);
+extern void os_check_bugs(void);
 
 /* Make sure they are clear when running in TT mode. Required by
  * SEGV_MAYBE_FIXABLE */
@@ -198,6 +210,8 @@ extern void os_flush_stdout(void);
 /* tt.c
  * for tt mode only (will be deleted in future...)
  */
+extern void forward_ipi(int fd, int pid);
+extern void kill_child_dead(int pid);
 extern void stop(void);
 extern int wait_for_stop(int pid, int sig, int cont_type, void *relay);
 extern int protect_memory(unsigned long addr, unsigned long len,
@@ -294,4 +308,26 @@ extern void initial_thread_cb_skas(void (*proc)(void *),
 extern void halt_skas(void);
 extern void reboot_skas(void);
 
+/* irq.c */
+extern int os_waiting_for_events(struct irq_fd *active_fds);
+extern int os_isatty(int fd);
+extern int os_create_pollfd(int fd, int events, void *tmp_pfd, int size_tmpfds);
+extern void os_free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg,
+                struct irq_fd *active_fds, struct irq_fd ***last_irq_ptr2);
+extern void os_free_irq_later(struct irq_fd *active_fds,
+                int irq, void *dev_id);
+extern int os_get_pollfd(int i);
+extern void os_set_pollfd(int i, int fd);
+extern void os_set_ioignore(void);
+extern void init_irq_signals(int on_sigstack);
+
+/* sigio.c */
+extern void write_sigio_workaround(void);
+extern int add_sigio_fd(int fd, int read);
+extern int ignore_sigio_fd(int fd);
+
+/* skas/trap */
+extern void sig_handler_common_skas(int sig, void *sc_ptr);
+extern void user_signal(int sig, union uml_pt_regs *regs, int pid);
+
 #endif
diff --git a/arch/um/include/sigio.h b/arch/um/include/sigio.h
index 37d76e29a147..fe99ea163c2e 100644
--- a/arch/um/include/sigio.h
+++ b/arch/um/include/sigio.h
@@ -8,9 +8,6 @@
 
 extern int write_sigio_irq(int fd);
 extern int register_sigio_fd(int fd);
-extern int read_sigio_fd(int fd);
-extern int add_sigio_fd(int fd, int read);
-extern int ignore_sigio_fd(int fd);
 extern void sigio_lock(void);
 extern void sigio_unlock(void);
 
diff --git a/arch/um/include/skas/mode-skas.h b/arch/um/include/skas/mode-skas.h
index 260065cfeef1..8bc6916bbbb1 100644
--- a/arch/um/include/skas/mode-skas.h
+++ b/arch/um/include/skas/mode-skas.h
@@ -13,7 +13,6 @@ extern unsigned long exec_fp_regs[];
 extern unsigned long exec_fpx_regs[];
 extern int have_fpx_regs;
 
-extern void sig_handler_common_skas(int sig, void *sc_ptr);
 extern void kill_off_processes_skas(void);
 
 #endif
diff --git a/arch/um/include/skas/skas.h b/arch/um/include/skas/skas.h
index 86357282d681..853b26f148c5 100644
--- a/arch/um/include/skas/skas.h
+++ b/arch/um/include/skas/skas.h
@@ -17,7 +17,6 @@ extern int user_thread(unsigned long stack, int flags);
 extern void new_thread_proc(void *stack, void (*handler)(int sig));
 extern void new_thread_handler(int sig);
 extern void handle_syscall(union uml_pt_regs *regs);
-extern void user_signal(int sig, union uml_pt_regs *regs, int pid);
 extern int new_mm(unsigned long stack);
 extern void get_skas_faultinfo(int pid, struct faultinfo * fi);
 extern long execute_syscall_skas(void *r);
diff --git a/arch/um/include/user_util.h b/arch/um/include/user_util.h
index a6f1f176cf84..992a7e1e0fca 100644
--- a/arch/um/include/user_util.h
+++ b/arch/um/include/user_util.h
@@ -58,7 +58,6 @@ extern int attach(int pid);
 extern void kill_child_dead(int pid);
 extern int cont(int pid);
 extern void check_sigio(void);
-extern void write_sigio_workaround(void);
 extern void arch_check_bugs(void);
 extern int cpu_feature(char *what, char *buf, int len);
 extern int arch_handle_signal(int sig, union uml_pt_regs *regs);
diff --git a/arch/um/kernel/Makefile b/arch/um/kernel/Makefile
index 693018ba80f1..fe08971b64cf 100644
--- a/arch/um/kernel/Makefile
+++ b/arch/um/kernel/Makefile
@@ -7,23 +7,20 @@ extra-y := vmlinux.lds
 clean-files :=
 
 obj-y = config.o exec_kern.o exitcode.o \
-        init_task.o irq.o irq_user.o ksyms.o mem.o physmem.o \
-        process_kern.o ptrace.o reboot.o resource.o sigio_user.o sigio_kern.o \
+        init_task.o irq.o ksyms.o mem.o physmem.o \
+        process_kern.o ptrace.o reboot.o resource.o sigio_kern.o \
         signal_kern.o smp.o syscall_kern.o sysrq.o \
         time_kern.o tlb.o trap_kern.o uaccess.o um_arch.o umid.o
 
 obj-$(CONFIG_BLK_DEV_INITRD) += initrd.o
 obj-$(CONFIG_GPROF)     += gprof_syms.o
 obj-$(CONFIG_GCOV)      += gmon_syms.o
-obj-$(CONFIG_TTY_LOG)   += tty_log.o
 obj-$(CONFIG_SYSCALL_DEBUG) += syscall.o
 
 obj-$(CONFIG_MODE_TT) += tt/
 obj-$(CONFIG_MODE_SKAS) += skas/
 
-user-objs-$(CONFIG_TTY_LOG) += tty_log.o
-
-USER_OBJS := $(user-objs-y) config.o tty_log.o
+USER_OBJS := config.o
 
 include arch/um/scripts/Makefile.rules
 
diff --git a/arch/um/kernel/exec_kern.c b/arch/um/kernel/exec_kern.c
index c264e1c05ab3..1ca84319317d 100644
--- a/arch/um/kernel/exec_kern.c
+++ b/arch/um/kernel/exec_kern.c
@@ -30,8 +30,6 @@ void start_thread(struct pt_regs *regs, unsigned long eip, unsigned long esp)
         CHOOSE_MODE_PROC(start_thread_tt, start_thread_skas, regs, eip, esp);
 }
 
-extern void log_exec(char **argv, void *tty);
-
 static long execve1(char *file, char __user * __user *argv,
                     char __user *__user *env)
 {
diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
index bbf94bf2921e..c39ea3abeda4 100644
--- a/arch/um/kernel/irq.c
+++ b/arch/um/kernel/irq.c
@@ -31,6 +31,8 @@
 #include "irq_user.h"
 #include "irq_kern.h"
 #include "os.h"
+#include "sigio.h"
+#include "misc_constants.h"
 
 /*
  * Generic, controller-independent functions:
@@ -77,6 +79,298 @@ skip:
         return 0;
 }
 
+struct irq_fd *active_fds = NULL;
+static struct irq_fd **last_irq_ptr = &active_fds;
+
+extern void free_irqs(void);
+
+void sigio_handler(int sig, union uml_pt_regs *regs)
+{
+        struct irq_fd *irq_fd;
+        int n;
+
+        if(smp_sigio_handler()) return;
+        while(1){
+                n = os_waiting_for_events(active_fds);
+                if (n <= 0) {
+                        if(n == -EINTR) continue;
+                        else break;
+                }
+
+                for(irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next){
+                        if(irq_fd->current_events != 0){
+                                irq_fd->current_events = 0;
+                                do_IRQ(irq_fd->irq, regs);
+                        }
+                }
+        }
+
+        free_irqs();
+}
+
+static void maybe_sigio_broken(int fd, int type)
+{
+        if(os_isatty(fd)){
+                if((type == IRQ_WRITE) && !pty_output_sigio){
+                        write_sigio_workaround();
+                        add_sigio_fd(fd, 0);
+                }
+                else if((type == IRQ_READ) && !pty_close_sigio){
+                        write_sigio_workaround();
+                        add_sigio_fd(fd, 1);
+                }
+        }
+}
+
+
+int activate_fd(int irq, int fd, int type, void *dev_id)
+{
+        struct pollfd *tmp_pfd;
+        struct irq_fd *new_fd, *irq_fd;
+        unsigned long flags;
+        int pid, events, err, n;
+
+        pid = os_getpid();
+        err = os_set_fd_async(fd, pid);
+        if(err < 0)
+                goto out;
+
+        new_fd = um_kmalloc(sizeof(*new_fd));
+        err = -ENOMEM;
+        if(new_fd == NULL)
+                goto out;
+
+        if(type == IRQ_READ) events = UM_POLLIN | UM_POLLPRI;
+        else events = UM_POLLOUT;
+        *new_fd = ((struct irq_fd) { .next              = NULL,
+                                     .id                = dev_id,
+                                     .fd                = fd,
+                                     .type              = type,
+                                     .irq               = irq,
+                                     .pid               = pid,
+                                     .events            = events,
+                                     .current_events    = 0 } );
+
+        /* Critical section - locked by a spinlock because this stuff can
+         * be changed from interrupt handlers.  The stuff above is done
+         * outside the lock because it allocates memory.
+         */
+
+        /* Actually, it only looks like it can be called from interrupt
+         * context.  The culprit is reactivate_fd, which calls
+         * maybe_sigio_broken, which calls write_sigio_workaround,
+         * which calls activate_fd.  However, write_sigio_workaround should
+         * only be called once, at boot time.  That would make it clear that
+         * this is called only from process context, and can be locked with
+         * a semaphore.
+         */
+        flags = irq_lock();
+        for(irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next){
+                if((irq_fd->fd == fd) && (irq_fd->type == type)){
+                        printk("Registering fd %d twice\n", fd);
+                        printk("Irqs : %d, %d\n", irq_fd->irq, irq);
+                        printk("Ids : 0x%p, 0x%p\n", irq_fd->id, dev_id);
+                        goto out_unlock;
+                }
+        }
+
+        /*-------------*/
+        if(type == IRQ_WRITE)
+                fd = -1;
+
+        tmp_pfd = NULL;
+        n = 0;
+
+        while(1){
+                n = os_create_pollfd(fd, events, tmp_pfd, n);
+                if (n == 0)
+                        break;
+
+                /* n > 0
+                 * It means we couldn't put new pollfd to current pollfds
+                 * and tmp_fds is NULL or too small for new pollfds array.
+                 * Needed size is equal to n as minimum.
+                 *
+                 * Here we have to drop the lock in order to call
+                 * kmalloc, which might sleep.
+                 * If something else came in and changed the pollfds array
+                 * so we will not be able to put new pollfd struct to pollfds
+                 * then we free the buffer tmp_fds and try again.
+                 */
+                irq_unlock(flags);
+                if (tmp_pfd != NULL) {
+                        kfree(tmp_pfd);
+                        tmp_pfd = NULL;
+                }
+
+                tmp_pfd = um_kmalloc(n);
+                if (tmp_pfd == NULL)
+                        goto out_kfree;
+
+                flags = irq_lock();
+        }
+        /*-------------*/
+
+        *last_irq_ptr = new_fd;
+        last_irq_ptr = &new_fd->next;
+
+        irq_unlock(flags);
+
+        /* This calls activate_fd, so it has to be outside the critical
+         * section.
+         */
+        maybe_sigio_broken(fd, type);
+
+        return(0);
+
+ out_unlock:
+        irq_unlock(flags);
+ out_kfree:
+        kfree(new_fd);
+ out:
+        return(err);
+}
+
+static void free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg)
+{
+        unsigned long flags;
+
+        flags = irq_lock();
+        os_free_irq_by_cb(test, arg, active_fds, &last_irq_ptr);
+        irq_unlock(flags);
+}
+
+struct irq_and_dev {
+        int irq;
+        void *dev;
+};
+
+static int same_irq_and_dev(struct irq_fd *irq, void *d)
+{
+        struct irq_and_dev *data = d;
+
+        return((irq->irq == data->irq) && (irq->id == data->dev));
+}
+
+void free_irq_by_irq_and_dev(unsigned int irq, void *dev)
+{
+        struct irq_and_dev data = ((struct irq_and_dev) { .irq  = irq,
+                                                          .dev  = dev });
+
+        free_irq_by_cb(same_irq_and_dev, &data);
+}
+
+static int same_fd(struct irq_fd *irq, void *fd)
+{
+        return(irq->fd == *((int *) fd));
+}
+
+void free_irq_by_fd(int fd)
+{
+        free_irq_by_cb(same_fd, &fd);
+}
+
+static struct irq_fd *find_irq_by_fd(int fd, int irqnum, int *index_out)
+{
+        struct irq_fd *irq;
+        int i = 0;
+        int fdi;
+
+        for(irq=active_fds; irq != NULL; irq = irq->next){
+                if((irq->fd == fd) && (irq->irq == irqnum)) break;
+                i++;
+        }
+        if(irq == NULL){
+                printk("find_irq_by_fd doesn't have descriptor %d\n", fd);
+                goto out;
+        }
+        fdi = os_get_pollfd(i);
+        if((fdi != -1) && (fdi != fd)){
+                printk("find_irq_by_fd - mismatch between active_fds and "
+                       "pollfds, fd %d vs %d, need %d\n", irq->fd,
+                       fdi, fd);
+                irq = NULL;
+                goto out;
+        }
+        *index_out = i;
+ out:
+        return(irq);
+}
+
+void reactivate_fd(int fd, int irqnum)
+{
+        struct irq_fd *irq;
+        unsigned long flags;
+        int i;
+
+        flags = irq_lock();
+        irq = find_irq_by_fd(fd, irqnum, &i);
+        if(irq == NULL){
+                irq_unlock(flags);
+                return;
+        }
+        os_set_pollfd(i, irq->fd);
+        irq_unlock(flags);
+
+        /* This calls activate_fd, so it has to be outside the critical
+         * section.
+         */
+        maybe_sigio_broken(fd, irq->type);
+}
+
+void deactivate_fd(int fd, int irqnum)
+{
+        struct irq_fd *irq;
+        unsigned long flags;
+        int i;
+
+        flags = irq_lock();
+        irq = find_irq_by_fd(fd, irqnum, &i);
+        if(irq == NULL)
+                goto out;
+        os_set_pollfd(i, -1);
+ out:
+        irq_unlock(flags);
+}
+
+int deactivate_all_fds(void)
+{
+        struct irq_fd *irq;
+        int err;
+
+        for(irq=active_fds;irq != NULL;irq = irq->next){
+                err = os_clear_fd_async(irq->fd);
+                if(err)
+                        return(err);
+        }
+        /* If there is a signal already queued, after unblocking ignore it */
+        os_set_ioignore();
+
+        return(0);
+}
+
+void forward_interrupts(int pid)
+{
+        struct irq_fd *irq;
+        unsigned long flags;
+        int err;
+
+        flags = irq_lock();
+        for(irq=active_fds;irq != NULL;irq = irq->next){
+                err = os_set_owner(irq->fd, pid);
+                if(err < 0){
+                        /* XXX Just remove the irq rather than
+                         * print out an infinite stream of these
+                         */
+                        printk("Failed to forward %d to pid %d, err = %d\n",
+                               irq->fd, pid, -err);
+                }
+
+                irq->pid = pid;
+        }
+        irq_unlock(flags);
+}
+
 /*
  * do_IRQ handles all normal device IRQ's (the special
  * SMP cross-CPU interrupts have their own specific
diff --git a/arch/um/kernel/irq_user.c b/arch/um/kernel/irq_user.c
deleted file mode 100644
index 0e32f5f4a887..000000000000
--- a/arch/um/kernel/irq_user.c
+++ /dev/null
@@ -1,412 +0,0 @@
-/* 
- * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <signal.h>
-#include <string.h>
-#include <sys/poll.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include "user_util.h"
-#include "kern_util.h"
-#include "user.h"
-#include "process.h"
-#include "sigio.h"
-#include "irq_user.h"
-#include "os.h"
-
-struct irq_fd {
-        struct irq_fd *next;
-        void *id;
-        int fd;
-        int type;
-        int irq;
-        int pid;
-        int events;
-        int current_events;
-};
-
-static struct irq_fd *active_fds = NULL;
-static struct irq_fd **last_irq_ptr = &active_fds;
-
-static struct pollfd *pollfds = NULL;
-static int pollfds_num = 0;
-static int pollfds_size = 0;
-
-extern int io_count, intr_count;
-
-extern void free_irqs(void);
-
-void sigio_handler(int sig, union uml_pt_regs *regs)
-{
-        struct irq_fd *irq_fd;
-        int i, n;
-
-        if(smp_sigio_handler()) return;
-        while(1){
-                n = poll(pollfds, pollfds_num, 0);
-                if(n < 0){
-                        if(errno == EINTR) continue;
-                        printk("sigio_handler : poll returned %d, "
-                               "errno = %d\n", n, errno);
-                        break;
-                }
-                if(n == 0) break;
-
-                irq_fd = active_fds;
-                for(i = 0; i < pollfds_num; i++){
-                        if(pollfds[i].revents != 0){
-                                irq_fd->current_events = pollfds[i].revents;
-                                pollfds[i].fd = -1;
-                        }
-                        irq_fd = irq_fd->next;
-                }
-
-                for(irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next){
-                        if(irq_fd->current_events != 0){
-                                irq_fd->current_events = 0;
-                                do_IRQ(irq_fd->irq, regs);
-                        }
-                }
-        }
-
-        free_irqs();
-}
-
-int activate_ipi(int fd, int pid)
-{
-        return(os_set_fd_async(fd, pid));
-}
-
-static void maybe_sigio_broken(int fd, int type)
-{
-        if(isatty(fd)){
-                if((type == IRQ_WRITE) && !pty_output_sigio){
-                        write_sigio_workaround();
-                        add_sigio_fd(fd, 0);
-                }
-                else if((type == IRQ_READ) && !pty_close_sigio){
-                        write_sigio_workaround();
-                        add_sigio_fd(fd, 1);                    
-                }
-        }
-}
-
-int activate_fd(int irq, int fd, int type, void *dev_id)
-{
-        struct pollfd *tmp_pfd;
-        struct irq_fd *new_fd, *irq_fd;
-        unsigned long flags;
-        int pid, events, err, n, size;
-
-        pid = os_getpid();
-        err = os_set_fd_async(fd, pid);
-        if(err < 0)
-                goto out;
-
-        new_fd = um_kmalloc(sizeof(*new_fd));
-        err = -ENOMEM;
-        if(new_fd == NULL)
-                goto out;
-
-        if(type == IRQ_READ) events = POLLIN | POLLPRI;
-        else events = POLLOUT;
-        *new_fd = ((struct irq_fd) { .next              = NULL,
-                                     .id                = dev_id,
-                                     .fd                = fd,
-                                     .type              = type,
-                                     .irq               = irq,
-                                     .pid               = pid,
-                                     .events            = events,
-                                     .current_events    = 0 } );
-
-        /* Critical section - locked by a spinlock because this stuff can
-         * be changed from interrupt handlers.  The stuff above is done 
-         * outside the lock because it allocates memory.
-         */
-
-        /* Actually, it only looks like it can be called from interrupt
-         * context.  The culprit is reactivate_fd, which calls 
-         * maybe_sigio_broken, which calls write_sigio_workaround,
-         * which calls activate_fd.  However, write_sigio_workaround should
-         * only be called once, at boot time.  That would make it clear that
-         * this is called only from process context, and can be locked with
-         * a semaphore.
-         */
-        flags = irq_lock();
-        for(irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next){
-                if((irq_fd->fd == fd) && (irq_fd->type == type)){
-                        printk("Registering fd %d twice\n", fd);
-                        printk("Irqs : %d, %d\n", irq_fd->irq, irq);
-                        printk("Ids : 0x%x, 0x%x\n", irq_fd->id, dev_id);
-                        goto out_unlock;
-                }
-        }
-
-        n = pollfds_num;
-        if(n == pollfds_size){
-                while(1){
-                        /* Here we have to drop the lock in order to call 
-                         * kmalloc, which might sleep.  If something else
-                         * came in and changed the pollfds array, we free
-                         * the buffer and try again.
-                         */
-                        irq_unlock(flags);
-                        size = (pollfds_num + 1) * sizeof(pollfds[0]);
-                        tmp_pfd = um_kmalloc(size);
-                        flags = irq_lock();
-                        if(tmp_pfd == NULL)
-                                goto out_unlock;
-                        if(n == pollfds_size)
-                                break;
-                        kfree(tmp_pfd);
-                }
-                if(pollfds != NULL){
-                        memcpy(tmp_pfd, pollfds,
-                               sizeof(pollfds[0]) * pollfds_size);
-                        kfree(pollfds);
-                }
-                pollfds = tmp_pfd;
-                pollfds_size++;
-        }
-
-        if(type == IRQ_WRITE) 
-                fd = -1;
-
-        pollfds[pollfds_num] = ((struct pollfd) { .fd   = fd,
-                                                  .events       = events,
-                                                  .revents      = 0 });
-        pollfds_num++;
-
-        *last_irq_ptr = new_fd;
-        last_irq_ptr = &new_fd->next;
-
-        irq_unlock(flags);
-
-        /* This calls activate_fd, so it has to be outside the critical
-         * section.
-         */
-        maybe_sigio_broken(fd, type);
-
-        return(0);
-
- out_unlock:
-        irq_unlock(flags);
-        kfree(new_fd);
- out:
-        return(err);
-}
-
-static void free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg)
-{
-        struct irq_fd **prev;
-        unsigned long flags;
-        int i = 0;
-
-        flags = irq_lock();
-        prev = &active_fds;
-        while(*prev != NULL){
-                if((*test)(*prev, arg)){
-                        struct irq_fd *old_fd = *prev;
-                        if((pollfds[i].fd != -1) && 
-                           (pollfds[i].fd != (*prev)->fd)){
-                                printk("free_irq_by_cb - mismatch between "
-                                       "active_fds and pollfds, fd %d vs %d\n",
-                                       (*prev)->fd, pollfds[i].fd);
-                                goto out;
-                        }
-
-                        pollfds_num--;
-
-                        /* This moves the *whole* array after pollfds[i] (though
-                         * it doesn't spot as such)! */
-
-                        memmove(&pollfds[i], &pollfds[i + 1],
-                               (pollfds_num - i) * sizeof(pollfds[0]));
-
-                        if(last_irq_ptr == &old_fd->next) 
-                                last_irq_ptr = prev;
-                        *prev = (*prev)->next;
-                        if(old_fd->type == IRQ_WRITE) 
-                                ignore_sigio_fd(old_fd->fd);
-                        kfree(old_fd);
-                        continue;
-                }
-                prev = &(*prev)->next;
-                i++;
-        }
- out:
-        irq_unlock(flags);
-}
-
-struct irq_and_dev {
-        int irq;
-        void *dev;
-};
-
-static int same_irq_and_dev(struct irq_fd *irq, void *d)
-{
-        struct irq_and_dev *data = d;
-
-        return((irq->irq == data->irq) && (irq->id == data->dev));
-}
-
-void free_irq_by_irq_and_dev(unsigned int irq, void *dev)
-{
-        struct irq_and_dev data = ((struct irq_and_dev) { .irq  = irq,
-                                                          .dev  = dev });
-
-        free_irq_by_cb(same_irq_and_dev, &data);
-}
-
-static int same_fd(struct irq_fd *irq, void *fd)
-{
-        return(irq->fd == *((int *) fd));
-}
-
-void free_irq_by_fd(int fd)
-{
-        free_irq_by_cb(same_fd, &fd);
-}
-
-static struct irq_fd *find_irq_by_fd(int fd, int irqnum, int *index_out)
-{
-        struct irq_fd *irq;
-        int i = 0;
-
-        for(irq=active_fds; irq != NULL; irq = irq->next){
-                if((irq->fd == fd) && (irq->irq == irqnum)) break;
-                i++;
-        }
-        if(irq == NULL){
-                printk("find_irq_by_fd doesn't have descriptor %d\n", fd);
-                goto out;
-        }
-        if((pollfds[i].fd != -1) && (pollfds[i].fd != fd)){
-                printk("find_irq_by_fd - mismatch between active_fds and "
-                       "pollfds, fd %d vs %d, need %d\n", irq->fd, 
-                       pollfds[i].fd, fd);
-                irq = NULL;
-                goto out;
-        }
-        *index_out = i;
- out:
-        return(irq);
-}
-
-void reactivate_fd(int fd, int irqnum)
-{
-        struct irq_fd *irq;
-        unsigned long flags;
-        int i;
-
-        flags = irq_lock();
-        irq = find_irq_by_fd(fd, irqnum, &i);
-        if(irq == NULL){
-                irq_unlock(flags);
-                return;
-        }
-
-        pollfds[i].fd = irq->fd;
-
-        irq_unlock(flags);
-
-        /* This calls activate_fd, so it has to be outside the critical
-         * section.
-         */
-        maybe_sigio_broken(fd, irq->type);
-}
-
-void deactivate_fd(int fd, int irqnum)
-{
-        struct irq_fd *irq;
-        unsigned long flags;
-        int i;
-
-        flags = irq_lock();
-        irq = find_irq_by_fd(fd, irqnum, &i);
-        if(irq == NULL)
-                goto out;
-        pollfds[i].fd = -1;
- out:
-        irq_unlock(flags);
-}
-
-int deactivate_all_fds(void)
-{
-        struct irq_fd *irq;
-        int err;
-
-        for(irq=active_fds;irq != NULL;irq = irq->next){
-                err = os_clear_fd_async(irq->fd);
-                if(err)
-                        return(err);
-        }
-        /* If there is a signal already queued, after unblocking ignore it */
-        set_handler(SIGIO, SIG_IGN, 0, -1);
-
-        return(0);
-}
-
-void forward_ipi(int fd, int pid)
-{
-        int err;
-
-        err = os_set_owner(fd, pid);
-        if(err < 0)
-                printk("forward_ipi: set_owner failed, fd = %d, me = %d, "
-                       "target = %d, err = %d\n", fd, os_getpid(), pid, -err);
-}
-
-void forward_interrupts(int pid)
-{
-        struct irq_fd *irq;
-        unsigned long flags;
-        int err;
-
-        flags = irq_lock();
-        for(irq=active_fds;irq != NULL;irq = irq->next){
-                err = os_set_owner(irq->fd, pid);
-                if(err < 0){
-                        /* XXX Just remove the irq rather than
-                         * print out an infinite stream of these
-                         */
-                        printk("Failed to forward %d to pid %d, err = %d\n",
-                               irq->fd, pid, -err);
-                }
-
-                irq->pid = pid;
-        }
-        irq_unlock(flags);
-}
-
-void init_irq_signals(int on_sigstack)
-{
-        __sighandler_t h;
-        int flags;
-
-        flags = on_sigstack ? SA_ONSTACK : 0;
-        if(timer_irq_inited) h = (__sighandler_t) alarm_handler;
-        else h = boot_timer_handler;
-
-        set_handler(SIGVTALRM, h, flags | SA_RESTART, 
-                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, -1);
-        set_handler(SIGIO, (__sighandler_t) sig_handler, flags | SA_RESTART,
-                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
-        signal(SIGWINCH, SIG_IGN);
-}
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
index 0e65340eee33..0500800df1c1 100644
--- a/arch/um/kernel/physmem.c
+++ b/arch/um/kernel/physmem.c
@@ -9,6 +9,7 @@
 #include "linux/vmalloc.h"
 #include "linux/bootmem.h"
 #include "linux/module.h"
+#include "linux/pfn.h"
 #include "asm/types.h"
 #include "asm/pgtable.h"
 #include "kern_util.h"
@@ -316,8 +317,6 @@ void map_memory(unsigned long virt, unsigned long phys, unsigned long len,
         }
 }
 
-#define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-
 extern int __syscall_stub_start, __binary_start;
 
 void setup_physmem(unsigned long start, unsigned long reserve_end,
diff --git a/arch/um/kernel/sigio_kern.c b/arch/um/kernel/sigio_kern.c
index 229988463c4c..1c1300fb1e95 100644
--- a/arch/um/kernel/sigio_kern.c
+++ b/arch/um/kernel/sigio_kern.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
  * Licensed under the GPL
  */
@@ -12,13 +12,16 @@
 #include "sigio.h"
 #include "irq_user.h"
 #include "irq_kern.h"
+#include "os.h"
 
 /* Protected by sigio_lock() called from write_sigio_workaround */
 static int sigio_irq_fd = -1;
 
 static irqreturn_t sigio_interrupt(int irq, void *data, struct pt_regs *unused)
 {
-        read_sigio_fd(sigio_irq_fd);
+        char c;
+
+        os_read_file(sigio_irq_fd, &c, sizeof(c));
         reactivate_fd(sigio_irq_fd, SIGIO_WRITE_IRQ);
         return(IRQ_HANDLED);
 }
@@ -51,6 +54,9 @@ void sigio_unlock(void)
         spin_unlock(&sigio_spinlock);
 }
 
+extern void sigio_cleanup(void);
+__uml_exitcall(sigio_cleanup);
+
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically
diff --git a/arch/um/kernel/smp.c b/arch/um/kernel/smp.c
index 72113b0a96e7..c8d8d0ac1a7f 100644
--- a/arch/um/kernel/smp.c
+++ b/arch/um/kernel/smp.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
  * Licensed under the GPL
  */
@@ -77,9 +77,9 @@ static int idle_proc(void *cpup)
         if(err < 0)
                 panic("CPU#%d failed to create IPI pipe, err = %d", cpu, -err);
 
-        activate_ipi(cpu_data[cpu].ipi_pipe[0], 
+        os_set_fd_async(cpu_data[cpu].ipi_pipe[0],
                      current->thread.mode.tt.extern_pid);
- 
+
         wmb();
         if (cpu_test_and_set(cpu, cpu_callin_map)) {
                 printk("huh, CPU#%d already present??\n", cpu);
@@ -106,7 +106,7 @@ static struct task_struct *idle_thread(int cpu)
                 panic("copy_process failed in idle_thread, error = %ld",
                       PTR_ERR(new_task));
 
-        cpu_tasks[cpu] = ((struct cpu_task) 
+        cpu_tasks[cpu] = ((struct cpu_task)
                           { .pid =      new_task->thread.mode.tt.extern_pid,
                             .task =     new_task } );
         idle_threads[cpu] = new_task;
@@ -134,12 +134,12 @@ void smp_prepare_cpus(unsigned int maxcpus)
         if(err < 0)
                 panic("CPU#0 failed to create IPI pipe, errno = %d", -err);
 
-        activate_ipi(cpu_data[me].ipi_pipe[0],
+        os_set_fd_async(cpu_data[me].ipi_pipe[0],
                      current->thread.mode.tt.extern_pid);
 
         for(cpu = 1; cpu < ncpus; cpu++){
                 printk("Booting processor %d...\n", cpu);
-                
+
                 idle = idle_thread(cpu);
 
                 init_idle(idle, cpu);
@@ -223,7 +223,7 @@ void smp_call_function_slave(int cpu)
         atomic_inc(&scf_finished);
 }
 
-int smp_call_function(void (*_func)(void *info), void *_info, int nonatomic, 
+int smp_call_function(void (*_func)(void *info), void *_info, int nonatomic,
                       int wait)
 {
         int cpus = num_online_cpus() - 1;
diff --git a/arch/um/kernel/um_arch.c b/arch/um/kernel/um_arch.c
index 80c9c18aae94..7d51dd7201c3 100644
--- a/arch/um/kernel/um_arch.c
+++ b/arch/um/kernel/um_arch.c
@@ -421,7 +421,7 @@ int linux_main(int argc, char **argv)
 #ifndef CONFIG_HIGHMEM
                 highmem = 0;
                 printf("CONFIG_HIGHMEM not enabled - physical memory shrunk "
-                       "to %lu bytes\n", physmem_size);
+                       "to %Lu bytes\n", physmem_size);
 #endif
         }
 
@@ -433,8 +433,8 @@ int linux_main(int argc, char **argv)
 
         setup_physmem(uml_physmem, uml_reserved, physmem_size, highmem);
         if(init_maps(physmem_size, iomem_size, highmem)){
-                printf("Failed to allocate mem_map for %lu bytes of physical "
-                       "memory and %lu bytes of highmem\n", physmem_size,
+                printf("Failed to allocate mem_map for %Lu bytes of physical "
+                       "memory and %Lu bytes of highmem\n", physmem_size,
                        highmem);
                 exit(1);
         }
@@ -477,7 +477,8 @@ static struct notifier_block panic_exit_notifier = {
 
 void __init setup_arch(char **cmdline_p)
 {
-        notifier_chain_register(&panic_notifier_list, &panic_exit_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &panic_exit_notifier);
         paging_init();
         strlcpy(saved_command_line, command_line, COMMAND_LINE_SIZE);
         *cmdline_p = command_line;
@@ -487,8 +488,7 @@ void __init setup_arch(char **cmdline_p)
 void __init check_bugs(void)
 {
         arch_check_bugs();
-        check_sigio();
-        check_devanon();
+        os_check_bugs();
 }
 
 void apply_alternatives(struct alt_instr *start, struct alt_instr *end)
diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
index 08a4e628b24c..1659386b42bb 100644
--- a/arch/um/os-Linux/Makefile
+++ b/arch/um/os-Linux/Makefile
@@ -3,14 +3,17 @@
 # Licensed under the GPL
 #
 
-obj-y = aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
-        start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o user_syms.o \
-        util.o drivers/ sys-$(SUBARCH)/
+obj-y = aio.o elf_aux.o file.o helper.o irq.o main.o mem.o process.o sigio.o \
+        signal.o start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o \
+        user_syms.o util.o drivers/ sys-$(SUBARCH)/
 
 obj-$(CONFIG_MODE_SKAS) += skas/
+obj-$(CONFIG_TTY_LOG) += tty_log.o
+user-objs-$(CONFIG_TTY_LOG) += tty_log.o
 
-USER_OBJS := aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
-        start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o util.o
+USER_OBJS := $(user-objs-y) aio.o elf_aux.o file.o helper.o irq.o main.o mem.o \
+        process.o sigio.o signal.o start_up.o time.o trap.o tt.o tty.o \
+        uaccess.o umid.o util.o
 
 elf_aux.o: $(ARCH_DIR)/kernel-offsets.h
 CFLAGS_elf_aux.o += -I$(objtree)/arch/um
diff --git a/arch/um/os-Linux/irq.c b/arch/um/os-Linux/irq.c
new file mode 100644
index 000000000000..e599be423da1
--- /dev/null
+++ b/arch/um/os-Linux/irq.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "process.h"
+#include "sigio.h"
+#include "irq_user.h"
+#include "os.h"
+
+static struct pollfd *pollfds = NULL;
+static int pollfds_num = 0;
+static int pollfds_size = 0;
+
+int os_waiting_for_events(struct irq_fd *active_fds)
+{
+        struct irq_fd *irq_fd;
+        int i, n, err;
+
+        n = poll(pollfds, pollfds_num, 0);
+        if(n < 0){
+                err = -errno;
+                if(errno != EINTR)
+                        printk("sigio_handler: os_waiting_for_events:"
+                               " poll returned %d, errno = %d\n", n, errno);
+                return err;
+        }
+
+        if(n == 0)
+                return 0;
+
+        irq_fd = active_fds;
+
+        for(i = 0; i < pollfds_num; i++){
+                if(pollfds[i].revents != 0){
+                        irq_fd->current_events = pollfds[i].revents;
+                        pollfds[i].fd = -1;
+                }
+                irq_fd = irq_fd->next;
+        }
+        return n;
+}
+
+int os_isatty(int fd)
+{
+        return(isatty(fd));
+}
+
+int os_create_pollfd(int fd, int events, void *tmp_pfd, int size_tmpfds)
+{
+        if (pollfds_num == pollfds_size) {
+                if (size_tmpfds <= pollfds_size * sizeof(pollfds[0])) {
+                        /* return min size needed for new pollfds area */
+                        return((pollfds_size + 1) * sizeof(pollfds[0]));
+                }
+
+                if(pollfds != NULL){
+                        memcpy(tmp_pfd, pollfds,
+                               sizeof(pollfds[0]) * pollfds_size);
+                        /* remove old pollfds */
+                        kfree(pollfds);
+                }
+                pollfds = tmp_pfd;
+                pollfds_size++;
+        } else {
+                /* remove not used tmp_pfd */
+                if (tmp_pfd != NULL)
+                        kfree(tmp_pfd);
+        }
+
+        pollfds[pollfds_num] = ((struct pollfd) { .fd   = fd,
+                                                  .events       = events,
+                                                  .revents      = 0 });
+        pollfds_num++;
+
+        return(0);
+}
+
+void os_free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg,
+                struct irq_fd *active_fds, struct irq_fd ***last_irq_ptr2)
+{
+        struct irq_fd **prev;
+        int i = 0;
+
+        prev = &active_fds;
+        while(*prev != NULL){
+                if((*test)(*prev, arg)){
+                        struct irq_fd *old_fd = *prev;
+                        if((pollfds[i].fd != -1) &&
+                           (pollfds[i].fd != (*prev)->fd)){
+                                printk("os_free_irq_by_cb - mismatch between "
+                                       "active_fds and pollfds, fd %d vs %d\n",
+                                       (*prev)->fd, pollfds[i].fd);
+                                goto out;
+                        }
+
+                        pollfds_num--;
+
+                        /* This moves the *whole* array after pollfds[i]
+                         * (though it doesn't spot as such)!
+                         */
+
+                        memmove(&pollfds[i], &pollfds[i + 1],
+                               (pollfds_num - i) * sizeof(pollfds[0]));
+                        if(*last_irq_ptr2 == &old_fd->next)
+                                *last_irq_ptr2 = prev;
+
+                        *prev = (*prev)->next;
+                        if(old_fd->type == IRQ_WRITE)
+                                ignore_sigio_fd(old_fd->fd);
+                        kfree(old_fd);
+                        continue;
+                }
+                prev = &(*prev)->next;
+                i++;
+        }
+ out:
+        return;
+}
+
+
+int os_get_pollfd(int i)
+{
+        return(pollfds[i].fd);
+}
+
+void os_set_pollfd(int i, int fd)
+{
+        pollfds[i].fd = fd;
+}
+
+void os_set_ioignore(void)
+{
+        set_handler(SIGIO, SIG_IGN, 0, -1);
+}
+
+void init_irq_signals(int on_sigstack)
+{
+        __sighandler_t h;
+        int flags;
+
+        flags = on_sigstack ? SA_ONSTACK : 0;
+        if(timer_irq_inited) h = (__sighandler_t) alarm_handler;
+        else h = boot_timer_handler;
+
+        set_handler(SIGVTALRM, h, flags | SA_RESTART,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, -1);
+        set_handler(SIGIO, (__sighandler_t) sig_handler, flags | SA_RESTART,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        signal(SIGWINCH, SIG_IGN);
+}
diff --git a/arch/um/kernel/sigio_user.c b/arch/um/os-Linux/sigio.c
index f7b18e157d35..9ba942947146 100644
--- a/arch/um/kernel/sigio_user.c
+++ b/arch/um/os-Linux/sigio.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -20,128 +20,7 @@
 #include "sigio.h"
 #include "os.h"
 
-/* Changed during early boot */
-int pty_output_sigio = 0;
-int pty_close_sigio = 0;
-
-/* Used as a flag during SIGIO testing early in boot */
-static volatile int got_sigio = 0;
-
-void __init handler(int sig)
-{
-        got_sigio = 1;
-}
-
-struct openpty_arg {
-        int master;
-        int slave;
-        int err;
-};
-
-static void openpty_cb(void *arg)
-{
-        struct openpty_arg *info = arg;
-
-        info->err = 0;
-        if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
-                info->err = -errno;
-}
-
-void __init check_one_sigio(void (*proc)(int, int))
-{
-        struct sigaction old, new;
-        struct openpty_arg pty = { .master = -1, .slave = -1 };
-        int master, slave, err;
-
-        initial_thread_cb(openpty_cb, &pty);
-        if(pty.err){
-                printk("openpty failed, errno = %d\n", -pty.err);
-                return;
-        }
-
-        master = pty.master;
-        slave = pty.slave;
-
-        if((master == -1) || (slave == -1)){
-                printk("openpty failed to allocate a pty\n");
-                return;
-        }
-
-        /* Not now, but complain so we now where we failed. */
-        err = raw(master);
-        if (err < 0)
-                panic("check_sigio : __raw failed, errno = %d\n", -err);
-
-        err = os_sigio_async(master, slave);
-        if(err < 0)
-                panic("tty_fds : sigio_async failed, err = %d\n", -err);
-
-        if(sigaction(SIGIO, NULL, &old) < 0)
-                panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
-        new = old;
-        new.sa_handler = handler;
-        if(sigaction(SIGIO, &new, NULL) < 0)
-                panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
-
-        got_sigio = 0;
-        (*proc)(master, slave);
-                
-        os_close_file(master);
-        os_close_file(slave);
-
-        if(sigaction(SIGIO, &old, NULL) < 0)
-                panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
-}
-
-static void tty_output(int master, int slave)
-{
-        int n;
-        char buf[512];
-
-        printk("Checking that host ptys support output SIGIO...");
-
-        memset(buf, 0, sizeof(buf));
-
-        while(os_write_file(master, buf, sizeof(buf)) > 0) ;
-        if(errno != EAGAIN)
-                panic("check_sigio : write failed, errno = %d\n", errno);
-        while(((n = os_read_file(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
-
-        if (got_sigio) {
-                printk("Yes\n");
-                pty_output_sigio = 1;
-        } else if (n == -EAGAIN) {
-                printk("No, enabling workaround\n");
-        } else {
-                panic("check_sigio : read failed, err = %d\n", n);
-        }
-}
-
-static void tty_close(int master, int slave)
-{
-        printk("Checking that host ptys support SIGIO on close...");
-
-        os_close_file(slave);
-        if(got_sigio){
-                printk("Yes\n");
-                pty_close_sigio = 1;
-        }
-        else printk("No, enabling workaround\n");
-}
-
-void __init check_sigio(void)
-{
-        if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
-           (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
-                printk("No pseudo-terminals available - skipping pty SIGIO "
-                       "check\n");
-                return;
-        }
-        check_one_sigio(tty_output);
-        check_one_sigio(tty_close);
-}
-
-/* Protected by sigio_lock(), also used by sigio_cleanup, which is an 
+/* Protected by sigio_lock(), also used by sigio_cleanup, which is an
  * exitcall.
  */
 static int write_sigio_pid = -1;
@@ -150,8 +29,10 @@ static int write_sigio_pid = -1;
  * the descriptors closed after it is killed.  So, it can't see them change.
  * On the UML side, they are changed under the sigio_lock.
  */
-static int write_sigio_fds[2] = { -1, -1 };
-static int sigio_private[2] = { -1, -1 };
+#define SIGIO_FDS_INIT {-1, -1}
+
+static int write_sigio_fds[2] = SIGIO_FDS_INIT;
+static int sigio_private[2] = SIGIO_FDS_INIT;
 
 struct pollfds {
         struct pollfd *poll;
@@ -264,13 +145,13 @@ static void update_thread(void)
         return;
  fail:
         /* Critical section start */
-        if(write_sigio_pid != -1) 
+        if(write_sigio_pid != -1)
                 os_kill_process(write_sigio_pid, 1);
         write_sigio_pid = -1;
-        os_close_file(sigio_private[0]);
-        os_close_file(sigio_private[1]);
-        os_close_file(write_sigio_fds[0]);
-        os_close_file(write_sigio_fds[1]);
+        close(sigio_private[0]);
+        close(sigio_private[1]);
+        close(write_sigio_fds[0]);
+        close(write_sigio_fds[1]);
         /* Critical section end */
         set_signals(flags);
 }
@@ -281,13 +162,13 @@ int add_sigio_fd(int fd, int read)
 
         sigio_lock();
         for(i = 0; i < current_poll.used; i++){
-                if(current_poll.poll[i].fd == fd) 
+                if(current_poll.poll[i].fd == fd)
                         goto out;
         }
 
         n = current_poll.used + 1;
         err = need_poll(n);
-        if(err) 
+        if(err)
                 goto out;
 
         for(i = 0; i < current_poll.used; i++)
@@ -316,7 +197,7 @@ int ignore_sigio_fd(int fd)
         }
         if(i == current_poll.used)
                 goto out;
-        
+
         err = need_poll(current_poll.used - 1);
         if(err)
                 goto out;
@@ -337,7 +218,7 @@ int ignore_sigio_fd(int fd)
         return(err);
 }
 
-static struct pollfd* setup_initial_poll(int fd)
+static struct pollfd *setup_initial_poll(int fd)
 {
         struct pollfd *p;
 
@@ -377,7 +258,7 @@ void write_sigio_workaround(void)
         }
         err = os_pipe(l_sigio_private, 1, 1);
         if(err < 0){
-                printk("write_sigio_workaround - os_pipe 1 failed, "
+                printk("write_sigio_workaround - os_pipe 2 failed, "
                        "err = %d\n", -err);
                 goto out_close1;
         }
@@ -391,76 +272,52 @@ void write_sigio_workaround(void)
         /* Did we race? Don't try to optimize this, please, it's not so likely
          * to happen, and no more than once at the boot. */
         if(write_sigio_pid != -1)
-                goto out_unlock;
+                goto out_free;
 
-        write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
-                                            CLONE_FILES | CLONE_VM, &stack, 0);
-
-        if (write_sigio_pid < 0)
-                goto out_clear;
+        current_poll = ((struct pollfds) { .poll        = p,
+                                           .used        = 1,
+                                           .size        = 1 });
 
         if (write_sigio_irq(l_write_sigio_fds[0]))
-                goto out_kill;
+                goto out_clear_poll;
 
-        /* Success, finally. */
         memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
         memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
 
-        current_poll = ((struct pollfds) { .poll        = p,
-                                           .used        = 1,
-                                           .size        = 1 });
+        write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
+                                            CLONE_FILES | CLONE_VM, &stack, 0);
 
-        sigio_unlock();
-        return;
+        if (write_sigio_pid < 0)
+                goto out_clear;
 
- out_kill:
-        l_write_sigio_pid = write_sigio_pid;
-        write_sigio_pid = -1;
         sigio_unlock();
-        /* Going to call waitpid, avoid holding the lock. */
-        os_kill_process(l_write_sigio_pid, 1);
-        goto out_free;
+        return;
 
- out_clear:
+out_clear:
         write_sigio_pid = -1;
- out_unlock:
-        sigio_unlock();
- out_free:
+        write_sigio_fds[0] = -1;
+        write_sigio_fds[1] = -1;
+        sigio_private[0] = -1;
+        sigio_private[1] = -1;
+out_clear_poll:
+        current_poll = ((struct pollfds) { .poll        = NULL,
+                                           .size        = 0,
+                                           .used        = 0 });
+out_free:
         kfree(p);
- out_close2:
-        os_close_file(l_sigio_private[0]);
-        os_close_file(l_sigio_private[1]);
- out_close1:
-        os_close_file(l_write_sigio_fds[0]);
-        os_close_file(l_write_sigio_fds[1]);
-        return;
-}
-
-int read_sigio_fd(int fd)
-{
-        int n;
-        char c;
-
-        n = os_read_file(fd, &c, sizeof(c));
-        if(n != sizeof(c)){
-                if(n < 0) {
-                        printk("read_sigio_fd - read failed, err = %d\n", -n);
-                        return(n);
-                }
-                else {
-                        printk("read_sigio_fd - short read, bytes = %d\n", n);
-                        return(-EIO);
-                }
-        }
-        return(n);
+        sigio_unlock();
+out_close2:
+        close(l_sigio_private[0]);
+        close(l_sigio_private[1]);
+out_close1:
+        close(l_write_sigio_fds[0]);
+        close(l_write_sigio_fds[1]);
 }
 
-static void sigio_cleanup(void)
+void sigio_cleanup(void)
 {
-        if (write_sigio_pid != -1) {
+        if(write_sigio_pid != -1){
                 os_kill_process(write_sigio_pid, 1);
                 write_sigio_pid = -1;
         }
 }
-
-__uml_exitcall(sigio_cleanup);
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index 829d6b0d8b02..32753131f8d8 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -3,6 +3,7 @@
  * Licensed under the GPL
  */
 
+#include <pty.h>
 #include <stdio.h>
 #include <stddef.h>
 #include <stdarg.h>
@@ -539,3 +540,130 @@ int __init parse_iomem(char *str, int *add)
         return(1);
 }
 
+
+/* Changed during early boot */
+int pty_output_sigio = 0;
+int pty_close_sigio = 0;
+
+/* Used as a flag during SIGIO testing early in boot */
+static volatile int got_sigio = 0;
+
+static void __init handler(int sig)
+{
+        got_sigio = 1;
+}
+
+struct openpty_arg {
+        int master;
+        int slave;
+        int err;
+};
+
+static void openpty_cb(void *arg)
+{
+        struct openpty_arg *info = arg;
+
+        info->err = 0;
+        if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
+                info->err = -errno;
+}
+
+static void __init check_one_sigio(void (*proc)(int, int))
+{
+        struct sigaction old, new;
+        struct openpty_arg pty = { .master = -1, .slave = -1 };
+        int master, slave, err;
+
+        initial_thread_cb(openpty_cb, &pty);
+        if(pty.err){
+                printk("openpty failed, errno = %d\n", -pty.err);
+                return;
+        }
+
+        master = pty.master;
+        slave = pty.slave;
+
+        if((master == -1) || (slave == -1)){
+                printk("openpty failed to allocate a pty\n");
+                return;
+        }
+
+        /* Not now, but complain so we now where we failed. */
+        err = raw(master);
+        if (err < 0)
+                panic("check_sigio : __raw failed, errno = %d\n", -err);
+
+        err = os_sigio_async(master, slave);
+        if(err < 0)
+                panic("tty_fds : sigio_async failed, err = %d\n", -err);
+
+        if(sigaction(SIGIO, NULL, &old) < 0)
+                panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
+        new = old;
+        new.sa_handler = handler;
+        if(sigaction(SIGIO, &new, NULL) < 0)
+                panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
+
+        got_sigio = 0;
+        (*proc)(master, slave);
+
+        close(master);
+        close(slave);
+
+        if(sigaction(SIGIO, &old, NULL) < 0)
+                panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
+}
+
+static void tty_output(int master, int slave)
+{
+        int n;
+        char buf[512];
+
+        printk("Checking that host ptys support output SIGIO...");
+
+        memset(buf, 0, sizeof(buf));
+
+        while(os_write_file(master, buf, sizeof(buf)) > 0) ;
+        if(errno != EAGAIN)
+                panic("check_sigio : write failed, errno = %d\n", errno);
+        while(((n = os_read_file(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
+
+        if(got_sigio){
+                printk("Yes\n");
+                pty_output_sigio = 1;
+        }
+        else if(n == -EAGAIN) printk("No, enabling workaround\n");
+        else panic("check_sigio : read failed, err = %d\n", n);
+}
+
+static void tty_close(int master, int slave)
+{
+        printk("Checking that host ptys support SIGIO on close...");
+
+        close(slave);
+        if(got_sigio){
+                printk("Yes\n");
+                pty_close_sigio = 1;
+        }
+        else printk("No, enabling workaround\n");
+}
+
+void __init check_sigio(void)
+{
+        if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
+           (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
+                printk("No pseudo-terminals available - skipping pty SIGIO "
+                       "check\n");
+                return;
+        }
+        check_one_sigio(tty_output);
+        check_one_sigio(tty_close);
+}
+
+void os_check_bugs(void)
+{
+        check_ptrace();
+        check_sigio();
+        check_devanon();
+}
+
diff --git a/arch/um/os-Linux/tt.c b/arch/um/os-Linux/tt.c
index 919d19f11537..5461a065bbb9 100644
--- a/arch/um/os-Linux/tt.c
+++ b/arch/um/os-Linux/tt.c
@@ -110,6 +110,16 @@ int wait_for_stop(int pid, int sig, int cont_type, void *relay)
         }
 }
 
+void forward_ipi(int fd, int pid)
+{
+        int err;
+
+        err = os_set_owner(fd, pid);
+        if(err < 0)
+                printk("forward_ipi: set_owner failed, fd = %d, me = %d, "
+                       "target = %d, err = %d\n", fd, os_getpid(), pid, -err);
+}
+
 /*
  *-------------------------
  * only for tt mode (will be deleted in future...)
diff --git a/arch/um/kernel/tty_log.c b/arch/um/os-Linux/tty_log.c
index 9ada656f68ce..c6ba56c1560f 100644
--- a/arch/um/kernel/tty_log.c
+++ b/arch/um/os-Linux/tty_log.c
@@ -1,5 +1,5 @@
-/* 
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) and 
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) and
  * geoffrey hing <ghing@net.ohio-state.edu>
  * Licensed under the GPL
  */
@@ -58,7 +58,7 @@ int open_tty_log(void *tty, void *current_tty)
                 return(tty_log_fd);
         }
 
-        sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec, 
+        sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec,
                 (unsigned int) tv.tv_usec);
 
         fd = os_open_file(buf, of_append(of_create(of_rdwr(OPENFLAGS()))),
@@ -216,15 +216,3 @@ __uml_setup("tty_log_fd=", set_tty_log_fd,
 "    tty data will be written.  Preconfigure the descriptor with something\n"
 "    like '10>tty_log tty_log_fd=10'.\n\n"
 );
-
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/os-Linux/umid.c b/arch/um/os-Linux/umid.c
index ecf107ae5ac8..198e59163288 100644
--- a/arch/um/os-Linux/umid.c
+++ b/arch/um/os-Linux/umid.c
@@ -143,8 +143,10 @@ static int not_dead_yet(char *dir)
                 goto out_close;
         }
 
-        if((kill(p, 0) == 0) || (errno != ESRCH))
+        if((kill(p, 0) == 0) || (errno != ESRCH)){
+                printk("umid \"%s\" is already in use by pid %d\n", umid, p);
                 return 1;
+        }
 
         err = actually_do_remove(dir);
         if(err)
@@ -234,33 +236,44 @@ int __init make_umid(void)
         err = mkdir(tmp, 0777);
         if(err < 0){
                 err = -errno;
-                if(errno != EEXIST)
+                if(err != -EEXIST)
                         goto err;
 
-                if(not_dead_yet(tmp) < 0)
+                /* 1   -> this umid is already in use
+                 * < 0 -> we couldn't remove the umid directory
+                 * In either case, we can't use this umid, so return -EEXIST.
+                 */
+                if(not_dead_yet(tmp) != 0)
                         goto err;
 
                 err = mkdir(tmp, 0777);
         }
-        if(err < 0){
-                printk("Failed to create '%s' - err = %d\n", umid, err);
-                goto err_rmdir;
+        if(err){
+                err = -errno;
+                printk("Failed to create '%s' - err = %d\n", umid, -errno);
+                goto err;
         }
 
         umid_setup = 1;
 
         create_pid_file();
 
-        return 0;
-
- err_rmdir:
-        rmdir(tmp);
+        err = 0;
  err:
         return err;
 }
 
 static int __init make_umid_init(void)
 {
+        if(!make_umid())
+                return 0;
+
+        /* If initializing with the given umid failed, then try again with
+         * a random one.
+         */
+        printk("Failed to initialize umid \"%s\", trying with a random umid\n",
+               umid);
+        *umid = '\0';
         make_umid();
 
         return 0;
diff --git a/arch/um/sys-i386/ptrace.c b/arch/um/sys-i386/ptrace.c
index e839ce65ad28..8032a105949a 100644
--- a/arch/um/sys-i386/ptrace.c
+++ b/arch/um/sys-i386/ptrace.c
@@ -6,6 +6,7 @@
 #include <linux/config.h>
 #include <linux/compiler.h>
 #include "linux/sched.h"
+#include "linux/mm.h"
 #include "asm/elf.h"
 #include "asm/ptrace.h"
 #include "asm/uaccess.h"
@@ -26,9 +27,17 @@ int is_syscall(unsigned long addr)
 
         n = copy_from_user(&instr, (void __user *) addr, sizeof(instr));
         if(n){
-                printk("is_syscall : failed to read instruction from 0x%lx\n",
-                       addr);
-                return(0);
+                /* access_process_vm() grants access to vsyscall and stub,
+                 * while copy_from_user doesn't. Maybe access_process_vm is
+                 * slow, but that doesn't matter, since it will be called only
+                 * in case of singlestepping, if copy_from_user failed.
+                 */
+                n = access_process_vm(current, addr, &instr, sizeof(instr), 0);
+                if(n != sizeof(instr)) {
+                        printk("is_syscall : failed to read instruction from "
+                               "0x%lx\n", addr);
+                        return(1);
+                }
         }
         /* int 0x80 or sysenter */
         return((instr == 0x80cd) || (instr == 0x340f));
diff --git a/arch/um/sys-i386/signal.c b/arch/um/sys-i386/signal.c
index 7cd1a82dc8c2..33a40f5ef0d2 100644
--- a/arch/um/sys-i386/signal.c
+++ b/arch/um/sys-i386/signal.c
@@ -58,7 +58,7 @@ static int copy_sc_from_user_skas(struct pt_regs *regs,
 }
 
 int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
-                         struct pt_regs *regs)
+                         struct pt_regs *regs, unsigned long sp)
 {
         struct sigcontext sc;
         unsigned long fpregs[HOST_FP_SIZE];
@@ -72,7 +72,7 @@ int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
         sc.edi = REGS_EDI(regs->regs.skas.regs);
         sc.esi = REGS_ESI(regs->regs.skas.regs);
         sc.ebp = REGS_EBP(regs->regs.skas.regs);
-        sc.esp = REGS_SP(regs->regs.skas.regs);
+        sc.esp = sp;
         sc.ebx = REGS_EBX(regs->regs.skas.regs);
         sc.edx = REGS_EDX(regs->regs.skas.regs);
         sc.ecx = REGS_ECX(regs->regs.skas.regs);
@@ -132,7 +132,7 @@ int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext *from,
 }
 
 int copy_sc_to_user_tt(struct sigcontext *to, struct _fpstate *fp,
-                       struct sigcontext *from, int fpsize)
+                       struct sigcontext *from, int fpsize, unsigned long sp)
 {
         struct _fpstate *to_fp, *from_fp;
         int err;
@@ -140,11 +140,18 @@ int copy_sc_to_user_tt(struct sigcontext *to, struct _fpstate *fp,
         to_fp = (fp ? fp : (struct _fpstate *) (to + 1));
         from_fp = from->fpstate;
         err = copy_to_user(to, from, sizeof(*to));
+
+        /* The SP in the sigcontext is the updated one for the signal
+         * delivery.  The sp passed in is the original, and this needs
+         * to be restored, so we stick it in separately.
+         */
+        err |= copy_to_user(&SC_SP(to), sp, sizeof(sp));
+
         if(from_fp != NULL){
                 err |= copy_to_user(&to->fpstate, &to_fp, sizeof(to->fpstate));
                 err |= copy_to_user(to_fp, from_fp, fpsize);
         }
-        return(err);
+        return err;
 }
 #endif
 
@@ -159,11 +166,11 @@ static int copy_sc_from_user(struct pt_regs *to, void __user *from)
 }
 
 static int copy_sc_to_user(struct sigcontext *to, struct _fpstate *fp,
-                           struct pt_regs *from)
+                           struct pt_regs *from, unsigned long sp)
 {
         return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs),
-                                              sizeof(*fp)),
-                           copy_sc_to_user_skas(to, fp, from)));
+                                              sizeof(*fp), sp),
+                           copy_sc_to_user_skas(to, fp, from, sp)));
 }
 
 static int copy_ucontext_to_user(struct ucontext *uc, struct _fpstate *fp,
@@ -174,7 +181,7 @@ static int copy_ucontext_to_user(struct ucontext *uc, struct _fpstate *fp,
         err |= put_user(current->sas_ss_sp, &uc->uc_stack.ss_sp);
         err |= put_user(sas_ss_flags(sp), &uc->uc_stack.ss_flags);
         err |= put_user(current->sas_ss_size, &uc->uc_stack.ss_size);
-        err |= copy_sc_to_user(&uc->uc_mcontext, fp, &current->thread.regs);
+        err |= copy_sc_to_user(&uc->uc_mcontext, fp, &current->thread.regs, sp);
         err |= copy_to_user(&uc->uc_sigmask, set, sizeof(*set));
         return(err);
 }
@@ -207,6 +214,7 @@ int setup_signal_stack_sc(unsigned long stack_top, int sig,
 {
         struct sigframe __user *frame;
         void *restorer;
+        unsigned long save_sp = PT_REGS_SP(regs);
         int err = 0;
 
         stack_top &= -8UL;
@@ -218,9 +226,19 @@ int setup_signal_stack_sc(unsigned long stack_top, int sig,
         if(ka->sa.sa_flags & SA_RESTORER)
                 restorer = ka->sa.sa_restorer;
 
+        /* Update SP now because the page fault handler refuses to extend
+         * the stack if the faulting address is too far below the current
+         * SP, which frame now certainly is.  If there's an error, the original
+         * value is restored on the way out.
+         * When writing the sigcontext to the stack, we have to write the
+         * original value, so that's passed to copy_sc_to_user, which does
+         * the right thing with it.
+         */
+        PT_REGS_SP(regs) = (unsigned long) frame;
+
         err |= __put_user(restorer, &frame->pretcode);
         err |= __put_user(sig, &frame->sig);
-        err |= copy_sc_to_user(&frame->sc, NULL, regs);
+        err |= copy_sc_to_user(&frame->sc, NULL, regs, save_sp);
         err |= __put_user(mask->sig[0], &frame->sc.oldmask);
         if (_NSIG_WORDS > 1)
                 err |= __copy_to_user(&frame->extramask, &mask->sig[1],
@@ -238,7 +256,7 @@ int setup_signal_stack_sc(unsigned long stack_top, int sig,
         err |= __put_user(0x80cd, (short __user *)(frame->retcode+6));
 
         if(err)
-                return(err);
+                goto err;
 
         PT_REGS_SP(regs) = (unsigned long) frame;
         PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
@@ -248,7 +266,11 @@ int setup_signal_stack_sc(unsigned long stack_top, int sig,
 
         if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
                 ptrace_notify(SIGTRAP);
-        return(0);
+        return 0;
+
+err:
+        PT_REGS_SP(regs) = save_sp;
+        return err;
 }
 
 int setup_signal_stack_si(unsigned long stack_top, int sig,
@@ -257,6 +279,7 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
 {
         struct rt_sigframe __user *frame;
         void *restorer;
+        unsigned long save_sp = PT_REGS_SP(regs);
         int err = 0;
 
         stack_top &= -8UL;
@@ -268,13 +291,16 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
         if(ka->sa.sa_flags & SA_RESTORER)
                 restorer = ka->sa.sa_restorer;
 
+        /* See comment above about why this is here */
+        PT_REGS_SP(regs) = (unsigned long) frame;
+
         err |= __put_user(restorer, &frame->pretcode);
         err |= __put_user(sig, &frame->sig);
         err |= __put_user(&frame->info, &frame->pinfo);
         err |= __put_user(&frame->uc, &frame->puc);
         err |= copy_siginfo_to_user(&frame->info, info);
         err |= copy_ucontext_to_user(&frame->uc, &frame->fpstate, mask,
-                                     PT_REGS_SP(regs));
+                                     save_sp);
 
         /*
          * This is movl $,%eax ; int $0x80
@@ -288,9 +314,8 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
         err |= __put_user(0x80cd, (short __user *)(frame->retcode+5));
 
         if(err)
-                return(err);
+                goto err;
 
-        PT_REGS_SP(regs) = (unsigned long) frame;
         PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
         PT_REGS_EAX(regs) = (unsigned long) sig;
         PT_REGS_EDX(regs) = (unsigned long) &frame->info;
@@ -298,7 +323,11 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
 
         if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
                 ptrace_notify(SIGTRAP);
-        return(0);
+        return 0;
+
+err:
+        PT_REGS_SP(regs) = save_sp;
+        return err;
 }
 
 long sys_sigreturn(struct pt_regs regs)
diff --git a/arch/um/sys-i386/user-offsets.c b/arch/um/sys-i386/user-offsets.c
index 26b68675053d..6f4ef2b7fa4a 100644
--- a/arch/um/sys-i386/user-offsets.c
+++ b/arch/um/sys-i386/user-offsets.c
@@ -3,12 +3,13 @@
 #include <asm/ptrace.h>
 #include <asm/user.h>
 #include <linux/stddef.h>
+#include <sys/poll.h>
 
 #define DEFINE(sym, val) \
-        asm volatile("\n->" #sym " %0 " #val : : "i" (val))
+        asm volatile("\n->" #sym " %0 " #val : : "i" (val))
 
 #define DEFINE_LONGS(sym, val) \
-        asm volatile("\n->" #sym " %0 " #val : : "i" (val/sizeof(unsigned long)))
+        asm volatile("\n->" #sym " %0 " #val : : "i" (val/sizeof(unsigned long)))
 
 #define OFFSET(sym, str, mem) \
         DEFINE(sym, offsetof(struct str, mem));
@@ -67,4 +68,9 @@ void foo(void)
         DEFINE(HOST_ES, ES);
         DEFINE(HOST_GS, GS);
         DEFINE(UM_FRAME_SIZE, sizeof(struct user_regs_struct));
+
+        /* XXX Duplicated between i386 and x86_64 */
+        DEFINE(UM_POLLIN, POLLIN);
+        DEFINE(UM_POLLPRI, POLLPRI);
+        DEFINE(UM_POLLOUT, POLLOUT);
 }
diff --git a/arch/um/sys-x86_64/ptrace.c b/arch/um/sys-x86_64/ptrace.c
index 74eee5c7c6dd..147bbf05cbc2 100644
--- a/arch/um/sys-x86_64/ptrace.c
+++ b/arch/um/sys-x86_64/ptrace.c
@@ -8,6 +8,7 @@
 #include <asm/ptrace.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
+#include <linux/mm.h>
 #include <asm/uaccess.h>
 #include <asm/elf.h>
 
@@ -136,9 +137,28 @@ void arch_switch(void)
 */
 }
 
+/* XXX Mostly copied from sys-i386 */
 int is_syscall(unsigned long addr)
 {
-        panic("is_syscall");
+        unsigned short instr;
+        int n;
+
+        n = copy_from_user(&instr, (void __user *) addr, sizeof(instr));
+        if(n){
+                /* access_process_vm() grants access to vsyscall and stub,
+                 * while copy_from_user doesn't. Maybe access_process_vm is
+                 * slow, but that doesn't matter, since it will be called only
+                 * in case of singlestepping, if copy_from_user failed.
+                 */
+                n = access_process_vm(current, addr, &instr, sizeof(instr), 0);
+                if(n != sizeof(instr)) {
+                        printk("is_syscall : failed to read instruction from "
+                               "0x%lx\n", addr);
+                        return(1);
+                }
+        }
+        /* sysenter */
+        return(instr == 0x050f);
 }
 
 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu )
diff --git a/arch/um/sys-x86_64/signal.c b/arch/um/sys-x86_64/signal.c
index fe1d065332b1..e75c4e1838b0 100644
--- a/arch/um/sys-x86_64/signal.c
+++ b/arch/um/sys-x86_64/signal.c
@@ -55,7 +55,8 @@ static int copy_sc_from_user_skas(struct pt_regs *regs,
 }
 
 int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
-                        struct pt_regs *regs, unsigned long mask)
+                         struct pt_regs *regs, unsigned long mask,
+                         unsigned long sp)
 {
         struct faultinfo * fi = &current->thread.arch.faultinfo;
         int err = 0;
@@ -70,7 +71,11 @@ int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
         err |= PUTREG(regs, RDI, to, rdi);
         err |= PUTREG(regs, RSI, to, rsi);
         err |= PUTREG(regs, RBP, to, rbp);
-        err |= PUTREG(regs, RSP, to, rsp);
+        /* Must use orignal RSP, which is passed in, rather than what's in
+         * the pt_regs, because that's already been updated to point at the
+         * signal frame.
+         */
+        err |= __put_user(sp, &to->rsp);
         err |= PUTREG(regs, RBX, to, rbx);
         err |= PUTREG(regs, RDX, to, rdx);
         err |= PUTREG(regs, RCX, to, rcx);
@@ -102,7 +107,7 @@ int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
 
 #ifdef CONFIG_MODE_TT
 int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext *from,
-                        int fpsize)
+                         int fpsize)
 {
         struct _fpstate *to_fp, *from_fp;
         unsigned long sigs;
@@ -120,7 +125,7 @@ int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext *from,
 }
 
 int copy_sc_to_user_tt(struct sigcontext *to, struct _fpstate *fp,
-                      struct sigcontext *from, int fpsize)
+                       struct sigcontext *from, int fpsize, unsigned long sp)
 {
         struct _fpstate *to_fp, *from_fp;
         int err;
@@ -128,11 +133,17 @@ int copy_sc_to_user_tt(struct sigcontext *to, struct _fpstate *fp,
         to_fp = (fp ? fp : (struct _fpstate *) (to + 1));
         from_fp = from->fpstate;
         err = copy_to_user(to, from, sizeof(*to));
+        /* The SP in the sigcontext is the updated one for the signal
+         * delivery.  The sp passed in is the original, and this needs
+         * to be restored, so we stick it in separately.
+         */
+        err |= copy_to_user(&SC_SP(to), sp, sizeof(sp));
+
         if(from_fp != NULL){
                 err |= copy_to_user(&to->fpstate, &to_fp, sizeof(to->fpstate));
                 err |= copy_to_user(to_fp, from_fp, fpsize);
         }
-        return(err);
+        return err;
 }
 
 #endif
@@ -148,11 +159,12 @@ static int copy_sc_from_user(struct pt_regs *to, void __user *from)
 }
 
 static int copy_sc_to_user(struct sigcontext *to, struct _fpstate *fp,
-                          struct pt_regs *from, unsigned long mask)
+                           struct pt_regs *from, unsigned long mask,
+                           unsigned long sp)
 {
        return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs),
-                                             sizeof(*fp)),
-                          copy_sc_to_user_skas(to, fp, from, mask)));
+                                             sizeof(*fp), sp),
+                          copy_sc_to_user_skas(to, fp, from, mask, sp)));
 }
 
 struct rt_sigframe
@@ -170,6 +182,7 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
 {
         struct rt_sigframe __user *frame;
         struct _fpstate __user *fp = NULL;
+        unsigned long save_sp = PT_REGS_RSP(regs);
         int err = 0;
         struct task_struct *me = current;
 
@@ -193,14 +206,25 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
                         goto out;
         }
 
+        /* Update SP now because the page fault handler refuses to extend
+         * the stack if the faulting address is too far below the current
+         * SP, which frame now certainly is.  If there's an error, the original
+         * value is restored on the way out.
+         * When writing the sigcontext to the stack, we have to write the
+         * original value, so that's passed to copy_sc_to_user, which does
+         * the right thing with it.
+         */
+        PT_REGS_RSP(regs) = (unsigned long) frame;
+
         /* Create the ucontext.  */
         err |= __put_user(0, &frame->uc.uc_flags);
         err |= __put_user(0, &frame->uc.uc_link);
         err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
-        err |= __put_user(sas_ss_flags(PT_REGS_SP(regs)),
+        err |= __put_user(sas_ss_flags(save_sp),
                           &frame->uc.uc_stack.ss_flags);
         err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
-        err |= copy_sc_to_user(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
+        err |= copy_sc_to_user(&frame->uc.uc_mcontext, fp, regs, set->sig[0],
+                save_sp);
         err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate);
         if (sizeof(*set) == 16) {
                 __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]);
@@ -217,10 +241,10 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
         else
                 /* could use a vstub here */
-                goto out;
+                goto restore_sp;
 
         if (err)
-                goto out;
+                goto restore_sp;
 
         /* Set up registers for signal handler */
         {
@@ -238,10 +262,12 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
         PT_REGS_RSI(regs) = (unsigned long) &frame->info;
         PT_REGS_RDX(regs) = (unsigned long) &frame->uc;
         PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler;
-
-        PT_REGS_RSP(regs) = (unsigned long) frame;
  out:
-        return(err);
+        return err;
+
+restore_sp:
+        PT_REGS_RSP(regs) = save_sp;
+        return err;
 }
 
 long sys_rt_sigreturn(struct pt_regs *regs)
diff --git a/arch/um/sys-x86_64/user-offsets.c b/arch/um/sys-x86_64/user-offsets.c
index 7bd54a921cf7..899cebb57c3f 100644
--- a/arch/um/sys-x86_64/user-offsets.c
+++ b/arch/um/sys-x86_64/user-offsets.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stddef.h>
 #include <signal.h>
+#include <sys/poll.h>
 #define __FRAME_OFFSETS
 #include <asm/ptrace.h>
 #include <asm/types.h>
@@ -88,4 +89,9 @@ void foo(void)
         DEFINE_LONGS(HOST_IP, RIP);
         DEFINE_LONGS(HOST_SP, RSP);
         DEFINE(UM_FRAME_SIZE, sizeof(struct user_regs_struct));
+
+        /* XXX Duplicated between i386 and x86_64 */
+        DEFINE(UM_POLLIN, POLLIN);
+        DEFINE(UM_POLLPRI, POLLPRI);
+        DEFINE(UM_POLLOUT, POLLOUT);
 }
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig
index 45efe0ca88f8..4310b4a311a5 100644
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -250,6 +250,15 @@ config SCHED_SMT
           cost of slightly increased overhead in some places. If unsure say
           N here.
 
+config SCHED_MC
+        bool "Multi-core scheduler support"
+        depends on SMP
+        default y
+        help
+          Multi-core scheduler support improves the CPU scheduler's decision
+          making when dealing with multi-core CPU chips at a cost of slightly
+          increased overhead in some places. If unsure say N here.
+
 source "kernel/Kconfig.preempt"
 
 config NUMA
@@ -325,6 +334,10 @@ config HAVE_ARCH_EARLY_PFN_TO_NID
         def_bool y
         depends on NUMA
 
+config OUT_OF_LINE_PFN_TO_PAGE
+        def_bool y
+        depends on DISCONTIGMEM
+
 config NR_CPUS
         int "Maximum number of CPUs (2-256)"
         range 2 255
diff --git a/arch/x86_64/ia32/ia32entry.S b/arch/x86_64/ia32/ia32entry.S
index 7549a4389fbf..35b2faccdc6c 100644
--- a/arch/x86_64/ia32/ia32entry.S
+++ b/arch/x86_64/ia32/ia32entry.S
@@ -688,6 +688,8 @@ ia32_sys_call_table:
         .quad sys_ni_syscall            /* pselect6 for now */
         .quad sys_ni_syscall            /* ppoll for now */
         .quad sys_unshare               /* 310 */
+        .quad compat_sys_set_robust_list
+        .quad compat_sys_get_robust_list
 ia32_syscall_end:               
         .rept IA32_NR_syscalls-(ia32_syscall_end-ia32_sys_call_table)/8
                 .quad ni_syscall
diff --git a/arch/x86_64/kernel/process.c b/arch/x86_64/kernel/process.c
index 0370720515f1..70dd8e5c6889 100644
--- a/arch/x86_64/kernel/process.c
+++ b/arch/x86_64/kernel/process.c
@@ -66,24 +66,17 @@ EXPORT_SYMBOL(boot_option_idle_override);
 void (*pm_idle)(void);
 static DEFINE_PER_CPU(unsigned int, cpu_idle_state);
 
-static struct notifier_block *idle_notifier;
-static DEFINE_SPINLOCK(idle_notifier_lock);
+static ATOMIC_NOTIFIER_HEAD(idle_notifier);
 
 void idle_notifier_register(struct notifier_block *n)
 {
-        unsigned long flags;
-        spin_lock_irqsave(&idle_notifier_lock, flags);
-        notifier_chain_register(&idle_notifier, n);
-        spin_unlock_irqrestore(&idle_notifier_lock, flags);
+        atomic_notifier_chain_register(&idle_notifier, n);
 }
 EXPORT_SYMBOL_GPL(idle_notifier_register);
 
 void idle_notifier_unregister(struct notifier_block *n)
 {
-        unsigned long flags;
-        spin_lock_irqsave(&idle_notifier_lock, flags);
-        notifier_chain_unregister(&idle_notifier, n);
-        spin_unlock_irqrestore(&idle_notifier_lock, flags);
+        atomic_notifier_chain_unregister(&idle_notifier, n);
 }
 EXPORT_SYMBOL(idle_notifier_unregister);
 
@@ -93,13 +86,13 @@ static DEFINE_PER_CPU(enum idle_state, idle_state) = CPU_NOT_IDLE;
 void enter_idle(void)
 {
         __get_cpu_var(idle_state) = CPU_IDLE;
-        notifier_call_chain(&idle_notifier, IDLE_START, NULL);
+        atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
 }
 
 static void __exit_idle(void)
 {
         __get_cpu_var(idle_state) = CPU_NOT_IDLE;
-        notifier_call_chain(&idle_notifier, IDLE_END, NULL);
+        atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
 }
 
 /* Called from interrupts to signify idle end */
diff --git a/arch/x86_64/kernel/setup.c b/arch/x86_64/kernel/setup.c
index a57eec8311a7..d1f3e9272c05 100644
--- a/arch/x86_64/kernel/setup.c
+++ b/arch/x86_64/kernel/setup.c
@@ -962,7 +962,6 @@ static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
 
         cpuid(1, &eax, &ebx, &ecx, &edx);
 
-        c->apicid = phys_pkg_id(0);
 
         if (!cpu_has(c, X86_FEATURE_HT) || cpu_has(c, X86_FEATURE_CMP_LEGACY))
                 return;
@@ -1171,6 +1170,8 @@ void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
                         c->x86_capability[2] = cpuid_edx(0x80860001);
         }
 
+        c->apicid = phys_pkg_id(0);
+
         /*
          * Vendor-specific initialization.  In this section we
          * canonicalize the feature flags, meaning if there are
diff --git a/arch/x86_64/kernel/smpboot.c b/arch/x86_64/kernel/smpboot.c
index 66e98659d077..ea48fa638070 100644
--- a/arch/x86_64/kernel/smpboot.c
+++ b/arch/x86_64/kernel/smpboot.c
@@ -68,6 +68,9 @@ u8 phys_proc_id[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
 /* core ID of each logical CPU */
 u8 cpu_core_id[NR_CPUS] __read_mostly = { [0 ... NR_CPUS-1] = BAD_APICID };
 
+/* Last level cache ID of each logical CPU */
+u8 cpu_llc_id[NR_CPUS] __cpuinitdata  = {[0 ... NR_CPUS-1] = BAD_APICID};
+
 /* Bitmask of currently online CPUs */
 cpumask_t cpu_online_map __read_mostly;
 
@@ -445,6 +448,18 @@ void __cpuinit smp_callin(void)
         cpu_set(cpuid, cpu_callin_map);
 }
 
+/* maps the cpu to the sched domain representing multi-core */
+cpumask_t cpu_coregroup_map(int cpu)
+{
+        struct cpuinfo_x86 *c = cpu_data + cpu;
+        /*
+         * For perf, we return last level cache shared map.
+         * TBD: when power saving sched policy is added, we will return
+         *      cpu_core_map when power saving policy is enabled
+         */
+        return c->llc_shared_map;
+}
+
 /* representing cpus for which sibling maps can be computed */
 static cpumask_t cpu_sibling_setup_map;
 
@@ -463,12 +478,16 @@ static inline void set_cpu_sibling_map(int cpu)
                                 cpu_set(cpu, cpu_sibling_map[i]);
                                 cpu_set(i, cpu_core_map[cpu]);
                                 cpu_set(cpu, cpu_core_map[i]);
+                                cpu_set(i, c[cpu].llc_shared_map);
+                                cpu_set(cpu, c[i].llc_shared_map);
                         }
                 }
         } else {
                 cpu_set(cpu, cpu_sibling_map[cpu]);
         }
 
+        cpu_set(cpu, c[cpu].llc_shared_map);
+
         if (current_cpu_data.x86_max_cores == 1) {
                 cpu_core_map[cpu] = cpu_sibling_map[cpu];
                 c[cpu].booted_cores = 1;
@@ -476,6 +495,11 @@ static inline void set_cpu_sibling_map(int cpu)
         }
 
         for_each_cpu_mask(i, cpu_sibling_setup_map) {
+                if (cpu_llc_id[cpu] != BAD_APICID &&
+                    cpu_llc_id[cpu] == cpu_llc_id[i]) {
+                        cpu_set(i, c[cpu].llc_shared_map);
+                        cpu_set(cpu, c[i].llc_shared_map);
+                }
                 if (phys_proc_id[cpu] == phys_proc_id[i]) {
                         cpu_set(i, cpu_core_map[cpu]);
                         cpu_set(cpu, cpu_core_map[i]);
diff --git a/arch/x86_64/kernel/traps.c b/arch/x86_64/kernel/traps.c
index 7b148309c529..edaa9fe654dc 100644
--- a/arch/x86_64/kernel/traps.c
+++ b/arch/x86_64/kernel/traps.c
@@ -69,20 +69,20 @@ asmlinkage void alignment_check(void);
 asmlinkage void machine_check(void);
 asmlinkage void spurious_interrupt_bug(void);
 
-struct notifier_block *die_chain;
-static DEFINE_SPINLOCK(die_notifier_lock);
+ATOMIC_NOTIFIER_HEAD(die_chain);
 
 int register_die_notifier(struct notifier_block *nb)
 {
-        int err = 0;
-        unsigned long flags;
-
         vmalloc_sync_all();
-        spin_lock_irqsave(&die_notifier_lock, flags);
-        err = notifier_chain_register(&die_chain, nb);
-        spin_unlock_irqrestore(&die_notifier_lock, flags);
-        return err;
+        return atomic_notifier_chain_register(&die_chain, nb);
+}
+EXPORT_SYMBOL(register_die_notifier);
+
+int unregister_die_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&die_chain, nb);
 }
+EXPORT_SYMBOL(unregister_die_notifier);
 
 static inline void conditional_sti(struct pt_regs *regs)
 {
diff --git a/arch/x86_64/mm/init.c b/arch/x86_64/mm/init.c
index b04415625442..e5f7f1c34462 100644
--- a/arch/x86_64/mm/init.c
+++ b/arch/x86_64/mm/init.c
@@ -72,7 +72,7 @@ void show_mem(void)
         show_free_areas();
         printk(KERN_INFO "Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
 
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                for (i = 0; i < pgdat->node_spanned_pages; ++i) {
                         page = pfn_to_page(pgdat->node_start_pfn + i);
                         total++;
diff --git a/arch/x86_64/mm/numa.c b/arch/x86_64/mm/numa.c
index 63c72641b737..4be82d6e2b48 100644
--- a/arch/x86_64/mm/numa.c
+++ b/arch/x86_64/mm/numa.c
@@ -377,21 +377,6 @@ EXPORT_SYMBOL(node_data);
  * Should do that.
  */
 
-/* Requires pfn_valid(pfn) to be true */
-struct page *pfn_to_page(unsigned long pfn)
-{
-        int nid = phys_to_nid(((unsigned long)(pfn)) << PAGE_SHIFT);
-        return (pfn - node_start_pfn(nid)) + NODE_DATA(nid)->node_mem_map;
-}
-EXPORT_SYMBOL(pfn_to_page);
-
-unsigned long page_to_pfn(struct page *page)
-{
-        return (long)(((page) - page_zone(page)->zone_mem_map) +
-                      page_zone(page)->zone_start_pfn);
-}
-EXPORT_SYMBOL(page_to_pfn);
-
 int pfn_valid(unsigned long pfn)
 {
         unsigned nid;
diff --git a/arch/xtensa/platform-iss/setup.c b/arch/xtensa/platform-iss/setup.c
index 2e6dcbf0cc04..23790a5610e2 100644
--- a/arch/xtensa/platform-iss/setup.c
+++ b/arch/xtensa/platform-iss/setup.c
@@ -108,5 +108,5 @@ static struct notifier_block iss_panic_block = {
 
 void __init platform_setup(char **p_cmdline)
 {
-        notifier_chain_register(&panic_notifier_list, &iss_panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &iss_panic_block);
 }
diff --git a/block/Kconfig b/block/Kconfig
index 43ca070dc0f8..5536839886ff 100644
--- a/block/Kconfig
+++ b/block/Kconfig
@@ -13,6 +13,7 @@ config LBD
 
 config BLK_DEV_IO_TRACE
         bool "Support for tracing block io actions"
+        depends on SYSFS
         select RELAY
         select DEBUG_FS
         help
diff --git a/block/genhd.c b/block/genhd.c
index 64510fd88621..db4c60c802d6 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -454,8 +454,8 @@ static ssize_t disk_stats_read(struct gendisk * disk, char *page)
         disk_round_stats(disk);
         preempt_enable();
         return sprintf(page,
-                "%8u %8u %8llu %8u "
-                "%8u %8u %8llu %8u "
+                "%8lu %8lu %8llu %8u "
+                "%8lu %8lu %8llu %8u "
                 "%8u %8u %8u"
                 "\n",
                 disk_stat_read(disk, ios[READ]),
@@ -649,7 +649,7 @@ static int diskstats_show(struct seq_file *s, void *v)
         preempt_disable();
         disk_round_stats(gp);
         preempt_enable();
-        seq_printf(s, "%4d %4d %s %u %u %llu %u %u %u %llu %u %u %u %u\n",
+        seq_printf(s, "%4d %4d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u\n",
                 gp->major, n + gp->first_minor, disk_name(gp, n, buf),
                 disk_stat_read(gp, ios[0]), disk_stat_read(gp, merges[0]),
                 (unsigned long long)disk_stat_read(gp, sectors[0]),
diff --git a/block/ll_rw_blk.c b/block/ll_rw_blk.c
index 062067fa7ead..82469db25100 100644
--- a/block/ll_rw_blk.c
+++ b/block/ll_rw_blk.c
@@ -785,6 +785,8 @@ void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b)
         t->max_hw_segments = min(t->max_hw_segments,b->max_hw_segments);
         t->max_segment_size = min(t->max_segment_size,b->max_segment_size);
         t->hardsect_size = max(t->hardsect_size,b->hardsect_size);
+        if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
+                clear_bit(QUEUE_FLAG_CLUSTER, &t->queue_flags);
 }
 
 EXPORT_SYMBOL(blk_queue_stack_limits);
@@ -906,17 +908,15 @@ init_tag_map(request_queue_t *q, struct blk_queue_tag *tags, int depth)
                                 __FUNCTION__, depth);
         }
 
-        tag_index = kmalloc(depth * sizeof(struct request *), GFP_ATOMIC);
+        tag_index = kzalloc(depth * sizeof(struct request *), GFP_ATOMIC);
         if (!tag_index)
                 goto fail;
 
         nr_ulongs = ALIGN(depth, BITS_PER_LONG) / BITS_PER_LONG;
-        tag_map = kmalloc(nr_ulongs * sizeof(unsigned long), GFP_ATOMIC);
+        tag_map = kzalloc(nr_ulongs * sizeof(unsigned long), GFP_ATOMIC);
         if (!tag_map)
                 goto fail;
 
-        memset(tag_index, 0, depth * sizeof(struct request *));
-        memset(tag_map, 0, nr_ulongs * sizeof(unsigned long));
         tags->real_max_depth = depth;
         tags->max_depth = depth;
         tags->tag_index = tag_index;
@@ -2479,10 +2479,12 @@ void blk_execute_rq_nowait(request_queue_t *q, struct gendisk *bd_disk,
         rq->rq_disk = bd_disk;
         rq->flags |= REQ_NOMERGE;
         rq->end_io = done;
-        elv_add_request(q, rq, where, 1);
-        generic_unplug_device(q);
+        WARN_ON(irqs_disabled());
+        spin_lock_irq(q->queue_lock);
+        __elv_add_request(q, rq, where, 1);
+        __generic_unplug_device(q);
+        spin_unlock_irq(q->queue_lock);
 }
-
 EXPORT_SYMBOL_GPL(blk_execute_rq_nowait);
 
 /**
diff --git a/drivers/Kconfig b/drivers/Kconfig
index bddf431bbb72..9f5c0da57c90 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -70,4 +70,6 @@ source "drivers/sn/Kconfig"
 
 source "drivers/edac/Kconfig"
 
+source "drivers/rtc/Kconfig"
+
 endmenu
diff --git a/drivers/Makefile b/drivers/Makefile
index 5c69b86db624..424955274e60 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -56,6 +56,7 @@ obj-$(CONFIG_USB_GADGET)	+= usb/gadget/
 obj-$(CONFIG_GAMEPORT)          += input/gameport/
 obj-$(CONFIG_INPUT)             += input/
 obj-$(CONFIG_I2O)               += message/
+obj-$(CONFIG_RTC_LIB)           += rtc/
 obj-$(CONFIG_I2C)               += i2c/
 obj-$(CONFIG_W1)                += w1/
 obj-$(CONFIG_HWMON)             += hwmon/
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 105a0d61eb1f..dd547af4681a 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -47,16 +47,16 @@ static struct kset_uevent_ops memory_uevent_ops = {
         .uevent         = memory_uevent,
 };
 
-static struct notifier_block *memory_chain;
+static BLOCKING_NOTIFIER_HEAD(memory_chain);
 
 int register_memory_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&memory_chain, nb);
+        return blocking_notifier_chain_register(&memory_chain, nb);
 }
 
 void unregister_memory_notifier(struct notifier_block *nb)
 {
-        notifier_chain_unregister(&memory_chain, nb);
+        blocking_notifier_chain_unregister(&memory_chain, nb);
 }
 
 /*
@@ -140,7 +140,7 @@ static ssize_t show_mem_state(struct sys_device *dev, char *buf)
 
 static inline int memory_notify(unsigned long val, void *v)
 {
-        return notifier_call_chain(&memory_chain, val, v);
+        return blocking_notifier_call_chain(&memory_chain, val, v);
 }
 
 /*
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 9bdea2a5cf0e..49c7cd558ddf 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -311,11 +311,10 @@ static boolean DAC960_CreateAuxiliaryStructures(DAC960_Controller_T *Controller)
                 CommandsRemaining = CommandAllocationGroupSize;
           CommandGroupByteCount =
                 CommandsRemaining * CommandAllocationLength;
-          AllocationPointer = kmalloc(CommandGroupByteCount, GFP_ATOMIC);
+          AllocationPointer = kzalloc(CommandGroupByteCount, GFP_ATOMIC);
           if (AllocationPointer == NULL)
                 return DAC960_Failure(Controller,
                                         "AUXILIARY STRUCTURE CREATION");
-          memset(AllocationPointer, 0, CommandGroupByteCount);
          }
       Command = (DAC960_Command_T *) AllocationPointer;
       AllocationPointer += CommandAllocationLength;
@@ -2709,14 +2708,12 @@ DAC960_DetectController(struct pci_dev *PCI_Device,
   void __iomem *BaseAddress;
   int i;
 
-  Controller = (DAC960_Controller_T *)
-        kmalloc(sizeof(DAC960_Controller_T), GFP_ATOMIC);
+  Controller = kzalloc(sizeof(DAC960_Controller_T), GFP_ATOMIC);
   if (Controller == NULL) {
         DAC960_Error("Unable to allocate Controller structure for "
                        "Controller at\n", NULL);
         return NULL;
   }
-  memset(Controller, 0, sizeof(DAC960_Controller_T));
   Controller->ControllerNumber = DAC960_ControllerCount;
   DAC960_Controllers[DAC960_ControllerCount++] = Controller;
   Controller->Bus = PCI_Device->bus->number;
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 71ec9e664383..1b0fd31c57c3 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -996,13 +996,11 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         status = -EINVAL;
                         goto cleanup1;
                 }
-                buff = (unsigned char **) kmalloc(MAXSGENTRIES * 
-                                sizeof(char *), GFP_KERNEL);
+                buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
                 if (!buff) {
                         status = -ENOMEM;
                         goto cleanup1;
                 }
-                memset(buff, 0, MAXSGENTRIES);
                 buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int), 
                                         GFP_KERNEL);
                 if (!buff_size) {
@@ -2729,9 +2727,9 @@ static void __devinit cciss_interrupt_mode(ctlr_info_t *c, struct pci_dev *pdev,
                         return;
                 }
         }
+default_int_mode:
 #endif /* CONFIG_PCI_MSI */
         /* if we get here we're going to use the default interrupt mode */
-default_int_mode:
         c->intr[SIMPLE_MODE_INT] = pdev->irq;
         return;
 }
@@ -2940,13 +2938,12 @@ static void cciss_getgeometry(int cntl_num)
         int block_size;
         int total_size; 
 
-        ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
+        ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
         if (ld_buff == NULL)
         {
                 printk(KERN_ERR "cciss: out of memory\n");
                 return;
         }
-        memset(ld_buff, 0, sizeof(ReportLunData_struct));
         size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
         if (size_buff == NULL)
         {
@@ -3060,10 +3057,9 @@ static int alloc_cciss_hba(void)
         for(i=0; i< MAX_CTLR; i++) {
                 if (!hba[i]) {
                         ctlr_info_t *p;
-                        p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
+                        p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
                         if (!p)
                                 goto Enomem;
-                        memset(p, 0, sizeof(ctlr_info_t));
                         for (n = 0; n < NWD; n++)
                                 p->gendisk[n] = disk[n];
                         hba[i] = p;
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index 0e66e904bd8c..597c007fe81b 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -1027,12 +1027,11 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
         int i;
 
         c = (ctlr_info_t *) hba[cntl_num];      
-        ld_buff = kmalloc(reportlunsize, GFP_KERNEL);
+        ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
         if (ld_buff == NULL) {
                 printk(KERN_ERR "cciss: out of memory\n");
                 return;
         }
-        memset(ld_buff, 0, reportlunsize);
         inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
         if (inq_buff == NULL) {
                 printk(KERN_ERR "cciss: out of memory\n");
diff --git a/drivers/block/paride/bpck6.c b/drivers/block/paride/bpck6.c
index 08d858ad64db..41a237c5957d 100644
--- a/drivers/block/paride/bpck6.c
+++ b/drivers/block/paride/bpck6.c
@@ -224,10 +224,9 @@ static void bpck6_log_adapter( PIA *pi, char * scratch, int verbose )
 
 static int bpck6_init_proto(PIA *pi)
 {
-        Interface *p = kmalloc(sizeof(Interface), GFP_KERNEL);
+        Interface *p = kzalloc(sizeof(Interface), GFP_KERNEL);
 
         if (p) {
-                memset(p, 0, sizeof(Interface));
                 pi->private = (unsigned long)p;
                 return 0;
         }
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index facc3f1d9e37..73d30bf01582 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -696,7 +696,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
+        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV && !ARM
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index b8fb87c6c29f..40eb005b9d77 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -3744,7 +3744,7 @@ static int ipmi_init_msghandler(void)
         ipmi_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
         add_timer(&ipmi_timer);
 
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         initialized = 1;
 
@@ -3764,7 +3764,7 @@ static __exit void cleanup_ipmi(void)
         if (!initialized)
                 return;
 
-        notifier_chain_unregister(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block);
 
         /* This can't be called if any interfaces exist, so no worry about
            shutting down the interfaces. */
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 12f858dc9994..35fbd4d8ed4b 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -237,10 +237,10 @@ struct smi_info
 
 static int try_smi_init(struct smi_info *smi);
 
-static struct notifier_block *xaction_notifier_list;
+static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 static int register_xaction_notifier(struct notifier_block * nb)
 {
-        return notifier_chain_register(&xaction_notifier_list, nb);
+        return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 }
 
 static void si_restart_short_timer(struct smi_info *smi_info);
@@ -302,7 +302,8 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                 do_gettimeofday(&t);
                 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
-                err = notifier_call_chain(&xaction_notifier_list, 0, smi_info);
+                err = atomic_notifier_call_chain(&xaction_notifier_list,
+                                0, smi_info);
                 if (err & NOTIFY_STOP_MASK) {
                         rv = SI_SM_CALL_WITHOUT_DELAY;
                         goto out;
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 616539310d9a..7ece9f3c8f70 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -1158,7 +1158,8 @@ static int __init ipmi_wdog_init(void)
         }
 
         register_reboot_notifier(&wdog_reboot_notifier);
-        notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &wdog_panic_notifier);
 
         printk(KERN_INFO PFX "driver initialized\n");
 
@@ -1176,7 +1177,8 @@ static __exit void ipmi_unregister_watchdog(void)
                 release_nmi(&ipmi_nmi_handler);
 #endif
 
-        notifier_chain_unregister(&panic_notifier_list, &wdog_panic_notifier);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &wdog_panic_notifier);
         unregister_reboot_notifier(&wdog_reboot_notifier);
 
         if (! watchdog_user)
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index aed80e6aec6d..9b6ae7dc8b8a 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -52,9 +52,8 @@ static void handle_update(void *data);
  * changes to devices when the CPU clock speed changes.
  * The mutex locks both lists.
  */
-static struct notifier_block *cpufreq_policy_notifier_list;
-static struct notifier_block *cpufreq_transition_notifier_list;
-static DECLARE_RWSEM (cpufreq_notifier_rwsem);
+static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
+static BLOCKING_NOTIFIER_HEAD(cpufreq_transition_notifier_list);
 
 
 static LIST_HEAD(cpufreq_governor_list);
@@ -247,8 +246,6 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
         dprintk("notification %u of frequency transition to %u kHz\n",
                 state, freqs->new);
 
-        down_read(&cpufreq_notifier_rwsem);
-
         policy = cpufreq_cpu_data[freqs->cpu];
         switch (state) {
 
@@ -266,20 +263,19 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
                                 freqs->old = policy->cur;
                         }
                 }
-                notifier_call_chain(&cpufreq_transition_notifier_list,
-                                        CPUFREQ_PRECHANGE, freqs);
+                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                                CPUFREQ_PRECHANGE, freqs);
                 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
                 break;
 
         case CPUFREQ_POSTCHANGE:
                 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
-                notifier_call_chain(&cpufreq_transition_notifier_list,
-                                        CPUFREQ_POSTCHANGE, freqs);
+                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                                CPUFREQ_POSTCHANGE, freqs);
                 if (likely(policy) && likely(policy->cpu == freqs->cpu))
                         policy->cur = freqs->new;
                 break;
         }
-        up_read(&cpufreq_notifier_rwsem);
 }
 EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
 
@@ -1007,7 +1003,7 @@ static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
                 freqs.old = cpu_policy->cur;
                 freqs.new = cur_freq;
 
-                notifier_call_chain(&cpufreq_transition_notifier_list,
+                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
                                     CPUFREQ_SUSPENDCHANGE, &freqs);
                 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
 
@@ -1088,7 +1084,8 @@ static int cpufreq_resume(struct sys_device * sysdev)
                         freqs.old = cpu_policy->cur;
                         freqs.new = cur_freq;
 
-                        notifier_call_chain(&cpufreq_transition_notifier_list,
+                        blocking_notifier_call_chain(
+                                        &cpufreq_transition_notifier_list,
                                         CPUFREQ_RESUMECHANGE, &freqs);
                         adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
 
@@ -1125,24 +1122,24 @@ static struct sysdev_driver cpufreq_sysdev_driver = {
  *      changes in cpufreq policy.
  *
  *      This function may sleep, and has the same return conditions as
- *      notifier_chain_register.
+ *      blocking_notifier_chain_register.
  */
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
 {
         int ret;
 
-        down_write(&cpufreq_notifier_rwsem);
         switch (list) {
         case CPUFREQ_TRANSITION_NOTIFIER:
-                ret = notifier_chain_register(&cpufreq_transition_notifier_list, nb);
+                ret = blocking_notifier_chain_register(
+                                &cpufreq_transition_notifier_list, nb);
                 break;
         case CPUFREQ_POLICY_NOTIFIER:
-                ret = notifier_chain_register(&cpufreq_policy_notifier_list, nb);
+                ret = blocking_notifier_chain_register(
+                                &cpufreq_policy_notifier_list, nb);
                 break;
         default:
                 ret = -EINVAL;
         }
-        up_write(&cpufreq_notifier_rwsem);
 
         return ret;
 }
@@ -1157,24 +1154,24 @@ EXPORT_SYMBOL(cpufreq_register_notifier);
  *      Remove a driver from the CPU frequency notifier list.
  *
  *      This function may sleep, and has the same return conditions as
- *      notifier_chain_unregister.
+ *      blocking_notifier_chain_unregister.
  */
 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
 {
         int ret;
 
-        down_write(&cpufreq_notifier_rwsem);
         switch (list) {
         case CPUFREQ_TRANSITION_NOTIFIER:
-                ret = notifier_chain_unregister(&cpufreq_transition_notifier_list, nb);
+                ret = blocking_notifier_chain_unregister(
+                                &cpufreq_transition_notifier_list, nb);
                 break;
         case CPUFREQ_POLICY_NOTIFIER:
-                ret = notifier_chain_unregister(&cpufreq_policy_notifier_list, nb);
+                ret = blocking_notifier_chain_unregister(
+                                &cpufreq_policy_notifier_list, nb);
                 break;
         default:
                 ret = -EINVAL;
         }
-        up_write(&cpufreq_notifier_rwsem);
 
         return ret;
 }
@@ -1346,29 +1343,23 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_poli
         if (ret)
                 goto error_out;
 
-        down_read(&cpufreq_notifier_rwsem);
-
         /* adjust if necessary - all reasons */
-        notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_ADJUST,
-                            policy);
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                        CPUFREQ_ADJUST, policy);
 
         /* adjust if necessary - hardware incompatibility*/
-        notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_INCOMPATIBLE,
-                            policy);
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                        CPUFREQ_INCOMPATIBLE, policy);
 
         /* verify the cpu speed can be set within this limit,
            which might be different to the first one */
         ret = cpufreq_driver->verify(policy);
-        if (ret) {
-                up_read(&cpufreq_notifier_rwsem);
+        if (ret)
                 goto error_out;
-        }
 
         /* notification of the new policy */
-        notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_NOTIFY,
-                            policy);
-
-        up_read(&cpufreq_notifier_rwsem);
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                        CPUFREQ_NOTIFY, policy);
 
         data->min = policy->min;
         data->max = policy->max;
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index d6543fc4a923..339f405ff708 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -484,26 +484,15 @@ static void dcdbas_host_control(void)
 static int dcdbas_reboot_notify(struct notifier_block *nb, unsigned long code,
                                 void *unused)
 {
-        static unsigned int notify_cnt = 0;
-
         switch (code) {
         case SYS_DOWN:
         case SYS_HALT:
         case SYS_POWER_OFF:
                 if (host_control_on_shutdown) {
                         /* firmware is going to perform host control action */
-                        if (++notify_cnt == 2) {
-                                printk(KERN_WARNING
-                                       "Please wait for shutdown "
-                                       "action to complete...\n");
-                                dcdbas_host_control();
-                        }
-                        /*
-                         * register again and initiate the host control
-                         * action on the second notification to allow
-                         * everyone that registered to be notified
-                         */
-                        register_reboot_notifier(nb);
+                        printk(KERN_WARNING "Please wait for shutdown "
+                               "action to complete...\n");
+                        dcdbas_host_control();
                 }
                 break;
         }
@@ -514,7 +503,7 @@ static int dcdbas_reboot_notify(struct notifier_block *nb, unsigned long code,
 static struct notifier_block dcdbas_reboot_nb = {
         .notifier_call = dcdbas_reboot_notify,
         .next = NULL,
-        .priority = 0
+        .priority = INT_MIN
 };
 
 static DCDBAS_BIN_ATTR_RW(smi_data);
diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
index f9fae28f5612..7aa5c38f0855 100644
--- a/drivers/i2c/chips/Kconfig
+++ b/drivers/i2c/chips/Kconfig
@@ -65,15 +65,6 @@ config SENSORS_PCF8591
           This driver can also be built as a module.  If so, the module
           will be called pcf8591.
 
-config SENSORS_RTC8564
-        tristate "Epson 8564 RTC chip"
-        depends on I2C && EXPERIMENTAL
-        help
-          If you say yes here you get support for the Epson 8564 RTC chip.
-
-          This driver can also be built as a module.  If so, the module
-          will be called i2c-rtc8564.
-
 config ISP1301_OMAP
         tristate "Philips ISP1301 with OMAP OTG"
         depends on I2C && ARCH_OMAP_OTG
@@ -126,13 +117,4 @@ config SENSORS_MAX6875
           This driver can also be built as a module.  If so, the module
           will be called max6875.
 
-config RTC_X1205_I2C
-        tristate "Xicor X1205 RTC chip"
-        depends on I2C && EXPERIMENTAL
-        help
-          If you say yes here you get support for the Xicor X1205 RTC chip.
-
-          This driver can also be built as a module. If so, the module
-          will be called x1205.
-
 endmenu
diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
index 46178b57b1f1..779868ef2e26 100644
--- a/drivers/i2c/chips/Makefile
+++ b/drivers/i2c/chips/Makefile
@@ -10,10 +10,8 @@ obj-$(CONFIG_SENSORS_M41T00)	+= m41t00.o
 obj-$(CONFIG_SENSORS_PCA9539)   += pca9539.o
 obj-$(CONFIG_SENSORS_PCF8574)   += pcf8574.o
 obj-$(CONFIG_SENSORS_PCF8591)   += pcf8591.o
-obj-$(CONFIG_SENSORS_RTC8564)   += rtc8564.o
 obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
 obj-$(CONFIG_TPS65010)          += tps65010.o
-obj-$(CONFIG_RTC_X1205_I2C)     += x1205.o
 
 ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/i2c/chips/rtc8564.c b/drivers/i2c/chips/rtc8564.c
deleted file mode 100644
index 0d8699b3f488..000000000000
--- a/drivers/i2c/chips/rtc8564.c
+++ /dev/null
@@ -1,385 +0,0 @@
-/*
- *  linux/drivers/i2c/chips/rtc8564.c
- *
- *  Copyright (C) 2002-2004 Stefan Eletzhofer
- *
- *      based on linux/drivers/acron/char/pcf8583.c
- *  Copyright (C) 2000 Russell King
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * Driver for system3's EPSON RTC 8564 chip
- */
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/bcd.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/rtc.h>          /* get the user-level API */
-#include <linux/init.h>
-
-#include "rtc8564.h"
-
-#ifdef DEBUG
-# define _DBG(x, fmt, args...) do{ if (debug>=x) printk(KERN_DEBUG"%s: " fmt "\n", __FUNCTION__, ##args); } while(0);
-#else
-# define _DBG(x, fmt, args...) do { } while(0);
-#endif
-
-#define _DBGRTCTM(x, rtctm) if (debug>=x) printk("%s: secs=%d, mins=%d, hours=%d, mday=%d, " \
-                        "mon=%d, year=%d, wday=%d VL=%d\n", __FUNCTION__, \
-                        (rtctm).secs, (rtctm).mins, (rtctm).hours, (rtctm).mday, \
-                        (rtctm).mon, (rtctm).year, (rtctm).wday, (rtctm).vl);
-
-struct rtc8564_data {
-        struct i2c_client client;
-        u16 ctrl;
-};
-
-static inline u8 _rtc8564_ctrl1(struct i2c_client *client)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-        return data->ctrl & 0xff;
-}
-static inline u8 _rtc8564_ctrl2(struct i2c_client *client)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-        return (data->ctrl & 0xff00) >> 8;
-}
-
-#define CTRL1(c) _rtc8564_ctrl1(c)
-#define CTRL2(c) _rtc8564_ctrl2(c)
-
-static int debug;
-module_param(debug, int, S_IRUGO | S_IWUSR);
-
-static struct i2c_driver rtc8564_driver;
-
-static unsigned short ignore[] = { I2C_CLIENT_END };
-static unsigned short normal_addr[] = { 0x51, I2C_CLIENT_END };
-
-static struct i2c_client_address_data addr_data = {
-        .normal_i2c             = normal_addr,
-        .probe                  = ignore,
-        .ignore                 = ignore,
-};
-
-static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem);
-static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem);
-
-static int rtc8564_read(struct i2c_client *client, unsigned char adr,
-                        unsigned char *buf, unsigned char len)
-{
-        int ret = -EIO;
-        unsigned char addr[1] = { adr };
-        struct i2c_msg msgs[2] = {
-                {client->addr, 0, 1, addr},
-                {client->addr, I2C_M_RD, len, buf}
-        };
-
-        _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, buf, len);
-
-        if (!buf) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        ret = i2c_transfer(client->adapter, msgs, 2);
-        if (ret == 2) {
-                ret = 0;
-        }
-
-done:
-        return ret;
-}
-
-static int rtc8564_write(struct i2c_client *client, unsigned char adr,
-                         unsigned char *data, unsigned char len)
-{
-        int ret = 0;
-        unsigned char _data[16];
-        struct i2c_msg wr;
-        int i;
-
-        if (!data || len > 15) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, data, len);
-
-        _data[0] = adr;
-        for (i = 0; i < len; i++) {
-                _data[i + 1] = data[i];
-                _DBG(5, "data[%d] = 0x%02x (%d)", i, data[i], data[i]);
-        }
-
-        wr.addr = client->addr;
-        wr.flags = 0;
-        wr.len = len + 1;
-        wr.buf = _data;
-
-        ret = i2c_transfer(client->adapter, &wr, 1);
-        if (ret == 1) {
-                ret = 0;
-        }
-
-done:
-        return ret;
-}
-
-static int rtc8564_attach(struct i2c_adapter *adap, int addr, int kind)
-{
-        int ret;
-        struct i2c_client *new_client;
-        struct rtc8564_data *d;
-        unsigned char data[10];
-        unsigned char ad[1] = { 0 };
-        struct i2c_msg ctrl_wr[1] = {
-                {addr, 0, 2, data}
-        };
-        struct i2c_msg ctrl_rd[2] = {
-                {addr, 0, 1, ad},
-                {addr, I2C_M_RD, 2, data}
-        };
-
-        d = kzalloc(sizeof(struct rtc8564_data), GFP_KERNEL);
-        if (!d) {
-                ret = -ENOMEM;
-                goto done;
-        }
-        new_client = &d->client;
-
-        strlcpy(new_client->name, "RTC8564", I2C_NAME_SIZE);
-        i2c_set_clientdata(new_client, d);
-        new_client->addr = addr;
-        new_client->adapter = adap;
-        new_client->driver = &rtc8564_driver;
-
-        _DBG(1, "client=%p", new_client);
-
-        /* init ctrl1 reg */
-        data[0] = 0;
-        data[1] = 0;
-        ret = i2c_transfer(new_client->adapter, ctrl_wr, 1);
-        if (ret != 1) {
-                printk(KERN_INFO "rtc8564: cant init ctrl1\n");
-                ret = -ENODEV;
-                goto done;
-        }
-
-        /* read back ctrl1 and ctrl2 */
-        ret = i2c_transfer(new_client->adapter, ctrl_rd, 2);
-        if (ret != 2) {
-                printk(KERN_INFO "rtc8564: cant read ctrl\n");
-                ret = -ENODEV;
-                goto done;
-        }
-
-        d->ctrl = data[0] | (data[1] << 8);
-
-        _DBG(1, "RTC8564_REG_CTRL1=%02x, RTC8564_REG_CTRL2=%02x",
-             data[0], data[1]);
-
-        ret = i2c_attach_client(new_client);
-done:
-        if (ret) {
-                kfree(d);
-        }
-        return ret;
-}
-
-static int rtc8564_probe(struct i2c_adapter *adap)
-{
-        return i2c_probe(adap, &addr_data, rtc8564_attach);
-}
-
-static int rtc8564_detach(struct i2c_client *client)
-{
-        i2c_detach_client(client);
-        kfree(i2c_get_clientdata(client));
-        return 0;
-}
-
-static int rtc8564_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
-{
-        int ret = -EIO;
-        unsigned char buf[15];
-
-        _DBG(1, "client=%p, dt=%p", client, dt);
-
-        if (!dt)
-                return -EINVAL;
-
-        memset(buf, 0, sizeof(buf));
-
-        ret = rtc8564_read(client, 0, buf, 15);
-        if (ret)
-                return ret;
-
-        /* century stored in minute alarm reg */
-        dt->year = BCD2BIN(buf[RTC8564_REG_YEAR]);
-        dt->year += 100 * BCD2BIN(buf[RTC8564_REG_AL_MIN] & 0x3f);
-        dt->mday = BCD2BIN(buf[RTC8564_REG_DAY] & 0x3f);
-        dt->wday = BCD2BIN(buf[RTC8564_REG_WDAY] & 7);
-        dt->mon = BCD2BIN(buf[RTC8564_REG_MON_CENT] & 0x1f);
-
-        dt->secs = BCD2BIN(buf[RTC8564_REG_SEC] & 0x7f);
-        dt->vl = (buf[RTC8564_REG_SEC] & 0x80) == 0x80;
-        dt->mins = BCD2BIN(buf[RTC8564_REG_MIN] & 0x7f);
-        dt->hours = BCD2BIN(buf[RTC8564_REG_HR] & 0x3f);
-
-        _DBGRTCTM(2, *dt);
-
-        return 0;
-}
-
-static int
-rtc8564_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
-{
-        int ret, len = 5;
-        unsigned char buf[15];
-
-        _DBG(1, "client=%p, dt=%p", client, dt);
-
-        if (!dt)
-                return -EINVAL;
-
-        _DBGRTCTM(2, *dt);
-
-        buf[RTC8564_REG_CTRL1] = CTRL1(client) | RTC8564_CTRL1_STOP;
-        buf[RTC8564_REG_CTRL2] = CTRL2(client);
-        buf[RTC8564_REG_SEC] = BIN2BCD(dt->secs);
-        buf[RTC8564_REG_MIN] = BIN2BCD(dt->mins);
-        buf[RTC8564_REG_HR] = BIN2BCD(dt->hours);
-
-        if (datetoo) {
-                len += 5;
-                buf[RTC8564_REG_DAY] = BIN2BCD(dt->mday);
-                buf[RTC8564_REG_WDAY] = BIN2BCD(dt->wday);
-                buf[RTC8564_REG_MON_CENT] = BIN2BCD(dt->mon) & 0x1f;
-                /* century stored in minute alarm reg */
-                buf[RTC8564_REG_YEAR] = BIN2BCD(dt->year % 100);
-                buf[RTC8564_REG_AL_MIN] = BIN2BCD(dt->year / 100);
-        }
-
-        ret = rtc8564_write(client, 0, buf, len);
-        if (ret) {
-                _DBG(1, "error writing data! %d", ret);
-        }
-
-        buf[RTC8564_REG_CTRL1] = CTRL1(client);
-        ret = rtc8564_write(client, 0, buf, 1);
-        if (ret) {
-                _DBG(1, "error writing data! %d", ret);
-        }
-
-        return ret;
-}
-
-static int rtc8564_get_ctrl(struct i2c_client *client, unsigned int *ctrl)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-
-        if (!ctrl)
-                return -1;
-
-        *ctrl = data->ctrl;
-        return 0;
-}
-
-static int rtc8564_set_ctrl(struct i2c_client *client, unsigned int *ctrl)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-        unsigned char buf[2];
-
-        if (!ctrl)
-                return -1;
-
-        buf[0] = *ctrl & 0xff;
-        buf[1] = (*ctrl & 0xff00) >> 8;
-        data->ctrl = *ctrl;
-
-        return rtc8564_write(client, 0, buf, 2);
-}
-
-static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem)
-{
-
-        if (!mem)
-                return -EINVAL;
-
-        return rtc8564_read(client, mem->loc, mem->data, mem->nr);
-}
-
-static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem)
-{
-
-        if (!mem)
-                return -EINVAL;
-
-        return rtc8564_write(client, mem->loc, mem->data, mem->nr);
-}
-
-static int
-rtc8564_command(struct i2c_client *client, unsigned int cmd, void *arg)
-{
-
-        _DBG(1, "cmd=%d", cmd);
-
-        switch (cmd) {
-        case RTC_GETDATETIME:
-                return rtc8564_get_datetime(client, arg);
-
-        case RTC_SETTIME:
-                return rtc8564_set_datetime(client, arg, 0);
-
-        case RTC_SETDATETIME:
-                return rtc8564_set_datetime(client, arg, 1);
-
-        case RTC_GETCTRL:
-                return rtc8564_get_ctrl(client, arg);
-
-        case RTC_SETCTRL:
-                return rtc8564_set_ctrl(client, arg);
-
-        case MEM_READ:
-                return rtc8564_read_mem(client, arg);
-
-        case MEM_WRITE:
-                return rtc8564_write_mem(client, arg);
-
-        default:
-                return -EINVAL;
-        }
-}
-
-static struct i2c_driver rtc8564_driver = {
-        .driver = {
-                .name   = "RTC8564",
-        },
-        .id             = I2C_DRIVERID_RTC8564,
-        .attach_adapter = rtc8564_probe,
-        .detach_client  = rtc8564_detach,
-        .command        = rtc8564_command
-};
-
-static __init int rtc8564_init(void)
-{
-        return i2c_add_driver(&rtc8564_driver);
-}
-
-static __exit void rtc8564_exit(void)
-{
-        i2c_del_driver(&rtc8564_driver);
-}
-
-MODULE_AUTHOR("Stefan Eletzhofer <Stefan.Eletzhofer@eletztrick.de>");
-MODULE_DESCRIPTION("EPSON RTC8564 Driver");
-MODULE_LICENSE("GPL");
-
-module_init(rtc8564_init);
-module_exit(rtc8564_exit);
diff --git a/drivers/i2c/chips/rtc8564.h b/drivers/i2c/chips/rtc8564.h
deleted file mode 100644
index e5342d10b8fa..000000000000
--- a/drivers/i2c/chips/rtc8564.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- *  linux/drivers/i2c/chips/rtc8564.h
- *
- *  Copyright (C) 2002-2004 Stefan Eletzhofer
- *
- *      based on linux/drivers/acron/char/pcf8583.h
- *  Copyright (C) 2000 Russell King
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-struct rtc_tm {
-        unsigned char   secs;
-        unsigned char   mins;
-        unsigned char   hours;
-        unsigned char   mday;
-        unsigned char   mon;
-        unsigned short  year; /* xxxx 4 digits :) */
-        unsigned char   wday;
-        unsigned char   vl;
-};
-
-struct mem {
-        unsigned int    loc;
-        unsigned int    nr;
-        unsigned char   *data;
-};
-
-#define RTC_GETDATETIME 0
-#define RTC_SETTIME     1
-#define RTC_SETDATETIME 2
-#define RTC_GETCTRL     3
-#define RTC_SETCTRL     4
-#define MEM_READ        5
-#define MEM_WRITE       6
-
-#define RTC8564_REG_CTRL1               0x0 /* T  0 S 0 | T 0 0 0 */
-#define RTC8564_REG_CTRL2               0x1 /* 0  0 0 TI/TP | AF TF AIE TIE */
-#define RTC8564_REG_SEC                 0x2 /* VL 4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_MIN                 0x3 /* x  4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_HR                  0x4 /* x  x 2 1 | 8 4 2 1 */
-#define RTC8564_REG_DAY                 0x5 /* x  x 2 1 | 8 4 2 1 */
-#define RTC8564_REG_WDAY                0x6 /* x  x x x | x 4 2 1 */
-#define RTC8564_REG_MON_CENT    0x7 /* C  x x 1 | 8 4 2 1 */
-#define RTC8564_REG_YEAR                0x8 /* 8  4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_MIN              0x9 /* AE 4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_HR               0xa /* AE 4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_DAY              0xb /* AE x 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_WDAY             0xc /* AE x x x | x 4 2 1 */
-#define RTC8564_REG_CLKOUT              0xd /* FE x x x | x x FD1 FD0 */
-#define RTC8564_REG_TCTL                0xe /* TE x x x | x x FD1 FD0 */
-#define RTC8564_REG_TIMER               0xf /* 8 bit binary */
-
-/* Control reg */
-#define RTC8564_CTRL1_TEST1             (1<<3)
-#define RTC8564_CTRL1_STOP              (1<<5)
-#define RTC8564_CTRL1_TEST2             (1<<7)
-
-#define RTC8564_CTRL2_TIE               (1<<0)
-#define RTC8564_CTRL2_AIE               (1<<1)
-#define RTC8564_CTRL2_TF                (1<<2)
-#define RTC8564_CTRL2_AF                (1<<3)
-#define RTC8564_CTRL2_TI_TP             (1<<4)
-
-/* CLKOUT frequencies */
-#define RTC8564_FD_32768HZ              (0x0)
-#define RTC8564_FD_1024HZ               (0x1)
-#define RTC8564_FD_32                   (0x2)
-#define RTC8564_FD_1HZ                  (0x3)
-
-/* Timer CTRL */
-#define RTC8564_TD_4096HZ               (0x0)
-#define RTC8564_TD_64HZ                 (0x1)
-#define RTC8564_TD_1HZ                  (0x2)
-#define RTC8564_TD_1_60HZ               (0x3)
-
-#define I2C_DRIVERID_RTC8564 0xf000
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index c7671e188017..b4a41d6d0714 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -2143,6 +2143,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
         req.data = (char *)&capbuf;
         req.data_len = sizeof(capbuf);
+        req.flags |= REQ_QUIET;
 
         stat = cdrom_queue_packet_command(drive, &req);
         if (stat == 0) {
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index d2ead1776c16..34fcabac5fdb 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -80,7 +80,7 @@ static struct adb_driver *adb_driver_list[] = {
 static struct class *adb_dev_class;
 
 struct adb_driver *adb_controller;
-struct notifier_block *adb_client_list = NULL;
+BLOCKING_NOTIFIER_HEAD(adb_client_list);
 static int adb_got_sleep;
 static int adb_inited;
 static pid_t adb_probe_task_pid;
@@ -354,7 +354,8 @@ adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
                 /* Stop autopoll */
                 if (adb_controller->autopoll)
                         adb_controller->autopoll(0);
-                ret = notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
+                ret = blocking_notifier_call_chain(&adb_client_list,
+                                ADB_MSG_POWERDOWN, NULL);
                 if (ret & NOTIFY_STOP_MASK) {
                         up(&adb_probe_mutex);
                         return PBOOK_SLEEP_REFUSE;
@@ -391,7 +392,8 @@ do_adb_reset_bus(void)
         if (adb_controller->autopoll)
                 adb_controller->autopoll(0);
 
-        nret = notifier_call_chain(&adb_client_list, ADB_MSG_PRE_RESET, NULL);
+        nret = blocking_notifier_call_chain(&adb_client_list,
+                        ADB_MSG_PRE_RESET, NULL);
         if (nret & NOTIFY_STOP_MASK) {
                 if (adb_controller->autopoll)
                         adb_controller->autopoll(autopoll_devs);
@@ -426,7 +428,8 @@ do_adb_reset_bus(void)
         }
         up(&adb_handler_sem);
 
-        nret = notifier_call_chain(&adb_client_list, ADB_MSG_POST_RESET, NULL);
+        nret = blocking_notifier_call_chain(&adb_client_list,
+                        ADB_MSG_POST_RESET, NULL);
         if (nret & NOTIFY_STOP_MASK)
                 return -EBUSY;
         
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index c0b46bceb5df..f5779a73184d 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -1214,7 +1214,8 @@ static int __init adbhid_init(void)
 
         adbhid_probe();
 
-        notifier_chain_register(&adb_client_list, &adbhid_adb_notifier);
+        blocking_notifier_chain_register(&adb_client_list,
+                        &adbhid_adb_notifier);
 
         return 0;
 }
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index 4f5f3abc9cb3..0b5ff553e39a 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -187,7 +187,7 @@ extern int disable_kernel_backlight;
 
 int __fake_sleep;
 int asleep;
-struct notifier_block *sleep_notifier_list;
+BLOCKING_NOTIFIER_HEAD(sleep_notifier_list);
 
 #ifdef CONFIG_ADB
 static int adb_dev_map = 0;
diff --git a/drivers/macintosh/via-pmu68k.c b/drivers/macintosh/via-pmu68k.c
index f08e52f2107b..35b70323e7e3 100644
--- a/drivers/macintosh/via-pmu68k.c
+++ b/drivers/macintosh/via-pmu68k.c
@@ -102,7 +102,7 @@ static int pmu_kind = PMU_UNKNOWN;
 static int pmu_fully_inited = 0;
 
 int asleep;
-struct notifier_block *sleep_notifier_list;
+BLOCKING_NOTIFIER_HEAD(sleep_notifier_list);
 
 static int pmu_probe(void);
 static int pmu_init(void);
@@ -913,7 +913,8 @@ int powerbook_sleep(void)
         struct adb_request sleep_req;
 
         /* Notify device drivers */
-        ret = notifier_call_chain(&sleep_notifier_list, PBOOK_SLEEP, NULL);
+        ret = blocking_notifier_call_chain(&sleep_notifier_list,
+                        PBOOK_SLEEP, NULL);
         if (ret & NOTIFY_STOP_MASK)
                 return -EBUSY;
 
@@ -984,7 +985,7 @@ int powerbook_sleep(void)
                         enable_irq(i);
 
         /* Notify drivers */
-        notifier_call_chain(&sleep_notifier_list, PBOOK_WAKE, NULL);
+        blocking_notifier_call_chain(&sleep_notifier_list, PBOOK_WAKE, NULL);
 
         /* reenable ADB autopoll */
         pmu_adb_autopoll(adb_dev_map);
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 6c0ba04bc57a..ab3faa702d58 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -52,7 +52,7 @@
 static LIST_HEAD(wf_controls);
 static LIST_HEAD(wf_sensors);
 static DEFINE_MUTEX(wf_lock);
-static struct notifier_block *wf_client_list;
+static BLOCKING_NOTIFIER_HEAD(wf_client_list);
 static int wf_client_count;
 static unsigned int wf_overtemp;
 static unsigned int wf_overtemp_counter;
@@ -68,7 +68,7 @@ static struct platform_device wf_platform_device = {
 
 static inline void wf_notify(int event, void *param)
 {
-        notifier_call_chain(&wf_client_list, event, param);
+        blocking_notifier_call_chain(&wf_client_list, event, param);
 }
 
 int wf_critical_overtemp(void)
@@ -398,7 +398,7 @@ int wf_register_client(struct notifier_block *nb)
         struct wf_sensor *sr;
 
         mutex_lock(&wf_lock);
-        rc = notifier_chain_register(&wf_client_list, nb);
+        rc = blocking_notifier_chain_register(&wf_client_list, nb);
         if (rc != 0)
                 goto bail;
         wf_client_count++;
@@ -417,7 +417,7 @@ EXPORT_SYMBOL_GPL(wf_register_client);
 int wf_unregister_client(struct notifier_block *nb)
 {
         mutex_lock(&wf_lock);
-        notifier_chain_unregister(&wf_client_list, nb);
+        blocking_notifier_chain_unregister(&wf_client_list, nb);
         wf_client_count++;
         if (wf_client_count == 0)
                 wf_stop_thread();
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index ac43f98062fd..fd2aae150ccc 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -127,6 +127,32 @@ config MD_RAID5
 
           If unsure, say Y.
 
+config MD_RAID5_RESHAPE
+        bool "Support adding drives to a raid-5 array (experimental)"
+        depends on MD_RAID5 && EXPERIMENTAL
+        ---help---
+          A RAID-5 set can be expanded by adding extra drives. This
+          requires "restriping" the array which means (almost) every
+          block must be written to a different place.
+
+          This option allows such restriping to be done while the array
+          is online.  However it is still EXPERIMENTAL code.  It should
+          work, but please be sure that you have backups.
+
+          You will need a version of mdadm newer than 2.3.1.   During the
+          early stage of reshape there is a critical section where live data
+          is being over-written.  A crash during this time needs extra care
+          for recovery.  The newer mdadm takes a copy of the data in the
+          critical section and will restore it, if necessary, after a crash.
+
+          The mdadm usage is e.g.
+               mdadm --grow /dev/md1 --raid-disks=6
+          to grow '/dev/md1' to having 6 disks.
+
+          Note: The array can only be expanded, not contracted.
+          There should be enough spares already present to make the new
+          array workable.
+
 config MD_RAID6
         tristate "RAID-6 mode"
         depends on BLK_DEV_MD
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 259e86f26549..61a590bb6241 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -518,6 +518,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         char *ivopts;
         unsigned int crypto_flags;
         unsigned int key_size;
+        unsigned long long tmpll;
 
         if (argc != 5) {
                 ti->error = PFX "Not enough arguments";
@@ -633,15 +634,17 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad5;
         }
 
-        if (sscanf(argv[2], SECTOR_FORMAT, &cc->iv_offset) != 1) {
+        if (sscanf(argv[2], "%llu", &tmpll) != 1) {
                 ti->error = PFX "Invalid iv_offset sector";
                 goto bad5;
         }
+        cc->iv_offset = tmpll;
 
-        if (sscanf(argv[4], SECTOR_FORMAT, &cc->start) != 1) {
+        if (sscanf(argv[4], "%llu", &tmpll) != 1) {
                 ti->error = PFX "Invalid device sector";
                 goto bad5;
         }
+        cc->start = tmpll;
 
         if (dm_get_device(ti, argv[3], cc->start, ti->len,
                           dm_table_get_mode(ti->table), &cc->dev)) {
@@ -885,8 +888,8 @@ static int crypt_status(struct dm_target *ti, status_type_t type,
                         result[sz++] = '-';
                 }
 
-                DMEMIT(" " SECTOR_FORMAT " %s " SECTOR_FORMAT,
-                       cc->iv_offset, cc->dev->name, cc->start);
+                DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
+                                cc->dev->name, (unsigned long long)cc->start);
                 break;
         }
         return 0;
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 442e2be6052e..8edd6435414d 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -15,6 +15,7 @@
 #include <linux/slab.h>
 #include <linux/devfs_fs_kernel.h>
 #include <linux/dm-ioctl.h>
+#include <linux/hdreg.h>
 
 #include <asm/uaccess.h>
 
@@ -244,9 +245,9 @@ static void __hash_remove(struct hash_cell *hc)
                 dm_table_put(table);
         }
 
-        dm_put(hc->md);
         if (hc->new_map)
                 dm_table_put(hc->new_map);
+        dm_put(hc->md);
         free_cell(hc);
 }
 
@@ -600,12 +601,22 @@ static int dev_create(struct dm_ioctl *param, size_t param_size)
  */
 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
 {
+        struct mapped_device *md;
+        void *mdptr = NULL;
+
         if (*param->uuid)
                 return __get_uuid_cell(param->uuid);
-        else if (*param->name)
+
+        if (*param->name)
                 return __get_name_cell(param->name);
-        else
-                return dm_get_mdptr(huge_decode_dev(param->dev));
+
+        md = dm_get_md(huge_decode_dev(param->dev));
+        if (md) {
+                mdptr = dm_get_mdptr(md);
+                dm_put(md);
+        }
+
+        return mdptr;
 }
 
 static struct mapped_device *find_device(struct dm_ioctl *param)
@@ -690,6 +701,54 @@ static int dev_rename(struct dm_ioctl *param, size_t param_size)
         return dm_hash_rename(param->name, new_name);
 }
 
+static int dev_set_geometry(struct dm_ioctl *param, size_t param_size)
+{
+        int r = -EINVAL, x;
+        struct mapped_device *md;
+        struct hd_geometry geometry;
+        unsigned long indata[4];
+        char *geostr = (char *) param + param->data_start;
+
+        md = find_device(param);
+        if (!md)
+                return -ENXIO;
+
+        if (geostr < (char *) (param + 1) ||
+            invalid_str(geostr, (void *) param + param_size)) {
+                DMWARN("Invalid geometry supplied.");
+                goto out;
+        }
+
+        x = sscanf(geostr, "%lu %lu %lu %lu", indata,
+                   indata + 1, indata + 2, indata + 3);
+
+        if (x != 4) {
+                DMWARN("Unable to interpret geometry settings.");
+                goto out;
+        }
+
+        if (indata[0] > 65535 || indata[1] > 255 ||
+            indata[2] > 255 || indata[3] > ULONG_MAX) {
+                DMWARN("Geometry exceeds range limits.");
+                goto out;
+        }
+
+        geometry.cylinders = indata[0];
+        geometry.heads = indata[1];
+        geometry.sectors = indata[2];
+        geometry.start = indata[3];
+
+        r = dm_set_geometry(md, &geometry);
+        if (!r)
+                r = __dev_status(md, param);
+
+        param->data_size = 0;
+
+out:
+        dm_put(md);
+        return r;
+}
+
 static int do_suspend(struct dm_ioctl *param)
 {
         int r = 0;
@@ -975,33 +1034,43 @@ static int table_load(struct dm_ioctl *param, size_t param_size)
         int r;
         struct hash_cell *hc;
         struct dm_table *t;
+        struct mapped_device *md;
 
-        r = dm_table_create(&t, get_mode(param), param->target_count);
+        md = find_device(param);
+        if (!md)
+                return -ENXIO;
+
+        r = dm_table_create(&t, get_mode(param), param->target_count, md);
         if (r)
-                return r;
+                goto out;
 
         r = populate_table(t, param, param_size);
         if (r) {
                 dm_table_put(t);
-                return r;
+                goto out;
         }
 
         down_write(&_hash_lock);
-        hc = __find_device_hash_cell(param);
-        if (!hc) {
-                DMWARN("device doesn't appear to be in the dev hash table.");
-                up_write(&_hash_lock);
+        hc = dm_get_mdptr(md);
+        if (!hc || hc->md != md) {
+                DMWARN("device has been removed from the dev hash table.");
                 dm_table_put(t);
-                return -ENXIO;
+                up_write(&_hash_lock);
+                r = -ENXIO;
+                goto out;
         }
 
         if (hc->new_map)
                 dm_table_put(hc->new_map);
         hc->new_map = t;
+        up_write(&_hash_lock);
+
         param->flags |= DM_INACTIVE_PRESENT_FLAG;
+        r = __dev_status(md, param);
+
+out:
+        dm_put(md);
 
-        r = __dev_status(hc->md, param);
-        up_write(&_hash_lock);
         return r;
 }
 
@@ -1214,7 +1283,8 @@ static ioctl_fn lookup_ioctl(unsigned int cmd)
 
                 {DM_LIST_VERSIONS_CMD, list_versions},
 
-                {DM_TARGET_MSG_CMD, target_message}
+                {DM_TARGET_MSG_CMD, target_message},
+                {DM_DEV_SET_GEOMETRY_CMD, dev_set_geometry}
         };
 
         return (cmd >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[cmd].fn;
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 6a2cd5dc8a63..daf586c0898d 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -26,6 +26,7 @@ struct linear_c {
 static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
         struct linear_c *lc;
+        unsigned long long tmp;
 
         if (argc != 2) {
                 ti->error = "dm-linear: Invalid argument count";
@@ -38,10 +39,11 @@ static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 return -ENOMEM;
         }
 
-        if (sscanf(argv[1], SECTOR_FORMAT, &lc->start) != 1) {
+        if (sscanf(argv[1], "%llu", &tmp) != 1) {
                 ti->error = "dm-linear: Invalid device sector";
                 goto bad;
         }
+        lc->start = tmp;
 
         if (dm_get_device(ti, argv[0], lc->start, ti->len,
                           dm_table_get_mode(ti->table), &lc->dev)) {
@@ -87,8 +89,8 @@ static int linear_status(struct dm_target *ti, status_type_t type,
                 break;
 
         case STATUSTYPE_TABLE:
-                snprintf(result, maxlen, "%s " SECTOR_FORMAT, lc->dev->name,
-                         lc->start);
+                snprintf(result, maxlen, "%s %llu", lc->dev->name,
+                                (unsigned long long)lc->start);
                 break;
         }
         return 0;
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 4e90f231fbfb..d12cf3e5e076 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -402,9 +402,21 @@ static void rh_dec(struct region_hash *rh, region_t region)
 
         spin_lock_irqsave(&rh->region_lock, flags);
         if (atomic_dec_and_test(&reg->pending)) {
+                /*
+                 * There is no pending I/O for this region.
+                 * We can move the region to corresponding list for next action.
+                 * At this point, the region is not yet connected to any list.
+                 *
+                 * If the state is RH_NOSYNC, the region should be kept off
+                 * from clean list.
+                 * The hash entry for RH_NOSYNC will remain in memory
+                 * until the region is recovered or the map is reloaded.
+                 */
+
+                /* do nothing for RH_NOSYNC */
                 if (reg->state == RH_RECOVERING) {
                         list_add_tail(&reg->list, &rh->quiesced_regions);
-                } else {
+                } else if (reg->state == RH_DIRTY) {
                         reg->state = RH_CLEAN;
                         list_add(&reg->list, &rh->clean_regions);
                 }
@@ -922,9 +934,9 @@ static inline int _check_region_size(struct dm_target *ti, uint32_t size)
 static int get_mirror(struct mirror_set *ms, struct dm_target *ti,
                       unsigned int mirror, char **argv)
 {
-        sector_t offset;
+        unsigned long long offset;
 
-        if (sscanf(argv[1], SECTOR_FORMAT, &offset) != 1) {
+        if (sscanf(argv[1], "%llu", &offset) != 1) {
                 ti->error = "dm-mirror: Invalid offset";
                 return -EINVAL;
         }
@@ -1191,16 +1203,17 @@ static int mirror_status(struct dm_target *ti, status_type_t type,
                 for (m = 0; m < ms->nr_mirrors; m++)
                         DMEMIT("%s ", ms->mirror[m].dev->name);
 
-                DMEMIT(SECTOR_FORMAT "/" SECTOR_FORMAT,
-                       ms->rh.log->type->get_sync_count(ms->rh.log),
-                       ms->nr_regions);
+                DMEMIT("%llu/%llu",
+                        (unsigned long long)ms->rh.log->type->
+                                get_sync_count(ms->rh.log),
+                        (unsigned long long)ms->nr_regions);
                 break;
 
         case STATUSTYPE_TABLE:
                 DMEMIT("%d ", ms->nr_mirrors);
                 for (m = 0; m < ms->nr_mirrors; m++)
-                        DMEMIT("%s " SECTOR_FORMAT " ",
-                               ms->mirror[m].dev->name, ms->mirror[m].offset);
+                        DMEMIT("%s %llu ", ms->mirror[m].dev->name,
+                                (unsigned long long)ms->mirror[m].offset);
         }
 
         return 0;
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 7401540086df..08312b46463a 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -49,11 +49,26 @@ struct pending_exception {
         struct bio_list snapshot_bios;
 
         /*
-         * Other pending_exceptions that are processing this
-         * chunk.  When this list is empty, we know we can
-         * complete the origins.
+         * Short-term queue of pending exceptions prior to submission.
          */
-        struct list_head siblings;
+        struct list_head list;
+
+        /*
+         * The primary pending_exception is the one that holds
+         * the sibling_count and the list of origin_bios for a
+         * group of pending_exceptions.  It is always last to get freed.
+         * These fields get set up when writing to the origin.
+         */
+        struct pending_exception *primary_pe;
+
+        /*
+         * Number of pending_exceptions processing this chunk.
+         * When this drops to zero we must complete the origin bios.
+         * If incrementing or decrementing this, hold pe->snap->lock for
+         * the sibling concerned and not pe->primary_pe->snap->lock unless
+         * they are the same.
+         */
+        atomic_t sibling_count;
 
         /* Pointer back to snapshot context */
         struct dm_snapshot *snap;
@@ -377,6 +392,8 @@ static void read_snapshot_metadata(struct dm_snapshot *s)
                 down_write(&s->lock);
                 s->valid = 0;
                 up_write(&s->lock);
+
+                dm_table_event(s->table);
         }
 }
 
@@ -542,8 +559,12 @@ static void snapshot_dtr(struct dm_target *ti)
 {
         struct dm_snapshot *s = (struct dm_snapshot *) ti->private;
 
+        /* Prevent further origin writes from using this snapshot. */
+        /* After this returns there can be no new kcopyd jobs. */
         unregister_snapshot(s);
 
+        kcopyd_client_destroy(s->kcopyd_client);
+
         exit_exception_table(&s->pending, pending_cache);
         exit_exception_table(&s->complete, exception_cache);
 
@@ -552,7 +573,7 @@ static void snapshot_dtr(struct dm_target *ti)
 
         dm_put_device(ti, s->origin);
         dm_put_device(ti, s->cow);
-        kcopyd_client_destroy(s->kcopyd_client);
+
         kfree(s);
 }
 
@@ -586,78 +607,117 @@ static void error_bios(struct bio *bio)
         }
 }
 
+static inline void error_snapshot_bios(struct pending_exception *pe)
+{
+        error_bios(bio_list_get(&pe->snapshot_bios));
+}
+
 static struct bio *__flush_bios(struct pending_exception *pe)
 {
-        struct pending_exception *sibling;
+        /*
+         * If this pe is involved in a write to the origin and
+         * it is the last sibling to complete then release
+         * the bios for the original write to the origin.
+         */
+
+        if (pe->primary_pe &&
+            atomic_dec_and_test(&pe->primary_pe->sibling_count))
+                return bio_list_get(&pe->primary_pe->origin_bios);
+
+        return NULL;
+}
+
+static void __invalidate_snapshot(struct dm_snapshot *s,
+                                struct pending_exception *pe, int err)
+{
+        if (!s->valid)
+                return;
 
-        if (list_empty(&pe->siblings))
-                return bio_list_get(&pe->origin_bios);
+        if (err == -EIO)
+                DMERR("Invalidating snapshot: Error reading/writing.");
+        else if (err == -ENOMEM)
+                DMERR("Invalidating snapshot: Unable to allocate exception.");
 
-        sibling = list_entry(pe->siblings.next,
-                             struct pending_exception, siblings);
+        if (pe)
+                remove_exception(&pe->e);
 
-        list_del(&pe->siblings);
+        if (s->store.drop_snapshot)
+                s->store.drop_snapshot(&s->store);
 
-        /* This is fine as long as kcopyd is single-threaded. If kcopyd
-         * becomes multi-threaded, we'll need some locking here.
-         */
-        bio_list_merge(&sibling->origin_bios, &pe->origin_bios);
+        s->valid = 0;
 
-        return NULL;
+        dm_table_event(s->table);
 }
 
 static void pending_complete(struct pending_exception *pe, int success)
 {
         struct exception *e;
+        struct pending_exception *primary_pe;
         struct dm_snapshot *s = pe->snap;
         struct bio *flush = NULL;
 
-        if (success) {
-                e = alloc_exception();
-                if (!e) {
-                        DMWARN("Unable to allocate exception.");
-                        down_write(&s->lock);
-                        s->store.drop_snapshot(&s->store);
-                        s->valid = 0;
-                        flush = __flush_bios(pe);
-                        up_write(&s->lock);
-
-                        error_bios(bio_list_get(&pe->snapshot_bios));
-                        goto out;
-                }
-                *e = pe->e;
-
-                /*
-                 * Add a proper exception, and remove the
-                 * in-flight exception from the list.
-                 */
+        if (!success) {
+                /* Read/write error - snapshot is unusable */
                 down_write(&s->lock);
-                insert_exception(&s->complete, e);
-                remove_exception(&pe->e);
+                __invalidate_snapshot(s, pe, -EIO);
                 flush = __flush_bios(pe);
-
-                /* Submit any pending write bios */
                 up_write(&s->lock);
 
-                flush_bios(bio_list_get(&pe->snapshot_bios));
-        } else {
-                /* Read/write error - snapshot is unusable */
+                error_snapshot_bios(pe);
+                goto out;
+        }
+
+        e = alloc_exception();
+        if (!e) {
                 down_write(&s->lock);
-                if (s->valid)
-                        DMERR("Error reading/writing snapshot");
-                s->store.drop_snapshot(&s->store);
-                s->valid = 0;
-                remove_exception(&pe->e);
+                __invalidate_snapshot(s, pe, -ENOMEM);
                 flush = __flush_bios(pe);
                 up_write(&s->lock);
 
-                error_bios(bio_list_get(&pe->snapshot_bios));
+                error_snapshot_bios(pe);
+                goto out;
+        }
+        *e = pe->e;
 
-                dm_table_event(s->table);
+        /*
+         * Add a proper exception, and remove the
+         * in-flight exception from the list.
+         */
+        down_write(&s->lock);
+        if (!s->valid) {
+                flush = __flush_bios(pe);
+                up_write(&s->lock);
+
+                free_exception(e);
+
+                error_snapshot_bios(pe);
+                goto out;
         }
 
+        insert_exception(&s->complete, e);
+        remove_exception(&pe->e);
+        flush = __flush_bios(pe);
+
+        up_write(&s->lock);
+
+        /* Submit any pending write bios */
+        flush_bios(bio_list_get(&pe->snapshot_bios));
+
  out:
-        free_pending_exception(pe);
+        primary_pe = pe->primary_pe;
+
+        /*
+         * Free the pe if it's not linked to an origin write or if
+         * it's not itself a primary pe.
+         */
+        if (!primary_pe || primary_pe != pe)
+                free_pending_exception(pe);
+
+        /*
+         * Free the primary pe if nothing references it.
+         */
+        if (primary_pe && !atomic_read(&primary_pe->sibling_count))
+                free_pending_exception(primary_pe);
 
         if (flush)
                 flush_bios(flush);
@@ -734,38 +794,45 @@ __find_pending_exception(struct dm_snapshot *s, struct bio *bio)
         if (e) {
                 /* cast the exception to a pending exception */
                 pe = container_of(e, struct pending_exception, e);
+                goto out;
+        }
 
-        } else {
-                /*
-                 * Create a new pending exception, we don't want
-                 * to hold the lock while we do this.
-                 */
-                up_write(&s->lock);
-                pe = alloc_pending_exception();
-                down_write(&s->lock);
+        /*
+         * Create a new pending exception, we don't want
+         * to hold the lock while we do this.
+         */
+        up_write(&s->lock);
+        pe = alloc_pending_exception();
+        down_write(&s->lock);
 
-                e = lookup_exception(&s->pending, chunk);
-                if (e) {
-                        free_pending_exception(pe);
-                        pe = container_of(e, struct pending_exception, e);
-                } else {
-                        pe->e.old_chunk = chunk;
-                        bio_list_init(&pe->origin_bios);
-                        bio_list_init(&pe->snapshot_bios);
-                        INIT_LIST_HEAD(&pe->siblings);
-                        pe->snap = s;
-                        pe->started = 0;
-
-                        if (s->store.prepare_exception(&s->store, &pe->e)) {
-                                free_pending_exception(pe);
-                                s->valid = 0;
-                                return NULL;
-                        }
+        if (!s->valid) {
+                free_pending_exception(pe);
+                return NULL;
+        }
 
-                        insert_exception(&s->pending, &pe->e);
-                }
+        e = lookup_exception(&s->pending, chunk);
+        if (e) {
+                free_pending_exception(pe);
+                pe = container_of(e, struct pending_exception, e);
+                goto out;
+        }
+
+        pe->e.old_chunk = chunk;
+        bio_list_init(&pe->origin_bios);
+        bio_list_init(&pe->snapshot_bios);
+        pe->primary_pe = NULL;
+        atomic_set(&pe->sibling_count, 1);
+        pe->snap = s;
+        pe->started = 0;
+
+        if (s->store.prepare_exception(&s->store, &pe->e)) {
+                free_pending_exception(pe);
+                return NULL;
         }
 
+        insert_exception(&s->pending, &pe->e);
+
+ out:
         return pe;
 }
 
@@ -782,13 +849,15 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
 {
         struct exception *e;
         struct dm_snapshot *s = (struct dm_snapshot *) ti->private;
+        int copy_needed = 0;
         int r = 1;
         chunk_t chunk;
-        struct pending_exception *pe;
+        struct pending_exception *pe = NULL;
 
         chunk = sector_to_chunk(s, bio->bi_sector);
 
         /* Full snapshots are not usable */
+        /* To get here the table must be live so s->active is always set. */
         if (!s->valid)
                 return -EIO;
 
@@ -806,36 +875,41 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                  * to copy an exception */
                 down_write(&s->lock);
 
+                if (!s->valid) {
+                        r = -EIO;
+                        goto out_unlock;
+                }
+
                 /* If the block is already remapped - use that, else remap it */
                 e = lookup_exception(&s->complete, chunk);
                 if (e) {
                         remap_exception(s, e, bio);
-                        up_write(&s->lock);
-
-                } else {
-                        pe = __find_pending_exception(s, bio);
-
-                        if (!pe) {
-                                if (s->store.drop_snapshot)
-                                        s->store.drop_snapshot(&s->store);
-                                s->valid = 0;
-                                r = -EIO;
-                                up_write(&s->lock);
-                        } else {
-                                remap_exception(s, &pe->e, bio);
-                                bio_list_add(&pe->snapshot_bios, bio);
-
-                                if (!pe->started) {
-                                        /* this is protected by snap->lock */
-                                        pe->started = 1;
-                                        up_write(&s->lock);
-                                        start_copy(pe);
-                                } else
-                                        up_write(&s->lock);
-                                r = 0;
-                        }
+                        goto out_unlock;
+                }
+
+                pe = __find_pending_exception(s, bio);
+                if (!pe) {
+                        __invalidate_snapshot(s, pe, -ENOMEM);
+                        r = -EIO;
+                        goto out_unlock;
+                }
+
+                remap_exception(s, &pe->e, bio);
+                bio_list_add(&pe->snapshot_bios, bio);
+
+                if (!pe->started) {
+                        /* this is protected by snap->lock */
+                        pe->started = 1;
+                        copy_needed = 1;
                 }
 
+                r = 0;
+
+ out_unlock:
+                up_write(&s->lock);
+
+                if (copy_needed)
+                        start_copy(pe);
         } else {
                 /*
                  * FIXME: this read path scares me because we
@@ -847,6 +921,11 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                 /* Do reads */
                 down_read(&s->lock);
 
+                if (!s->valid) {
+                        up_read(&s->lock);
+                        return -EIO;
+                }
+
                 /* See if it it has been remapped */
                 e = lookup_exception(&s->complete, chunk);
                 if (e)
@@ -884,9 +963,9 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
                                 snap->store.fraction_full(&snap->store,
                                                           &numerator,
                                                           &denominator);
-                                snprintf(result, maxlen,
-                                         SECTOR_FORMAT "/" SECTOR_FORMAT,
-                                         numerator, denominator);
+                                snprintf(result, maxlen, "%llu/%llu",
+                                        (unsigned long long)numerator,
+                                        (unsigned long long)denominator);
                         }
                         else
                                 snprintf(result, maxlen, "Unknown");
@@ -899,9 +978,10 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
                  * to make private copies if the output is to
                  * make sense.
                  */
-                snprintf(result, maxlen, "%s %s %c " SECTOR_FORMAT,
+                snprintf(result, maxlen, "%s %s %c %llu",
                          snap->origin->name, snap->cow->name,
-                         snap->type, snap->chunk_size);
+                         snap->type,
+                         (unsigned long long)snap->chunk_size);
                 break;
         }
 
@@ -911,40 +991,27 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
 /*-----------------------------------------------------------------
  * Origin methods
  *---------------------------------------------------------------*/
-static void list_merge(struct list_head *l1, struct list_head *l2)
-{
-        struct list_head *l1_n, *l2_p;
-
-        l1_n = l1->next;
-        l2_p = l2->prev;
-
-        l1->next = l2;
-        l2->prev = l1;
-
-        l2_p->next = l1_n;
-        l1_n->prev = l2_p;
-}
-
 static int __origin_write(struct list_head *snapshots, struct bio *bio)
 {
-        int r = 1, first = 1;
+        int r = 1, first = 0;
         struct dm_snapshot *snap;
         struct exception *e;
-        struct pending_exception *pe, *last = NULL;
+        struct pending_exception *pe, *next_pe, *primary_pe = NULL;
         chunk_t chunk;
+        LIST_HEAD(pe_queue);
 
         /* Do all the snapshots on this origin */
         list_for_each_entry (snap, snapshots, list) {
 
+                down_write(&snap->lock);
+
                 /* Only deal with valid and active snapshots */
                 if (!snap->valid || !snap->active)
-                        continue;
+                        goto next_snapshot;
 
                 /* Nothing to do if writing beyond end of snapshot */
                 if (bio->bi_sector >= dm_table_get_size(snap->table))
-                        continue;
-
-                down_write(&snap->lock);
+                        goto next_snapshot;
 
                 /*
                  * Remember, different snapshots can have
@@ -956,49 +1023,75 @@ static int __origin_write(struct list_head *snapshots, struct bio *bio)
                  * Check exception table to see if block
                  * is already remapped in this snapshot
                  * and trigger an exception if not.
+                 *
+                 * sibling_count is initialised to 1 so pending_complete()
+                 * won't destroy the primary_pe while we're inside this loop.
                  */
                 e = lookup_exception(&snap->complete, chunk);
-                if (!e) {
-                        pe = __find_pending_exception(snap, bio);
-                        if (!pe) {
-                                snap->store.drop_snapshot(&snap->store);
-                                snap->valid = 0;
-
-                        } else {
-                                if (last)
-                                        list_merge(&pe->siblings,
-                                                   &last->siblings);
-
-                                last = pe;
-                                r = 0;
+                if (e)
+                        goto next_snapshot;
+
+                pe = __find_pending_exception(snap, bio);
+                if (!pe) {
+                        __invalidate_snapshot(snap, pe, ENOMEM);
+                        goto next_snapshot;
+                }
+
+                if (!primary_pe) {
+                        /*
+                         * Either every pe here has same
+                         * primary_pe or none has one yet.
+                         */
+                        if (pe->primary_pe)
+                                primary_pe = pe->primary_pe;
+                        else {
+                                primary_pe = pe;
+                                first = 1;
                         }
+
+                        bio_list_add(&primary_pe->origin_bios, bio);
+
+                        r = 0;
+                }
+
+                if (!pe->primary_pe) {
+                        atomic_inc(&primary_pe->sibling_count);
+                        pe->primary_pe = primary_pe;
+                }
+
+                if (!pe->started) {
+                        pe->started = 1;
+                        list_add_tail(&pe->list, &pe_queue);
                 }
 
+ next_snapshot:
                 up_write(&snap->lock);
         }
 
+        if (!primary_pe)
+                goto out;
+
         /*
-         * Now that we have a complete pe list we can start the copying.
+         * If this is the first time we're processing this chunk and
+         * sibling_count is now 1 it means all the pending exceptions
+         * got completed while we were in the loop above, so it falls to
+         * us here to remove the primary_pe and submit any origin_bios.
          */
-        if (last) {
-                pe = last;
-                do {
-                        down_write(&pe->snap->lock);
-                        if (first)
-                                bio_list_add(&pe->origin_bios, bio);
-                        if (!pe->started) {
-                                pe->started = 1;
-                                up_write(&pe->snap->lock);
-                                start_copy(pe);
-                        } else
-                                up_write(&pe->snap->lock);
-                        first = 0;
-                        pe = list_entry(pe->siblings.next,
-                                        struct pending_exception, siblings);
-
-                } while (pe != last);
+
+        if (first && atomic_dec_and_test(&primary_pe->sibling_count)) {
+                flush_bios(bio_list_get(&primary_pe->origin_bios));
+                free_pending_exception(primary_pe);
+                /* If we got here, pe_queue is necessarily empty. */
+                goto out;
         }
 
+        /*
+         * Now that we have a complete pe list we can start the copying.
+         */
+        list_for_each_entry_safe(pe, next_pe, &pe_queue, list)
+                start_copy(pe);
+
+ out:
         return r;
 }
 
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 697aacafb02a..08328a8f5a3c 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -49,9 +49,9 @@ static inline struct stripe_c *alloc_context(unsigned int stripes)
 static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
                       unsigned int stripe, char **argv)
 {
-        sector_t start;
+        unsigned long long start;
 
-        if (sscanf(argv[1], SECTOR_FORMAT, &start) != 1)
+        if (sscanf(argv[1], "%llu", &start) != 1)
                 return -EINVAL;
 
         if (dm_get_device(ti, argv[0], start, sc->stripe_width,
@@ -103,7 +103,7 @@ static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 return -EINVAL;
         }
 
-        if (((uint32_t)ti->len) & (chunk_size - 1)) {
+        if (ti->len & (chunk_size - 1)) {
                 ti->error = "dm-stripe: Target length not divisible by "
                     "chunk size";
                 return -EINVAL;
@@ -201,10 +201,11 @@ static int stripe_status(struct dm_target *ti,
                 break;
 
         case STATUSTYPE_TABLE:
-                DMEMIT("%d " SECTOR_FORMAT, sc->stripes, sc->chunk_mask + 1);
+                DMEMIT("%d %llu", sc->stripes,
+                        (unsigned long long)sc->chunk_mask + 1);
                 for (i = 0; i < sc->stripes; i++)
-                        DMEMIT(" %s " SECTOR_FORMAT, sc->stripe[i].dev->name,
-                               sc->stripe[i].physical_start);
+                        DMEMIT(" %s %llu", sc->stripe[i].dev->name,
+                            (unsigned long long)sc->stripe[i].physical_start);
                 break;
         }
         return 0;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 907b08ddb783..8f56a54cf0ce 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -14,6 +14,7 @@
 #include <linux/ctype.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
+#include <linux/mutex.h>
 #include <asm/atomic.h>
 
 #define MAX_DEPTH 16
@@ -22,6 +23,7 @@
 #define CHILDREN_PER_NODE (KEYS_PER_NODE + 1)
 
 struct dm_table {
+        struct mapped_device *md;
         atomic_t holders;
 
         /* btree table */
@@ -97,6 +99,8 @@ static void combine_restrictions_low(struct io_restrictions *lhs,
 
         lhs->seg_boundary_mask =
                 min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask);
+
+        lhs->no_cluster |= rhs->no_cluster;
 }
 
 /*
@@ -204,7 +208,8 @@ static int alloc_targets(struct dm_table *t, unsigned int num)
         return 0;
 }
 
-int dm_table_create(struct dm_table **result, int mode, unsigned num_targets)
+int dm_table_create(struct dm_table **result, int mode,
+                    unsigned num_targets, struct mapped_device *md)
 {
         struct dm_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
 
@@ -227,6 +232,7 @@ int dm_table_create(struct dm_table **result, int mode, unsigned num_targets)
         }
 
         t->mode = mode;
+        t->md = md;
         *result = t;
         return 0;
 }
@@ -345,7 +351,7 @@ static struct dm_dev *find_device(struct list_head *l, dev_t dev)
 /*
  * Open a device so we can use it as a map destination.
  */
-static int open_dev(struct dm_dev *d, dev_t dev)
+static int open_dev(struct dm_dev *d, dev_t dev, struct mapped_device *md)
 {
         static char *_claim_ptr = "I belong to device-mapper";
         struct block_device *bdev;
@@ -357,7 +363,7 @@ static int open_dev(struct dm_dev *d, dev_t dev)
         bdev = open_by_devnum(dev, d->mode);
         if (IS_ERR(bdev))
                 return PTR_ERR(bdev);
-        r = bd_claim(bdev, _claim_ptr);
+        r = bd_claim_by_disk(bdev, _claim_ptr, dm_disk(md));
         if (r)
                 blkdev_put(bdev);
         else
@@ -368,12 +374,12 @@ static int open_dev(struct dm_dev *d, dev_t dev)
 /*
  * Close a device that we've been using.
  */
-static void close_dev(struct dm_dev *d)
+static void close_dev(struct dm_dev *d, struct mapped_device *md)
 {
         if (!d->bdev)
                 return;
 
-        bd_release(d->bdev);
+        bd_release_from_disk(d->bdev, dm_disk(md));
         blkdev_put(d->bdev);
         d->bdev = NULL;
 }
@@ -394,7 +400,7 @@ static int check_device_area(struct dm_dev *dd, sector_t start, sector_t len)
  * careful to leave things as they were if we fail to reopen the
  * device.
  */
-static int upgrade_mode(struct dm_dev *dd, int new_mode)
+static int upgrade_mode(struct dm_dev *dd, int new_mode, struct mapped_device *md)
 {
         int r;
         struct dm_dev dd_copy;
@@ -404,9 +410,9 @@ static int upgrade_mode(struct dm_dev *dd, int new_mode)
 
         dd->mode |= new_mode;
         dd->bdev = NULL;
-        r = open_dev(dd, dev);
+        r = open_dev(dd, dev, md);
         if (!r)
-                close_dev(&dd_copy);
+                close_dev(&dd_copy, md);
         else
                 *dd = dd_copy;
 
@@ -448,7 +454,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
                 dd->mode = mode;
                 dd->bdev = NULL;
 
-                if ((r = open_dev(dd, dev))) {
+                if ((r = open_dev(dd, dev, t->md))) {
                         kfree(dd);
                         return r;
                 }
@@ -459,7 +465,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
                 list_add(&dd->list, &t->devices);
 
         } else if (dd->mode != (mode | dd->mode)) {
-                r = upgrade_mode(dd, mode);
+                r = upgrade_mode(dd, mode, t->md);
                 if (r)
                         return r;
         }
@@ -523,6 +529,8 @@ int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
                 rs->seg_boundary_mask =
                         min_not_zero(rs->seg_boundary_mask,
                                      q->seg_boundary_mask);
+
+                rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
         }
 
         return r;
@@ -534,7 +542,7 @@ int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
 void dm_put_device(struct dm_target *ti, struct dm_dev *dd)
 {
         if (atomic_dec_and_test(&dd->count)) {
-                close_dev(dd);
+                close_dev(dd, ti->table->md);
                 list_del(&dd->list);
                 kfree(dd);
         }
@@ -763,14 +771,14 @@ int dm_table_complete(struct dm_table *t)
         return r;
 }
 
-static DECLARE_MUTEX(_event_lock);
+static DEFINE_MUTEX(_event_lock);
 void dm_table_event_callback(struct dm_table *t,
                              void (*fn)(void *), void *context)
 {
-        down(&_event_lock);
+        mutex_lock(&_event_lock);
         t->event_fn = fn;
         t->event_context = context;
-        up(&_event_lock);
+        mutex_unlock(&_event_lock);
 }
 
 void dm_table_event(struct dm_table *t)
@@ -781,10 +789,10 @@ void dm_table_event(struct dm_table *t)
          */
         BUG_ON(in_interrupt());
 
-        down(&_event_lock);
+        mutex_lock(&_event_lock);
         if (t->event_fn)
                 t->event_fn(t->event_context);
-        up(&_event_lock);
+        mutex_unlock(&_event_lock);
 }
 
 sector_t dm_table_get_size(struct dm_table *t)
@@ -832,6 +840,11 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
         q->hardsect_size = t->limits.hardsect_size;
         q->max_segment_size = t->limits.max_segment_size;
         q->seg_boundary_mask = t->limits.seg_boundary_mask;
+        if (t->limits.no_cluster)
+                q->queue_flags &= ~(1 << QUEUE_FLAG_CLUSTER);
+        else
+                q->queue_flags |= (1 << QUEUE_FLAG_CLUSTER);
+
 }
 
 unsigned int dm_table_get_num_targets(struct dm_table *t)
@@ -943,12 +956,20 @@ int dm_table_flush_all(struct dm_table *t)
         return ret;
 }
 
+struct mapped_device *dm_table_get_md(struct dm_table *t)
+{
+        dm_get(t->md);
+
+        return t->md;
+}
+
 EXPORT_SYMBOL(dm_vcalloc);
 EXPORT_SYMBOL(dm_get_device);
 EXPORT_SYMBOL(dm_put_device);
 EXPORT_SYMBOL(dm_table_event);
 EXPORT_SYMBOL(dm_table_get_size);
 EXPORT_SYMBOL(dm_table_get_mode);
+EXPORT_SYMBOL(dm_table_get_md);
 EXPORT_SYMBOL(dm_table_put);
 EXPORT_SYMBOL(dm_table_get);
 EXPORT_SYMBOL(dm_table_unplug_all);
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index a64798ef481e..4d710b7a133b 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -10,6 +10,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/moduleparam.h>
 #include <linux/blkpg.h>
 #include <linux/bio.h>
@@ -17,6 +18,7 @@
 #include <linux/mempool.h>
 #include <linux/slab.h>
 #include <linux/idr.h>
+#include <linux/hdreg.h>
 #include <linux/blktrace_api.h>
 
 static const char *_name = DM_NAME;
@@ -69,6 +71,7 @@ struct mapped_device {
 
         request_queue_t *queue;
         struct gendisk *disk;
+        char name[16];
 
         void *interface_ptr;
 
@@ -101,6 +104,9 @@ struct mapped_device {
          */
         struct super_block *frozen_sb;
         struct block_device *suspended_bdev;
+
+        /* forced geometry settings */
+        struct hd_geometry geometry;
 };
 
 #define MIN_IOS 256
@@ -226,6 +232,13 @@ static int dm_blk_close(struct inode *inode, struct file *file)
         return 0;
 }
 
+static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
+{
+        struct mapped_device *md = bdev->bd_disk->private_data;
+
+        return dm_get_geometry(md, geo);
+}
+
 static inline struct dm_io *alloc_io(struct mapped_device *md)
 {
         return mempool_alloc(md->io_pool, GFP_NOIO);
@@ -312,6 +325,33 @@ struct dm_table *dm_get_table(struct mapped_device *md)
         return t;
 }
 
+/*
+ * Get the geometry associated with a dm device
+ */
+int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo)
+{
+        *geo = md->geometry;
+
+        return 0;
+}
+
+/*
+ * Set the geometry of a device.
+ */
+int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo)
+{
+        sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
+
+        if (geo->start > sz) {
+                DMWARN("Start sector is beyond the geometry limits.");
+                return -EINVAL;
+        }
+
+        md->geometry = *geo;
+
+        return 0;
+}
+
 /*-----------------------------------------------------------------
  * CRUD START:
  *   A more elegant soln is in the works that uses the queue
@@ -704,14 +744,14 @@ static int dm_any_congested(void *congested_data, int bdi_bits)
 /*-----------------------------------------------------------------
  * An IDR is used to keep track of allocated minor numbers.
  *---------------------------------------------------------------*/
-static DECLARE_MUTEX(_minor_lock);
+static DEFINE_MUTEX(_minor_lock);
 static DEFINE_IDR(_minor_idr);
 
 static void free_minor(unsigned int minor)
 {
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
         idr_remove(&_minor_idr, minor);
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
 }
 
 /*
@@ -724,7 +764,7 @@ static int specific_minor(struct mapped_device *md, unsigned int minor)
         if (minor >= (1 << MINORBITS))
                 return -EINVAL;
 
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
 
         if (idr_find(&_minor_idr, minor)) {
                 r = -EBUSY;
@@ -749,7 +789,7 @@ static int specific_minor(struct mapped_device *md, unsigned int minor)
         }
 
 out:
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
         return r;
 }
 
@@ -758,7 +798,7 @@ static int next_free_minor(struct mapped_device *md, unsigned int *minor)
         int r;
         unsigned int m;
 
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
 
         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
         if (!r) {
@@ -780,7 +820,7 @@ static int next_free_minor(struct mapped_device *md, unsigned int *minor)
         *minor = m;
 
 out:
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
         return r;
 }
 
@@ -842,6 +882,7 @@ static struct mapped_device *alloc_dev(unsigned int minor, int persistent)
         md->disk->private_data = md;
         sprintf(md->disk->disk_name, "dm-%d", minor);
         add_disk(md->disk);
+        format_dev_t(md->name, MKDEV(_major, minor));
 
         atomic_set(&md->pending, 0);
         init_waitqueue_head(&md->wait);
@@ -904,6 +945,13 @@ static int __bind(struct mapped_device *md, struct dm_table *t)
         sector_t size;
 
         size = dm_table_get_size(t);
+
+        /*
+         * Wipe any geometry if the size of the table changed.
+         */
+        if (size != get_capacity(md->disk))
+                memset(&md->geometry, 0, sizeof(md->geometry));
+
         __set_size(md, size);
         if (size == 0)
                 return 0;
@@ -967,13 +1015,13 @@ static struct mapped_device *dm_find_md(dev_t dev)
         if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
                 return NULL;
 
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
 
         md = idr_find(&_minor_idr, minor);
         if (!md || (dm_disk(md)->first_minor != minor))
                 md = NULL;
 
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
 
         return md;
 }
@@ -988,15 +1036,9 @@ struct mapped_device *dm_get_md(dev_t dev)
         return md;
 }
 
-void *dm_get_mdptr(dev_t dev)
+void *dm_get_mdptr(struct mapped_device *md)
 {
-        struct mapped_device *md;
-        void *mdptr = NULL;
-
-        md = dm_find_md(dev);
-        if (md)
-                mdptr = md->interface_ptr;
-        return mdptr;
+        return md->interface_ptr;
 }
 
 void dm_set_mdptr(struct mapped_device *md, void *ptr)
@@ -1011,18 +1053,18 @@ void dm_get(struct mapped_device *md)
 
 void dm_put(struct mapped_device *md)
 {
-        struct dm_table *map = dm_get_table(md);
+        struct dm_table *map;
 
         if (atomic_dec_and_test(&md->holders)) {
+                map = dm_get_table(md);
                 if (!dm_suspended(md)) {
                         dm_table_presuspend_targets(map);
                         dm_table_postsuspend_targets(map);
                 }
                 __unbind(md);
+                dm_table_put(map);
                 free_dev(md);
         }
-
-        dm_table_put(map);
 }
 
 /*
@@ -1107,6 +1149,7 @@ int dm_suspend(struct mapped_device *md, int do_lockfs)
 {
         struct dm_table *map = NULL;
         DECLARE_WAITQUEUE(wait, current);
+        struct bio *def;
         int r = -EINVAL;
 
         down(&md->suspend_lock);
@@ -1166,9 +1209,11 @@ int dm_suspend(struct mapped_device *md, int do_lockfs)
         /* were we interrupted ? */
         r = -EINTR;
         if (atomic_read(&md->pending)) {
+                clear_bit(DMF_BLOCK_IO, &md->flags);
+                def = bio_list_get(&md->deferred);
+                __flush_deferred_io(md, def);
                 up_write(&md->io_lock);
                 unlock_fs(md);
-                clear_bit(DMF_BLOCK_IO, &md->flags);
                 goto out;
         }
         up_write(&md->io_lock);
@@ -1262,6 +1307,7 @@ int dm_suspended(struct mapped_device *md)
 static struct block_device_operations dm_blk_dops = {
         .open = dm_blk_open,
         .release = dm_blk_close,
+        .getgeo = dm_blk_getgeo,
         .owner = THIS_MODULE
 };
 
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 4eaf075da217..fd90bc8f9e45 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -14,6 +14,7 @@
 #include <linux/device-mapper.h>
 #include <linux/list.h>
 #include <linux/blkdev.h>
+#include <linux/hdreg.h>
 
 #define DM_NAME "device-mapper"
 #define DMWARN(f, x...) printk(KERN_WARNING DM_NAME ": " f "\n" , ## x)
@@ -23,16 +24,6 @@
 #define DMEMIT(x...) sz += ((sz >= maxlen) ? \
                           0 : scnprintf(result + sz, maxlen - sz, x))
 
-/*
- * FIXME: I think this should be with the definition of sector_t
- * in types.h.
- */
-#ifdef CONFIG_LBD
-#define SECTOR_FORMAT "%llu"
-#else
-#define SECTOR_FORMAT "%lu"
-#endif
-
 #define SECTOR_SHIFT 9
 
 /*
@@ -57,7 +48,7 @@ struct mapped_device;
 int dm_create(struct mapped_device **md);
 int dm_create_with_minor(unsigned int minor, struct mapped_device **md);
 void dm_set_mdptr(struct mapped_device *md, void *ptr);
-void *dm_get_mdptr(dev_t dev);
+void *dm_get_mdptr(struct mapped_device *md);
 struct mapped_device *dm_get_md(dev_t dev);
 
 /*
@@ -95,11 +86,18 @@ int dm_wait_event(struct mapped_device *md, int event_nr);
 struct gendisk *dm_disk(struct mapped_device *md);
 int dm_suspended(struct mapped_device *md);
 
+/*
+ * Geometry functions.
+ */
+int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
+int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
+
 /*-----------------------------------------------------------------
  * Functions for manipulating a table.  Tables are also reference
  * counted.
  *---------------------------------------------------------------*/
-int dm_table_create(struct dm_table **result, int mode, unsigned num_targets);
+int dm_table_create(struct dm_table **result, int mode,
+                    unsigned num_targets, struct mapped_device *md);
 
 void dm_table_get(struct dm_table *t);
 void dm_table_put(struct dm_table *t);
@@ -117,6 +115,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q);
 unsigned int dm_table_get_num_targets(struct dm_table *t);
 struct list_head *dm_table_get_devices(struct dm_table *t);
 int dm_table_get_mode(struct dm_table *t);
+struct mapped_device *dm_table_get_md(struct dm_table *t);
 void dm_table_presuspend_targets(struct dm_table *t);
 void dm_table_postsuspend_targets(struct dm_table *t);
 void dm_table_resume_targets(struct dm_table *t);
diff --git a/drivers/md/kcopyd.c b/drivers/md/kcopyd.c
index 9dcb2c8a3853..72480a48d88b 100644
--- a/drivers/md/kcopyd.c
+++ b/drivers/md/kcopyd.c
@@ -22,6 +22,7 @@
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
+#include <linux/mutex.h>
 
 #include "kcopyd.h"
 
@@ -44,6 +45,9 @@ struct kcopyd_client {
         struct page_list *pages;
         unsigned int nr_pages;
         unsigned int nr_free_pages;
+
+        wait_queue_head_t destroyq;
+        atomic_t nr_jobs;
 };
 
 static struct page_list *alloc_pl(void)
@@ -292,10 +296,15 @@ static int run_complete_job(struct kcopyd_job *job)
         int read_err = job->read_err;
         unsigned int write_err = job->write_err;
         kcopyd_notify_fn fn = job->fn;
+        struct kcopyd_client *kc = job->kc;
 
-        kcopyd_put_pages(job->kc, job->pages);
+        kcopyd_put_pages(kc, job->pages);
         mempool_free(job, _job_pool);
         fn(read_err, write_err, context);
+
+        if (atomic_dec_and_test(&kc->nr_jobs))
+                wake_up(&kc->destroyq);
+
         return 0;
 }
 
@@ -430,6 +439,7 @@ static void do_work(void *ignored)
  */
 static void dispatch_job(struct kcopyd_job *job)
 {
+        atomic_inc(&job->kc->nr_jobs);
         push(&_pages_jobs, job);
         wake();
 }
@@ -572,21 +582,21 @@ int kcopyd_cancel(struct kcopyd_job *job, int block)
 /*-----------------------------------------------------------------
  * Unit setup
  *---------------------------------------------------------------*/
-static DECLARE_MUTEX(_client_lock);
+static DEFINE_MUTEX(_client_lock);
 static LIST_HEAD(_clients);
 
 static void client_add(struct kcopyd_client *kc)
 {
-        down(&_client_lock);
+        mutex_lock(&_client_lock);
         list_add(&kc->list, &_clients);
-        up(&_client_lock);
+        mutex_unlock(&_client_lock);
 }
 
 static void client_del(struct kcopyd_client *kc)
 {
-        down(&_client_lock);
+        mutex_lock(&_client_lock);
         list_del(&kc->list);
-        up(&_client_lock);
+        mutex_unlock(&_client_lock);
 }
 
 static DEFINE_MUTEX(kcopyd_init_lock);
@@ -669,6 +679,9 @@ int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
                 return r;
         }
 
+        init_waitqueue_head(&kc->destroyq);
+        atomic_set(&kc->nr_jobs, 0);
+
         client_add(kc);
         *result = kc;
         return 0;
@@ -676,6 +689,9 @@ int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
 
 void kcopyd_client_destroy(struct kcopyd_client *kc)
 {
+        /* Wait for completion of all jobs submitted by this client. */
+        wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs));
+
         dm_io_put(kc->nr_pages);
         client_free_pages(kc);
         client_del(kc);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 5ed2228745cb..039e071c1007 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -43,6 +43,7 @@
 #include <linux/buffer_head.h> /* for invalidate_bdev */
 #include <linux/suspend.h>
 #include <linux/poll.h>
+#include <linux/mutex.h>
 
 #include <linux/init.h>
 
@@ -158,11 +159,12 @@ static int start_readonly;
  */
 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
 static atomic_t md_event_count;
-static void md_new_event(mddev_t *mddev)
+void md_new_event(mddev_t *mddev)
 {
         atomic_inc(&md_event_count);
         wake_up(&md_event_waiters);
 }
+EXPORT_SYMBOL_GPL(md_new_event);
 
 /*
  * Enables to iterate over all existing md arrays
@@ -253,7 +255,7 @@ static mddev_t * mddev_find(dev_t unit)
         else
                 new->md_minor = MINOR(unit) >> MdpMinorShift;
 
-        init_MUTEX(&new->reconfig_sem);
+        mutex_init(&new->reconfig_mutex);
         INIT_LIST_HEAD(&new->disks);
         INIT_LIST_HEAD(&new->all_mddevs);
         init_timer(&new->safemode_timer);
@@ -266,6 +268,7 @@ static mddev_t * mddev_find(dev_t unit)
                 kfree(new);
                 return NULL;
         }
+        set_bit(QUEUE_FLAG_CLUSTER, &new->queue->queue_flags);
 
         blk_queue_make_request(new->queue, md_fail_request);
 
@@ -274,22 +277,22 @@ static mddev_t * mddev_find(dev_t unit)
 
 static inline int mddev_lock(mddev_t * mddev)
 {
-        return down_interruptible(&mddev->reconfig_sem);
+        return mutex_lock_interruptible(&mddev->reconfig_mutex);
 }
 
 static inline void mddev_lock_uninterruptible(mddev_t * mddev)
 {
-        down(&mddev->reconfig_sem);
+        mutex_lock(&mddev->reconfig_mutex);
 }
 
 static inline int mddev_trylock(mddev_t * mddev)
 {
-        return down_trylock(&mddev->reconfig_sem);
+        return mutex_trylock(&mddev->reconfig_mutex);
 }
 
 static inline void mddev_unlock(mddev_t * mddev)
 {
-        up(&mddev->reconfig_sem);
+        mutex_unlock(&mddev->reconfig_mutex);
 
         md_wakeup_thread(mddev->thread);
 }
@@ -660,7 +663,8 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
         }
 
         if (sb->major_version != 0 ||
-            sb->minor_version != 90) {
+            sb->minor_version < 90 ||
+            sb->minor_version > 91) {
                 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
                         sb->major_version, sb->minor_version,
                         b);
@@ -745,6 +749,20 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->bitmap_offset = 0;
                 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
 
+                if (mddev->minor_version >= 91) {
+                        mddev->reshape_position = sb->reshape_position;
+                        mddev->delta_disks = sb->delta_disks;
+                        mddev->new_level = sb->new_level;
+                        mddev->new_layout = sb->new_layout;
+                        mddev->new_chunk = sb->new_chunk;
+                } else {
+                        mddev->reshape_position = MaxSector;
+                        mddev->delta_disks = 0;
+                        mddev->new_level = mddev->level;
+                        mddev->new_layout = mddev->layout;
+                        mddev->new_chunk = mddev->chunk_size;
+                }
+
                 if (sb->state & (1<<MD_SB_CLEAN))
                         mddev->recovery_cp = MaxSector;
                 else {
@@ -764,7 +782,8 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
 
                 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
                     mddev->bitmap_file == NULL) {
-                        if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
+                        if (mddev->level != 1 && mddev->level != 4
+                            && mddev->level != 5 && mddev->level != 6
                             && mddev->level != 10) {
                                 /* FIXME use a better test */
                                 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
@@ -838,7 +857,6 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 
         sb->md_magic = MD_SB_MAGIC;
         sb->major_version = mddev->major_version;
-        sb->minor_version = mddev->minor_version;
         sb->patch_version = mddev->patch_version;
         sb->gvalid_words  = 0; /* ignored */
         memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
@@ -857,6 +875,17 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         sb->events_hi = (mddev->events>>32);
         sb->events_lo = (u32)mddev->events;
 
+        if (mddev->reshape_position == MaxSector)
+                sb->minor_version = 90;
+        else {
+                sb->minor_version = 91;
+                sb->reshape_position = mddev->reshape_position;
+                sb->new_level = mddev->new_level;
+                sb->delta_disks = mddev->delta_disks;
+                sb->new_layout = mddev->new_layout;
+                sb->new_chunk = mddev->new_chunk;
+        }
+        mddev->minor_version = sb->minor_version;
         if (mddev->in_sync)
         {
                 sb->recovery_cp = mddev->recovery_cp;
@@ -893,10 +922,9 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                         d->raid_disk = rdev2->raid_disk;
                 else
                         d->raid_disk = rdev2->desc_nr; /* compatibility */
-                if (test_bit(Faulty, &rdev2->flags)) {
+                if (test_bit(Faulty, &rdev2->flags))
                         d->state = (1<<MD_DISK_FAULTY);
-                        failed++;
-                } else if (test_bit(In_sync, &rdev2->flags)) {
+                else if (test_bit(In_sync, &rdev2->flags)) {
                         d->state = (1<<MD_DISK_ACTIVE);
                         d->state |= (1<<MD_DISK_SYNC);
                         active++;
@@ -1102,6 +1130,20 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                         }
                         mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
                 }
+                if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
+                        mddev->reshape_position = le64_to_cpu(sb->reshape_position);
+                        mddev->delta_disks = le32_to_cpu(sb->delta_disks);
+                        mddev->new_level = le32_to_cpu(sb->new_level);
+                        mddev->new_layout = le32_to_cpu(sb->new_layout);
+                        mddev->new_chunk = le32_to_cpu(sb->new_chunk)<<9;
+                } else {
+                        mddev->reshape_position = MaxSector;
+                        mddev->delta_disks = 0;
+                        mddev->new_level = mddev->level;
+                        mddev->new_layout = mddev->layout;
+                        mddev->new_chunk = mddev->chunk_size;
+                }
+
         } else if (mddev->pers == NULL) {
                 /* Insist of good event counter while assembling */
                 __u64 ev1 = le64_to_cpu(sb->events);
@@ -1173,6 +1215,14 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
         }
+        if (mddev->reshape_position != MaxSector) {
+                sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
+                sb->reshape_position = cpu_to_le64(mddev->reshape_position);
+                sb->new_layout = cpu_to_le32(mddev->new_layout);
+                sb->delta_disks = cpu_to_le32(mddev->delta_disks);
+                sb->new_level = cpu_to_le32(mddev->new_level);
+                sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
+        }
 
         max_dev = 0;
         ITERATE_RDEV(mddev,rdev2,tmp)
@@ -1301,6 +1351,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
         else
                 ko = &rdev->bdev->bd_disk->kobj;
         sysfs_create_link(&rdev->kobj, ko, "block");
+        bd_claim_by_disk(rdev->bdev, rdev, mddev->gendisk);
         return 0;
 }
 
@@ -1311,6 +1362,7 @@ static void unbind_rdev_from_array(mdk_rdev_t * rdev)
                 MD_BUG();
                 return;
         }
+        bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
         list_del_init(&rdev->same_set);
         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
         rdev->mddev = NULL;
@@ -1493,7 +1545,7 @@ static void sync_sbs(mddev_t * mddev)
         }
 }
 
-static void md_update_sb(mddev_t * mddev)
+void md_update_sb(mddev_t * mddev)
 {
         int err;
         struct list_head *tmp;
@@ -1570,6 +1622,7 @@ repeat:
         wake_up(&mddev->sb_wait);
 
 }
+EXPORT_SYMBOL_GPL(md_update_sb);
 
 /* words written to sysfs files may, or my not, be \n terminated.
  * We want to accept with case. For this we use cmd_match.
@@ -2162,7 +2215,9 @@ action_show(mddev_t *mddev, char *page)
         char *type = "idle";
         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
             test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
-                if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
+                if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
+                        type = "reshape";
+                else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
                         if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
                                 type = "resync";
                         else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
@@ -2193,7 +2248,14 @@ action_store(mddev_t *mddev, const char *page, size_t len)
                 return -EBUSY;
         else if (cmd_match(page, "resync") || cmd_match(page, "recover"))
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
-        else {
+        else if (cmd_match(page, "reshape")) {
+                int err;
+                if (mddev->pers->start_reshape == NULL)
+                        return -EINVAL;
+                err = mddev->pers->start_reshape(mddev);
+                if (err)
+                        return err;
+        } else {
                 if (cmd_match(page, "check"))
                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
                 else if (cmd_match(page, "repair"))
@@ -2304,6 +2366,63 @@ sync_completed_show(mddev_t *mddev, char *page)
 static struct md_sysfs_entry
 md_sync_completed = __ATTR_RO(sync_completed);
 
+static ssize_t
+suspend_lo_show(mddev_t *mddev, char *page)
+{
+        return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
+}
+
+static ssize_t
+suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
+{
+        char *e;
+        unsigned long long new = simple_strtoull(buf, &e, 10);
+
+        if (mddev->pers->quiesce == NULL)
+                return -EINVAL;
+        if (buf == e || (*e && *e != '\n'))
+                return -EINVAL;
+        if (new >= mddev->suspend_hi ||
+            (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
+                mddev->suspend_lo = new;
+                mddev->pers->quiesce(mddev, 2);
+                return len;
+        } else
+                return -EINVAL;
+}
+static struct md_sysfs_entry md_suspend_lo =
+__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
+
+
+static ssize_t
+suspend_hi_show(mddev_t *mddev, char *page)
+{
+        return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
+}
+
+static ssize_t
+suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
+{
+        char *e;
+        unsigned long long new = simple_strtoull(buf, &e, 10);
+
+        if (mddev->pers->quiesce == NULL)
+                return -EINVAL;
+        if (buf == e || (*e && *e != '\n'))
+                return -EINVAL;
+        if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
+            (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
+                mddev->suspend_hi = new;
+                mddev->pers->quiesce(mddev, 1);
+                mddev->pers->quiesce(mddev, 0);
+                return len;
+        } else
+                return -EINVAL;
+}
+static struct md_sysfs_entry md_suspend_hi =
+__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
+
+
 static struct attribute *md_default_attrs[] = {
         &md_level.attr,
         &md_raid_disks.attr,
@@ -2321,6 +2440,8 @@ static struct attribute *md_redundancy_attrs[] = {
         &md_sync_max.attr,
         &md_sync_speed.attr,
         &md_sync_completed.attr,
+        &md_suspend_lo.attr,
+        &md_suspend_hi.attr,
         NULL,
 };
 static struct attribute_group md_redundancy_group = {
@@ -2380,7 +2501,7 @@ int mdp_major = 0;
 
 static struct kobject *md_probe(dev_t dev, int *part, void *data)
 {
-        static DECLARE_MUTEX(disks_sem);
+        static DEFINE_MUTEX(disks_mutex);
         mddev_t *mddev = mddev_find(dev);
         struct gendisk *disk;
         int partitioned = (MAJOR(dev) != MD_MAJOR);
@@ -2390,15 +2511,15 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         if (!mddev)
                 return NULL;
 
-        down(&disks_sem);
+        mutex_lock(&disks_mutex);
         if (mddev->gendisk) {
-                up(&disks_sem);
+                mutex_unlock(&disks_mutex);
                 mddev_put(mddev);
                 return NULL;
         }
         disk = alloc_disk(1 << shift);
         if (!disk) {
-                up(&disks_sem);
+                mutex_unlock(&disks_mutex);
                 mddev_put(mddev);
                 return NULL;
         }
@@ -2416,7 +2537,7 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         disk->queue = mddev->queue;
         add_disk(disk);
         mddev->gendisk = disk;
-        up(&disks_sem);
+        mutex_unlock(&disks_mutex);
         mddev->kobj.parent = &disk->kobj;
         mddev->kobj.k_name = NULL;
         snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
@@ -2539,6 +2660,14 @@ static int do_md_run(mddev_t * mddev)
         mddev->level = pers->level;
         strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
 
+        if (mddev->reshape_position != MaxSector &&
+            pers->start_reshape == NULL) {
+                /* This personality cannot handle reshaping... */
+                mddev->pers = NULL;
+                module_put(pers->owner);
+                return -EINVAL;
+        }
+
         mddev->recovery = 0;
         mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
         mddev->barriers_work = 1;
@@ -2772,7 +2901,6 @@ static void autorun_array(mddev_t *mddev)
  */
 static void autorun_devices(int part)
 {
-        struct list_head candidates;
         struct list_head *tmp;
         mdk_rdev_t *rdev0, *rdev;
         mddev_t *mddev;
@@ -2781,6 +2909,7 @@ static void autorun_devices(int part)
         printk(KERN_INFO "md: autorun ...\n");
         while (!list_empty(&pending_raid_disks)) {
                 dev_t dev;
+                LIST_HEAD(candidates);
                 rdev0 = list_entry(pending_raid_disks.next,
                                          mdk_rdev_t, same_set);
 
@@ -3427,11 +3556,18 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
         mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
         mddev->bitmap_offset = 0;
 
+        mddev->reshape_position = MaxSector;
+
         /*
          * Generate a 128 bit UUID
          */
         get_random_bytes(mddev->uuid, 16);
 
+        mddev->new_level = mddev->level;
+        mddev->new_chunk = mddev->chunk_size;
+        mddev->new_layout = mddev->layout;
+        mddev->delta_disks = 0;
+
         return 0;
 }
 
@@ -3440,6 +3576,7 @@ static int update_size(mddev_t *mddev, unsigned long size)
         mdk_rdev_t * rdev;
         int rv;
         struct list_head *tmp;
+        int fit = (size == 0);
 
         if (mddev->pers->resize == NULL)
                 return -EINVAL;
@@ -3457,7 +3594,6 @@ static int update_size(mddev_t *mddev, unsigned long size)
                 return -EBUSY;
         ITERATE_RDEV(mddev,rdev,tmp) {
                 sector_t avail;
-                int fit = (size == 0);
                 if (rdev->sb_offset > rdev->data_offset)
                         avail = (rdev->sb_offset*2) - rdev->data_offset;
                 else
@@ -3487,14 +3623,16 @@ static int update_raid_disks(mddev_t *mddev, int raid_disks)
 {
         int rv;
         /* change the number of raid disks */
-        if (mddev->pers->reshape == NULL)
+        if (mddev->pers->check_reshape == NULL)
                 return -EINVAL;
         if (raid_disks <= 0 ||
             raid_disks >= mddev->max_disks)
                 return -EINVAL;
-        if (mddev->sync_thread)
+        if (mddev->sync_thread || mddev->reshape_position != MaxSector)
                 return -EBUSY;
-        rv = mddev->pers->reshape(mddev, raid_disks);
+        mddev->delta_disks = raid_disks - mddev->raid_disks;
+
+        rv = mddev->pers->check_reshape(mddev);
         return rv;
 }
 
@@ -4041,7 +4179,10 @@ static void status_unused(struct seq_file *seq)
 
 static void status_resync(struct seq_file *seq, mddev_t * mddev)
 {
-        unsigned long max_blocks, resync, res, dt, db, rt;
+        sector_t max_blocks, resync, res;
+        unsigned long dt, db, rt;
+        int scale;
+        unsigned int per_milli;
 
         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
 
@@ -4057,9 +4198,22 @@ static void status_resync(struct seq_file *seq, mddev_t * mddev)
                 MD_BUG();
                 return;
         }
-        res = (resync/1024)*1000/(max_blocks/1024 + 1);
+        /* Pick 'scale' such that (resync>>scale)*1000 will fit
+         * in a sector_t, and (max_blocks>>scale) will fit in a
+         * u32, as those are the requirements for sector_div.
+         * Thus 'scale' must be at least 10
+         */
+        scale = 10;
+        if (sizeof(sector_t) > sizeof(unsigned long)) {
+                while ( max_blocks/2 > (1ULL<<(scale+32)))
+                        scale++;
+        }
+        res = (resync>>scale)*1000;
+        sector_div(res, (u32)((max_blocks>>scale)+1));
+
+        per_milli = res;
         {
-                int i, x = res/50, y = 20-x;
+                int i, x = per_milli/50, y = 20-x;
                 seq_printf(seq, "[");
                 for (i = 0; i < x; i++)
                         seq_printf(seq, "=");
@@ -4068,10 +4222,14 @@ static void status_resync(struct seq_file *seq, mddev_t * mddev)
                         seq_printf(seq, ".");
                 seq_printf(seq, "] ");
         }
-        seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
+        seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
+                   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
+                    "reshape" :
                       (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
-                       "resync" : "recovery"),
-                      res/10, res % 10, resync, max_blocks);
+                       "resync" : "recovery")),
+                      per_milli/10, per_milli % 10,
+                   (unsigned long long) resync,
+                   (unsigned long long) max_blocks);
 
         /*
          * We do not want to overflow, so the order of operands and
@@ -4085,7 +4243,7 @@ static void status_resync(struct seq_file *seq, mddev_t * mddev)
         dt = ((jiffies - mddev->resync_mark) / HZ);
         if (!dt) dt++;
         db = resync - (mddev->resync_mark_cnt/2);
-        rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
+        rt = (dt * ((unsigned long)(max_blocks-resync) / (db/100+1)))/100;
 
         seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
 
@@ -4442,7 +4600,7 @@ static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
 
 #define SYNC_MARKS      10
 #define SYNC_MARK_STEP  (3*HZ)
-static void md_do_sync(mddev_t *mddev)
+void md_do_sync(mddev_t *mddev)
 {
         mddev_t *mddev2;
         unsigned int currspeed = 0,
@@ -4522,7 +4680,9 @@ static void md_do_sync(mddev_t *mddev)
                  */
                 max_sectors = mddev->resync_max_sectors;
                 mddev->resync_mismatches = 0;
-        } else
+        } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
+                max_sectors = mddev->size << 1;
+        else
                 /* recovery follows the physical size of devices */
                 max_sectors = mddev->size << 1;
 
@@ -4658,6 +4818,8 @@ static void md_do_sync(mddev_t *mddev)
         mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
 
         if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
+            test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
+            !test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
             mddev->curr_resync > 2 &&
             mddev->curr_resync >= mddev->recovery_cp) {
                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
@@ -4675,6 +4837,7 @@ static void md_do_sync(mddev_t *mddev)
         set_bit(MD_RECOVERY_DONE, &mddev->recovery);
         md_wakeup_thread(mddev->thread);
 }
+EXPORT_SYMBOL_GPL(md_do_sync);
 
 
 /*
@@ -4730,7 +4893,7 @@ void md_check_recovery(mddev_t *mddev)
                 ))
                 return;
 
-        if (mddev_trylock(mddev)==0) {
+        if (mddev_trylock(mddev)) {
                 int spares =0;
 
                 spin_lock_irq(&mddev->write_lock);
@@ -4866,7 +5029,7 @@ static int md_notify_reboot(struct notifier_block *this,
                 printk(KERN_INFO "md: stopping all md devices.\n");
 
                 ITERATE_MDDEV(mddev,tmp)
-                        if (mddev_trylock(mddev)==0)
+                        if (mddev_trylock(mddev))
                                 do_md_stop (mddev, 1);
                 /*
                  * certain more exotic SCSI devices are known to be
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 5d88329e3c7a..3cb0872a845d 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1402,6 +1402,9 @@ static void raid1d(mddev_t *mddev)
                         clear_bit(R1BIO_BarrierRetry, &r1_bio->state);
                         clear_bit(R1BIO_Barrier, &r1_bio->state);
                         for (i=0; i < conf->raid_disks; i++)
+                                if (r1_bio->bios[i])
+                                        atomic_inc(&r1_bio->remaining);
+                        for (i=0; i < conf->raid_disks; i++)
                                 if (r1_bio->bios[i]) {
                                         struct bio_vec *bvec;
                                         int j;
@@ -1789,6 +1792,11 @@ static int run(mddev_t *mddev)
                        mdname(mddev), mddev->level);
                 goto out;
         }
+        if (mddev->reshape_position != MaxSector) {
+                printk("raid1: %s: reshape_position set but not supported\n",
+                       mdname(mddev));
+                goto out;
+        }
         /*
          * copy the already verified devices into our private RAID1
          * bookkeeping area. [whatever we allocate in run(),
@@ -1971,7 +1979,7 @@ static int raid1_resize(mddev_t *mddev, sector_t sectors)
         return 0;
 }
 
-static int raid1_reshape(mddev_t *mddev, int raid_disks)
+static int raid1_reshape(mddev_t *mddev)
 {
         /* We need to:
          * 1/ resize the r1bio_pool
@@ -1988,10 +1996,22 @@ static int raid1_reshape(mddev_t *mddev, int raid_disks)
         struct pool_info *newpoolinfo;
         mirror_info_t *newmirrors;
         conf_t *conf = mddev_to_conf(mddev);
-        int cnt;
+        int cnt, raid_disks;
 
         int d, d2;
 
+        /* Cannot change chunk_size, layout, or level */
+        if (mddev->chunk_size != mddev->new_chunk ||
+            mddev->layout != mddev->new_layout ||
+            mddev->level != mddev->new_level) {
+                mddev->new_chunk = mddev->chunk_size;
+                mddev->new_layout = mddev->layout;
+                mddev->new_level = mddev->level;
+                return -EINVAL;
+        }
+
+        raid_disks = mddev->raid_disks + mddev->delta_disks;
+
         if (raid_disks < conf->raid_disks) {
                 cnt=0;
                 for (d= 0; d < conf->raid_disks; d++)
@@ -2038,6 +2058,7 @@ static int raid1_reshape(mddev_t *mddev, int raid_disks)
 
         mddev->degraded += (raid_disks - conf->raid_disks);
         conf->raid_disks = mddev->raid_disks = raid_disks;
+        mddev->delta_disks = 0;
 
         conf->last_used = 0; /* just make sure it is in-range */
         lower_barrier(conf);
@@ -2079,7 +2100,7 @@ static struct mdk_personality raid1_personality =
         .spare_active   = raid1_spare_active,
         .sync_request   = sync_request,
         .resize         = raid1_resize,
-        .reshape        = raid1_reshape,
+        .check_reshape  = raid1_reshape,
         .quiesce        = raid1_quiesce,
 };
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 2dba305daf3c..dae740adaf65 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -22,6 +22,7 @@
 #include <linux/raid/raid5.h>
 #include <linux/highmem.h>
 #include <linux/bitops.h>
+#include <linux/kthread.h>
 #include <asm/atomic.h>
 
 #include <linux/raid/bitmap.h>
@@ -93,11 +94,11 @@ static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
                                 if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD)
                                         md_wakeup_thread(conf->mddev->thread);
                         }
-                        list_add_tail(&sh->lru, &conf->inactive_list);
                         atomic_dec(&conf->active_stripes);
-                        if (!conf->inactive_blocked ||
-                            atomic_read(&conf->active_stripes) < (conf->max_nr_stripes*3/4))
+                        if (!test_bit(STRIPE_EXPANDING, &sh->state)) {
+                                list_add_tail(&sh->lru, &conf->inactive_list);
                                 wake_up(&conf->wait_for_stripe);
+                        }
                 }
         }
 }
@@ -178,10 +179,10 @@ static int grow_buffers(struct stripe_head *sh, int num)
 
 static void raid5_build_block (struct stripe_head *sh, int i);
 
-static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
+static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx, int disks)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks, i;
+        int i;
 
         if (atomic_read(&sh->count) != 0)
                 BUG();
@@ -198,7 +199,9 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
         sh->pd_idx = pd_idx;
         sh->state = 0;
 
-        for (i=disks; i--; ) {
+        sh->disks = disks;
+
+        for (i = sh->disks; i--; ) {
                 struct r5dev *dev = &sh->dev[i];
 
                 if (dev->toread || dev->towrite || dev->written ||
@@ -215,7 +218,7 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
         insert_hash(conf, sh);
 }
 
-static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector)
+static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector, int disks)
 {
         struct stripe_head *sh;
         struct hlist_node *hn;
@@ -223,7 +226,7 @@ static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector)
         CHECK_DEVLOCK();
         PRINTK("__find_stripe, sector %llu\n", (unsigned long long)sector);
         hlist_for_each_entry(sh, hn, stripe_hash(conf, sector), hash)
-                if (sh->sector == sector)
+                if (sh->sector == sector && sh->disks == disks)
                         return sh;
         PRINTK("__stripe %llu not in cache\n", (unsigned long long)sector);
         return NULL;
@@ -232,8 +235,8 @@ static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector)
 static void unplug_slaves(mddev_t *mddev);
 static void raid5_unplug_device(request_queue_t *q);
 
-static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector,
-                                             int pd_idx, int noblock) 
+static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector, int disks,
+                                             int pd_idx, int noblock)
 {
         struct stripe_head *sh;
 
@@ -245,7 +248,7 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
                 wait_event_lock_irq(conf->wait_for_stripe,
                                     conf->quiesce == 0,
                                     conf->device_lock, /* nothing */);
-                sh = __find_stripe(conf, sector);
+                sh = __find_stripe(conf, sector, disks);
                 if (!sh) {
                         if (!conf->inactive_blocked)
                                 sh = get_free_stripe(conf);
@@ -259,11 +262,11 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
                                                      < (conf->max_nr_stripes *3/4)
                                                      || !conf->inactive_blocked),
                                                     conf->device_lock,
-                                                    unplug_slaves(conf->mddev);
+                                                    unplug_slaves(conf->mddev)
                                         );
                                 conf->inactive_blocked = 0;
                         } else
-                                init_stripe(sh, sector, pd_idx);
+                                init_stripe(sh, sector, pd_idx, disks);
                 } else {
                         if (atomic_read(&sh->count)) {
                                 if (!list_empty(&sh->lru))
@@ -271,9 +274,8 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
                         } else {
                                 if (!test_bit(STRIPE_HANDLE, &sh->state))
                                         atomic_inc(&conf->active_stripes);
-                                if (list_empty(&sh->lru))
-                                        BUG();
-                                list_del_init(&sh->lru);
+                                if (!list_empty(&sh->lru))
+                                        list_del_init(&sh->lru);
                         }
                 }
         } while (sh == NULL);
@@ -300,6 +302,7 @@ static int grow_one_stripe(raid5_conf_t *conf)
                 kmem_cache_free(conf->slab_cache, sh);
                 return 0;
         }
+        sh->disks = conf->raid_disks;
         /* we just created an active stripe so... */
         atomic_set(&sh->count, 1);
         atomic_inc(&conf->active_stripes);
@@ -313,14 +316,16 @@ static int grow_stripes(raid5_conf_t *conf, int num)
         kmem_cache_t *sc;
         int devs = conf->raid_disks;
 
-        sprintf(conf->cache_name, "raid5/%s", mdname(conf->mddev));
-
-        sc = kmem_cache_create(conf->cache_name, 
+        sprintf(conf->cache_name[0], "raid5/%s", mdname(conf->mddev));
+        sprintf(conf->cache_name[1], "raid5/%s-alt", mdname(conf->mddev));
+        conf->active_name = 0;
+        sc = kmem_cache_create(conf->cache_name[conf->active_name],
                                sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
                                0, 0, NULL, NULL);
         if (!sc)
                 return 1;
         conf->slab_cache = sc;
+        conf->pool_size = devs;
         while (num--) {
                 if (!grow_one_stripe(conf))
                         return 1;
@@ -328,6 +333,129 @@ static int grow_stripes(raid5_conf_t *conf, int num)
         return 0;
 }
 
+#ifdef CONFIG_MD_RAID5_RESHAPE
+static int resize_stripes(raid5_conf_t *conf, int newsize)
+{
+        /* Make all the stripes able to hold 'newsize' devices.
+         * New slots in each stripe get 'page' set to a new page.
+         *
+         * This happens in stages:
+         * 1/ create a new kmem_cache and allocate the required number of
+         *    stripe_heads.
+         * 2/ gather all the old stripe_heads and tranfer the pages across
+         *    to the new stripe_heads.  This will have the side effect of
+         *    freezing the array as once all stripe_heads have been collected,
+         *    no IO will be possible.  Old stripe heads are freed once their
+         *    pages have been transferred over, and the old kmem_cache is
+         *    freed when all stripes are done.
+         * 3/ reallocate conf->disks to be suitable bigger.  If this fails,
+         *    we simple return a failre status - no need to clean anything up.
+         * 4/ allocate new pages for the new slots in the new stripe_heads.
+         *    If this fails, we don't bother trying the shrink the
+         *    stripe_heads down again, we just leave them as they are.
+         *    As each stripe_head is processed the new one is released into
+         *    active service.
+         *
+         * Once step2 is started, we cannot afford to wait for a write,
+         * so we use GFP_NOIO allocations.
+         */
+        struct stripe_head *osh, *nsh;
+        LIST_HEAD(newstripes);
+        struct disk_info *ndisks;
+        int err = 0;
+        kmem_cache_t *sc;
+        int i;
+
+        if (newsize <= conf->pool_size)
+                return 0; /* never bother to shrink */
+
+        /* Step 1 */
+        sc = kmem_cache_create(conf->cache_name[1-conf->active_name],
+                               sizeof(struct stripe_head)+(newsize-1)*sizeof(struct r5dev),
+                               0, 0, NULL, NULL);
+        if (!sc)
+                return -ENOMEM;
+
+        for (i = conf->max_nr_stripes; i; i--) {
+                nsh = kmem_cache_alloc(sc, GFP_KERNEL);
+                if (!nsh)
+                        break;
+
+                memset(nsh, 0, sizeof(*nsh) + (newsize-1)*sizeof(struct r5dev));
+
+                nsh->raid_conf = conf;
+                spin_lock_init(&nsh->lock);
+
+                list_add(&nsh->lru, &newstripes);
+        }
+        if (i) {
+                /* didn't get enough, give up */
+                while (!list_empty(&newstripes)) {
+                        nsh = list_entry(newstripes.next, struct stripe_head, lru);
+                        list_del(&nsh->lru);
+                        kmem_cache_free(sc, nsh);
+                }
+                kmem_cache_destroy(sc);
+                return -ENOMEM;
+        }
+        /* Step 2 - Must use GFP_NOIO now.
+         * OK, we have enough stripes, start collecting inactive
+         * stripes and copying them over
+         */
+        list_for_each_entry(nsh, &newstripes, lru) {
+                spin_lock_irq(&conf->device_lock);
+                wait_event_lock_irq(conf->wait_for_stripe,
+                                    !list_empty(&conf->inactive_list),
+                                    conf->device_lock,
+                                    unplug_slaves(conf->mddev)
+                        );
+                osh = get_free_stripe(conf);
+                spin_unlock_irq(&conf->device_lock);
+                atomic_set(&nsh->count, 1);
+                for(i=0; i<conf->pool_size; i++)
+                        nsh->dev[i].page = osh->dev[i].page;
+                for( ; i<newsize; i++)
+                        nsh->dev[i].page = NULL;
+                kmem_cache_free(conf->slab_cache, osh);
+        }
+        kmem_cache_destroy(conf->slab_cache);
+
+        /* Step 3.
+         * At this point, we are holding all the stripes so the array
+         * is completely stalled, so now is a good time to resize
+         * conf->disks.
+         */
+        ndisks = kzalloc(newsize * sizeof(struct disk_info), GFP_NOIO);
+        if (ndisks) {
+                for (i=0; i<conf->raid_disks; i++)
+                        ndisks[i] = conf->disks[i];
+                kfree(conf->disks);
+                conf->disks = ndisks;
+        } else
+                err = -ENOMEM;
+
+        /* Step 4, return new stripes to service */
+        while(!list_empty(&newstripes)) {
+                nsh = list_entry(newstripes.next, struct stripe_head, lru);
+                list_del_init(&nsh->lru);
+                for (i=conf->raid_disks; i < newsize; i++)
+                        if (nsh->dev[i].page == NULL) {
+                                struct page *p = alloc_page(GFP_NOIO);
+                                nsh->dev[i].page = p;
+                                if (!p)
+                                        err = -ENOMEM;
+                        }
+                release_stripe(nsh);
+        }
+        /* critical section pass, GFP_NOIO no longer needed */
+
+        conf->slab_cache = sc;
+        conf->active_name = 1-conf->active_name;
+        conf->pool_size = newsize;
+        return err;
+}
+#endif
+
 static int drop_one_stripe(raid5_conf_t *conf)
 {
         struct stripe_head *sh;
@@ -339,7 +467,7 @@ static int drop_one_stripe(raid5_conf_t *conf)
                 return 0;
         if (atomic_read(&sh->count))
                 BUG();
-        shrink_buffers(sh, conf->raid_disks);
+        shrink_buffers(sh, conf->pool_size);
         kmem_cache_free(conf->slab_cache, sh);
         atomic_dec(&conf->active_stripes);
         return 1;
@@ -360,7 +488,7 @@ static int raid5_end_read_request(struct bio * bi, unsigned int bytes_done,
 {
         struct stripe_head *sh = bi->bi_private;
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks, i;
+        int disks = sh->disks, i;
         int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
 
         if (bi->bi_size)
@@ -458,7 +586,7 @@ static int raid5_end_write_request (struct bio *bi, unsigned int bytes_done,
 {
         struct stripe_head *sh = bi->bi_private;
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks, i;
+        int disks = sh->disks, i;
         unsigned long flags;
         int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
 
@@ -612,7 +740,7 @@ static sector_t raid5_compute_sector(sector_t r_sector, unsigned int raid_disks,
 static sector_t compute_blocknr(struct stripe_head *sh, int i)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int raid_disks = conf->raid_disks, data_disks = raid_disks - 1;
+        int raid_disks = sh->disks, data_disks = raid_disks - 1;
         sector_t new_sector = sh->sector, check;
         int sectors_per_chunk = conf->chunk_size >> 9;
         sector_t stripe;
@@ -713,8 +841,7 @@ static void copy_data(int frombio, struct bio *bio,
 
 static void compute_block(struct stripe_head *sh, int dd_idx)
 {
-        raid5_conf_t *conf = sh->raid_conf;
-        int i, count, disks = conf->raid_disks;
+        int i, count, disks = sh->disks;
         void *ptr[MAX_XOR_BLOCKS], *p;
 
         PRINTK("compute_block, stripe %llu, idx %d\n", 
@@ -744,7 +871,7 @@ static void compute_block(struct stripe_head *sh, int dd_idx)
 static void compute_parity(struct stripe_head *sh, int method)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int i, pd_idx = sh->pd_idx, disks = conf->raid_disks, count;
+        int i, pd_idx = sh->pd_idx, disks = sh->disks, count;
         void *ptr[MAX_XOR_BLOCKS];
         struct bio *chosen;
 
@@ -910,6 +1037,20 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
         return 0;
 }
 
+static void end_reshape(raid5_conf_t *conf);
+
+static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int disks)
+{
+        int sectors_per_chunk = conf->chunk_size >> 9;
+        sector_t x = stripe;
+        int pd_idx, dd_idx;
+        int chunk_offset = sector_div(x, sectors_per_chunk);
+        stripe = x;
+        raid5_compute_sector(stripe*(disks-1)*sectors_per_chunk
+                             + chunk_offset, disks, disks-1, &dd_idx, &pd_idx, conf);
+        return pd_idx;
+}
+
 
 /*
  * handle_stripe - do things to a stripe.
@@ -932,11 +1073,11 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
 static void handle_stripe(struct stripe_head *sh)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks;
+        int disks = sh->disks;
         struct bio *return_bi= NULL;
         struct bio *bi;
         int i;
-        int syncing;
+        int syncing, expanding, expanded;
         int locked=0, uptodate=0, to_read=0, to_write=0, failed=0, written=0;
         int non_overwrite = 0;
         int failed_num=0;
@@ -951,6 +1092,8 @@ static void handle_stripe(struct stripe_head *sh)
         clear_bit(STRIPE_DELAYED, &sh->state);
 
         syncing = test_bit(STRIPE_SYNCING, &sh->state);
+        expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+        expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
         /* Now to look around and see what can be done */
 
         rcu_read_lock();
@@ -1143,13 +1286,14 @@ static void handle_stripe(struct stripe_head *sh)
          * parity, or to satisfy requests
          * or to load a block that is being partially written.
          */
-        if (to_read || non_overwrite || (syncing && (uptodate < disks))) {
+        if (to_read || non_overwrite || (syncing && (uptodate < disks)) || expanding) {
                 for (i=disks; i--;) {
                         dev = &sh->dev[i];
                         if (!test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
                             (dev->toread ||
                              (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
                              syncing ||
+                             expanding ||
                              (failed && (sh->dev[failed_num].toread ||
                                          (sh->dev[failed_num].towrite && !test_bit(R5_OVERWRITE, &sh->dev[failed_num].flags))))
                                     )
@@ -1339,13 +1483,77 @@ static void handle_stripe(struct stripe_head *sh)
                         set_bit(R5_Wantwrite, &dev->flags);
                         set_bit(R5_ReWrite, &dev->flags);
                         set_bit(R5_LOCKED, &dev->flags);
+                        locked++;
                 } else {
                         /* let's read it back */
                         set_bit(R5_Wantread, &dev->flags);
                         set_bit(R5_LOCKED, &dev->flags);
+                        locked++;
                 }
         }
 
+        if (expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
+                /* Need to write out all blocks after computing parity */
+                sh->disks = conf->raid_disks;
+                sh->pd_idx = stripe_to_pdidx(sh->sector, conf, conf->raid_disks);
+                compute_parity(sh, RECONSTRUCT_WRITE);
+                for (i= conf->raid_disks; i--;) {
+                        set_bit(R5_LOCKED, &sh->dev[i].flags);
+                        locked++;
+                        set_bit(R5_Wantwrite, &sh->dev[i].flags);
+                }
+                clear_bit(STRIPE_EXPANDING, &sh->state);
+        } else if (expanded) {
+                clear_bit(STRIPE_EXPAND_READY, &sh->state);
+                atomic_dec(&conf->reshape_stripes);
+                wake_up(&conf->wait_for_overlap);
+                md_done_sync(conf->mddev, STRIPE_SECTORS, 1);
+        }
+
+        if (expanding && locked == 0) {
+                /* We have read all the blocks in this stripe and now we need to
+                 * copy some of them into a target stripe for expand.
+                 */
+                clear_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+                for (i=0; i< sh->disks; i++)
+                        if (i != sh->pd_idx) {
+                                int dd_idx, pd_idx, j;
+                                struct stripe_head *sh2;
+
+                                sector_t bn = compute_blocknr(sh, i);
+                                sector_t s = raid5_compute_sector(bn, conf->raid_disks,
+                                                                  conf->raid_disks-1,
+                                                                  &dd_idx, &pd_idx, conf);
+                                sh2 = get_active_stripe(conf, s, conf->raid_disks, pd_idx, 1);
+                                if (sh2 == NULL)
+                                        /* so far only the early blocks of this stripe
+                                         * have been requested.  When later blocks
+                                         * get requested, we will try again
+                                         */
+                                        continue;
+                                if(!test_bit(STRIPE_EXPANDING, &sh2->state) ||
+                                   test_bit(R5_Expanded, &sh2->dev[dd_idx].flags)) {
+                                        /* must have already done this block */
+                                        release_stripe(sh2);
+                                        continue;
+                                }
+                                memcpy(page_address(sh2->dev[dd_idx].page),
+                                       page_address(sh->dev[i].page),
+                                       STRIPE_SIZE);
+                                set_bit(R5_Expanded, &sh2->dev[dd_idx].flags);
+                                set_bit(R5_UPTODATE, &sh2->dev[dd_idx].flags);
+                                for (j=0; j<conf->raid_disks; j++)
+                                        if (j != sh2->pd_idx &&
+                                            !test_bit(R5_Expanded, &sh2->dev[j].flags))
+                                                break;
+                                if (j == conf->raid_disks) {
+                                        set_bit(STRIPE_EXPAND_READY, &sh2->state);
+                                        set_bit(STRIPE_HANDLE, &sh2->state);
+                                }
+                                release_stripe(sh2);
+                        }
+        }
+
         spin_unlock(&sh->lock);
 
         while ((bi=return_bi)) {
@@ -1384,7 +1592,7 @@ static void handle_stripe(struct stripe_head *sh)
                 rcu_read_unlock();
  
                 if (rdev) {
-                        if (syncing)
+                        if (syncing || expanding || expanded)
                                 md_sync_acct(rdev->bdev, STRIPE_SECTORS);
 
                         bi->bi_bdev = rdev->bdev;
@@ -1526,17 +1734,16 @@ static inline void raid5_plug_device(raid5_conf_t *conf)
         spin_unlock_irq(&conf->device_lock);
 }
 
-static int make_request (request_queue_t *q, struct bio * bi)
+static int make_request(request_queue_t *q, struct bio * bi)
 {
         mddev_t *mddev = q->queuedata;
         raid5_conf_t *conf = mddev_to_conf(mddev);
-        const unsigned int raid_disks = conf->raid_disks;
-        const unsigned int data_disks = raid_disks - 1;
         unsigned int dd_idx, pd_idx;
         sector_t new_sector;
         sector_t logical_sector, last_sector;
         struct stripe_head *sh;
         const int rw = bio_data_dir(bi);
+        int remaining;
 
         if (unlikely(bio_barrier(bi))) {
                 bio_endio(bi, bi->bi_size, -EOPNOTSUPP);
@@ -1555,20 +1762,77 @@ static int make_request (request_queue_t *q, struct bio * bi)
 
         for (;logical_sector < last_sector; logical_sector += STRIPE_SECTORS) {
                 DEFINE_WAIT(w);
-                
-                new_sector = raid5_compute_sector(logical_sector,
-                                                  raid_disks, data_disks, &dd_idx, &pd_idx, conf);
+                int disks;
 
+        retry:
+                prepare_to_wait(&conf->wait_for_overlap, &w, TASK_UNINTERRUPTIBLE);
+                if (likely(conf->expand_progress == MaxSector))
+                        disks = conf->raid_disks;
+                else {
+                        /* spinlock is needed as expand_progress may be
+                         * 64bit on a 32bit platform, and so it might be
+                         * possible to see a half-updated value
+                         * Ofcourse expand_progress could change after
+                         * the lock is dropped, so once we get a reference
+                         * to the stripe that we think it is, we will have
+                         * to check again.
+                         */
+                        spin_lock_irq(&conf->device_lock);
+                        disks = conf->raid_disks;
+                        if (logical_sector >= conf->expand_progress)
+                                disks = conf->previous_raid_disks;
+                        else {
+                                if (logical_sector >= conf->expand_lo) {
+                                        spin_unlock_irq(&conf->device_lock);
+                                        schedule();
+                                        goto retry;
+                                }
+                        }
+                        spin_unlock_irq(&conf->device_lock);
+                }
+                new_sector = raid5_compute_sector(logical_sector, disks, disks - 1,
+                                                  &dd_idx, &pd_idx, conf);
                 PRINTK("raid5: make_request, sector %llu logical %llu\n",
                         (unsigned long long)new_sector, 
                         (unsigned long long)logical_sector);
 
-        retry:
-                prepare_to_wait(&conf->wait_for_overlap, &w, TASK_UNINTERRUPTIBLE);
-                sh = get_active_stripe(conf, new_sector, pd_idx, (bi->bi_rw&RWA_MASK));
+                sh = get_active_stripe(conf, new_sector, disks, pd_idx, (bi->bi_rw&RWA_MASK));
                 if (sh) {
-                        if (!add_stripe_bio(sh, bi, dd_idx, (bi->bi_rw&RW_MASK))) {
-                                /* Add failed due to overlap.  Flush everything
+                        if (unlikely(conf->expand_progress != MaxSector)) {
+                                /* expansion might have moved on while waiting for a
+                                 * stripe, so we must do the range check again.
+                                 * Expansion could still move past after this
+                                 * test, but as we are holding a reference to
+                                 * 'sh', we know that if that happens,
+                                 *  STRIPE_EXPANDING will get set and the expansion
+                                 * won't proceed until we finish with the stripe.
+                                 */
+                                int must_retry = 0;
+                                spin_lock_irq(&conf->device_lock);
+                                if (logical_sector <  conf->expand_progress &&
+                                    disks == conf->previous_raid_disks)
+                                        /* mismatch, need to try again */
+                                        must_retry = 1;
+                                spin_unlock_irq(&conf->device_lock);
+                                if (must_retry) {
+                                        release_stripe(sh);
+                                        goto retry;
+                                }
+                        }
+                        /* FIXME what if we get a false positive because these
+                         * are being updated.
+                         */
+                        if (logical_sector >= mddev->suspend_lo &&
+                            logical_sector < mddev->suspend_hi) {
+                                release_stripe(sh);
+                                schedule();
+                                goto retry;
+                        }
+
+                        if (test_bit(STRIPE_EXPANDING, &sh->state) ||
+                            !add_stripe_bio(sh, bi, dd_idx, (bi->bi_rw&RW_MASK))) {
+                                /* Stripe is busy expanding or
+                                 * add failed due to overlap.  Flush everything
                                  * and wait a while
                                  */
                                 raid5_unplug_device(mddev->queue);
@@ -1580,7 +1844,6 @@ static int make_request (request_queue_t *q, struct bio * bi)
                         raid5_plug_device(conf);
                         handle_stripe(sh);
                         release_stripe(sh);
-
                 } else {
                         /* cannot get stripe for read-ahead, just give-up */
                         clear_bit(BIO_UPTODATE, &bi->bi_flags);
@@ -1590,7 +1853,9 @@ static int make_request (request_queue_t *q, struct bio * bi)
                         
         }
         spin_lock_irq(&conf->device_lock);
-        if (--bi->bi_phys_segments == 0) {
+        remaining = --bi->bi_phys_segments;
+        spin_unlock_irq(&conf->device_lock);
+        if (remaining == 0) {
                 int bytes = bi->bi_size;
 
                 if ( bio_data_dir(bi) == WRITE )
@@ -1598,7 +1863,6 @@ static int make_request (request_queue_t *q, struct bio * bi)
                 bi->bi_size = 0;
                 bi->bi_end_io(bi, bytes, 0);
         }
-        spin_unlock_irq(&conf->device_lock);
         return 0;
 }
 
@@ -1607,12 +1871,8 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
 {
         raid5_conf_t *conf = (raid5_conf_t *) mddev->private;
         struct stripe_head *sh;
-        int sectors_per_chunk = conf->chunk_size >> 9;
-        sector_t x;
-        unsigned long stripe;
-        int chunk_offset;
-        int dd_idx, pd_idx;
-        sector_t first_sector;
+        int pd_idx;
+        sector_t first_sector, last_sector;
         int raid_disks = conf->raid_disks;
         int data_disks = raid_disks-1;
         sector_t max_sector = mddev->size << 1;
@@ -1621,6 +1881,10 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
         if (sector_nr >= max_sector) {
                 /* just being told to finish up .. nothing much to do */
                 unplug_slaves(mddev);
+                if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
+                        end_reshape(conf);
+                        return 0;
+                }
 
                 if (mddev->curr_resync < max_sector) /* aborted */
                         bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
@@ -1631,6 +1895,123 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
 
                 return 0;
         }
+
+        if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
+                /* reshaping is quite different to recovery/resync so it is
+                 * handled quite separately ... here.
+                 *
+                 * On each call to sync_request, we gather one chunk worth of
+                 * destination stripes and flag them as expanding.
+                 * Then we find all the source stripes and request reads.
+                 * As the reads complete, handle_stripe will copy the data
+                 * into the destination stripe and release that stripe.
+                 */
+                int i;
+                int dd_idx;
+                sector_t writepos, safepos, gap;
+
+                if (sector_nr == 0 &&
+                    conf->expand_progress != 0) {
+                        /* restarting in the middle, skip the initial sectors */
+                        sector_nr = conf->expand_progress;
+                        sector_div(sector_nr, conf->raid_disks-1);
+                        *skipped = 1;
+                        return sector_nr;
+                }
+
+                /* we update the metadata when there is more than 3Meg
+                 * in the block range (that is rather arbitrary, should
+                 * probably be time based) or when the data about to be
+                 * copied would over-write the source of the data at
+                 * the front of the range.
+                 * i.e. one new_stripe forward from expand_progress new_maps
+                 * to after where expand_lo old_maps to
+                 */
+                writepos = conf->expand_progress +
+                        conf->chunk_size/512*(conf->raid_disks-1);
+                sector_div(writepos, conf->raid_disks-1);
+                safepos = conf->expand_lo;
+                sector_div(safepos, conf->previous_raid_disks-1);
+                gap = conf->expand_progress - conf->expand_lo;
+
+                if (writepos >= safepos ||
+                    gap > (conf->raid_disks-1)*3000*2 /*3Meg*/) {
+                        /* Cannot proceed until we've updated the superblock... */
+                        wait_event(conf->wait_for_overlap,
+                                   atomic_read(&conf->reshape_stripes)==0);
+                        mddev->reshape_position = conf->expand_progress;
+                        mddev->sb_dirty = 1;
+                        md_wakeup_thread(mddev->thread);
+                        wait_event(mddev->sb_wait, mddev->sb_dirty == 0 ||
+                                   kthread_should_stop());
+                        spin_lock_irq(&conf->device_lock);
+                        conf->expand_lo = mddev->reshape_position;
+                        spin_unlock_irq(&conf->device_lock);
+                        wake_up(&conf->wait_for_overlap);
+                }
+
+                for (i=0; i < conf->chunk_size/512; i+= STRIPE_SECTORS) {
+                        int j;
+                        int skipped = 0;
+                        pd_idx = stripe_to_pdidx(sector_nr+i, conf, conf->raid_disks);
+                        sh = get_active_stripe(conf, sector_nr+i,
+                                               conf->raid_disks, pd_idx, 0);
+                        set_bit(STRIPE_EXPANDING, &sh->state);
+                        atomic_inc(&conf->reshape_stripes);
+                        /* If any of this stripe is beyond the end of the old
+                         * array, then we need to zero those blocks
+                         */
+                        for (j=sh->disks; j--;) {
+                                sector_t s;
+                                if (j == sh->pd_idx)
+                                        continue;
+                                s = compute_blocknr(sh, j);
+                                if (s < (mddev->array_size<<1)) {
+                                        skipped = 1;
+                                        continue;
+                                }
+                                memset(page_address(sh->dev[j].page), 0, STRIPE_SIZE);
+                                set_bit(R5_Expanded, &sh->dev[j].flags);
+                                set_bit(R5_UPTODATE, &sh->dev[j].flags);
+                        }
+                        if (!skipped) {
+                                set_bit(STRIPE_EXPAND_READY, &sh->state);
+                                set_bit(STRIPE_HANDLE, &sh->state);
+                        }
+                        release_stripe(sh);
+                }
+                spin_lock_irq(&conf->device_lock);
+                conf->expand_progress = (sector_nr + i)*(conf->raid_disks-1);
+                spin_unlock_irq(&conf->device_lock);
+                /* Ok, those stripe are ready. We can start scheduling
+                 * reads on the source stripes.
+                 * The source stripes are determined by mapping the first and last
+                 * block on the destination stripes.
+                 */
+                raid_disks = conf->previous_raid_disks;
+                data_disks = raid_disks - 1;
+                first_sector =
+                        raid5_compute_sector(sector_nr*(conf->raid_disks-1),
+                                             raid_disks, data_disks,
+                                             &dd_idx, &pd_idx, conf);
+                last_sector =
+                        raid5_compute_sector((sector_nr+conf->chunk_size/512)
+                                               *(conf->raid_disks-1) -1,
+                                             raid_disks, data_disks,
+                                             &dd_idx, &pd_idx, conf);
+                if (last_sector >= (mddev->size<<1))
+                        last_sector = (mddev->size<<1)-1;
+                while (first_sector <= last_sector) {
+                        pd_idx = stripe_to_pdidx(first_sector, conf, conf->previous_raid_disks);
+                        sh = get_active_stripe(conf, first_sector,
+                                               conf->previous_raid_disks, pd_idx, 0);
+                        set_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+                        set_bit(STRIPE_HANDLE, &sh->state);
+                        release_stripe(sh);
+                        first_sector += STRIPE_SECTORS;
+                }
+                return conf->chunk_size>>9;
+        }
         /* if there is 1 or more failed drives and we are trying
          * to resync, then assert that we are finished, because there is
          * nothing we can do.
@@ -1649,16 +2030,10 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
                 return sync_blocks * STRIPE_SECTORS; /* keep things rounded to whole stripes */
         }
 
-        x = sector_nr;
-        chunk_offset = sector_div(x, sectors_per_chunk);
-        stripe = x;
-        BUG_ON(x != stripe);
-
-        first_sector = raid5_compute_sector((sector_t)stripe*data_disks*sectors_per_chunk
-                + chunk_offset, raid_disks, data_disks, &dd_idx, &pd_idx, conf);
-        sh = get_active_stripe(conf, sector_nr, pd_idx, 1);
+        pd_idx = stripe_to_pdidx(sector_nr, conf, raid_disks);
+        sh = get_active_stripe(conf, sector_nr, raid_disks, pd_idx, 1);
         if (sh == NULL) {
-                sh = get_active_stripe(conf, sector_nr, pd_idx, 0);
+                sh = get_active_stripe(conf, sector_nr, raid_disks, pd_idx, 0);
                 /* make sure we don't swamp the stripe cache if someone else
                  * is trying to get access 
                  */
@@ -1822,11 +2197,64 @@ static int run(mddev_t *mddev)
                 return -EIO;
         }
 
-        mddev->private = kzalloc(sizeof (raid5_conf_t)
-                                 + mddev->raid_disks * sizeof(struct disk_info),
-                                 GFP_KERNEL);
+        if (mddev->reshape_position != MaxSector) {
+                /* Check that we can continue the reshape.
+                 * Currently only disks can change, it must
+                 * increase, and we must be past the point where
+                 * a stripe over-writes itself
+                 */
+                sector_t here_new, here_old;
+                int old_disks;
+
+                if (mddev->new_level != mddev->level ||
+                    mddev->new_layout != mddev->layout ||
+                    mddev->new_chunk != mddev->chunk_size) {
+                        printk(KERN_ERR "raid5: %s: unsupported reshape required - aborting.\n",
+                               mdname(mddev));
+                        return -EINVAL;
+                }
+                if (mddev->delta_disks <= 0) {
+                        printk(KERN_ERR "raid5: %s: unsupported reshape (reduce disks) required - aborting.\n",
+                               mdname(mddev));
+                        return -EINVAL;
+                }
+                old_disks = mddev->raid_disks - mddev->delta_disks;
+                /* reshape_position must be on a new-stripe boundary, and one
+                 * further up in new geometry must map after here in old geometry.
+                 */
+                here_new = mddev->reshape_position;
+                if (sector_div(here_new, (mddev->chunk_size>>9)*(mddev->raid_disks-1))) {
+                        printk(KERN_ERR "raid5: reshape_position not on a stripe boundary\n");
+                        return -EINVAL;
+                }
+                /* here_new is the stripe we will write to */
+                here_old = mddev->reshape_position;
+                sector_div(here_old, (mddev->chunk_size>>9)*(old_disks-1));
+                /* here_old is the first stripe that we might need to read from */
+                if (here_new >= here_old) {
+                        /* Reading from the same stripe as writing to - bad */
+                        printk(KERN_ERR "raid5: reshape_position too early for auto-recovery - aborting.\n");
+                        return -EINVAL;
+                }
+                printk(KERN_INFO "raid5: reshape will continue\n");
+                /* OK, we should be able to continue; */
+        }
+
+
+        mddev->private = kzalloc(sizeof (raid5_conf_t), GFP_KERNEL);
         if ((conf = mddev->private) == NULL)
                 goto abort;
+        if (mddev->reshape_position == MaxSector) {
+                conf->previous_raid_disks = conf->raid_disks = mddev->raid_disks;
+        } else {
+                conf->raid_disks = mddev->raid_disks;
+                conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks;
+        }
+
+        conf->disks = kzalloc(conf->raid_disks * sizeof(struct disk_info),
+                              GFP_KERNEL);
+        if (!conf->disks)
+                goto abort;
 
         conf->mddev = mddev;
 
@@ -1847,7 +2275,7 @@ static int run(mddev_t *mddev)
 
         ITERATE_RDEV(mddev,rdev,tmp) {
                 raid_disk = rdev->raid_disk;
-                if (raid_disk >= mddev->raid_disks
+                if (raid_disk >= conf->raid_disks
                     || raid_disk < 0)
                         continue;
                 disk = conf->disks + raid_disk;
@@ -1863,7 +2291,6 @@ static int run(mddev_t *mddev)
                 }
         }
 
-        conf->raid_disks = mddev->raid_disks;
         /*
          * 0 for a fully functional array, 1 for a degraded array.
          */
@@ -1873,6 +2300,7 @@ static int run(mddev_t *mddev)
         conf->level = mddev->level;
         conf->algorithm = mddev->layout;
         conf->max_nr_stripes = NR_STRIPES;
+        conf->expand_progress = mddev->reshape_position;
 
         /* device size must be a multiple of chunk size */
         mddev->size &= ~(mddev->chunk_size/1024 -1);
@@ -1945,6 +2373,21 @@ static int run(mddev_t *mddev)
 
         print_raid5_conf(conf);
 
+        if (conf->expand_progress != MaxSector) {
+                printk("...ok start reshape thread\n");
+                conf->expand_lo = conf->expand_progress;
+                atomic_set(&conf->reshape_stripes, 0);
+                clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
+                clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+                set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
+                set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
+                mddev->sync_thread = md_register_thread(md_do_sync, mddev,
+                                                        "%s_reshape");
+                /* FIXME if md_register_thread fails?? */
+                md_wakeup_thread(mddev->sync_thread);
+
+        }
+
         /* read-ahead size must cover two whole stripes, which is
          * 2 * (n-1) * chunksize where 'n' is the number of raid devices
          */
@@ -1960,12 +2403,13 @@ static int run(mddev_t *mddev)
 
         mddev->queue->unplug_fn = raid5_unplug_device;
         mddev->queue->issue_flush_fn = raid5_issue_flush;
+        mddev->array_size =  mddev->size * (conf->previous_raid_disks - 1);
 
-        mddev->array_size =  mddev->size * (mddev->raid_disks - 1);
         return 0;
 abort:
         if (conf) {
                 print_raid5_conf(conf);
+                kfree(conf->disks);
                 kfree(conf->stripe_hashtbl);
                 kfree(conf);
         }
@@ -1986,6 +2430,7 @@ static int stop(mddev_t *mddev)
         kfree(conf->stripe_hashtbl);
         blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
         sysfs_remove_group(&mddev->kobj, &raid5_attrs_group);
+        kfree(conf->disks);
         kfree(conf);
         mddev->private = NULL;
         return 0;
@@ -2001,7 +2446,7 @@ static void print_sh (struct stripe_head *sh)
         printk("sh %llu,  count %d.\n",
                 (unsigned long long)sh->sector, atomic_read(&sh->count));
         printk("sh %llu, ", (unsigned long long)sh->sector);
-        for (i = 0; i < sh->raid_conf->raid_disks; i++) {
+        for (i = 0; i < sh->disks; i++) {
                 printk("(cache%d: %p %ld) ", 
                         i, sh->dev[i].page, sh->dev[i].flags);
         }
@@ -2132,7 +2577,7 @@ static int raid5_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         /*
          * find the disk ...
          */
-        for (disk=0; disk < mddev->raid_disks; disk++)
+        for (disk=0; disk < conf->raid_disks; disk++)
                 if ((p=conf->disks + disk)->rdev == NULL) {
                         clear_bit(In_sync, &rdev->flags);
                         rdev->raid_disk = disk;
@@ -2168,11 +2613,146 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
         return 0;
 }
 
+#ifdef CONFIG_MD_RAID5_RESHAPE
+static int raid5_check_reshape(mddev_t *mddev)
+{
+        raid5_conf_t *conf = mddev_to_conf(mddev);
+        int err;
+
+        if (mddev->delta_disks < 0 ||
+            mddev->new_level != mddev->level)
+                return -EINVAL; /* Cannot shrink array or change level yet */
+        if (mddev->delta_disks == 0)
+                return 0; /* nothing to do */
+
+        /* Can only proceed if there are plenty of stripe_heads.
+         * We need a minimum of one full stripe,, and for sensible progress
+         * it is best to have about 4 times that.
+         * If we require 4 times, then the default 256 4K stripe_heads will
+         * allow for chunk sizes up to 256K, which is probably OK.
+         * If the chunk size is greater, user-space should request more
+         * stripe_heads first.
+         */
+        if ((mddev->chunk_size / STRIPE_SIZE) * 4 > conf->max_nr_stripes ||
+            (mddev->new_chunk / STRIPE_SIZE) * 4 > conf->max_nr_stripes) {
+                printk(KERN_WARNING "raid5: reshape: not enough stripes.  Needed %lu\n",
+                       (mddev->chunk_size / STRIPE_SIZE)*4);
+                return -ENOSPC;
+        }
+
+        err = resize_stripes(conf, conf->raid_disks + mddev->delta_disks);
+        if (err)
+                return err;
+
+        /* looks like we might be able to manage this */
+        return 0;
+}
+
+static int raid5_start_reshape(mddev_t *mddev)
+{
+        raid5_conf_t *conf = mddev_to_conf(mddev);
+        mdk_rdev_t *rdev;
+        struct list_head *rtmp;
+        int spares = 0;
+        int added_devices = 0;
+
+        if (mddev->degraded ||
+            test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
+                return -EBUSY;
+
+        ITERATE_RDEV(mddev, rdev, rtmp)
+                if (rdev->raid_disk < 0 &&
+                    !test_bit(Faulty, &rdev->flags))
+                        spares++;
+
+        if (spares < mddev->delta_disks-1)
+                /* Not enough devices even to make a degraded array
+                 * of that size
+                 */
+                return -EINVAL;
+
+        atomic_set(&conf->reshape_stripes, 0);
+        spin_lock_irq(&conf->device_lock);
+        conf->previous_raid_disks = conf->raid_disks;
+        conf->raid_disks += mddev->delta_disks;
+        conf->expand_progress = 0;
+        conf->expand_lo = 0;
+        spin_unlock_irq(&conf->device_lock);
+
+        /* Add some new drives, as many as will fit.
+         * We know there are enough to make the newly sized array work.
+         */
+        ITERATE_RDEV(mddev, rdev, rtmp)
+                if (rdev->raid_disk < 0 &&
+                    !test_bit(Faulty, &rdev->flags)) {
+                        if (raid5_add_disk(mddev, rdev)) {
+                                char nm[20];
+                                set_bit(In_sync, &rdev->flags);
+                                conf->working_disks++;
+                                added_devices++;
+                                sprintf(nm, "rd%d", rdev->raid_disk);
+                                sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
+                        } else
+                                break;
+                }
+
+        mddev->degraded = (conf->raid_disks - conf->previous_raid_disks) - added_devices;
+        mddev->raid_disks = conf->raid_disks;
+        mddev->reshape_position = 0;
+        mddev->sb_dirty = 1;
+
+        clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
+        clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+        set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
+        set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
+        mddev->sync_thread = md_register_thread(md_do_sync, mddev,
+                                                "%s_reshape");
+        if (!mddev->sync_thread) {
+                mddev->recovery = 0;
+                spin_lock_irq(&conf->device_lock);
+                mddev->raid_disks = conf->raid_disks = conf->previous_raid_disks;
+                conf->expand_progress = MaxSector;
+                spin_unlock_irq(&conf->device_lock);
+                return -EAGAIN;
+        }
+        md_wakeup_thread(mddev->sync_thread);
+        md_new_event(mddev);
+        return 0;
+}
+#endif
+
+static void end_reshape(raid5_conf_t *conf)
+{
+        struct block_device *bdev;
+
+        if (!test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {
+                conf->mddev->array_size = conf->mddev->size * (conf->raid_disks-1);
+                set_capacity(conf->mddev->gendisk, conf->mddev->array_size << 1);
+                conf->mddev->changed = 1;
+
+                bdev = bdget_disk(conf->mddev->gendisk, 0);
+                if (bdev) {
+                        mutex_lock(&bdev->bd_inode->i_mutex);
+                        i_size_write(bdev->bd_inode, conf->mddev->array_size << 10);
+                        mutex_unlock(&bdev->bd_inode->i_mutex);
+                        bdput(bdev);
+                }
+                spin_lock_irq(&conf->device_lock);
+                conf->expand_progress = MaxSector;
+                spin_unlock_irq(&conf->device_lock);
+                conf->mddev->reshape_position = MaxSector;
+        }
+}
+
 static void raid5_quiesce(mddev_t *mddev, int state)
 {
         raid5_conf_t *conf = mddev_to_conf(mddev);
 
         switch(state) {
+        case 2: /* resume for a suspend */
+                wake_up(&conf->wait_for_overlap);
+                break;
+
         case 1: /* stop all writes */
                 spin_lock_irq(&conf->device_lock);
                 conf->quiesce = 1;
@@ -2186,6 +2766,7 @@ static void raid5_quiesce(mddev_t *mddev, int state)
                 spin_lock_irq(&conf->device_lock);
                 conf->quiesce = 0;
                 wake_up(&conf->wait_for_stripe);
+                wake_up(&conf->wait_for_overlap);
                 spin_unlock_irq(&conf->device_lock);
                 break;
         }
@@ -2206,6 +2787,10 @@ static struct mdk_personality raid5_personality =
         .spare_active   = raid5_spare_active,
         .sync_request   = sync_request,
         .resize         = raid5_resize,
+#ifdef CONFIG_MD_RAID5_RESHAPE
+        .check_reshape  = raid5_check_reshape,
+        .start_reshape  = raid5_start_reshape,
+#endif
         .quiesce        = raid5_quiesce,
 };
 
diff --git a/drivers/md/raid6main.c b/drivers/md/raid6main.c
index cd477ebf2ee4..6df4930fddec 100644
--- a/drivers/md/raid6main.c
+++ b/drivers/md/raid6main.c
@@ -331,9 +331,9 @@ static int grow_stripes(raid6_conf_t *conf, int num)
         kmem_cache_t *sc;
         int devs = conf->raid_disks;
 
-        sprintf(conf->cache_name, "raid6/%s", mdname(conf->mddev));
+        sprintf(conf->cache_name[0], "raid6/%s", mdname(conf->mddev));
 
-        sc = kmem_cache_create(conf->cache_name,
+        sc = kmem_cache_create(conf->cache_name[0],
                                sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
                                0, 0, NULL, NULL);
         if (!sc)
@@ -2006,11 +2006,14 @@ static int run(mddev_t *mddev)
                 return -EIO;
         }
 
-        mddev->private = kzalloc(sizeof (raid6_conf_t)
-                                 + mddev->raid_disks * sizeof(struct disk_info),
-                                 GFP_KERNEL);
+        mddev->private = kzalloc(sizeof (raid6_conf_t), GFP_KERNEL);
         if ((conf = mddev->private) == NULL)
                 goto abort;
+        conf->disks = kzalloc(mddev->raid_disks * sizeof(struct disk_info),
+                                 GFP_KERNEL);
+        if (!conf->disks)
+                goto abort;
+
         conf->mddev = mddev;
 
         if ((conf->stripe_hashtbl = kzalloc(PAGE_SIZE, GFP_KERNEL)) == NULL)
@@ -2158,6 +2161,7 @@ abort:
                 print_raid6_conf(conf);
                 safe_put_page(conf->spare_page);
                 kfree(conf->stripe_hashtbl);
+                kfree(conf->disks);
                 kfree(conf);
         }
         mddev->private = NULL;
diff --git a/drivers/misc/ibmasm/heartbeat.c b/drivers/misc/ibmasm/heartbeat.c
index f295401fac21..7fd7a43e38de 100644
--- a/drivers/misc/ibmasm/heartbeat.c
+++ b/drivers/misc/ibmasm/heartbeat.c
@@ -52,12 +52,13 @@ static struct notifier_block panic_notifier = { panic_happened, NULL, 1 };
 
 void ibmasm_register_panic_notifier(void)
 {
-        notifier_chain_register(&panic_notifier_list, &panic_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_notifier);
 }
 
 void ibmasm_unregister_panic_notifier(void)
 {
-        notifier_chain_unregister(&panic_notifier_list, &panic_notifier);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &panic_notifier);
 }
 
 
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 2d0ac169a86c..f13a539dc169 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3159,7 +3159,7 @@ static int bond_slave_netdev_event(unsigned long event, struct net_device *slave
  * bond_netdev_event: handle netdev notifier chain events.
  *
  * This function receives events for the netdev chain.  The caller (an
- * ioctl handler calling notifier_call_chain) holds the necessary
+ * ioctl handler calling blocking_notifier_call_chain) holds the necessary
  * locks for us to safely manipulate the slave devices (RTNL lock,
  * dev_probe_lock).
  */
diff --git a/drivers/net/irda/nsc-ircc.c b/drivers/net/irda/nsc-ircc.c
index 83141a3ff546..9aa074b44dd3 100644
--- a/drivers/net/irda/nsc-ircc.c
+++ b/drivers/net/irda/nsc-ircc.c
@@ -207,7 +207,7 @@ static int __init nsc_ircc_init(void)
         /* Register with PnP subsystem to detect disable ports */
         ret = pnp_register_driver(&nsc_ircc_pnp_driver);
 
-        if (ret >= 0)
+        if (!ret)
                 pnp_registered = 1;
 
         ret = -ENODEV;
diff --git a/drivers/parisc/led.c b/drivers/parisc/led.c
index 3627a2d7f79f..298f2ddb2c17 100644
--- a/drivers/parisc/led.c
+++ b/drivers/parisc/led.c
@@ -499,11 +499,16 @@ static int led_halt(struct notifier_block *, unsigned long, void *);
 static struct notifier_block led_notifier = {
         .notifier_call = led_halt,
 };
+static int notifier_disabled = 0;
 
 static int led_halt(struct notifier_block *nb, unsigned long event, void *buf) 
 {
         char *txt;
-        
+
+        if (notifier_disabled)
+                return NOTIFY_OK;
+
+        notifier_disabled = 1;
         switch (event) {
         case SYS_RESTART:       txt = "SYSTEM RESTART";
                                 break;
@@ -527,7 +532,6 @@ static int led_halt(struct notifier_block *nb, unsigned long event, void *buf)
                 if (led_func_ptr)
                         led_func_ptr(0xff); /* turn all LEDs ON */
         
-        unregister_reboot_notifier(&led_notifier);
         return NOTIFY_OK;
 }
 
@@ -758,6 +762,12 @@ not_found:
         return 1;
 }
 
+static void __exit led_exit(void)
+{
+        unregister_reboot_notifier(&led_notifier);
+        return;
+}
+
 #ifdef CONFIG_PROC_FS
 module_init(led_create_procfs)
 #endif
diff --git a/drivers/parisc/power.c b/drivers/parisc/power.c
index 54b2b7f20b96..0bcab83b4080 100644
--- a/drivers/parisc/power.c
+++ b/drivers/parisc/power.c
@@ -251,7 +251,8 @@ static int __init power_init(void)
         }
 
         /* Register a call for panic conditions. */
-        notifier_chain_register(&panic_notifier_list, &parisc_panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &parisc_panic_block);
 
         tasklet_enable(&power_tasklet);
 
@@ -264,7 +265,8 @@ static void __exit power_exit(void)
                 return;
 
         tasklet_disable(&power_tasklet);
-        notifier_chain_unregister(&panic_notifier_list, &parisc_panic_block);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &parisc_panic_block);
         power_tasklet.func = NULL;
         pdc_soft_power_button(0);
 }
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 9302b8fd7461..d5890027f8af 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -3126,9 +3126,9 @@ parport_pc_find_isa_ports (int autoirq, int autodma)
  * autoirq is PARPORT_IRQ_NONE, PARPORT_IRQ_AUTO, or PARPORT_IRQ_PROBEONLY
  * autodma is PARPORT_DMA_NONE or PARPORT_DMA_AUTO
  */
-static int __init parport_pc_find_ports (int autoirq, int autodma)
+static void __init parport_pc_find_ports (int autoirq, int autodma)
 {
-        int count = 0, r;
+        int count = 0, err;
 
 #ifdef CONFIG_PARPORT_PC_SUPERIO
         detect_and_report_winbond ();
@@ -3140,23 +3140,17 @@ static int __init parport_pc_find_ports (int autoirq, int autodma)
 
         /* PnP ports, skip detection if SuperIO already found them */
         if (!count) {
-                r = pnp_register_driver (&parport_pc_pnp_driver);
-                if (r >= 0) {
+                err = pnp_register_driver (&parport_pc_pnp_driver);
+                if (!err)
                         pnp_registered_parport = 1;
-                        count += r;
-                }
         }
 
         /* ISA ports and whatever (see asm/parport.h). */
-        count += parport_pc_find_nonpci_ports (autoirq, autodma);
-
-        r = pci_register_driver (&parport_pc_pci_driver);
-        if (r)
-                return r;
-        pci_registered_parport = 1;
-        count += 1;
+        parport_pc_find_nonpci_ports (autoirq, autodma);
 
-        return count;
+        err = pci_register_driver (&parport_pc_pci_driver);
+        if (!err)
+                pci_registered_parport = 1;
 }
 
 /*
@@ -3381,8 +3375,6 @@ __setup("parport_init_mode=",parport_init_mode_setup);
 
 static int __init parport_pc_init(void)
 {
-        int count = 0;
-
         if (parse_parport_params())
                 return -EINVAL;
 
@@ -3395,12 +3387,11 @@ static int __init parport_pc_init(void)
                                 break;
                         if ((io_hi[i]) == PARPORT_IOHI_AUTO)
                                io_hi[i] = 0x400 + io[i];
-                        if (parport_pc_probe_port(io[i], io_hi[i],
-                                                  irqval[i], dmaval[i], NULL))
-                                count++;
+                        parport_pc_probe_port(io[i], io_hi[i],
+                                                  irqval[i], dmaval[i], NULL);
                 }
         } else
-                count += parport_pc_find_ports (irqval[0], dmaval[0]);
+                parport_pc_find_ports (irqval[0], dmaval[0]);
 
         return 0;
 }
diff --git a/drivers/pnp/card.c b/drivers/pnp/card.c
index b68eef251614..bb19c64073c6 100644
--- a/drivers/pnp/card.c
+++ b/drivers/pnp/card.c
@@ -47,7 +47,7 @@ static void card_remove(struct pnp_dev * dev)
 {
         dev->card_link = NULL;
 }
- 
+
 static void card_remove_first(struct pnp_dev * dev)
 {
         struct pnp_card_driver * drv = to_pnp_card_driver(dev->driver);
@@ -361,7 +361,7 @@ static int card_resume(struct pnp_dev *dev)
 
 int pnp_register_card_driver(struct pnp_card_driver * drv)
 {
-        int count;
+        int error;
         struct list_head *pos, *temp;
 
         drv->link.name = drv->name;
@@ -372,21 +372,19 @@ int pnp_register_card_driver(struct pnp_card_driver * drv)
         drv->link.suspend = drv->suspend ? card_suspend : NULL;
         drv->link.resume = drv->resume ? card_resume : NULL;
 
-        count = pnp_register_driver(&drv->link);
-        if (count < 0)
-                return count;
+        error = pnp_register_driver(&drv->link);
+        if (error < 0)
+                return error;
 
         spin_lock(&pnp_lock);
         list_add_tail(&drv->global_list, &pnp_card_drivers);
         spin_unlock(&pnp_lock);
 
-        count = 0;
-
         list_for_each_safe(pos,temp,&pnp_cards){
                 struct pnp_card *card = list_entry(pos, struct pnp_card, global_list);
-                count += card_probe(card,drv);
+                card_probe(card,drv);
         }
-        return count;
+        return 0;
 }
 
 /**
diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c
index 7cafacdd12b0..e54c15383193 100644
--- a/drivers/pnp/driver.c
+++ b/drivers/pnp/driver.c
@@ -201,31 +201,14 @@ struct bus_type pnp_bus_type = {
         .resume = pnp_bus_resume,
 };
 
-
-static int count_devices(struct device * dev, void * c)
-{
-        int * count = c;
-        (*count)++;
-        return 0;
-}
-
 int pnp_register_driver(struct pnp_driver *drv)
 {
-        int count;
-
         pnp_dbg("the driver '%s' has been registered", drv->name);
 
         drv->driver.name = drv->name;
         drv->driver.bus = &pnp_bus_type;
 
-        count = driver_register(&drv->driver);
-
-        /* get the number of initial matches */
-        if (count >= 0){
-                count = 0;
-                driver_for_each_device(&drv->driver, NULL, &count, count_devices);
-        }
-        return count;
+        return driver_register(&drv->driver);
 }
 
 void pnp_unregister_driver(struct pnp_driver *drv)
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
new file mode 100644
index 000000000000..929dd8090578
--- /dev/null
+++ b/drivers/rtc/Kconfig
@@ -0,0 +1,165 @@
+\#
+# RTC class/drivers configuration
+#
+
+menu "Real Time Clock"
+
+config RTC_LIB
+        tristate
+
+config RTC_CLASS
+        tristate "RTC class"
+        depends on EXPERIMENTAL
+        default n
+        select RTC_LIB
+        help
+          Generic RTC class support. If you say yes here, you will
+          be allowed to plug one or more RTCs to your system. You will
+          probably want to enable one of more of the interfaces below.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-class.
+
+config RTC_HCTOSYS
+        bool "Set system time from RTC on startup"
+        depends on RTC_CLASS = y
+        default y
+        help
+          If you say yes here, the system time will be set using
+          the value read from the specified RTC device. This is useful
+          in order to avoid unnecessary fschk runs.
+
+config RTC_HCTOSYS_DEVICE
+        string "The RTC to read the time from"
+        depends on RTC_HCTOSYS = y
+        default "rtc0"
+        help
+          The RTC device that will be used as the source for
+          the system time, usually rtc0.
+
+comment "RTC interfaces"
+        depends on RTC_CLASS
+
+config RTC_INTF_SYSFS
+        tristate "sysfs"
+        depends on RTC_CLASS && SYSFS
+        default RTC_CLASS
+        help
+          Say yes here if you want to use your RTC using the sysfs
+          interface, /sys/class/rtc/rtcX .
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-sysfs.
+
+config RTC_INTF_PROC
+        tristate "proc"
+        depends on RTC_CLASS && PROC_FS
+        default RTC_CLASS
+        help
+          Say yes here if you want to use your RTC using the proc
+          interface, /proc/driver/rtc .
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-proc.
+
+config RTC_INTF_DEV
+        tristate "dev"
+        depends on RTC_CLASS
+        default RTC_CLASS
+        help
+          Say yes here if you want to use your RTC using the dev
+          interface, /dev/rtc .
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-dev.
+
+comment "RTC drivers"
+        depends on RTC_CLASS
+
+config RTC_DRV_X1205
+        tristate "Xicor/Intersil X1205"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Xicor/Intersil X1205 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-x1205.
+
+config RTC_DRV_DS1672
+        tristate "Dallas/Maxim DS1672"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Dallas/Maxim DS1672 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1672.
+
+config RTC_DRV_PCF8563
+        tristate "Philips PCF8563/Epson RTC8564"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Philips PCF8563 RTC chip. The Epson RTC8564
+          should work as well.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-pcf8563.
+
+config RTC_DRV_RS5C372
+        tristate "Ricoh RS5C372A/B"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Ricoh RS5C372A and RS5C372B RTC chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rs5c372.
+
+config RTC_DRV_M48T86
+        tristate "ST M48T86/Dallas DS12887"
+        depends on RTC_CLASS
+        help
+          If you say Y here you will get support for the
+          ST M48T86 and Dallas DS12887 RTC chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-m48t86.
+
+config RTC_DRV_EP93XX
+        tristate "Cirrus Logic EP93XX"
+        depends on RTC_CLASS && ARCH_EP93XX
+        help
+          If you say yes here you get support for the
+          RTC embedded in the Cirrus Logic EP93XX processors.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ep93xx.
+
+config RTC_DRV_SA1100
+        tristate "SA11x0/PXA2xx"
+        depends on RTC_CLASS && (ARCH_SA1100 || ARCH_PXA)
+        help
+          If you say Y here you will get access to the real time clock
+          built into your SA11x0 or PXA2xx CPU.
+
+          To compile this driver as a module, choose M here: the
+          module will be called rtc-sa1100.
+
+config RTC_DRV_TEST
+        tristate "Test driver/device"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          RTC test driver. It's a software RTC which can be
+          used to test the RTC subsystem APIs. It gets
+          the time from the system clock.
+          You want this driver only if you are doing development
+          on the RTC subsystem. Please read the source code
+          for further details.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-test.
+
+endmenu
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
new file mode 100644
index 000000000000..8d4c7fe88d58
--- /dev/null
+++ b/drivers/rtc/Makefile
@@ -0,0 +1,21 @@
+#
+# Makefile for RTC class/drivers.
+#
+
+obj-$(CONFIG_RTC_LIB)           += rtc-lib.o
+obj-$(CONFIG_RTC_HCTOSYS)       += hctosys.o
+obj-$(CONFIG_RTC_CLASS)         += rtc-core.o
+rtc-core-y                      := class.o interface.o
+
+obj-$(CONFIG_RTC_INTF_SYSFS)    += rtc-sysfs.o
+obj-$(CONFIG_RTC_INTF_PROC)     += rtc-proc.o
+obj-$(CONFIG_RTC_INTF_DEV)      += rtc-dev.o
+
+obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
+obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
+obj-$(CONFIG_RTC_DRV_DS1672)    += rtc-ds1672.o
+obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
+obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
+obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
+obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
+obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
new file mode 100644
index 000000000000..8533936d50d8
--- /dev/null
+++ b/drivers/rtc/class.c
@@ -0,0 +1,145 @@
+/*
+ * RTC subsystem, base class
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * class skeleton from drivers/hwmon/hwmon.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/kdev_t.h>
+#include <linux/idr.h>
+
+static DEFINE_IDR(rtc_idr);
+static DEFINE_MUTEX(idr_lock);
+struct class *rtc_class;
+
+static void rtc_device_release(struct class_device *class_dev)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+        mutex_lock(&idr_lock);
+        idr_remove(&rtc_idr, rtc->id);
+        mutex_unlock(&idr_lock);
+        kfree(rtc);
+}
+
+/**
+ * rtc_device_register - register w/ RTC class
+ * @dev: the device to register
+ *
+ * rtc_device_unregister() must be called when the class device is no
+ * longer needed.
+ *
+ * Returns the pointer to the new struct class device.
+ */
+struct rtc_device *rtc_device_register(const char *name, struct device *dev,
+                                        struct rtc_class_ops *ops,
+                                        struct module *owner)
+{
+        struct rtc_device *rtc;
+        int id, err;
+
+        if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+
+        mutex_lock(&idr_lock);
+        err = idr_get_new(&rtc_idr, NULL, &id);
+        mutex_unlock(&idr_lock);
+
+        if (err < 0)
+                goto exit;
+
+        id = id & MAX_ID_MASK;
+
+        rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
+        if (rtc == NULL) {
+                err = -ENOMEM;
+                goto exit_idr;
+        }
+
+        rtc->id = id;
+        rtc->ops = ops;
+        rtc->owner = owner;
+        rtc->class_dev.dev = dev;
+        rtc->class_dev.class = rtc_class;
+        rtc->class_dev.release = rtc_device_release;
+
+        mutex_init(&rtc->ops_lock);
+        spin_lock_init(&rtc->irq_lock);
+        spin_lock_init(&rtc->irq_task_lock);
+
+        strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
+        snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id);
+
+        err = class_device_register(&rtc->class_dev);
+        if (err)
+                goto exit_kfree;
+
+        dev_info(dev, "rtc core: registered %s as %s\n",
+                        rtc->name, rtc->class_dev.class_id);
+
+        return rtc;
+
+exit_kfree:
+        kfree(rtc);
+
+exit_idr:
+        idr_remove(&rtc_idr, id);
+
+exit:
+        return ERR_PTR(err);
+}
+EXPORT_SYMBOL_GPL(rtc_device_register);
+
+
+/**
+ * rtc_device_unregister - removes the previously registered RTC class device
+ *
+ * @rtc: the RTC class device to destroy
+ */
+void rtc_device_unregister(struct rtc_device *rtc)
+{
+        mutex_lock(&rtc->ops_lock);
+        rtc->ops = NULL;
+        mutex_unlock(&rtc->ops_lock);
+        class_device_unregister(&rtc->class_dev);
+}
+EXPORT_SYMBOL_GPL(rtc_device_unregister);
+
+int rtc_interface_register(struct class_interface *intf)
+{
+        intf->class = rtc_class;
+        return class_interface_register(intf);
+}
+EXPORT_SYMBOL_GPL(rtc_interface_register);
+
+static int __init rtc_init(void)
+{
+        rtc_class = class_create(THIS_MODULE, "rtc");
+        if (IS_ERR(rtc_class)) {
+                printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
+                return PTR_ERR(rtc_class);
+        }
+        return 0;
+}
+
+static void __exit rtc_exit(void)
+{
+        class_destroy(rtc_class);
+}
+
+module_init(rtc_init);
+module_exit(rtc_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towerteh.it>");
+MODULE_DESCRIPTION("RTC class support");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
new file mode 100644
index 000000000000..d02fe9a0001f
--- /dev/null
+++ b/drivers/rtc/hctosys.c
@@ -0,0 +1,69 @@
+/*
+ * RTC subsystem, initialize system time on startup
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/rtc.h>
+
+/* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
+ * whether it stores the most close value or the value with partial
+ * seconds truncated. However, it is important that we use it to store
+ * the truncated value. This is because otherwise it is necessary,
+ * in an rtc sync function, to read both xtime.tv_sec and
+ * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
+ * of >32bits is not possible. So storing the most close value would
+ * slow down the sync API. So here we have the truncated value and
+ * the best guess is to add 0.5s.
+ */
+
+static int __init rtc_hctosys(void)
+{
+        int err;
+        struct rtc_time tm;
+        struct class_device *class_dev = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
+
+        if (class_dev == NULL) {
+                printk("%s: unable to open rtc device (%s)\n",
+                        __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
+                return -ENODEV;
+        }
+
+        err = rtc_read_time(class_dev, &tm);
+        if (err == 0) {
+                err = rtc_valid_tm(&tm);
+                if (err == 0) {
+                        struct timespec tv;
+
+                        tv.tv_nsec = NSEC_PER_SEC >> 1;
+
+                        rtc_tm_to_time(&tm, &tv.tv_sec);
+
+                        do_settimeofday(&tv);
+
+                        dev_info(class_dev->dev,
+                                "setting the system clock to "
+                                "%d-%02d-%02d %02d:%02d:%02d (%u)\n",
+                                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                                tm.tm_hour, tm.tm_min, tm.tm_sec,
+                                (unsigned int) tv.tv_sec);
+                }
+                else
+                        dev_err(class_dev->dev,
+                                "hctosys: invalid date/time\n");
+        }
+        else
+                dev_err(class_dev->dev,
+                        "hctosys: unable to read the hardware clock\n");
+
+        rtc_class_close(class_dev);
+
+        return 0;
+}
+
+late_initcall(rtc_hctosys);
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
new file mode 100644
index 000000000000..56e490709b87
--- /dev/null
+++ b/drivers/rtc/interface.c
@@ -0,0 +1,277 @@
+/*
+ * RTC subsystem, interface functions
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/rtc.h>
+
+int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->read_time)
+                err = -EINVAL;
+        else {
+                memset(tm, 0, sizeof(struct rtc_time));
+                err = rtc->ops->read_time(class_dev->dev, tm);
+        }
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_read_time);
+
+int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = rtc_valid_tm(tm);
+        if (err != 0)
+                return err;
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->set_time)
+                err = -EINVAL;
+        else
+                err = rtc->ops->set_time(class_dev->dev, tm);
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_set_time);
+
+int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (rtc->ops->set_mmss)
+                err = rtc->ops->set_mmss(class_dev->dev, secs);
+        else if (rtc->ops->read_time && rtc->ops->set_time) {
+                struct rtc_time new, old;
+
+                err = rtc->ops->read_time(class_dev->dev, &old);
+                if (err == 0) {
+                        rtc_time_to_tm(secs, &new);
+
+                        /*
+                         * avoid writing when we're going to change the day of
+                         * the month. We will retry in the next minute. This
+                         * basically means that if the RTC must not drift
+                         * by more than 1 minute in 11 minutes.
+                         */
+                        if (!((old.tm_hour == 23 && old.tm_min == 59) ||
+                                (new.tm_hour == 23 && new.tm_min == 59)))
+                                err = rtc->ops->set_time(class_dev->dev, &new);
+                }
+        }
+        else
+                err = -EINVAL;
+
+        mutex_unlock(&rtc->ops_lock);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_set_mmss);
+
+int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (rtc->ops == NULL)
+                err = -ENODEV;
+        else if (!rtc->ops->read_alarm)
+                err = -EINVAL;
+        else {
+                memset(alarm, 0, sizeof(struct rtc_wkalrm));
+                err = rtc->ops->read_alarm(class_dev->dev, alarm);
+        }
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_read_alarm);
+
+int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->set_alarm)
+                err = -EINVAL;
+        else
+                err = rtc->ops->set_alarm(class_dev->dev, alarm);
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_set_alarm);
+
+void rtc_update_irq(struct class_device *class_dev,
+                unsigned long num, unsigned long events)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        spin_lock(&rtc->irq_lock);
+        rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
+        spin_unlock(&rtc->irq_lock);
+
+        spin_lock(&rtc->irq_task_lock);
+        if (rtc->irq_task)
+                rtc->irq_task->func(rtc->irq_task->private_data);
+        spin_unlock(&rtc->irq_task_lock);
+
+        wake_up_interruptible(&rtc->irq_queue);
+        kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
+}
+EXPORT_SYMBOL_GPL(rtc_update_irq);
+
+struct class_device *rtc_class_open(char *name)
+{
+        struct class_device *class_dev = NULL,
+                                *class_dev_tmp;
+
+        down(&rtc_class->sem);
+        list_for_each_entry(class_dev_tmp, &rtc_class->children, node) {
+                if (strncmp(class_dev_tmp->class_id, name, BUS_ID_SIZE) == 0) {
+                        class_dev = class_dev_tmp;
+                        break;
+                }
+        }
+
+        if (class_dev) {
+                if (!try_module_get(to_rtc_device(class_dev)->owner))
+                        class_dev = NULL;
+        }
+        up(&rtc_class->sem);
+
+        return class_dev;
+}
+EXPORT_SYMBOL_GPL(rtc_class_open);
+
+void rtc_class_close(struct class_device *class_dev)
+{
+        module_put(to_rtc_device(class_dev)->owner);
+}
+EXPORT_SYMBOL_GPL(rtc_class_close);
+
+int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
+{
+        int retval = -EBUSY;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        if (task == NULL || task->func == NULL)
+                return -EINVAL;
+
+        spin_lock(&rtc->irq_task_lock);
+        if (rtc->irq_task == NULL) {
+                rtc->irq_task = task;
+                retval = 0;
+        }
+        spin_unlock(&rtc->irq_task_lock);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(rtc_irq_register);
+
+void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        spin_lock(&rtc->irq_task_lock);
+        if (rtc->irq_task == task)
+                rtc->irq_task = NULL;
+        spin_unlock(&rtc->irq_task_lock);
+}
+EXPORT_SYMBOL_GPL(rtc_irq_unregister);
+
+int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int enabled)
+{
+        int err = 0;
+        unsigned long flags;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        spin_lock_irqsave(&rtc->irq_task_lock, flags);
+        if (rtc->irq_task != task)
+                err = -ENXIO;
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
+
+        if (err == 0)
+                err = rtc->ops->irq_set_state(class_dev->dev, enabled);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_irq_set_state);
+
+int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int freq)
+{
+        int err = 0, tmp = 0;
+        unsigned long flags;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        /* allowed range is 2-8192 */
+        if (freq < 2 || freq > 8192)
+                return -EINVAL;
+/*
+        FIXME: this does not belong here, will move where appropriate
+        at a later stage. It cannot hurt right now, trust me :)
+        if ((freq > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
+                return -EACCES;
+*/
+        /* check if freq is a power of 2 */
+        while (freq > (1 << tmp))
+                tmp++;
+
+        if (freq != (1 << tmp))
+                return -EINVAL;
+
+        spin_lock_irqsave(&rtc->irq_task_lock, flags);
+        if (rtc->irq_task != task)
+                err = -ENXIO;
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
+
+        if (err == 0) {
+                err = rtc->ops->irq_set_freq(class_dev->dev, freq);
+                if (err == 0)
+                        rtc->irq_freq = freq;
+        }
+        return err;
+}
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
new file mode 100644
index 000000000000..b1e3e6179e56
--- /dev/null
+++ b/drivers/rtc/rtc-dev.c
@@ -0,0 +1,382 @@
+/*
+ * RTC subsystem, dev interface
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+
+static struct class *rtc_dev_class;
+static dev_t rtc_devt;
+
+#define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
+
+static int rtc_dev_open(struct inode *inode, struct file *file)
+{
+        int err;
+        struct rtc_device *rtc = container_of(inode->i_cdev,
+                                        struct rtc_device, char_dev);
+        struct rtc_class_ops *ops = rtc->ops;
+
+        /* We keep the lock as long as the device is in use
+         * and return immediately if busy
+         */
+        if (!(mutex_trylock(&rtc->char_lock)))
+                return -EBUSY;
+
+        file->private_data = &rtc->class_dev;
+
+        err = ops->open ? ops->open(rtc->class_dev.dev) : 0;
+        if (err == 0) {
+                spin_lock_irq(&rtc->irq_lock);
+                rtc->irq_data = 0;
+                spin_unlock_irq(&rtc->irq_lock);
+
+                return 0;
+        }
+
+        /* something has gone wrong, release the lock */
+        mutex_unlock(&rtc->char_lock);
+        return err;
+}
+
+
+static ssize_t
+rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+
+        DECLARE_WAITQUEUE(wait, current);
+        unsigned long data;
+        ssize_t ret;
+
+        if (count < sizeof(unsigned long))
+                return -EINVAL;
+
+        add_wait_queue(&rtc->irq_queue, &wait);
+        do {
+                __set_current_state(TASK_INTERRUPTIBLE);
+
+                spin_lock_irq(&rtc->irq_lock);
+                data = rtc->irq_data;
+                rtc->irq_data = 0;
+                spin_unlock_irq(&rtc->irq_lock);
+
+                if (data != 0) {
+                        ret = 0;
+                        break;
+                }
+                if (file->f_flags & O_NONBLOCK) {
+                        ret = -EAGAIN;
+                        break;
+                }
+                if (signal_pending(current)) {
+                        ret = -ERESTARTSYS;
+                        break;
+                }
+                schedule();
+        } while (1);
+        set_current_state(TASK_RUNNING);
+        remove_wait_queue(&rtc->irq_queue, &wait);
+
+        if (ret == 0) {
+                /* Check for any data updates */
+                if (rtc->ops->read_callback)
+                        data = rtc->ops->read_callback(rtc->class_dev.dev, data);
+
+                ret = put_user(data, (unsigned long __user *)buf);
+                if (ret == 0)
+                        ret = sizeof(unsigned long);
+        }
+        return ret;
+}
+
+static unsigned int rtc_dev_poll(struct file *file, poll_table *wait)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+        unsigned long data;
+
+        poll_wait(file, &rtc->irq_queue, wait);
+
+        data = rtc->irq_data;
+
+        return (data != 0) ? (POLLIN | POLLRDNORM) : 0;
+}
+
+static int rtc_dev_ioctl(struct inode *inode, struct file *file,
+                unsigned int cmd, unsigned long arg)
+{
+        int err = 0;
+        struct class_device *class_dev = file->private_data;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+        struct rtc_class_ops *ops = rtc->ops;
+        struct rtc_time tm;
+        struct rtc_wkalrm alarm;
+        void __user *uarg = (void __user *) arg;
+
+        /* avoid conflicting IRQ users */
+        if (cmd == RTC_PIE_ON || cmd == RTC_PIE_OFF || cmd == RTC_IRQP_SET) {
+                spin_lock(&rtc->irq_task_lock);
+                if (rtc->irq_task)
+                        err = -EBUSY;
+                spin_unlock(&rtc->irq_task_lock);
+
+                if (err < 0)
+                        return err;
+        }
+
+        /* try the driver's ioctl interface */
+        if (ops->ioctl) {
+                err = ops->ioctl(class_dev->dev, cmd, arg);
+                if (err != -EINVAL)
+                        return err;
+        }
+
+        /* if the driver does not provide the ioctl interface
+         * or if that particular ioctl was not implemented
+         * (-EINVAL), we will try to emulate here.
+         */
+
+        switch (cmd) {
+        case RTC_ALM_READ:
+                err = rtc_read_alarm(class_dev, &alarm);
+                if (err < 0)
+                        return err;
+
+                if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
+                        return -EFAULT;
+                break;
+
+        case RTC_ALM_SET:
+                if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
+                        return -EFAULT;
+
+                alarm.enabled = 0;
+                alarm.pending = 0;
+                alarm.time.tm_mday = -1;
+                alarm.time.tm_mon = -1;
+                alarm.time.tm_year = -1;
+                alarm.time.tm_wday = -1;
+                alarm.time.tm_yday = -1;
+                alarm.time.tm_isdst = -1;
+                err = rtc_set_alarm(class_dev, &alarm);
+                break;
+
+        case RTC_RD_TIME:
+                err = rtc_read_time(class_dev, &tm);
+                if (err < 0)
+                        return err;
+
+                if (copy_to_user(uarg, &tm, sizeof(tm)))
+                        return -EFAULT;
+                break;
+
+        case RTC_SET_TIME:
+                if (!capable(CAP_SYS_TIME))
+                        return -EACCES;
+
+                if (copy_from_user(&tm, uarg, sizeof(tm)))
+                        return -EFAULT;
+
+                err = rtc_set_time(class_dev, &tm);
+                break;
+#if 0
+        case RTC_EPOCH_SET:
+#ifndef rtc_epoch
+                /*
+                 * There were no RTC clocks before 1900.
+                 */
+                if (arg < 1900) {
+                        err = -EINVAL;
+                        break;
+                }
+                if (!capable(CAP_SYS_TIME)) {
+                        err = -EACCES;
+                        break;
+                }
+                rtc_epoch = arg;
+                err = 0;
+#endif
+                break;
+
+        case RTC_EPOCH_READ:
+                err = put_user(rtc_epoch, (unsigned long __user *)uarg);
+                break;
+#endif
+        case RTC_WKALM_SET:
+                if (copy_from_user(&alarm, uarg, sizeof(alarm)))
+                        return -EFAULT;
+
+                err = rtc_set_alarm(class_dev, &alarm);
+                break;
+
+        case RTC_WKALM_RD:
+                err = rtc_read_alarm(class_dev, &alarm);
+                if (err < 0)
+                        return err;
+
+                if (copy_to_user(uarg, &alarm, sizeof(alarm)))
+                        return -EFAULT;
+                break;
+
+        default:
+                err = -EINVAL;
+                break;
+        }
+
+        return err;
+}
+
+static int rtc_dev_release(struct inode *inode, struct file *file)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+
+        if (rtc->ops->release)
+                rtc->ops->release(rtc->class_dev.dev);
+
+        mutex_unlock(&rtc->char_lock);
+        return 0;
+}
+
+static int rtc_dev_fasync(int fd, struct file *file, int on)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+        return fasync_helper(fd, file, on, &rtc->async_queue);
+}
+
+static struct file_operations rtc_dev_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .read           = rtc_dev_read,
+        .poll           = rtc_dev_poll,
+        .ioctl          = rtc_dev_ioctl,
+        .open           = rtc_dev_open,
+        .release        = rtc_dev_release,
+        .fasync         = rtc_dev_fasync,
+};
+
+/* insertion/removal hooks */
+
+static int rtc_dev_add_device(struct class_device *class_dev,
+                                struct class_interface *class_intf)
+{
+        int err = 0;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        if (rtc->id >= RTC_DEV_MAX) {
+                dev_err(class_dev->dev, "too many RTCs\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&rtc->char_lock);
+        spin_lock_init(&rtc->irq_lock);
+        init_waitqueue_head(&rtc->irq_queue);
+
+        cdev_init(&rtc->char_dev, &rtc_dev_fops);
+        rtc->char_dev.owner = rtc->owner;
+
+        if (cdev_add(&rtc->char_dev, MKDEV(MAJOR(rtc_devt), rtc->id), 1)) {
+                cdev_del(&rtc->char_dev);
+                dev_err(class_dev->dev,
+                        "failed to add char device %d:%d\n",
+                        MAJOR(rtc_devt), rtc->id);
+                return -ENODEV;
+        }
+
+        rtc->rtc_dev = class_device_create(rtc_dev_class, NULL,
+                                                MKDEV(MAJOR(rtc_devt), rtc->id),
+                                                class_dev->dev, "rtc%d", rtc->id);
+        if (IS_ERR(rtc->rtc_dev)) {
+                dev_err(class_dev->dev, "cannot create rtc_dev device\n");
+                err = PTR_ERR(rtc->rtc_dev);
+                goto err_cdev_del;
+        }
+
+        dev_info(class_dev->dev, "rtc intf: dev (%d:%d)\n",
+                MAJOR(rtc->rtc_dev->devt),
+                MINOR(rtc->rtc_dev->devt));
+
+        return 0;
+
+err_cdev_del:
+
+        cdev_del(&rtc->char_dev);
+        return err;
+}
+
+static void rtc_dev_remove_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        if (rtc->rtc_dev) {
+                dev_dbg(class_dev->dev, "removing char %d:%d\n",
+                        MAJOR(rtc->rtc_dev->devt),
+                        MINOR(rtc->rtc_dev->devt));
+
+                class_device_unregister(rtc->rtc_dev);
+                cdev_del(&rtc->char_dev);
+        }
+}
+
+/* interface registration */
+
+static struct class_interface rtc_dev_interface = {
+        .add = &rtc_dev_add_device,
+        .remove = &rtc_dev_remove_device,
+};
+
+static int __init rtc_dev_init(void)
+{
+        int err;
+
+        rtc_dev_class = class_create(THIS_MODULE, "rtc-dev");
+        if (IS_ERR(rtc_dev_class))
+                return PTR_ERR(rtc_dev_class);
+
+        err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
+        if (err < 0) {
+                printk(KERN_ERR "%s: failed to allocate char dev region\n",
+                        __FILE__);
+                goto err_destroy_class;
+        }
+
+        err = rtc_interface_register(&rtc_dev_interface);
+        if (err < 0) {
+                printk(KERN_ERR "%s: failed to register the interface\n",
+                        __FILE__);
+                goto err_unregister_chrdev;
+        }
+
+        return 0;
+
+err_unregister_chrdev:
+        unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
+
+err_destroy_class:
+        class_destroy(rtc_dev_class);
+
+        return err;
+}
+
+static void __exit rtc_dev_exit(void)
+{
+        class_interface_unregister(&rtc_dev_interface);
+        class_destroy(rtc_dev_class);
+        unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
+}
+
+module_init(rtc_dev_init);
+module_exit(rtc_dev_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC class dev interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
new file mode 100644
index 000000000000..358695a416f3
--- /dev/null
+++ b/drivers/rtc/rtc-ds1672.c
@@ -0,0 +1,233 @@
+/*
+ * An rtc/i2c driver for the Dallas DS1672
+ * Copyright 2005 Alessandro Zummo
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/rtc.h>
+
+#define DRV_VERSION "0.2"
+
+/* Addresses to scan: none. This chip cannot be detected. */
+static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+
+/* Insmod parameters */
+I2C_CLIENT_INSMOD;
+
+/* Registers */
+
+#define DS1672_REG_CNT_BASE     0
+#define DS1672_REG_CONTROL      4
+#define DS1672_REG_TRICKLE      5
+
+
+/* Prototypes */
+static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind);
+
+/*
+ * In the routines that deal directly with the ds1672 hardware, we use
+ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
+ * Epoch is initialized as 2000. Time is set to UTC.
+ */
+static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned long time;
+        unsigned char addr = DS1672_REG_CNT_BASE;
+        unsigned char buf[4];
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, &addr },          /* setup read ptr */
+                { client->addr, I2C_M_RD, 4, buf },     /* read date */
+        };
+
+        /* read date registers */
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        dev_dbg(&client->dev,
+                "%s: raw read data - counters=%02x,%02x,%02x,%02x\n"
+                __FUNCTION__,
+                buf[0], buf[1], buf[2], buf[3]);
+
+        time = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+
+        rtc_time_to_tm(time, tm);
+
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        return 0;
+}
+
+static int ds1672_set_mmss(struct i2c_client *client, unsigned long secs)
+{
+        int xfer;
+        unsigned char buf[5];
+
+        buf[0] = DS1672_REG_CNT_BASE;
+        buf[1] = secs & 0x000000FF;
+        buf[2] = (secs & 0x0000FF00) >> 8;
+        buf[3] = (secs & 0x00FF0000) >> 16;
+        buf[4] = (secs & 0xFF000000) >> 24;
+
+        xfer = i2c_master_send(client, buf, 5);
+        if (xfer != 5) {
+                dev_err(&client->dev, "%s: send: %d\n", __FUNCTION__, xfer);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int ds1672_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned long secs;
+
+        dev_dbg(&client->dev,
+                "%s: secs=%d, mins=%d, hours=%d, ",
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        rtc_tm_to_time(tm, &secs);
+
+        return ds1672_set_mmss(client, secs);
+}
+
+static int ds1672_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return ds1672_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int ds1672_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return ds1672_set_datetime(to_i2c_client(dev), tm);
+}
+
+static int ds1672_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        return ds1672_set_mmss(to_i2c_client(dev), secs);
+}
+
+static struct rtc_class_ops ds1672_rtc_ops = {
+        .read_time      = ds1672_rtc_read_time,
+        .set_time       = ds1672_rtc_set_time,
+        .set_mmss       = ds1672_rtc_set_mmss,
+};
+
+static int ds1672_attach(struct i2c_adapter *adapter)
+{
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return i2c_probe(adapter, &addr_data, ds1672_probe);
+}
+
+static int ds1672_detach(struct i2c_client *client)
+{
+        int err;
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(client);
+
+        return 0;
+}
+
+static struct i2c_driver ds1672_driver = {
+        .driver         = {
+                .name   = "ds1672",
+        },
+        .id             = I2C_DRIVERID_DS1672,
+        .attach_adapter = &ds1672_attach,
+        .detach_client  = &ds1672_detach,
+};
+
+static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
+{
+        int err = 0;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        /* I2C client */
+        client->addr = address;
+        client->driver = &ds1672_driver;
+        client->adapter = adapter;
+
+        strlcpy(client->name, ds1672_driver.driver.name, I2C_NAME_SIZE);
+
+        /* Inform the i2c layer */
+        if ((err = i2c_attach_client(client)))
+                goto exit_kfree;
+
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(ds1672_driver.driver.name, &client->dev,
+                                &ds1672_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(client);
+
+exit:
+        return err;
+}
+
+static int __init ds1672_init(void)
+{
+        return i2c_add_driver(&ds1672_driver);
+}
+
+static void __exit ds1672_exit(void)
+{
+        i2c_del_driver(&ds1672_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Dallas/Maxim DS1672 timekeeper driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(ds1672_init);
+module_exit(ds1672_exit);
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
new file mode 100644
index 000000000000..0dd80ea686a9
--- /dev/null
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -0,0 +1,162 @@
+/*
+ * A driver for the RTC embedded in the Cirrus Logic EP93XX processors
+ * Copyright (c) 2006 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <asm/hardware.h>
+
+#define EP93XX_RTC_REG(x)       (EP93XX_RTC_BASE + (x))
+#define EP93XX_RTC_DATA         EP93XX_RTC_REG(0x0000)
+#define EP93XX_RTC_LOAD         EP93XX_RTC_REG(0x000C)
+#define EP93XX_RTC_SWCOMP       EP93XX_RTC_REG(0x0108)
+
+#define DRV_VERSION "0.2"
+
+static int ep93xx_get_swcomp(struct device *dev, unsigned short *preload,
+                                unsigned short *delete)
+{
+        unsigned short comp = __raw_readl(EP93XX_RTC_SWCOMP);
+
+        if (preload)
+                *preload = comp & 0xffff;
+
+        if (delete)
+                *delete = (comp >> 16) & 0x1f;
+
+        return 0;
+}
+
+static int ep93xx_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time = __raw_readl(EP93XX_RTC_DATA);
+
+        rtc_time_to_tm(time, tm);
+        return 0;
+}
+
+static int ep93xx_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        __raw_writel(secs + 1, EP93XX_RTC_LOAD);
+        return 0;
+}
+
+static int ep93xx_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        int err;
+        unsigned long secs;
+
+        err = rtc_tm_to_time(tm, &secs);
+        if (err != 0)
+                return err;
+
+        return ep93xx_rtc_set_mmss(dev, secs);
+}
+
+static int ep93xx_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        unsigned short preload, delete;
+
+        ep93xx_get_swcomp(dev, &preload, &delete);
+
+        seq_printf(seq, "24hr\t\t: yes\n");
+        seq_printf(seq, "preload\t\t: %d\n", preload);
+        seq_printf(seq, "delete\t\t: %d\n", delete);
+
+        return 0;
+}
+
+static struct rtc_class_ops ep93xx_rtc_ops = {
+        .read_time      = ep93xx_rtc_read_time,
+        .set_time       = ep93xx_rtc_set_time,
+        .set_mmss       = ep93xx_rtc_set_mmss,
+        .proc           = ep93xx_rtc_proc,
+};
+
+static ssize_t ep93xx_sysfs_show_comp_preload(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        unsigned short preload;
+
+        ep93xx_get_swcomp(dev, &preload, NULL);
+
+        return sprintf(buf, "%d\n", preload);
+}
+static DEVICE_ATTR(comp_preload, S_IRUGO, ep93xx_sysfs_show_comp_preload, NULL);
+
+static ssize_t ep93xx_sysfs_show_comp_delete(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        unsigned short delete;
+
+        ep93xx_get_swcomp(dev, NULL, &delete);
+
+        return sprintf(buf, "%d\n", delete);
+}
+static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_sysfs_show_comp_delete, NULL);
+
+
+static int __devinit ep93xx_rtc_probe(struct platform_device *dev)
+{
+        struct rtc_device *rtc = rtc_device_register("ep93xx",
+                                &dev->dev, &ep93xx_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&dev->dev, "unable to register\n");
+                return PTR_ERR(rtc);
+        }
+
+        platform_set_drvdata(dev, rtc);
+
+        device_create_file(&dev->dev, &dev_attr_comp_preload);
+        device_create_file(&dev->dev, &dev_attr_comp_delete);
+
+        return 0;
+}
+
+static int __devexit ep93xx_rtc_remove(struct platform_device *dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(dev);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ep93xx_rtc_platform_driver = {
+        .driver         = {
+                .name   = "ep93xx-rtc",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ep93xx_rtc_probe,
+        .remove         = __devexit_p(ep93xx_rtc_remove),
+};
+
+static int __init ep93xx_rtc_init(void)
+{
+        return platform_driver_register(&ep93xx_rtc_platform_driver);
+}
+
+static void __exit ep93xx_rtc_exit(void)
+{
+        platform_driver_unregister(&ep93xx_rtc_platform_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("EP93XX RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(ep93xx_rtc_init);
+module_exit(ep93xx_rtc_exit);
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
new file mode 100644
index 000000000000..cfedc1d28ee1
--- /dev/null
+++ b/drivers/rtc/rtc-lib.c
@@ -0,0 +1,101 @@
+/*
+ * rtc and date/time utility functions
+ *
+ * Copyright (C) 2005-06 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.c and other bits
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+
+static const unsigned char rtc_days_in_month[] = {
+        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+};
+
+#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
+#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
+
+int rtc_month_days(unsigned int month, unsigned int year)
+{
+        return rtc_days_in_month[month] + (LEAP_YEAR(year) && month == 1);
+}
+EXPORT_SYMBOL(rtc_month_days);
+
+/*
+ * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
+ */
+void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
+{
+        register int days, month, year;
+
+        days = time / 86400;
+        time -= days * 86400;
+
+        /* day of the week, 1970-01-01 was a Thursday */
+        tm->tm_wday = (days + 4) % 7;
+
+        year = 1970 + days / 365;
+        days -= (year - 1970) * 365
+                + LEAPS_THRU_END_OF(year - 1)
+                - LEAPS_THRU_END_OF(1970 - 1);
+        if (days < 0) {
+                year -= 1;
+                days += 365 + LEAP_YEAR(year);
+        }
+        tm->tm_year = year - 1900;
+        tm->tm_yday = days + 1;
+
+        for (month = 0; month < 11; month++) {
+                int newdays;
+
+                newdays = days - rtc_month_days(month, year);
+                if (newdays < 0)
+                        break;
+                days = newdays;
+        }
+        tm->tm_mon = month;
+        tm->tm_mday = days + 1;
+
+        tm->tm_hour = time / 3600;
+        time -= tm->tm_hour * 3600;
+        tm->tm_min = time / 60;
+        tm->tm_sec = time - tm->tm_min * 60;
+}
+EXPORT_SYMBOL(rtc_time_to_tm);
+
+/*
+ * Does the rtc_time represent a valid date/time?
+ */
+int rtc_valid_tm(struct rtc_time *tm)
+{
+        if (tm->tm_year < 70
+                || tm->tm_mon >= 12
+                || tm->tm_mday < 1
+                || tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + 1900)
+                || tm->tm_hour >= 24
+                || tm->tm_min >= 60
+                || tm->tm_sec >= 60)
+                return -EINVAL;
+
+        return 0;
+}
+EXPORT_SYMBOL(rtc_valid_tm);
+
+/*
+ * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
+ */
+int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
+{
+        *time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+                        tm->tm_hour, tm->tm_min, tm->tm_sec);
+        return 0;
+}
+EXPORT_SYMBOL(rtc_tm_to_time);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
new file mode 100644
index 000000000000..db445c872b1b
--- /dev/null
+++ b/drivers/rtc/rtc-m48t86.c
@@ -0,0 +1,209 @@
+/*
+ * ST M48T86 / Dallas DS12887 RTC driver
+ * Copyright (c) 2006 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This drivers only supports the clock running in BCD and 24H mode.
+ * If it will be ever adapted to binary and 12H mode, care must be taken
+ * to not introduce bugs.
+ */
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/m48t86.h>
+#include <linux/bcd.h>
+
+#define M48T86_REG_SEC          0x00
+#define M48T86_REG_SECALRM      0x01
+#define M48T86_REG_MIN          0x02
+#define M48T86_REG_MINALRM      0x03
+#define M48T86_REG_HOUR 0x04
+#define M48T86_REG_HOURALRM     0x05
+#define M48T86_REG_DOW          0x06 /* 1 = sunday */
+#define M48T86_REG_DOM          0x07
+#define M48T86_REG_MONTH        0x08 /* 1 - 12 */
+#define M48T86_REG_YEAR         0x09 /* 0 - 99 */
+#define M48T86_REG_A            0x0A
+#define M48T86_REG_B            0x0B
+#define M48T86_REG_C            0x0C
+#define M48T86_REG_D            0x0D
+
+#define M48T86_REG_B_H24        (1 << 1)
+#define M48T86_REG_B_DM         (1 << 2)
+#define M48T86_REG_B_SET        (1 << 7)
+#define M48T86_REG_D_VRT        (1 << 7)
+
+#define DRV_VERSION "0.1"
+
+
+static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char reg;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct m48t86_ops *ops = pdev->dev.platform_data;
+
+        reg = ops->readb(M48T86_REG_B);
+
+        if (reg & M48T86_REG_B_DM) {
+                /* data (binary) mode */
+                tm->tm_sec      = ops->readb(M48T86_REG_SEC);
+                tm->tm_min      = ops->readb(M48T86_REG_MIN);
+                tm->tm_hour     = ops->readb(M48T86_REG_HOUR) & 0x3F;
+                tm->tm_mday     = ops->readb(M48T86_REG_DOM);
+                /* tm_mon is 0-11 */
+                tm->tm_mon      = ops->readb(M48T86_REG_MONTH) - 1;
+                tm->tm_year     = ops->readb(M48T86_REG_YEAR) + 100;
+                tm->tm_wday     = ops->readb(M48T86_REG_DOW);
+        } else {
+                /* bcd mode */
+                tm->tm_sec      = BCD2BIN(ops->readb(M48T86_REG_SEC));
+                tm->tm_min      = BCD2BIN(ops->readb(M48T86_REG_MIN));
+                tm->tm_hour     = BCD2BIN(ops->readb(M48T86_REG_HOUR) & 0x3F);
+                tm->tm_mday     = BCD2BIN(ops->readb(M48T86_REG_DOM));
+                /* tm_mon is 0-11 */
+                tm->tm_mon      = BCD2BIN(ops->readb(M48T86_REG_MONTH)) - 1;
+                tm->tm_year     = BCD2BIN(ops->readb(M48T86_REG_YEAR)) + 100;
+                tm->tm_wday     = BCD2BIN(ops->readb(M48T86_REG_DOW));
+        }
+
+        /* correct the hour if the clock is in 12h mode */
+        if (!(reg & M48T86_REG_B_H24))
+                if (ops->readb(M48T86_REG_HOUR) & 0x80)
+                        tm->tm_hour += 12;
+
+        return 0;
+}
+
+static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char reg;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct m48t86_ops *ops = pdev->dev.platform_data;
+
+        reg = ops->readb(M48T86_REG_B);
+
+        /* update flag and 24h mode */
+        reg |= M48T86_REG_B_SET | M48T86_REG_B_H24;
+        ops->writeb(reg, M48T86_REG_B);
+
+        if (reg & M48T86_REG_B_DM) {
+                /* data (binary) mode */
+                ops->writeb(tm->tm_sec, M48T86_REG_SEC);
+                ops->writeb(tm->tm_min, M48T86_REG_MIN);
+                ops->writeb(tm->tm_hour, M48T86_REG_HOUR);
+                ops->writeb(tm->tm_mday, M48T86_REG_DOM);
+                ops->writeb(tm->tm_mon + 1, M48T86_REG_MONTH);
+                ops->writeb(tm->tm_year % 100, M48T86_REG_YEAR);
+                ops->writeb(tm->tm_wday, M48T86_REG_DOW);
+        } else {
+                /* bcd mode */
+                ops->writeb(BIN2BCD(tm->tm_sec), M48T86_REG_SEC);
+                ops->writeb(BIN2BCD(tm->tm_min), M48T86_REG_MIN);
+                ops->writeb(BIN2BCD(tm->tm_hour), M48T86_REG_HOUR);
+                ops->writeb(BIN2BCD(tm->tm_mday), M48T86_REG_DOM);
+                ops->writeb(BIN2BCD(tm->tm_mon + 1), M48T86_REG_MONTH);
+                ops->writeb(BIN2BCD(tm->tm_year % 100), M48T86_REG_YEAR);
+                ops->writeb(BIN2BCD(tm->tm_wday), M48T86_REG_DOW);
+        }
+
+        /* update ended */
+        reg &= ~M48T86_REG_B_SET;
+        ops->writeb(reg, M48T86_REG_B);
+
+        return 0;
+}
+
+static int m48t86_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        unsigned char reg;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct m48t86_ops *ops = pdev->dev.platform_data;
+
+        reg = ops->readb(M48T86_REG_B);
+
+        seq_printf(seq, "24hr\t\t: %s\n",
+                 (reg & M48T86_REG_B_H24) ? "yes" : "no");
+
+        seq_printf(seq, "mode\t\t: %s\n",
+                 (reg & M48T86_REG_B_DM) ? "binary" : "bcd");
+
+        reg = ops->readb(M48T86_REG_D);
+
+        seq_printf(seq, "battery\t\t: %s\n",
+                 (reg & M48T86_REG_D_VRT) ? "ok" : "exhausted");
+
+        return 0;
+}
+
+static struct rtc_class_ops m48t86_rtc_ops = {
+        .read_time      = m48t86_rtc_read_time,
+        .set_time       = m48t86_rtc_set_time,
+        .proc           = m48t86_rtc_proc,
+};
+
+static int __devinit m48t86_rtc_probe(struct platform_device *dev)
+{
+        unsigned char reg;
+        struct m48t86_ops *ops = dev->dev.platform_data;
+        struct rtc_device *rtc = rtc_device_register("m48t86",
+                                &dev->dev, &m48t86_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&dev->dev, "unable to register\n");
+                return PTR_ERR(rtc);
+        }
+
+        platform_set_drvdata(dev, rtc);
+
+        /* read battery status */
+        reg = ops->readb(M48T86_REG_D);
+        dev_info(&dev->dev, "battery %s\n",
+                (reg & M48T86_REG_D_VRT) ? "ok" : "exhausted");
+
+        return 0;
+}
+
+static int __devexit m48t86_rtc_remove(struct platform_device *dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(dev);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver m48t86_rtc_platform_driver = {
+        .driver         = {
+                .name   = "rtc-m48t86",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = m48t86_rtc_probe,
+        .remove         = __devexit_p(m48t86_rtc_remove),
+};
+
+static int __init m48t86_rtc_init(void)
+{
+        return platform_driver_register(&m48t86_rtc_platform_driver);
+}
+
+static void __exit m48t86_rtc_exit(void)
+{
+        platform_driver_unregister(&m48t86_rtc_platform_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("M48T86 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(m48t86_rtc_init);
+module_exit(m48t86_rtc_exit);
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
new file mode 100644
index 000000000000..d857d45bdbe8
--- /dev/null
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -0,0 +1,353 @@
+/*
+ * An I2C driver for the Philips PCF8563 RTC
+ * Copyright 2005-06 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ * Maintainers: http://www.nslu2-linux.org/
+ *
+ * based on the other drivers in this same directory.
+ *
+ * http://www.semiconductors.philips.com/acrobat/datasheets/PCF8563-04.pdf
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+
+#define DRV_VERSION "0.4.2"
+
+/* Addresses to scan: none
+ * This chip cannot be reliably autodetected. An empty eeprom
+ * located at 0x51 will pass the validation routine due to
+ * the way the registers are implemented.
+ */
+static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+
+/* Module parameters */
+I2C_CLIENT_INSMOD;
+
+#define PCF8563_REG_ST1         0x00 /* status */
+#define PCF8563_REG_ST2         0x01
+
+#define PCF8563_REG_SC          0x02 /* datetime */
+#define PCF8563_REG_MN          0x03
+#define PCF8563_REG_HR          0x04
+#define PCF8563_REG_DM          0x05
+#define PCF8563_REG_DW          0x06
+#define PCF8563_REG_MO          0x07
+#define PCF8563_REG_YR          0x08
+
+#define PCF8563_REG_AMN         0x09 /* alarm */
+#define PCF8563_REG_AHR         0x0A
+#define PCF8563_REG_ADM         0x0B
+#define PCF8563_REG_ADW         0x0C
+
+#define PCF8563_REG_CLKO        0x0D /* clock out */
+#define PCF8563_REG_TMRC        0x0E /* timer control */
+#define PCF8563_REG_TMR         0x0F /* timer */
+
+#define PCF8563_SC_LV           0x80 /* low voltage */
+#define PCF8563_MO_C            0x80 /* century */
+
+static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind);
+static int pcf8563_detach(struct i2c_client *client);
+
+/*
+ * In the routines that deal directly with the pcf8563 hardware, we use
+ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
+ */
+static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[13] = { PCF8563_REG_ST1 };
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, buf },    /* setup read ptr */
+                { client->addr, I2C_M_RD, 13, buf },    /* read status + date */
+        };
+
+        /* read registers */
+        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        if (buf[PCF8563_REG_SC] & PCF8563_SC_LV)
+                dev_info(&client->dev,
+                        "low voltage detected, date/time is not reliable.\n");
+
+        dev_dbg(&client->dev,
+                "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
+                "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
+                __FUNCTION__,
+                buf[0], buf[1], buf[2], buf[3],
+                buf[4], buf[5], buf[6], buf[7],
+                buf[8]);
+
+
+        tm->tm_sec = BCD2BIN(buf[PCF8563_REG_SC] & 0x7F);
+        tm->tm_min = BCD2BIN(buf[PCF8563_REG_MN] & 0x7F);
+        tm->tm_hour = BCD2BIN(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
+        tm->tm_mday = BCD2BIN(buf[PCF8563_REG_DM] & 0x3F);
+        tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
+        tm->tm_mon = BCD2BIN(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
+        tm->tm_year = BCD2BIN(buf[PCF8563_REG_YR])
+                + (buf[PCF8563_REG_MO] & PCF8563_MO_C ? 100 : 0);
+
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* the clock can give out invalid datetime, but we cannot return
+         * -EINVAL otherwise hwclock will refuse to set the time on bootup.
+         */
+        if (rtc_valid_tm(tm) < 0)
+                dev_err(&client->dev, "retrieved date/time is not valid.\n");
+
+        return 0;
+}
+
+static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        int i, err;
+        unsigned char buf[9];
+
+        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* hours, minutes and seconds */
+        buf[PCF8563_REG_SC] = BIN2BCD(tm->tm_sec);
+        buf[PCF8563_REG_MN] = BIN2BCD(tm->tm_min);
+        buf[PCF8563_REG_HR] = BIN2BCD(tm->tm_hour);
+
+        buf[PCF8563_REG_DM] = BIN2BCD(tm->tm_mday);
+
+        /* month, 1 - 12 */
+        buf[PCF8563_REG_MO] = BIN2BCD(tm->tm_mon + 1);
+
+        /* year and century */
+        buf[PCF8563_REG_YR] = BIN2BCD(tm->tm_year % 100);
+        if (tm->tm_year / 100)
+                buf[PCF8563_REG_MO] |= PCF8563_MO_C;
+
+        buf[PCF8563_REG_DW] = tm->tm_wday & 0x07;
+
+        /* write register's data */
+        for (i = 0; i < 7; i++) {
+                unsigned char data[2] = { PCF8563_REG_SC + i,
+                                                buf[PCF8563_REG_SC + i] };
+
+                err = i2c_master_send(client, data, sizeof(data));
+                if (err != sizeof(data)) {
+                        dev_err(&client->dev,
+                                "%s: err=%d addr=%02x, data=%02x\n",
+                                __FUNCTION__, err, data[0], data[1]);
+                        return -EIO;
+                }
+        };
+
+        return 0;
+}
+
+struct pcf8563_limit
+{
+        unsigned char reg;
+        unsigned char mask;
+        unsigned char min;
+        unsigned char max;
+};
+
+static int pcf8563_validate_client(struct i2c_client *client)
+{
+        int i;
+
+        static const struct pcf8563_limit pattern[] = {
+                /* register, mask, min, max */
+                { PCF8563_REG_SC,       0x7F,   0,      59      },
+                { PCF8563_REG_MN,       0x7F,   0,      59      },
+                { PCF8563_REG_HR,       0x3F,   0,      23      },
+                { PCF8563_REG_DM,       0x3F,   0,      31      },
+                { PCF8563_REG_MO,       0x1F,   0,      12      },
+        };
+
+        /* check limits (only registers with bcd values) */
+        for (i = 0; i < ARRAY_SIZE(pattern); i++) {
+                int xfer;
+                unsigned char value;
+                unsigned char buf = pattern[i].reg;
+
+                struct i2c_msg msgs[] = {
+                        { client->addr, 0, 1, &buf },
+                        { client->addr, I2C_M_RD, 1, &buf },
+                };
+
+                xfer = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+
+                if (xfer != ARRAY_SIZE(msgs)) {
+                        dev_err(&client->adapter->dev,
+                                "%s: could not read register 0x%02X\n",
+                                __FUNCTION__, pattern[i].reg);
+
+                        return -EIO;
+                }
+
+                value = BCD2BIN(buf & pattern[i].mask);
+
+                if (value > pattern[i].max ||
+                        value < pattern[i].min) {
+                        dev_dbg(&client->adapter->dev,
+                                "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, "
+                                "max=%d, value=%d, raw=0x%02X\n",
+                                __FUNCTION__, i, pattern[i].reg, pattern[i].mask,
+                                pattern[i].min, pattern[i].max,
+                                value, buf);
+
+                        return -ENODEV;
+                }
+        }
+
+        return 0;
+}
+
+static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return pcf8563_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return pcf8563_set_datetime(to_i2c_client(dev), tm);
+}
+
+static int pcf8563_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        seq_printf(seq, "24hr\t\t: yes\n");
+        return 0;
+}
+
+static struct rtc_class_ops pcf8563_rtc_ops = {
+        .proc           = pcf8563_rtc_proc,
+        .read_time      = pcf8563_rtc_read_time,
+        .set_time       = pcf8563_rtc_set_time,
+};
+
+static int pcf8563_attach(struct i2c_adapter *adapter)
+{
+        return i2c_probe(adapter, &addr_data, pcf8563_probe);
+}
+
+static struct i2c_driver pcf8563_driver = {
+        .driver         = {
+                .name   = "pcf8563",
+        },
+        .id             = I2C_DRIVERID_PCF8563,
+        .attach_adapter = &pcf8563_attach,
+        .detach_client  = &pcf8563_detach,
+};
+
+static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind)
+{
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+
+        int err = 0;
+
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        client->addr = address;
+        client->driver = &pcf8563_driver;
+        client->adapter = adapter;
+
+        strlcpy(client->name, pcf8563_driver.driver.name, I2C_NAME_SIZE);
+
+        /* Verify the chip is really an PCF8563 */
+        if (kind < 0) {
+                if (pcf8563_validate_client(client) < 0) {
+                        err = -ENODEV;
+                        goto exit_kfree;
+                }
+        }
+
+        /* Inform the i2c layer */
+        if ((err = i2c_attach_client(client)))
+                goto exit_kfree;
+
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(pcf8563_driver.driver.name, &client->dev,
+                                &pcf8563_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(client);
+
+exit:
+        return err;
+}
+
+static int pcf8563_detach(struct i2c_client *client)
+{
+        int err;
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(client);
+
+        return 0;
+}
+
+static int __init pcf8563_init(void)
+{
+        return i2c_add_driver(&pcf8563_driver);
+}
+
+static void __exit pcf8563_exit(void)
+{
+        i2c_del_driver(&pcf8563_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(pcf8563_init);
+module_exit(pcf8563_exit);
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
new file mode 100644
index 000000000000..90b8a97a0919
--- /dev/null
+++ b/drivers/rtc/rtc-proc.c
@@ -0,0 +1,162 @@
+/*
+ * RTC subsystem, proc interface
+ *
+ * Copyright (C) 2005-06 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+static struct class_device *rtc_dev = NULL;
+static DEFINE_MUTEX(rtc_lock);
+
+static int rtc_proc_show(struct seq_file *seq, void *offset)
+{
+        int err;
+        struct class_device *class_dev = seq->private;
+        struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
+        struct rtc_wkalrm alrm;
+        struct rtc_time tm;
+
+        err = rtc_read_time(class_dev, &tm);
+        if (err == 0) {
+                seq_printf(seq,
+                        "rtc_time\t: %02d:%02d:%02d\n"
+                        "rtc_date\t: %04d-%02d-%02d\n",
+                        tm.tm_hour, tm.tm_min, tm.tm_sec,
+                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
+        }
+
+        err = rtc_read_alarm(class_dev, &alrm);
+        if (err == 0) {
+                seq_printf(seq, "alrm_time\t: ");
+                if ((unsigned int)alrm.time.tm_hour <= 24)
+                        seq_printf(seq, "%02d:", alrm.time.tm_hour);
+                else
+                        seq_printf(seq, "**:");
+                if ((unsigned int)alrm.time.tm_min <= 59)
+                        seq_printf(seq, "%02d:", alrm.time.tm_min);
+                else
+                        seq_printf(seq, "**:");
+                if ((unsigned int)alrm.time.tm_sec <= 59)
+                        seq_printf(seq, "%02d\n", alrm.time.tm_sec);
+                else
+                        seq_printf(seq, "**\n");
+
+                seq_printf(seq, "alrm_date\t: ");
+                if ((unsigned int)alrm.time.tm_year <= 200)
+                        seq_printf(seq, "%04d-", alrm.time.tm_year + 1900);
+                else
+                        seq_printf(seq, "****-");
+                if ((unsigned int)alrm.time.tm_mon <= 11)
+                        seq_printf(seq, "%02d-", alrm.time.tm_mon + 1);
+                else
+                        seq_printf(seq, "**-");
+                if ((unsigned int)alrm.time.tm_mday <= 31)
+                        seq_printf(seq, "%02d\n", alrm.time.tm_mday);
+                else
+                        seq_printf(seq, "**\n");
+                seq_printf(seq, "alrm_wakeup\t: %s\n",
+                                alrm.enabled ? "yes" : "no");
+                seq_printf(seq, "alrm_pending\t: %s\n",
+                                alrm.pending ? "yes" : "no");
+        }
+
+        if (ops->proc)
+                ops->proc(class_dev->dev, seq);
+
+        return 0;
+}
+
+static int rtc_proc_open(struct inode *inode, struct file *file)
+{
+        struct class_device *class_dev = PDE(inode)->data;
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        return single_open(file, rtc_proc_show, class_dev);
+}
+
+static int rtc_proc_release(struct inode *inode, struct file *file)
+{
+        int res = single_release(inode, file);
+        module_put(THIS_MODULE);
+        return res;
+}
+
+static struct file_operations rtc_proc_fops = {
+        .open           = rtc_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = rtc_proc_release,
+};
+
+static int rtc_proc_add_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        mutex_lock(&rtc_lock);
+        if (rtc_dev == NULL) {
+                struct proc_dir_entry *ent;
+
+                rtc_dev = class_dev;
+
+                ent = create_proc_entry("driver/rtc", 0, NULL);
+                if (ent) {
+                        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+                        ent->proc_fops = &rtc_proc_fops;
+                        ent->owner = rtc->owner;
+                        ent->data = class_dev;
+
+                        dev_info(class_dev->dev, "rtc intf: proc\n");
+                }
+                else
+                        rtc_dev = NULL;
+        }
+        mutex_unlock(&rtc_lock);
+
+        return 0;
+}
+
+static void rtc_proc_remove_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        mutex_lock(&rtc_lock);
+        if (rtc_dev == class_dev) {
+                remove_proc_entry("driver/rtc", NULL);
+                rtc_dev = NULL;
+        }
+        mutex_unlock(&rtc_lock);
+}
+
+static struct class_interface rtc_proc_interface = {
+        .add = &rtc_proc_add_device,
+        .remove = &rtc_proc_remove_device,
+};
+
+static int __init rtc_proc_init(void)
+{
+        return rtc_interface_register(&rtc_proc_interface);
+}
+
+static void __exit rtc_proc_exit(void)
+{
+        class_interface_unregister(&rtc_proc_interface);
+}
+
+module_init(rtc_proc_init);
+module_exit(rtc_proc_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC class proc interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
new file mode 100644
index 000000000000..396c8681f66c
--- /dev/null
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -0,0 +1,294 @@
+/*
+ * An I2C driver for the Ricoh RS5C372 RTC
+ *
+ * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
+ * Copyright (C) 2006 Tower Technologies
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/i2c.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+
+#define DRV_VERSION "0.2"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { /* 0x32,*/ I2C_CLIENT_END };
+
+/* Insmod parameters */
+I2C_CLIENT_INSMOD;
+
+#define RS5C372_REG_SECS        0
+#define RS5C372_REG_MINS        1
+#define RS5C372_REG_HOURS       2
+#define RS5C372_REG_WDAY        3
+#define RS5C372_REG_DAY         4
+#define RS5C372_REG_MONTH       5
+#define RS5C372_REG_YEAR        6
+#define RS5C372_REG_TRIM        7
+
+#define RS5C372_TRIM_XSL        0x80
+#define RS5C372_TRIM_MASK       0x7F
+
+#define RS5C372_REG_BASE        0
+
+static int rs5c372_attach(struct i2c_adapter *adapter);
+static int rs5c372_detach(struct i2c_client *client);
+static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind);
+
+static struct i2c_driver rs5c372_driver = {
+        .driver         = {
+                .name   = "rs5c372",
+        },
+        .attach_adapter = &rs5c372_attach,
+        .detach_client  = &rs5c372_detach,
+};
+
+static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[7] = { RS5C372_REG_BASE };
+
+        /* this implements the 1st reading method, according
+         * to the datasheet. buf[0] is initialized with
+         * address ptr and transmission format register.
+         */
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, buf },
+                { client->addr, I2C_M_RD, 7, buf },
+        };
+
+        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        tm->tm_sec = BCD2BIN(buf[RS5C372_REG_SECS] & 0x7f);
+        tm->tm_min = BCD2BIN(buf[RS5C372_REG_MINS] & 0x7f);
+        tm->tm_hour = BCD2BIN(buf[RS5C372_REG_HOURS] & 0x3f);
+        tm->tm_wday = BCD2BIN(buf[RS5C372_REG_WDAY] & 0x07);
+        tm->tm_mday = BCD2BIN(buf[RS5C372_REG_DAY] & 0x3f);
+
+        /* tm->tm_mon is zero-based */
+        tm->tm_mon = BCD2BIN(buf[RS5C372_REG_MONTH] & 0x1f) - 1;
+
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(buf[RS5C372_REG_YEAR]) + 100;
+
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        return 0;
+}
+
+static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[8] = { RS5C372_REG_BASE };
+
+        dev_dbg(&client->dev,
+                "%s: secs=%d, mins=%d, hours=%d ",
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        buf[1] = BIN2BCD(tm->tm_sec);
+        buf[2] = BIN2BCD(tm->tm_min);
+        buf[3] = BIN2BCD(tm->tm_hour);
+        buf[4] = BIN2BCD(tm->tm_wday);
+        buf[5] = BIN2BCD(tm->tm_mday);
+        buf[6] = BIN2BCD(tm->tm_mon + 1);
+        buf[7] = BIN2BCD(tm->tm_year - 100);
+
+        if ((i2c_master_send(client, buf, 8)) != 8) {
+                dev_err(&client->dev, "%s: write error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
+{
+        unsigned char buf = RS5C372_REG_TRIM;
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, &buf },
+                { client->addr, I2C_M_RD, 1, &buf },
+        };
+
+        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, trim);
+
+        if (osc)
+                *osc = (buf & RS5C372_TRIM_XSL) ? 32000 : 32768;
+
+        if (trim)
+                *trim = buf & RS5C372_TRIM_MASK;
+
+        return 0;
+}
+
+static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return rs5c372_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return rs5c372_set_datetime(to_i2c_client(dev), tm);
+}
+
+static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        int err, osc, trim;
+
+        seq_printf(seq, "24hr\t\t: yes\n");
+
+        if ((err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim)) == 0) {
+                seq_printf(seq, "%d.%03d KHz\n", osc / 1000, osc % 1000);
+                seq_printf(seq, "trim\t: %d\n", trim);
+        }
+
+        return 0;
+}
+
+static struct rtc_class_ops rs5c372_rtc_ops = {
+        .proc           = rs5c372_rtc_proc,
+        .read_time      = rs5c372_rtc_read_time,
+        .set_time       = rs5c372_rtc_set_time,
+};
+
+static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int trim;
+
+        if (rs5c372_get_trim(to_i2c_client(dev), NULL, &trim) == 0)
+                return sprintf(buf, "0x%2x\n", trim);
+
+        return 0;
+}
+static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
+
+static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int osc;
+
+        if (rs5c372_get_trim(to_i2c_client(dev), &osc, NULL) == 0)
+                return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
+
+        return 0;
+}
+static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
+
+static int rs5c372_attach(struct i2c_adapter *adapter)
+{
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return i2c_probe(adapter, &addr_data, rs5c372_probe);
+}
+
+static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind)
+{
+        int err = 0;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        /* I2C client */
+        client->addr = address;
+        client->driver = &rs5c372_driver;
+        client->adapter = adapter;
+
+        strlcpy(client->name, rs5c372_driver.driver.name, I2C_NAME_SIZE);
+
+        /* Inform the i2c layer */
+        if ((err = i2c_attach_client(client)))
+                goto exit_kfree;
+
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(rs5c372_driver.driver.name, &client->dev,
+                                &rs5c372_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        device_create_file(&client->dev, &dev_attr_trim);
+        device_create_file(&client->dev, &dev_attr_osc);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(client);
+
+exit:
+        return err;
+}
+
+static int rs5c372_detach(struct i2c_client *client)
+{
+        int err;
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(client);
+
+        return 0;
+}
+
+static __init int rs5c372_init(void)
+{
+        return i2c_add_driver(&rs5c372_driver);
+}
+
+static __exit void rs5c372_exit(void)
+{
+        i2c_del_driver(&rs5c372_driver);
+}
+
+module_init(rs5c372_init);
+module_exit(rs5c372_exit);
+
+MODULE_AUTHOR(
+                "Pavel Mironchik <pmironchik@optifacio.net>, "
+                "Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
new file mode 100644
index 000000000000..83b2bb480a16
--- /dev/null
+++ b/drivers/rtc/rtc-sa1100.c
@@ -0,0 +1,388 @@
+/*
+ * Real Time Clock interface for StrongARM SA1x00 and XScale PXA2xx
+ *
+ * Copyright (c) 2000 Nils Faerber
+ *
+ * Based on rtc.c by Paul Gortmaker
+ *
+ * Original Driver by Nils Faerber <nils@kernelconcepts.de>
+ *
+ * Modifications from:
+ *   CIH <cih@coventive.com>
+ *   Nicolas Pitre <nico@cam.org>
+ *   Andrew Christian <andrew.christian@hp.com>
+ *
+ * Converted to the RTC subsystem and Driver Model
+ *   by Richard Purdie <rpurdie@rpsys.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/string.h>
+#include <linux/pm.h>
+
+#include <asm/bitops.h>
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/rtc.h>
+
+#ifdef CONFIG_ARCH_PXA
+#include <asm/arch/pxa-regs.h>
+#endif
+
+#define TIMER_FREQ              CLOCK_TICK_RATE
+#define RTC_DEF_DIVIDER         32768 - 1
+#define RTC_DEF_TRIM            0
+
+static unsigned long rtc_freq = 1024;
+static struct rtc_time rtc_alarm;
+static spinlock_t sa1100_rtc_lock = SPIN_LOCK_UNLOCKED;
+
+static int rtc_update_alarm(struct rtc_time *alrm)
+{
+        struct rtc_time alarm_tm, now_tm;
+        unsigned long now, time;
+        int ret;
+
+        do {
+                now = RCNR;
+                rtc_time_to_tm(now, &now_tm);
+                rtc_next_alarm_time(&alarm_tm, &now_tm, alrm);
+                ret = rtc_tm_to_time(&alarm_tm, &time);
+                if (ret != 0)
+                        break;
+
+                RTSR = RTSR & (RTSR_HZE|RTSR_ALE|RTSR_AL);
+                RTAR = time;
+        } while (now != RCNR);
+
+        return ret;
+}
+
+static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id,
+                struct pt_regs *regs)
+{
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        unsigned int rtsr;
+        unsigned long events = 0;
+
+        spin_lock(&sa1100_rtc_lock);
+
+        rtsr = RTSR;
+        /* clear interrupt sources */
+        RTSR = 0;
+        RTSR = (RTSR_AL | RTSR_HZ) & (rtsr >> 2);
+
+        /* clear alarm interrupt if it has occurred */
+        if (rtsr & RTSR_AL)
+                rtsr &= ~RTSR_ALE;
+        RTSR = rtsr & (RTSR_ALE | RTSR_HZE);
+
+        /* update irq data & counter */
+        if (rtsr & RTSR_AL)
+                events |= RTC_AF | RTC_IRQF;
+        if (rtsr & RTSR_HZ)
+                events |= RTC_UF | RTC_IRQF;
+
+        rtc_update_irq(&rtc->class_dev, 1, events);
+
+        if (rtsr & RTSR_AL && rtc_periodic_alarm(&rtc_alarm))
+                rtc_update_alarm(&rtc_alarm);
+
+        spin_unlock(&sa1100_rtc_lock);
+
+        return IRQ_HANDLED;
+}
+
+static int rtc_timer1_count;
+
+static irqreturn_t timer1_interrupt(int irq, void *dev_id,
+                struct pt_regs *regs)
+{
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        /*
+         * If we match for the first time, rtc_timer1_count will be 1.
+         * Otherwise, we wrapped around (very unlikely but
+         * still possible) so compute the amount of missed periods.
+         * The match reg is updated only when the data is actually retrieved
+         * to avoid unnecessary interrupts.
+         */
+        OSSR = OSSR_M1; /* clear match on timer1 */
+
+        rtc_update_irq(&rtc->class_dev, rtc_timer1_count, RTC_PF | RTC_IRQF);
+
+        if (rtc_timer1_count == 1)
+                rtc_timer1_count = (rtc_freq * ((1<<30)/(TIMER_FREQ>>2)));
+
+        return IRQ_HANDLED;
+}
+
+static int sa1100_rtc_read_callback(struct device *dev, int data)
+{
+        if (data & RTC_PF) {
+                /* interpolate missed periods and set match for the next */
+                unsigned long period = TIMER_FREQ/rtc_freq;
+                unsigned long oscr = OSCR;
+                unsigned long osmr1 = OSMR1;
+                unsigned long missed = (oscr - osmr1)/period;
+                data += missed << 8;
+                OSSR = OSSR_M1; /* clear match on timer 1 */
+                OSMR1 = osmr1 + (missed + 1)*period;
+                /* Ensure we didn't miss another match in the mean time.
+                 * Here we compare (match - OSCR) 8 instead of 0 --
+                 * see comment in pxa_timer_interrupt() for explanation.
+                 */
+                while( (signed long)((osmr1 = OSMR1) - OSCR) <= 8 ) {
+                        data += 0x100;
+                        OSSR = OSSR_M1; /* clear match on timer 1 */
+                        OSMR1 = osmr1 + period;
+                }
+        }
+        return data;
+}
+
+static int sa1100_rtc_open(struct device *dev)
+{
+        int ret;
+
+        ret = request_irq(IRQ_RTC1Hz, sa1100_rtc_interrupt, SA_INTERRUPT,
+                                "rtc 1Hz", dev);
+        if (ret) {
+                printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_RTC1Hz);
+                goto fail_ui;
+        }
+        ret = request_irq(IRQ_RTCAlrm, sa1100_rtc_interrupt, SA_INTERRUPT,
+                                "rtc Alrm", dev);
+        if (ret) {
+                printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_RTCAlrm);
+                goto fail_ai;
+        }
+        ret = request_irq(IRQ_OST1, timer1_interrupt, SA_INTERRUPT,
+                                "rtc timer", dev);
+        if (ret) {
+                printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_OST1);
+                goto fail_pi;
+        }
+        return 0;
+
+ fail_pi:
+        free_irq(IRQ_RTCAlrm, NULL);
+ fail_ai:
+        free_irq(IRQ_RTC1Hz, NULL);
+ fail_ui:
+        return ret;
+}
+
+static void sa1100_rtc_release(struct device *dev)
+{
+        spin_lock_irq(&sa1100_rtc_lock);
+        RTSR = 0;
+        OIER &= ~OIER_E1;
+        OSSR = OSSR_M1;
+        spin_unlock_irq(&sa1100_rtc_lock);
+
+        free_irq(IRQ_OST1, dev);
+        free_irq(IRQ_RTCAlrm, dev);
+        free_irq(IRQ_RTC1Hz, dev);
+}
+
+
+static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
+                unsigned long arg)
+{
+        switch(cmd) {
+        case RTC_AIE_OFF:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR &= ~RTSR_ALE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_AIE_ON:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR |= RTSR_ALE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_UIE_OFF:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR &= ~RTSR_HZE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_UIE_ON:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR |= RTSR_HZE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_PIE_OFF:
+                spin_lock_irq(&sa1100_rtc_lock);
+                OIER &= ~OIER_E1;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_PIE_ON:
+                if ((rtc_freq > 64) && !capable(CAP_SYS_RESOURCE))
+                        return -EACCES;
+                spin_lock_irq(&sa1100_rtc_lock);
+                OSMR1 = TIMER_FREQ/rtc_freq + OSCR;
+                OIER |= OIER_E1;
+                rtc_timer1_count = 1;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_IRQP_READ:
+                return put_user(rtc_freq, (unsigned long *)arg);
+        case RTC_IRQP_SET:
+                if (arg < 1 || arg > TIMER_FREQ)
+                        return -EINVAL;
+                if ((arg > 64) && (!capable(CAP_SYS_RESOURCE)))
+                        return -EACCES;
+                rtc_freq = arg;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        rtc_time_to_tm(RCNR, tm);
+        return 0;
+}
+
+static int sa1100_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time;
+        int ret;
+
+        ret = rtc_tm_to_time(tm, &time);
+        if (ret == 0)
+                RCNR = time;
+        return ret;
+}
+
+static int sa1100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        memcpy(&alrm->time, &rtc_alarm, sizeof(struct rtc_time));
+        alrm->pending = RTSR & RTSR_AL ? 1 : 0;
+        return 0;
+}
+
+static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        int ret;
+
+        spin_lock_irq(&sa1100_rtc_lock);
+        ret = rtc_update_alarm(&alrm->time);
+        if (ret == 0) {
+                memcpy(&rtc_alarm, &alrm->time, sizeof(struct rtc_time));
+
+                if (alrm->enabled)
+                        enable_irq_wake(IRQ_RTCAlrm);
+                else
+                        disable_irq_wake(IRQ_RTCAlrm);
+        }
+        spin_unlock_irq(&sa1100_rtc_lock);
+
+        return ret;
+}
+
+static int sa1100_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        seq_printf(seq, "trim/divider\t: 0x%08x\n", RTTR);
+        seq_printf(seq, "alarm_IRQ\t: %s\n",
+                        (RTSR & RTSR_ALE) ? "yes" : "no" );
+        seq_printf(seq, "update_IRQ\t: %s\n",
+                        (RTSR & RTSR_HZE) ? "yes" : "no");
+        seq_printf(seq, "periodic_IRQ\t: %s\n",
+                        (OIER & OIER_E1) ? "yes" : "no");
+        seq_printf(seq, "periodic_freq\t: %ld\n", rtc_freq);
+
+        return 0;
+}
+
+static struct rtc_class_ops sa1100_rtc_ops = {
+        .open = sa1100_rtc_open,
+        .read_callback = sa1100_rtc_read_callback,
+        .release = sa1100_rtc_release,
+        .ioctl = sa1100_rtc_ioctl,
+        .read_time = sa1100_rtc_read_time,
+        .set_time = sa1100_rtc_set_time,
+        .read_alarm = sa1100_rtc_read_alarm,
+        .set_alarm = sa1100_rtc_set_alarm,
+        .proc = sa1100_rtc_proc,
+};
+
+static int sa1100_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+
+        /*
+         * According to the manual we should be able to let RTTR be zero
+         * and then a default diviser for a 32.768KHz clock is used.
+         * Apparently this doesn't work, at least for my SA1110 rev 5.
+         * If the clock divider is uninitialized then reset it to the
+         * default value to get the 1Hz clock.
+         */
+        if (RTTR == 0) {
+                RTTR = RTC_DEF_DIVIDER + (RTC_DEF_TRIM << 16);
+                printk(KERN_WARNING "rtc: warning: initializing default clock divider/trim value\n");
+                /* The current RTC value probably doesn't make sense either */
+                RCNR = 0;
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
+                                THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&pdev->dev, "Unable to register the RTC device\n");
+                return PTR_ERR(rtc);
+        }
+
+        platform_set_drvdata(pdev, rtc);
+
+        dev_info(&pdev->dev, "SA11xx/PXA2xx RTC Registered\n");
+
+        return 0;
+}
+
+static int sa1100_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        return 0;
+}
+
+static struct platform_driver sa1100_rtc_driver = {
+        .probe          = sa1100_rtc_probe,
+        .remove         = sa1100_rtc_remove,
+        .driver         = {
+                .name           = "sa1100-rtc",
+        },
+};
+
+static int __init sa1100_rtc_init(void)
+{
+        return platform_driver_register(&sa1100_rtc_driver);
+}
+
+static void __exit sa1100_rtc_exit(void)
+{
+        platform_driver_unregister(&sa1100_rtc_driver);
+}
+
+module_init(sa1100_rtc_init);
+module_exit(sa1100_rtc_exit);
+
+MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
+MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
new file mode 100644
index 000000000000..7c1f3d2e53c4
--- /dev/null
+++ b/drivers/rtc/rtc-sysfs.c
@@ -0,0 +1,124 @@
+/*
+ * RTC subsystem, sysfs interface
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+
+/* device attributes */
+
+static ssize_t rtc_sysfs_show_name(struct class_device *dev, char *buf)
+{
+        return sprintf(buf, "%s\n", to_rtc_device(dev)->name);
+}
+static CLASS_DEVICE_ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL);
+
+static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf)
+{
+        ssize_t retval;
+        struct rtc_time tm;
+
+        retval = rtc_read_time(dev, &tm);
+        if (retval == 0) {
+                retval = sprintf(buf, "%04d-%02d-%02d\n",
+                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
+        }
+
+        return retval;
+}
+static CLASS_DEVICE_ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL);
+
+static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf)
+{
+        ssize_t retval;
+        struct rtc_time tm;
+
+        retval = rtc_read_time(dev, &tm);
+        if (retval == 0) {
+                retval = sprintf(buf, "%02d:%02d:%02d\n",
+                        tm.tm_hour, tm.tm_min, tm.tm_sec);
+        }
+
+        return retval;
+}
+static CLASS_DEVICE_ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL);
+
+static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf)
+{
+        ssize_t retval;
+        struct rtc_time tm;
+
+        retval = rtc_read_time(dev, &tm);
+        if (retval == 0) {
+                unsigned long time;
+                rtc_tm_to_time(&tm, &time);
+                retval = sprintf(buf, "%lu\n", time);
+        }
+
+        return retval;
+}
+static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL);
+
+static struct attribute *rtc_attrs[] = {
+        &class_device_attr_name.attr,
+        &class_device_attr_date.attr,
+        &class_device_attr_time.attr,
+        &class_device_attr_since_epoch.attr,
+        NULL,
+};
+
+static struct attribute_group rtc_attr_group = {
+        .attrs = rtc_attrs,
+};
+
+static int __devinit rtc_sysfs_add_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        int err;
+
+        dev_info(class_dev->dev, "rtc intf: sysfs\n");
+
+        err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group);
+        if (err)
+                dev_err(class_dev->dev,
+                        "failed to create sysfs attributes\n");
+
+        return err;
+}
+
+static void rtc_sysfs_remove_device(struct class_device *class_dev,
+                                struct class_interface *class_intf)
+{
+        sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
+}
+
+/* interface registration */
+
+static struct class_interface rtc_sysfs_interface = {
+        .add = &rtc_sysfs_add_device,
+        .remove = &rtc_sysfs_remove_device,
+};
+
+static int __init rtc_sysfs_init(void)
+{
+        return rtc_interface_register(&rtc_sysfs_interface);
+}
+
+static void __exit rtc_sysfs_exit(void)
+{
+        class_interface_unregister(&rtc_sysfs_interface);
+}
+
+module_init(rtc_sysfs_init);
+module_exit(rtc_sysfs_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC class sysfs interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
new file mode 100644
index 000000000000..43d107487820
--- /dev/null
+++ b/drivers/rtc/rtc-test.c
@@ -0,0 +1,204 @@
+/*
+ * An RTC test device/driver
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+
+static struct platform_device *test0 = NULL, *test1 = NULL;
+
+static int test_rtc_read_alarm(struct device *dev,
+        struct rtc_wkalrm *alrm)
+{
+        return 0;
+}
+
+static int test_rtc_set_alarm(struct device *dev,
+        struct rtc_wkalrm *alrm)
+{
+        return 0;
+}
+
+static int test_rtc_read_time(struct device *dev,
+        struct rtc_time *tm)
+{
+        rtc_time_to_tm(get_seconds(), tm);
+        return 0;
+}
+
+static int test_rtc_set_time(struct device *dev,
+        struct rtc_time *tm)
+{
+        return 0;
+}
+
+static int test_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        return 0;
+}
+
+static int test_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        struct platform_device *plat_dev = to_platform_device(dev);
+
+        seq_printf(seq, "24hr\t\t: yes\n");
+        seq_printf(seq, "test\t\t: yes\n");
+        seq_printf(seq, "id\t\t: %d\n", plat_dev->id);
+
+        return 0;
+}
+
+static int test_rtc_ioctl(struct device *dev, unsigned int cmd,
+        unsigned long arg)
+{
+        /* We do support interrupts, they're generated
+         * using the sysfs interface.
+         */
+        switch (cmd) {
+        case RTC_PIE_ON:
+        case RTC_PIE_OFF:
+        case RTC_UIE_ON:
+        case RTC_UIE_OFF:
+        case RTC_AIE_ON:
+        case RTC_AIE_OFF:
+                return 0;
+
+        default:
+                return -EINVAL;
+        }
+}
+
+static struct rtc_class_ops test_rtc_ops = {
+        .proc = test_rtc_proc,
+        .read_time = test_rtc_read_time,
+        .set_time = test_rtc_set_time,
+        .read_alarm = test_rtc_read_alarm,
+        .set_alarm = test_rtc_set_alarm,
+        .set_mmss = test_rtc_set_mmss,
+        .ioctl = test_rtc_ioctl,
+};
+
+static ssize_t test_irq_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%d\n", 42);
+}
+static ssize_t test_irq_store(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int retval;
+        struct platform_device *plat_dev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
+
+        retval = count;
+        if (strncmp(buf, "tick", 4) == 0)
+                rtc_update_irq(&rtc->class_dev, 1, RTC_PF | RTC_IRQF);
+        else if (strncmp(buf, "alarm", 5) == 0)
+                rtc_update_irq(&rtc->class_dev, 1, RTC_AF | RTC_IRQF);
+        else if (strncmp(buf, "update", 6) == 0)
+                rtc_update_irq(&rtc->class_dev, 1, RTC_UF | RTC_IRQF);
+        else
+                retval = -EINVAL;
+
+        return retval;
+}
+static DEVICE_ATTR(irq, S_IRUGO | S_IWUSR, test_irq_show, test_irq_store);
+
+static int test_probe(struct platform_device *plat_dev)
+{
+        int err;
+        struct rtc_device *rtc = rtc_device_register("test", &plat_dev->dev,
+                                                &test_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&plat_dev->dev,
+                        "unable to register the class device\n");
+                return err;
+        }
+        device_create_file(&plat_dev->dev, &dev_attr_irq);
+
+        platform_set_drvdata(plat_dev, rtc);
+
+        return 0;
+}
+
+static int __devexit test_remove(struct platform_device *plat_dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
+
+        rtc_device_unregister(rtc);
+        device_remove_file(&plat_dev->dev, &dev_attr_irq);
+
+        return 0;
+}
+
+static struct platform_driver test_drv = {
+        .probe  = test_probe,
+        .remove = __devexit_p(test_remove),
+        .driver = {
+                .name = "rtc-test",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init test_init(void)
+{
+        int err;
+
+        if ((err = platform_driver_register(&test_drv)))
+                return err;
+
+        if ((test0 = platform_device_alloc("rtc-test", 0)) == NULL) {
+                err = -ENOMEM;
+                goto exit_driver_unregister;
+        }
+
+        if ((test1 = platform_device_alloc("rtc-test", 1)) == NULL) {
+                err = -ENOMEM;
+                goto exit_free_test0;
+        }
+
+        if ((err = platform_device_add(test0)))
+                goto exit_free_test1;
+
+        if ((err = platform_device_add(test1)))
+                goto exit_device_unregister;
+
+        return 0;
+
+exit_device_unregister:
+        platform_device_unregister(test0);
+
+exit_free_test1:
+        platform_device_put(test1);
+
+exit_free_test0:
+        platform_device_put(test0);
+
+exit_driver_unregister:
+        platform_driver_unregister(&test_drv);
+        return err;
+}
+
+static void __exit test_exit(void)
+{
+        platform_device_unregister(test0);
+        platform_device_unregister(test1);
+        platform_driver_unregister(&test_drv);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC test driver/device");
+MODULE_LICENSE("GPL");
+
+module_init(test_init);
+module_exit(test_exit);
diff --git a/drivers/i2c/chips/x1205.c b/drivers/rtc/rtc-x1205.c
index 245fffa92dbd..621d17afc0d9 100644
--- a/drivers/i2c/chips/x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -1,32 +1,25 @@
 /*
- *  x1205.c - An i2c driver for the Xicor X1205 RTC
- *  Copyright 2004 Karen Spearel
- *  Copyright 2005 Alessandro Zummo
+ * An i2c driver for the Xicor/Intersil X1205 RTC
+ * Copyright 2004 Karen Spearel
+ * Copyright 2005 Alessandro Zummo
  *
- *  please send all reports to:
- *      kas11 at tampabay dot rr dot com
- *      a dot zummo at towertech dot it
+ * please send all reports to:
+ *      Karen Spearel <kas111 at gmail dot com>
+ *      Alessandro Zummo <a.zummo@towertech.it>
  *
- *  based on the other drivers in this same directory.
+ * based on a lot of other RTC drivers.
  *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/i2c.h>
-#include <linux/string.h>
 #include <linux/bcd.h>
 #include <linux/rtc.h>
-#include <linux/list.h>
+#include <linux/delay.h>
 
-#include <linux/x1205.h>
-
-#define DRV_VERSION "0.9.9"
+#define DRV_VERSION "1.0.6"
 
 /* Addresses to scan: none. This chip is located at
  * 0x6f and uses a two bytes register addressing.
@@ -40,8 +33,6 @@ static unsigned short normal_i2c[] = { I2C_CLIENT_END };
 
 /* Insmod parameters */
 I2C_CLIENT_INSMOD;
-I2C_CLIENT_MODULE_PARM(hctosys,
-        "Set the system time from the hardware clock upon initialization");
 
 /* offsets into CCR area */
 
@@ -101,107 +92,35 @@ I2C_CLIENT_MODULE_PARM(hctosys,
 static int x1205_attach(struct i2c_adapter *adapter);
 static int x1205_detach(struct i2c_client *client);
 static int x1205_probe(struct i2c_adapter *adapter, int address, int kind);
-static int x1205_command(struct i2c_client *client, unsigned int cmd,
-        void *arg);
 
 static struct i2c_driver x1205_driver = {
-        .driver = {
+        .driver         = {
                 .name   = "x1205",
         },
+        .id             = I2C_DRIVERID_X1205,
         .attach_adapter = &x1205_attach,
         .detach_client  = &x1205_detach,
 };
 
-struct x1205_data {
-        struct i2c_client client;
-        struct list_head list;
-        unsigned int epoch;
-};
-
-static const unsigned char days_in_mo[] =
-        { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-static LIST_HEAD(x1205_clients);
-
-/* Workaround until the I2C subsytem will allow to send
- * commands to a specific client. This function will send the command
- * to the first client.
- */
-int x1205_do_command(unsigned int cmd, void *arg)
-{
-        struct list_head *walk;
-        struct list_head *tmp;
-        struct x1205_data *data;
-
-        list_for_each_safe(walk, tmp, &x1205_clients) {
-                data = list_entry(walk, struct x1205_data, list);
-                return x1205_command(&data->client, cmd, arg);
-        }
-
-        return -ENODEV;
-}
-
-#define is_leap(year) \
-        ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
-
-/* make sure the rtc_time values are in bounds */
-static int x1205_validate_tm(struct rtc_time *tm)
-{
-        int year = tm->tm_year + 1900;
-
-        if ((tm->tm_year < 70) || (tm->tm_year > 255))
-                return -EINVAL;
-
-        if ((tm->tm_mon > 11) || (tm->tm_mday == 0))
-                return -EINVAL;
-
-        if (tm->tm_mday > days_in_mo[tm->tm_mon]
-                + ((tm->tm_mon == 1) && is_leap(year)))
-                return -EINVAL;
-
-        if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60))
-                return -EINVAL;
-
-        return 0;
-}
-
 /*
  * In the routines that deal directly with the x1205 hardware, we use
  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
  * Epoch is initialized as 2000. Time is set to UTC.
  */
 static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
-                                u8 reg_base)
+                                unsigned char reg_base)
 {
         unsigned char dt_addr[2] = { 0, reg_base };
-        static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
 
-        unsigned char buf[8], sr;
+        unsigned char buf[8];
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, sr_addr },        /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, &sr },     /* read status */
                 { client->addr, 0, 2, dt_addr },        /* setup read ptr */
                 { client->addr, I2C_M_RD, 8, buf },     /* read date */
         };
 
-        struct x1205_data *data = i2c_get_clientdata(client);
-
-        /* read status register */
-        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
-                return -EIO;
-        }
-
-        /* check for battery failure */
-        if (sr & X1205_SR_RTCF) {
-                dev_warn(&client->dev,
-                        "Clock had a power failure, you must set the date.\n");
-                return -EINVAL;
-        }
-
         /* read date registers */
-        if ((i2c_transfer(client->adapter, &msgs[2], 2)) != 2) {
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
                 dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
                 return -EIO;
         }
@@ -217,9 +136,9 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
         tm->tm_min = BCD2BIN(buf[CCR_MIN]);
         tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
         tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
-        tm->tm_mon = BCD2BIN(buf[CCR_MONTH]);
-        data->epoch = BCD2BIN(buf[CCR_Y2K]) * 100;
-        tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + data->epoch - 1900;
+        tm->tm_mon = BCD2BIN(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
+        tm->tm_year = BCD2BIN(buf[CCR_YEAR])
+                        + (BCD2BIN(buf[CCR_Y2K]) * 100) - 1900;
         tm->tm_wday = buf[CCR_WDAY];
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
@@ -231,11 +150,28 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
         return 0;
 }
 
+static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
+{
+        static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 2, sr_addr },        /* setup read ptr */
+                { client->addr, I2C_M_RD, 1, sr },      /* read status */
+        };
+
+        /* read status register */
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
 static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                                 int datetoo, u8 reg_base)
 {
-        int i, err, xfer;
-
+        int i, xfer;
         unsigned char buf[8];
 
         static const unsigned char wel[3] = { 0, X1205_REG_SR,
@@ -246,17 +182,10 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
 
         static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
 
-        struct x1205_data *data = i2c_get_clientdata(client);
-
-        /* check if all values in the tm struct are correct */
-        if ((err = x1205_validate_tm(tm)) < 0)
-                return err;
-
-        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
-                "mday=%d, mon=%d, year=%d, wday=%d\n",
+        dev_dbg(&client->dev,
+                "%s: secs=%d, mins=%d, hours=%d\n",
                 __FUNCTION__,
-                tm->tm_sec, tm->tm_min, tm->tm_hour,
-                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+                tm->tm_sec, tm->tm_min, tm->tm_hour);
 
         buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
         buf[CCR_MIN] = BIN2BCD(tm->tm_min);
@@ -266,26 +195,29 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
 
         /* should we also set the date? */
         if (datetoo) {
+                dev_dbg(&client->dev,
+                        "%s: mday=%d, mon=%d, year=%d, wday=%d\n",
+                        __FUNCTION__,
+                        tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
                 buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
 
-                /* month, 0 - 11 */
-                buf[CCR_MONTH] = BIN2BCD(tm->tm_mon);
+                /* month, 1 - 12 */
+                buf[CCR_MONTH] = BIN2BCD(tm->tm_mon + 1);
 
-                /* year, since 1900 */
-                buf[CCR_YEAR] = BIN2BCD(tm->tm_year + 1900 - data->epoch);
+                /* year, since the rtc epoch*/
+                buf[CCR_YEAR] = BIN2BCD(tm->tm_year % 100);
                 buf[CCR_WDAY] = tm->tm_wday & 0x07;
-                buf[CCR_Y2K] = BIN2BCD(data->epoch / 100);
+                buf[CCR_Y2K] = BIN2BCD(tm->tm_year / 100);
         }
 
         /* this sequence is required to unlock the chip */
-        xfer = i2c_master_send(client, wel, 3);
-        if (xfer != 3) {
+        if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
                 dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
                 return -EIO;
         }
 
-        xfer = i2c_master_send(client, rwel, 3);
-        if (xfer != 3) {
+        if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
                 dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
                 return -EIO;
         }
@@ -305,8 +237,7 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
         };
 
         /* disable further writes */
-        xfer = i2c_master_send(client, diswe, 3);
-        if (xfer != 3) {
+        if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
                 dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
                 return -EIO;
         }
@@ -314,6 +245,20 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
         return 0;
 }
 
+static int x1205_fix_osc(struct i2c_client *client)
+{
+        int err;
+        struct rtc_time tm;
+
+        tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
+
+        if ((err = x1205_set_datetime(client, &tm, 0, X1205_CCR_BASE)) < 0)
+                dev_err(&client->dev,
+                        "unable to restart the oscillator\n");
+
+        return err;
+}
+
 static int x1205_get_dtrim(struct i2c_client *client, int *trim)
 {
         unsigned char dtr;
@@ -380,60 +325,9 @@ static int x1205_get_atrim(struct i2c_client *client, int *trim)
         return 0;
 }
 
-static int x1205_hctosys(struct i2c_client *client)
-{
-        int err;
-
-        struct rtc_time tm;
-        struct timespec tv;
-
-        err = x1205_command(client, X1205_CMD_GETDATETIME, &tm);
-
-        if (err) {
-                dev_err(&client->dev,
-                        "Unable to set the system clock\n");
-                return err;
-        }
-
-        /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
-         * whether it stores the most close value or the value with partial
-         * seconds truncated. However, it is important that we use it to store
-         * the truncated value. This is because otherwise it is necessary,
-         * in an rtc sync function, to read both xtime.tv_sec and
-         * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
-         * of >32bits is not possible. So storing the most close value would
-         * slow down the sync API. So here we have the truncated value and
-         * the best guess is to add 0.5s.
-         */
-
-        tv.tv_nsec = NSEC_PER_SEC >> 1;
-
-        /* WARNING: this is not the C library 'mktime' call, it is a built in
-         * inline function from include/linux/time.h.  It expects (requires)
-         * the month to be in the range 1-12
-         */
-
-        tv.tv_sec  = mktime(tm.tm_year + 1900, tm.tm_mon + 1,
-                                tm.tm_mday, tm.tm_hour,
-                                tm.tm_min, tm.tm_sec);
-
-        do_settimeofday(&tv);
-
-        dev_info(&client->dev,
-                "setting the system clock to %d-%d-%d %d:%d:%d\n",
-                tm.tm_year + 1900, tm.tm_mon + 1,
-                tm.tm_mday, tm.tm_hour, tm.tm_min,
-                tm.tm_sec);
-
-        return 0;
-}
-
 struct x1205_limit
 {
-        unsigned char reg;
-        unsigned char mask;
-        unsigned char min;
-        unsigned char max;
+        unsigned char reg, mask, min, max;
 };
 
 static int x1205_validate_client(struct i2c_client *client)
@@ -477,11 +371,10 @@ static int x1205_validate_client(struct i2c_client *client)
                         { client->addr, I2C_M_RD, 1, &buf },
                 };
 
-                xfer = i2c_transfer(client->adapter, msgs, 2);
-                if (xfer != 2) {
+                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
                         dev_err(&client->adapter->dev,
                                 "%s: could not read register %x\n",
-                                __FUNCTION__, addr[1]);
+                                __FUNCTION__, probe_zero_pattern[i]);
 
                         return -EIO;
                 }
@@ -489,7 +382,7 @@ static int x1205_validate_client(struct i2c_client *client)
                 if ((buf & probe_zero_pattern[i+1]) != 0) {
                         dev_err(&client->adapter->dev,
                                 "%s: register=%02x, zero pattern=%d, value=%x\n",
-                                __FUNCTION__, addr[1], i, buf);
+                                __FUNCTION__, probe_zero_pattern[i], i, buf);
 
                         return -ENODEV;
                 }
@@ -506,12 +399,10 @@ static int x1205_validate_client(struct i2c_client *client)
                         { client->addr, I2C_M_RD, 1, &reg },
                 };
 
-                xfer = i2c_transfer(client->adapter, msgs, 2);
-
-                if (xfer != 2) {
+                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
                         dev_err(&client->adapter->dev,
                                 "%s: could not read register %x\n",
-                                __FUNCTION__, addr[1]);
+                                __FUNCTION__, probe_limits_pattern[i].reg);
 
                         return -EIO;
                 }
@@ -522,7 +413,8 @@ static int x1205_validate_client(struct i2c_client *client)
                         value < probe_limits_pattern[i].min) {
                         dev_dbg(&client->adapter->dev,
                                 "%s: register=%x, lim pattern=%d, value=%d\n",
-                                __FUNCTION__, addr[1], i, value);
+                                __FUNCTION__, probe_limits_pattern[i].reg,
+                                i, value);
 
                         return -ENODEV;
                 }
@@ -531,37 +423,89 @@ static int x1205_validate_client(struct i2c_client *client)
         return 0;
 }
 
-static int x1205_attach(struct i2c_adapter *adapter)
+static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
-        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return x1205_get_datetime(to_i2c_client(dev),
+                &alrm->time, X1205_ALM0_BASE);
+}
 
-        return i2c_probe(adapter, &addr_data, x1205_probe);
+static int x1205_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        return x1205_set_datetime(to_i2c_client(dev),
+                &alrm->time, 1, X1205_ALM0_BASE);
 }
 
-int x1205_direct_attach(int adapter_id,
-        struct i2c_client_address_data *address_data)
+static int x1205_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        int err;
-        struct i2c_adapter *adapter = i2c_get_adapter(adapter_id);
+        return x1205_get_datetime(to_i2c_client(dev),
+                tm, X1205_CCR_BASE);
+}
 
-        if (adapter) {
-                err = i2c_probe(adapter,
-                        address_data, x1205_probe);
+static int x1205_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return x1205_set_datetime(to_i2c_client(dev),
+                tm, 1, X1205_CCR_BASE);
+}
 
-                i2c_put_adapter(adapter);
+static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        int err, dtrim, atrim;
 
-                return err;
-        }
+        seq_printf(seq, "24hr\t\t: yes\n");
 
-        return -ENODEV;
+        if ((err = x1205_get_dtrim(to_i2c_client(dev), &dtrim)) == 0)
+                seq_printf(seq, "digital_trim\t: %d ppm\n", dtrim);
+
+        if ((err = x1205_get_atrim(to_i2c_client(dev), &atrim)) == 0)
+                seq_printf(seq, "analog_trim\t: %d.%02d pF\n",
+                        atrim / 1000, atrim % 1000);
+        return 0;
 }
 
-static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
+static struct rtc_class_ops x1205_rtc_ops = {
+        .proc           = x1205_rtc_proc,
+        .read_time      = x1205_rtc_read_time,
+        .set_time       = x1205_rtc_set_time,
+        .read_alarm     = x1205_rtc_read_alarm,
+        .set_alarm      = x1205_rtc_set_alarm,
+};
+
+static ssize_t x1205_sysfs_show_atrim(struct device *dev,
+                                struct device_attribute *attr, char *buf)
 {
-        struct i2c_client *client;
-        struct x1205_data *data;
+        int atrim;
+
+        if (x1205_get_atrim(to_i2c_client(dev), &atrim) == 0)
+                return sprintf(buf, "%d.%02d pF\n",
+                        atrim / 1000, atrim % 1000);
+        return 0;
+}
+static DEVICE_ATTR(atrim, S_IRUGO, x1205_sysfs_show_atrim, NULL);
+
+static ssize_t x1205_sysfs_show_dtrim(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int dtrim;
+
+        if (x1205_get_dtrim(to_i2c_client(dev), &dtrim) == 0)
+                return sprintf(buf, "%d ppm\n", dtrim);
+
+        return 0;
+}
+static DEVICE_ATTR(dtrim, S_IRUGO, x1205_sysfs_show_dtrim, NULL);
 
+static int x1205_attach(struct i2c_adapter *adapter)
+{
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return i2c_probe(adapter, &addr_data, x1205_probe);
+}
+
+static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
+{
         int err = 0;
+        unsigned char sr;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
 
         dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
 
@@ -570,22 +514,17 @@ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
                 goto exit;
         }
 
-        if (!(data = kzalloc(sizeof(struct x1205_data), GFP_KERNEL))) {
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto exit;
         }
 
-        /* Initialize our structures */
-        data->epoch = 2000;
-
-        client = &data->client;
+        /* I2C client */
         client->addr = address;
         client->driver = &x1205_driver;
         client->adapter = adapter;
 
-        strlcpy(client->name, "x1205", I2C_NAME_SIZE);
-
-        i2c_set_clientdata(client, data);
+        strlcpy(client->name, x1205_driver.driver.name, I2C_NAME_SIZE);
 
         /* Verify the chip is really an X1205 */
         if (kind < 0) {
@@ -599,18 +538,43 @@ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
         if ((err = i2c_attach_client(client)))
                 goto exit_kfree;
 
-        list_add(&data->list, &x1205_clients);
-
         dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 
-        /* If requested, set the system time */
-        if (hctosys)
-                x1205_hctosys(client);
+        rtc = rtc_device_register(x1205_driver.driver.name, &client->dev,
+                                &x1205_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        /* Check for power failures and eventualy enable the osc */
+        if ((err = x1205_get_status(client, &sr)) == 0) {
+                if (sr & X1205_SR_RTCF) {
+                        dev_err(&client->dev,
+                                "power failure detected, "
+                                "please set the clock\n");
+                        udelay(50);
+                        x1205_fix_osc(client);
+                }
+        }
+        else
+                dev_err(&client->dev, "couldn't read status\n");
+
+        device_create_file(&client->dev, &dev_attr_atrim);
+        device_create_file(&client->dev, &dev_attr_dtrim);
 
         return 0;
 
+exit_detach:
+        i2c_detach_client(client);
+
 exit_kfree:
-        kfree(data);
+        kfree(client);
 
 exit:
         return err;
@@ -619,61 +583,21 @@ exit:
 static int x1205_detach(struct i2c_client *client)
 {
         int err;
-        struct x1205_data *data = i2c_get_clientdata(client);
+        struct rtc_device *rtc = i2c_get_clientdata(client);
 
         dev_dbg(&client->dev, "%s\n", __FUNCTION__);
 
+        if (rtc)
+                rtc_device_unregister(rtc);
+
         if ((err = i2c_detach_client(client)))
                 return err;
 
-        list_del(&data->list);
-
-        kfree(data);
+        kfree(client);
 
         return 0;
 }
 
-static int x1205_command(struct i2c_client *client, unsigned int cmd,
-        void *param)
-{
-        if (param == NULL)
-                return -EINVAL;
-
-        if (!capable(CAP_SYS_TIME))
-                return -EACCES;
-
-        dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd);
-
-        switch (cmd) {
-        case X1205_CMD_GETDATETIME:
-                return x1205_get_datetime(client, param, X1205_CCR_BASE);
-
-        case X1205_CMD_SETTIME:
-                return x1205_set_datetime(client, param, 0,
-                                X1205_CCR_BASE);
-
-        case X1205_CMD_SETDATETIME:
-                return x1205_set_datetime(client, param, 1,
-                                X1205_CCR_BASE);
-
-        case X1205_CMD_GETALARM:
-                return x1205_get_datetime(client, param, X1205_ALM0_BASE);
-
-        case X1205_CMD_SETALARM:
-                return x1205_set_datetime(client, param, 1,
-                                X1205_ALM0_BASE);
-
-        case X1205_CMD_GETDTRIM:
-                return x1205_get_dtrim(client, param);
-
-        case X1205_CMD_GETATRIM:
-                return x1205_get_atrim(client, param);
-
-        default:
-                return -EINVAL;
-        }
-}
-
 static int __init x1205_init(void)
 {
         return i2c_add_driver(&x1205_driver);
@@ -685,14 +609,11 @@ static void __exit x1205_exit(void)
 }
 
 MODULE_AUTHOR(
-        "Karen Spearel <kas11@tampabay.rr.com>, "
+        "Karen Spearel <kas111 at gmail dot com>, "
         "Alessandro Zummo <a.zummo@towertech.it>");
-MODULE_DESCRIPTION("Xicor X1205 RTC driver");
+MODULE_DESCRIPTION("Xicor/Intersil X1205 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-EXPORT_SYMBOL_GPL(x1205_do_command);
-EXPORT_SYMBOL_GPL(x1205_direct_attach);
-
 module_init(x1205_init);
 module_exit(x1205_exit);
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 62e3cda859af..7f7013e80a88 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -671,7 +671,7 @@ static struct file_operations gdth_fops = {
 static struct notifier_block gdth_notifier = {
     gdth_halt, NULL, 0
 };
-
+static int notifier_disabled = 0;
 
 static void gdth_delay(int milliseconds)
 {
@@ -4595,13 +4595,13 @@ static int __init gdth_detect(struct scsi_host_template *shtp)
         add_timer(&gdth_timer);
 #endif
         major = register_chrdev(0,"gdth",&gdth_fops);
+        notifier_disabled = 0;
         register_reboot_notifier(&gdth_notifier);
     }
     gdth_polling = FALSE;
     return gdth_ctr_vcount;
 }
 
-
 static int gdth_release(struct Scsi_Host *shp)
 {
     int hanum;
@@ -5632,10 +5632,14 @@ static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
     char            cmnd[MAX_COMMAND_SIZE];   
 #endif
 
+    if (notifier_disabled)
+        return NOTIFY_OK;
+
     TRACE2(("gdth_halt() event %d\n",(int)event));
     if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
         return NOTIFY_DONE;
 
+    notifier_disabled = 1;
     printk("GDT-HA: Flushing all host drives .. ");
     for (hanum = 0; hanum < gdth_ctr_count; ++hanum) {
         gdth_flush(hanum);
@@ -5679,7 +5683,6 @@ static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
 #ifdef GDTH_STATISTICS
     del_timer(&gdth_timer);
 #endif
-    unregister_reboot_notifier(&gdth_notifier);
     return NOTIFY_OK;
 }
 
diff --git a/drivers/usb/core/notify.c b/drivers/usb/core/notify.c
index 4b55285de9a0..fe0ed54fa0ae 100644
--- a/drivers/usb/core/notify.c
+++ b/drivers/usb/core/notify.c
@@ -16,57 +16,7 @@
 #include <linux/mutex.h>
 #include "usb.h"
 
-
-static struct notifier_block *usb_notifier_list;
-static DEFINE_MUTEX(usb_notifier_lock);
-
-static void usb_notifier_chain_register(struct notifier_block **list,
-                                        struct notifier_block *n)
-{
-        mutex_lock(&usb_notifier_lock);
-        while (*list) {
-                if (n->priority > (*list)->priority)
-                        break;
-                list = &((*list)->next);
-        }
-        n->next = *list;
-        *list = n;
-        mutex_unlock(&usb_notifier_lock);
-}
-
-static void usb_notifier_chain_unregister(struct notifier_block **nl,
-                                   struct notifier_block *n)
-{
-        mutex_lock(&usb_notifier_lock);
-        while ((*nl)!=NULL) {
-                if ((*nl)==n) {
-                        *nl = n->next;
-                        goto exit;
-                }
-                nl=&((*nl)->next);
-        }
-exit:
-        mutex_unlock(&usb_notifier_lock);
-}
-
-static int usb_notifier_call_chain(struct notifier_block **n,
-                                   unsigned long val, void *v)
-{
-        int ret=NOTIFY_DONE;
-        struct notifier_block *nb = *n;
-
-        mutex_lock(&usb_notifier_lock);
-        while (nb) {
-                ret = nb->notifier_call(nb,val,v);
-                if (ret&NOTIFY_STOP_MASK) {
-                        goto exit;
-                }
-                nb = nb->next;
-        }
-exit:
-        mutex_unlock(&usb_notifier_lock);
-        return ret;
-}
+static BLOCKING_NOTIFIER_HEAD(usb_notifier_list);
 
 /**
  * usb_register_notify - register a notifier callback whenever a usb change happens
@@ -76,7 +26,7 @@ exit:
  */
 void usb_register_notify(struct notifier_block *nb)
 {
-        usb_notifier_chain_register(&usb_notifier_list, nb);
+        blocking_notifier_chain_register(&usb_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(usb_register_notify);
 
@@ -89,27 +39,28 @@ EXPORT_SYMBOL_GPL(usb_register_notify);
  */
 void usb_unregister_notify(struct notifier_block *nb)
 {
-        usb_notifier_chain_unregister(&usb_notifier_list, nb);
+        blocking_notifier_chain_unregister(&usb_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(usb_unregister_notify);
 
 
 void usb_notify_add_device(struct usb_device *udev)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_DEVICE_ADD, udev);
+        blocking_notifier_call_chain(&usb_notifier_list, USB_DEVICE_ADD, udev);
 }
 
 void usb_notify_remove_device(struct usb_device *udev)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_DEVICE_REMOVE, udev);
+        blocking_notifier_call_chain(&usb_notifier_list,
+                        USB_DEVICE_REMOVE, udev);
 }
 
 void usb_notify_add_bus(struct usb_bus *ubus)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_BUS_ADD, ubus);
+        blocking_notifier_call_chain(&usb_notifier_list, USB_BUS_ADD, ubus);
 }
 
 void usb_notify_remove_bus(struct usb_bus *ubus)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_BUS_REMOVE, ubus);
+        blocking_notifier_call_chain(&usb_notifier_list, USB_BUS_REMOVE, ubus);
 }
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index fdebd60a3250..22e9d696fdd2 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -70,6 +70,22 @@ config FB_MACMODES
        depends on FB
        default n
 
+config FB_FIRMWARE_EDID
+       bool "Enable firmware EDID"
+       depends on FB
+       default y
+       ---help---
+         This enables access to the EDID transferred from the firmware.
+         On the i386, this is from the Video BIOS. Enable this if DDC/I2C
+         transfers do not work for your driver and if you are using
+         nvidiafb, i810fb or savagefb.
+
+         In general, choosing Y for this option is safe.  If you
+         experience extremely long delays while booting before you get
+         something on your display, try setting this to N.  Matrox cards in
+         combination with certain motherboards and monitors are known to
+         suffer from this problem.
+
 config FB_MODE_HELPERS
         bool "Enable Video Mode Handling Helpers"
         depends on FB
@@ -1202,6 +1218,17 @@ config FB_AU1100
         bool "Au1100 LCD Driver"
         depends on (FB = y) && EXPERIMENTAL && PCI && MIPS && MIPS_PB1100=y
 
+config FB_AU1200
+        bool "Au1200 LCD Driver"
+        depends on FB && MIPS && SOC_AU1200
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This is the framebuffer driver for the AMD Au1200 SOC.  It can drive
+          various panels and CRTs by passing in kernel cmd line option
+          au1200fb:panel=<name>.
+
 source "drivers/video/geode/Kconfig"
 
 config FB_FFB
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index aa434e725c0d..cb90218515ac 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -86,6 +86,7 @@ obj-$(CONFIG_FB_ASILIANT)	  += asiliantfb.o
 obj-$(CONFIG_FB_PXA)              += pxafb.o
 obj-$(CONFIG_FB_W100)             += w100fb.o
 obj-$(CONFIG_FB_AU1100)           += au1100fb.o
+obj-$(CONFIG_FB_AU1200)           += au1200fb.o
 obj-$(CONFIG_FB_PMAG_AA)          += pmag-aa-fb.o
 obj-$(CONFIG_FB_PMAG_BA)          += pmag-ba-fb.o
 obj-$(CONFIG_FB_PMAGB_B)          += pmagb-b-fb.o
diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c
index 76448d6ae896..98baecccb3fd 100644
--- a/drivers/video/acornfb.c
+++ b/drivers/video/acornfb.c
@@ -1308,7 +1308,7 @@ static int __init acornfb_probe(struct platform_device *dev)
         /*
          * Try to select a suitable default mode
          */
-        for (i = 0; i < sizeof(modedb) / sizeof(*modedb); i++) {
+        for (i = 0; i < ARRAY_SIZE(modedb); i++) {
                 unsigned long hs;
 
                 hs = modedb[i].refresh *
@@ -1380,7 +1380,7 @@ static int __init acornfb_probe(struct platform_device *dev)
          */
         free_unused_pages(PAGE_OFFSET + size, PAGE_OFFSET + MAX_SIZE);
 #endif
-        
+
         fb_info.fix.smem_len = size;
         current_par.palette_size   = VIDC_PALETTE_SIZE;
 
@@ -1391,7 +1391,7 @@ static int __init acornfb_probe(struct platform_device *dev)
          */
         do {
                 rc = fb_find_mode(&fb_info.var, &fb_info, NULL, modedb,
-                                 sizeof(modedb) / sizeof(*modedb),
+                                 ARRAY_SIZE(modedb),
                                  &acornfb_default_mode, DEFAULT_BPP);
                 /*
                  * If we found an exact match, all ok.
@@ -1408,7 +1408,7 @@ static int __init acornfb_probe(struct platform_device *dev)
                         break;
 
                 rc = fb_find_mode(&fb_info.var, &fb_info, NULL, modedb,
-                                 sizeof(modedb) / sizeof(*modedb),
+                                 ARRAY_SIZE(modedb),
                                  &acornfb_default_mode, DEFAULT_BPP);
                 if (rc)
                         break;
diff --git a/drivers/video/asiliantfb.c b/drivers/video/asiliantfb.c
index c924d81f7978..29f9f0dfe3b4 100644
--- a/drivers/video/asiliantfb.c
+++ b/drivers/video/asiliantfb.c
@@ -353,8 +353,6 @@ struct chips_init_reg {
         unsigned char data;
 };
 
-#define N_ELTS(x)       (sizeof(x) / sizeof(x[0]))
-
 static struct chips_init_reg chips_init_sr[] =
 {
         {0x00, 0x03},           /* Reset register */
@@ -460,22 +458,22 @@ static void __devinit chips_hw_init(struct fb_info *p)
 {
         int i;
 
-        for (i = 0; i < N_ELTS(chips_init_xr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_xr); ++i)
                 write_xr(chips_init_xr[i].addr, chips_init_xr[i].data);
         write_xr(0x81, 0x12);
         write_xr(0x82, 0x08);
         write_xr(0x20, 0x00);
-        for (i = 0; i < N_ELTS(chips_init_sr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_sr); ++i)
                 write_sr(chips_init_sr[i].addr, chips_init_sr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_gr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_gr); ++i)
                 write_gr(chips_init_gr[i].addr, chips_init_gr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_ar); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_ar); ++i)
                 write_ar(chips_init_ar[i].addr, chips_init_ar[i].data);
         /* Enable video output in attribute index register */
         writeb(0x20, mmio_base + 0x780);
-        for (i = 0; i < N_ELTS(chips_init_cr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_cr); ++i)
                 write_cr(chips_init_cr[i].addr, chips_init_cr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_fr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_fr); ++i)
                 write_fr(chips_init_fr[i].addr, chips_init_fr[i].data);
 }
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 620c9a934e0e..821c6da8e42c 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1725,9 +1725,9 @@ static int __init aty128_init(struct pci_dev *pdev, const struct pci_device_id *
         strcpy(video_card, "Rage128 XX ");
         video_card[8] = ent->device >> 8;
         video_card[9] = ent->device & 0xFF;
-            
+
         /* range check to make sure */
-        if (ent->driver_data < (sizeof(r128_family)/sizeof(char *)))
+        if (ent->driver_data < ARRAY_SIZE(r128_family))
             strncat(video_card, r128_family[ent->driver_data], sizeof(video_card));
 
         printk(KERN_INFO "aty128fb: %s [chip rev 0x%x] ", video_card, chip_rev);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 485be386a8ff..e799fcca365a 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -434,7 +434,7 @@ static int __devinit correct_chipset(struct atyfb_par *par)
         const char *name;
         int i;
 
-        for (i = sizeof(aty_chips) / sizeof(*aty_chips) - 1; i >= 0; i--)
+        for (i = ARRAY_SIZE(aty_chips) - 1; i >= 0; i--)
                 if (par->pci_id == aty_chips[i].pci_id)
                         break;
 
@@ -2168,10 +2168,10 @@ static void __init aty_calc_mem_refresh(struct atyfb_par *par, int xclk)
 
         if (IS_XL(par->pci_id) || IS_MOBILITY(par->pci_id)) {
                 refresh_tbl = ragexl_tbl;
-                size = sizeof(ragexl_tbl)/sizeof(int);
+                size = ARRAY_SIZE(ragexl_tbl);
         } else {
                 refresh_tbl = ragepro_tbl;
-                size = sizeof(ragepro_tbl)/sizeof(int);
+                size = ARRAY_SIZE(ragepro_tbl);
         }
 
         for (i=0; i < size; i++) {
@@ -2298,6 +2298,10 @@ static int __init aty_init(struct fb_info *info, const char *name)
                 case CLK_ATI18818_1:
                         par->pll_ops = &aty_pll_ati18818_1;
                         break;
+                case CLK_IBMRGB514:
+                        par->pll_ops = &aty_pll_ibm514;
+                        break;
+#if 0 /* dead code */
                 case CLK_STG1703:
                         par->pll_ops = &aty_pll_stg1703;
                         break;
@@ -2307,9 +2311,7 @@ static int __init aty_init(struct fb_info *info, const char *name)
                 case CLK_ATT20C408:
                         par->pll_ops = &aty_pll_att20c408;
                         break;
-                case CLK_IBMRGB514:
-                        par->pll_ops = &aty_pll_ibm514;
-                        break;
+#endif
                 default:
                         PRINTKI("aty_init: CLK type not implemented yet!");
                         par->pll_ops = &aty_pll_unsupported;
@@ -3397,7 +3399,7 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         struct atyfb_par *par;
         int i, rc = -ENOMEM;
 
-        for (i = sizeof(aty_chips) / sizeof(*aty_chips) - 1; i >= 0; i--)
+        for (i = ARRAY_SIZE(aty_chips); i >= 0; i--)
                 if (pdev->device == aty_chips[i].pci_id)
                         break;
 
diff --git a/drivers/video/aty/mach64_gx.c b/drivers/video/aty/mach64_gx.c
index 01fdff79483b..2045639cb671 100644
--- a/drivers/video/aty/mach64_gx.c
+++ b/drivers/video/aty/mach64_gx.c
@@ -149,8 +149,7 @@ static int aty_var_to_pll_514(const struct fb_info *info, u32 vclk_per,
         };
         int i;
 
-        for (i = 0; i < sizeof(RGB514_clocks) / sizeof(*RGB514_clocks);
-             i++)
+        for (i = 0; i < ARRAY_SIZE(RGB514_clocks); i++)
                 if (vclk_per <= RGB514_clocks[i].limit) {
                         pll->ibm514.m = RGB514_clocks[i].m;
                         pll->ibm514.n = RGB514_clocks[i].n;
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index c9f0c5a07e6e..9a6b5b39b88e 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -1067,7 +1067,7 @@ static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
 
 
         if (regno > 255)
-                return 1;
+                return -EINVAL;
 
         red >>= 8;
         green >>= 8;
@@ -1086,9 +1086,9 @@ static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
                         pindex = regno * 8;
 
                         if (rinfo->depth == 16 && regno > 63)
-                                return 1;
+                                return -EINVAL;
                         if (rinfo->depth == 15 && regno > 31)
-                                return 1;
+                                return -EINVAL;
 
                         /* For 565, the green component is mixed one order
                          * below
diff --git a/drivers/video/au1200fb.c b/drivers/video/au1200fb.c
new file mode 100644
index 000000000000..b367de30b98c
--- /dev/null
+++ b/drivers/video/au1200fb.c
@@ -0,0 +1,3844 @@
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Au1200 LCD Driver.
+ *
+ * Copyright 2004-2005 AMD
+ * Author: AMD
+ *
+ * Based on:
+ * linux/drivers/video/skeletonfb.c -- Skeleton for a frame buffer device
+ *  Created 28 Dec 1997 by Geert Uytterhoeven
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ctype.h>
+#include <linux/dma-mapping.h>
+
+#include <asm/mach-au1x00/au1000.h>
+#include "au1200fb.h"
+
+#ifdef CONFIG_PM
+#include <asm/mach-au1x00/au1xxx_pm.h>
+#endif
+
+#ifndef CONFIG_FB_AU1200_DEVS
+#define CONFIG_FB_AU1200_DEVS 4
+#endif
+
+#define DRIVER_NAME "au1200fb"
+#define DRIVER_DESC "LCD controller driver for AU1200 processors"
+
+#define DEBUG 1
+
+#define print_err(f, arg...) printk(KERN_ERR DRIVER_NAME ": " f "\n", ## arg)
+#define print_warn(f, arg...) printk(KERN_WARNING DRIVER_NAME ": " f "\n", ## arg)
+#define print_info(f, arg...) printk(KERN_INFO DRIVER_NAME ": " f "\n", ## arg)
+
+#if DEBUG
+#define print_dbg(f, arg...) printk(KERN_DEBUG __FILE__ ": " f "\n", ## arg)
+#else
+#define print_dbg(f, arg...) do {} while (0)
+#endif
+
+
+#define AU1200_LCD_FB_IOCTL 0x46FF
+
+#define AU1200_LCD_SET_SCREEN 1
+#define AU1200_LCD_GET_SCREEN 2
+#define AU1200_LCD_SET_WINDOW 3
+#define AU1200_LCD_GET_WINDOW 4
+#define AU1200_LCD_SET_PANEL  5
+#define AU1200_LCD_GET_PANEL  6
+
+#define SCREEN_SIZE                 (1<< 1)
+#define SCREEN_BACKCOLOR    (1<< 2)
+#define SCREEN_BRIGHTNESS   (1<< 3)
+#define SCREEN_COLORKEY     (1<< 4)
+#define SCREEN_MASK         (1<< 5)
+
+struct au1200_lcd_global_regs_t {
+        unsigned int flags;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int backcolor;
+        unsigned int brightness;
+        unsigned int colorkey;
+        unsigned int mask;
+        unsigned int panel_choice;
+        char panel_desc[80];
+
+};
+
+#define WIN_POSITION            (1<< 0)
+#define WIN_ALPHA_COLOR         (1<< 1)
+#define WIN_ALPHA_MODE          (1<< 2)
+#define WIN_PRIORITY            (1<< 3)
+#define WIN_CHANNEL             (1<< 4)
+#define WIN_BUFFER_FORMAT       (1<< 5)
+#define WIN_COLOR_ORDER         (1<< 6)
+#define WIN_PIXEL_ORDER         (1<< 7)
+#define WIN_SIZE                (1<< 8)
+#define WIN_COLORKEY_MODE       (1<< 9)
+#define WIN_DOUBLE_BUFFER_MODE  (1<< 10)
+#define WIN_RAM_ARRAY_MODE      (1<< 11)
+#define WIN_BUFFER_SCALE        (1<< 12)
+#define WIN_ENABLE                  (1<< 13)
+
+struct au1200_lcd_window_regs_t {
+        unsigned int flags;
+        unsigned int xpos;
+        unsigned int ypos;
+        unsigned int alpha_color;
+        unsigned int alpha_mode;
+        unsigned int priority;
+        unsigned int channel;
+        unsigned int buffer_format;
+        unsigned int color_order;
+        unsigned int pixel_order;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int colorkey_mode;
+        unsigned int double_buffer_mode;
+        unsigned int ram_array_mode;
+        unsigned int xscale;
+        unsigned int yscale;
+        unsigned int enable;
+};
+
+
+struct au1200_lcd_iodata_t {
+        unsigned int subcmd;
+        struct au1200_lcd_global_regs_t global;
+        struct au1200_lcd_window_regs_t window;
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_11
+#else
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_00
+#endif
+#define LCD_CONTROL_DEFAULT_SBPPF LCD_CONTROL_SBPPF_565
+
+/* Private, per-framebuffer management information (independent of the panel itself) */
+struct au1200fb_device {
+        struct fb_info fb_info;                 /* FB driver info record */
+
+        int                                     plane;
+        unsigned char*          fb_mem;         /* FrameBuffer memory map */
+        unsigned int            fb_len;
+        dma_addr_t              fb_phys;
+};
+
+static struct au1200fb_device _au1200fb_devices[CONFIG_FB_AU1200_DEVS];
+/********************************************************************/
+
+/* LCD controller restrictions */
+#define AU1200_LCD_MAX_XRES     1280
+#define AU1200_LCD_MAX_YRES     1024
+#define AU1200_LCD_MAX_BPP      32
+#define AU1200_LCD_MAX_CLK      96000000 /* fixme: this needs to go away ? */
+#define AU1200_LCD_NBR_PALETTE_ENTRIES 256
+
+/* Default number of visible screen buffer to allocate */
+#define AU1200FB_NBR_VIDEO_BUFFERS 1
+
+/********************************************************************/
+
+static struct au1200_lcd *lcd = (struct au1200_lcd *) AU1200_LCD_ADDR;
+static int window_index = 2; /* default is zero */
+static int panel_index = 2; /* default is zero */
+static struct window_settings *win;
+static struct panel_settings *panel;
+static int noblanking = 1;
+static int nohwcursor = 0;
+
+struct window_settings {
+        unsigned char name[64];
+        uint32 mode_backcolor;
+        uint32 mode_colorkey;
+        uint32 mode_colorkeymsk;
+        struct {
+                int xres;
+                int yres;
+                int xpos;
+                int ypos;
+                uint32 mode_winctrl1; /* winctrl1[FRM,CCO,PO,PIPE] */
+                uint32 mode_winenable;
+        } w[4];
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_00
+#else
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_01
+#endif
+
+extern int board_au1200fb_panel_init (void);
+extern int board_au1200fb_panel_shutdown (void);
+
+#ifdef CONFIG_PM
+int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data);
+au1xxx_power_dev_t *LCD_pm_dev;
+#endif
+
+/*
+ * Default window configurations
+ */
+static struct window_settings windows[] = {
+        { /* Index 0 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 100, 100,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN1,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+
+        { /* Index 1 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 320, 240, 5, 5,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_24BPP |
+                                LCD_WINCTRL1_PO_00,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565
+                                | LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 200, 25, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        { /* Index 2 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_32BPP |
+                                LCD_WINCTRL1_PO_00|LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        /* Need VGA 640 @ 24bpp, @ 32bpp */
+        /* Need VGA 800 @ 24bpp, @ 32bpp */
+        /* Need VGA 1024 @ 24bpp, @ 32bpp */
+};
+
+/*
+ * Controller configurations for various panels.
+ */
+
+struct panel_settings
+{
+        const char name[25];            /* Full name <vendor>_<model> */
+
+        struct  fb_monspecs monspecs;   /* FB monitor specs */
+
+        /* panel timings */
+        uint32 mode_screen;
+        uint32 mode_horztiming;
+        uint32 mode_verttiming;
+        uint32 mode_clkcontrol;
+        uint32 mode_pwmdiv;
+        uint32 mode_pwmhi;
+        uint32 mode_outmask;
+        uint32 mode_fifoctrl;
+        uint32 mode_toyclksrc;
+        uint32 mode_backlight;
+        uint32 mode_auxpll;
+        int (*device_init)(void);
+        int (*device_shutdown)(void);
+#define Xres min_xres
+#define Yres min_yres
+        u32     min_xres;               /* Minimum horizontal resolution */
+        u32     max_xres;               /* Maximum horizontal resolution */
+        u32     min_yres;               /* Minimum vertical resolution */
+        u32     max_yres;               /* Maximum vertical resolution */
+};
+
+/********************************************************************/
+/* fixme: Maybe a modedb for the CRT ? otherwise panels should be as-is */
+
+/* List of panels known to work with the AU1200 LCD controller.
+ * To add a new panel, enter the same specifications as the
+ * Generic_TFT one, and MAKE SURE that it doesn't conflicts
+ * with the controller restrictions. Restrictions are:
+ *
+ * STN color panels: max_bpp <= 12
+ * STN mono panels: max_bpp <= 4
+ * TFT panels: max_bpp <= 16
+ * max_xres <= 800
+ * max_yres <= 600
+ */
+static struct panel_settings known_lcd_panels[] =
+{
+        [0] = { /* QVGA 320x240 H:33.3kHz V:110Hz */
+                .name = "QVGA_320x240",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = 0x00c4623b,
+                .mode_verttiming        = 0x00502814,
+                .mode_clkcontrol        = 0x00020002, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                320, 320,
+                240, 240,
+        },
+
+        [1] = { /* VGA 640x480 H:30.3kHz V:58Hz */
+                .name = "VGA_640x480",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x13f9df80,
+                .mode_horztiming        = 0x003c5859,
+                .mode_verttiming        = 0x00741201,
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                640, 480,
+                640, 480,
+        },
+
+        [2] = { /* SVGA 800x600 H:46.1kHz V:69Hz */
+                .name = "SVGA_800x600",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x18fa5780,
+                .mode_horztiming        = 0x00dc7e77,
+                .mode_verttiming        = 0x00584805,
+                .mode_clkcontrol        = 0x00020000, /* /2=48Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                800, 800,
+                600, 600,
+        },
+
+        [3] = { /* XVGA 1024x768 H:56.2kHz V:70Hz */
+                .name = "XVGA_1024x768",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x007d0e57,
+                .mode_verttiming        = 0x00740a01,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 6, /* 72MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1024, 1024,
+                768, 768,
+        },
+
+        [4] = { /* XVGA XVGA 1280x1024 H:68.5kHz V:65Hz */
+                .name = "XVGA_1280x1024",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x27fbff80,
+                .mode_horztiming        = 0x00cdb2c7,
+                .mode_verttiming        = 0x00600002,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 10, /* 120MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1280, 1280,
+                1024, 1024,
+        },
+
+        [5] = { /* Samsung 1024x768 TFT */
+                .name = "Samsung_1024x768_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x018cc677,
+                .mode_verttiming        = 0x00241217,
+                .mode_clkcontrol        = 0x00000000, /* SCB 0x1 /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f, /* SCB 0x0 */
+                .mode_pwmhi             = 0x03400000, /* SCB 0x0 */
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                1024, 1024,
+                768, 768,
+        },
+
+        [6] = { /* Toshiba 640x480 TFT */
+                .name = "Toshiba_640x480_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(640) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(96) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(51),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(11) | LCD_VERTTIMING_VND2_N(32),
+                .mode_clkcontrol        = 0x00000000, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                640, 480,
+                640, 480,
+        },
+
+        [7] = { /* Sharp 320x240 TFT */
+                .name = "Sharp_320x240_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 12500,
+                        .hfmax = 20000,
+                        .vfmin = 38,
+                        .vfmax = 81,
+                        .dclkmin = 4500000,
+                        .dclkmax = 6800000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(60) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(2),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(2) | LCD_VERTTIMING_VND2_N(5),
+                .mode_clkcontrol        = LCD_CLKCONTROL_PCD_N(7), /*16=6Mhz*/
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                320, 320,
+                240, 240,
+        },
+
+        [8] = { /* Toppoly TD070WGCB2 7" 856x480 TFT */
+                .name = "Toppoly_TD070WGCB2",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(856) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HND2_N(43) |
+                        LCD_HORZTIMING_HND1_N(43) | LCD_HORZTIMING_HPW_N(114),
+                .mode_verttiming        = LCD_VERTTIMING_VND2_N(20) |
+                        LCD_VERTTIMING_VND1_N(21) | LCD_VERTTIMING_VPW_N(4),
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                856, 856,
+                480, 480,
+        },
+};
+
+#define NUM_PANELS (ARRAY_SIZE(known_lcd_panels))
+
+/********************************************************************/
+
+#ifdef CONFIG_PM
+static int set_brightness(unsigned int brightness)
+{
+        unsigned int hi1, divider;
+
+        /* limit brightness pwm duty to >= 30/1600 */
+        if (brightness < 30) {
+                brightness = 30;
+        }
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        hi1 = (((brightness & 0xFF) + 1) * divider >> 8);
+        lcd->pwmhi &= 0xFFFF;
+        lcd->pwmhi |= (hi1 << 16);
+
+        return brightness;
+}
+#endif /* CONFIG_PM */
+
+static int winbpp (unsigned int winctrl1)
+{
+        int bits = 0;
+
+        /* how many bits are needed for each pixel format */
+        switch (winctrl1 & LCD_WINCTRL1_FRM) {
+        case LCD_WINCTRL1_FRM_1BPP:
+                bits = 1;
+                break;
+        case LCD_WINCTRL1_FRM_2BPP:
+                bits = 2;
+                break;
+        case LCD_WINCTRL1_FRM_4BPP:
+                bits = 4;
+                break;
+        case LCD_WINCTRL1_FRM_8BPP:
+                bits = 8;
+                break;
+        case LCD_WINCTRL1_FRM_12BPP:
+        case LCD_WINCTRL1_FRM_16BPP655:
+        case LCD_WINCTRL1_FRM_16BPP565:
+        case LCD_WINCTRL1_FRM_16BPP556:
+        case LCD_WINCTRL1_FRM_16BPPI1555:
+        case LCD_WINCTRL1_FRM_16BPPI5551:
+        case LCD_WINCTRL1_FRM_16BPPA1555:
+        case LCD_WINCTRL1_FRM_16BPPA5551:
+                bits = 16;
+                break;
+        case LCD_WINCTRL1_FRM_24BPP:
+        case LCD_WINCTRL1_FRM_32BPP:
+                bits = 32;
+                break;
+        }
+
+        return bits;
+}
+
+static int fbinfo2index (struct fb_info *fb_info)
+{
+        int i;
+
+        for (i = 0; i < CONFIG_FB_AU1200_DEVS; ++i) {
+                if (fb_info == (struct fb_info *)(&_au1200fb_devices[i].fb_info))
+                        return i;
+        }
+        printk("au1200fb: ERROR: fbinfo2index failed!\n");
+        return -1;
+}
+
+static int au1200_setlocation (struct au1200fb_device *fbdev, int plane,
+        int xpos, int ypos)
+{
+        uint32 winctrl0, winctrl1, winenable, fb_offset = 0;
+        int xsz, ysz;
+
+        /* FIX!!! NOT CHECKING FOR COMPLETE OFFSCREEN YET */
+
+        winctrl0 = lcd->window[plane].winctrl0;
+        winctrl1 = lcd->window[plane].winctrl1;
+        winctrl0 &= (LCD_WINCTRL0_A | LCD_WINCTRL0_AEN);
+        winctrl1 &= ~(LCD_WINCTRL1_SZX | LCD_WINCTRL1_SZY);
+
+        /* Check for off-screen adjustments */
+        xsz = win->w[plane].xres;
+        ysz = win->w[plane].yres;
+        if ((xpos + win->w[plane].xres) > panel->Xres) {
+                /* Off-screen to the right */
+                xsz = panel->Xres - xpos; /* off by 1 ??? */
+                /*printk("off screen right\n");*/
+        }
+
+        if ((ypos + win->w[plane].yres) > panel->Yres) {
+                /* Off-screen to the bottom */
+                ysz = panel->Yres - ypos; /* off by 1 ??? */
+                /*printk("off screen bottom\n");*/
+        }
+
+        if (xpos < 0) {
+                /* Off-screen to the left */
+                xsz = win->w[plane].xres + xpos;
+                fb_offset += (((0 - xpos) * winbpp(lcd->window[plane].winctrl1))/8);
+                xpos = 0;
+                /*printk("off screen left\n");*/
+        }
+
+        if (ypos < 0) {
+                /* Off-screen to the top */
+                ysz = win->w[plane].yres + ypos;
+                /* fixme: fb_offset += ((0-ypos)*fb_pars[plane].line_length); */
+                ypos = 0;
+                /*printk("off screen top\n");*/
+        }
+
+        /* record settings */
+        win->w[plane].xpos = xpos;
+        win->w[plane].ypos = ypos;
+
+        xsz -= 1;
+        ysz -= 1;
+        winctrl0 |= (xpos << 21);
+        winctrl0 |= (ypos << 10);
+        winctrl1 |= (xsz << 11);
+        winctrl1 |= (ysz << 0);
+
+        /* Disable the window while making changes, then restore WINEN */
+        winenable = lcd->winenable & (1 << plane);
+        au_sync();
+        lcd->winenable &= ~(1 << plane);
+        lcd->window[plane].winctrl0 = winctrl0;
+        lcd->window[plane].winctrl1 = winctrl1;
+        lcd->window[plane].winbuf0 =
+        lcd->window[plane].winbuf1 = fbdev->fb_phys;
+        lcd->window[plane].winbufctrl = 0; /* select winbuf0 */
+        lcd->winenable |= winenable;
+        au_sync();
+
+        return 0;
+}
+
+static void au1200_setpanel (struct panel_settings *newpanel)
+{
+        /*
+         * Perform global setup/init of LCD controller
+         */
+        uint32 winenable;
+
+        /* Make sure all windows disabled */
+        winenable = lcd->winenable;
+        lcd->winenable = 0;
+        au_sync();
+        /*
+         * Ensure everything is disabled before reconfiguring
+         */
+        if (lcd->screen & LCD_SCREEN_SEN) {
+                /* Wait for vertical sync period */
+                lcd->intstatus = LCD_INT_SS;
+                while ((lcd->intstatus & LCD_INT_SS) == 0) {
+                        au_sync();
+                }
+
+                lcd->screen &= ~LCD_SCREEN_SEN; /*disable the controller*/
+
+                do {
+                        lcd->intstatus = lcd->intstatus; /*clear interrupts*/
+                        au_sync();
+                /*wait for controller to shut down*/
+                } while ((lcd->intstatus & LCD_INT_SD) == 0);
+
+                /* Call shutdown of current panel (if up) */
+                /* this must occur last, because if an external clock is driving
+                    the controller, the clock cannot be turned off before first
+                        shutting down the controller.
+                 */
+                if (panel->device_shutdown != NULL)
+                        panel->device_shutdown();
+        }
+
+        /* Newpanel == NULL indicates a shutdown operation only */
+        if (newpanel == NULL)
+                return;
+
+        panel = newpanel;
+
+        printk("Panel(%s), %dx%d\n", panel->name, panel->Xres, panel->Yres);
+
+        /*
+         * Setup clocking if internal LCD clock source (assumes sys_auxpll valid)
+         */
+        if (!(panel->mode_clkcontrol & LCD_CLKCONTROL_EXT))
+        {
+                uint32 sys_clksrc;
+                au_writel(panel->mode_auxpll, SYS_AUXPLL);
+                sys_clksrc = au_readl(SYS_CLKSRC) & ~0x0000001f;
+                sys_clksrc |= panel->mode_toyclksrc;
+                au_writel(sys_clksrc, SYS_CLKSRC);
+        }
+
+        /*
+         * Configure panel timings
+         */
+        lcd->screen = panel->mode_screen;
+        lcd->horztiming = panel->mode_horztiming;
+        lcd->verttiming = panel->mode_verttiming;
+        lcd->clkcontrol = panel->mode_clkcontrol;
+        lcd->pwmdiv = panel->mode_pwmdiv;
+        lcd->pwmhi = panel->mode_pwmhi;
+        lcd->outmask = panel->mode_outmask;
+        lcd->fifoctrl = panel->mode_fifoctrl;
+        au_sync();
+
+        /* fixme: Check window settings to make sure still valid
+         * for new geometry */
+#if 0
+        au1200_setlocation(fbdev, 0, win->w[0].xpos, win->w[0].ypos);
+        au1200_setlocation(fbdev, 1, win->w[1].xpos, win->w[1].ypos);
+        au1200_setlocation(fbdev, 2, win->w[2].xpos, win->w[2].ypos);
+        au1200_setlocation(fbdev, 3, win->w[3].xpos, win->w[3].ypos);
+#endif
+        lcd->winenable = winenable;
+
+        /*
+         * Re-enable screen now that it is configured
+         */
+        lcd->screen |= LCD_SCREEN_SEN;
+        au_sync();
+
+        /* Call init of panel */
+        if (panel->device_init != NULL) panel->device_init();
+
+        /* FIX!!!! not appropriate on panel change!!! Global setup/init */
+        lcd->intenable = 0;
+        lcd->intstatus = ~0;
+        lcd->backcolor = win->mode_backcolor;
+
+        /* Setup Color Key - FIX!!! */
+        lcd->colorkey = win->mode_colorkey;
+        lcd->colorkeymsk = win->mode_colorkeymsk;
+
+        /* Setup HWCursor - FIX!!! Need to support this eventually */
+        lcd->hwc.cursorctrl = 0;
+        lcd->hwc.cursorpos = 0;
+        lcd->hwc.cursorcolor0 = 0;
+        lcd->hwc.cursorcolor1 = 0;
+        lcd->hwc.cursorcolor2 = 0;
+        lcd->hwc.cursorcolor3 = 0;
+
+
+#if 0
+#define D(X) printk("%25s: %08X\n", #X, X)
+        D(lcd->screen);
+        D(lcd->horztiming);
+        D(lcd->verttiming);
+        D(lcd->clkcontrol);
+        D(lcd->pwmdiv);
+        D(lcd->pwmhi);
+        D(lcd->outmask);
+        D(lcd->fifoctrl);
+        D(lcd->window[0].winctrl0);
+        D(lcd->window[0].winctrl1);
+        D(lcd->window[0].winctrl2);
+        D(lcd->window[0].winbuf0);
+        D(lcd->window[0].winbuf1);
+        D(lcd->window[0].winbufctrl);
+        D(lcd->window[1].winctrl0);
+        D(lcd->window[1].winctrl1);
+        D(lcd->window[1].winctrl2);
+        D(lcd->window[1].winbuf0);
+        D(lcd->window[1].winbuf1);
+        D(lcd->window[1].winbufctrl);
+        D(lcd->window[2].winctrl0);
+        D(lcd->window[2].winctrl1);
+        D(lcd->window[2].winctrl2);
+        D(lcd->window[2].winbuf0);
+        D(lcd->window[2].winbuf1);
+        D(lcd->window[2].winbufctrl);
+        D(lcd->window[3].winctrl0);
+        D(lcd->window[3].winctrl1);
+        D(lcd->window[3].winctrl2);
+        D(lcd->window[3].winbuf0);
+        D(lcd->window[3].winbuf1);
+        D(lcd->window[3].winbufctrl);
+        D(lcd->winenable);
+        D(lcd->intenable);
+        D(lcd->intstatus);
+        D(lcd->backcolor);
+        D(lcd->winenable);
+        D(lcd->colorkey);
+    D(lcd->colorkeymsk);
+        D(lcd->hwc.cursorctrl);
+        D(lcd->hwc.cursorpos);
+        D(lcd->hwc.cursorcolor0);
+        D(lcd->hwc.cursorcolor1);
+        D(lcd->hwc.cursorcolor2);
+        D(lcd->hwc.cursorcolor3);
+#endif
+}
+
+static void au1200_setmode(struct au1200fb_device *fbdev)
+{
+        int plane = fbdev->plane;
+        /* Window/plane setup */
+        lcd->window[plane].winctrl1 = ( 0
+                | LCD_WINCTRL1_PRI_N(plane)
+                | win->w[plane].mode_winctrl1 /* FRM,CCO,PO,PIPE */
+                ) ;
+
+        au1200_setlocation(fbdev, plane, win->w[plane].xpos, win->w[plane].ypos);
+
+        lcd->window[plane].winctrl2 = ( 0
+                | LCD_WINCTRL2_CKMODE_00
+                | LCD_WINCTRL2_DBM
+                | LCD_WINCTRL2_BX_N( fbdev->fb_info.fix.line_length)
+                | LCD_WINCTRL2_SCX_1
+                | LCD_WINCTRL2_SCY_1
+                ) ;
+        lcd->winenable |= win->w[plane].mode_winenable;
+        au_sync();
+}
+
+
+/* Inline helpers */
+
+/*#define panel_is_dual(panel)  ((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+/*#define panel_is_active(panel)((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+
+#define panel_is_color(panel) ((panel->mode_screen & LCD_SCREEN_PT) <= LCD_SCREEN_PT_CDSTN)
+
+/* Bitfields format supported by the controller. */
+static struct fb_bitfield rgb_bitfields[][4] = {
+        /*     Red,        Green,        Blue,       Transp   */
+        [LCD_WINCTRL1_FRM_16BPP655 >> 25] =
+                { { 10, 6, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP565 >> 25] =
+                { { 11, 5, 0 }, { 5, 6, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP556 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 0, 6, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 15, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_24BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_32BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 0, 0 } },
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Helpers */
+
+static void au1200fb_update_fbinfo(struct fb_info *fbi)
+{
+        /* FIX!!!! This also needs to take the window pixel format into account!!! */
+
+        /* Update var-dependent FB info */
+        if (panel_is_color(panel)) {
+                if (fbi->var.bits_per_pixel <= 8) {
+                        /* palettized */
+                        fbi->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual /
+                                (8/fbi->var.bits_per_pixel);
+                } else {
+                        /* non-palettized */
+                        fbi->fix.visual = FB_VISUAL_TRUECOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual * (fbi->var.bits_per_pixel / 8);
+                }
+        } else {
+                /* mono FIX!!! mono 8 and 4 bits */
+                fbi->fix.visual = FB_VISUAL_MONO10;
+                fbi->fix.line_length = fbi->var.xres_virtual / 8;
+        }
+
+        fbi->screen_size = fbi->fix.line_length * fbi->var.yres_virtual;
+        print_dbg("line length: %d\n", fbi->fix.line_length);
+        print_dbg("bits_per_pixel: %d\n", fbi->var.bits_per_pixel);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 framebuffer driver */
+
+/* fb_check_var
+ * Validate var settings with hardware restrictions and modify it if necessary
+ */
+static int au1200fb_fb_check_var(struct fb_var_screeninfo *var,
+        struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+        u32 pixclock;
+        int screen_size, plane;
+
+        plane = fbdev->plane;
+
+        /* Make sure that the mode respect all LCD controller and
+         * panel restrictions. */
+        var->xres = win->w[plane].xres;
+        var->yres = win->w[plane].yres;
+
+        /* No need for virtual resolution support */
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        var->bits_per_pixel = winbpp(win->w[plane].mode_winctrl1);
+
+        screen_size = var->xres_virtual * var->yres_virtual;
+        if (var->bits_per_pixel > 8) screen_size *= (var->bits_per_pixel / 8);
+        else screen_size /= (8/var->bits_per_pixel);
+
+        if (fbdev->fb_len < screen_size)
+                return -EINVAL; /* Virtual screen is to big, abort */
+
+        /* FIX!!!! what are the implicaitons of ignoring this for windows ??? */
+        /* The max LCD clock is fixed to 48MHz (value of AUX_CLK). The pixel
+         * clock can only be obtain by dividing this value by an even integer.
+         * Fallback to a slower pixel clock if necessary. */
+        pixclock = max((u32)(PICOS2KHZ(var->pixclock) * 1000), fbi->monspecs.dclkmin);
+        pixclock = min(pixclock, min(fbi->monspecs.dclkmax, (u32)AU1200_LCD_MAX_CLK/2));
+
+        if (AU1200_LCD_MAX_CLK % pixclock) {
+                int diff = AU1200_LCD_MAX_CLK % pixclock;
+                pixclock -= diff;
+        }
+
+        var->pixclock = KHZ2PICOS(pixclock/1000);
+#if 0
+        if (!panel_is_active(panel)) {
+                int pcd = AU1200_LCD_MAX_CLK / (pixclock * 2) - 1;
+
+                if (!panel_is_color(panel)
+                        && (panel->control_base & LCD_CONTROL_MPI) && (pcd < 3)) {
+                        /* STN 8bit mono panel support is up to 6MHz pixclock */
+                        var->pixclock = KHZ2PICOS(6000);
+                } else if (!pcd) {
+                        /* Other STN panel support is up to 12MHz  */
+                        var->pixclock = KHZ2PICOS(12000);
+                }
+        }
+#endif
+        /* Set bitfield accordingly */
+        switch (var->bits_per_pixel) {
+                case 16:
+                {
+                        /* 16bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+
+                case 32:
+                {
+                        /* 32bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+                default:
+                        print_dbg("Unsupported depth %dbpp", var->bits_per_pixel);
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* fb_set_par
+ * Set hardware with var settings. This will enable the controller with a
+ * specific mode, normally validated with the fb_check_var method
+ */
+static int au1200fb_fb_set_par(struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+
+        au1200fb_update_fbinfo(fbi);
+        au1200_setmode(fbdev);
+
+        return 0;
+}
+
+/* fb_setcolreg
+ * Set color in LCD palette.
+ */
+static int au1200fb_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
+        unsigned blue, unsigned transp, struct fb_info *fbi)
+{
+        volatile u32 *palette = lcd->palette;
+        u32 value;
+
+        if (regno > (AU1200_LCD_NBR_PALETTE_ENTRIES - 1))
+                return -EINVAL;
+
+        if (fbi->var.grayscale) {
+                /* Convert color to grayscale */
+                red = green = blue =
+                        (19595 * red + 38470 * green + 7471 * blue) >> 16;
+        }
+
+        if (fbi->fix.visual == FB_VISUAL_TRUECOLOR) {
+                /* Place color in the pseudopalette */
+                if (regno > 16)
+                        return -EINVAL;
+
+                palette = (u32*) fbi->pseudo_palette;
+
+                red   >>= (16 - fbi->var.red.length);
+                green >>= (16 - fbi->var.green.length);
+                blue  >>= (16 - fbi->var.blue.length);
+
+                value = (red   << fbi->var.red.offset)  |
+                        (green << fbi->var.green.offset)|
+                        (blue  << fbi->var.blue.offset);
+                value &= 0xFFFF;
+
+        } else if (1 /*FIX!!! panel_is_active(fbdev->panel)*/) {
+                /* COLOR TFT PALLETTIZED (use RGB 565) */
+                value = (red & 0xF800)|((green >> 5) &
+                                0x07E0)|((blue >> 11) & 0x001F);
+                value &= 0xFFFF;
+
+        } else if (0 /*panel_is_color(fbdev->panel)*/) {
+                /* COLOR STN MODE */
+                value = 0x1234;
+                value &= 0xFFF;
+        } else {
+                /* MONOCHROME MODE */
+                value = (green >> 12) & 0x000F;
+                value &= 0xF;
+        }
+
+        palette[regno] = value;
+
+        return 0;
+}
+
+/* fb_blank
+ * Blank the screen. Depending on the mode, the screen will be
+ * activated with the backlight color, or desactivated
+ */
+static int au1200fb_fb_blank(int blank_mode, struct fb_info *fbi)
+{
+        /* Short-circuit screen blanking */
+        if (noblanking)
+                return 0;
+
+        switch (blank_mode) {
+
+        case FB_BLANK_UNBLANK:
+        case FB_BLANK_NORMAL:
+                /* printk("turn on panel\n"); */
+                au1200_setpanel(panel);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_POWERDOWN:
+                /* printk("turn off panel\n"); */
+                au1200_setpanel(NULL);
+                break;
+        default:
+                break;
+
+        }
+
+        /* FB_BLANK_NORMAL is a soft blank */
+        return (blank_mode == FB_BLANK_NORMAL) ? -EINVAL : 0;
+}
+
+/* fb_mmap
+ * Map video memory in user space. We don't use the generic fb_mmap
+ * method mainly to allow the use of the TLB streaming flag (CCA=6)
+ */
+static int au1200fb_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+
+{
+        unsigned int len;
+        unsigned long start=0, off;
+        struct au1200fb_device *fbdev = (struct au1200fb_device *) info;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
+                return -EINVAL;
+        }
+
+        start = fbdev->fb_phys & PAGE_MASK;
+        len = PAGE_ALIGN((start & ~PAGE_MASK) + fbdev->fb_len);
+
+        off = vma->vm_pgoff << PAGE_SHIFT;
+
+        if ((vma->vm_end - vma->vm_start + off) > len) {
+                return -EINVAL;
+        }
+
+        off += start;
+        vma->vm_pgoff = off >> PAGE_SHIFT;
+
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        pgprot_val(vma->vm_page_prot) |= _CACHE_MASK; /* CCA=7 */
+
+        vma->vm_flags |= VM_IO;
+
+        return io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
+                                  vma->vm_end - vma->vm_start,
+                                  vma->vm_page_prot);
+
+        return 0;
+}
+
+static void set_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+
+        unsigned int hi1, divider;
+
+        /* SCREEN_SIZE: user cannot reset size, must switch panel choice */
+
+        if (pdata->flags & SCREEN_BACKCOLOR)
+                lcd->backcolor = pdata->backcolor;
+
+        if (pdata->flags & SCREEN_BRIGHTNESS) {
+
+                // limit brightness pwm duty to >= 30/1600
+                if (pdata->brightness < 30) {
+                        pdata->brightness = 30;
+                }
+                divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+                hi1 = (lcd->pwmhi >> 16) + 1;
+                hi1 = (((pdata->brightness & 0xFF)+1) * divider >> 8);
+                lcd->pwmhi &= 0xFFFF;
+                lcd->pwmhi |= (hi1 << 16);
+        }
+
+        if (pdata->flags & SCREEN_COLORKEY)
+                lcd->colorkey = pdata->colorkey;
+
+        if (pdata->flags & SCREEN_MASK)
+                lcd->colorkeymsk = pdata->mask;
+        au_sync();
+}
+
+static void get_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+        unsigned int hi1, divider;
+
+        pdata->xsize = ((lcd->screen & LCD_SCREEN_SX) >> 19) + 1;
+        pdata->ysize = ((lcd->screen & LCD_SCREEN_SY) >> 8) + 1;
+
+        pdata->backcolor = lcd->backcolor;
+        pdata->colorkey = lcd->colorkey;
+        pdata->mask = lcd->colorkeymsk;
+
+        // brightness
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        pdata->brightness = ((hi1 << 8) / divider) - 1;
+        au_sync();
+}
+
+static void set_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        unsigned int val, bpp;
+
+        /* Window control register 0 */
+        if (pdata->flags & WIN_POSITION) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_OX |
+                                LCD_WINCTRL0_OY);
+                val |= ((pdata->xpos << 21) & LCD_WINCTRL0_OX);
+                val |= ((pdata->ypos << 10) & LCD_WINCTRL0_OY);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_COLOR) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_A);
+                val |= ((pdata->alpha_color << 2) & LCD_WINCTRL0_A);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_MODE) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_AEN);
+                val |= ((pdata->alpha_mode << 1) & LCD_WINCTRL0_AEN);
+                lcd->window[plane].winctrl0 = val;
+        }
+
+        /* Window control register 1 */
+        if (pdata->flags & WIN_PRIORITY) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PRI);
+                val |= ((pdata->priority << 30) & LCD_WINCTRL1_PRI);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_CHANNEL) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PIPE);
+                val |= ((pdata->channel << 29) & LCD_WINCTRL1_PIPE);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_BUFFER_FORMAT) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_FRM);
+                val |= ((pdata->buffer_format << 25) & LCD_WINCTRL1_FRM);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_COLOR_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_CCO);
+                val |= ((pdata->color_order << 24) & LCD_WINCTRL1_CCO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_PIXEL_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PO);
+                val |= ((pdata->pixel_order << 22) & LCD_WINCTRL1_PO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_SIZE) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_SZX |
+                                LCD_WINCTRL1_SZY);
+                val |= (((pdata->xsize << 11) - 1) & LCD_WINCTRL1_SZX);
+                val |= (((pdata->ysize) - 1) & LCD_WINCTRL1_SZY);
+                lcd->window[plane].winctrl1 = val;
+                /* program buffer line width */
+                bpp = winbpp(val) / 8;
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_BX);
+                val |= (((pdata->xsize * bpp) << 8) & LCD_WINCTRL2_BX);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Window control register 2 */
+        if (pdata->flags & WIN_COLORKEY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_CKMODE);
+                val |= ((pdata->colorkey_mode << 24) & LCD_WINCTRL2_CKMODE);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_DOUBLE_BUFFER_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_DBM);
+                val |= ((pdata->double_buffer_mode << 23) & LCD_WINCTRL2_DBM);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_RAM_ARRAY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_RAM);
+                val |= ((pdata->ram_array_mode << 21) & LCD_WINCTRL2_RAM);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Buffer line width programmed with WIN_SIZE */
+
+        if (pdata->flags & WIN_BUFFER_SCALE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_SCX |
+                                LCD_WINCTRL2_SCY);
+                val |= ((pdata->xsize << 11) & LCD_WINCTRL2_SCX);
+                val |= ((pdata->ysize) & LCD_WINCTRL2_SCY);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        if (pdata->flags & WIN_ENABLE) {
+                val = lcd->winenable;
+                val &= ~(1<<plane);
+                val |= (pdata->enable & 1) << plane;
+                lcd->winenable = val;
+        }
+        au_sync();
+}
+
+static void get_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        /* Window control register 0 */
+        pdata->xpos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OX) >> 21;
+        pdata->ypos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OY) >> 10;
+        pdata->alpha_color = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_A) >> 2;
+        pdata->alpha_mode = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_AEN) >> 1;
+
+        /* Window control register 1 */
+        pdata->priority = (lcd->window[plane].winctrl1& LCD_WINCTRL1_PRI) >> 30;
+        pdata->channel = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PIPE) >> 29;
+        pdata->buffer_format = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+        pdata->color_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_CCO) >> 24;
+        pdata->pixel_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PO) >> 22;
+        pdata->xsize = ((lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZX) >> 11) + 1;
+        pdata->ysize = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZY) + 1;
+
+        /* Window control register 2 */
+        pdata->colorkey_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_CKMODE) >> 24;
+        pdata->double_buffer_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_DBM) >> 23;
+        pdata->ram_array_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_RAM) >> 21;
+
+        pdata->enable = (lcd->winenable >> plane) & 1;
+        au_sync();
+}
+
+static int au1200fb_ioctl(struct fb_info *info, unsigned int cmd,
+                          unsigned long arg)
+{
+        int plane;
+        int val;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        plane = fbinfo2index(info);
+        print_dbg("au1200fb: ioctl %d on plane %d\n", cmd, plane);
+
+        if (cmd == AU1200_LCD_FB_IOCTL) {
+                struct au1200_lcd_iodata_t iodata;
+
+                if (copy_from_user(&iodata, (void __user *) arg, sizeof(iodata)))
+                        return -EFAULT;
+
+                print_dbg("FB IOCTL called\n");
+
+                switch (iodata.subcmd) {
+                case AU1200_LCD_SET_SCREEN:
+                        print_dbg("AU1200_LCD_SET_SCREEN\n");
+                        set_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_GET_SCREEN:
+                        print_dbg("AU1200_LCD_GET_SCREEN\n");
+                        get_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_SET_WINDOW:
+                        print_dbg("AU1200_LCD_SET_WINDOW\n");
+                        set_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_GET_WINDOW:
+                        print_dbg("AU1200_LCD_GET_WINDOW\n");
+                        get_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_SET_PANEL:
+                        print_dbg("AU1200_LCD_SET_PANEL\n");
+                        if ((iodata.global.panel_choice >= 0) &&
+                                        (iodata.global.panel_choice <
+                                         NUM_PANELS))
+                        {
+                                struct panel_settings *newpanel;
+                                panel_index = iodata.global.panel_choice;
+                                newpanel = &known_lcd_panels[panel_index];
+                                au1200_setpanel(newpanel);
+                        }
+                        break;
+
+                case AU1200_LCD_GET_PANEL:
+                        print_dbg("AU1200_LCD_GET_PANEL\n");
+                        iodata.global.panel_choice = panel_index;
+                        break;
+
+                default:
+                        return -EINVAL;
+                }
+
+                val = copy_to_user((void __user *) arg, &iodata, sizeof(iodata));
+                if (val) {
+                        print_dbg("error: could not copy %d bytes\n", val);
+                        return -EFAULT;
+                }
+        }
+
+        return 0;
+}
+
+
+static struct fb_ops au1200fb_fb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_check_var   = au1200fb_fb_check_var,
+        .fb_set_par     = au1200fb_fb_set_par,
+        .fb_setcolreg   = au1200fb_fb_setcolreg,
+        .fb_blank       = au1200fb_fb_blank,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+        .fb_sync        = NULL,
+        .fb_ioctl       = au1200fb_ioctl,
+        .fb_mmap        = au1200fb_fb_mmap,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static irqreturn_t au1200fb_handle_irq(int irq, void* dev_id, struct pt_regs *regs)
+{
+        /* Nothing to do for now, just clear any pending interrupt */
+        lcd->intstatus = lcd->intstatus;
+        au_sync();
+
+        return IRQ_HANDLED;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD device probe helpers */
+
+static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
+{
+        struct fb_info *fbi = &fbdev->fb_info;
+        int bpp;
+
+        memset(fbi, 0, sizeof(struct fb_info));
+        fbi->fbops = &au1200fb_fb_ops;
+
+        bpp = winbpp(win->w[fbdev->plane].mode_winctrl1);
+
+        /* Copy monitor specs from panel data */
+        /* fixme: we're setting up LCD controller windows, so these dont give a
+        damn as to what the monitor specs are (the panel itself does, but that
+        isnt done here...so maybe need a generic catchall monitor setting??? */
+        memcpy(&fbi->monspecs, &panel->monspecs, sizeof(struct fb_monspecs));
+
+        /* We first try the user mode passed in argument. If that failed,
+         * or if no one has been specified, we default to the first mode of the
+         * panel list. Note that after this call, var data will be set */
+        if (!fb_find_mode(&fbi->var,
+                          fbi,
+                          NULL, /* drv_info.opt_mode, */
+                          fbi->monspecs.modedb,
+                          fbi->monspecs.modedb_len,
+                          fbi->monspecs.modedb,
+                          bpp)) {
+
+                print_err("Cannot find valid mode for panel %s", panel->name);
+                return -EFAULT;
+        }
+
+        fbi->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
+        if (!fbi->pseudo_palette) {
+                return -ENOMEM;
+        }
+        memset(fbi->pseudo_palette, 0, sizeof(u32) * 16);
+
+        if (fb_alloc_cmap(&fbi->cmap, AU1200_LCD_NBR_PALETTE_ENTRIES, 0) < 0) {
+                print_err("Fail to allocate colormap (%d entries)",
+                           AU1200_LCD_NBR_PALETTE_ENTRIES);
+                kfree(fbi->pseudo_palette);
+                return -EFAULT;
+        }
+
+        strncpy(fbi->fix.id, "AU1200", sizeof(fbi->fix.id));
+        fbi->fix.smem_start = fbdev->fb_phys;
+        fbi->fix.smem_len = fbdev->fb_len;
+        fbi->fix.type = FB_TYPE_PACKED_PIXELS;
+        fbi->fix.xpanstep = 0;
+        fbi->fix.ypanstep = 0;
+        fbi->fix.mmio_start = 0;
+        fbi->fix.mmio_len = 0;
+        fbi->fix.accel = FB_ACCEL_NONE;
+
+        fbi->screen_base = (char __iomem *) fbdev->fb_mem;
+
+        au1200fb_update_fbinfo(fbi);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD controller device driver */
+
+static int au1200fb_drv_probe(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        unsigned long page;
+        int bpp, plane, ret;
+
+        if (!dev)
+                return -EINVAL;
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane) {
+                bpp = winbpp(win->w[plane].mode_winctrl1);
+                if (win->w[plane].xres == 0)
+                        win->w[plane].xres = panel->Xres;
+                if (win->w[plane].yres == 0)
+                        win->w[plane].yres = panel->Yres;
+
+                fbdev = &_au1200fb_devices[plane];
+                memset(fbdev, 0, sizeof(struct au1200fb_device));
+                fbdev->plane = plane;
+
+                /* Allocate the framebuffer to the maximum screen size */
+                fbdev->fb_len = (win->w[plane].xres * win->w[plane].yres * bpp) / 8;
+
+                fbdev->fb_mem = dma_alloc_noncoherent(dev,
+                                PAGE_ALIGN(fbdev->fb_len),
+                                &fbdev->fb_phys, GFP_KERNEL);
+                if (!fbdev->fb_mem) {
+                        print_err("fail to allocate frambuffer (size: %dK))",
+                                  fbdev->fb_len / 1024);
+                        return -ENOMEM;
+                }
+
+                /*
+                 * Set page reserved so that mmap will work. This is necessary
+                 * since we'll be remapping normal memory.
+                 */
+                for (page = (unsigned long)fbdev->fb_phys;
+                     page < PAGE_ALIGN((unsigned long)fbdev->fb_phys +
+                             fbdev->fb_len);
+                     page += PAGE_SIZE) {
+                        SetPageReserved(pfn_to_page(page >> PAGE_SHIFT)); /* LCD DMA is NOT coherent on Au1200 */
+                }
+                print_dbg("Framebuffer memory map at %p", fbdev->fb_mem);
+                print_dbg("phys=0x%08x, size=%dK", fbdev->fb_phys, fbdev->fb_len / 1024);
+
+                /* Init FB data */
+                if ((ret = au1200fb_init_fbinfo(fbdev)) < 0)
+                        goto failed;
+
+                /* Register new framebuffer */
+                if ((ret = register_framebuffer(&fbdev->fb_info)) < 0) {
+                        print_err("cannot register new framebuffer");
+                        goto failed;
+                }
+
+                au1200fb_fb_set_par(&fbdev->fb_info);
+
+#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
+                if (plane == 0)
+                        if (fb_prepare_logo(&fbdev->fb_info, FB_ROTATE_UR)) {
+                                /* Start display and show logo on boot */
+                                fb_set_cmap(&fbdev->fb_info.cmap,
+                                                &fbdev->fb_info);
+
+                                fb_show_logo(&fbdev->fb_info, FB_ROTATE_UR);
+                        }
+#endif
+        }
+
+        /* Now hook interrupt too */
+        if ((ret = request_irq(AU1200_LCD_INT, au1200fb_handle_irq,
+                          SA_INTERRUPT | SA_SHIRQ, "lcd", (void *)dev)) < 0) {
+                print_err("fail to request interrupt line %d (err: %d)",
+                          AU1200_LCD_INT, ret);
+                goto failed;
+        }
+
+        return 0;
+
+failed:
+        /* NOTE: This only does the current plane/window that failed; others are still active */
+        if (fbdev->fb_mem)
+                dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                fbdev->fb_mem, fbdev->fb_phys);
+        if (fbdev->fb_info.cmap.len != 0)
+                fb_dealloc_cmap(&fbdev->fb_info.cmap);
+        if (fbdev->fb_info.pseudo_palette)
+                kfree(fbdev->fb_info.pseudo_palette);
+        if (plane == 0)
+                free_irq(AU1200_LCD_INT, (void*)dev);
+        return ret;
+}
+
+static int au1200fb_drv_remove(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        int plane;
+
+        if (!dev)
+                return -ENODEV;
+
+        /* Turn off the panel */
+        au1200_setpanel(NULL);
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)
+        {
+                fbdev = &_au1200fb_devices[plane];
+
+                /* Clean up all probe data */
+                unregister_framebuffer(&fbdev->fb_info);
+                if (fbdev->fb_mem)
+                        dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                        fbdev->fb_mem, fbdev->fb_phys);
+                if (fbdev->fb_info.cmap.len != 0)
+                        fb_dealloc_cmap(&fbdev->fb_info.cmap);
+                if (fbdev->fb_info.pseudo_palette)
+                        kfree(fbdev->fb_info.pseudo_palette);
+        }
+
+        free_irq(AU1200_LCD_INT, (void *)dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_drv_suspend(struct device *dev, u32 state, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+
+static int au1200fb_drv_resume(struct device *dev, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+static struct device_driver au1200fb_driver = {
+        .name           = "au1200-lcd",
+        .bus            = &platform_bus_type,
+        .probe          = au1200fb_drv_probe,
+        .remove         = au1200fb_drv_remove,
+#ifdef CONFIG_PM
+        .suspend        = au1200fb_drv_suspend,
+        .resume         = au1200fb_drv_resume,
+#endif
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Kernel driver */
+
+static void au1200fb_setup(void)
+{
+        char* options = NULL;
+        char* this_opt;
+        int num_panels = ARRAY_SIZE(known_lcd_panels);
+        int panel_idx = -1;
+
+        fb_get_options(DRIVER_NAME, &options);
+
+        if (options) {
+                while ((this_opt = strsep(&options,",")) != NULL) {
+                        /* Panel option - can be panel name,
+                         * "bs" for board-switch, or number/index */
+                        if (!strncmp(this_opt, "panel:", 6)) {
+                                int i;
+                                long int li;
+                                char *endptr;
+                                this_opt += 6;
+                                /* First check for index, which allows
+                                 * to short circuit this mess */
+                                li = simple_strtol(this_opt, &endptr, 0);
+                                if (*endptr == '\0') {
+                                        panel_idx = (int)li;
+                                }
+                                else if (strcmp(this_opt, "bs") == 0) {
+                                        extern int board_au1200fb_panel(void);
+                                        panel_idx = board_au1200fb_panel();
+                                }
+
+                                else
+                                for (i = 0; i < num_panels; i++) {
+                                        if (!strcmp(this_opt, known_lcd_panels[i].name)) {
+                                                panel_idx = i;
+                                                break;
+                                        }
+                                }
+
+                                if ((panel_idx < 0) || (panel_idx >= num_panels)) {
+                                                print_warn("Panel %s not supported!", this_opt);
+                                }
+                                else
+                                        panel_index = panel_idx;
+                        }
+
+                        else if (strncmp(this_opt, "nohwcursor", 10) == 0) {
+                                nohwcursor = 1;
+                        }
+
+                        /* Unsupported option */
+                        else {
+                                print_warn("Unsupported option \"%s\"", this_opt);
+                        }
+                }
+        }
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data) {
+        int retval = -1;
+        unsigned int d = 0;
+        unsigned int brightness = 0;
+
+        if (request == AU1XXX_PM_SLEEP) {
+                board_au1200fb_panel_shutdown();
+        }
+        else if (request == AU1XXX_PM_WAKEUP) {
+                if(dev->prev_state == SLEEP_STATE)
+                {
+                        int plane;
+                        au1200_setpanel(panel);
+                        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)         {
+                                struct au1200fb_device *fbdev;
+                                fbdev = &_au1200fb_devices[plane];
+                                au1200fb_fb_set_par(&fbdev->fb_info);
+                        }
+                }
+
+                d = *((unsigned int*)data);
+                if(d <=10) brightness = 26;
+                else if(d<=20) brightness = 51;
+                else if(d<=30) brightness = 77;
+                else if(d<=40) brightness = 102;
+                else if(d<=50) brightness = 128;
+                else if(d<=60) brightness = 153;
+                else if(d<=70) brightness = 179;
+                else if(d<=80) brightness = 204;
+                else if(d<=90) brightness = 230;
+                else brightness = 255;
+                set_brightness(brightness);
+        } else if (request == AU1XXX_PM_GETSTATUS) {
+                return dev->cur_state;
+        } else if (request == AU1XXX_PM_ACCESS) {
+                if (dev->cur_state != SLEEP_STATE)
+                        return retval;
+                else {
+                        au1200_setpanel(panel);
+                }
+        } else if (request == AU1XXX_PM_IDLE) {
+        } else if (request == AU1XXX_PM_CLEANUP) {
+        }
+
+        return retval;
+}
+#endif
+
+static int __init au1200fb_init(void)
+{
+        print_info("" DRIVER_DESC "");
+
+        /* Setup driver with options */
+        au1200fb_setup();
+
+        /* Point to the panel selected */
+        panel = &known_lcd_panels[panel_index];
+        win = &windows[window_index];
+
+        printk(DRIVER_NAME ": Panel %d %s\n", panel_index, panel->name);
+        printk(DRIVER_NAME ": Win %d %s\n", window_index, win->name);
+
+        /* Kickstart the panel, the framebuffers/windows come soon enough */
+        au1200_setpanel(panel);
+
+        #ifdef CONFIG_PM
+        LCD_pm_dev = new_au1xxx_power_device("LCD", &au1200fb_pm_callback, NULL);
+        if ( LCD_pm_dev == NULL)
+                printk(KERN_INFO "Unable to create a power management device entry for the au1200fb.\n");
+        else
+                printk(KERN_INFO "Power management device entry for the au1200fb loaded.\n");
+        #endif
+
+        return driver_register(&au1200fb_driver);
+}
+
+static void __exit au1200fb_cleanup(void)
+{
+        driver_unregister(&au1200fb_driver);
+}
+
+module_init(au1200fb_init);
+module_exit(au1200fb_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Au1200 LCD Driver.
+ *
+ * Copyright 2004-2005 AMD
+ * Author: AMD
+ *
+ * Based on:
+ * linux/drivers/video/skeletonfb.c -- Skeleton for a frame buffer device
+ *  Created 28 Dec 1997 by Geert Uytterhoeven
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ctype.h>
+#include <linux/dma-mapping.h>
+
+#include <asm/mach-au1x00/au1000.h>
+#include "au1200fb.h"
+
+#ifdef CONFIG_PM
+#include <asm/mach-au1x00/au1xxx_pm.h>
+#endif
+
+#ifndef CONFIG_FB_AU1200_DEVS
+#define CONFIG_FB_AU1200_DEVS 4
+#endif
+
+#define DRIVER_NAME "au1200fb"
+#define DRIVER_DESC "LCD controller driver for AU1200 processors"
+
+#define DEBUG 1
+
+#define print_err(f, arg...) printk(KERN_ERR DRIVER_NAME ": " f "\n", ## arg)
+#define print_warn(f, arg...) printk(KERN_WARNING DRIVER_NAME ": " f "\n", ## arg)
+#define print_info(f, arg...) printk(KERN_INFO DRIVER_NAME ": " f "\n", ## arg)
+
+#if DEBUG
+#define print_dbg(f, arg...) printk(KERN_DEBUG __FILE__ ": " f "\n", ## arg)
+#else
+#define print_dbg(f, arg...) do {} while (0)
+#endif
+
+
+#define AU1200_LCD_FB_IOCTL 0x46FF
+
+#define AU1200_LCD_SET_SCREEN 1
+#define AU1200_LCD_GET_SCREEN 2
+#define AU1200_LCD_SET_WINDOW 3
+#define AU1200_LCD_GET_WINDOW 4
+#define AU1200_LCD_SET_PANEL  5
+#define AU1200_LCD_GET_PANEL  6
+
+#define SCREEN_SIZE                 (1<< 1)
+#define SCREEN_BACKCOLOR    (1<< 2)
+#define SCREEN_BRIGHTNESS   (1<< 3)
+#define SCREEN_COLORKEY     (1<< 4)
+#define SCREEN_MASK         (1<< 5)
+
+struct au1200_lcd_global_regs_t {
+        unsigned int flags;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int backcolor;
+        unsigned int brightness;
+        unsigned int colorkey;
+        unsigned int mask;
+        unsigned int panel_choice;
+        char panel_desc[80];
+
+};
+
+#define WIN_POSITION            (1<< 0)
+#define WIN_ALPHA_COLOR         (1<< 1)
+#define WIN_ALPHA_MODE          (1<< 2)
+#define WIN_PRIORITY            (1<< 3)
+#define WIN_CHANNEL             (1<< 4)
+#define WIN_BUFFER_FORMAT       (1<< 5)
+#define WIN_COLOR_ORDER         (1<< 6)
+#define WIN_PIXEL_ORDER         (1<< 7)
+#define WIN_SIZE                (1<< 8)
+#define WIN_COLORKEY_MODE       (1<< 9)
+#define WIN_DOUBLE_BUFFER_MODE  (1<< 10)
+#define WIN_RAM_ARRAY_MODE      (1<< 11)
+#define WIN_BUFFER_SCALE        (1<< 12)
+#define WIN_ENABLE                  (1<< 13)
+
+struct au1200_lcd_window_regs_t {
+        unsigned int flags;
+        unsigned int xpos;
+        unsigned int ypos;
+        unsigned int alpha_color;
+        unsigned int alpha_mode;
+        unsigned int priority;
+        unsigned int channel;
+        unsigned int buffer_format;
+        unsigned int color_order;
+        unsigned int pixel_order;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int colorkey_mode;
+        unsigned int double_buffer_mode;
+        unsigned int ram_array_mode;
+        unsigned int xscale;
+        unsigned int yscale;
+        unsigned int enable;
+};
+
+
+struct au1200_lcd_iodata_t {
+        unsigned int subcmd;
+        struct au1200_lcd_global_regs_t global;
+        struct au1200_lcd_window_regs_t window;
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_11
+#else
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_00
+#endif
+#define LCD_CONTROL_DEFAULT_SBPPF LCD_CONTROL_SBPPF_565
+
+/* Private, per-framebuffer management information (independent of the panel itself) */
+struct au1200fb_device {
+        struct fb_info fb_info;                 /* FB driver info record */
+
+        int                                     plane;
+        unsigned char*          fb_mem;         /* FrameBuffer memory map */
+        unsigned int            fb_len;
+        dma_addr_t              fb_phys;
+};
+
+static struct au1200fb_device _au1200fb_devices[CONFIG_FB_AU1200_DEVS];
+/********************************************************************/
+
+/* LCD controller restrictions */
+#define AU1200_LCD_MAX_XRES     1280
+#define AU1200_LCD_MAX_YRES     1024
+#define AU1200_LCD_MAX_BPP      32
+#define AU1200_LCD_MAX_CLK      96000000 /* fixme: this needs to go away ? */
+#define AU1200_LCD_NBR_PALETTE_ENTRIES 256
+
+/* Default number of visible screen buffer to allocate */
+#define AU1200FB_NBR_VIDEO_BUFFERS 1
+
+/********************************************************************/
+
+static struct au1200_lcd *lcd = (struct au1200_lcd *) AU1200_LCD_ADDR;
+static int window_index = 2; /* default is zero */
+static int panel_index = 2; /* default is zero */
+static struct window_settings *win;
+static struct panel_settings *panel;
+static int noblanking = 1;
+static int nohwcursor = 0;
+
+struct window_settings {
+        unsigned char name[64];
+        uint32 mode_backcolor;
+        uint32 mode_colorkey;
+        uint32 mode_colorkeymsk;
+        struct {
+                int xres;
+                int yres;
+                int xpos;
+                int ypos;
+                uint32 mode_winctrl1; /* winctrl1[FRM,CCO,PO,PIPE] */
+                uint32 mode_winenable;
+        } w[4];
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_00
+#else
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_01
+#endif
+
+extern int board_au1200fb_panel_init (void);
+extern int board_au1200fb_panel_shutdown (void);
+
+#ifdef CONFIG_PM
+int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data);
+au1xxx_power_dev_t *LCD_pm_dev;
+#endif
+
+/*
+ * Default window configurations
+ */
+static struct window_settings windows[] = {
+        { /* Index 0 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 100, 100,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN1,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+
+        { /* Index 1 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 320, 240, 5, 5,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_24BPP |
+                                LCD_WINCTRL1_PO_00,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565
+                                | LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 200, 25, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        { /* Index 2 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_32BPP |
+                                LCD_WINCTRL1_PO_00|LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        /* Need VGA 640 @ 24bpp, @ 32bpp */
+        /* Need VGA 800 @ 24bpp, @ 32bpp */
+        /* Need VGA 1024 @ 24bpp, @ 32bpp */
+};
+
+/*
+ * Controller configurations for various panels.
+ */
+
+struct panel_settings
+{
+        const char name[25];            /* Full name <vendor>_<model> */
+
+        struct  fb_monspecs monspecs;   /* FB monitor specs */
+
+        /* panel timings */
+        uint32 mode_screen;
+        uint32 mode_horztiming;
+        uint32 mode_verttiming;
+        uint32 mode_clkcontrol;
+        uint32 mode_pwmdiv;
+        uint32 mode_pwmhi;
+        uint32 mode_outmask;
+        uint32 mode_fifoctrl;
+        uint32 mode_toyclksrc;
+        uint32 mode_backlight;
+        uint32 mode_auxpll;
+        int (*device_init)(void);
+        int (*device_shutdown)(void);
+#define Xres min_xres
+#define Yres min_yres
+        u32     min_xres;               /* Minimum horizontal resolution */
+        u32     max_xres;               /* Maximum horizontal resolution */
+        u32     min_yres;               /* Minimum vertical resolution */
+        u32     max_yres;               /* Maximum vertical resolution */
+};
+
+/********************************************************************/
+/* fixme: Maybe a modedb for the CRT ? otherwise panels should be as-is */
+
+/* List of panels known to work with the AU1200 LCD controller.
+ * To add a new panel, enter the same specifications as the
+ * Generic_TFT one, and MAKE SURE that it doesn't conflicts
+ * with the controller restrictions. Restrictions are:
+ *
+ * STN color panels: max_bpp <= 12
+ * STN mono panels: max_bpp <= 4
+ * TFT panels: max_bpp <= 16
+ * max_xres <= 800
+ * max_yres <= 600
+ */
+static struct panel_settings known_lcd_panels[] =
+{
+        [0] = { /* QVGA 320x240 H:33.3kHz V:110Hz */
+                .name = "QVGA_320x240",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = 0x00c4623b,
+                .mode_verttiming        = 0x00502814,
+                .mode_clkcontrol        = 0x00020002, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                320, 320,
+                240, 240,
+        },
+
+        [1] = { /* VGA 640x480 H:30.3kHz V:58Hz */
+                .name = "VGA_640x480",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x13f9df80,
+                .mode_horztiming        = 0x003c5859,
+                .mode_verttiming        = 0x00741201,
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                640, 480,
+                640, 480,
+        },
+
+        [2] = { /* SVGA 800x600 H:46.1kHz V:69Hz */
+                .name = "SVGA_800x600",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x18fa5780,
+                .mode_horztiming        = 0x00dc7e77,
+                .mode_verttiming        = 0x00584805,
+                .mode_clkcontrol        = 0x00020000, /* /2=48Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                800, 800,
+                600, 600,
+        },
+
+        [3] = { /* XVGA 1024x768 H:56.2kHz V:70Hz */
+                .name = "XVGA_1024x768",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x007d0e57,
+                .mode_verttiming        = 0x00740a01,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 6, /* 72MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1024, 1024,
+                768, 768,
+        },
+
+        [4] = { /* XVGA XVGA 1280x1024 H:68.5kHz V:65Hz */
+                .name = "XVGA_1280x1024",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x27fbff80,
+                .mode_horztiming        = 0x00cdb2c7,
+                .mode_verttiming        = 0x00600002,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 10, /* 120MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1280, 1280,
+                1024, 1024,
+        },
+
+        [5] = { /* Samsung 1024x768 TFT */
+                .name = "Samsung_1024x768_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x018cc677,
+                .mode_verttiming        = 0x00241217,
+                .mode_clkcontrol        = 0x00000000, /* SCB 0x1 /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f, /* SCB 0x0 */
+                .mode_pwmhi             = 0x03400000, /* SCB 0x0 */
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                1024, 1024,
+                768, 768,
+        },
+
+        [6] = { /* Toshiba 640x480 TFT */
+                .name = "Toshiba_640x480_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(640) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(96) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(51),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(11) | LCD_VERTTIMING_VND2_N(32),
+                .mode_clkcontrol        = 0x00000000, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                640, 480,
+                640, 480,
+        },
+
+        [7] = { /* Sharp 320x240 TFT */
+                .name = "Sharp_320x240_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 12500,
+                        .hfmax = 20000,
+                        .vfmin = 38,
+                        .vfmax = 81,
+                        .dclkmin = 4500000,
+                        .dclkmax = 6800000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(60) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(2),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(2) | LCD_VERTTIMING_VND2_N(5),
+                .mode_clkcontrol        = LCD_CLKCONTROL_PCD_N(7), /*16=6Mhz*/
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                320, 320,
+                240, 240,
+        },
+
+        [8] = { /* Toppoly TD070WGCB2 7" 856x480 TFT */
+                .name = "Toppoly_TD070WGCB2",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(856) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HND2_N(43) |
+                        LCD_HORZTIMING_HND1_N(43) | LCD_HORZTIMING_HPW_N(114),
+                .mode_verttiming        = LCD_VERTTIMING_VND2_N(20) |
+                        LCD_VERTTIMING_VND1_N(21) | LCD_VERTTIMING_VPW_N(4),
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                856, 856,
+                480, 480,
+        },
+};
+
+#define NUM_PANELS (ARRAY_SIZE(known_lcd_panels))
+
+/********************************************************************/
+
+#ifdef CONFIG_PM
+static int set_brightness(unsigned int brightness)
+{
+        unsigned int hi1, divider;
+
+        /* limit brightness pwm duty to >= 30/1600 */
+        if (brightness < 30) {
+                brightness = 30;
+        }
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        hi1 = (((brightness & 0xFF) + 1) * divider >> 8);
+        lcd->pwmhi &= 0xFFFF;
+        lcd->pwmhi |= (hi1 << 16);
+
+        return brightness;
+}
+#endif /* CONFIG_PM */
+
+static int winbpp (unsigned int winctrl1)
+{
+        int bits = 0;
+
+        /* how many bits are needed for each pixel format */
+        switch (winctrl1 & LCD_WINCTRL1_FRM) {
+        case LCD_WINCTRL1_FRM_1BPP:
+                bits = 1;
+                break;
+        case LCD_WINCTRL1_FRM_2BPP:
+                bits = 2;
+                break;
+        case LCD_WINCTRL1_FRM_4BPP:
+                bits = 4;
+                break;
+        case LCD_WINCTRL1_FRM_8BPP:
+                bits = 8;
+                break;
+        case LCD_WINCTRL1_FRM_12BPP:
+        case LCD_WINCTRL1_FRM_16BPP655:
+        case LCD_WINCTRL1_FRM_16BPP565:
+        case LCD_WINCTRL1_FRM_16BPP556:
+        case LCD_WINCTRL1_FRM_16BPPI1555:
+        case LCD_WINCTRL1_FRM_16BPPI5551:
+        case LCD_WINCTRL1_FRM_16BPPA1555:
+        case LCD_WINCTRL1_FRM_16BPPA5551:
+                bits = 16;
+                break;
+        case LCD_WINCTRL1_FRM_24BPP:
+        case LCD_WINCTRL1_FRM_32BPP:
+                bits = 32;
+                break;
+        }
+
+        return bits;
+}
+
+static int fbinfo2index (struct fb_info *fb_info)
+{
+        int i;
+
+        for (i = 0; i < CONFIG_FB_AU1200_DEVS; ++i) {
+                if (fb_info == (struct fb_info *)(&_au1200fb_devices[i].fb_info))
+                        return i;
+        }
+        printk("au1200fb: ERROR: fbinfo2index failed!\n");
+        return -1;
+}
+
+static int au1200_setlocation (struct au1200fb_device *fbdev, int plane,
+        int xpos, int ypos)
+{
+        uint32 winctrl0, winctrl1, winenable, fb_offset = 0;
+        int xsz, ysz;
+
+        /* FIX!!! NOT CHECKING FOR COMPLETE OFFSCREEN YET */
+
+        winctrl0 = lcd->window[plane].winctrl0;
+        winctrl1 = lcd->window[plane].winctrl1;
+        winctrl0 &= (LCD_WINCTRL0_A | LCD_WINCTRL0_AEN);
+        winctrl1 &= ~(LCD_WINCTRL1_SZX | LCD_WINCTRL1_SZY);
+
+        /* Check for off-screen adjustments */
+        xsz = win->w[plane].xres;
+        ysz = win->w[plane].yres;
+        if ((xpos + win->w[plane].xres) > panel->Xres) {
+                /* Off-screen to the right */
+                xsz = panel->Xres - xpos; /* off by 1 ??? */
+                /*printk("off screen right\n");*/
+        }
+
+        if ((ypos + win->w[plane].yres) > panel->Yres) {
+                /* Off-screen to the bottom */
+                ysz = panel->Yres - ypos; /* off by 1 ??? */
+                /*printk("off screen bottom\n");*/
+        }
+
+        if (xpos < 0) {
+                /* Off-screen to the left */
+                xsz = win->w[plane].xres + xpos;
+                fb_offset += (((0 - xpos) * winbpp(lcd->window[plane].winctrl1))/8);
+                xpos = 0;
+                /*printk("off screen left\n");*/
+        }
+
+        if (ypos < 0) {
+                /* Off-screen to the top */
+                ysz = win->w[plane].yres + ypos;
+                /* fixme: fb_offset += ((0-ypos)*fb_pars[plane].line_length); */
+                ypos = 0;
+                /*printk("off screen top\n");*/
+        }
+
+        /* record settings */
+        win->w[plane].xpos = xpos;
+        win->w[plane].ypos = ypos;
+
+        xsz -= 1;
+        ysz -= 1;
+        winctrl0 |= (xpos << 21);
+        winctrl0 |= (ypos << 10);
+        winctrl1 |= (xsz << 11);
+        winctrl1 |= (ysz << 0);
+
+        /* Disable the window while making changes, then restore WINEN */
+        winenable = lcd->winenable & (1 << plane);
+        au_sync();
+        lcd->winenable &= ~(1 << plane);
+        lcd->window[plane].winctrl0 = winctrl0;
+        lcd->window[plane].winctrl1 = winctrl1;
+        lcd->window[plane].winbuf0 =
+        lcd->window[plane].winbuf1 = fbdev->fb_phys;
+        lcd->window[plane].winbufctrl = 0; /* select winbuf0 */
+        lcd->winenable |= winenable;
+        au_sync();
+
+        return 0;
+}
+
+static void au1200_setpanel (struct panel_settings *newpanel)
+{
+        /*
+         * Perform global setup/init of LCD controller
+         */
+        uint32 winenable;
+
+        /* Make sure all windows disabled */
+        winenable = lcd->winenable;
+        lcd->winenable = 0;
+        au_sync();
+        /*
+         * Ensure everything is disabled before reconfiguring
+         */
+        if (lcd->screen & LCD_SCREEN_SEN) {
+                /* Wait for vertical sync period */
+                lcd->intstatus = LCD_INT_SS;
+                while ((lcd->intstatus & LCD_INT_SS) == 0) {
+                        au_sync();
+                }
+
+                lcd->screen &= ~LCD_SCREEN_SEN; /*disable the controller*/
+
+                do {
+                        lcd->intstatus = lcd->intstatus; /*clear interrupts*/
+                        au_sync();
+                /*wait for controller to shut down*/
+                } while ((lcd->intstatus & LCD_INT_SD) == 0);
+
+                /* Call shutdown of current panel (if up) */
+                /* this must occur last, because if an external clock is driving
+                    the controller, the clock cannot be turned off before first
+                        shutting down the controller.
+                 */
+                if (panel->device_shutdown != NULL)
+                        panel->device_shutdown();
+        }
+
+        /* Newpanel == NULL indicates a shutdown operation only */
+        if (newpanel == NULL)
+                return;
+
+        panel = newpanel;
+
+        printk("Panel(%s), %dx%d\n", panel->name, panel->Xres, panel->Yres);
+
+        /*
+         * Setup clocking if internal LCD clock source (assumes sys_auxpll valid)
+         */
+        if (!(panel->mode_clkcontrol & LCD_CLKCONTROL_EXT))
+        {
+                uint32 sys_clksrc;
+                au_writel(panel->mode_auxpll, SYS_AUXPLL);
+                sys_clksrc = au_readl(SYS_CLKSRC) & ~0x0000001f;
+                sys_clksrc |= panel->mode_toyclksrc;
+                au_writel(sys_clksrc, SYS_CLKSRC);
+        }
+
+        /*
+         * Configure panel timings
+         */
+        lcd->screen = panel->mode_screen;
+        lcd->horztiming = panel->mode_horztiming;
+        lcd->verttiming = panel->mode_verttiming;
+        lcd->clkcontrol = panel->mode_clkcontrol;
+        lcd->pwmdiv = panel->mode_pwmdiv;
+        lcd->pwmhi = panel->mode_pwmhi;
+        lcd->outmask = panel->mode_outmask;
+        lcd->fifoctrl = panel->mode_fifoctrl;
+        au_sync();
+
+        /* fixme: Check window settings to make sure still valid
+         * for new geometry */
+#if 0
+        au1200_setlocation(fbdev, 0, win->w[0].xpos, win->w[0].ypos);
+        au1200_setlocation(fbdev, 1, win->w[1].xpos, win->w[1].ypos);
+        au1200_setlocation(fbdev, 2, win->w[2].xpos, win->w[2].ypos);
+        au1200_setlocation(fbdev, 3, win->w[3].xpos, win->w[3].ypos);
+#endif
+        lcd->winenable = winenable;
+
+        /*
+         * Re-enable screen now that it is configured
+         */
+        lcd->screen |= LCD_SCREEN_SEN;
+        au_sync();
+
+        /* Call init of panel */
+        if (panel->device_init != NULL) panel->device_init();
+
+        /* FIX!!!! not appropriate on panel change!!! Global setup/init */
+        lcd->intenable = 0;
+        lcd->intstatus = ~0;
+        lcd->backcolor = win->mode_backcolor;
+
+        /* Setup Color Key - FIX!!! */
+        lcd->colorkey = win->mode_colorkey;
+        lcd->colorkeymsk = win->mode_colorkeymsk;
+
+        /* Setup HWCursor - FIX!!! Need to support this eventually */
+        lcd->hwc.cursorctrl = 0;
+        lcd->hwc.cursorpos = 0;
+        lcd->hwc.cursorcolor0 = 0;
+        lcd->hwc.cursorcolor1 = 0;
+        lcd->hwc.cursorcolor2 = 0;
+        lcd->hwc.cursorcolor3 = 0;
+
+
+#if 0
+#define D(X) printk("%25s: %08X\n", #X, X)
+        D(lcd->screen);
+        D(lcd->horztiming);
+        D(lcd->verttiming);
+        D(lcd->clkcontrol);
+        D(lcd->pwmdiv);
+        D(lcd->pwmhi);
+        D(lcd->outmask);
+        D(lcd->fifoctrl);
+        D(lcd->window[0].winctrl0);
+        D(lcd->window[0].winctrl1);
+        D(lcd->window[0].winctrl2);
+        D(lcd->window[0].winbuf0);
+        D(lcd->window[0].winbuf1);
+        D(lcd->window[0].winbufctrl);
+        D(lcd->window[1].winctrl0);
+        D(lcd->window[1].winctrl1);
+        D(lcd->window[1].winctrl2);
+        D(lcd->window[1].winbuf0);
+        D(lcd->window[1].winbuf1);
+        D(lcd->window[1].winbufctrl);
+        D(lcd->window[2].winctrl0);
+        D(lcd->window[2].winctrl1);
+        D(lcd->window[2].winctrl2);
+        D(lcd->window[2].winbuf0);
+        D(lcd->window[2].winbuf1);
+        D(lcd->window[2].winbufctrl);
+        D(lcd->window[3].winctrl0);
+        D(lcd->window[3].winctrl1);
+        D(lcd->window[3].winctrl2);
+        D(lcd->window[3].winbuf0);
+        D(lcd->window[3].winbuf1);
+        D(lcd->window[3].winbufctrl);
+        D(lcd->winenable);
+        D(lcd->intenable);
+        D(lcd->intstatus);
+        D(lcd->backcolor);
+        D(lcd->winenable);
+        D(lcd->colorkey);
+    D(lcd->colorkeymsk);
+        D(lcd->hwc.cursorctrl);
+        D(lcd->hwc.cursorpos);
+        D(lcd->hwc.cursorcolor0);
+        D(lcd->hwc.cursorcolor1);
+        D(lcd->hwc.cursorcolor2);
+        D(lcd->hwc.cursorcolor3);
+#endif
+}
+
+static void au1200_setmode(struct au1200fb_device *fbdev)
+{
+        int plane = fbdev->plane;
+        /* Window/plane setup */
+        lcd->window[plane].winctrl1 = ( 0
+                | LCD_WINCTRL1_PRI_N(plane)
+                | win->w[plane].mode_winctrl1 /* FRM,CCO,PO,PIPE */
+                ) ;
+
+        au1200_setlocation(fbdev, plane, win->w[plane].xpos, win->w[plane].ypos);
+
+        lcd->window[plane].winctrl2 = ( 0
+                | LCD_WINCTRL2_CKMODE_00
+                | LCD_WINCTRL2_DBM
+                | LCD_WINCTRL2_BX_N( fbdev->fb_info.fix.line_length)
+                | LCD_WINCTRL2_SCX_1
+                | LCD_WINCTRL2_SCY_1
+                ) ;
+        lcd->winenable |= win->w[plane].mode_winenable;
+        au_sync();
+}
+
+
+/* Inline helpers */
+
+/*#define panel_is_dual(panel)  ((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+/*#define panel_is_active(panel)((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+
+#define panel_is_color(panel) ((panel->mode_screen & LCD_SCREEN_PT) <= LCD_SCREEN_PT_CDSTN)
+
+/* Bitfields format supported by the controller. */
+static struct fb_bitfield rgb_bitfields[][4] = {
+        /*     Red,        Green,        Blue,       Transp   */
+        [LCD_WINCTRL1_FRM_16BPP655 >> 25] =
+                { { 10, 6, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP565 >> 25] =
+                { { 11, 5, 0 }, { 5, 6, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP556 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 0, 6, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 15, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_24BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_32BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 0, 0 } },
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Helpers */
+
+static void au1200fb_update_fbinfo(struct fb_info *fbi)
+{
+        /* FIX!!!! This also needs to take the window pixel format into account!!! */
+
+        /* Update var-dependent FB info */
+        if (panel_is_color(panel)) {
+                if (fbi->var.bits_per_pixel <= 8) {
+                        /* palettized */
+                        fbi->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual /
+                                (8/fbi->var.bits_per_pixel);
+                } else {
+                        /* non-palettized */
+                        fbi->fix.visual = FB_VISUAL_TRUECOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual * (fbi->var.bits_per_pixel / 8);
+                }
+        } else {
+                /* mono FIX!!! mono 8 and 4 bits */
+                fbi->fix.visual = FB_VISUAL_MONO10;
+                fbi->fix.line_length = fbi->var.xres_virtual / 8;
+        }
+
+        fbi->screen_size = fbi->fix.line_length * fbi->var.yres_virtual;
+        print_dbg("line length: %d\n", fbi->fix.line_length);
+        print_dbg("bits_per_pixel: %d\n", fbi->var.bits_per_pixel);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 framebuffer driver */
+
+/* fb_check_var
+ * Validate var settings with hardware restrictions and modify it if necessary
+ */
+static int au1200fb_fb_check_var(struct fb_var_screeninfo *var,
+        struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+        u32 pixclock;
+        int screen_size, plane;
+
+        plane = fbdev->plane;
+
+        /* Make sure that the mode respect all LCD controller and
+         * panel restrictions. */
+        var->xres = win->w[plane].xres;
+        var->yres = win->w[plane].yres;
+
+        /* No need for virtual resolution support */
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        var->bits_per_pixel = winbpp(win->w[plane].mode_winctrl1);
+
+        screen_size = var->xres_virtual * var->yres_virtual;
+        if (var->bits_per_pixel > 8) screen_size *= (var->bits_per_pixel / 8);
+        else screen_size /= (8/var->bits_per_pixel);
+
+        if (fbdev->fb_len < screen_size)
+                return -EINVAL; /* Virtual screen is to big, abort */
+
+        /* FIX!!!! what are the implicaitons of ignoring this for windows ??? */
+        /* The max LCD clock is fixed to 48MHz (value of AUX_CLK). The pixel
+         * clock can only be obtain by dividing this value by an even integer.
+         * Fallback to a slower pixel clock if necessary. */
+        pixclock = max((u32)(PICOS2KHZ(var->pixclock) * 1000), fbi->monspecs.dclkmin);
+        pixclock = min(pixclock, min(fbi->monspecs.dclkmax, (u32)AU1200_LCD_MAX_CLK/2));
+
+        if (AU1200_LCD_MAX_CLK % pixclock) {
+                int diff = AU1200_LCD_MAX_CLK % pixclock;
+                pixclock -= diff;
+        }
+
+        var->pixclock = KHZ2PICOS(pixclock/1000);
+#if 0
+        if (!panel_is_active(panel)) {
+                int pcd = AU1200_LCD_MAX_CLK / (pixclock * 2) - 1;
+
+                if (!panel_is_color(panel)
+                        && (panel->control_base & LCD_CONTROL_MPI) && (pcd < 3)) {
+                        /* STN 8bit mono panel support is up to 6MHz pixclock */
+                        var->pixclock = KHZ2PICOS(6000);
+                } else if (!pcd) {
+                        /* Other STN panel support is up to 12MHz  */
+                        var->pixclock = KHZ2PICOS(12000);
+                }
+        }
+#endif
+        /* Set bitfield accordingly */
+        switch (var->bits_per_pixel) {
+                case 16:
+                {
+                        /* 16bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+
+                case 32:
+                {
+                        /* 32bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+                default:
+                        print_dbg("Unsupported depth %dbpp", var->bits_per_pixel);
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* fb_set_par
+ * Set hardware with var settings. This will enable the controller with a
+ * specific mode, normally validated with the fb_check_var method
+ */
+static int au1200fb_fb_set_par(struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+
+        au1200fb_update_fbinfo(fbi);
+        au1200_setmode(fbdev);
+
+        return 0;
+}
+
+/* fb_setcolreg
+ * Set color in LCD palette.
+ */
+static int au1200fb_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
+        unsigned blue, unsigned transp, struct fb_info *fbi)
+{
+        volatile u32 *palette = lcd->palette;
+        u32 value;
+
+        if (regno > (AU1200_LCD_NBR_PALETTE_ENTRIES - 1))
+                return -EINVAL;
+
+        if (fbi->var.grayscale) {
+                /* Convert color to grayscale */
+                red = green = blue =
+                        (19595 * red + 38470 * green + 7471 * blue) >> 16;
+        }
+
+        if (fbi->fix.visual == FB_VISUAL_TRUECOLOR) {
+                /* Place color in the pseudopalette */
+                if (regno > 16)
+                        return -EINVAL;
+
+                palette = (u32*) fbi->pseudo_palette;
+
+                red   >>= (16 - fbi->var.red.length);
+                green >>= (16 - fbi->var.green.length);
+                blue  >>= (16 - fbi->var.blue.length);
+
+                value = (red   << fbi->var.red.offset)  |
+                        (green << fbi->var.green.offset)|
+                        (blue  << fbi->var.blue.offset);
+                value &= 0xFFFF;
+
+        } else if (1 /*FIX!!! panel_is_active(fbdev->panel)*/) {
+                /* COLOR TFT PALLETTIZED (use RGB 565) */
+                value = (red & 0xF800)|((green >> 5) &
+                                0x07E0)|((blue >> 11) & 0x001F);
+                value &= 0xFFFF;
+
+        } else if (0 /*panel_is_color(fbdev->panel)*/) {
+                /* COLOR STN MODE */
+                value = 0x1234;
+                value &= 0xFFF;
+        } else {
+                /* MONOCHROME MODE */
+                value = (green >> 12) & 0x000F;
+                value &= 0xF;
+        }
+
+        palette[regno] = value;
+
+        return 0;
+}
+
+/* fb_blank
+ * Blank the screen. Depending on the mode, the screen will be
+ * activated with the backlight color, or desactivated
+ */
+static int au1200fb_fb_blank(int blank_mode, struct fb_info *fbi)
+{
+        /* Short-circuit screen blanking */
+        if (noblanking)
+                return 0;
+
+        switch (blank_mode) {
+
+        case FB_BLANK_UNBLANK:
+        case FB_BLANK_NORMAL:
+                /* printk("turn on panel\n"); */
+                au1200_setpanel(panel);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_POWERDOWN:
+                /* printk("turn off panel\n"); */
+                au1200_setpanel(NULL);
+                break;
+        default:
+                break;
+
+        }
+
+        /* FB_BLANK_NORMAL is a soft blank */
+        return (blank_mode == FB_BLANK_NORMAL) ? -EINVAL : 0;
+}
+
+/* fb_mmap
+ * Map video memory in user space. We don't use the generic fb_mmap
+ * method mainly to allow the use of the TLB streaming flag (CCA=6)
+ */
+static int au1200fb_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+
+{
+        unsigned int len;
+        unsigned long start=0, off;
+        struct au1200fb_device *fbdev = (struct au1200fb_device *) info;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
+                return -EINVAL;
+        }
+
+        start = fbdev->fb_phys & PAGE_MASK;
+        len = PAGE_ALIGN((start & ~PAGE_MASK) + fbdev->fb_len);
+
+        off = vma->vm_pgoff << PAGE_SHIFT;
+
+        if ((vma->vm_end - vma->vm_start + off) > len) {
+                return -EINVAL;
+        }
+
+        off += start;
+        vma->vm_pgoff = off >> PAGE_SHIFT;
+
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        pgprot_val(vma->vm_page_prot) |= _CACHE_MASK; /* CCA=7 */
+
+        vma->vm_flags |= VM_IO;
+
+        return io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
+                                  vma->vm_end - vma->vm_start,
+                                  vma->vm_page_prot);
+
+        return 0;
+}
+
+static void set_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+
+        unsigned int hi1, divider;
+
+        /* SCREEN_SIZE: user cannot reset size, must switch panel choice */
+
+        if (pdata->flags & SCREEN_BACKCOLOR)
+                lcd->backcolor = pdata->backcolor;
+
+        if (pdata->flags & SCREEN_BRIGHTNESS) {
+
+                // limit brightness pwm duty to >= 30/1600
+                if (pdata->brightness < 30) {
+                        pdata->brightness = 30;
+                }
+                divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+                hi1 = (lcd->pwmhi >> 16) + 1;
+                hi1 = (((pdata->brightness & 0xFF)+1) * divider >> 8);
+                lcd->pwmhi &= 0xFFFF;
+                lcd->pwmhi |= (hi1 << 16);
+        }
+
+        if (pdata->flags & SCREEN_COLORKEY)
+                lcd->colorkey = pdata->colorkey;
+
+        if (pdata->flags & SCREEN_MASK)
+                lcd->colorkeymsk = pdata->mask;
+        au_sync();
+}
+
+static void get_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+        unsigned int hi1, divider;
+
+        pdata->xsize = ((lcd->screen & LCD_SCREEN_SX) >> 19) + 1;
+        pdata->ysize = ((lcd->screen & LCD_SCREEN_SY) >> 8) + 1;
+
+        pdata->backcolor = lcd->backcolor;
+        pdata->colorkey = lcd->colorkey;
+        pdata->mask = lcd->colorkeymsk;
+
+        // brightness
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        pdata->brightness = ((hi1 << 8) / divider) - 1;
+        au_sync();
+}
+
+static void set_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        unsigned int val, bpp;
+
+        /* Window control register 0 */
+        if (pdata->flags & WIN_POSITION) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_OX |
+                                LCD_WINCTRL0_OY);
+                val |= ((pdata->xpos << 21) & LCD_WINCTRL0_OX);
+                val |= ((pdata->ypos << 10) & LCD_WINCTRL0_OY);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_COLOR) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_A);
+                val |= ((pdata->alpha_color << 2) & LCD_WINCTRL0_A);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_MODE) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_AEN);
+                val |= ((pdata->alpha_mode << 1) & LCD_WINCTRL0_AEN);
+                lcd->window[plane].winctrl0 = val;
+        }
+
+        /* Window control register 1 */
+        if (pdata->flags & WIN_PRIORITY) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PRI);
+                val |= ((pdata->priority << 30) & LCD_WINCTRL1_PRI);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_CHANNEL) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PIPE);
+                val |= ((pdata->channel << 29) & LCD_WINCTRL1_PIPE);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_BUFFER_FORMAT) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_FRM);
+                val |= ((pdata->buffer_format << 25) & LCD_WINCTRL1_FRM);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_COLOR_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_CCO);
+                val |= ((pdata->color_order << 24) & LCD_WINCTRL1_CCO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_PIXEL_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PO);
+                val |= ((pdata->pixel_order << 22) & LCD_WINCTRL1_PO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_SIZE) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_SZX |
+                                LCD_WINCTRL1_SZY);
+                val |= (((pdata->xsize << 11) - 1) & LCD_WINCTRL1_SZX);
+                val |= (((pdata->ysize) - 1) & LCD_WINCTRL1_SZY);
+                lcd->window[plane].winctrl1 = val;
+                /* program buffer line width */
+                bpp = winbpp(val) / 8;
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_BX);
+                val |= (((pdata->xsize * bpp) << 8) & LCD_WINCTRL2_BX);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Window control register 2 */
+        if (pdata->flags & WIN_COLORKEY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_CKMODE);
+                val |= ((pdata->colorkey_mode << 24) & LCD_WINCTRL2_CKMODE);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_DOUBLE_BUFFER_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_DBM);
+                val |= ((pdata->double_buffer_mode << 23) & LCD_WINCTRL2_DBM);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_RAM_ARRAY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_RAM);
+                val |= ((pdata->ram_array_mode << 21) & LCD_WINCTRL2_RAM);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Buffer line width programmed with WIN_SIZE */
+
+        if (pdata->flags & WIN_BUFFER_SCALE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_SCX |
+                                LCD_WINCTRL2_SCY);
+                val |= ((pdata->xsize << 11) & LCD_WINCTRL2_SCX);
+                val |= ((pdata->ysize) & LCD_WINCTRL2_SCY);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        if (pdata->flags & WIN_ENABLE) {
+                val = lcd->winenable;
+                val &= ~(1<<plane);
+                val |= (pdata->enable & 1) << plane;
+                lcd->winenable = val;
+        }
+        au_sync();
+}
+
+static void get_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        /* Window control register 0 */
+        pdata->xpos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OX) >> 21;
+        pdata->ypos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OY) >> 10;
+        pdata->alpha_color = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_A) >> 2;
+        pdata->alpha_mode = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_AEN) >> 1;
+
+        /* Window control register 1 */
+        pdata->priority = (lcd->window[plane].winctrl1& LCD_WINCTRL1_PRI) >> 30;
+        pdata->channel = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PIPE) >> 29;
+        pdata->buffer_format = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+        pdata->color_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_CCO) >> 24;
+        pdata->pixel_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PO) >> 22;
+        pdata->xsize = ((lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZX) >> 11) + 1;
+        pdata->ysize = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZY) + 1;
+
+        /* Window control register 2 */
+        pdata->colorkey_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_CKMODE) >> 24;
+        pdata->double_buffer_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_DBM) >> 23;
+        pdata->ram_array_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_RAM) >> 21;
+
+        pdata->enable = (lcd->winenable >> plane) & 1;
+        au_sync();
+}
+
+static int au1200fb_ioctl(struct fb_info *info, unsigned int cmd,
+                          unsigned long arg)
+{
+        int plane;
+        int val;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        plane = fbinfo2index(info);
+        print_dbg("au1200fb: ioctl %d on plane %d\n", cmd, plane);
+
+        if (cmd == AU1200_LCD_FB_IOCTL) {
+                struct au1200_lcd_iodata_t iodata;
+
+                if (copy_from_user(&iodata, (void __user *) arg, sizeof(iodata)))
+                        return -EFAULT;
+
+                print_dbg("FB IOCTL called\n");
+
+                switch (iodata.subcmd) {
+                case AU1200_LCD_SET_SCREEN:
+                        print_dbg("AU1200_LCD_SET_SCREEN\n");
+                        set_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_GET_SCREEN:
+                        print_dbg("AU1200_LCD_GET_SCREEN\n");
+                        get_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_SET_WINDOW:
+                        print_dbg("AU1200_LCD_SET_WINDOW\n");
+                        set_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_GET_WINDOW:
+                        print_dbg("AU1200_LCD_GET_WINDOW\n");
+                        get_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_SET_PANEL:
+                        print_dbg("AU1200_LCD_SET_PANEL\n");
+                        if ((iodata.global.panel_choice >= 0) &&
+                                        (iodata.global.panel_choice <
+                                         NUM_PANELS))
+                        {
+                                struct panel_settings *newpanel;
+                                panel_index = iodata.global.panel_choice;
+                                newpanel = &known_lcd_panels[panel_index];
+                                au1200_setpanel(newpanel);
+                        }
+                        break;
+
+                case AU1200_LCD_GET_PANEL:
+                        print_dbg("AU1200_LCD_GET_PANEL\n");
+                        iodata.global.panel_choice = panel_index;
+                        break;
+
+                default:
+                        return -EINVAL;
+                }
+
+                val = copy_to_user((void __user *) arg, &iodata, sizeof(iodata));
+                if (val) {
+                        print_dbg("error: could not copy %d bytes\n", val);
+                        return -EFAULT;
+                }
+        }
+
+        return 0;
+}
+
+
+static struct fb_ops au1200fb_fb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_check_var   = au1200fb_fb_check_var,
+        .fb_set_par     = au1200fb_fb_set_par,
+        .fb_setcolreg   = au1200fb_fb_setcolreg,
+        .fb_blank       = au1200fb_fb_blank,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+        .fb_sync        = NULL,
+        .fb_ioctl       = au1200fb_ioctl,
+        .fb_mmap        = au1200fb_fb_mmap,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static irqreturn_t au1200fb_handle_irq(int irq, void* dev_id, struct pt_regs *regs)
+{
+        /* Nothing to do for now, just clear any pending interrupt */
+        lcd->intstatus = lcd->intstatus;
+        au_sync();
+
+        return IRQ_HANDLED;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD device probe helpers */
+
+static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
+{
+        struct fb_info *fbi = &fbdev->fb_info;
+        int bpp;
+
+        memset(fbi, 0, sizeof(struct fb_info));
+        fbi->fbops = &au1200fb_fb_ops;
+
+        bpp = winbpp(win->w[fbdev->plane].mode_winctrl1);
+
+        /* Copy monitor specs from panel data */
+        /* fixme: we're setting up LCD controller windows, so these dont give a
+        damn as to what the monitor specs are (the panel itself does, but that
+        isnt done here...so maybe need a generic catchall monitor setting??? */
+        memcpy(&fbi->monspecs, &panel->monspecs, sizeof(struct fb_monspecs));
+
+        /* We first try the user mode passed in argument. If that failed,
+         * or if no one has been specified, we default to the first mode of the
+         * panel list. Note that after this call, var data will be set */
+        if (!fb_find_mode(&fbi->var,
+                          fbi,
+                          NULL, /* drv_info.opt_mode, */
+                          fbi->monspecs.modedb,
+                          fbi->monspecs.modedb_len,
+                          fbi->monspecs.modedb,
+                          bpp)) {
+
+                print_err("Cannot find valid mode for panel %s", panel->name);
+                return -EFAULT;
+        }
+
+        fbi->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
+        if (!fbi->pseudo_palette) {
+                return -ENOMEM;
+        }
+        memset(fbi->pseudo_palette, 0, sizeof(u32) * 16);
+
+        if (fb_alloc_cmap(&fbi->cmap, AU1200_LCD_NBR_PALETTE_ENTRIES, 0) < 0) {
+                print_err("Fail to allocate colormap (%d entries)",
+                           AU1200_LCD_NBR_PALETTE_ENTRIES);
+                kfree(fbi->pseudo_palette);
+                return -EFAULT;
+        }
+
+        strncpy(fbi->fix.id, "AU1200", sizeof(fbi->fix.id));
+        fbi->fix.smem_start = fbdev->fb_phys;
+        fbi->fix.smem_len = fbdev->fb_len;
+        fbi->fix.type = FB_TYPE_PACKED_PIXELS;
+        fbi->fix.xpanstep = 0;
+        fbi->fix.ypanstep = 0;
+        fbi->fix.mmio_start = 0;
+        fbi->fix.mmio_len = 0;
+        fbi->fix.accel = FB_ACCEL_NONE;
+
+        fbi->screen_base = (char __iomem *) fbdev->fb_mem;
+
+        au1200fb_update_fbinfo(fbi);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD controller device driver */
+
+static int au1200fb_drv_probe(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        unsigned long page;
+        int bpp, plane, ret;
+
+        if (!dev)
+                return -EINVAL;
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane) {
+                bpp = winbpp(win->w[plane].mode_winctrl1);
+                if (win->w[plane].xres == 0)
+                        win->w[plane].xres = panel->Xres;
+                if (win->w[plane].yres == 0)
+                        win->w[plane].yres = panel->Yres;
+
+                fbdev = &_au1200fb_devices[plane];
+                memset(fbdev, 0, sizeof(struct au1200fb_device));
+                fbdev->plane = plane;
+
+                /* Allocate the framebuffer to the maximum screen size */
+                fbdev->fb_len = (win->w[plane].xres * win->w[plane].yres * bpp) / 8;
+
+                fbdev->fb_mem = dma_alloc_noncoherent(dev,
+                                PAGE_ALIGN(fbdev->fb_len),
+                                &fbdev->fb_phys, GFP_KERNEL);
+                if (!fbdev->fb_mem) {
+                        print_err("fail to allocate frambuffer (size: %dK))",
+                                  fbdev->fb_len / 1024);
+                        return -ENOMEM;
+                }
+
+                /*
+                 * Set page reserved so that mmap will work. This is necessary
+                 * since we'll be remapping normal memory.
+                 */
+                for (page = (unsigned long)fbdev->fb_phys;
+                     page < PAGE_ALIGN((unsigned long)fbdev->fb_phys +
+                             fbdev->fb_len);
+                     page += PAGE_SIZE) {
+                        SetPageReserved(pfn_to_page(page >> PAGE_SHIFT)); /* LCD DMA is NOT coherent on Au1200 */
+                }
+                print_dbg("Framebuffer memory map at %p", fbdev->fb_mem);
+                print_dbg("phys=0x%08x, size=%dK", fbdev->fb_phys, fbdev->fb_len / 1024);
+
+                /* Init FB data */
+                if ((ret = au1200fb_init_fbinfo(fbdev)) < 0)
+                        goto failed;
+
+                /* Register new framebuffer */
+                if ((ret = register_framebuffer(&fbdev->fb_info)) < 0) {
+                        print_err("cannot register new framebuffer");
+                        goto failed;
+                }
+
+                au1200fb_fb_set_par(&fbdev->fb_info);
+
+#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
+                if (plane == 0)
+                        if (fb_prepare_logo(&fbdev->fb_info, FB_ROTATE_UR)) {
+                                /* Start display and show logo on boot */
+                                fb_set_cmap(&fbdev->fb_info.cmap,
+                                                &fbdev->fb_info);
+
+                                fb_show_logo(&fbdev->fb_info, FB_ROTATE_UR);
+                        }
+#endif
+        }
+
+        /* Now hook interrupt too */
+        if ((ret = request_irq(AU1200_LCD_INT, au1200fb_handle_irq,
+                          SA_INTERRUPT | SA_SHIRQ, "lcd", (void *)dev)) < 0) {
+                print_err("fail to request interrupt line %d (err: %d)",
+                          AU1200_LCD_INT, ret);
+                goto failed;
+        }
+
+        return 0;
+
+failed:
+        /* NOTE: This only does the current plane/window that failed; others are still active */
+        if (fbdev->fb_mem)
+                dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                fbdev->fb_mem, fbdev->fb_phys);
+        if (fbdev->fb_info.cmap.len != 0)
+                fb_dealloc_cmap(&fbdev->fb_info.cmap);
+        if (fbdev->fb_info.pseudo_palette)
+                kfree(fbdev->fb_info.pseudo_palette);
+        if (plane == 0)
+                free_irq(AU1200_LCD_INT, (void*)dev);
+        return ret;
+}
+
+static int au1200fb_drv_remove(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        int plane;
+
+        if (!dev)
+                return -ENODEV;
+
+        /* Turn off the panel */
+        au1200_setpanel(NULL);
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)
+        {
+                fbdev = &_au1200fb_devices[plane];
+
+                /* Clean up all probe data */
+                unregister_framebuffer(&fbdev->fb_info);
+                if (fbdev->fb_mem)
+                        dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                        fbdev->fb_mem, fbdev->fb_phys);
+                if (fbdev->fb_info.cmap.len != 0)
+                        fb_dealloc_cmap(&fbdev->fb_info.cmap);
+                if (fbdev->fb_info.pseudo_palette)
+                        kfree(fbdev->fb_info.pseudo_palette);
+        }
+
+        free_irq(AU1200_LCD_INT, (void *)dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_drv_suspend(struct device *dev, u32 state, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+
+static int au1200fb_drv_resume(struct device *dev, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+static struct device_driver au1200fb_driver = {
+        .name           = "au1200-lcd",
+        .bus            = &platform_bus_type,
+        .probe          = au1200fb_drv_probe,
+        .remove         = au1200fb_drv_remove,
+#ifdef CONFIG_PM
+        .suspend        = au1200fb_drv_suspend,
+        .resume         = au1200fb_drv_resume,
+#endif
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Kernel driver */
+
+static void au1200fb_setup(void)
+{
+        char* options = NULL;
+        char* this_opt;
+        int num_panels = ARRAY_SIZE(known_lcd_panels);
+        int panel_idx = -1;
+
+        fb_get_options(DRIVER_NAME, &options);
+
+        if (options) {
+                while ((this_opt = strsep(&options,",")) != NULL) {
+                        /* Panel option - can be panel name,
+                         * "bs" for board-switch, or number/index */
+                        if (!strncmp(this_opt, "panel:", 6)) {
+                                int i;
+                                long int li;
+                                char *endptr;
+                                this_opt += 6;
+                                /* First check for index, which allows
+                                 * to short circuit this mess */
+                                li = simple_strtol(this_opt, &endptr, 0);
+                                if (*endptr == '\0') {
+                                        panel_idx = (int)li;
+                                }
+                                else if (strcmp(this_opt, "bs") == 0) {
+                                        extern int board_au1200fb_panel(void);
+                                        panel_idx = board_au1200fb_panel();
+                                }
+
+                                else
+                                for (i = 0; i < num_panels; i++) {
+                                        if (!strcmp(this_opt, known_lcd_panels[i].name)) {
+                                                panel_idx = i;
+                                                break;
+                                        }
+                                }
+
+                                if ((panel_idx < 0) || (panel_idx >= num_panels)) {
+                                                print_warn("Panel %s not supported!", this_opt);
+                                }
+                                else
+                                        panel_index = panel_idx;
+                        }
+
+                        else if (strncmp(this_opt, "nohwcursor", 10) == 0) {
+                                nohwcursor = 1;
+                        }
+
+                        /* Unsupported option */
+                        else {
+                                print_warn("Unsupported option \"%s\"", this_opt);
+                        }
+                }
+        }
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data) {
+        int retval = -1;
+        unsigned int d = 0;
+        unsigned int brightness = 0;
+
+        if (request == AU1XXX_PM_SLEEP) {
+                board_au1200fb_panel_shutdown();
+        }
+        else if (request == AU1XXX_PM_WAKEUP) {
+                if(dev->prev_state == SLEEP_STATE)
+                {
+                        int plane;
+                        au1200_setpanel(panel);
+                        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)         {
+                                struct au1200fb_device *fbdev;
+                                fbdev = &_au1200fb_devices[plane];
+                                au1200fb_fb_set_par(&fbdev->fb_info);
+                        }
+                }
+
+                d = *((unsigned int*)data);
+                if(d <=10) brightness = 26;
+                else if(d<=20) brightness = 51;
+                else if(d<=30) brightness = 77;
+                else if(d<=40) brightness = 102;
+                else if(d<=50) brightness = 128;
+                else if(d<=60) brightness = 153;
+                else if(d<=70) brightness = 179;
+                else if(d<=80) brightness = 204;
+                else if(d<=90) brightness = 230;
+                else brightness = 255;
+                set_brightness(brightness);
+        } else if (request == AU1XXX_PM_GETSTATUS) {
+                return dev->cur_state;
+        } else if (request == AU1XXX_PM_ACCESS) {
+                if (dev->cur_state != SLEEP_STATE)
+                        return retval;
+                else {
+                        au1200_setpanel(panel);
+                }
+        } else if (request == AU1XXX_PM_IDLE) {
+        } else if (request == AU1XXX_PM_CLEANUP) {
+        }
+
+        return retval;
+}
+#endif
+
+static int __init au1200fb_init(void)
+{
+        print_info("" DRIVER_DESC "");
+
+        /* Setup driver with options */
+        au1200fb_setup();
+
+        /* Point to the panel selected */
+        panel = &known_lcd_panels[panel_index];
+        win = &windows[window_index];
+
+        printk(DRIVER_NAME ": Panel %d %s\n", panel_index, panel->name);
+        printk(DRIVER_NAME ": Win %d %s\n", window_index, win->name);
+
+        /* Kickstart the panel, the framebuffers/windows come soon enough */
+        au1200_setpanel(panel);
+
+        #ifdef CONFIG_PM
+        LCD_pm_dev = new_au1xxx_power_device("LCD", &au1200fb_pm_callback, NULL);
+        if ( LCD_pm_dev == NULL)
+                printk(KERN_INFO "Unable to create a power management device entry for the au1200fb.\n");
+        else
+                printk(KERN_INFO "Power management device entry for the au1200fb loaded.\n");
+        #endif
+
+        return driver_register(&au1200fb_driver);
+}
+
+static void __exit au1200fb_cleanup(void)
+{
+        driver_unregister(&au1200fb_driver);
+}
+
+module_init(au1200fb_init);
+module_exit(au1200fb_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/au1200fb.h b/drivers/video/au1200fb.h
new file mode 100644
index 000000000000..e2672714d8d4
--- /dev/null
+++ b/drivers/video/au1200fb.h
@@ -0,0 +1,572 @@
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Hardware definitions for the Au1200 LCD controller
+ *
+ * Copyright 2004 AMD
+ * Author:      AMD
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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 _AU1200LCD_H
+#define _AU1200LCD_H
+
+/********************************************************************/
+#define AU1200_LCD_ADDR         0xB5000000
+
+#define uint8 unsigned char
+#define uint32 unsigned int
+
+struct au1200_lcd {
+        volatile uint32 reserved0;
+        volatile uint32 screen;
+        volatile uint32 backcolor;
+        volatile uint32 horztiming;
+        volatile uint32 verttiming;
+        volatile uint32 clkcontrol;
+        volatile uint32 pwmdiv;
+        volatile uint32 pwmhi;
+        volatile uint32 reserved1;
+        volatile uint32 winenable;
+        volatile uint32 colorkey;
+        volatile uint32 colorkeymsk;
+        struct
+        {
+                volatile uint32 cursorctrl;
+                volatile uint32 cursorpos;
+                volatile uint32 cursorcolor0;
+                volatile uint32 cursorcolor1;
+                volatile uint32 cursorcolor2;
+                uint32  cursorcolor3;
+        } hwc;
+        volatile uint32 intstatus;
+        volatile uint32 intenable;
+        volatile uint32 outmask;
+        volatile uint32 fifoctrl;
+        uint32  reserved2[(0x0100-0x0058)/4];
+        struct
+        {
+                volatile uint32 winctrl0;
+                volatile uint32 winctrl1;
+                volatile uint32 winctrl2;
+                volatile uint32 winbuf0;
+                volatile uint32 winbuf1;
+                volatile uint32 winbufctrl;
+                uint32  winreserved0;
+                uint32  winreserved1;
+        } window[4];
+
+        uint32  reserved3[(0x0400-0x0180)/4];
+
+        volatile uint32 palette[(0x0800-0x0400)/4];
+
+        volatile uint8  cursorpattern[256];
+};
+
+/* lcd_screen */
+#define LCD_SCREEN_SEN          (1<<31)
+#define LCD_SCREEN_SX           (0x07FF<<19)
+#define LCD_SCREEN_SY           (0x07FF<< 8)
+#define LCD_SCREEN_SWP          (1<<7)
+#define LCD_SCREEN_SWD          (1<<6)
+#define LCD_SCREEN_PT           (7<<0)
+#define LCD_SCREEN_PT_TFT       (0<<0)
+#define LCD_SCREEN_SX_N(WIDTH)  ((WIDTH-1)<<19)
+#define LCD_SCREEN_SY_N(HEIGHT) ((HEIGHT-1)<<8)
+#define LCD_SCREEN_PT_CSTN      (1<<0)
+#define LCD_SCREEN_PT_CDSTN     (2<<0)
+#define LCD_SCREEN_PT_M8STN     (3<<0)
+#define LCD_SCREEN_PT_M4STN     (4<<0)
+
+/* lcd_backcolor */
+#define LCD_BACKCOLOR_SBGR              (0xFF<<16)
+#define LCD_BACKCOLOR_SBGG              (0xFF<<8)
+#define LCD_BACKCOLOR_SBGB              (0xFF<<0)
+#define LCD_BACKCOLOR_SBGR_N(N) ((N)<<16)
+#define LCD_BACKCOLOR_SBGG_N(N) ((N)<<8)
+#define LCD_BACKCOLOR_SBGB_N(N) ((N)<<0)
+
+/* lcd_winenable */
+#define LCD_WINENABLE_WEN3              (1<<3)
+#define LCD_WINENABLE_WEN2              (1<<2)
+#define LCD_WINENABLE_WEN1              (1<<1)
+#define LCD_WINENABLE_WEN0              (1<<0)
+
+/* lcd_colorkey */
+#define LCD_COLORKEY_CKR                (0xFF<<16)
+#define LCD_COLORKEY_CKG                (0xFF<<8)
+#define LCD_COLORKEY_CKB                (0xFF<<0)
+#define LCD_COLORKEY_CKR_N(N)   ((N)<<16)
+#define LCD_COLORKEY_CKG_N(N)   ((N)<<8)
+#define LCD_COLORKEY_CKB_N(N)   ((N)<<0)
+
+/* lcd_colorkeymsk */
+#define LCD_COLORKEYMSK_CKMR            (0xFF<<16)
+#define LCD_COLORKEYMSK_CKMG            (0xFF<<8)
+#define LCD_COLORKEYMSK_CKMB            (0xFF<<0)
+#define LCD_COLORKEYMSK_CKMR_N(N)       ((N)<<16)
+#define LCD_COLORKEYMSK_CKMG_N(N)       ((N)<<8)
+#define LCD_COLORKEYMSK_CKMB_N(N)       ((N)<<0)
+
+/* lcd windows control 0 */
+#define LCD_WINCTRL0_OX         (0x07FF<<21)
+#define LCD_WINCTRL0_OY         (0x07FF<<10)
+#define LCD_WINCTRL0_A          (0x00FF<<2)
+#define LCD_WINCTRL0_AEN        (1<<1)
+#define LCD_WINCTRL0_OX_N(N) ((N)<<21)
+#define LCD_WINCTRL0_OY_N(N) ((N)<<10)
+#define LCD_WINCTRL0_A_N(N) ((N)<<2)
+
+/* lcd windows control 1 */
+#define LCD_WINCTRL1_PRI        (3<<30)
+#define LCD_WINCTRL1_PIPE       (1<<29)
+#define LCD_WINCTRL1_FRM        (0xF<<25)
+#define LCD_WINCTRL1_CCO        (1<<24)
+#define LCD_WINCTRL1_PO         (3<<22)
+#define LCD_WINCTRL1_SZX        (0x07FF<<11)
+#define LCD_WINCTRL1_SZY        (0x07FF<<0)
+#define LCD_WINCTRL1_FRM_1BPP   (0<<25)
+#define LCD_WINCTRL1_FRM_2BPP   (1<<25)
+#define LCD_WINCTRL1_FRM_4BPP   (2<<25)
+#define LCD_WINCTRL1_FRM_8BPP   (3<<25)
+#define LCD_WINCTRL1_FRM_12BPP  (4<<25)
+#define LCD_WINCTRL1_FRM_16BPP655       (5<<25)
+#define LCD_WINCTRL1_FRM_16BPP565       (6<<25)
+#define LCD_WINCTRL1_FRM_16BPP556       (7<<25)
+#define LCD_WINCTRL1_FRM_16BPPI1555     (8<<25)
+#define LCD_WINCTRL1_FRM_16BPPI5551     (9<<25)
+#define LCD_WINCTRL1_FRM_16BPPA1555     (10<<25)
+#define LCD_WINCTRL1_FRM_16BPPA5551     (11<<25)
+#define LCD_WINCTRL1_FRM_24BPP          (12<<25)
+#define LCD_WINCTRL1_FRM_32BPP          (13<<25)
+#define LCD_WINCTRL1_PRI_N(N)   ((N)<<30)
+#define LCD_WINCTRL1_PO_00              (0<<22)
+#define LCD_WINCTRL1_PO_01              (1<<22)
+#define LCD_WINCTRL1_PO_10              (2<<22)
+#define LCD_WINCTRL1_PO_11              (3<<22)
+#define LCD_WINCTRL1_SZX_N(N)   ((N-1)<<11)
+#define LCD_WINCTRL1_SZY_N(N)   ((N-1)<<0)
+
+/* lcd windows control 2 */
+#define LCD_WINCTRL2_CKMODE             (3<<24)
+#define LCD_WINCTRL2_DBM                (1<<23)
+#define LCD_WINCTRL2_RAM                (3<<21)
+#define LCD_WINCTRL2_BX                 (0x1FFF<<8)
+#define LCD_WINCTRL2_SCX                (0xF<<4)
+#define LCD_WINCTRL2_SCY                (0xF<<0)
+#define LCD_WINCTRL2_CKMODE_00          (0<<24)
+#define LCD_WINCTRL2_CKMODE_01          (1<<24)
+#define LCD_WINCTRL2_CKMODE_10          (2<<24)
+#define LCD_WINCTRL2_CKMODE_11          (3<<24)
+#define LCD_WINCTRL2_RAM_NONE           (0<<21)
+#define LCD_WINCTRL2_RAM_PALETTE        (1<<21)
+#define LCD_WINCTRL2_RAM_GAMMA          (2<<21)
+#define LCD_WINCTRL2_RAM_BUFFER         (3<<21)
+#define LCD_WINCTRL2_BX_N(N)    ((N)<<8)
+#define LCD_WINCTRL2_SCX_1              (0<<4)
+#define LCD_WINCTRL2_SCX_2              (1<<4)
+#define LCD_WINCTRL2_SCX_4              (2<<4)
+#define LCD_WINCTRL2_SCY_1              (0<<0)
+#define LCD_WINCTRL2_SCY_2              (1<<0)
+#define LCD_WINCTRL2_SCY_4              (2<<0)
+
+/* lcd windows buffer control */
+#define LCD_WINBUFCTRL_DB               (1<<1)
+#define LCD_WINBUFCTRL_DBN              (1<<0)
+
+/* lcd_intstatus, lcd_intenable */
+#define LCD_INT_IFO                             (0xF<<14)
+#define LCD_INT_IFU                             (0xF<<10)
+#define LCD_INT_OFO                             (1<<9)
+#define LCD_INT_OFU                             (1<<8)
+#define LCD_INT_WAIT                    (1<<3)
+#define LCD_INT_SD                              (1<<2)
+#define LCD_INT_SA                              (1<<1)
+#define LCD_INT_SS                              (1<<0)
+
+/* lcd_horztiming */
+#define LCD_HORZTIMING_HND2             (0x1FF<<18)
+#define LCD_HORZTIMING_HND1             (0x1FF<<9)
+#define LCD_HORZTIMING_HPW              (0x1FF<<0)
+#define LCD_HORZTIMING_HND2_N(N)(((N)-1)<<18)
+#define LCD_HORZTIMING_HND1_N(N)(((N)-1)<<9)
+#define LCD_HORZTIMING_HPW_N(N) (((N)-1)<<0)
+
+/* lcd_verttiming */
+#define LCD_VERTTIMING_VND2             (0x1FF<<18)
+#define LCD_VERTTIMING_VND1             (0x1FF<<9)
+#define LCD_VERTTIMING_VPW              (0x1FF<<0)
+#define LCD_VERTTIMING_VND2_N(N)(((N)-1)<<18)
+#define LCD_VERTTIMING_VND1_N(N)(((N)-1)<<9)
+#define LCD_VERTTIMING_VPW_N(N) (((N)-1)<<0)
+
+/* lcd_clkcontrol */
+#define LCD_CLKCONTROL_EXT              (1<<22)
+#define LCD_CLKCONTROL_DELAY    (3<<20)
+#define LCD_CLKCONTROL_CDD              (1<<19)
+#define LCD_CLKCONTROL_IB               (1<<18)
+#define LCD_CLKCONTROL_IC               (1<<17)
+#define LCD_CLKCONTROL_IH               (1<<16)
+#define LCD_CLKCONTROL_IV               (1<<15)
+#define LCD_CLKCONTROL_BF               (0x1F<<10)
+#define LCD_CLKCONTROL_PCD              (0x3FF<<0)
+#define LCD_CLKCONTROL_BF_N(N)  (((N)-1)<<10)
+#define LCD_CLKCONTROL_PCD_N(N) ((N)<<0)
+
+/* lcd_pwmdiv */
+#define LCD_PWMDIV_EN                   (1<<31)
+#define LCD_PWMDIV_PWMDIV               (0x1FFFF<<0)
+#define LCD_PWMDIV_PWMDIV_N(N)  ((N)<<0)
+
+/* lcd_pwmhi */
+#define LCD_PWMHI_PWMHI1                (0xFFFF<<16)
+#define LCD_PWMHI_PWMHI0                (0xFFFF<<0)
+#define LCD_PWMHI_PWMHI1_N(N)   ((N)<<16)
+#define LCD_PWMHI_PWMHI0_N(N)   ((N)<<0)
+
+/* lcd_hwccon */
+#define LCD_HWCCON_EN                   (1<<0)
+
+/* lcd_cursorpos */
+#define LCD_CURSORPOS_HWCXOFF           (0x1F<<27)
+#define LCD_CURSORPOS_HWCXPOS           (0x07FF<<16)
+#define LCD_CURSORPOS_HWCYOFF           (0x1F<<11)
+#define LCD_CURSORPOS_HWCYPOS           (0x07FF<<0)
+#define LCD_CURSORPOS_HWCXOFF_N(N)      ((N)<<27)
+#define LCD_CURSORPOS_HWCXPOS_N(N)      ((N)<<16)
+#define LCD_CURSORPOS_HWCYOFF_N(N)      ((N)<<11)
+#define LCD_CURSORPOS_HWCYPOS_N(N)      ((N)<<0)
+
+/* lcd_cursorcolor */
+#define LCD_CURSORCOLOR_HWCA            (0xFF<<24)
+#define LCD_CURSORCOLOR_HWCR            (0xFF<<16)
+#define LCD_CURSORCOLOR_HWCG            (0xFF<<8)
+#define LCD_CURSORCOLOR_HWCB            (0xFF<<0)
+#define LCD_CURSORCOLOR_HWCA_N(N)       ((N)<<24)
+#define LCD_CURSORCOLOR_HWCR_N(N)       ((N)<<16)
+#define LCD_CURSORCOLOR_HWCG_N(N)       ((N)<<8)
+#define LCD_CURSORCOLOR_HWCB_N(N)       ((N)<<0)
+
+/* lcd_fifoctrl */
+#define LCD_FIFOCTRL_F3IF               (1<<29)
+#define LCD_FIFOCTRL_F3REQ              (0x1F<<24)
+#define LCD_FIFOCTRL_F2IF               (1<<29)
+#define LCD_FIFOCTRL_F2REQ              (0x1F<<16)
+#define LCD_FIFOCTRL_F1IF               (1<<29)
+#define LCD_FIFOCTRL_F1REQ              (0x1F<<8)
+#define LCD_FIFOCTRL_F0IF               (1<<29)
+#define LCD_FIFOCTRL_F0REQ              (0x1F<<0)
+#define LCD_FIFOCTRL_F3REQ_N(N) ((N-1)<<24)
+#define LCD_FIFOCTRL_F2REQ_N(N) ((N-1)<<16)
+#define LCD_FIFOCTRL_F1REQ_N(N) ((N-1)<<8)
+#define LCD_FIFOCTRL_F0REQ_N(N) ((N-1)<<0)
+
+/* lcd_outmask */
+#define LCD_OUTMASK_MASK                (0x00FFFFFF)
+
+/********************************************************************/
+#endif /* _AU1200LCD_H */
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Hardware definitions for the Au1200 LCD controller
+ *
+ * Copyright 2004 AMD
+ * Author:      AMD
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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 _AU1200LCD_H
+#define _AU1200LCD_H
+
+/********************************************************************/
+#define AU1200_LCD_ADDR         0xB5000000
+
+#define uint8 unsigned char
+#define uint32 unsigned int
+
+struct au1200_lcd {
+        volatile uint32 reserved0;
+        volatile uint32 screen;
+        volatile uint32 backcolor;
+        volatile uint32 horztiming;
+        volatile uint32 verttiming;
+        volatile uint32 clkcontrol;
+        volatile uint32 pwmdiv;
+        volatile uint32 pwmhi;
+        volatile uint32 reserved1;
+        volatile uint32 winenable;
+        volatile uint32 colorkey;
+        volatile uint32 colorkeymsk;
+        struct
+        {
+                volatile uint32 cursorctrl;
+                volatile uint32 cursorpos;
+                volatile uint32 cursorcolor0;
+                volatile uint32 cursorcolor1;
+                volatile uint32 cursorcolor2;
+                uint32  cursorcolor3;
+        } hwc;
+        volatile uint32 intstatus;
+        volatile uint32 intenable;
+        volatile uint32 outmask;
+        volatile uint32 fifoctrl;
+        uint32  reserved2[(0x0100-0x0058)/4];
+        struct
+        {
+                volatile uint32 winctrl0;
+                volatile uint32 winctrl1;
+                volatile uint32 winctrl2;
+                volatile uint32 winbuf0;
+                volatile uint32 winbuf1;
+                volatile uint32 winbufctrl;
+                uint32  winreserved0;
+                uint32  winreserved1;
+        } window[4];
+
+        uint32  reserved3[(0x0400-0x0180)/4];
+
+        volatile uint32 palette[(0x0800-0x0400)/4];
+
+        volatile uint8  cursorpattern[256];
+};
+
+/* lcd_screen */
+#define LCD_SCREEN_SEN          (1<<31)
+#define LCD_SCREEN_SX           (0x07FF<<19)
+#define LCD_SCREEN_SY           (0x07FF<< 8)
+#define LCD_SCREEN_SWP          (1<<7)
+#define LCD_SCREEN_SWD          (1<<6)
+#define LCD_SCREEN_PT           (7<<0)
+#define LCD_SCREEN_PT_TFT       (0<<0)
+#define LCD_SCREEN_SX_N(WIDTH)  ((WIDTH-1)<<19)
+#define LCD_SCREEN_SY_N(HEIGHT) ((HEIGHT-1)<<8)
+#define LCD_SCREEN_PT_CSTN      (1<<0)
+#define LCD_SCREEN_PT_CDSTN     (2<<0)
+#define LCD_SCREEN_PT_M8STN     (3<<0)
+#define LCD_SCREEN_PT_M4STN     (4<<0)
+
+/* lcd_backcolor */
+#define LCD_BACKCOLOR_SBGR              (0xFF<<16)
+#define LCD_BACKCOLOR_SBGG              (0xFF<<8)
+#define LCD_BACKCOLOR_SBGB              (0xFF<<0)
+#define LCD_BACKCOLOR_SBGR_N(N) ((N)<<16)
+#define LCD_BACKCOLOR_SBGG_N(N) ((N)<<8)
+#define LCD_BACKCOLOR_SBGB_N(N) ((N)<<0)
+
+/* lcd_winenable */
+#define LCD_WINENABLE_WEN3              (1<<3)
+#define LCD_WINENABLE_WEN2              (1<<2)
+#define LCD_WINENABLE_WEN1              (1<<1)
+#define LCD_WINENABLE_WEN0              (1<<0)
+
+/* lcd_colorkey */
+#define LCD_COLORKEY_CKR                (0xFF<<16)
+#define LCD_COLORKEY_CKG                (0xFF<<8)
+#define LCD_COLORKEY_CKB                (0xFF<<0)
+#define LCD_COLORKEY_CKR_N(N)   ((N)<<16)
+#define LCD_COLORKEY_CKG_N(N)   ((N)<<8)
+#define LCD_COLORKEY_CKB_N(N)   ((N)<<0)
+
+/* lcd_colorkeymsk */
+#define LCD_COLORKEYMSK_CKMR            (0xFF<<16)
+#define LCD_COLORKEYMSK_CKMG            (0xFF<<8)
+#define LCD_COLORKEYMSK_CKMB            (0xFF<<0)
+#define LCD_COLORKEYMSK_CKMR_N(N)       ((N)<<16)
+#define LCD_COLORKEYMSK_CKMG_N(N)       ((N)<<8)
+#define LCD_COLORKEYMSK_CKMB_N(N)       ((N)<<0)
+
+/* lcd windows control 0 */
+#define LCD_WINCTRL0_OX         (0x07FF<<21)
+#define LCD_WINCTRL0_OY         (0x07FF<<10)
+#define LCD_WINCTRL0_A          (0x00FF<<2)
+#define LCD_WINCTRL0_AEN        (1<<1)
+#define LCD_WINCTRL0_OX_N(N) ((N)<<21)
+#define LCD_WINCTRL0_OY_N(N) ((N)<<10)
+#define LCD_WINCTRL0_A_N(N) ((N)<<2)
+
+/* lcd windows control 1 */
+#define LCD_WINCTRL1_PRI        (3<<30)
+#define LCD_WINCTRL1_PIPE       (1<<29)
+#define LCD_WINCTRL1_FRM        (0xF<<25)
+#define LCD_WINCTRL1_CCO        (1<<24)
+#define LCD_WINCTRL1_PO         (3<<22)
+#define LCD_WINCTRL1_SZX        (0x07FF<<11)
+#define LCD_WINCTRL1_SZY        (0x07FF<<0)
+#define LCD_WINCTRL1_FRM_1BPP   (0<<25)
+#define LCD_WINCTRL1_FRM_2BPP   (1<<25)
+#define LCD_WINCTRL1_FRM_4BPP   (2<<25)
+#define LCD_WINCTRL1_FRM_8BPP   (3<<25)
+#define LCD_WINCTRL1_FRM_12BPP  (4<<25)
+#define LCD_WINCTRL1_FRM_16BPP655       (5<<25)
+#define LCD_WINCTRL1_FRM_16BPP565       (6<<25)
+#define LCD_WINCTRL1_FRM_16BPP556       (7<<25)
+#define LCD_WINCTRL1_FRM_16BPPI1555     (8<<25)
+#define LCD_WINCTRL1_FRM_16BPPI5551     (9<<25)
+#define LCD_WINCTRL1_FRM_16BPPA1555     (10<<25)
+#define LCD_WINCTRL1_FRM_16BPPA5551     (11<<25)
+#define LCD_WINCTRL1_FRM_24BPP          (12<<25)
+#define LCD_WINCTRL1_FRM_32BPP          (13<<25)
+#define LCD_WINCTRL1_PRI_N(N)   ((N)<<30)
+#define LCD_WINCTRL1_PO_00              (0<<22)
+#define LCD_WINCTRL1_PO_01              (1<<22)
+#define LCD_WINCTRL1_PO_10              (2<<22)
+#define LCD_WINCTRL1_PO_11              (3<<22)
+#define LCD_WINCTRL1_SZX_N(N)   ((N-1)<<11)
+#define LCD_WINCTRL1_SZY_N(N)   ((N-1)<<0)
+
+/* lcd windows control 2 */
+#define LCD_WINCTRL2_CKMODE             (3<<24)
+#define LCD_WINCTRL2_DBM                (1<<23)
+#define LCD_WINCTRL2_RAM                (3<<21)
+#define LCD_WINCTRL2_BX                 (0x1FFF<<8)
+#define LCD_WINCTRL2_SCX                (0xF<<4)
+#define LCD_WINCTRL2_SCY                (0xF<<0)
+#define LCD_WINCTRL2_CKMODE_00          (0<<24)
+#define LCD_WINCTRL2_CKMODE_01          (1<<24)
+#define LCD_WINCTRL2_CKMODE_10          (2<<24)
+#define LCD_WINCTRL2_CKMODE_11          (3<<24)
+#define LCD_WINCTRL2_RAM_NONE           (0<<21)
+#define LCD_WINCTRL2_RAM_PALETTE        (1<<21)
+#define LCD_WINCTRL2_RAM_GAMMA          (2<<21)
+#define LCD_WINCTRL2_RAM_BUFFER         (3<<21)
+#define LCD_WINCTRL2_BX_N(N)    ((N)<<8)
+#define LCD_WINCTRL2_SCX_1              (0<<4)
+#define LCD_WINCTRL2_SCX_2              (1<<4)
+#define LCD_WINCTRL2_SCX_4              (2<<4)
+#define LCD_WINCTRL2_SCY_1              (0<<0)
+#define LCD_WINCTRL2_SCY_2              (1<<0)
+#define LCD_WINCTRL2_SCY_4              (2<<0)
+
+/* lcd windows buffer control */
+#define LCD_WINBUFCTRL_DB               (1<<1)
+#define LCD_WINBUFCTRL_DBN              (1<<0)
+
+/* lcd_intstatus, lcd_intenable */
+#define LCD_INT_IFO                             (0xF<<14)
+#define LCD_INT_IFU                             (0xF<<10)
+#define LCD_INT_OFO                             (1<<9)
+#define LCD_INT_OFU                             (1<<8)
+#define LCD_INT_WAIT                    (1<<3)
+#define LCD_INT_SD                              (1<<2)
+#define LCD_INT_SA                              (1<<1)
+#define LCD_INT_SS                              (1<<0)
+
+/* lcd_horztiming */
+#define LCD_HORZTIMING_HND2             (0x1FF<<18)
+#define LCD_HORZTIMING_HND1             (0x1FF<<9)
+#define LCD_HORZTIMING_HPW              (0x1FF<<0)
+#define LCD_HORZTIMING_HND2_N(N)(((N)-1)<<18)
+#define LCD_HORZTIMING_HND1_N(N)(((N)-1)<<9)
+#define LCD_HORZTIMING_HPW_N(N) (((N)-1)<<0)
+
+/* lcd_verttiming */
+#define LCD_VERTTIMING_VND2             (0x1FF<<18)
+#define LCD_VERTTIMING_VND1             (0x1FF<<9)
+#define LCD_VERTTIMING_VPW              (0x1FF<<0)
+#define LCD_VERTTIMING_VND2_N(N)(((N)-1)<<18)
+#define LCD_VERTTIMING_VND1_N(N)(((N)-1)<<9)
+#define LCD_VERTTIMING_VPW_N(N) (((N)-1)<<0)
+
+/* lcd_clkcontrol */
+#define LCD_CLKCONTROL_EXT              (1<<22)
+#define LCD_CLKCONTROL_DELAY    (3<<20)
+#define LCD_CLKCONTROL_CDD              (1<<19)
+#define LCD_CLKCONTROL_IB               (1<<18)
+#define LCD_CLKCONTROL_IC               (1<<17)
+#define LCD_CLKCONTROL_IH               (1<<16)
+#define LCD_CLKCONTROL_IV               (1<<15)
+#define LCD_CLKCONTROL_BF               (0x1F<<10)
+#define LCD_CLKCONTROL_PCD              (0x3FF<<0)
+#define LCD_CLKCONTROL_BF_N(N)  (((N)-1)<<10)
+#define LCD_CLKCONTROL_PCD_N(N) ((N)<<0)
+
+/* lcd_pwmdiv */
+#define LCD_PWMDIV_EN                   (1<<31)
+#define LCD_PWMDIV_PWMDIV               (0x1FFFF<<0)
+#define LCD_PWMDIV_PWMDIV_N(N)  ((N)<<0)
+
+/* lcd_pwmhi */
+#define LCD_PWMHI_PWMHI1                (0xFFFF<<16)
+#define LCD_PWMHI_PWMHI0                (0xFFFF<<0)
+#define LCD_PWMHI_PWMHI1_N(N)   ((N)<<16)
+#define LCD_PWMHI_PWMHI0_N(N)   ((N)<<0)
+
+/* lcd_hwccon */
+#define LCD_HWCCON_EN                   (1<<0)
+
+/* lcd_cursorpos */
+#define LCD_CURSORPOS_HWCXOFF           (0x1F<<27)
+#define LCD_CURSORPOS_HWCXPOS           (0x07FF<<16)
+#define LCD_CURSORPOS_HWCYOFF           (0x1F<<11)
+#define LCD_CURSORPOS_HWCYPOS           (0x07FF<<0)
+#define LCD_CURSORPOS_HWCXOFF_N(N)      ((N)<<27)
+#define LCD_CURSORPOS_HWCXPOS_N(N)      ((N)<<16)
+#define LCD_CURSORPOS_HWCYOFF_N(N)      ((N)<<11)
+#define LCD_CURSORPOS_HWCYPOS_N(N)      ((N)<<0)
+
+/* lcd_cursorcolor */
+#define LCD_CURSORCOLOR_HWCA            (0xFF<<24)
+#define LCD_CURSORCOLOR_HWCR            (0xFF<<16)
+#define LCD_CURSORCOLOR_HWCG            (0xFF<<8)
+#define LCD_CURSORCOLOR_HWCB            (0xFF<<0)
+#define LCD_CURSORCOLOR_HWCA_N(N)       ((N)<<24)
+#define LCD_CURSORCOLOR_HWCR_N(N)       ((N)<<16)
+#define LCD_CURSORCOLOR_HWCG_N(N)       ((N)<<8)
+#define LCD_CURSORCOLOR_HWCB_N(N)       ((N)<<0)
+
+/* lcd_fifoctrl */
+#define LCD_FIFOCTRL_F3IF               (1<<29)
+#define LCD_FIFOCTRL_F3REQ              (0x1F<<24)
+#define LCD_FIFOCTRL_F2IF               (1<<29)
+#define LCD_FIFOCTRL_F2REQ              (0x1F<<16)
+#define LCD_FIFOCTRL_F1IF               (1<<29)
+#define LCD_FIFOCTRL_F1REQ              (0x1F<<8)
+#define LCD_FIFOCTRL_F0IF               (1<<29)
+#define LCD_FIFOCTRL_F0REQ              (0x1F<<0)
+#define LCD_FIFOCTRL_F3REQ_N(N) ((N-1)<<24)
+#define LCD_FIFOCTRL_F2REQ_N(N) ((N-1)<<16)
+#define LCD_FIFOCTRL_F1REQ_N(N) ((N-1)<<8)
+#define LCD_FIFOCTRL_F0REQ_N(N) ((N-1)<<0)
+
+/* lcd_outmask */
+#define LCD_OUTMASK_MASK                (0x00FFFFFF)
+
+/********************************************************************/
+#endif /* _AU1200LCD_H */
diff --git a/drivers/video/chipsfb.c b/drivers/video/chipsfb.c
index bc061d4ec786..72ff6bf75e5e 100644
--- a/drivers/video/chipsfb.c
+++ b/drivers/video/chipsfb.c
@@ -178,8 +178,6 @@ struct chips_init_reg {
         unsigned char data;
 };
 
-#define N_ELTS(x)       (sizeof(x) / sizeof(x[0]))
-
 static struct chips_init_reg chips_init_sr[] = {
         { 0x00, 0x03 },
         { 0x01, 0x01 },
@@ -287,18 +285,18 @@ static void __init chips_hw_init(void)
 {
         int i;
 
-        for (i = 0; i < N_ELTS(chips_init_xr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_xr); ++i)
                 write_xr(chips_init_xr[i].addr, chips_init_xr[i].data);
         outb(0x29, 0x3c2); /* set misc output reg */
-        for (i = 0; i < N_ELTS(chips_init_sr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_sr); ++i)
                 write_sr(chips_init_sr[i].addr, chips_init_sr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_gr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_gr); ++i)
                 write_gr(chips_init_gr[i].addr, chips_init_gr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_ar); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_ar); ++i)
                 write_ar(chips_init_ar[i].addr, chips_init_ar[i].data);
-        for (i = 0; i < N_ELTS(chips_init_cr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_cr); ++i)
                 write_cr(chips_init_cr[i].addr, chips_init_cr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_fr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_fr); ++i)
                 write_fr(chips_init_fr[i].addr, chips_init_fr[i].data);
 }
 
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index 6ee449858a5c..4444bef68fba 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -26,6 +26,30 @@ config VGA_CONSOLE
 #          fi
 #       fi
 
+config VGACON_SOFT_SCROLLBACK
+       bool "Enable Scrollback Buffer in System RAM"
+       depends on VGA_CONSOLE
+       default n
+       help
+         The scrollback buffer of the standard VGA console is located in
+         the VGA RAM.  The size of this RAM is fixed and is quite small.
+         If you require a larger scrollback buffer, this can be placed in
+         System RAM which is dynamically allocated during intialization.
+         Placing the scrollback buffer in System RAM will slightly slow
+         down the console.
+
+         If you want this feature, say 'Y' here and enter the amount of
+         RAM to allocate for this buffer.  If unsure, say 'N'.
+
+config VGACON_SOFT_SCROLLBACK_SIZE
+       int "Scrollback Buffer Size (in KB)"
+       depends on VGACON_SOFT_SCROLLBACK
+       default "64"
+       help
+         Enter the amount of System RAM to allocate for the scrollback
+         buffer.  Each 64KB will give you approximately 16 80x25
+         screenfuls of scrollback buffer
+
 config VIDEO_SELECT
         bool "Video mode selection support"
         depends on  X86 && VGA_CONSOLE
diff --git a/drivers/video/console/fonts.c b/drivers/video/console/fonts.c
index 4fd07d9eca03..0cc1bfda76a6 100644
--- a/drivers/video/console/fonts.c
+++ b/drivers/video/console/fonts.c
@@ -66,7 +66,7 @@ static const struct font_desc *fonts[] = {
 #endif
 };
 
-#define num_fonts (sizeof(fonts)/sizeof(*fonts))
+#define num_fonts ARRAY_SIZE(fonts)
 
 #ifdef NO_FONTS
 #error No fonts configured.
diff --git a/drivers/video/console/newport_con.c b/drivers/video/console/newport_con.c
index 762c7a593141..e99fe30e568c 100644
--- a/drivers/video/console/newport_con.c
+++ b/drivers/video/console/newport_con.c
@@ -149,7 +149,7 @@ static inline void newport_clear_lines(int ystart, int yend, int ci)
         newport_clear_screen(0, ystart, 1280 + 63, yend, ci);
 }
 
-void newport_reset(void)
+static void newport_reset(void)
 {
         unsigned short treg;
         int i;
@@ -193,7 +193,7 @@ void newport_reset(void)
  * calculate the actual screen size by reading
  * the video timing out of the VC2
  */
-void newport_get_screensize(void)
+static void newport_get_screensize(void)
 {
         int i, cols;
         unsigned short ventry, treg;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 5a86978537d2..d5a04b68c4d4 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -93,7 +93,6 @@ static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
 static unsigned long vgacon_uni_pagedir[2];
 
-
 /* Description of the hardware situation */
 static unsigned long    vga_vram_base;          /* Base of video memory */
 static unsigned long    vga_vram_end;           /* End of video memory */
@@ -161,6 +160,201 @@ static inline void write_vga(unsigned char reg, unsigned int val)
         spin_unlock_irqrestore(&vga_lock, flags);
 }
 
+static inline void vga_set_mem_top(struct vc_data *c)
+{
+        write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
+}
+
+#ifdef CONFIG_VGACON_SOFT_SCROLLBACK
+#include <linux/bootmem.h>
+/* software scrollback */
+static void *vgacon_scrollback;
+static int vgacon_scrollback_tail;
+static int vgacon_scrollback_size;
+static int vgacon_scrollback_rows;
+static int vgacon_scrollback_cnt;
+static int vgacon_scrollback_cur;
+static int vgacon_scrollback_save;
+static int vgacon_scrollback_restore;
+
+static void vgacon_scrollback_init(int pitch)
+{
+        int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
+
+        if (vgacon_scrollback) {
+                vgacon_scrollback_cnt  = 0;
+                vgacon_scrollback_tail = 0;
+                vgacon_scrollback_cur  = 0;
+                vgacon_scrollback_rows = rows - 1;
+                vgacon_scrollback_size = rows * pitch;
+        }
+}
+
+static void __init vgacon_scrollback_startup(void)
+{
+        vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
+                                          * 1024);
+        vgacon_scrollback_init(vga_video_num_columns * 2);
+}
+
+static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
+{
+        void *p;
+
+        if (!vgacon_scrollback_size || c->vc_num != fg_console)
+                return;
+
+        p = (void *) (c->vc_origin + t * c->vc_size_row);
+
+        while (count--) {
+                scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
+                            p, c->vc_size_row);
+                vgacon_scrollback_cnt++;
+                p += c->vc_size_row;
+                vgacon_scrollback_tail += c->vc_size_row;
+
+                if (vgacon_scrollback_tail >= vgacon_scrollback_size)
+                        vgacon_scrollback_tail = 0;
+
+                if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
+                        vgacon_scrollback_cnt = vgacon_scrollback_rows;
+
+                vgacon_scrollback_cur = vgacon_scrollback_cnt;
+        }
+}
+
+static void vgacon_restore_screen(struct vc_data *c)
+{
+        vgacon_scrollback_save = 0;
+
+        if (!vga_is_gfx && !vgacon_scrollback_restore) {
+                scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
+                            c->vc_screenbuf_size > vga_vram_size ?
+                            vga_vram_size : c->vc_screenbuf_size);
+                vgacon_scrollback_restore = 1;
+                vgacon_scrollback_cur = vgacon_scrollback_cnt;
+        }
+}
+
+static int vgacon_scrolldelta(struct vc_data *c, int lines)
+{
+        int start, end, count, soff, diff;
+        void *d, *s;
+
+        if (!lines) {
+                c->vc_visible_origin = c->vc_origin;
+                vga_set_mem_top(c);
+                return 1;
+        }
+
+        if (!vgacon_scrollback)
+                return 1;
+
+        if (!vgacon_scrollback_save) {
+                vgacon_cursor(c, CM_ERASE);
+                vgacon_save_screen(c);
+                vgacon_scrollback_save = 1;
+        }
+
+        vgacon_scrollback_restore = 0;
+        start = vgacon_scrollback_cur + lines;
+        end = start + abs(lines);
+
+        if (start < 0)
+                start = 0;
+
+        if (start > vgacon_scrollback_cnt)
+                start = vgacon_scrollback_cnt;
+
+        if (end < 0)
+                end = 0;
+
+        if (end > vgacon_scrollback_cnt)
+                end = vgacon_scrollback_cnt;
+
+        vgacon_scrollback_cur = start;
+        count = end - start;
+        soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
+                                         c->vc_size_row);
+        soff -= count * c->vc_size_row;
+
+        if (soff < 0)
+                soff += vgacon_scrollback_size;
+
+        count = vgacon_scrollback_cnt - start;
+
+        if (count > c->vc_rows)
+                count = c->vc_rows;
+
+        diff = c->vc_rows - count;
+
+        d = (void *) c->vc_origin;
+        s = (void *) c->vc_screenbuf;
+
+        while (count--) {
+                scr_memcpyw(d, vgacon_scrollback + soff, c->vc_size_row);
+                d += c->vc_size_row;
+                soff += c->vc_size_row;
+
+                if (soff >= vgacon_scrollback_size)
+                        soff = 0;
+        }
+
+        if (diff == c->vc_rows) {
+                vgacon_cursor(c, CM_MOVE);
+        } else {
+                while (diff--) {
+                        scr_memcpyw(d, s, c->vc_size_row);
+                        d += c->vc_size_row;
+                        s += c->vc_size_row;
+                }
+        }
+
+        return 1;
+}
+#else
+#define vgacon_scrollback_startup(...) do { } while (0)
+#define vgacon_scrollback_init(...)    do { } while (0)
+#define vgacon_scrollback_update(...)  do { } while (0)
+
+static void vgacon_restore_screen(struct vc_data *c)
+{
+        if (c->vc_origin != c->vc_visible_origin)
+                vgacon_scrolldelta(c, 0);
+}
+
+static int vgacon_scrolldelta(struct vc_data *c, int lines)
+{
+        if (!lines)             /* Turn scrollback off */
+                c->vc_visible_origin = c->vc_origin;
+        else {
+                int margin = c->vc_size_row * 4;
+                int ul, we, p, st;
+
+                if (vga_rolled_over >
+                    (c->vc_scr_end - vga_vram_base) + margin) {
+                        ul = c->vc_scr_end - vga_vram_base;
+                        we = vga_rolled_over + c->vc_size_row;
+                } else {
+                        ul = 0;
+                        we = vga_vram_size;
+                }
+                p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
+                    lines * c->vc_size_row;
+                st = (c->vc_origin - vga_vram_base - ul + we) % we;
+                if (st < 2 * margin)
+                        margin = 0;
+                if (p < margin)
+                        p = 0;
+                if (p > st - margin)
+                        p = st;
+                c->vc_visible_origin = vga_vram_base + (p + ul) % we;
+        }
+        vga_set_mem_top(c);
+        return 1;
+}
+#endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
+
 static const char __init *vgacon_startup(void)
 {
         const char *display_desc = NULL;
@@ -330,7 +524,7 @@ static const char __init *vgacon_startup(void)
 
         vgacon_xres = ORIG_VIDEO_COLS * VGA_FONTWIDTH;
         vgacon_yres = vga_scan_lines;
-
+        vgacon_scrollback_startup();
         return display_desc;
 }
 
@@ -357,11 +551,6 @@ static void vgacon_init(struct vc_data *c, int init)
                 con_set_default_unimap(c);
 }
 
-static inline void vga_set_mem_top(struct vc_data *c)
-{
-        write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
-}
-
 static void vgacon_deinit(struct vc_data *c)
 {
         /* When closing the last console, reset video origin */
@@ -433,29 +622,37 @@ static void vgacon_set_cursor_size(int xpos, int from, int to)
         cursor_size_lastto = to;
 
         spin_lock_irqsave(&vga_lock, flags);
-        outb_p(0x0a, vga_video_port_reg);       /* Cursor start */
-        curs = inb_p(vga_video_port_val);
-        outb_p(0x0b, vga_video_port_reg);       /* Cursor end */
-        cure = inb_p(vga_video_port_val);
+        if (vga_video_type >= VIDEO_TYPE_VGAC) {
+                outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
+                curs = inb_p(vga_video_port_val);
+                outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
+                cure = inb_p(vga_video_port_val);
+        } else {
+                curs = 0;
+                cure = 0;
+        }
 
         curs = (curs & 0xc0) | from;
         cure = (cure & 0xe0) | to;
 
-        outb_p(0x0a, vga_video_port_reg);       /* Cursor start */
+        outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
         outb_p(curs, vga_video_port_val);
-        outb_p(0x0b, vga_video_port_reg);       /* Cursor end */
+        outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
         outb_p(cure, vga_video_port_val);
         spin_unlock_irqrestore(&vga_lock, flags);
 }
 
 static void vgacon_cursor(struct vc_data *c, int mode)
 {
-        if (c->vc_origin != c->vc_visible_origin)
-                vgacon_scrolldelta(c, 0);
+        vgacon_restore_screen(c);
+
         switch (mode) {
         case CM_ERASE:
                 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
-                vgacon_set_cursor_size(c->vc_x, 31, 30);
+                if (vga_video_type >= VIDEO_TYPE_VGAC)
+                        vgacon_set_cursor_size(c->vc_x, 31, 30);
+                else
+                        vgacon_set_cursor_size(c->vc_x, 31, 31);
                 break;
 
         case CM_MOVE:
@@ -493,7 +690,10 @@ static void vgacon_cursor(struct vc_data *c, int mode)
                                                 10 ? 1 : 2));
                         break;
                 case CUR_NONE:
-                        vgacon_set_cursor_size(c->vc_x, 31, 30);
+                        if (vga_video_type >= VIDEO_TYPE_VGAC)
+                                vgacon_set_cursor_size(c->vc_x, 31, 30);
+                        else
+                                vgacon_set_cursor_size(c->vc_x, 31, 31);
                         break;
                 default:
                         vgacon_set_cursor_size(c->vc_x, 1,
@@ -595,6 +795,7 @@ static int vgacon_switch(struct vc_data *c)
                         vgacon_doresize(c, c->vc_cols, c->vc_rows);
         }
 
+        vgacon_scrollback_init(c->vc_size_row);
         return 0;               /* Redrawing not needed */
 }
 
@@ -1062,37 +1263,6 @@ static int vgacon_resize(struct vc_data *c, unsigned int width,
         return 0;
 }
 
-static int vgacon_scrolldelta(struct vc_data *c, int lines)
-{
-        if (!lines)             /* Turn scrollback off */
-                c->vc_visible_origin = c->vc_origin;
-        else {
-                int margin = c->vc_size_row * 4;
-                int ul, we, p, st;
-
-                if (vga_rolled_over >
-                    (c->vc_scr_end - vga_vram_base) + margin) {
-                        ul = c->vc_scr_end - vga_vram_base;
-                        we = vga_rolled_over + c->vc_size_row;
-                } else {
-                        ul = 0;
-                        we = vga_vram_size;
-                }
-                p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
-                    lines * c->vc_size_row;
-                st = (c->vc_origin - vga_vram_base - ul + we) % we;
-                if (st < 2 * margin)
-                        margin = 0;
-                if (p < margin)
-                        p = 0;
-                if (p > st - margin)
-                        p = st;
-                c->vc_visible_origin = vga_vram_base + (p + ul) % we;
-        }
-        vga_set_mem_top(c);
-        return 1;
-}
-
 static int vgacon_set_origin(struct vc_data *c)
 {
         if (vga_is_gfx ||       /* We don't play origin tricks in graphic modes */
@@ -1135,15 +1305,14 @@ static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
         if (t || b != c->vc_rows || vga_is_gfx)
                 return 0;
 
-        if (c->vc_origin != c->vc_visible_origin)
-                vgacon_scrolldelta(c, 0);
-
         if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
                 return 0;
 
+        vgacon_restore_screen(c);
         oldo = c->vc_origin;
         delta = lines * c->vc_size_row;
         if (dir == SM_UP) {
+                vgacon_scrollback_update(c, t, lines);
                 if (c->vc_scr_end + delta >= vga_vram_end) {
                         scr_memcpyw((u16 *) vga_vram_base,
                                     (u16 *) (oldo + delta),
diff --git a/drivers/video/fbcmap.c b/drivers/video/fbcmap.c
index c32a2a50bfa2..1f98392a43b3 100644
--- a/drivers/video/fbcmap.c
+++ b/drivers/video/fbcmap.c
@@ -85,7 +85,7 @@ static struct fb_cmap default_16_colors = {
  *      Allocates memory for a colormap @cmap.  @len is the
  *      number of entries in the palette.
  *
- *      Returns -1 errno on error, or zero on success.
+ *      Returns negative errno on error, or zero on success.
  *
  */
 
@@ -116,7 +116,7 @@ int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp)
 
 fail:
     fb_dealloc_cmap(cmap);
-    return -1;
+    return -ENOMEM;
 }
 
 /**
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 07d882b14396..b1a8dca76430 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -55,7 +55,7 @@
 
 #define FBPIXMAPSIZE    (1024 * 8)
 
-static struct notifier_block *fb_notifier_list;
+static BLOCKING_NOTIFIER_HEAD(fb_notifier_list);
 struct fb_info *registered_fb[FB_MAX];
 int num_registered_fb;
 
@@ -784,7 +784,7 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 
                     event.info = info;
                     event.data = &mode1;
-                    ret = notifier_call_chain(&fb_notifier_list,
+                    ret = blocking_notifier_call_chain(&fb_notifier_list,
                                               FB_EVENT_MODE_DELETE, &event);
                 }
 
@@ -830,8 +830,8 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 
                                 info->flags &= ~FBINFO_MISC_USEREVENT;
                                 event.info = info;
-                                notifier_call_chain(&fb_notifier_list, evnt,
-                                                    &event);
+                                blocking_notifier_call_chain(&fb_notifier_list,
+                                                evnt, &event);
                         }
                 }
         }
@@ -854,7 +854,8 @@ fb_blank(struct fb_info *info, int blank)
 
                 event.info = info;
                 event.data = &blank;
-                notifier_call_chain(&fb_notifier_list, FB_EVENT_BLANK, &event);
+                blocking_notifier_call_chain(&fb_notifier_list,
+                                FB_EVENT_BLANK, &event);
         }
 
         return ret;
@@ -925,7 +926,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 con2fb.framebuffer = -1;
                 event.info = info;
                 event.data = &con2fb;
-                notifier_call_chain(&fb_notifier_list,
+                blocking_notifier_call_chain(&fb_notifier_list,
                                     FB_EVENT_GET_CONSOLE_MAP, &event);
                 return copy_to_user(argp, &con2fb,
                                     sizeof(con2fb)) ? -EFAULT : 0;
@@ -944,7 +945,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                     return -EINVAL;
                 event.info = info;
                 event.data = &con2fb;
-                return notifier_call_chain(&fb_notifier_list,
+                return blocking_notifier_call_chain(&fb_notifier_list,
                                            FB_EVENT_SET_CONSOLE_MAP,
                                            &event);
         case FBIOBLANK:
@@ -1324,7 +1325,7 @@ register_framebuffer(struct fb_info *fb_info)
         devfs_mk_cdev(MKDEV(FB_MAJOR, i),
                         S_IFCHR | S_IRUGO | S_IWUGO, "fb/%d", i);
         event.info = fb_info;
-        notifier_call_chain(&fb_notifier_list,
+        blocking_notifier_call_chain(&fb_notifier_list,
                             FB_EVENT_FB_REGISTERED, &event);
         return 0;
 }
@@ -1366,7 +1367,7 @@ unregister_framebuffer(struct fb_info *fb_info)
  */
 int fb_register_client(struct notifier_block *nb)
 {
-        return notifier_chain_register(&fb_notifier_list, nb);
+        return blocking_notifier_chain_register(&fb_notifier_list, nb);
 }
 
 /**
@@ -1375,7 +1376,7 @@ int fb_register_client(struct notifier_block *nb)
  */
 int fb_unregister_client(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&fb_notifier_list, nb);
+        return blocking_notifier_chain_unregister(&fb_notifier_list, nb);
 }
 
 /**
@@ -1393,11 +1394,13 @@ void fb_set_suspend(struct fb_info *info, int state)
 
         event.info = info;
         if (state) {
-                notifier_call_chain(&fb_notifier_list, FB_EVENT_SUSPEND, &event);
+                blocking_notifier_call_chain(&fb_notifier_list,
+                                FB_EVENT_SUSPEND, &event);
                 info->state = FBINFO_STATE_SUSPENDED;
         } else {
                 info->state = FBINFO_STATE_RUNNING;
-                notifier_call_chain(&fb_notifier_list, FB_EVENT_RESUME, &event);
+                blocking_notifier_call_chain(&fb_notifier_list,
+                                FB_EVENT_RESUME, &event);
         }
 }
 
@@ -1469,7 +1472,7 @@ int fb_new_modelist(struct fb_info *info)
 
         if (!list_empty(&info->modelist)) {
                 event.info = info;
-                err = notifier_call_chain(&fb_notifier_list,
+                err = blocking_notifier_call_chain(&fb_notifier_list,
                                            FB_EVENT_NEW_MODELIST,
                                            &event);
         }
@@ -1495,7 +1498,7 @@ int fb_con_duit(struct fb_info *info, int event, void *data)
         evnt.info = info;
         evnt.data = data;
 
-        return notifier_call_chain(&fb_notifier_list, event, &evnt);
+        return blocking_notifier_call_chain(&fb_notifier_list, event, &evnt);
 }
 EXPORT_SYMBOL(fb_con_duit);
 
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 7c74e7325d95..53beeb4a9998 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -1281,7 +1281,7 @@ int fb_validate_mode(const struct fb_var_screeninfo *var, struct fb_info *info)
                 -EINVAL : 0;
 }
 
-#if defined(__i386__)
+#if defined(CONFIG_FB_FIRMWARE_EDID) && defined(__i386__)
 #include <linux/pci.h>
 
 /*
@@ -1311,11 +1311,11 @@ const unsigned char *fb_firmware_edid(struct device *device)
 {
         return NULL;
 }
-#endif /* _i386_ */
+#endif
+EXPORT_SYMBOL(fb_firmware_edid);
 
 EXPORT_SYMBOL(fb_parse_edid);
 EXPORT_SYMBOL(fb_edid_to_monspecs);
-EXPORT_SYMBOL(fb_firmware_edid);
 EXPORT_SYMBOL(fb_get_mode);
 EXPORT_SYMBOL(fb_validate_mode);
 EXPORT_SYMBOL(fb_destroy_modedb);
diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index 6d26057337e2..b72b05250a9d 100644
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -348,7 +348,7 @@ static ssize_t store_cmap(struct class_device *class_device, const char *buf,
                 fb_copy_cmap(&umap, &fb_info->cmap);
                 fb_dealloc_cmap(&umap);
 
-                return rc;
+                return rc ?: count;
         }
         for (i = 0; i < length; i++) {
                 u16 red, blue, green, tsp;
@@ -367,7 +367,7 @@ static ssize_t store_cmap(struct class_device *class_device, const char *buf,
                 if (transp)
                         fb_info->cmap.transp[i] = tsp;
         }
-        return 0;
+        return count;
 }
 
 static ssize_t show_cmap(struct class_device *class_device, char *buf)
diff --git a/drivers/video/geode/Kconfig b/drivers/video/geode/Kconfig
index 42fb9a89a792..4e173ef20a7d 100644
--- a/drivers/video/geode/Kconfig
+++ b/drivers/video/geode/Kconfig
@@ -8,9 +8,24 @@ config FB_GEODE
           Say 'Y' here to allow you to select framebuffer drivers for
           the AMD Geode family of processors.
 
+config FB_GEODE_GX
+        tristate "AMD Geode GX framebuffer support (EXPERIMENTAL)"
+        depends on FB && FB_GEODE && EXPERIMENTAL
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        ---help---
+          Framebuffer driver for the display controller integrated into the
+          AMD Geode GX processors.
+
+          To compile this driver as a module, choose M here: the module will be
+          called gxfb.
+
+          If unsure, say N.
+
 config FB_GEODE_GX1
         tristate "AMD Geode GX1 framebuffer support (EXPERIMENTAL)"
-        depends on FB_GEODE && EXPERIMENTAL
+        depends on FB && FB_GEODE && EXPERIMENTAL
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
diff --git a/drivers/video/geode/Makefile b/drivers/video/geode/Makefile
index 13ad501ea990..f896565bc312 100644
--- a/drivers/video/geode/Makefile
+++ b/drivers/video/geode/Makefile
@@ -1,5 +1,7 @@
 # Makefile for the Geode family framebuffer drivers
 
 obj-$(CONFIG_FB_GEODE_GX1) += gx1fb.o
+obj-$(CONFIG_FB_GEODE_GX)  += gxfb.o
 
-gx1fb-objs              := gx1fb_core.o display_gx1.o video_cs5530.o
+gx1fb-objs := gx1fb_core.o display_gx1.o video_cs5530.o
+gxfb-objs  := gxfb_core.o display_gx.o video_gx.o
diff --git a/drivers/video/geode/display_gx.c b/drivers/video/geode/display_gx.c
new file mode 100644
index 000000000000..825c3405f5c2
--- /dev/null
+++ b/drivers/video/geode/display_gx.c
@@ -0,0 +1,156 @@
+/*
+ * Geode GX display controller.
+ *
+ *   Copyright (C) 2005 Arcom Control Systems Ltd.
+ *
+ *   Portions from AMD's original 2.4 driver:
+ *     Copyright (C) 2004 Advanced Micro Devices, Inc.
+ *
+ *   This program is free software; you can redistribute it and/or modify it
+ *   under the terms of the GNU General Public License as published by * the
+ *   Free Software Foundation; either version 2 of the License, or * (at your
+ *   option) any later version.
+ */
+#include <linux/spinlock.h>
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#include <asm/div64.h>
+#include <asm/delay.h>
+
+#include "geodefb.h"
+#include "display_gx.h"
+
+int gx_frame_buffer_size(void)
+{
+        /* Assuming 16 MiB. */
+        return 16*1024*1024;
+}
+
+int gx_line_delta(int xres, int bpp)
+{
+        /* Must be a multiple of 8 bytes. */
+        return (xres * (bpp >> 3) + 7) & ~0x7;
+}
+
+static void gx_set_mode(struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+        u32 gcfg, dcfg;
+        int hactive, hblankstart, hsyncstart, hsyncend, hblankend, htotal;
+        int vactive, vblankstart, vsyncstart, vsyncend, vblankend, vtotal;
+
+        /* Unlock the display controller registers. */
+        readl(par->dc_regs + DC_UNLOCK);
+        writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
+
+        gcfg = readl(par->dc_regs + DC_GENERAL_CFG);
+        dcfg = readl(par->dc_regs + DC_DISPLAY_CFG);
+
+        /* Disable the timing generator. */
+        dcfg &= ~(DC_DCFG_TGEN);
+        writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
+
+        /* Wait for pending memory requests before disabling the FIFO load. */
+        udelay(100);
+
+        /* Disable FIFO load and compression. */
+        gcfg &= ~(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
+        writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
+
+        /* Setup DCLK and its divisor. */
+        par->vid_ops->set_dclk(info);
+
+        /*
+         * Setup new mode.
+         */
+
+        /* Clear all unused feature bits. */
+        gcfg &= DC_GCFG_YUVM | DC_GCFG_VDSE;
+        dcfg = 0;
+
+        /* Set FIFO priority (default 6/5) and enable. */
+        /* FIXME: increase fifo priority for 1280x1024 and higher modes? */
+        gcfg |= (6 << DC_GCFG_DFHPEL_POS) | (5 << DC_GCFG_DFHPSL_POS) | DC_GCFG_DFLE;
+
+        /* Framebuffer start offset. */
+        writel(0, par->dc_regs + DC_FB_ST_OFFSET);
+
+        /* Line delta and line buffer length. */
+        writel(info->fix.line_length >> 3, par->dc_regs + DC_GFX_PITCH);
+        writel(((info->var.xres * info->var.bits_per_pixel/8) >> 3) + 2,
+               par->dc_regs + DC_LINE_SIZE);
+
+        /* Enable graphics and video data and unmask address lines. */
+        dcfg |= DC_DCFG_GDEN | DC_DCFG_VDEN | DC_DCFG_A20M | DC_DCFG_A18M;
+
+        /* Set pixel format. */
+        switch (info->var.bits_per_pixel) {
+        case 8:
+                dcfg |= DC_DCFG_DISP_MODE_8BPP;
+                break;
+        case 16:
+                dcfg |= DC_DCFG_DISP_MODE_16BPP;
+                dcfg |= DC_DCFG_16BPP_MODE_565;
+                break;
+        case 32:
+                dcfg |= DC_DCFG_DISP_MODE_24BPP;
+                dcfg |= DC_DCFG_PALB;
+                break;
+        }
+
+        /* Enable timing generator. */
+        dcfg |= DC_DCFG_TGEN;
+
+        /* Horizontal and vertical timings. */
+        hactive = info->var.xres;
+        hblankstart = hactive;
+        hsyncstart = hblankstart + info->var.right_margin;
+        hsyncend =  hsyncstart + info->var.hsync_len;
+        hblankend = hsyncend + info->var.left_margin;
+        htotal = hblankend;
+
+        vactive = info->var.yres;
+        vblankstart = vactive;
+        vsyncstart = vblankstart + info->var.lower_margin;
+        vsyncend =  vsyncstart + info->var.vsync_len;
+        vblankend = vsyncend + info->var.upper_margin;
+        vtotal = vblankend;
+
+        writel((hactive - 1)     | ((htotal - 1) << 16),    par->dc_regs + DC_H_ACTIVE_TIMING);
+        writel((hblankstart - 1) | ((hblankend - 1) << 16), par->dc_regs + DC_H_BLANK_TIMING);
+        writel((hsyncstart - 1)  | ((hsyncend - 1) << 16),  par->dc_regs + DC_H_SYNC_TIMING);
+
+        writel((vactive - 1)     | ((vtotal - 1) << 16),    par->dc_regs + DC_V_ACTIVE_TIMING);
+        writel((vblankstart - 1) | ((vblankend - 1) << 16), par->dc_regs + DC_V_BLANK_TIMING);
+        writel((vsyncstart - 1)  | ((vsyncend - 1) << 16),  par->dc_regs + DC_V_SYNC_TIMING);
+
+        /* Write final register values. */
+        writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
+        writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
+
+        par->vid_ops->configure_display(info);
+
+        /* Relock display controller registers */
+        writel(0, par->dc_regs + DC_UNLOCK);
+}
+
+static void gx_set_hw_palette_reg(struct fb_info *info, unsigned regno,
+                                   unsigned red, unsigned green, unsigned blue)
+{
+        struct geodefb_par *par = info->par;
+        int val;
+
+        /* Hardware palette is in RGB 8-8-8 format. */
+        val  = (red   << 8) & 0xff0000;
+        val |= (green)      & 0x00ff00;
+        val |= (blue  >> 8) & 0x0000ff;
+
+        writel(regno, par->dc_regs + DC_PAL_ADDRESS);
+        writel(val, par->dc_regs + DC_PAL_DATA);
+}
+
+struct geode_dc_ops gx_dc_ops = {
+        .set_mode        = gx_set_mode,
+        .set_palette_reg = gx_set_hw_palette_reg,
+};
diff --git a/drivers/video/geode/display_gx.h b/drivers/video/geode/display_gx.h
new file mode 100644
index 000000000000..86c623361305
--- /dev/null
+++ b/drivers/video/geode/display_gx.h
@@ -0,0 +1,96 @@
+/*
+ * Geode GX display controller
+ *
+ * Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#ifndef __DISPLAY_GX_H__
+#define __DISPLAY_GX_H__
+
+int gx_frame_buffer_size(void);
+int gx_line_delta(int xres, int bpp);
+
+extern struct geode_dc_ops gx_dc_ops;
+
+/* Display controller registers */
+
+#define DC_UNLOCK 0x00
+#  define DC_UNLOCK_CODE 0x00004758
+
+#define DC_GENERAL_CFG 0x04
+#  define DC_GCFG_DFLE        0x00000001
+#  define DC_GCFG_CURE        0x00000002
+#  define DC_GCFG_ICNE        0x00000004
+#  define DC_GCFG_VIDE        0x00000008
+#  define DC_GCFG_CMPE        0x00000020
+#  define DC_GCFG_DECE        0x00000040
+#  define DC_GCFG_VGAE        0x00000080
+#  define DC_GCFG_DFHPSL_MASK 0x00000F00
+#  define DC_GCFG_DFHPSL_POS           8
+#  define DC_GCFG_DFHPEL_MASK 0x0000F000
+#  define DC_GCFG_DFHPEL_POS          12
+#  define DC_GCFG_STFM        0x00010000
+#  define DC_GCFG_FDTY        0x00020000
+#  define DC_GCFG_VGAFT       0x00040000
+#  define DC_GCFG_VDSE        0x00080000
+#  define DC_GCFG_YUVM        0x00100000
+#  define DC_GCFG_VFSL        0x00800000
+#  define DC_GCFG_SIGE        0x01000000
+#  define DC_GCFG_SGRE        0x02000000
+#  define DC_GCFG_SGFR        0x04000000
+#  define DC_GCFG_CRC_MODE    0x08000000
+#  define DC_GCFG_DIAG        0x10000000
+#  define DC_GCFG_CFRW        0x20000000
+
+#define DC_DISPLAY_CFG 0x08
+#  define DC_DCFG_TGEN            0x00000001
+#  define DC_DCFG_GDEN            0x00000008
+#  define DC_DCFG_VDEN            0x00000010
+#  define DC_DCFG_TRUP            0x00000040
+#  define DC_DCFG_DISP_MODE_MASK  0x00000300
+#  define DC_DCFG_DISP_MODE_8BPP  0x00000000
+#  define DC_DCFG_DISP_MODE_16BPP 0x00000100
+#  define DC_DCFG_DISP_MODE_24BPP 0x00000200
+#  define DC_DCFG_16BPP_MODE_MASK 0x00000c00
+#  define DC_DCFG_16BPP_MODE_565  0x00000000
+#  define DC_DCFG_16BPP_MODE_555  0x00000100
+#  define DC_DCFG_16BPP_MODE_444  0x00000200
+#  define DC_DCFG_DCEN            0x00080000
+#  define DC_DCFG_PALB            0x02000000
+#  define DC_DCFG_FRLK            0x04000000
+#  define DC_DCFG_VISL            0x08000000
+#  define DC_DCFG_FRSL            0x20000000
+#  define DC_DCFG_A18M            0x40000000
+#  define DC_DCFG_A20M            0x80000000
+
+#define DC_FB_ST_OFFSET 0x10
+
+#define DC_LINE_SIZE 0x30
+#  define DC_LINE_SIZE_FB_LINE_SIZE_MASK  0x000007ff
+#  define DC_LINE_SIZE_FB_LINE_SIZE_POS            0
+#  define DC_LINE_SIZE_CB_LINE_SIZE_MASK  0x007f0000
+#  define DC_LINE_SIZE_CB_LINE_SIZE_POS           16
+#  define DC_LINE_SIZE_VID_LINE_SIZE_MASK 0xff000000
+#  define DC_LINE_SIZE_VID_LINE_SIZE_POS          24
+
+#define DC_GFX_PITCH 0x34
+#  define DC_GFX_PITCH_FB_PITCH_MASK 0x0000ffff
+#  define DC_GFX_PITCH_FB_PITCH_POS           0
+#  define DC_GFX_PITCH_CB_PITCH_MASK 0xffff0000
+#  define DC_GFX_PITCH_CB_PITCH_POS          16
+
+#define DC_H_ACTIVE_TIMING 0x40
+#define DC_H_BLANK_TIMING  0x44
+#define DC_H_SYNC_TIMING   0x48
+#define DC_V_ACTIVE_TIMING 0x50
+#define DC_V_BLANK_TIMING  0x54
+#define DC_V_SYNC_TIMING   0x58
+
+#define DC_PAL_ADDRESS 0x70
+#define DC_PAL_DATA    0x74
+
+#endif /* !__DISPLAY_GX1_H__ */
diff --git a/drivers/video/geode/gxfb_core.c b/drivers/video/geode/gxfb_core.c
new file mode 100644
index 000000000000..89c34b15f5d4
--- /dev/null
+++ b/drivers/video/geode/gxfb_core.c
@@ -0,0 +1,423 @@
+/*
+ * Geode GX framebuffer driver.
+ *
+ *   Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ *   This program is free software; you can redistribute it and/or modify it
+ *   under the terms of the GNU General Public License as published by the
+ *   Free Software Foundation; either version 2 of the License, or (at your
+ *   option) any later version.
+ *
+ *
+ * This driver assumes that the BIOS has created a virtual PCI device header
+ * for the video device. The PCI header is assumed to contain the following
+ * BARs:
+ *
+ *    BAR0 - framebuffer memory
+ *    BAR1 - graphics processor registers
+ *    BAR2 - display controller registers
+ *    BAR3 - video processor and flat panel control registers.
+ *
+ * 16 MiB of framebuffer memory is assumed to be available.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+
+#include "geodefb.h"
+#include "display_gx.h"
+#include "video_gx.h"
+
+static char mode_option[32] = "640x480-16@60";
+
+/* Modes relevant to the GX (taken from modedb.c) */
+static const struct fb_videomode __initdata gx_modedb[] = {
+        /* 640x480-60 VESA */
+        { NULL, 60, 640, 480, 39682,  48, 16, 33, 10, 96, 2,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 640x480-75 VESA */
+        { NULL, 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 640x480-85 VESA */
+        { NULL, 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 800x600-60 VESA */
+        { NULL, 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 800x600-75 VESA */
+        { NULL, 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 800x600-85 VESA */
+        { NULL, 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1024x768-60 VESA */
+        { NULL, 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1024x768-75 VESA */
+        { NULL, 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1024x768-85 VESA */
+        { NULL, 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x960-60 VESA */
+        { NULL, 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x960-85 VESA */
+        { NULL, 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x1024-60 VESA */
+        { NULL, 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x1024-75 VESA */
+        { NULL, 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x1024-85 VESA */
+        { NULL, 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1600x1200-60 VESA */
+        { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1600x1200-75 VESA */
+        { NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1600x1200-85 VESA */
+        { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+};
+
+static int gxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        if (var->xres > 1600 || var->yres > 1200)
+                return -EINVAL;
+        if ((var->xres > 1280 || var->yres > 1024) && var->bits_per_pixel > 16)
+                return -EINVAL;
+
+        if (var->bits_per_pixel == 32) {
+                var->red.offset   = 16; var->red.length   = 8;
+                var->green.offset =  8; var->green.length = 8;
+                var->blue.offset  =  0; var->blue.length  = 8;
+        } else if (var->bits_per_pixel == 16) {
+                var->red.offset   = 11; var->red.length   = 5;
+                var->green.offset =  5; var->green.length = 6;
+                var->blue.offset  =  0; var->blue.length  = 5;
+        } else if (var->bits_per_pixel == 8) {
+                var->red.offset   = 0; var->red.length   = 8;
+                var->green.offset = 0; var->green.length = 8;
+                var->blue.offset  = 0; var->blue.length  = 8;
+        } else
+                return -EINVAL;
+        var->transp.offset = 0; var->transp.length = 0;
+
+        /* Enough video memory? */
+        if (gx_line_delta(var->xres, var->bits_per_pixel) * var->yres > info->fix.smem_len)
+                return -EINVAL;
+
+        /* FIXME: Check timing parameters here? */
+
+        return 0;
+}
+
+static int gxfb_set_par(struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+
+        if (info->var.bits_per_pixel > 8) {
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
+                fb_dealloc_cmap(&info->cmap);
+        } else {
+                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                fb_alloc_cmap(&info->cmap, 1<<info->var.bits_per_pixel, 0);
+        }
+
+        info->fix.line_length = gx_line_delta(info->var.xres, info->var.bits_per_pixel);
+
+        par->dc_ops->set_mode(info);
+
+        return 0;
+}
+
+static inline u_int chan_to_field(u_int chan, struct fb_bitfield *bf)
+{
+        chan &= 0xffff;
+        chan >>= 16 - bf->length;
+        return chan << bf->offset;
+}
+
+static int gxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                           unsigned blue, unsigned transp,
+                           struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+
+        if (info->var.grayscale) {
+                /* grayscale = 0.30*R + 0.59*G + 0.11*B */
+                red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
+        }
+
+        /* Truecolor has hardware independent palette */
+        if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
+                u32 *pal = info->pseudo_palette;
+                u32 v;
+
+                if (regno >= 16)
+                        return -EINVAL;
+
+                v  = chan_to_field(red, &info->var.red);
+                v |= chan_to_field(green, &info->var.green);
+                v |= chan_to_field(blue, &info->var.blue);
+
+                pal[regno] = v;
+        } else {
+                if (regno >= 256)
+                        return -EINVAL;
+
+                par->dc_ops->set_palette_reg(info, regno, red, green, blue);
+        }
+
+        return 0;
+}
+
+static int gxfb_blank(int blank_mode, struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+
+        return par->vid_ops->blank_display(info, blank_mode);
+}
+
+static int __init gxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev)
+{
+        struct geodefb_par *par = info->par;
+        int fb_len;
+        int ret;
+
+        ret = pci_enable_device(dev);
+        if (ret < 0)
+                return ret;
+
+        ret = pci_request_region(dev, 3, "gxfb (video processor)");
+        if (ret < 0)
+                return ret;
+        par->vid_regs = ioremap(pci_resource_start(dev, 3),
+                                pci_resource_len(dev, 3));
+        if (!par->vid_regs)
+                return -ENOMEM;
+
+        ret = pci_request_region(dev, 2, "gxfb (display controller)");
+        if (ret < 0)
+                return ret;
+        par->dc_regs = ioremap(pci_resource_start(dev, 2), pci_resource_len(dev, 2));
+        if (!par->dc_regs)
+                return -ENOMEM;
+
+        ret = pci_request_region(dev, 0, "gxfb (framebuffer)");
+        if (ret < 0)
+                return ret;
+        if ((fb_len = gx_frame_buffer_size()) < 0)
+                return -ENOMEM;
+        info->fix.smem_start = pci_resource_start(dev, 0);
+        info->fix.smem_len = fb_len;
+        info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
+        if (!info->screen_base)
+                return -ENOMEM;
+
+        dev_info(&dev->dev, "%d Kibyte of video memory at 0x%lx\n",
+                 info->fix.smem_len / 1024, info->fix.smem_start);
+
+        return 0;
+}
+
+static struct fb_ops gxfb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_check_var   = gxfb_check_var,
+        .fb_set_par     = gxfb_set_par,
+        .fb_setcolreg   = gxfb_setcolreg,
+        .fb_blank       = gxfb_blank,
+        /* No HW acceleration for now. */
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+};
+
+static struct fb_info * __init gxfb_init_fbinfo(struct device *dev)
+{
+        struct geodefb_par *par;
+        struct fb_info *info;
+
+        /* Alloc enough space for the pseudo palette. */
+        info = framebuffer_alloc(sizeof(struct geodefb_par) + sizeof(u32) * 16, dev);
+        if (!info)
+                return NULL;
+
+        par = info->par;
+
+        strcpy(info->fix.id, "Geode GX");
+
+        info->fix.type          = FB_TYPE_PACKED_PIXELS;
+        info->fix.type_aux      = 0;
+        info->fix.xpanstep      = 0;
+        info->fix.ypanstep      = 0;
+        info->fix.ywrapstep     = 0;
+        info->fix.accel         = FB_ACCEL_NONE;
+
+        info->var.nonstd        = 0;
+        info->var.activate      = FB_ACTIVATE_NOW;
+        info->var.height        = -1;
+        info->var.width = -1;
+        info->var.accel_flags = 0;
+        info->var.vmode = FB_VMODE_NONINTERLACED;
+
+        info->fbops             = &gxfb_ops;
+        info->flags             = FBINFO_DEFAULT;
+        info->node              = -1;
+
+        info->pseudo_palette    = (void *)par + sizeof(struct geodefb_par);
+
+        info->var.grayscale     = 0;
+
+        return info;
+}
+
+static int __init gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        struct geodefb_par *par;
+        struct fb_info *info;
+        int ret;
+
+        info = gxfb_init_fbinfo(&pdev->dev);
+        if (!info)
+                return -ENOMEM;
+        par = info->par;
+
+        /* GX display controller and GX video device. */
+        par->dc_ops  = &gx_dc_ops;
+        par->vid_ops = &gx_vid_ops;
+
+        if ((ret = gxfb_map_video_memory(info, pdev)) < 0) {
+                dev_err(&pdev->dev, "failed to map frame buffer or controller registers\n");
+                goto err;
+        }
+
+        ret = fb_find_mode(&info->var, info, mode_option,
+                           gx_modedb, ARRAY_SIZE(gx_modedb), NULL, 16);
+        if (ret == 0 || ret == 4) {
+                dev_err(&pdev->dev, "could not find valid video mode\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* Clear the frame buffer of garbage. */
+        memset_io(info->screen_base, 0, info->fix.smem_len);
+
+        gxfb_check_var(&info->var, info);
+        gxfb_set_par(info);
+
+        if (register_framebuffer(info) < 0) {
+                ret = -EINVAL;
+                goto err;
+        }
+        pci_set_drvdata(pdev, info);
+        printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
+        return 0;
+
+  err:
+        if (info->screen_base) {
+                iounmap(info->screen_base);
+                pci_release_region(pdev, 0);
+        }
+        if (par->vid_regs) {
+                iounmap(par->vid_regs);
+                pci_release_region(pdev, 3);
+        }
+        if (par->dc_regs) {
+                iounmap(par->dc_regs);
+                pci_release_region(pdev, 2);
+        }
+
+        pci_disable_device(pdev);
+
+        if (info)
+                framebuffer_release(info);
+        return ret;
+}
+
+static void gxfb_remove(struct pci_dev *pdev)
+{
+        struct fb_info *info = pci_get_drvdata(pdev);
+        struct geodefb_par *par = info->par;
+
+        unregister_framebuffer(info);
+
+        iounmap((void __iomem *)info->screen_base);
+        pci_release_region(pdev, 0);
+
+        iounmap(par->vid_regs);
+        pci_release_region(pdev, 3);
+
+        iounmap(par->dc_regs);
+        pci_release_region(pdev, 2);
+
+        pci_disable_device(pdev);
+        pci_set_drvdata(pdev, NULL);
+
+        framebuffer_release(info);
+}
+
+static struct pci_device_id gxfb_id_table[] = {
+        { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_VIDEO,
+          PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16,
+          0xff0000, 0 },
+        { 0, }
+};
+
+MODULE_DEVICE_TABLE(pci, gxfb_id_table);
+
+static struct pci_driver gxfb_driver = {
+        .name           = "gxfb",
+        .id_table       = gxfb_id_table,
+        .probe          = gxfb_probe,
+        .remove         = gxfb_remove,
+};
+
+static int __init gxfb_init(void)
+{
+#ifndef MODULE
+        if (fb_get_options("gxfb", NULL))
+                return -ENODEV;
+#endif
+        return pci_register_driver(&gxfb_driver);
+}
+
+static void __exit gxfb_cleanup(void)
+{
+        pci_unregister_driver(&gxfb_driver);
+}
+
+module_init(gxfb_init);
+module_exit(gxfb_cleanup);
+
+module_param_string(mode, mode_option, sizeof(mode_option), 0444);
+MODULE_PARM_DESC(mode, "video mode (<x>x<y>[-<bpp>][@<refr>])");
+
+MODULE_DESCRIPTION("Framebuffer driver for the AMD Geode GX");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/geode/video_gx.c b/drivers/video/geode/video_gx.c
new file mode 100644
index 000000000000..2b2a7880ea75
--- /dev/null
+++ b/drivers/video/geode/video_gx.c
@@ -0,0 +1,262 @@
+/*
+ * Geode GX video processor device.
+ *
+ *   Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ *   Portions from AMD's original 2.4 driver:
+ *     Copyright (C) 2004 Advanced Micro Devices, Inc.
+ *
+ *   This program is free software; you can redistribute it and/or modify it
+ *   under the terms of the GNU General Public License as published by the
+ *   Free Software Foundation; either version 2 of the License, or (at your
+ *   option) any later version.
+ */
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#include <asm/delay.h>
+#include <asm/msr.h>
+
+#include "geodefb.h"
+#include "video_gx.h"
+
+
+/*
+ * Tables of register settings for various DOTCLKs.
+ */
+struct gx_pll_entry {
+        long pixclock; /* ps */
+        u32 sys_rstpll_bits;
+        u32 dotpll_value;
+};
+
+#define POSTDIV3 ((u32)MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3)
+#define PREMULT2 ((u32)MSR_GLCP_SYS_RSTPLL_DOTPREMULT2)
+#define PREDIV2  ((u32)MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3)
+
+static const struct gx_pll_entry gx_pll_table_48MHz[] = {
+        { 40123, POSTDIV3,          0x00000BF2 },       /*  24.9230 */
+        { 39721, 0,                 0x00000037 },       /*  25.1750 */
+        { 35308, POSTDIV3|PREMULT2, 0x00000B1A },       /*  28.3220 */
+        { 31746, POSTDIV3,          0x000002D2 },       /*  31.5000 */
+        { 27777, POSTDIV3|PREMULT2, 0x00000FE2 },       /*  36.0000 */
+        { 26666, POSTDIV3,          0x0000057A },       /*  37.5000 */
+        { 25000, POSTDIV3,          0x0000030A },       /*  40.0000 */
+        { 22271, 0,                 0x00000063 },       /*  44.9000 */
+        { 20202, 0,                 0x0000054B },       /*  49.5000 */
+        { 20000, 0,                 0x0000026E },       /*  50.0000 */
+        { 19860, PREMULT2,          0x00000037 },       /*  50.3500 */
+        { 18518, POSTDIV3|PREMULT2, 0x00000B0D },       /*  54.0000 */
+        { 17777, 0,                 0x00000577 },       /*  56.2500 */
+        { 17733, 0,                 0x000007F7 },       /*  56.3916 */
+        { 17653, 0,                 0x0000057B },       /*  56.6444 */
+        { 16949, PREMULT2,          0x00000707 },       /*  59.0000 */
+        { 15873, POSTDIV3|PREMULT2, 0x00000B39 },       /*  63.0000 */
+        { 15384, POSTDIV3|PREMULT2, 0x00000B45 },       /*  65.0000 */
+        { 14814, POSTDIV3|PREMULT2, 0x00000FC1 },       /*  67.5000 */
+        { 14124, POSTDIV3,          0x00000561 },       /*  70.8000 */
+        { 13888, POSTDIV3,          0x000007E1 },       /*  72.0000 */
+        { 13426, PREMULT2,          0x00000F4A },       /*  74.4810 */
+        { 13333, 0,                 0x00000052 },       /*  75.0000 */
+        { 12698, 0,                 0x00000056 },       /*  78.7500 */
+        { 12500, POSTDIV3|PREMULT2, 0x00000709 },       /*  80.0000 */
+        { 11135, PREMULT2,          0x00000262 },       /*  89.8000 */
+        { 10582, 0,                 0x000002D2 },       /*  94.5000 */
+        { 10101, PREMULT2,          0x00000B4A },       /*  99.0000 */
+        { 10000, PREMULT2,          0x00000036 },       /* 100.0000 */
+        {  9259, 0,                 0x000007E2 },       /* 108.0000 */
+        {  8888, 0,                 0x000007F6 },       /* 112.5000 */
+        {  7692, POSTDIV3|PREMULT2, 0x00000FB0 },       /* 130.0000 */
+        {  7407, POSTDIV3|PREMULT2, 0x00000B50 },       /* 135.0000 */
+        {  6349, 0,                 0x00000055 },       /* 157.5000 */
+        {  6172, 0,                 0x000009C1 },       /* 162.0000 */
+        {  5787, PREMULT2,          0x0000002D },       /* 172.798  */
+        {  5698, 0,                 0x000002C1 },       /* 175.5000 */
+        {  5291, 0,                 0x000002D1 },       /* 189.0000 */
+        {  4938, 0,                 0x00000551 },       /* 202.5000 */
+        {  4357, 0,                 0x0000057D },       /* 229.5000 */
+};
+
+static const struct gx_pll_entry gx_pll_table_14MHz[] = {
+        { 39721, 0, 0x00000037 },       /*  25.1750 */
+        { 35308, 0, 0x00000B7B },       /*  28.3220 */
+        { 31746, 0, 0x000004D3 },       /*  31.5000 */
+        { 27777, 0, 0x00000BE3 },       /*  36.0000 */
+        { 26666, 0, 0x0000074F },       /*  37.5000 */
+        { 25000, 0, 0x0000050B },       /*  40.0000 */
+        { 22271, 0, 0x00000063 },       /*  44.9000 */
+        { 20202, 0, 0x0000054B },       /*  49.5000 */
+        { 20000, 0, 0x0000026E },       /*  50.0000 */
+        { 19860, 0, 0x000007C3 },       /*  50.3500 */
+        { 18518, 0, 0x000007E3 },       /*  54.0000 */
+        { 17777, 0, 0x00000577 },       /*  56.2500 */
+        { 17733, 0, 0x000002FB },       /*  56.3916 */
+        { 17653, 0, 0x0000057B },       /*  56.6444 */
+        { 16949, 0, 0x0000058B },       /*  59.0000 */
+        { 15873, 0, 0x0000095E },       /*  63.0000 */
+        { 15384, 0, 0x0000096A },       /*  65.0000 */
+        { 14814, 0, 0x00000BC2 },       /*  67.5000 */
+        { 14124, 0, 0x0000098A },       /*  70.8000 */
+        { 13888, 0, 0x00000BE2 },       /*  72.0000 */
+        { 13333, 0, 0x00000052 },       /*  75.0000 */
+        { 12698, 0, 0x00000056 },       /*  78.7500 */
+        { 12500, 0, 0x0000050A },       /*  80.0000 */
+        { 11135, 0, 0x0000078E },       /*  89.8000 */
+        { 10582, 0, 0x000002D2 },       /*  94.5000 */
+        { 10101, 0, 0x000011F6 },       /*  99.0000 */
+        { 10000, 0, 0x0000054E },       /* 100.0000 */
+        {  9259, 0, 0x000007E2 },       /* 108.0000 */
+        {  8888, 0, 0x000002FA },       /* 112.5000 */
+        {  7692, 0, 0x00000BB1 },       /* 130.0000 */
+        {  7407, 0, 0x00000975 },       /* 135.0000 */
+        {  6349, 0, 0x00000055 },       /* 157.5000 */
+        {  6172, 0, 0x000009C1 },       /* 162.0000 */
+        {  5698, 0, 0x000002C1 },       /* 175.5000 */
+        {  5291, 0, 0x00000539 },       /* 189.0000 */
+        {  4938, 0, 0x00000551 },       /* 202.5000 */
+        {  4357, 0, 0x0000057D },       /* 229.5000 */
+};
+
+static void gx_set_dclk_frequency(struct fb_info *info)
+{
+        const struct gx_pll_entry *pll_table;
+        int pll_table_len;
+        int i, best_i;
+        long min, diff;
+        u64 dotpll, sys_rstpll;
+        int timeout = 1000;
+
+        /* Rev. 1 Geode GXs use a 14 MHz reference clock instead of 48 MHz. */
+        if (cpu_data->x86_mask == 1) {
+                pll_table = gx_pll_table_14MHz;
+                pll_table_len = ARRAY_SIZE(gx_pll_table_14MHz);
+        } else {
+                pll_table = gx_pll_table_48MHz;
+                pll_table_len = ARRAY_SIZE(gx_pll_table_48MHz);
+        }
+
+        /* Search the table for the closest pixclock. */
+        best_i = 0;
+        min = abs(pll_table[0].pixclock - info->var.pixclock);
+        for (i = 1; i < pll_table_len; i++) {
+                diff = abs(pll_table[i].pixclock - info->var.pixclock);
+                if (diff < min) {
+                        min = diff;
+                        best_i = i;
+                }
+        }
+
+        rdmsrl(MSR_GLCP_SYS_RSTPLL, sys_rstpll);
+        rdmsrl(MSR_GLCP_DOTPLL, dotpll);
+
+        /* Program new M, N and P. */
+        dotpll &= 0x00000000ffffffffull;
+        dotpll |= (u64)pll_table[best_i].dotpll_value << 32;
+        dotpll |= MSR_GLCP_DOTPLL_DOTRESET;
+        dotpll &= ~MSR_GLCP_DOTPLL_BYPASS;
+
+        wrmsrl(MSR_GLCP_DOTPLL, dotpll);
+
+        /* Program dividers. */
+        sys_rstpll &= ~( MSR_GLCP_SYS_RSTPLL_DOTPREDIV2
+                         | MSR_GLCP_SYS_RSTPLL_DOTPREMULT2
+                         | MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3 );
+        sys_rstpll |= pll_table[best_i].sys_rstpll_bits;
+
+        wrmsrl(MSR_GLCP_SYS_RSTPLL, sys_rstpll);
+
+        /* Clear reset bit to start PLL. */
+        dotpll &= ~(MSR_GLCP_DOTPLL_DOTRESET);
+        wrmsrl(MSR_GLCP_DOTPLL, dotpll);
+
+        /* Wait for LOCK bit. */
+        do {
+                rdmsrl(MSR_GLCP_DOTPLL, dotpll);
+        } while (timeout-- && !(dotpll & MSR_GLCP_DOTPLL_LOCK));
+}
+
+static void gx_configure_display(struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+        u32 dcfg, fp_pm;
+
+        dcfg = readl(par->vid_regs + GX_DCFG);
+
+        /* Clear bits from existing mode. */
+        dcfg &= ~(GX_DCFG_CRT_SYNC_SKW_MASK
+                  | GX_DCFG_CRT_HSYNC_POL   | GX_DCFG_CRT_VSYNC_POL
+                  | GX_DCFG_VSYNC_EN        | GX_DCFG_HSYNC_EN);
+
+        /* Set default sync skew.  */
+        dcfg |= GX_DCFG_CRT_SYNC_SKW_DFLT;
+
+        /* Enable hsync and vsync. */
+        dcfg |= GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN;
+
+        /* Sync polarities. */
+        if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
+                dcfg |= GX_DCFG_CRT_HSYNC_POL;
+        if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
+                dcfg |= GX_DCFG_CRT_VSYNC_POL;
+
+        writel(dcfg, par->vid_regs + GX_DCFG);
+
+        /* Power on flat panel. */
+        fp_pm = readl(par->vid_regs + GX_FP_PM);
+        fp_pm |= GX_FP_PM_P;
+        writel(fp_pm, par->vid_regs + GX_FP_PM);
+}
+
+static int gx_blank_display(struct fb_info *info, int blank_mode)
+{
+        struct geodefb_par *par = info->par;
+        u32 dcfg, fp_pm;
+        int blank, hsync, vsync;
+
+        /* CRT power saving modes. */
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+                blank = 0; hsync = 1; vsync = 1;
+                break;
+        case FB_BLANK_NORMAL:
+                blank = 1; hsync = 1; vsync = 1;
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+                blank = 1; hsync = 1; vsync = 0;
+                break;
+        case FB_BLANK_HSYNC_SUSPEND:
+                blank = 1; hsync = 0; vsync = 1;
+                break;
+        case FB_BLANK_POWERDOWN:
+                blank = 1; hsync = 0; vsync = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+        dcfg = readl(par->vid_regs + GX_DCFG);
+        dcfg &= ~(GX_DCFG_DAC_BL_EN
+                  | GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN);
+        if (!blank)
+                dcfg |= GX_DCFG_DAC_BL_EN;
+        if (hsync)
+                dcfg |= GX_DCFG_HSYNC_EN;
+        if (vsync)
+                dcfg |= GX_DCFG_VSYNC_EN;
+        writel(dcfg, par->vid_regs + GX_DCFG);
+
+        /* Power on/off flat panel. */
+        fp_pm = readl(par->vid_regs + GX_FP_PM);
+        if (blank_mode == FB_BLANK_POWERDOWN)
+                fp_pm &= ~GX_FP_PM_P;
+        else
+                fp_pm |= GX_FP_PM_P;
+        writel(fp_pm, par->vid_regs + GX_FP_PM);
+
+        return 0;
+}
+
+struct geode_vid_ops gx_vid_ops = {
+        .set_dclk          = gx_set_dclk_frequency,
+        .configure_display = gx_configure_display,
+        .blank_display     = gx_blank_display,
+};
diff --git a/drivers/video/geode/video_gx.h b/drivers/video/geode/video_gx.h
new file mode 100644
index 000000000000..2d9211f3ed84
--- /dev/null
+++ b/drivers/video/geode/video_gx.h
@@ -0,0 +1,47 @@
+/*
+ * Geode GX video device
+ *
+ * Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#ifndef __VIDEO_GX_H__
+#define __VIDEO_GX_H__
+
+extern struct geode_vid_ops gx_vid_ops;
+
+/* Geode GX video processor registers */
+
+#define GX_DCFG         0x0008
+#  define GX_DCFG_CRT_EN                0x00000001
+#  define GX_DCFG_HSYNC_EN              0x00000002
+#  define GX_DCFG_VSYNC_EN              0x00000004
+#  define GX_DCFG_DAC_BL_EN             0x00000008
+#  define GX_DCFG_CRT_HSYNC_POL         0x00000100
+#  define GX_DCFG_CRT_VSYNC_POL         0x00000200
+#  define GX_DCFG_CRT_SYNC_SKW_MASK     0x0001C000
+#  define GX_DCFG_CRT_SYNC_SKW_DFLT     0x00010000
+#  define GX_DCFG_VG_CK                 0x00100000
+#  define GX_DCFG_GV_GAM                0x00200000
+#  define GX_DCFG_DAC_VREF              0x04000000
+
+/* Geode GX flat panel display control registers */
+#define GX_FP_PM 0x410
+#  define GX_FP_PM_P 0x01000000
+
+/* Geode GX clock control MSRs */
+
+#define MSR_GLCP_SYS_RSTPLL     0x4c000014
+#  define MSR_GLCP_SYS_RSTPLL_DOTPREDIV2        (0x0000000000000002ull)
+#  define MSR_GLCP_SYS_RSTPLL_DOTPREMULT2       (0x0000000000000004ull)
+#  define MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3       (0x0000000000000008ull)
+
+#define MSR_GLCP_DOTPLL         0x4c000015
+#  define MSR_GLCP_DOTPLL_DOTRESET              (0x0000000000000001ull)
+#  define MSR_GLCP_DOTPLL_BYPASS                (0x0000000000008000ull)
+#  define MSR_GLCP_DOTPLL_LOCK                  (0x0000000002000000ull)
+
+#endif /* !__VIDEO_GX_H__ */
diff --git a/drivers/video/i810/i810-i2c.c b/drivers/video/i810/i810-i2c.c
index e3c8b5f1ca76..3fe3ae1aff12 100644
--- a/drivers/video/i810/i810-i2c.c
+++ b/drivers/video/i810/i810-i2c.c
@@ -210,8 +210,7 @@ int i810_probe_i2c_connector(struct fb_info *info, u8 **out_edid, int conn)
                 }
         }
 
-        if (out_edid)
-                *out_edid = edid;
+        *out_edid = edid;
 
         return (edid) ? 0 : 1;
 }
diff --git a/drivers/video/imsttfb.c b/drivers/video/imsttfb.c
index 7db42542eb19..f73c642b50c2 100644
--- a/drivers/video/imsttfb.c
+++ b/drivers/video/imsttfb.c
@@ -440,9 +440,9 @@ getclkMHz(struct imstt_par *par)
 static void
 setclkMHz(struct imstt_par *par, __u32 MHz)
 {
-        __u32 clk_m, clk_n, clk_p, x, stage, spilled;
+        __u32 clk_m, clk_n, x, stage, spilled;
 
-        clk_m = clk_n = clk_p = 0;
+        clk_m = clk_n = 0;
         stage = spilled = 0;
         for (;;) {
                 switch (stage) {
@@ -453,7 +453,7 @@ setclkMHz(struct imstt_par *par, __u32 MHz)
                                 clk_n++;
                                 break;
                 }
-                x = 20 * (clk_m + 1) / ((clk_n + 1) * (clk_p ? 2 * clk_p : 1));
+                x = 20 * (clk_m + 1) / (clk_n + 1);
                 if (x == MHz)
                         break;
                 if (x > MHz) {
@@ -466,7 +466,7 @@ setclkMHz(struct imstt_par *par, __u32 MHz)
 
         par->init.pclk_m = clk_m;
         par->init.pclk_n = clk_n;
-        par->init.pclk_p = clk_p;
+        par->init.pclk_p = 0;
 }
 
 static struct imstt_regvals *
@@ -1372,18 +1372,24 @@ init_imstt(struct fb_info *info)
         write_reg_le32(par->dc_regs, STGCTL, tmp & ~0x1);
         write_reg_le32(par->dc_regs, SSR, 0);
 
-        /* set default values for DAC registers */ 
+        /* set default values for DAC registers */
         if (par->ramdac == IBM) {
-                par->cmap_regs[PPMASK] = 0xff;  eieio();
-                par->cmap_regs[PIDXHI] = 0;     eieio();
-                for (i = 0; i < sizeof(ibm_initregs) / sizeof(*ibm_initregs); i++) {
-                        par->cmap_regs[PIDXLO] = ibm_initregs[i].addr;  eieio();
-                        par->cmap_regs[PIDXDATA] = ibm_initregs[i].value;       eieio();
+                par->cmap_regs[PPMASK] = 0xff;
+                eieio();
+                par->cmap_regs[PIDXHI] = 0;
+                eieio();
+                for (i = 0; i < ARRAY_SIZE(ibm_initregs); i++) {
+                        par->cmap_regs[PIDXLO] = ibm_initregs[i].addr;
+                        eieio();
+                        par->cmap_regs[PIDXDATA] = ibm_initregs[i].value;
+                        eieio();
                 }
         } else {
-                for (i = 0; i < sizeof(tvp_initregs) / sizeof(*tvp_initregs); i++) {
-                        par->cmap_regs[TVPADDRW] = tvp_initregs[i].addr;        eieio();
-                        par->cmap_regs[TVPIDATA] = tvp_initregs[i].value;       eieio();
+                for (i = 0; i < ARRAY_SIZE(tvp_initregs); i++) {
+                        par->cmap_regs[TVPADDRW] = tvp_initregs[i].addr;
+                        eieio();
+                        par->cmap_regs[TVPIDATA] = tvp_initregs[i].value;
+                        eieio();
                 }
         }
 
diff --git a/drivers/video/macmodes.c b/drivers/video/macmodes.c
index 2fc71081f7e7..c0385c6f7db5 100644
--- a/drivers/video/macmodes.c
+++ b/drivers/video/macmodes.c
@@ -380,7 +380,7 @@ int __init mac_find_mode(struct fb_var_screeninfo *var, struct fb_info *info,
     if (mode_option && !strncmp(mode_option, "mac", 3)) {
         mode_option += 3;
         db = mac_modedb;
-        dbsize = sizeof(mac_modedb)/sizeof(*mac_modedb);
+        dbsize = ARRAY_SIZE(mac_modedb);
     }
     return fb_find_mode(var, info, mode_option, db, dbsize,
                         &mac_modedb[DEFAULT_MODEDB_INDEX], default_bpp);
diff --git a/drivers/video/matrox/matroxfb_g450.c b/drivers/video/matrox/matroxfb_g450.c
index c122d8743dd2..4d610b405d45 100644
--- a/drivers/video/matrox/matroxfb_g450.c
+++ b/drivers/video/matrox/matroxfb_g450.c
@@ -59,7 +59,7 @@ static const struct mctl g450_controls[] =
         }, offsetof(struct matrox_fb_info, altout.tvo_params.testout) },
 };
 
-#define G450CTRLS (sizeof(g450_controls)/sizeof(g450_controls[0]))
+#define G450CTRLS ARRAY_SIZE(g450_controls)
 
 /* Return: positive number: id found
            -EINVAL:         id not found, return failure
diff --git a/drivers/video/matrox/matroxfb_maven.c b/drivers/video/matrox/matroxfb_maven.c
index 6019710dc298..5d29a26b8cdf 100644
--- a/drivers/video/matrox/matroxfb_maven.c
+++ b/drivers/video/matrox/matroxfb_maven.c
@@ -89,12 +89,12 @@ static const struct mctl maven_controls[] =
         }, offsetof(struct matrox_fb_info, altout.tvo_params.hue) },
         { { V4L2_CID_GAMMA, V4L2_CTRL_TYPE_INTEGER,
           "gamma",
-          0, sizeof(maven_gamma)/sizeof(maven_gamma[0])-1, 1, 3,
+          0, ARRAY_SIZE(maven_gamma) - 1, 1, 3,
           0,
         }, offsetof(struct matrox_fb_info, altout.tvo_params.gamma) },
         { { MATROXFB_CID_TESTOUT, V4L2_CTRL_TYPE_BOOLEAN,
           "test output",
-          0, 1, 1, 0, 
+          0, 1, 1, 0,
           0,
         }, offsetof(struct matrox_fb_info, altout.tvo_params.testout) },
         { { MATROXFB_CID_DEFLICKER, V4L2_CTRL_TYPE_INTEGER,
@@ -105,7 +105,7 @@ static const struct mctl maven_controls[] =
 
 };
 
-#define MAVCTRLS (sizeof(maven_controls)/sizeof(maven_controls[0]))
+#define MAVCTRLS ARRAY_SIZE(maven_controls)
 
 /* Return: positive number: id found
            -EINVAL:         id not found, return failure
@@ -129,7 +129,7 @@ static int get_ctrl_id(__u32 v4l2_id) {
 
 struct maven_data {
         struct matrox_fb_info*          primary_head;
-        struct i2c_client*              client;
+        struct i2c_client               client;
         int                             version;
 };
 
@@ -970,7 +970,7 @@ static inline int maven_compute_timming(struct maven_data* md,
 
 static int maven_program_timming(struct maven_data* md,
                 const struct mavenregs* m) {
-        struct i2c_client* c = md->client;
+        struct i2c_client* c = &md->client;
 
         if (m->mode == MATROXFB_OUTPUT_MODE_MONITOR) {
                 LR(0x80);
@@ -1007,7 +1007,7 @@ static int maven_program_timming(struct maven_data* md,
 }
 
 static inline int maven_resync(struct maven_data* md) {
-        struct i2c_client* c = md->client;
+        struct i2c_client* c = &md->client;
         maven_set_reg(c, 0x95, 0x20);   /* start whole thing */
         return 0;
 }
@@ -1065,48 +1065,48 @@ static int maven_set_control (struct maven_data* md,
                   maven_compute_bwlevel(md, &blacklevel, &whitelevel);
                   blacklevel = (blacklevel >> 2) | ((blacklevel & 3) << 8);
                   whitelevel = (whitelevel >> 2) | ((whitelevel & 3) << 8);
-                  maven_set_reg_pair(md->client, 0x0e, blacklevel);
-                  maven_set_reg_pair(md->client, 0x1e, whitelevel);
+                  maven_set_reg_pair(&md->client, 0x0e, blacklevel);
+                  maven_set_reg_pair(&md->client, 0x1e, whitelevel);
                 }
                 break;
                 case V4L2_CID_SATURATION:
                 {
-                  maven_set_reg(md->client, 0x20, p->value);
-                  maven_set_reg(md->client, 0x22, p->value);
+                  maven_set_reg(&md->client, 0x20, p->value);
+                  maven_set_reg(&md->client, 0x22, p->value);
                 }
                 break;
                 case V4L2_CID_HUE:
                 {
-                  maven_set_reg(md->client, 0x25, p->value);
+                  maven_set_reg(&md->client, 0x25, p->value);
                 }
                 break;
                 case V4L2_CID_GAMMA:
                 {
                   const struct maven_gamma* g;
                   g = maven_compute_gamma(md);
-                  maven_set_reg(md->client, 0x83, g->reg83);
-                  maven_set_reg(md->client, 0x84, g->reg84);
-                  maven_set_reg(md->client, 0x85, g->reg85);
-                  maven_set_reg(md->client, 0x86, g->reg86);
-                  maven_set_reg(md->client, 0x87, g->reg87);
-                  maven_set_reg(md->client, 0x88, g->reg88);
-                  maven_set_reg(md->client, 0x89, g->reg89);
-                  maven_set_reg(md->client, 0x8a, g->reg8a);
-                  maven_set_reg(md->client, 0x8b, g->reg8b);
+                  maven_set_reg(&md->client, 0x83, g->reg83);
+                  maven_set_reg(&md->client, 0x84, g->reg84);
+                  maven_set_reg(&md->client, 0x85, g->reg85);
+                  maven_set_reg(&md->client, 0x86, g->reg86);
+                  maven_set_reg(&md->client, 0x87, g->reg87);
+                  maven_set_reg(&md->client, 0x88, g->reg88);
+                  maven_set_reg(&md->client, 0x89, g->reg89);
+                  maven_set_reg(&md->client, 0x8a, g->reg8a);
+                  maven_set_reg(&md->client, 0x8b, g->reg8b);
                 }
                 break;
                 case MATROXFB_CID_TESTOUT:
                 {
                         unsigned char val 
-                          = maven_get_reg (md->client,0x8d);
+                          = maven_get_reg(&md->client,0x8d);
                         if (p->value) val |= 0x10;
                         else          val &= ~0x10;
-                        maven_set_reg (md->client, 0x8d, val);
+                        maven_set_reg(&md->client, 0x8d, val);
                 }
                 break;
                 case MATROXFB_CID_DEFLICKER:
                 {
-                  maven_set_reg(md->client, 0x93, maven_compute_deflicker(md));
+                  maven_set_reg(&md->client, 0x93, maven_compute_deflicker(md));
                 }
                 break;
         }
@@ -1185,7 +1185,6 @@ static int maven_init_client(struct i2c_client* clnt) {
         MINFO_FROM(container_of(clnt->adapter, struct i2c_bit_adapter, adapter)->minfo);
 
         md->primary_head = MINFO;
-        md->client = clnt;
         down_write(&ACCESS_FBINFO(altout.lock));
         ACCESS_FBINFO(outputs[1]).output = &maven_altout;
         ACCESS_FBINFO(outputs[1]).src = ACCESS_FBINFO(outputs[1]).default_src;
@@ -1243,19 +1242,17 @@ static int maven_detect_client(struct i2c_adapter* adapter, int address, int kin
                                               I2C_FUNC_SMBUS_BYTE_DATA |
                                               I2C_FUNC_PROTOCOL_MANGLING))
                 goto ERROR0;
-        if (!(new_client = (struct i2c_client*)kmalloc(sizeof(*new_client) + sizeof(*data),
-                        GFP_KERNEL))) {
+        if (!(data = kzalloc(sizeof(*data), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto ERROR0;
         }
-        memset(new_client, 0, sizeof(*new_client) + sizeof(*data));
-        data = (struct maven_data*)(new_client + 1);
+        new_client = &data->client;
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
         new_client->adapter = adapter;
         new_client->driver = &maven_driver;
         new_client->flags = 0;
-        strcpy(new_client->name, "maven client");
+        strlcpy(new_client->name, "maven", I2C_NAME_SIZE);
         if ((err = i2c_attach_client(new_client)))
                 goto ERROR3;
         err = maven_init_client(new_client);
@@ -1279,12 +1276,10 @@ static int maven_attach_adapter(struct i2c_adapter* adapter) {
 static int maven_detach_client(struct i2c_client* client) {
         int err;
 
-        if ((err = i2c_detach_client(client))) {
-                printk(KERN_ERR "maven: Cannot deregister client\n");
+        if ((err = i2c_detach_client(client)))
                 return err;
-        }
         maven_shutdown_client(client);
-        kfree(client);
+        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
@@ -1297,20 +1292,13 @@ static struct i2c_driver maven_driver={
         .detach_client  = maven_detach_client,
 };
 
-/* ************************** */
-
-static int matroxfb_maven_init(void) {
-        int err;
-
-        err = i2c_add_driver(&maven_driver);
-        if (err) {
-                printk(KERN_ERR "maven: Maven driver failed to register (%d).\n", err);
-                return err;
-        }
-        return 0;
+static int __init matroxfb_maven_init(void)
+{
+        return i2c_add_driver(&maven_driver);
 }
 
-static void matroxfb_maven_exit(void) {
+static void __exit matroxfb_maven_exit(void)
+{
         i2c_del_driver(&maven_driver);
 }
 
diff --git a/drivers/video/modedb.c b/drivers/video/modedb.c
index 1da2f84bdc25..26a1c618a205 100644
--- a/drivers/video/modedb.c
+++ b/drivers/video/modedb.c
@@ -183,6 +183,10 @@ static const struct fb_videomode modedb[] = {
         NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
         FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
     }, {
+        /* 1680x1050 @ 60 Hz, 65.191 kHz hsync */
+        NULL, 60, 1680, 1050, 6848, 280, 104, 30, 3, 176, 6,
+        FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
+    }, {
         /* 1600x1200 @ 85 Hz, 105.77 kHz hsync */
         NULL, 85, 1600, 1200, 4545, 272, 16, 37, 4, 192, 3,
         FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
@@ -496,7 +500,7 @@ int fb_find_mode(struct fb_var_screeninfo *var,
     /* Set up defaults */
     if (!db) {
         db = modedb;
-        dbsize = sizeof(modedb)/sizeof(*modedb);
+        dbsize = ARRAY_SIZE(modedb);
     }
     if (!default_mode)
         default_mode = &modedb[DEFAULT_MODEDB_INDEX];
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index b961d5601bd9..24b12f71d5a8 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -165,20 +165,20 @@ static int neoFindMode(int xres, int yres, int depth)
 
         switch (depth) {
         case 8:
-                size = sizeof(bios8) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios8);
                 mode = bios8;
                 break;
         case 16:
-                size = sizeof(bios16) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios16);
                 mode = bios16;
                 break;
         case 24:
-                size = sizeof(bios24) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios24);
                 mode = bios24;
                 break;
 #ifdef NO_32BIT_SUPPORT_YET
         case 32:
-                size = sizeof(bios32) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios32);
                 mode = bios32;
                 break;
 #endif
diff --git a/drivers/video/nvidia/nv_accel.c b/drivers/video/nvidia/nv_accel.c
index f377a29ec97a..4aefb8f41637 100644
--- a/drivers/video/nvidia/nv_accel.c
+++ b/drivers/video/nvidia/nv_accel.c
@@ -300,6 +300,9 @@ int nvidiafb_sync(struct fb_info *info)
 {
         struct nvidia_par *par = info->par;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return 0;
+
         if (!par->lockup)
                 NVFlush(par);
 
@@ -313,6 +316,9 @@ void nvidiafb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
         struct nvidia_par *par = info->par;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+
         if (par->lockup)
                 return cfb_copyarea(info, region);
 
@@ -329,6 +335,9 @@ void nvidiafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
         struct nvidia_par *par = info->par;
         u32 color;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+
         if (par->lockup)
                 return cfb_fillrect(info, rect);
 
@@ -412,6 +421,9 @@ void nvidiafb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct nvidia_par *par = info->par;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+
         if (image->depth == 1 && !par->lockup)
                 nvidiafb_mono_color_expand(info, image);
         else
diff --git a/drivers/video/nvidia/nv_i2c.c b/drivers/video/nvidia/nv_i2c.c
index bd9eca05e146..1edb1c432b75 100644
--- a/drivers/video/nvidia/nv_i2c.c
+++ b/drivers/video/nvidia/nv_i2c.c
@@ -218,8 +218,7 @@ int nvidia_probe_i2c_connector(struct fb_info *info, int conn, u8 **out_edid)
                 }
         }
 
-        if (out_edid)
-                *out_edid = edid;
+        *out_edid = edid;
 
         return (edid) ? 0 : 1;
 }
diff --git a/drivers/video/nvidia/nv_type.h b/drivers/video/nvidia/nv_type.h
index e4a5b1da71c4..acdc26693402 100644
--- a/drivers/video/nvidia/nv_type.h
+++ b/drivers/video/nvidia/nv_type.h
@@ -129,6 +129,7 @@ struct nvidia_par {
         int fpHeight;
         int PanelTweak;
         int paneltweak;
+        int pm_state;
         u32 crtcSync_read;
         u32 fpSyncs;
         u32 dmaPut;
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index a7c4e5e8ead6..6d3e4890cb43 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -21,6 +21,7 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/pci.h>
+#include <linux/console.h>
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
 #endif
@@ -296,6 +297,8 @@ static struct pci_device_id nvidiafb_pci_tbl[] = {
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_GT,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_QUADRO_NVS280,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, 0x0252,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, 0x0313,
@@ -615,6 +618,30 @@ static int nvidia_panel_tweak(struct nvidia_par *par,
    return tweak;
 }
 
+static void nvidia_vga_protect(struct nvidia_par *par, int on)
+{
+        unsigned char tmp;
+
+        if (on) {
+                /*
+                 * Turn off screen and disable sequencer.
+                 */
+                tmp = NVReadSeq(par, 0x01);
+
+                NVWriteSeq(par, 0x00, 0x01);            /* Synchronous Reset */
+                NVWriteSeq(par, 0x01, tmp | 0x20);      /* disable the display */
+        } else {
+                /*
+                 * Reenable sequencer, then turn on screen.
+                 */
+
+                tmp = NVReadSeq(par, 0x01);
+
+                NVWriteSeq(par, 0x01, tmp & ~0x20);     /* reenable display */
+                NVWriteSeq(par, 0x00, 0x03);            /* End Reset */
+        }
+}
+
 static void nvidia_save_vga(struct nvidia_par *par,
                             struct _riva_hw_state *state)
 {
@@ -643,9 +670,9 @@ static void nvidia_save_vga(struct nvidia_par *par,
 
 #undef DUMP_REG
 
-static void nvidia_write_regs(struct nvidia_par *par)
+static void nvidia_write_regs(struct nvidia_par *par,
+                              struct _riva_hw_state *state)
 {
-        struct _riva_hw_state *state = &par->ModeReg;
         int i;
 
         NVTRACE_ENTER();
@@ -694,32 +721,6 @@ static void nvidia_write_regs(struct nvidia_par *par)
         NVTRACE_LEAVE();
 }
 
-static void nvidia_vga_protect(struct nvidia_par *par, int on)
-{
-        unsigned char tmp;
-
-        if (on) {
-                /*
-                 * Turn off screen and disable sequencer.
-                 */
-                tmp = NVReadSeq(par, 0x01);
-
-                NVWriteSeq(par, 0x00, 0x01);            /* Synchronous Reset */
-                NVWriteSeq(par, 0x01, tmp | 0x20);      /* disable the display */
-        } else {
-                /*
-                 * Reenable sequencer, then turn on screen.
-                 */
-
-                tmp = NVReadSeq(par, 0x01);
-
-                NVWriteSeq(par, 0x01, tmp & ~0x20);     /* reenable display */
-                NVWriteSeq(par, 0x00, 0x03);            /* End Reset */
-        }
-}
-
-
-
 static int nvidia_calc_regs(struct fb_info *info)
 {
         struct nvidia_par *par = info->par;
@@ -1068,7 +1069,8 @@ static int nvidiafb_set_par(struct fb_info *info)
 
         nvidia_vga_protect(par, 1);
 
-        nvidia_write_regs(par);
+        nvidia_write_regs(par, &par->ModeReg);
+        NVSetStartAddress(par, 0);
 
 #if defined (__BIG_ENDIAN)
         /* turn on LFB swapping */
@@ -1377,6 +1379,57 @@ static struct fb_ops nvidia_fb_ops = {
         .fb_sync        = nvidiafb_sync,
 };
 
+#ifdef CONFIG_PM
+static int nvidiafb_suspend(struct pci_dev *dev, pm_message_t state)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct nvidia_par *par = info->par;
+
+        acquire_console_sem();
+        par->pm_state = state.event;
+
+        if (state.event == PM_EVENT_FREEZE) {
+                dev->dev.power.power_state = state;
+        } else {
+                fb_set_suspend(info, 1);
+                nvidiafb_blank(FB_BLANK_POWERDOWN, info);
+                nvidia_write_regs(par, &par->SavedReg);
+                pci_save_state(dev);
+                pci_disable_device(dev);
+                pci_set_power_state(dev, pci_choose_state(dev, state));
+        }
+
+        release_console_sem();
+        return 0;
+}
+
+static int nvidiafb_resume(struct pci_dev *dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct nvidia_par *par = info->par;
+
+        acquire_console_sem();
+        pci_set_power_state(dev, PCI_D0);
+
+        if (par->pm_state != PM_EVENT_FREEZE) {
+                pci_restore_state(dev);
+                pci_enable_device(dev);
+                pci_set_master(dev);
+        }
+
+        par->pm_state = PM_EVENT_ON;
+        nvidiafb_set_par(info);
+        fb_set_suspend (info, 0);
+        nvidiafb_blank(FB_BLANK_UNBLANK, info);
+
+        release_console_sem();
+        return 0;
+}
+#else
+#define nvidiafb_suspend NULL
+#define nvidiafb_resume NULL
+#endif
+
 static int __devinit nvidia_set_fbinfo(struct fb_info *info)
 {
         struct fb_monspecs *specs = &info->monspecs;
@@ -1720,8 +1773,6 @@ static void __exit nvidiafb_remove(struct pci_dev *pd)
         struct nvidia_par *par = info->par;
 
         NVTRACE_ENTER();
-        if (!info)
-                return;
 
         unregister_framebuffer(info);
 #ifdef CONFIG_MTRR
@@ -1798,8 +1849,10 @@ static int __devinit nvidiafb_setup(char *options)
 static struct pci_driver nvidiafb_driver = {
         .name = "nvidiafb",
         .id_table = nvidiafb_pci_tbl,
-        .probe = nvidiafb_probe,
-        .remove = __exit_p(nvidiafb_remove),
+        .probe    = nvidiafb_probe,
+        .suspend  = nvidiafb_suspend,
+        .resume   = nvidiafb_resume,
+        .remove   = __exit_p(nvidiafb_remove),
 };
 
 /* ------------------------------------------------------------------------- *
diff --git a/drivers/video/pmagb-b-fb.c b/drivers/video/pmagb-b-fb.c
index eeeac924b500..73e2d7d16608 100644
--- a/drivers/video/pmagb-b-fb.c
+++ b/drivers/video/pmagb-b-fb.c
@@ -228,7 +228,7 @@ static void __init pmagbbfb_osc_setup(struct fb_info *info)
 
         freq1 = (par->osc0 * count1 + count0 / 2) / count0;
         par->osc1 = freq1;
-        for (i = 0; i < sizeof(pmagbbfb_freqs) / sizeof(*pmagbbfb_freqs); i++)
+        for (i = 0; i < ARRAY_SIZE(pmagbbfb_freqs); i++)
                 if (freq1 >= pmagbbfb_freqs[i] -
                              (pmagbbfb_freqs[i] + 128) / 256 &&
                     freq1 <= pmagbbfb_freqs[i] +
diff --git a/drivers/video/radeonfb.c b/drivers/video/radeonfb.c
index db9fb9074dbc..24982adb3aa2 100644
--- a/drivers/video/radeonfb.c
+++ b/drivers/video/radeonfb.c
@@ -759,7 +759,7 @@ static void __iomem *radeon_find_rom(struct radeonfb_info *rinfo)
                 rom = rom_base;
         
                 for (i = 0; (i < 512) && (stage != 4); i++) {
-                    for(j = 0;j < sizeof(radeon_sig)/sizeof(char *);j++) {
+                    for (j = 0; j < ARRAY_SIZE(radeon_sig); j++) {
                         if (radeon_sig[j][0] == *rom)
                                 if (strncmp(radeon_sig[j], rom,
                                             strlen(radeon_sig[j])) == 0) {
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 6c19ab6afb01..f841f013b96f 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -2072,8 +2072,6 @@ static void __exit rivafb_remove(struct pci_dev *pd)
         struct riva_par *par = info->par;
         
         NVTRACE_ENTER();
-        if (!info)
-                return;
 
 #ifdef CONFIG_FB_RIVA_I2C
         riva_delete_i2c_busses(par);
diff --git a/drivers/video/savage/savagefb-i2c.c b/drivers/video/savage/savagefb-i2c.c
index 00719a91479f..21debed863ac 100644
--- a/drivers/video/savage/savagefb-i2c.c
+++ b/drivers/video/savage/savagefb-i2c.c
@@ -273,8 +273,7 @@ int savagefb_probe_i2c_connector(struct fb_info *info, u8 **out_edid)
                 }
         }
 
-        if (out_edid)
-                *out_edid = edid;
+        *out_edid = edid;
 
         return (edid) ? 0 : 1;
 }
diff --git a/drivers/video/sis/init301.c b/drivers/video/sis/init301.c
index 2d88f908170a..c3e070a6effd 100644
--- a/drivers/video/sis/init301.c
+++ b/drivers/video/sis/init301.c
@@ -8564,11 +8564,9 @@ SiS_ChrontelDoSomething3(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
 static void
 SiS_ChrontelDoSomething2(struct SiS_Private *SiS_Pr)
 {
-     unsigned short temp,tempcl,tempch;
+     unsigned short temp;
 
      SiS_LongDelay(SiS_Pr, 1);
-     tempcl = 3;
-     tempch = 0;
 
      do {
        temp = SiS_GetCH701x(SiS_Pr,0x66);
@@ -8582,13 +8580,6 @@ SiS_ChrontelDoSomething2(struct SiS_Private *SiS_Pr)
 
        SiS_SetCH701xForLCD(SiS_Pr);
 
-       if(tempcl == 0) {
-           if(tempch == 3) break;
-           SiS_ChrontelResetDB(SiS_Pr);
-           tempcl = 3;
-           tempch++;
-       }
-       tempcl--;
        temp = SiS_GetCH701x(SiS_Pr,0x76);
        temp &= 0xfb;  /* Reset PLL */
        SiS_SetCH701x(SiS_Pr,0x76,temp);
diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c
index 8c1a8b5135c6..c44de90ca12e 100644
--- a/drivers/video/sstfb.c
+++ b/drivers/video/sstfb.c
@@ -1194,10 +1194,11 @@ static struct dac_switch dacs[] __devinitdata = {
 static int __devinit sst_detect_dactype(struct fb_info *info, struct sstfb_par *par)
 {
         int i, ret = 0;
-        
-        for (i=0; i<sizeof(dacs)/sizeof(dacs[0]); i++) {
+
+        for (i = 0; i < ARRAY_SIZE(dacs); i++) {
                 ret = dacs[i].detect(info);
-                if (ret) break;
+                if (ret)
+                        break;
         }
         if (!ret)
                 return 0;
@@ -1604,8 +1605,8 @@ static int sstfb_dump_regs(struct fb_info *info)
                 {FBZMODE,"fbzmode"},
         };
 
-        const int pci_s = sizeof(pci_regs)/sizeof(pci_regs[0]);
-        const int sst_s = sizeof(sst_regs)/sizeof(sst_regs[0]);
+        const int pci_s = ARRAY_SIZE(pci_regs);
+        const int sst_s = ARRAY_SIZE(sst_regs);
         struct sstfb_par *par = info->par;
         struct pci_dev *dev = par->dev;
         u32 pci_res[pci_s];
diff --git a/drivers/video/virgefb.c b/drivers/video/virgefb.c
index ed78747487e2..5ea2345dab99 100644
--- a/drivers/video/virgefb.c
+++ b/drivers/video/virgefb.c
@@ -616,8 +616,7 @@ static struct {
 #endif
 };
 
-#define arraysize(x)    (sizeof(x)/sizeof(*(x)))
-#define NUM_TOTAL_MODES arraysize(virgefb_predefined)
+#define NUM_TOTAL_MODES ARRAY_SIZE(virgefb_predefined)
 
 /*
  *    Default to 800x600 for video=virge8:, virge16: or virge32:
diff --git a/fs/autofs/dirhash.c b/fs/autofs/dirhash.c
index 5ccfcf26310d..3fded389d06b 100644
--- a/fs/autofs/dirhash.c
+++ b/fs/autofs/dirhash.c
@@ -92,7 +92,7 @@ struct autofs_dir_ent *autofs_expire(struct super_block *sb,
                         ;
                 dput(dentry);
 
-                if ( may_umount(mnt) == 0 ) {
+                if ( may_umount(mnt) ) {
                         mntput(mnt);
                         DPRINTK(("autofs: signaling expire on %s\n", ent->name));
                         return ent; /* Expirable! */
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index f54c5b21f876..617fd7b37447 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -3,6 +3,7 @@
  * linux/fs/autofs/autofs_i.h
  *
  *   Copyright 1997-1998 Transmeta Corporation - All Rights Reserved
+ *   Copyright 2005-2006 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -41,14 +42,6 @@
 
 #define AUTOFS_SUPER_MAGIC 0x0187
 
-/*
- * If the daemon returns a negative response (AUTOFS_IOC_FAIL) then the
- * kernel will keep the negative response cached for up to the time given
- * here, although the time can be shorter if the kernel throws the dcache
- * entry away.  This probably should be settable from user space.
- */
-#define AUTOFS_NEGATIVE_TIMEOUT (60*HZ) /* 1 minute */
-
 /* Unified info structure.  This is pointed to by both the dentry and
    inode structures.  Each file in the filesystem has an instance of this
    structure.  It holds a reference to the dentry, so dentries are never
@@ -63,6 +56,7 @@ struct autofs_info {
 
         struct autofs_sb_info *sbi;
         unsigned long last_used;
+        atomic_t count;
 
         mode_t  mode;
         size_t  size;
@@ -83,23 +77,37 @@ struct autofs_wait_queue {
         int hash;
         int len;
         char *name;
+        u32 dev;
+        u64 ino;
+        uid_t uid;
+        gid_t gid;
+        pid_t pid;
+        pid_t tgid;
         /* This is for status reporting upon return */
         int status;
-        atomic_t notified;
+        atomic_t notify;
         atomic_t wait_ctr;
 };
 
 #define AUTOFS_SBI_MAGIC 0x6d4a556d
 
+#define AUTOFS_TYPE_INDIRECT     0x0001
+#define AUTOFS_TYPE_DIRECT       0x0002
+#define AUTOFS_TYPE_OFFSET       0x0004
+
 struct autofs_sb_info {
         u32 magic;
         struct dentry *root;
+        int pipefd;
         struct file *pipe;
         pid_t oz_pgrp;
         int catatonic;
         int version;
         int sub_version;
+        int min_proto;
+        int max_proto;
         unsigned long exp_timeout;
+        unsigned int type;
         int reghost_enabled;
         int needs_reghost;
         struct super_block *sb;
@@ -166,6 +174,8 @@ int autofs4_expire_multi(struct super_block *, struct vfsmount *,
 extern struct inode_operations autofs4_symlink_inode_operations;
 extern struct inode_operations autofs4_dir_inode_operations;
 extern struct inode_operations autofs4_root_inode_operations;
+extern struct inode_operations autofs4_indirect_root_inode_operations;
+extern struct inode_operations autofs4_direct_root_inode_operations;
 extern struct file_operations autofs4_dir_operations;
 extern struct file_operations autofs4_root_operations;
 
@@ -176,13 +186,6 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *, struct autofs_sb_info
 
 /* Queue management functions */
 
-enum autofs_notify
-{
-        NFY_NONE,
-        NFY_MOUNT,
-        NFY_EXPIRE
-};
-
 int autofs4_wait(struct autofs_sb_info *,struct dentry *, enum autofs_notify);
 int autofs4_wait_release(struct autofs_sb_info *,autofs_wqt_t,int);
 void autofs4_catatonic_mode(struct autofs_sb_info *);
@@ -200,12 +203,22 @@ static inline int autofs4_follow_mount(struct vfsmount **mnt, struct dentry **de
         return res;
 }
 
+static inline u32 autofs4_get_dev(struct autofs_sb_info *sbi)
+{
+        return new_encode_dev(sbi->sb->s_dev);
+}
+
+static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi)
+{
+        return sbi->sb->s_root->d_inode->i_ino;
+}
+
 static inline int simple_positive(struct dentry *dentry)
 {
         return dentry->d_inode && !d_unhashed(dentry);
 }
 
-static inline int simple_empty_nolock(struct dentry *dentry)
+static inline int __simple_empty(struct dentry *dentry)
 {
         struct dentry *child;
         int ret = 0;
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index dc39589df165..b8ce02607d66 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -4,7 +4,7 @@
  *
  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
  *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -16,7 +16,7 @@
 
 static unsigned long now;
 
-/* Check if a dentry can be expired return 1 if it can else return 0 */
+/* Check if a dentry can be expired */
 static inline int autofs4_can_expire(struct dentry *dentry,
                                         unsigned long timeout, int do_now)
 {
@@ -41,14 +41,14 @@ static inline int autofs4_can_expire(struct dentry *dentry,
                      attempts if expire fails the first time */
                 ino->last_used = now;
         }
-
         return 1;
 }
 
-/* Check a mount point for busyness return 1 if not busy, otherwise */
-static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
+/* Check a mount point for busyness */
+static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
 {
-        int status = 0;
+        struct dentry *top = dentry;
+        int status = 1;
 
         DPRINTK("dentry %p %.*s",
                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
@@ -63,9 +63,14 @@ static int autofs4_check_mount(struct vfsmount *mnt, struct dentry *dentry)
         if (is_autofs4_dentry(dentry))
                 goto done;
 
-        /* The big question */
-        if (may_umount_tree(mnt) == 0)
-                status = 1;
+        /* Update the expiry counter if fs is busy */
+        if (!may_umount_tree(mnt)) {
+                struct autofs_info *ino = autofs4_dentry_ino(top);
+                ino->last_used = jiffies;
+                goto done;
+        }
+
+        status = 0;
 done:
         DPRINTK("returning = %d", status);
         mntput(mnt);
@@ -73,78 +78,124 @@ done:
         return status;
 }
 
+/*
+ * Calculate next entry in top down tree traversal.
+ * From next_mnt in namespace.c - elegant.
+ */
+static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
+{
+        struct list_head *next = p->d_subdirs.next;
+
+        if (next == &p->d_subdirs) {
+                while (1) {
+                        if (p == root)
+                                return NULL;
+                        next = p->d_u.d_child.next;
+                        if (next != &p->d_parent->d_subdirs)
+                                break;
+                        p = p->d_parent;
+                }
+        }
+        return list_entry(next, struct dentry, d_u.d_child);
+}
+
+/*
+ * Check a direct mount point for busyness.
+ * Direct mounts have similar expiry semantics to tree mounts.
+ * The tree is not busy iff no mountpoints are busy and there are no
+ * autofs submounts.
+ */
+static int autofs4_direct_busy(struct vfsmount *mnt,
+                                struct dentry *top,
+                                unsigned long timeout,
+                                int do_now)
+{
+        DPRINTK("top %p %.*s",
+                top, (int) top->d_name.len, top->d_name.name);
+
+        /* If it's busy update the expiry counters */
+        if (!may_umount_tree(mnt)) {
+                struct autofs_info *ino = autofs4_dentry_ino(top);
+                if (ino)
+                        ino->last_used = jiffies;
+                return 1;
+        }
+
+        /* Timeout of a direct mount is determined by its top dentry */
+        if (!autofs4_can_expire(top, timeout, do_now))
+                return 1;
+
+        return 0;
+}
+
 /* Check a directory tree of mount points for busyness
  * The tree is not busy iff no mountpoints are busy
- * Return 1 if the tree is busy or 0 otherwise
  */
-static int autofs4_check_tree(struct vfsmount *mnt,
-                              struct dentry *top,
-                              unsigned long timeout,
-                              int do_now)
+static int autofs4_tree_busy(struct vfsmount *mnt,
+                             struct dentry *top,
+                             unsigned long timeout,
+                             int do_now)
 {
-        struct dentry *this_parent = top;
-        struct list_head *next;
+        struct autofs_info *top_ino = autofs4_dentry_ino(top);
+        struct dentry *p;
 
-        DPRINTK("parent %p %.*s",
+        DPRINTK("top %p %.*s",
                 top, (int)top->d_name.len, top->d_name.name);
 
         /* Negative dentry - give up */
         if (!simple_positive(top))
-                return 0;
-
-        /* Timeout of a tree mount is determined by its top dentry */
-        if (!autofs4_can_expire(top, timeout, do_now))
-                return 0;
-
-        /* Is someone visiting anywhere in the tree ? */
-        if (may_umount_tree(mnt))
-                return 0;
+                return 1;
 
         spin_lock(&dcache_lock);
-repeat:
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
-
+        for (p = top; p; p = next_dentry(p, top)) {
                 /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
-                        next = next->next;
+                if (!simple_positive(p))
                         continue;
-                }
 
                 DPRINTK("dentry %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
-
-                if (!simple_empty_nolock(dentry)) {
-                        this_parent = dentry;
-                        goto repeat;
-                }
+                        p, (int) p->d_name.len, p->d_name.name);
 
-                dentry = dget(dentry);
+                p = dget(p);
                 spin_unlock(&dcache_lock);
 
-                if (d_mountpoint(dentry)) {
-                        /* First busy => tree busy */
-                        if (!autofs4_check_mount(mnt, dentry)) {
-                                dput(dentry);
-                                return 0;
+                /*
+                 * Is someone visiting anywhere in the subtree ?
+                 * If there's no mount we need to check the usage
+                 * count for the autofs dentry.
+                 * If the fs is busy update the expiry counter.
+                 */
+                if (d_mountpoint(p)) {
+                        if (autofs4_mount_busy(mnt, p)) {
+                                top_ino->last_used = jiffies;
+                                dput(p);
+                                return 1;
+                        }
+                } else {
+                        struct autofs_info *ino = autofs4_dentry_ino(p);
+                        unsigned int ino_count = atomic_read(&ino->count);
+
+                        /* allow for dget above and top is already dgot */
+                        if (p == top)
+                                ino_count += 2;
+                        else
+                                ino_count++;
+
+                        if (atomic_read(&p->d_count) > ino_count) {
+                                top_ino->last_used = jiffies;
+                                dput(p);
+                                return 1;
                         }
                 }
-
-                dput(dentry);
+                dput(p);
                 spin_lock(&dcache_lock);
-                next = next->next;
-        }
-
-        if (this_parent != top) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
-                goto resume;
         }
         spin_unlock(&dcache_lock);
 
-        return 1;
+        /* Timeout of a tree mount is ultimately determined by its top dentry */
+        if (!autofs4_can_expire(top, timeout, do_now))
+                return 1;
+
+        return 0;
 }
 
 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
@@ -152,58 +203,68 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
                                            unsigned long timeout,
                                            int do_now)
 {
-        struct dentry *this_parent = parent;
-        struct list_head *next;
+        struct dentry *p;
 
         DPRINTK("parent %p %.*s",
                 parent, (int)parent->d_name.len, parent->d_name.name);
 
         spin_lock(&dcache_lock);
-repeat:
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
-
+        for (p = parent; p; p = next_dentry(p, parent)) {
                 /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
-                        next = next->next;
+                if (!simple_positive(p))
                         continue;
-                }
 
                 DPRINTK("dentry %p %.*s",
-                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
-
-                if (!list_empty(&dentry->d_subdirs)) {
-                        this_parent = dentry;
-                        goto repeat;
-                }
+                        p, (int) p->d_name.len, p->d_name.name);
 
-                dentry = dget(dentry);
+                p = dget(p);
                 spin_unlock(&dcache_lock);
 
-                if (d_mountpoint(dentry)) {
-                        /* Can we expire this guy */
-                        if (!autofs4_can_expire(dentry, timeout, do_now))
-                                goto cont;
-
+                if (d_mountpoint(p)) {
                         /* Can we umount this guy */
-                        if (autofs4_check_mount(mnt, dentry))
-                                return dentry;
+                        if (autofs4_mount_busy(mnt, p))
+                                goto cont;
 
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(p, timeout, do_now))
+                                return p;
                 }
 cont:
-                dput(dentry);
+                dput(p);
                 spin_lock(&dcache_lock);
-                next = next->next;
         }
+        spin_unlock(&dcache_lock);
+        return NULL;
+}
+
+/* Check if we can expire a direct mount (possibly a tree) */
+static struct dentry *autofs4_expire_direct(struct super_block *sb,
+                                            struct vfsmount *mnt,
+                                            struct autofs_sb_info *sbi,
+                                            int how)
+{
+        unsigned long timeout;
+        struct dentry *root = dget(sb->s_root);
+        int do_now = how & AUTOFS_EXP_IMMEDIATE;
+
+        if (!sbi->exp_timeout || !root)
+                return NULL;
+
+        now = jiffies;
+        timeout = sbi->exp_timeout;
+
+        /* Lock the tree as we must expire as a whole */
+        spin_lock(&sbi->fs_lock);
+        if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
+                struct autofs_info *ino = autofs4_dentry_ino(root);
 
-        if (this_parent != parent) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
-                goto resume;
+                /* Set this flag early to catch sys_chdir and the like */
+                ino->flags |= AUTOFS_INF_EXPIRING;
+                spin_unlock(&sbi->fs_lock);
+                return root;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&sbi->fs_lock);
+        dput(root);
 
         return NULL;
 }
@@ -214,10 +275,10 @@ cont:
  *  - it is unused by any user process
  *  - it has been unused for exp_timeout time
  */
-static struct dentry *autofs4_expire(struct super_block *sb,
-                                     struct vfsmount *mnt,
-                                     struct autofs_sb_info *sbi,
-                                     int how)
+static struct dentry *autofs4_expire_indirect(struct super_block *sb,
+                                              struct vfsmount *mnt,
+                                              struct autofs_sb_info *sbi,
+                                              int how)
 {
         unsigned long timeout;
         struct dentry *root = sb->s_root;
@@ -241,7 +302,7 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                 struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
 
                 /* Negative dentry - give up */
-                if ( !simple_positive(dentry) ) {
+                if (!simple_positive(dentry)) {
                         next = next->next;
                         continue;
                 }
@@ -249,31 +310,36 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                 dentry = dget(dentry);
                 spin_unlock(&dcache_lock);
 
-                /* Case 1: indirect mount or top level direct mount */
+                /*
+                 * Case 1: (i) indirect mount or top level pseudo direct mount
+                 *         (autofs-4.1).
+                 *         (ii) indirect mount with offset mount, check the "/"
+                 *         offset (autofs-5.0+).
+                 */
                 if (d_mountpoint(dentry)) {
                         DPRINTK("checking mountpoint %p %.*s",
                                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
 
-                        /* Can we expire this guy */
-                        if (!autofs4_can_expire(dentry, timeout, do_now))
+                        /* Can we umount this guy */
+                        if (autofs4_mount_busy(mnt, dentry))
                                 goto next;
 
-                        /* Can we umount this guy */
-                        if (autofs4_check_mount(mnt, dentry)) {
+                        /* Can we expire this guy */
+                        if (autofs4_can_expire(dentry, timeout, do_now)) {
                                 expired = dentry;
                                 break;
                         }
                         goto next;
                 }
 
-                if ( simple_empty(dentry) )
+                if (simple_empty(dentry))
                         goto next;
 
                 /* Case 2: tree mount, expire iff entire tree is not busy */
                 if (!exp_leaves) {
                         /* Lock the tree as we must expire as a whole */
                         spin_lock(&sbi->fs_lock);
-                        if (autofs4_check_tree(mnt, dentry, timeout, do_now)) {
+                        if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
                                 struct autofs_info *inf = autofs4_dentry_ino(dentry);
 
                                 /* Set this flag early to catch sys_chdir and the like */
@@ -283,7 +349,10 @@ static struct dentry *autofs4_expire(struct super_block *sb,
                                 break;
                         }
                         spin_unlock(&sbi->fs_lock);
-                /* Case 3: direct mount, expire individual leaves */
+                /*
+                 * Case 3: pseudo direct mount, expire individual leaves
+                 *         (autofs-4.1).
+                 */
                 } else {
                         expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
                         if (expired) {
@@ -297,7 +366,7 @@ next:
                 next = next->next;
         }
 
-        if ( expired ) {
+        if (expired) {
                 DPRINTK("returning %p %.*s",
                         expired, (int)expired->d_name.len, expired->d_name.name);
                 spin_lock(&dcache_lock);
@@ -325,7 +394,7 @@ int autofs4_expire_run(struct super_block *sb,
         pkt.hdr.proto_version = sbi->version;
         pkt.hdr.type = autofs_ptype_expire;
 
-        if ((dentry = autofs4_expire(sb, mnt, sbi, 0)) == NULL)
+        if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
                 return -EAGAIN;
 
         pkt.len = dentry->d_name.len;
@@ -351,17 +420,22 @@ int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
         if (arg && get_user(do_now, arg))
                 return -EFAULT;
 
-        if ((dentry = autofs4_expire(sb, mnt, sbi, do_now)) != NULL) {
-                struct autofs_info *de_info = autofs4_dentry_ino(dentry);
+        if (sbi->type & AUTOFS_TYPE_DIRECT)
+                dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
+        else
+                dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);
+
+        if (dentry) {
+                struct autofs_info *ino = autofs4_dentry_ino(dentry);
 
                 /* This is synchronous because it makes the daemon a
                    little easier */
-                de_info->flags |= AUTOFS_INF_EXPIRING;
+                ino->flags |= AUTOFS_INF_EXPIRING;
                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
-                de_info->flags &= ~AUTOFS_INF_EXPIRING;
+                ino->flags &= ~AUTOFS_INF_EXPIRING;
                 dput(dentry);
         }
-                
+
         return ret;
 }
 
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 1ad98d48e550..4eddee4e76fc 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -3,6 +3,7 @@
  * linux/fs/autofs/inode.c
  *
  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
+ *  Copyright 2005-2006 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -13,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/file.h>
+#include <linux/seq_file.h>
 #include <linux/pagemap.h>
 #include <linux/parser.h>
 #include <linux/bitops.h>
@@ -46,6 +48,7 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *ino,
         ino->size = 0;
 
         ino->last_used = jiffies;
+        atomic_set(&ino->count, 0);
 
         ino->sbi = sbi;
 
@@ -64,10 +67,19 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *ino,
 
 void autofs4_free_ino(struct autofs_info *ino)
 {
+        struct autofs_info *p_ino;
+
         if (ino->dentry) {
                 ino->dentry->d_fsdata = NULL;
-                if (ino->dentry->d_inode)
+                if (ino->dentry->d_inode) {
+                        struct dentry *parent = ino->dentry->d_parent;
+                        if (atomic_dec_and_test(&ino->count)) {
+                                p_ino = autofs4_dentry_ino(parent);
+                                if (p_ino && parent != ino->dentry)
+                                        atomic_dec(&p_ino->count);
+                        }
                         dput(ino->dentry);
+                }
                 ino->dentry = NULL;
         }
         if (ino->free)
@@ -145,20 +157,44 @@ static void autofs4_put_super(struct super_block *sb)
                 autofs4_catatonic_mode(sbi); /* Free wait queues, close pipe */
 
         /* Clean up and release dangling references */
-        if (sbi)
-                autofs4_force_release(sbi);
+        autofs4_force_release(sbi);
 
         kfree(sbi);
 
         DPRINTK("shutting down");
 }
 
+static int autofs4_show_options(struct seq_file *m, struct vfsmount *mnt)
+{
+        struct autofs_sb_info *sbi = autofs4_sbi(mnt->mnt_sb);
+
+        if (!sbi)
+                return 0;
+
+        seq_printf(m, ",fd=%d", sbi->pipefd);
+        seq_printf(m, ",pgrp=%d", sbi->oz_pgrp);
+        seq_printf(m, ",timeout=%lu", sbi->exp_timeout/HZ);
+        seq_printf(m, ",minproto=%d", sbi->min_proto);
+        seq_printf(m, ",maxproto=%d", sbi->max_proto);
+
+        if (sbi->type & AUTOFS_TYPE_OFFSET)
+                seq_printf(m, ",offset");
+        else if (sbi->type & AUTOFS_TYPE_DIRECT)
+                seq_printf(m, ",direct");
+        else
+                seq_printf(m, ",indirect");
+
+        return 0;
+}
+
 static struct super_operations autofs4_sops = {
         .put_super      = autofs4_put_super,
         .statfs         = simple_statfs,
+        .show_options   = autofs4_show_options,
 };
 
-enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto};
+enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto,
+        Opt_indirect, Opt_direct, Opt_offset};
 
 static match_table_t tokens = {
         {Opt_fd, "fd=%u"},
@@ -167,11 +203,15 @@ static match_table_t tokens = {
         {Opt_pgrp, "pgrp=%u"},
         {Opt_minproto, "minproto=%u"},
         {Opt_maxproto, "maxproto=%u"},
+        {Opt_indirect, "indirect"},
+        {Opt_direct, "direct"},
+        {Opt_offset, "offset"},
         {Opt_err, NULL}
 };
 
 static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
-                         pid_t *pgrp, int *minproto, int *maxproto)
+                         pid_t *pgrp, unsigned int *type,
+                         int *minproto, int *maxproto)
 {
         char *p;
         substring_t args[MAX_OPT_ARGS];
@@ -225,6 +265,15 @@ static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
                                 return 1;
                         *maxproto = option;
                         break;
+                case Opt_indirect:
+                        *type = AUTOFS_TYPE_INDIRECT;
+                        break;
+                case Opt_direct:
+                        *type = AUTOFS_TYPE_DIRECT;
+                        break;
+                case Opt_offset:
+                        *type = AUTOFS_TYPE_DIRECT | AUTOFS_TYPE_OFFSET;
+                        break;
                 default:
                         return 1;
                 }
@@ -243,6 +292,11 @@ static struct autofs_info *autofs4_mkroot(struct autofs_sb_info *sbi)
         return ino;
 }
 
+void autofs4_dentry_release(struct dentry *);
+static struct dentry_operations autofs4_sb_dentry_operations = {
+        .d_release      = autofs4_dentry_release,
+};
+
 int autofs4_fill_super(struct super_block *s, void *data, int silent)
 {
         struct inode * root_inode;
@@ -251,7 +305,6 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
         int pipefd;
         struct autofs_sb_info *sbi;
         struct autofs_info *ino;
-        int minproto, maxproto;
 
         sbi = (struct autofs_sb_info *) kmalloc(sizeof(*sbi), GFP_KERNEL);
         if ( !sbi )
@@ -263,12 +316,16 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
         s->s_fs_info = sbi;
         sbi->magic = AUTOFS_SBI_MAGIC;
         sbi->root = NULL;
+        sbi->pipefd = -1;
         sbi->catatonic = 0;
         sbi->exp_timeout = 0;
         sbi->oz_pgrp = process_group(current);
         sbi->sb = s;
         sbi->version = 0;
         sbi->sub_version = 0;
+        sbi->type = 0;
+        sbi->min_proto = 0;
+        sbi->max_proto = 0;
         mutex_init(&sbi->wq_mutex);
         spin_lock_init(&sbi->fs_lock);
         sbi->queues = NULL;
@@ -285,38 +342,46 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
         if (!ino)
                 goto fail_free;
         root_inode = autofs4_get_inode(s, ino);
-        kfree(ino);
         if (!root_inode)
-                goto fail_free;
+                goto fail_ino;
 
-        root_inode->i_op = &autofs4_root_inode_operations;
-        root_inode->i_fop = &autofs4_root_operations;
         root = d_alloc_root(root_inode);
-        pipe = NULL;
-
         if (!root)
                 goto fail_iput;
+        pipe = NULL;
+
+        root->d_op = &autofs4_sb_dentry_operations;
+        root->d_fsdata = ino;
 
         /* Can this call block? */
         if (parse_options(data, &pipefd,
                           &root_inode->i_uid, &root_inode->i_gid,
-                          &sbi->oz_pgrp,
-                          &minproto, &maxproto)) {
+                          &sbi->oz_pgrp, &sbi->type,
+                          &sbi->min_proto, &sbi->max_proto)) {
                 printk("autofs: called with bogus options\n");
                 goto fail_dput;
         }
 
+        root_inode->i_fop = &autofs4_root_operations;
+        root_inode->i_op = sbi->type & AUTOFS_TYPE_DIRECT ?
+                        &autofs4_direct_root_inode_operations :
+                        &autofs4_indirect_root_inode_operations;
+
         /* Couldn't this be tested earlier? */
-        if (maxproto < AUTOFS_MIN_PROTO_VERSION ||
-            minproto > AUTOFS_MAX_PROTO_VERSION) {
+        if (sbi->max_proto < AUTOFS_MIN_PROTO_VERSION ||
+            sbi->min_proto > AUTOFS_MAX_PROTO_VERSION) {
                 printk("autofs: kernel does not match daemon version "
                        "daemon (%d, %d) kernel (%d, %d)\n",
-                        minproto, maxproto,
+                        sbi->min_proto, sbi->max_proto,
                         AUTOFS_MIN_PROTO_VERSION, AUTOFS_MAX_PROTO_VERSION);
                 goto fail_dput;
         }
 
-        sbi->version = maxproto > AUTOFS_MAX_PROTO_VERSION ? AUTOFS_MAX_PROTO_VERSION : maxproto;
+        /* Establish highest kernel protocol version */
+        if (sbi->max_proto > AUTOFS_MAX_PROTO_VERSION)
+                sbi->version = AUTOFS_MAX_PROTO_VERSION;
+        else
+                sbi->version = sbi->max_proto;
         sbi->sub_version = AUTOFS_PROTO_SUBVERSION;
 
         DPRINTK("pipe fd = %d, pgrp = %u", pipefd, sbi->oz_pgrp);
@@ -329,6 +394,7 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
         if ( !pipe->f_op || !pipe->f_op->write )
                 goto fail_fput;
         sbi->pipe = pipe;
+        sbi->pipefd = pipefd;
 
         /*
          * Take a reference to the root dentry so we get a chance to
@@ -356,6 +422,8 @@ fail_dput:
 fail_iput:
         printk("autofs: get root dentry failed\n");
         iput(root_inode);
+fail_ino:
+        kfree(ino);
 fail_free:
         kfree(sbi);
 fail_unlock:
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index 62d8d4acb8bb..c8fe43a475e2 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -4,7 +4,7 @@
  *
  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
  *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -30,7 +30,7 @@ static int autofs4_dir_close(struct inode *inode, struct file *file);
 static int autofs4_dir_readdir(struct file * filp, void * dirent, filldir_t filldir);
 static int autofs4_root_readdir(struct file * filp, void * dirent, filldir_t filldir);
 static struct dentry *autofs4_lookup(struct inode *,struct dentry *, struct nameidata *);
-static int autofs4_dcache_readdir(struct file *, void *, filldir_t);
+static void *autofs4_follow_link(struct dentry *, struct nameidata *);
 
 struct file_operations autofs4_root_operations = {
         .open           = dcache_dir_open,
@@ -47,7 +47,7 @@ struct file_operations autofs4_dir_operations = {
         .readdir        = autofs4_dir_readdir,
 };
 
-struct inode_operations autofs4_root_inode_operations = {
+struct inode_operations autofs4_indirect_root_inode_operations = {
         .lookup         = autofs4_lookup,
         .unlink         = autofs4_dir_unlink,
         .symlink        = autofs4_dir_symlink,
@@ -55,6 +55,14 @@ struct inode_operations autofs4_root_inode_operations = {
         .rmdir          = autofs4_dir_rmdir,
 };
 
+struct inode_operations autofs4_direct_root_inode_operations = {
+        .lookup         = autofs4_lookup,
+        .unlink         = autofs4_dir_unlink,
+        .mkdir          = autofs4_dir_mkdir,
+        .rmdir          = autofs4_dir_rmdir,
+        .follow_link    = autofs4_follow_link,
+};
+
 struct inode_operations autofs4_dir_inode_operations = {
         .lookup         = autofs4_lookup,
         .unlink         = autofs4_dir_unlink,
@@ -82,87 +90,7 @@ static int autofs4_root_readdir(struct file *file, void *dirent,
 
         DPRINTK("needs_reghost = %d", sbi->needs_reghost);
 
-        return autofs4_dcache_readdir(file, dirent, filldir);
-}
-
-/* Update usage from here to top of tree, so that scan of
-   top-level directories will give a useful result */
-static void autofs4_update_usage(struct vfsmount *mnt, struct dentry *dentry)
-{
-        struct dentry *top = dentry->d_sb->s_root;
-
-        spin_lock(&dcache_lock);
-        for(; dentry != top; dentry = dentry->d_parent) {
-                struct autofs_info *ino = autofs4_dentry_ino(dentry);
-
-                if (ino) {
-                        touch_atime(mnt, dentry);
-                        ino->last_used = jiffies;
-                }
-        }
-        spin_unlock(&dcache_lock);
-}
-
-/*
- * From 2.4 kernel readdir.c
- */
-static int autofs4_dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
-{
-        int i;
-        struct dentry *dentry = filp->f_dentry;
-
-        i = filp->f_pos;
-        switch (i) {
-                case 0:
-                        if (filldir(dirent, ".", 1, i, dentry->d_inode->i_ino, DT_DIR) < 0)
-                                break;
-                        i++;
-                        filp->f_pos++;
-                        /* fallthrough */
-                case 1:
-                        if (filldir(dirent, "..", 2, i, dentry->d_parent->d_inode->i_ino, DT_DIR) < 0)
-                                break;
-                        i++;
-                        filp->f_pos++;
-                        /* fallthrough */
-                default: {
-                        struct list_head *list;
-                        int j = i-2;
-
-                        spin_lock(&dcache_lock);
-                        list = dentry->d_subdirs.next;
-
-                        for (;;) {
-                                if (list == &dentry->d_subdirs) {
-                                        spin_unlock(&dcache_lock);
-                                        return 0;
-                                }
-                                if (!j)
-                                        break;
-                                j--;
-                                list = list->next;
-                        }
-
-                        while(1) {
-                                struct dentry *de = list_entry(list,
-                                                struct dentry, d_u.d_child);
-
-                                if (!d_unhashed(de) && de->d_inode) {
-                                        spin_unlock(&dcache_lock);
-                                        if (filldir(dirent, de->d_name.name, de->d_name.len, filp->f_pos, de->d_inode->i_ino, DT_UNKNOWN) < 0)
-                                                break;
-                                        spin_lock(&dcache_lock);
-                                }
-                                filp->f_pos++;
-                                list = list->next;
-                                if (list != &dentry->d_subdirs)
-                                        continue;
-                                spin_unlock(&dcache_lock);
-                                break;
-                        }
-                }
-        }
-        return 0;
+        return dcache_readdir(file, dirent, filldir);
 }
 
 static int autofs4_dir_open(struct inode *inode, struct file *file)
@@ -170,8 +98,16 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
         struct dentry *dentry = file->f_dentry;
         struct vfsmount *mnt = file->f_vfsmnt;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct dentry *cursor;
         int status;
 
+        status = dcache_dir_open(inode, file);
+        if (status)
+                goto out;
+
+        cursor = file->private_data;
+        cursor->d_fsdata = NULL;
+
         DPRINTK("file=%p dentry=%p %.*s",
                 file, dentry, dentry->d_name.len, dentry->d_name.name);
 
@@ -180,12 +116,15 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
 
         if (autofs4_ispending(dentry)) {
                 DPRINTK("dentry busy");
-                return -EBUSY;
+                dcache_dir_close(inode, file);
+                status = -EBUSY;
+                goto out;
         }
 
+        status = -ENOENT;
         if (!d_mountpoint(dentry) && dentry->d_op && dentry->d_op->d_revalidate) {
                 struct nameidata nd;
-                int empty;
+                int empty, ret;
 
                 /* In case there are stale directory dentrys from a failed mount */
                 spin_lock(&dcache_lock);
@@ -195,13 +134,13 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
                 if (!empty)
                         d_invalidate(dentry);
 
-                nd.dentry = dentry;
-                nd.mnt = mnt;
                 nd.flags = LOOKUP_DIRECTORY;
-                status = (dentry->d_op->d_revalidate)(dentry, &nd);
+                ret = (dentry->d_op->d_revalidate)(dentry, &nd);
 
-                if (!status)
-                        return -ENOENT;
+                if (!ret) {
+                        dcache_dir_close(inode, file);
+                        goto out;
+                }
         }
 
         if (d_mountpoint(dentry)) {
@@ -212,25 +151,29 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
                 if (!autofs4_follow_mount(&fp_mnt, &fp_dentry)) {
                         dput(fp_dentry);
                         mntput(fp_mnt);
-                        return -ENOENT;
+                        dcache_dir_close(inode, file);
+                        goto out;
                 }
 
                 fp = dentry_open(fp_dentry, fp_mnt, file->f_flags);
                 status = PTR_ERR(fp);
                 if (IS_ERR(fp)) {
-                        file->private_data = NULL;
-                        return status;
+                        dcache_dir_close(inode, file);
+                        goto out;
                 }
-                file->private_data = fp;
+                cursor->d_fsdata = fp;
         }
-out:
         return 0;
+out:
+        return status;
 }
 
 static int autofs4_dir_close(struct inode *inode, struct file *file)
 {
         struct dentry *dentry = file->f_dentry;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct dentry *cursor = file->private_data;
+        int status = 0;
 
         DPRINTK("file=%p dentry=%p %.*s",
                 file, dentry, dentry->d_name.len, dentry->d_name.name);
@@ -240,26 +183,28 @@ static int autofs4_dir_close(struct inode *inode, struct file *file)
 
         if (autofs4_ispending(dentry)) {
                 DPRINTK("dentry busy");
-                return -EBUSY;
+                status = -EBUSY;
+                goto out;
         }
 
         if (d_mountpoint(dentry)) {
-                struct file *fp = file->private_data;
-
-                if (!fp)
-                        return -ENOENT;
-
+                struct file *fp = cursor->d_fsdata;
+                if (!fp) {
+                        status = -ENOENT;
+                        goto out;
+                }
                 filp_close(fp, current->files);
-                file->private_data = NULL;
         }
 out:
-        return 0;
+        dcache_dir_close(inode, file);
+        return status;
 }
 
 static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldir)
 {
         struct dentry *dentry = file->f_dentry;
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct dentry *cursor = file->private_data;
         int status;
 
         DPRINTK("file=%p dentry=%p %.*s",
@@ -274,7 +219,7 @@ static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldi
         }
 
         if (d_mountpoint(dentry)) {
-                struct file *fp = file->private_data;
+                struct file *fp = cursor->d_fsdata;
 
                 if (!fp)
                         return -ENOENT;
@@ -289,27 +234,26 @@ static int autofs4_dir_readdir(struct file *file, void *dirent, filldir_t filldi
                 return status;
         }
 out:
-        return autofs4_dcache_readdir(file, dirent, filldir);
+        return dcache_readdir(file, dirent, filldir);
 }
 
-static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int flags)
+static int try_to_fill_dentry(struct dentry *dentry, int flags)
 {
-        struct super_block *sb = mnt->mnt_sb;
-        struct autofs_sb_info *sbi = autofs4_sbi(sb);
-        struct autofs_info *de_info = autofs4_dentry_ino(dentry);
+        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct autofs_info *ino = autofs4_dentry_ino(dentry);
         int status = 0;
 
         /* Block on any pending expiry here; invalidate the dentry
            when expiration is done to trigger mount request with a new
            dentry */
-        if (de_info && (de_info->flags & AUTOFS_INF_EXPIRING)) {
+        if (ino && (ino->flags & AUTOFS_INF_EXPIRING)) {
                 DPRINTK("waiting for expire %p name=%.*s",
                          dentry, dentry->d_name.len, dentry->d_name.name);
 
                 status = autofs4_wait(sbi, dentry, NFY_NONE);
-                
+
                 DPRINTK("expire done status=%d", status);
-                
+
                 /*
                  * If the directory still exists the mount request must
                  * continue otherwise it can't be followed at the right
@@ -317,34 +261,36 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
                  */
                 status = d_invalidate(dentry);
                 if (status != -EBUSY)
-                        return 0;
+                        return -ENOENT;
         }
 
         DPRINTK("dentry=%p %.*s ino=%p",
                  dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
 
-        /* Wait for a pending mount, triggering one if there isn't one already */
+        /*
+         * Wait for a pending mount, triggering one if there
+         * isn't one already
+         */
         if (dentry->d_inode == NULL) {
                 DPRINTK("waiting for mount name=%.*s",
                          dentry->d_name.len, dentry->d_name.name);
 
                 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
-                 
+
                 DPRINTK("mount done status=%d", status);
 
                 if (status && dentry->d_inode)
-                        return 0; /* Try to get the kernel to invalidate this dentry */
-                
+                        return status; /* Try to get the kernel to invalidate this dentry */
+
                 /* Turn this into a real negative dentry? */
                 if (status == -ENOENT) {
-                        dentry->d_time = jiffies + AUTOFS_NEGATIVE_TIMEOUT;
                         spin_lock(&dentry->d_lock);
                         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
                         spin_unlock(&dentry->d_lock);
-                        return 1;
+                        return status;
                 } else if (status) {
                         /* Return a negative dentry, but leave it "pending" */
-                        return 1;
+                        return status;
                 }
         /* Trigger mount for path component or follow link */
         } else if (flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY) ||
@@ -363,19 +309,87 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
                         spin_lock(&dentry->d_lock);
                         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
                         spin_unlock(&dentry->d_lock);
-                        return 0;
+                        return status;
                 }
         }
 
-        /* We don't update the usages for the autofs daemon itself, this
-           is necessary for recursive autofs mounts */
-        if (!autofs4_oz_mode(sbi))
-                autofs4_update_usage(mnt, dentry);
+        /* Initialize expiry counter after successful mount */
+        if (ino)
+                ino->last_used = jiffies;
 
         spin_lock(&dentry->d_lock);
         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
         spin_unlock(&dentry->d_lock);
-        return 1;
+        return status;
+}
+
+/* For autofs direct mounts the follow link triggers the mount */
+static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        int oz_mode = autofs4_oz_mode(sbi);
+        unsigned int lookup_type;
+        int status;
+
+        DPRINTK("dentry=%p %.*s oz_mode=%d nd->flags=%d",
+                dentry, dentry->d_name.len, dentry->d_name.name, oz_mode,
+                nd->flags);
+
+        /* If it's our master or we shouldn't trigger a mount we're done */
+        lookup_type = nd->flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY);
+        if (oz_mode || !lookup_type)
+                goto done;
+
+        /*
+         * If a request is pending wait for it.
+         * If it's a mount then it won't be expired till at least
+         * a liitle later and if it's an expire then we might need
+         * to mount it again.
+         */
+        if (autofs4_ispending(dentry)) {
+                DPRINTK("waiting for active request %p name=%.*s",
+                        dentry, dentry->d_name.len, dentry->d_name.name);
+
+                status = autofs4_wait(sbi, dentry, NFY_NONE);
+
+                DPRINTK("request done status=%d", status);
+        }
+
+        /*
+         * If the dentry contains directories then it is an
+         * autofs multi-mount with no root mount offset. So
+         * don't try to mount it again.
+         */
+        spin_lock(&dcache_lock);
+        if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
+                spin_unlock(&dcache_lock);
+
+                status = try_to_fill_dentry(dentry, 0);
+                if (status)
+                        goto out_error;
+
+                /*
+                 * The mount succeeded but if there is no root mount
+                 * it must be an autofs multi-mount with no root offset
+                 * so we don't need to follow the mount.
+                 */
+                if (d_mountpoint(dentry)) {
+                        if (!autofs4_follow_mount(&nd->mnt, &nd->dentry)) {
+                                status = -ENOENT;
+                                goto out_error;
+                        }
+                }
+
+                goto done;
+        }
+        spin_unlock(&dcache_lock);
+
+done:
+        return NULL;
+
+out_error:
+        path_release(nd);
+        return ERR_PTR(status);
 }
 
 /*
@@ -384,47 +398,43 @@ static int try_to_fill_dentry(struct vfsmount *mnt, struct dentry *dentry, int f
  * yet completely filled in, and revalidate has to delay such
  * lookups..
  */
-static int autofs4_revalidate(struct dentry * dentry, struct nameidata *nd)
+static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode * dir = dentry->d_parent->d_inode;
+        struct inode *dir = dentry->d_parent->d_inode;
         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
         int oz_mode = autofs4_oz_mode(sbi);
         int flags = nd ? nd->flags : 0;
-        int status = 1;
+        int status = 0;
 
         /* Pending dentry */
         if (autofs4_ispending(dentry)) {
                 if (!oz_mode)
-                        status = try_to_fill_dentry(nd->mnt, dentry, flags);
-                return status;
+                        status = try_to_fill_dentry(dentry, flags);
+                return !status;
         }
 
         /* Negative dentry.. invalidate if "old" */
         if (dentry->d_inode == NULL)
-                return (dentry->d_time - jiffies <= AUTOFS_NEGATIVE_TIMEOUT);
+                return 0;
 
         /* Check for a non-mountpoint directory with no contents */
         spin_lock(&dcache_lock);
         if (S_ISDIR(dentry->d_inode->i_mode) &&
             !d_mountpoint(dentry) && 
-            list_empty(&dentry->d_subdirs)) {
+            __simple_empty(dentry)) {
                 DPRINTK("dentry=%p %.*s, emptydir",
                          dentry, dentry->d_name.len, dentry->d_name.name);
                 spin_unlock(&dcache_lock);
                 if (!oz_mode)
-                        status = try_to_fill_dentry(nd->mnt, dentry, flags);
-                return status;
+                        status = try_to_fill_dentry(dentry, flags);
+                return !status;
         }
         spin_unlock(&dcache_lock);
 
-        /* Update the usage list */
-        if (!oz_mode)
-                autofs4_update_usage(nd->mnt, dentry);
-
         return 1;
 }
 
-static void autofs4_dentry_release(struct dentry *de)
+void autofs4_dentry_release(struct dentry *de)
 {
         struct autofs_info *inf;
 
@@ -462,12 +472,13 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
         DPRINTK("name = %.*s",
                 dentry->d_name.len, dentry->d_name.name);
 
+        /* File name too long to exist */
         if (dentry->d_name.len > NAME_MAX)
-                return ERR_PTR(-ENAMETOOLONG);/* File name too long to exist */
+                return ERR_PTR(-ENAMETOOLONG);
 
         sbi = autofs4_sbi(dir->i_sb);
-
         oz_mode = autofs4_oz_mode(sbi);
+
         DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
                  current->pid, process_group(current), sbi->catatonic, oz_mode);
 
@@ -519,7 +530,7 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
          * doesn't do the right thing for all system calls, but it should
          * be OK for the operations we permit from an autofs.
          */
-        if ( dentry->d_inode && d_unhashed(dentry) )
+        if (dentry->d_inode && d_unhashed(dentry))
                 return ERR_PTR(-ENOENT);
 
         return NULL;
@@ -531,6 +542,7 @@ static int autofs4_dir_symlink(struct inode *dir,
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
         struct inode *inode;
         char *cp;
 
@@ -564,6 +576,10 @@ static int autofs4_dir_symlink(struct inode *dir,
 
         dentry->d_fsdata = ino;
         ino->dentry = dget(dentry);
+        atomic_inc(&ino->count);
+        p_ino = autofs4_dentry_ino(dentry->d_parent);
+        if (p_ino && dentry->d_parent != dentry)
+                atomic_inc(&p_ino->count);
         ino->inode = inode;
 
         dir->i_mtime = CURRENT_TIME;
@@ -590,11 +606,17 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
         
         /* This allows root to remove symlinks */
         if ( !autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN) )
                 return -EACCES;
 
+        if (atomic_dec_and_test(&ino->count)) {
+                p_ino = autofs4_dentry_ino(dentry->d_parent);
+                if (p_ino && dentry->d_parent != dentry)
+                        atomic_dec(&p_ino->count);
+        }
         dput(ino->dentry);
 
         dentry->d_inode->i_size = 0;
@@ -611,6 +633,7 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
         
         if (!autofs4_oz_mode(sbi))
                 return -EACCES;
@@ -625,8 +648,12 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
         spin_unlock(&dentry->d_lock);
         spin_unlock(&dcache_lock);
 
+        if (atomic_dec_and_test(&ino->count)) {
+                p_ino = autofs4_dentry_ino(dentry->d_parent);
+                if (p_ino && dentry->d_parent != dentry)
+                        atomic_dec(&p_ino->count);
+        }
         dput(ino->dentry);
-
         dentry->d_inode->i_size = 0;
         dentry->d_inode->i_nlink = 0;
 
@@ -640,6 +667,7 @@ static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        struct autofs_info *p_ino;
         struct inode *inode;
 
         if ( !autofs4_oz_mode(sbi) )
@@ -662,6 +690,10 @@ static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
         dentry->d_fsdata = ino;
         ino->dentry = dget(dentry);
+        atomic_inc(&ino->count);
+        p_ino = autofs4_dentry_ino(dentry->d_parent);
+        if (p_ino && dentry->d_parent != dentry)
+                atomic_inc(&p_ino->count);
         ino->inode = inode;
         dir->i_nlink++;
         dir->i_mtime = CURRENT_TIME;
@@ -745,7 +777,7 @@ static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
 {
         int status = 0;
 
-        if (may_umount(mnt) == 0)
+        if (may_umount(mnt))
                 status = 1;
 
         DPRINTK("returning %d", status);
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index be78e9378c03..142ab6aa2aa1 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -3,7 +3,7 @@
  * linux/fs/autofs/waitq.c
  *
  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
- *  Copyright 2001-2003 Ian Kent <raven@themaw.net>
+ *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
  *
  * This file is part of the Linux kernel and is made available under
  * the terms of the GNU General Public License, version 2, or at your
@@ -33,7 +33,7 @@ void autofs4_catatonic_mode(struct autofs_sb_info *sbi)
         sbi->catatonic = 1;
         wq = sbi->queues;
         sbi->queues = NULL;     /* Erase all wait queues */
-        while ( wq ) {
+        while (wq) {
                 nwq = wq->next;
                 wq->status = -ENOENT; /* Magic is gone - report failure */
                 kfree(wq->name);
@@ -45,7 +45,6 @@ void autofs4_catatonic_mode(struct autofs_sb_info *sbi)
                 fput(sbi->pipe);        /* Close the pipe */
                 sbi->pipe = NULL;
         }
-
         shrink_dcache_sb(sbi->sb);
 }
 
@@ -98,7 +97,10 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
 
         pkt.hdr.proto_version = sbi->version;
         pkt.hdr.type = type;
-        if (type == autofs_ptype_missing) {
+        switch (type) {
+        /* Kernel protocol v4 missing and expire packets */
+        case autofs_ptype_missing:
+        {
                 struct autofs_packet_missing *mp = &pkt.missing;
 
                 pktsz = sizeof(*mp);
@@ -107,7 +109,10 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
                 mp->len = wq->len;
                 memcpy(mp->name, wq->name, wq->len);
                 mp->name[wq->len] = '\0';
-        } else if (type == autofs_ptype_expire_multi) {
+                break;
+        }
+        case autofs_ptype_expire_multi:
+        {
                 struct autofs_packet_expire_multi *ep = &pkt.expire_multi;
 
                 pktsz = sizeof(*ep);
@@ -116,7 +121,34 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
                 ep->len = wq->len;
                 memcpy(ep->name, wq->name, wq->len);
                 ep->name[wq->len] = '\0';
-        } else {
+                break;
+        }
+        /*
+         * Kernel protocol v5 packet for handling indirect and direct
+         * mount missing and expire requests
+         */
+        case autofs_ptype_missing_indirect:
+        case autofs_ptype_expire_indirect:
+        case autofs_ptype_missing_direct:
+        case autofs_ptype_expire_direct:
+        {
+                struct autofs_v5_packet *packet = &pkt.v5_packet;
+
+                pktsz = sizeof(*packet);
+
+                packet->wait_queue_token = wq->wait_queue_token;
+                packet->len = wq->len;
+                memcpy(packet->name, wq->name, wq->len);
+                packet->name[wq->len] = '\0';
+                packet->dev = wq->dev;
+                packet->ino = wq->ino;
+                packet->uid = wq->uid;
+                packet->gid = wq->gid;
+                packet->pid = wq->pid;
+                packet->tgid = wq->tgid;
+                break;
+        }
+        default:
                 printk("autofs4_notify_daemon: bad type %d!\n", type);
                 return;
         }
@@ -162,21 +194,29 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
 {
         struct autofs_wait_queue *wq;
         char *name;
-        int len, status;
+        unsigned int len = 0;
+        unsigned int hash = 0;
+        int status;
 
         /* In catatonic mode, we don't wait for nobody */
-        if ( sbi->catatonic )
+        if (sbi->catatonic)
                 return -ENOENT;
         
         name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
         if (!name)
                 return -ENOMEM;
 
-        len = autofs4_getpath(sbi, dentry, &name);
-        if (!len) {
-                kfree(name);
-                return -ENOENT;
+        /* If this is a direct mount request create a dummy name */
+        if (IS_ROOT(dentry) && (sbi->type & AUTOFS_TYPE_DIRECT))
+                len = sprintf(name, "%p", dentry);
+        else {
+                len = autofs4_getpath(sbi, dentry, &name);
+                if (!len) {
+                        kfree(name);
+                        return -ENOENT;
+                }
         }
+        hash = full_name_hash(name, len);
 
         if (mutex_lock_interruptible(&sbi->wq_mutex)) {
                 kfree(name);
@@ -190,7 +230,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                         break;
         }
 
-        if ( !wq ) {
+        if (!wq) {
                 /* Can't wait for an expire if there's no mount */
                 if (notify == NFY_NONE && !d_mountpoint(dentry)) {
                         kfree(name);
@@ -200,7 +240,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
 
                 /* Create a new wait queue */
                 wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL);
-                if ( !wq ) {
+                if (!wq) {
                         kfree(name);
                         mutex_unlock(&sbi->wq_mutex);
                         return -ENOMEM;
@@ -212,12 +252,18 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                 wq->next = sbi->queues;
                 sbi->queues = wq;
                 init_waitqueue_head(&wq->queue);
-                wq->hash = dentry->d_name.hash;
+                wq->hash = hash;
                 wq->name = name;
                 wq->len = len;
+                wq->dev = autofs4_get_dev(sbi);
+                wq->ino = autofs4_get_ino(sbi);
+                wq->uid = current->uid;
+                wq->gid = current->gid;
+                wq->pid = current->pid;
+                wq->tgid = current->tgid;
                 wq->status = -EINTR; /* Status return if interrupted */
                 atomic_set(&wq->wait_ctr, 2);
-                atomic_set(&wq->notified, 1);
+                atomic_set(&wq->notify, 1);
                 mutex_unlock(&sbi->wq_mutex);
         } else {
                 atomic_inc(&wq->wait_ctr);
@@ -227,9 +273,26 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                         (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify);
         }
 
-        if (notify != NFY_NONE && atomic_dec_and_test(&wq->notified)) {
-                int type = (notify == NFY_MOUNT ?
-                        autofs_ptype_missing : autofs_ptype_expire_multi);
+        if (notify != NFY_NONE && atomic_read(&wq->notify)) {
+                int type;
+
+                atomic_dec(&wq->notify);
+
+                if (sbi->version < 5) {
+                        if (notify == NFY_MOUNT)
+                                type = autofs_ptype_missing;
+                        else
+                                type = autofs_ptype_expire_multi;
+                } else {
+                        if (notify == NFY_MOUNT)
+                                type = (sbi->type & AUTOFS_TYPE_DIRECT) ?
+                                        autofs_ptype_missing_direct :
+                                         autofs_ptype_missing_indirect;
+                        else
+                                type = (sbi->type & AUTOFS_TYPE_DIRECT) ?
+                                        autofs_ptype_expire_direct :
+                                        autofs_ptype_expire_indirect;
+                }
 
                 DPRINTK("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
                         (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify);
@@ -240,14 +303,14 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
 
         /* wq->name is NULL if and only if the lock is already released */
 
-        if ( sbi->catatonic ) {
+        if (sbi->catatonic) {
                 /* We might have slept, so check again for catatonic mode */
                 wq->status = -ENOENT;
                 kfree(wq->name);
                 wq->name = NULL;
         }
 
-        if ( wq->name ) {
+        if (wq->name) {
                 /* Block all but "shutdown" signals while waiting */
                 sigset_t oldset;
                 unsigned long irqflags;
@@ -283,12 +346,12 @@ int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_tok
         struct autofs_wait_queue *wq, **wql;
 
         mutex_lock(&sbi->wq_mutex);
-        for ( wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next ) {
-                if ( wq->wait_queue_token == wait_queue_token )
+        for (wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next) {
+                if (wq->wait_queue_token == wait_queue_token)
                         break;
         }
 
-        if ( !wq ) {
+        if (!wq) {
                 mutex_unlock(&sbi->wq_mutex);
                 return -EINVAL;
         }
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 5983d42df015..17c76182f389 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -266,6 +266,9 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
                 mutex_init(&bdev->bd_mount_mutex);
                 INIT_LIST_HEAD(&bdev->bd_inodes);
                 INIT_LIST_HEAD(&bdev->bd_list);
+#ifdef CONFIG_SYSFS
+                INIT_LIST_HEAD(&bdev->bd_holder_list);
+#endif
                 inode_init_once(&ei->vfs_inode);
         }
 }
@@ -490,6 +493,300 @@ void bd_release(struct block_device *bdev)
 
 EXPORT_SYMBOL(bd_release);
 
+#ifdef CONFIG_SYSFS
+/*
+ * Functions for bd_claim_by_kobject / bd_release_from_kobject
+ *
+ *     If a kobject is passed to bd_claim_by_kobject()
+ *     and the kobject has a parent directory,
+ *     following symlinks are created:
+ *        o from the kobject to the claimed bdev
+ *        o from "holders" directory of the bdev to the parent of the kobject
+ *     bd_release_from_kobject() removes these symlinks.
+ *
+ *     Example:
+ *        If /dev/dm-0 maps to /dev/sda, kobject corresponding to
+ *        /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
+ *           /sys/block/dm-0/slaves/sda --> /sys/block/sda
+ *           /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
+ */
+
+static struct kobject *bdev_get_kobj(struct block_device *bdev)
+{
+        if (bdev->bd_contains != bdev)
+                return kobject_get(&bdev->bd_part->kobj);
+        else
+                return kobject_get(&bdev->bd_disk->kobj);
+}
+
+static struct kobject *bdev_get_holder(struct block_device *bdev)
+{
+        if (bdev->bd_contains != bdev)
+                return kobject_get(bdev->bd_part->holder_dir);
+        else
+                return kobject_get(bdev->bd_disk->holder_dir);
+}
+
+static void add_symlink(struct kobject *from, struct kobject *to)
+{
+        if (!from || !to)
+                return;
+        sysfs_create_link(from, to, kobject_name(to));
+}
+
+static void del_symlink(struct kobject *from, struct kobject *to)
+{
+        if (!from || !to)
+                return;
+        sysfs_remove_link(from, kobject_name(to));
+}
+
+/*
+ * 'struct bd_holder' contains pointers to kobjects symlinked by
+ * bd_claim_by_kobject.
+ * It's connected to bd_holder_list which is protected by bdev->bd_sem.
+ */
+struct bd_holder {
+        struct list_head list;  /* chain of holders of the bdev */
+        int count;              /* references from the holder */
+        struct kobject *sdir;   /* holder object, e.g. "/block/dm-0/slaves" */
+        struct kobject *hdev;   /* e.g. "/block/dm-0" */
+        struct kobject *hdir;   /* e.g. "/block/sda/holders" */
+        struct kobject *sdev;   /* e.g. "/block/sda" */
+};
+
+/*
+ * Get references of related kobjects at once.
+ * Returns 1 on success. 0 on failure.
+ *
+ * Should call bd_holder_release_dirs() after successful use.
+ */
+static int bd_holder_grab_dirs(struct block_device *bdev,
+                        struct bd_holder *bo)
+{
+        if (!bdev || !bo)
+                return 0;
+
+        bo->sdir = kobject_get(bo->sdir);
+        if (!bo->sdir)
+                return 0;
+
+        bo->hdev = kobject_get(bo->sdir->parent);
+        if (!bo->hdev)
+                goto fail_put_sdir;
+
+        bo->sdev = bdev_get_kobj(bdev);
+        if (!bo->sdev)
+                goto fail_put_hdev;
+
+        bo->hdir = bdev_get_holder(bdev);
+        if (!bo->hdir)
+                goto fail_put_sdev;
+
+        return 1;
+
+fail_put_sdev:
+        kobject_put(bo->sdev);
+fail_put_hdev:
+        kobject_put(bo->hdev);
+fail_put_sdir:
+        kobject_put(bo->sdir);
+
+        return 0;
+}
+
+/* Put references of related kobjects at once. */
+static void bd_holder_release_dirs(struct bd_holder *bo)
+{
+        kobject_put(bo->hdir);
+        kobject_put(bo->sdev);
+        kobject_put(bo->hdev);
+        kobject_put(bo->sdir);
+}
+
+static struct bd_holder *alloc_bd_holder(struct kobject *kobj)
+{
+        struct bd_holder *bo;
+
+        bo = kzalloc(sizeof(*bo), GFP_KERNEL);
+        if (!bo)
+                return NULL;
+
+        bo->count = 1;
+        bo->sdir = kobj;
+
+        return bo;
+}
+
+static void free_bd_holder(struct bd_holder *bo)
+{
+        kfree(bo);
+}
+
+/**
+ * add_bd_holder - create sysfs symlinks for bd_claim() relationship
+ *
+ * @bdev:       block device to be bd_claimed
+ * @bo:         preallocated and initialized by alloc_bd_holder()
+ *
+ * If there is no matching entry with @bo in @bdev->bd_holder_list,
+ * add @bo to the list, create symlinks.
+ *
+ * Returns 1 if @bo was added to the list.
+ * Returns 0 if @bo wasn't used by any reason and should be freed.
+ */
+static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
+{
+        struct bd_holder *tmp;
+
+        if (!bo)
+                return 0;
+
+        list_for_each_entry(tmp, &bdev->bd_holder_list, list) {
+                if (tmp->sdir == bo->sdir) {
+                        tmp->count++;
+                        return 0;
+                }
+        }
+
+        if (!bd_holder_grab_dirs(bdev, bo))
+                return 0;
+
+        add_symlink(bo->sdir, bo->sdev);
+        add_symlink(bo->hdir, bo->hdev);
+        list_add_tail(&bo->list, &bdev->bd_holder_list);
+        return 1;
+}
+
+/**
+ * del_bd_holder - delete sysfs symlinks for bd_claim() relationship
+ *
+ * @bdev:       block device to be bd_claimed
+ * @kobj:       holder's kobject
+ *
+ * If there is matching entry with @kobj in @bdev->bd_holder_list
+ * and no other bd_claim() from the same kobject,
+ * remove the struct bd_holder from the list, delete symlinks for it.
+ *
+ * Returns a pointer to the struct bd_holder when it's removed from the list
+ * and ready to be freed.
+ * Returns NULL if matching claim isn't found or there is other bd_claim()
+ * by the same kobject.
+ */
+static struct bd_holder *del_bd_holder(struct block_device *bdev,
+                                        struct kobject *kobj)
+{
+        struct bd_holder *bo;
+
+        list_for_each_entry(bo, &bdev->bd_holder_list, list) {
+                if (bo->sdir == kobj) {
+                        bo->count--;
+                        BUG_ON(bo->count < 0);
+                        if (!bo->count) {
+                                list_del(&bo->list);
+                                del_symlink(bo->sdir, bo->sdev);
+                                del_symlink(bo->hdir, bo->hdev);
+                                bd_holder_release_dirs(bo);
+                                return bo;
+                        }
+                        break;
+                }
+        }
+
+        return NULL;
+}
+
+/**
+ * bd_claim_by_kobject - bd_claim() with additional kobject signature
+ *
+ * @bdev:       block device to be claimed
+ * @holder:     holder's signature
+ * @kobj:       holder's kobject
+ *
+ * Do bd_claim() and if it succeeds, create sysfs symlinks between
+ * the bdev and the holder's kobject.
+ * Use bd_release_from_kobject() when relesing the claimed bdev.
+ *
+ * Returns 0 on success. (same as bd_claim())
+ * Returns errno on failure.
+ */
+static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
+                                struct kobject *kobj)
+{
+        int res;
+        struct bd_holder *bo;
+
+        if (!kobj)
+                return -EINVAL;
+
+        bo = alloc_bd_holder(kobj);
+        if (!bo)
+                return -ENOMEM;
+
+        mutex_lock(&bdev->bd_mutex);
+        res = bd_claim(bdev, holder);
+        if (res || !add_bd_holder(bdev, bo))
+                free_bd_holder(bo);
+        mutex_unlock(&bdev->bd_mutex);
+
+        return res;
+}
+
+/**
+ * bd_release_from_kobject - bd_release() with additional kobject signature
+ *
+ * @bdev:       block device to be released
+ * @kobj:       holder's kobject
+ *
+ * Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
+ */
+static void bd_release_from_kobject(struct block_device *bdev,
+                                        struct kobject *kobj)
+{
+        struct bd_holder *bo;
+
+        if (!kobj)
+                return;
+
+        mutex_lock(&bdev->bd_mutex);
+        bd_release(bdev);
+        if ((bo = del_bd_holder(bdev, kobj)))
+                free_bd_holder(bo);
+        mutex_unlock(&bdev->bd_mutex);
+}
+
+/**
+ * bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
+ *
+ * @bdev:       block device to be claimed
+ * @holder:     holder's signature
+ * @disk:       holder's gendisk
+ *
+ * Call bd_claim_by_kobject() with getting @disk->slave_dir.
+ */
+int bd_claim_by_disk(struct block_device *bdev, void *holder,
+                        struct gendisk *disk)
+{
+        return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
+}
+EXPORT_SYMBOL_GPL(bd_claim_by_disk);
+
+/**
+ * bd_release_from_disk - wrapper function for bd_release_from_kobject()
+ *
+ * @bdev:       block device to be claimed
+ * @disk:       holder's gendisk
+ *
+ * Call bd_release_from_kobject() and put @disk->slave_dir.
+ */
+void bd_release_from_disk(struct block_device *bdev, struct gendisk *disk)
+{
+        bd_release_from_kobject(bdev, disk->slave_dir);
+        kobject_put(disk->slave_dir);
+}
+EXPORT_SYMBOL_GPL(bd_release_from_disk);
+#endif
+
 /*
  * Tries to open block device by device number.  Use it ONLY if you
  * really do not have anything better - i.e. when you are behind a
diff --git a/fs/buffer.c b/fs/buffer.c
index d597758dd129..23f1f3a68077 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -493,7 +493,7 @@ static void free_more_memory(void)
         wakeup_pdflush(1024);
         yield();
 
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 zones = pgdat->node_zonelists[gfp_zone(GFP_NOFS)].zones;
                 if (*zones)
                         try_to_free_pages(zones, GFP_NOFS);
diff --git a/fs/hostfs/hostfs_user.c b/fs/hostfs/hostfs_user.c
index b97809deba66..23b7cee72123 100644
--- a/fs/hostfs/hostfs_user.c
+++ b/fs/hostfs/hostfs_user.c
@@ -360,7 +360,6 @@ int do_statfs(char *root, long *bsize_out, long long *blocks_out,
         spare_out[2] = buf.f_spare[2];
         spare_out[3] = buf.f_spare[3];
         spare_out[4] = buf.f_spare[4];
-        spare_out[5] = buf.f_spare[5];
         return(0);
 }
 
diff --git a/fs/namei.c b/fs/namei.c
index 98dc2e134362..22f6e8d16aa8 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -546,6 +546,22 @@ struct path {
         struct dentry *dentry;
 };
 
+static inline void dput_path(struct path *path, struct nameidata *nd)
+{
+        dput(path->dentry);
+        if (path->mnt != nd->mnt)
+                mntput(path->mnt);
+}
+
+static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
+{
+        dput(nd->dentry);
+        if (nd->mnt != path->mnt)
+                mntput(nd->mnt);
+        nd->mnt = path->mnt;
+        nd->dentry = path->dentry;
+}
+
 static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd)
 {
         int error;
@@ -555,8 +571,11 @@ static __always_inline int __do_follow_link(struct path *path, struct nameidata
         touch_atime(path->mnt, dentry);
         nd_set_link(nd, NULL);
 
-        if (path->mnt == nd->mnt)
-                mntget(path->mnt);
+        if (path->mnt != nd->mnt) {
+                path_to_nameidata(path, nd);
+                dget(dentry);
+        }
+        mntget(path->mnt);
         cookie = dentry->d_inode->i_op->follow_link(dentry, nd);
         error = PTR_ERR(cookie);
         if (!IS_ERR(cookie)) {
@@ -573,22 +592,6 @@ static __always_inline int __do_follow_link(struct path *path, struct nameidata
         return error;
 }
 
-static inline void dput_path(struct path *path, struct nameidata *nd)
-{
-        dput(path->dentry);
-        if (path->mnt != nd->mnt)
-                mntput(path->mnt);
-}
-
-static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
-{
-        dput(nd->dentry);
-        if (nd->mnt != path->mnt)
-                mntput(nd->mnt);
-        nd->mnt = path->mnt;
-        nd->dentry = path->dentry;
-}
-
 /*
  * This limits recursive symlink follows to 8, while
  * limiting consecutive symlinks to 40.
diff --git a/fs/namespace.c b/fs/namespace.c
index e069a4c5e389..bf478addb852 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -459,9 +459,9 @@ int may_umount_tree(struct vfsmount *mnt)
         spin_unlock(&vfsmount_lock);
 
         if (actual_refs > minimum_refs)
-                return -EBUSY;
+                return 0;
 
-        return 0;
+        return 1;
 }
 
 EXPORT_SYMBOL(may_umount_tree);
@@ -481,10 +481,10 @@ EXPORT_SYMBOL(may_umount_tree);
  */
 int may_umount(struct vfsmount *mnt)
 {
-        int ret = 0;
+        int ret = 1;
         spin_lock(&vfsmount_lock);
         if (propagate_mount_busy(mnt, 2))
-                ret = -EBUSY;
+                ret = 0;
         spin_unlock(&vfsmount_lock);
         return ret;
 }
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 417ec02df44f..c340be0a3f59 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -57,27 +57,17 @@ static int		exp_verify_string(char *cp, int max);
 #define EXPKEY_HASHMASK         (EXPKEY_HASHMAX -1)
 static struct cache_head *expkey_table[EXPKEY_HASHMAX];
 
-static inline int svc_expkey_hash(struct svc_expkey *item)
+static void expkey_put(struct kref *ref)
 {
-        int hash = item->ek_fsidtype;
-        char * cp = (char*)item->ek_fsid;
-        int len = key_len(item->ek_fsidtype);
+        struct svc_expkey *key = container_of(ref, struct svc_expkey, h.ref);
 
-        hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
-        hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS);
-        return hash & EXPKEY_HASHMASK;
-}
-
-void expkey_put(struct cache_head *item, struct cache_detail *cd)
-{
-        if (cache_put(item, cd)) {
-                struct svc_expkey *key = container_of(item, struct svc_expkey, h);
-                if (test_bit(CACHE_VALID, &item->flags) &&
-                    !test_bit(CACHE_NEGATIVE, &item->flags))
-                        exp_put(key->ek_export);
-                auth_domain_put(key->ek_client);
-                kfree(key);
+        if (test_bit(CACHE_VALID, &key->h.flags) &&
+            !test_bit(CACHE_NEGATIVE, &key->h.flags)) {
+                dput(key->ek_dentry);
+                mntput(key->ek_mnt);
         }
+        auth_domain_put(key->ek_client);
+        kfree(key);
 }
 
 static void expkey_request(struct cache_detail *cd,
@@ -95,7 +85,10 @@ static void expkey_request(struct cache_detail *cd,
         (*bpp)[-1] = '\n';
 }
 
-static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *, int);
+static struct svc_expkey *svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old);
+static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *);
+static struct cache_detail svc_expkey_cache;
+
 static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
 {
         /* client fsidtype fsid [path] */
@@ -106,6 +99,7 @@ static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
         int fsidtype;
         char *ep;
         struct svc_expkey key;
+        struct svc_expkey *ek;
 
         if (mesg[mlen-1] != '\n')
                 return -EINVAL;
@@ -150,40 +144,38 @@ static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
         key.ek_fsidtype = fsidtype;
         memcpy(key.ek_fsid, buf, len);
 
+        ek = svc_expkey_lookup(&key);
+        err = -ENOMEM;
+        if (!ek)
+                goto out;
+
         /* now we want a pathname, or empty meaning NEGATIVE  */
+        err = -EINVAL;
         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) < 0)
                 goto out;
         dprintk("Path seems to be <%s>\n", buf);
         err = 0;
         if (len == 0) {
-                struct svc_expkey *ek;
                 set_bit(CACHE_NEGATIVE, &key.h.flags);
-                ek = svc_expkey_lookup(&key, 1);
+                ek = svc_expkey_update(&key, ek);
                 if (ek)
-                        expkey_put(&ek->h, &svc_expkey_cache);
+                        cache_put(&ek->h, &svc_expkey_cache);
+                else err = -ENOMEM;
         } else {
                 struct nameidata nd;
-                struct svc_expkey *ek;
-                struct svc_export *exp;
                 err = path_lookup(buf, 0, &nd);
                 if (err)
                         goto out;
 
                 dprintk("Found the path %s\n", buf);
-                exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
-
-                err = -ENOENT;
-                if (!exp)
-                        goto out_nd;
-                key.ek_export = exp;
-                dprintk("And found export\n");
+                key.ek_mnt = nd.mnt;
+                key.ek_dentry = nd.dentry;
                 
-                ek = svc_expkey_lookup(&key, 1);
+                ek = svc_expkey_update(&key, ek);
                 if (ek)
-                        expkey_put(&ek->h, &svc_expkey_cache);
-                exp_put(exp);
-                err = 0;
-        out_nd:
+                        cache_put(&ek->h, &svc_expkey_cache);
+                else
+                        err = -ENOMEM;
                 path_release(&nd);
         }
         cache_flush();
@@ -214,35 +206,31 @@ static int expkey_show(struct seq_file *m,
         if (test_bit(CACHE_VALID, &h->flags) && 
             !test_bit(CACHE_NEGATIVE, &h->flags)) {
                 seq_printf(m, " ");
-                seq_path(m, ek->ek_export->ex_mnt, ek->ek_export->ex_dentry, "\\ \t\n");
+                seq_path(m, ek->ek_mnt, ek->ek_dentry, "\\ \t\n");
         }
         seq_printf(m, "\n");
         return 0;
 }
-        
-struct cache_detail svc_expkey_cache = {
-        .owner          = THIS_MODULE,
-        .hash_size      = EXPKEY_HASHMAX,
-        .hash_table     = expkey_table,
-        .name           = "nfsd.fh",
-        .cache_put      = expkey_put,
-        .cache_request  = expkey_request,
-        .cache_parse    = expkey_parse,
-        .cache_show     = expkey_show,
-};
 
-static inline int svc_expkey_match (struct svc_expkey *a, struct svc_expkey *b)
+static inline int expkey_match (struct cache_head *a, struct cache_head *b)
 {
-        if (a->ek_fsidtype != b->ek_fsidtype ||
-            a->ek_client != b->ek_client ||
-            memcmp(a->ek_fsid, b->ek_fsid, key_len(a->ek_fsidtype)) != 0)
+        struct svc_expkey *orig = container_of(a, struct svc_expkey, h);
+        struct svc_expkey *new = container_of(b, struct svc_expkey, h);
+
+        if (orig->ek_fsidtype != new->ek_fsidtype ||
+            orig->ek_client != new->ek_client ||
+            memcmp(orig->ek_fsid, new->ek_fsid, key_len(orig->ek_fsidtype)) != 0)
                 return 0;
         return 1;
 }
 
-static inline void svc_expkey_init(struct svc_expkey *new, struct svc_expkey *item)
+static inline void expkey_init(struct cache_head *cnew,
+                                   struct cache_head *citem)
 {
-        cache_get(&item->ek_client->h);
+        struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
+        struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
+
+        kref_get(&item->ek_client->ref);
         new->ek_client = item->ek_client;
         new->ek_fsidtype = item->ek_fsidtype;
         new->ek_fsid[0] = item->ek_fsid[0];
@@ -250,39 +238,94 @@ static inline void svc_expkey_init(struct svc_expkey *new, struct svc_expkey *it
         new->ek_fsid[2] = item->ek_fsid[2];
 }
 
-static inline void svc_expkey_update(struct svc_expkey *new, struct svc_expkey *item)
+static inline void expkey_update(struct cache_head *cnew,
+                                   struct cache_head *citem)
+{
+        struct svc_expkey *new = container_of(cnew, struct svc_expkey, h);
+        struct svc_expkey *item = container_of(citem, struct svc_expkey, h);
+
+        new->ek_mnt = mntget(item->ek_mnt);
+        new->ek_dentry = dget(item->ek_dentry);
+}
+
+static struct cache_head *expkey_alloc(void)
 {
-        cache_get(&item->ek_export->h);
-        new->ek_export = item->ek_export;
+        struct svc_expkey *i = kmalloc(sizeof(*i), GFP_KERNEL);
+        if (i)
+                return &i->h;
+        else
+                return NULL;
 }
 
-static DefineSimpleCacheLookup(svc_expkey,0) /* no inplace updates */
+static struct cache_detail svc_expkey_cache = {
+        .owner          = THIS_MODULE,
+        .hash_size      = EXPKEY_HASHMAX,
+        .hash_table     = expkey_table,
+        .name           = "nfsd.fh",
+        .cache_put      = expkey_put,
+        .cache_request  = expkey_request,
+        .cache_parse    = expkey_parse,
+        .cache_show     = expkey_show,
+        .match          = expkey_match,
+        .init           = expkey_init,
+        .update         = expkey_update,
+        .alloc          = expkey_alloc,
+};
 
-#define EXPORT_HASHBITS         8
-#define EXPORT_HASHMAX          (1<< EXPORT_HASHBITS)
-#define EXPORT_HASHMASK         (EXPORT_HASHMAX -1)
+static struct svc_expkey *
+svc_expkey_lookup(struct svc_expkey *item)
+{
+        struct cache_head *ch;
+        int hash = item->ek_fsidtype;
+        char * cp = (char*)item->ek_fsid;
+        int len = key_len(item->ek_fsidtype);
 
-static struct cache_head *export_table[EXPORT_HASHMAX];
+        hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
+        hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS);
+        hash &= EXPKEY_HASHMASK;
 
-static inline int svc_export_hash(struct svc_export *item)
+        ch = sunrpc_cache_lookup(&svc_expkey_cache, &item->h,
+                                 hash);
+        if (ch)
+                return container_of(ch, struct svc_expkey, h);
+        else
+                return NULL;
+}
+
+static struct svc_expkey *
+svc_expkey_update(struct svc_expkey *new, struct svc_expkey *old)
 {
-        int rv;
+        struct cache_head *ch;
+        int hash = new->ek_fsidtype;
+        char * cp = (char*)new->ek_fsid;
+        int len = key_len(new->ek_fsidtype);
 
-        rv = hash_ptr(item->ex_client, EXPORT_HASHBITS);
-        rv ^= hash_ptr(item->ex_dentry, EXPORT_HASHBITS);
-        rv ^= hash_ptr(item->ex_mnt, EXPORT_HASHBITS);
-        return rv;
+        hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
+        hash ^= hash_ptr(new->ek_client, EXPKEY_HASHBITS);
+        hash &= EXPKEY_HASHMASK;
+
+        ch = sunrpc_cache_update(&svc_expkey_cache, &new->h,
+                                 &old->h, hash);
+        if (ch)
+                return container_of(ch, struct svc_expkey, h);
+        else
+                return NULL;
 }
 
-void svc_export_put(struct cache_head *item, struct cache_detail *cd)
+
+#define EXPORT_HASHBITS         8
+#define EXPORT_HASHMAX          (1<< EXPORT_HASHBITS)
+#define EXPORT_HASHMASK         (EXPORT_HASHMAX -1)
+
+static struct cache_head *export_table[EXPORT_HASHMAX];
+
+static void svc_export_put(struct kref *ref)
 {
-        if (cache_put(item, cd)) {
-                struct svc_export *exp = container_of(item, struct svc_export, h);
-                dput(exp->ex_dentry);
-                mntput(exp->ex_mnt);
-                auth_domain_put(exp->ex_client);
-                kfree(exp);
-        }
+        struct svc_export *exp = container_of(ref, struct svc_export, h.ref);
+        dput(exp->ex_dentry);
+        mntput(exp->ex_mnt);
+        auth_domain_put(exp->ex_client);
+        kfree(exp);
 }
 
 static void svc_export_request(struct cache_detail *cd,
@@ -304,7 +347,9 @@ static void svc_export_request(struct cache_detail *cd,
         (*bpp)[-1] = '\n';
 }
 
-static struct svc_export *svc_export_lookup(struct svc_export *, int);
+static struct svc_export *svc_export_update(struct svc_export *new,
+                                            struct svc_export *old);
+static struct svc_export *svc_export_lookup(struct svc_export *);
 
 static int check_export(struct inode *inode, int flags)
 {
@@ -417,11 +462,16 @@ static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
                 if (err) goto out;
         }
 
-        expp = svc_export_lookup(&exp, 1);
+        expp = svc_export_lookup(&exp);
         if (expp)
-                exp_put(expp);
-        err = 0;
+                expp = svc_export_update(&exp, expp);
+        else
+                err = -ENOMEM;
         cache_flush();
+        if (expp == NULL)
+                err = -ENOMEM;
+        else
+                exp_put(expp);
  out:
         if (nd.dentry)
                 path_release(&nd);
@@ -455,6 +505,46 @@ static int svc_export_show(struct seq_file *m,
         seq_puts(m, ")\n");
         return 0;
 }
+static int svc_export_match(struct cache_head *a, struct cache_head *b)
+{
+        struct svc_export *orig = container_of(a, struct svc_export, h);
+        struct svc_export *new = container_of(b, struct svc_export, h);
+        return orig->ex_client == new->ex_client &&
+                orig->ex_dentry == new->ex_dentry &&
+                orig->ex_mnt == new->ex_mnt;
+}
+
+static void svc_export_init(struct cache_head *cnew, struct cache_head *citem)
+{
+        struct svc_export *new = container_of(cnew, struct svc_export, h);
+        struct svc_export *item = container_of(citem, struct svc_export, h);
+
+        kref_get(&item->ex_client->ref);
+        new->ex_client = item->ex_client;
+        new->ex_dentry = dget(item->ex_dentry);
+        new->ex_mnt = mntget(item->ex_mnt);
+}
+
+static void export_update(struct cache_head *cnew, struct cache_head *citem)
+{
+        struct svc_export *new = container_of(cnew, struct svc_export, h);
+        struct svc_export *item = container_of(citem, struct svc_export, h);
+
+        new->ex_flags = item->ex_flags;
+        new->ex_anon_uid = item->ex_anon_uid;
+        new->ex_anon_gid = item->ex_anon_gid;
+        new->ex_fsid = item->ex_fsid;
+}
+
+static struct cache_head *svc_export_alloc(void)
+{
+        struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL);
+        if (i)
+                return &i->h;
+        else
+                return NULL;
+}
+
 struct cache_detail svc_export_cache = {
         .owner          = THIS_MODULE,
         .hash_size      = EXPORT_HASHMAX,
@@ -464,34 +554,49 @@ struct cache_detail svc_export_cache = {
         .cache_request  = svc_export_request,
         .cache_parse    = svc_export_parse,
         .cache_show     = svc_export_show,
+        .match          = svc_export_match,
+        .init           = svc_export_init,
+        .update         = export_update,
+        .alloc          = svc_export_alloc,
 };
 
-static inline int svc_export_match(struct svc_export *a, struct svc_export *b)
+static struct svc_export *
+svc_export_lookup(struct svc_export *exp)
 {
-        return a->ex_client == b->ex_client &&
-                a->ex_dentry == b->ex_dentry &&
-                a->ex_mnt == b->ex_mnt;
-}
-static inline void svc_export_init(struct svc_export *new, struct svc_export *item)
-{
-        cache_get(&item->ex_client->h);
-        new->ex_client = item->ex_client;
-        new->ex_dentry = dget(item->ex_dentry);
-        new->ex_mnt = mntget(item->ex_mnt);
+        struct cache_head *ch;
+        int hash;
+        hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS);
+        hash ^= hash_ptr(exp->ex_dentry, EXPORT_HASHBITS);
+        hash ^= hash_ptr(exp->ex_mnt, EXPORT_HASHBITS);
+
+        ch = sunrpc_cache_lookup(&svc_export_cache, &exp->h,
+                                 hash);
+        if (ch)
+                return container_of(ch, struct svc_export, h);
+        else
+                return NULL;
 }
 
-static inline void svc_export_update(struct svc_export *new, struct svc_export *item)
+static struct svc_export *
+svc_export_update(struct svc_export *new, struct svc_export *old)
 {
-        new->ex_flags = item->ex_flags;
-        new->ex_anon_uid = item->ex_anon_uid;
-        new->ex_anon_gid = item->ex_anon_gid;
-        new->ex_fsid = item->ex_fsid;
+        struct cache_head *ch;
+        int hash;
+        hash = hash_ptr(old->ex_client, EXPORT_HASHBITS);
+        hash ^= hash_ptr(old->ex_dentry, EXPORT_HASHBITS);
+        hash ^= hash_ptr(old->ex_mnt, EXPORT_HASHBITS);
+
+        ch = sunrpc_cache_update(&svc_export_cache, &new->h,
+                                 &old->h,
+                                 hash);
+        if (ch)
+                return container_of(ch, struct svc_export, h);
+        else
+                return NULL;
 }
 
-static DefineSimpleCacheLookup(svc_export,1) /* allow inplace updates */
 
-
-struct svc_expkey *
+static struct svc_expkey *
 exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
 {
         struct svc_expkey key, *ek;
@@ -504,7 +609,7 @@ exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
         key.ek_fsidtype = fsid_type;
         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 
-        ek = svc_expkey_lookup(&key, 0);
+        ek = svc_expkey_lookup(&key);
         if (ek != NULL)
                 if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
                         ek = ERR_PTR(err);
@@ -519,13 +624,16 @@ static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv,
         key.ek_client = clp;
         key.ek_fsidtype = fsid_type;
         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
-        key.ek_export = exp;
+        key.ek_mnt = exp->ex_mnt;
+        key.ek_dentry = exp->ex_dentry;
         key.h.expiry_time = NEVER;
         key.h.flags = 0;
 
-        ek = svc_expkey_lookup(&key, 1);
+        ek = svc_expkey_lookup(&key);
+        if (ek)
+                ek = svc_expkey_update(&key,ek);
         if (ek) {
-                expkey_put(&ek->h, &svc_expkey_cache);
+                cache_put(&ek->h, &svc_expkey_cache);
                 return 0;
         }
         return -ENOMEM;
@@ -573,7 +681,7 @@ exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
         key.ex_mnt = mnt;
         key.ex_dentry = dentry;
 
-        exp = svc_export_lookup(&key, 0);
+        exp = svc_export_lookup(&key);
         if (exp != NULL) 
                 switch (cache_check(&svc_export_cache, &exp->h, reqp)) {
                 case 0: break;
@@ -654,7 +762,7 @@ static void exp_fsid_unhash(struct svc_export *exp)
         ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
         if (ek && !IS_ERR(ek)) {
                 ek->h.expiry_time = get_seconds()-1;
-                expkey_put(&ek->h, &svc_expkey_cache);
+                cache_put(&ek->h, &svc_expkey_cache);
         }
         svc_expkey_cache.nextcheck = get_seconds();
 }
@@ -692,7 +800,7 @@ static void exp_unhash(struct svc_export *exp)
         ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
         if (ek && !IS_ERR(ek)) {
                 ek->h.expiry_time = get_seconds()-1;
-                expkey_put(&ek->h, &svc_expkey_cache);
+                cache_put(&ek->h, &svc_expkey_cache);
         }
         svc_expkey_cache.nextcheck = get_seconds();
 }
@@ -741,8 +849,8 @@ exp_export(struct nfsctl_export *nxp)
         if ((nxp->ex_flags & NFSEXP_FSID) &&
             (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
             !IS_ERR(fsid_key) &&
-            fsid_key->ek_export &&
-            fsid_key->ek_export != exp)
+            fsid_key->ek_mnt &&
+            (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
                 goto finish;
 
         if (exp) {
@@ -775,13 +883,13 @@ exp_export(struct nfsctl_export *nxp)
         new.ex_anon_gid = nxp->ex_anon_gid;
         new.ex_fsid = nxp->ex_dev;
 
-        exp = svc_export_lookup(&new, 1);
+        exp = svc_export_lookup(&new);
+        if (exp)
+                exp = svc_export_update(&new, exp);
 
-        if (exp == NULL)
+        if (!exp)
                 goto finish;
 
-        err = 0;
-
         if (exp_hash(clp, exp) ||
             exp_fsid_hash(clp, exp)) {
                 /* failed to create at least one index */
@@ -794,7 +902,7 @@ finish:
         if (exp)
                 exp_put(exp);
         if (fsid_key && !IS_ERR(fsid_key))
-                expkey_put(&fsid_key->h, &svc_expkey_cache);
+                cache_put(&fsid_key->h, &svc_expkey_cache);
         if (clp)
                 auth_domain_put(clp);
         path_release(&nd);
@@ -912,6 +1020,24 @@ out:
         return err;
 }
 
+struct svc_export *
+exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
+         struct cache_req *reqp)
+{
+        struct svc_export *exp;
+        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
+        if (!ek || IS_ERR(ek))
+                return ERR_PTR(PTR_ERR(ek));
+
+        exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
+        cache_put(&ek->h, &svc_expkey_cache);
+
+        if (!exp || IS_ERR(exp))
+                return ERR_PTR(PTR_ERR(exp));
+        return exp;
+}
+
+
 /*
  * Called when we need the filehandle for the root of the pseudofs,
  * for a given NFSv4 client.   The root is defined to be the
@@ -922,6 +1048,7 @@ exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
                struct cache_req *creq)
 {
         struct svc_expkey *fsid_key;
+        struct svc_export *exp;
         int rv;
         u32 fsidv[2];
 
@@ -933,9 +1060,15 @@ exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
         if (!fsid_key || IS_ERR(fsid_key))
                 return nfserr_perm;
 
-        rv = fh_compose(fhp, fsid_key->ek_export, 
-                          fsid_key->ek_export->ex_dentry, NULL);
-        expkey_put(&fsid_key->h, &svc_expkey_cache);
+        exp = exp_get_by_name(clp, fsid_key->ek_mnt, fsid_key->ek_dentry, creq);
+        if (exp == NULL)
+                rv = nfserr_perm;
+        else if (IS_ERR(exp))
+                rv = nfserrno(PTR_ERR(exp));
+        else
+                rv = fh_compose(fhp, exp,
+                                fsid_key->ek_dentry, NULL);
+        cache_put(&fsid_key->h, &svc_expkey_cache);
         return rv;
 }
 
@@ -1054,7 +1187,7 @@ static int e_show(struct seq_file *m, void *p)
         cache_get(&exp->h);
         if (cache_check(&svc_export_cache, &exp->h, NULL))
                 return 0;
-        if (cache_put(&exp->h, &svc_export_cache)) BUG();
+        cache_put(&exp->h, &svc_export_cache);
         return svc_export_show(m, &svc_export_cache, cp);
 }
 
@@ -1129,7 +1262,6 @@ exp_delclient(struct nfsctl_client *ncp)
          */
         if (dom) {
                 err = auth_unix_forget_old(dom);
-                dom->h.expiry_time = get_seconds();
                 auth_domain_put(dom);
         }
 
diff --git a/fs/nfsd/nfs4idmap.c b/fs/nfsd/nfs4idmap.c
index 13369650cdf9..4b6aa60dfceb 100644
--- a/fs/nfsd/nfs4idmap.c
+++ b/fs/nfsd/nfs4idmap.c
@@ -76,21 +76,18 @@ struct ent {
         char              authname[IDMAP_NAMESZ];
 };
 
-#define DefineSimpleCacheLookupMap(STRUCT, FUNC)                        \
-        DefineCacheLookup(struct STRUCT, h, FUNC##_lookup,              \
-        (struct STRUCT *item, int set), /*no setup */,                  \
-        & FUNC##_cache, FUNC##_hash(item), FUNC##_match(item, tmp),     \
-        STRUCT##_init(new, item), STRUCT##_update(tmp, item), 0)
-
 /* Common entry handling */
 
 #define ENT_HASHBITS          8
 #define ENT_HASHMAX           (1 << ENT_HASHBITS)
 #define ENT_HASHMASK          (ENT_HASHMAX - 1)
 
-static inline void
-ent_init(struct ent *new, struct ent *itm)
+static void
+ent_init(struct cache_head *cnew, struct cache_head *citm)
 {
+        struct ent *new = container_of(cnew, struct ent, h);
+        struct ent *itm = container_of(citm, struct ent, h);
+
         new->id = itm->id;
         new->type = itm->type;
 
@@ -98,19 +95,21 @@ ent_init(struct ent *new, struct ent *itm)
         strlcpy(new->authname, itm->authname, sizeof(new->name));
 }
 
-static inline void
-ent_update(struct ent *new, struct ent *itm)
+static void
+ent_put(struct kref *ref)
 {
-        ent_init(new, itm);
+        struct ent *map = container_of(ref, struct ent, h.ref);
+        kfree(map);
 }
 
-static void
-ent_put(struct cache_head *ch, struct cache_detail *cd)
+static struct cache_head *
+ent_alloc(void)
 {
-        if (cache_put(ch, cd)) {
-                struct ent *map = container_of(ch, struct ent, h);
-                kfree(map);
-        }
+        struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
+        if (e)
+                return &e->h;
+        else
+                return NULL;
 }
 
 /*
@@ -149,9 +148,12 @@ idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
         (*bpp)[-1] = '\n';
 }
 
-static inline int
-idtoname_match(struct ent *a, struct ent *b)
+static int
+idtoname_match(struct cache_head *ca, struct cache_head *cb)
 {
+        struct ent *a = container_of(ca, struct ent, h);
+        struct ent *b = container_of(cb, struct ent, h);
+
         return (a->id == b->id && a->type == b->type &&
             strcmp(a->authname, b->authname) == 0);
 }
@@ -184,7 +186,8 @@ warn_no_idmapd(struct cache_detail *detail)
 
 
 static int         idtoname_parse(struct cache_detail *, char *, int);
-static struct ent *idtoname_lookup(struct ent *, int);
+static struct ent *idtoname_lookup(struct ent *);
+static struct ent *idtoname_update(struct ent *, struct ent *);
 
 static struct cache_detail idtoname_cache = {
         .owner          = THIS_MODULE,
@@ -196,6 +199,10 @@ static struct cache_detail idtoname_cache = {
         .cache_parse    = idtoname_parse,
         .cache_show     = idtoname_show,
         .warn_no_listener = warn_no_idmapd,
+        .match          = idtoname_match,
+        .init           = ent_init,
+        .update         = ent_init,
+        .alloc          = ent_alloc,
 };
 
 int
@@ -238,6 +245,11 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
         if (ent.h.expiry_time == 0)
                 goto out;
 
+        error = -ENOMEM;
+        res = idtoname_lookup(&ent);
+        if (!res)
+                goto out;
+
         /* Name */
         error = qword_get(&buf, buf1, PAGE_SIZE);
         if (error == -EINVAL)
@@ -252,10 +264,11 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
                 memcpy(ent.name, buf1, sizeof(ent.name));
         }
         error = -ENOMEM;
-        if ((res = idtoname_lookup(&ent, 1)) == NULL)
+        res = idtoname_update(&ent, res);
+        if (res == NULL)
                 goto out;
 
-        ent_put(&res->h, &idtoname_cache);
+        cache_put(&res->h, &idtoname_cache);
 
         error = 0;
 out:
@@ -264,7 +277,31 @@ out:
         return error;
 }
 
-static DefineSimpleCacheLookupMap(ent, idtoname);
+
+static struct ent *
+idtoname_lookup(struct ent *item)
+{
+        struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,
+                                                    &item->h,
+                                                    idtoname_hash(item));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
+
+static struct ent *
+idtoname_update(struct ent *new, struct ent *old)
+{
+        struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,
+                                                    &new->h, &old->h,
+                                                    idtoname_hash(new));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
+
 
 /*
  * Name -> ID cache
@@ -291,9 +328,12 @@ nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
         (*bpp)[-1] = '\n';
 }
 
-static inline int
-nametoid_match(struct ent *a, struct ent *b)
+static int
+nametoid_match(struct cache_head *ca, struct cache_head *cb)
 {
+        struct ent *a = container_of(ca, struct ent, h);
+        struct ent *b = container_of(cb, struct ent, h);
+
         return (a->type == b->type && strcmp(a->name, b->name) == 0 &&
             strcmp(a->authname, b->authname) == 0);
 }
@@ -317,7 +357,8 @@ nametoid_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
         return 0;
 }
 
-static struct ent *nametoid_lookup(struct ent *, int);
+static struct ent *nametoid_lookup(struct ent *);
+static struct ent *nametoid_update(struct ent *, struct ent *);
 static int         nametoid_parse(struct cache_detail *, char *, int);
 
 static struct cache_detail nametoid_cache = {
@@ -330,6 +371,10 @@ static struct cache_detail nametoid_cache = {
         .cache_parse    = nametoid_parse,
         .cache_show     = nametoid_show,
         .warn_no_listener = warn_no_idmapd,
+        .match          = nametoid_match,
+        .init           = ent_init,
+        .update         = ent_init,
+        .alloc          = ent_alloc,
 };
 
 static int
@@ -379,10 +424,14 @@ nametoid_parse(struct cache_detail *cd, char *buf, int buflen)
                 set_bit(CACHE_NEGATIVE, &ent.h.flags);
 
         error = -ENOMEM;
-        if ((res = nametoid_lookup(&ent, 1)) == NULL)
+        res = nametoid_lookup(&ent);
+        if (res == NULL)
+                goto out;
+        res = nametoid_update(&ent, res);
+        if (res == NULL)
                 goto out;
 
-        ent_put(&res->h, &nametoid_cache);
+        cache_put(&res->h, &nametoid_cache);
         error = 0;
 out:
         kfree(buf1);
@@ -390,7 +439,30 @@ out:
         return (error);
 }
 
-static DefineSimpleCacheLookupMap(ent, nametoid);
+
+static struct ent *
+nametoid_lookup(struct ent *item)
+{
+        struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,
+                                                    &item->h,
+                                                    nametoid_hash(item));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
+
+static struct ent *
+nametoid_update(struct ent *new, struct ent *old)
+{
+        struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,
+                                                    &new->h, &old->h,
+                                                    nametoid_hash(new));
+        if (ch)
+                return container_of(ch, struct ent, h);
+        else
+                return NULL;
+}
 
 /*
  * Exported API
@@ -458,24 +530,24 @@ idmap_defer(struct cache_req *req)
 }
 
 static inline int
-do_idmap_lookup(struct ent *(*lookup_fn)(struct ent *, int), struct ent *key,
+do_idmap_lookup(struct ent *(*lookup_fn)(struct ent *), struct ent *key,
                 struct cache_detail *detail, struct ent **item,
                 struct idmap_defer_req *mdr)
 {
-        *item = lookup_fn(key, 0);
+        *item = lookup_fn(key);
         if (!*item)
                 return -ENOMEM;
         return cache_check(detail, &(*item)->h, &mdr->req);
 }
 
 static inline int
-do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *, int),
+do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *),
                         struct ent *key, struct cache_detail *detail,
                         struct ent **item)
 {
         int ret = -ENOMEM;
 
-        *item = lookup_fn(key, 0);
+        *item = lookup_fn(key);
         if (!*item)
                 goto out_err;
         ret = -ETIMEDOUT;
@@ -488,7 +560,7 @@ do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *, int),
                 goto out_put;
         return 0;
 out_put:
-        ent_put(&(*item)->h, detail);
+        cache_put(&(*item)->h, detail);
 out_err:
         *item = NULL;
         return ret;
@@ -496,7 +568,7 @@ out_err:
 
 static int
 idmap_lookup(struct svc_rqst *rqstp,
-                struct ent *(*lookup_fn)(struct ent *, int), struct ent *key,
+                struct ent *(*lookup_fn)(struct ent *), struct ent *key,
                 struct cache_detail *detail, struct ent **item)
 {
         struct idmap_defer_req *mdr;
@@ -539,7 +611,7 @@ idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen
         if (ret)
                 return ret;
         *id = item->id;
-        ent_put(&item->h, &nametoid_cache);
+        cache_put(&item->h, &nametoid_cache);
         return 0;
 }
 
@@ -561,7 +633,7 @@ idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
         ret = strlen(item->name);
         BUG_ON(ret > IDMAP_NAMESZ);
         memcpy(name, item->name, ret);
-        ent_put(&item->h, &idtoname_cache);
+        cache_put(&item->h, &idtoname_cache);
         return ret;
 }
 
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 7a3e397b4ed3..3f2ec2e6d06c 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -506,7 +506,7 @@ fh_put(struct svc_fh *fhp)
                 nfsd_nr_put++;
         }
         if (exp) {
-                svc_export_put(&exp->h, &svc_export_cache);
+                cache_put(&exp->h, &svc_export_cache);
                 fhp->fh_export = NULL;
         }
         return;
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index f924f459bdb8..af0cb4b9e784 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -297,6 +297,25 @@ struct kobj_type ktype_part = {
         .sysfs_ops      = &part_sysfs_ops,
 };
 
+static inline void partition_sysfs_add_subdir(struct hd_struct *p)
+{
+        struct kobject *k;
+
+        k = kobject_get(&p->kobj);
+        p->holder_dir = kobject_add_dir(k, "holders");
+        kobject_put(k);
+}
+
+static inline void disk_sysfs_add_subdirs(struct gendisk *disk)
+{
+        struct kobject *k;
+
+        k = kobject_get(&disk->kobj);
+        disk->holder_dir = kobject_add_dir(k, "holders");
+        disk->slave_dir = kobject_add_dir(k, "slaves");
+        kobject_put(k);
+}
+
 void delete_partition(struct gendisk *disk, int part)
 {
         struct hd_struct *p = disk->part[part-1];
@@ -310,6 +329,8 @@ void delete_partition(struct gendisk *disk, int part)
         p->ios[0] = p->ios[1] = 0;
         p->sectors[0] = p->sectors[1] = 0;
         devfs_remove("%s/part%d", disk->devfs_name, part);
+        if (p->holder_dir)
+                kobject_unregister(p->holder_dir);
         kobject_unregister(&p->kobj);
 }
 
@@ -337,6 +358,7 @@ void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len)
         p->kobj.parent = &disk->kobj;
         p->kobj.ktype = &ktype_part;
         kobject_register(&p->kobj);
+        partition_sysfs_add_subdir(p);
         disk->part[part-1] = p;
 }
 
@@ -383,6 +405,7 @@ void register_disk(struct gendisk *disk)
         if ((err = kobject_add(&disk->kobj)))
                 return;
         disk_sysfs_symlinks(disk);
+        disk_sysfs_add_subdirs(disk);
         kobject_uevent(&disk->kobj, KOBJ_ADD);
 
         /* No minors to use for partitions */
@@ -483,6 +506,10 @@ void del_gendisk(struct gendisk *disk)
 
         devfs_remove_disk(disk);
 
+        if (disk->holder_dir)
+                kobject_unregister(disk->holder_dir);
+        if (disk->slave_dir)
+                kobject_unregister(disk->slave_dir);
         if (disk->driverfs_dev) {
                 char *disk_name = make_block_name(disk);
                 sysfs_remove_link(&disk->kobj, "device");
diff --git a/include/asm-alpha/mmzone.h b/include/asm-alpha/mmzone.h
index a011ef4cf3d3..192d80c875b0 100644
--- a/include/asm-alpha/mmzone.h
+++ b/include/asm-alpha/mmzone.h
@@ -59,9 +59,6 @@ PLAT_NODE_DATA_LOCALNR(unsigned long p, int n)
 #define kvaddr_to_nid(kaddr)    pa_to_nid(__pa(kaddr))
 #define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
 
-#define local_mapnr(kvaddr) \
-      ((__pa(kvaddr) >> PAGE_SHIFT) - node_start_pfn(kvaddr_to_nid(kvaddr)))
-
 /*
  * Given a kaddr, LOCAL_BASE_ADDR finds the owning node of the memory
  * and returns the kaddr corresponding to first physical page in the
@@ -86,8 +83,7 @@ PLAT_NODE_DATA_LOCALNR(unsigned long p, int n)
         pte_t pte;                                                           \
         unsigned long pfn;                                                   \
                                                                              \
-        pfn = ((unsigned long)((page)-page_zone(page)->zone_mem_map)) << 32; \
-        pfn += page_zone(page)->zone_start_pfn << 32;                        \
+        pfn = page_to_pfn(page) << 32; \
         pte_val(pte) = pfn | pgprot_val(pgprot);                             \
                                                                              \
         pte;                                                                 \
@@ -104,19 +100,8 @@ PLAT_NODE_DATA_LOCALNR(unsigned long p, int n)
         __xx;                                                           \
 })
 
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long kaddr = (unsigned long)__va((pfn) << PAGE_SHIFT); \
-        (NODE_DATA(kvaddr_to_nid(kaddr))->node_mem_map + local_mapnr(kaddr));   \
-})
-
-#define page_to_pfn(page)                                               \
-        ((page) - page_zone(page)->zone_mem_map +                       \
-         (page_zone(page)->zone_start_pfn))
-
 #define page_to_pa(page)                                                \
-        ((( (page) - page_zone(page)->zone_mem_map )                    \
-        + page_zone(page)->zone_start_pfn) << PAGE_SHIFT)
+        (page_to_pfn(page) << PAGE_SHIFT)
 
 #define pfn_to_nid(pfn)         pa_to_nid(((u64)(pfn) << PAGE_SHIFT))
 #define pfn_valid(pfn)                                                  \
diff --git a/include/asm-alpha/page.h b/include/asm-alpha/page.h
index fa0b41b164a7..61bcf70b5eac 100644
--- a/include/asm-alpha/page.h
+++ b/include/asm-alpha/page.h
@@ -85,8 +85,6 @@ typedef unsigned long pgprot_t;
 #define __pa(x)                 ((unsigned long) (x) - PAGE_OFFSET)
 #define __va(x)                 ((void *)((unsigned long) (x) + PAGE_OFFSET))
 #ifndef CONFIG_DISCONTIGMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
@@ -95,9 +93,9 @@ typedef unsigned long pgprot_t;
 
 #define VM_DATA_DEFAULT_FLAGS           (VM_READ | VM_WRITE | VM_EXEC | \
                                          VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
-
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _ALPHA_PAGE_H */
diff --git a/include/asm-arm/memory.h b/include/asm-arm/memory.h
index b4e1146ab682..afa5c3ea077c 100644
--- a/include/asm-arm/memory.h
+++ b/include/asm-arm/memory.h
@@ -172,9 +172,7 @@ static inline __deprecated void *bus_to_virt(unsigned long x)
  *  virt_addr_valid(k)  indicates whether a virtual address is valid
  */
 #ifndef CONFIG_DISCONTIGMEM
-
-#define page_to_pfn(page)       (((page) - mem_map) + PHYS_PFN_OFFSET)
-#define pfn_to_page(pfn)        ((mem_map + (pfn)) - PHYS_PFN_OFFSET)
+#define ARCH_PFN_OFFSET         (PHYS_PFN_OFFSET)
 #define pfn_valid(pfn)          ((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
 
 #define virt_to_page(kaddr)     (pfn_to_page(__pa(kaddr) >> PAGE_SHIFT))
@@ -189,13 +187,8 @@ static inline __deprecated void *bus_to_virt(unsigned long x)
  * around in memory.
  */
 #include <linux/numa.h>
-
-#define page_to_pfn(page)                                       \
-        (( (page) - page_zone(page)->zone_mem_map)              \
-          + page_zone(page)->zone_start_pfn)
-
-#define pfn_to_page(pfn)                                        \
-        (PFN_TO_MAPBASE(pfn) + LOCAL_MAP_NR((pfn) << PAGE_SHIFT))
+#define arch_pfn_to_nid(pfn)    (PFN_TO_NID(pfn))
+#define arch_local_page_offset(pfn, nid) (LOCAL_MAP_NR((pfn) << PAGE_OFFSET))
 
 #define pfn_valid(pfn)                                          \
         ({                                                      \
@@ -243,4 +236,6 @@ static inline __deprecated void *bus_to_virt(unsigned long x)
 
 #endif
 
+#include <asm-generic/memory_model.h>
+
 #endif
diff --git a/include/asm-arm/rtc.h b/include/asm-arm/rtc.h
index 370dfe77589d..1a5c9232a91e 100644
--- a/include/asm-arm/rtc.h
+++ b/include/asm-arm/rtc.h
@@ -25,9 +25,6 @@ struct rtc_ops {
         int             (*proc)(char *buf);
 };
 
-void rtc_time_to_tm(unsigned long, struct rtc_time *);
-int rtc_tm_to_time(struct rtc_time *, unsigned long *);
-int rtc_valid_tm(struct rtc_time *);
 void rtc_next_alarm_time(struct rtc_time *, struct rtc_time *, struct rtc_time *);
 void rtc_update(unsigned long, unsigned long);
 int register_rtc(struct rtc_ops *);
diff --git a/include/asm-arm26/memory.h b/include/asm-arm26/memory.h
index 20d78616f650..a65f10b80dfb 100644
--- a/include/asm-arm26/memory.h
+++ b/include/asm-arm26/memory.h
@@ -81,8 +81,7 @@ static inline void *phys_to_virt(unsigned long x)
  *  virt_to_page(k)     convert a _valid_ virtual address to struct page *
  *  virt_addr_valid(k)  indicates whether a virtual address is valid
  */
-#define page_to_pfn(page)       (((page) - mem_map) + PHYS_PFN_OFFSET)
-#define pfn_to_page(pfn)        ((mem_map + (pfn)) - PHYS_PFN_OFFSET)
+#define ARCH_PFN_OFFSET         (PHYS_PFN_OFFSET)
 #define pfn_valid(pfn)          ((pfn) >= PHYS_PFN_OFFSET && (pfn) < (PHYS_PFN_OFFSET + max_mapnr))
 
 #define virt_to_page(kaddr)     (pfn_to_page(__pa(kaddr) >> PAGE_SHIFT))
@@ -98,4 +97,5 @@ static inline void *phys_to_virt(unsigned long x)
  */
 #define page_to_bus(page)       (page_address(page))
 
+#include <asm-generic/memory_model.h>
 #endif
diff --git a/include/asm-cris/page.h b/include/asm-cris/page.h
index c99c478c482f..3787633e6209 100644
--- a/include/asm-cris/page.h
+++ b/include/asm-cris/page.h
@@ -43,8 +43,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 /* On CRIS the PFN numbers doesn't start at 0 so we have to compensate */
 /* for that before indexing into the page table starting at mem_map    */
-#define pfn_to_page(pfn)        (mem_map + ((pfn) - (PAGE_OFFSET >> PAGE_SHIFT)))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + (PAGE_OFFSET >> PAGE_SHIFT))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
 #define pfn_valid(pfn)          (((pfn) - (PAGE_OFFSET >> PAGE_SHIFT)) < max_mapnr)
 
 /* to index into the page map. our pages all start at physical addr PAGE_OFFSET so
@@ -77,6 +76,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _CRIS_PAGE_H */
diff --git a/include/asm-frv/futex.h b/include/asm-frv/futex.h
index fca9d90e32c9..08b3d1da3583 100644
--- a/include/asm-frv/futex.h
+++ b/include/asm-frv/futex.h
@@ -9,5 +9,11 @@
 
 extern int futex_atomic_op_inuser(int encoded_op, int __user *uaddr);
 
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
+
 #endif
 #endif
diff --git a/include/asm-frv/page.h b/include/asm-frv/page.h
index b8221b611b5c..dc0f7e08a4c2 100644
--- a/include/asm-frv/page.h
+++ b/include/asm-frv/page.h
@@ -57,13 +57,9 @@ extern unsigned long min_low_pfn;
 extern unsigned long max_pfn;
 
 #ifdef CONFIG_MMU
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long) ((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
-
 #else
-#define pfn_to_page(pfn)        (&mem_map[(pfn) - (PAGE_OFFSET >> PAGE_SHIFT)])
-#define page_to_pfn(page)       ((PAGE_OFFSET >> PAGE_SHIFT) + (unsigned long) ((page) - mem_map))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
 #define pfn_valid(pfn)          ((pfn) >= min_low_pfn && (pfn) < max_low_pfn)
 
 #endif
@@ -87,6 +83,7 @@ extern unsigned long max_pfn;
 #define WANT_PAGE_VIRTUAL       1
 #endif
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _ASM_PAGE_H */
diff --git a/include/asm-generic/futex.h b/include/asm-generic/futex.h
index 3ae2c7347549..df893c160318 100644
--- a/include/asm-generic/futex.h
+++ b/include/asm-generic/futex.h
@@ -49,5 +49,11 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
         return ret;
 }
 
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
+
 #endif
 #endif
diff --git a/include/asm-generic/memory_model.h b/include/asm-generic/memory_model.h
new file mode 100644
index 000000000000..0cfb086dd373
--- /dev/null
+++ b/include/asm-generic/memory_model.h
@@ -0,0 +1,77 @@
+#ifndef __ASM_MEMORY_MODEL_H
+#define __ASM_MEMORY_MODEL_H
+
+#ifdef __KERNEL__
+#ifndef __ASSEMBLY__
+
+#if defined(CONFIG_FLATMEM)
+
+#ifndef ARCH_PFN_OFFSET
+#define ARCH_PFN_OFFSET         (0UL)
+#endif
+
+#elif defined(CONFIG_DISCONTIGMEM)
+
+#ifndef arch_pfn_to_nid
+#define arch_pfn_to_nid(pfn)    pfn_to_nid(pfn)
+#endif
+
+#ifndef arch_local_page_offset
+#define arch_local_page_offset(pfn, nid)        \
+        ((pfn) - NODE_DATA(nid)->node_start_pfn)
+#endif
+
+#endif /* CONFIG_DISCONTIGMEM */
+
+#ifdef CONFIG_OUT_OF_LINE_PFN_TO_PAGE
+struct page;
+/* this is useful when inlined pfn_to_page is too big */
+extern struct page *pfn_to_page(unsigned long pfn);
+extern unsigned long page_to_pfn(struct page *page);
+#else
+/*
+ * supports 3 memory models.
+ */
+#if defined(CONFIG_FLATMEM)
+
+#define pfn_to_page(pfn)        (mem_map + ((pfn) - ARCH_PFN_OFFSET))
+#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + \
+                                 ARCH_PFN_OFFSET)
+#elif defined(CONFIG_DISCONTIGMEM)
+
+#define pfn_to_page(pfn)                        \
+({      unsigned long __pfn = (pfn);            \
+        unsigned long __nid = arch_pfn_to_nid(pfn);  \
+        NODE_DATA(__nid)->node_mem_map + arch_local_page_offset(__pfn, __nid);\
+})
+
+#define page_to_pfn(pg)                                                 \
+({      struct page *__pg = (pg);                                       \
+        struct pglist_data *__pgdat = NODE_DATA(page_to_nid(__pg));     \
+        (unsigned long)(__pg - __pgdat->node_mem_map) +                 \
+         __pgdat->node_start_pfn;                                       \
+})
+
+#elif defined(CONFIG_SPARSEMEM)
+/*
+ * Note: section's mem_map is encorded to reflect its start_pfn.
+ * section[i].section_mem_map == mem_map's address - start_pfn;
+ */
+#define page_to_pfn(pg)                                 \
+({      struct page *__pg = (pg);                               \
+        int __sec = page_to_section(__pg);                      \
+        __pg - __section_mem_map_addr(__nr_to_section(__sec));  \
+})
+
+#define pfn_to_page(pfn)                                \
+({      unsigned long __pfn = (pfn);                    \
+        struct mem_section *__sec = __pfn_to_section(__pfn);    \
+        __section_mem_map_addr(__sec) + __pfn;          \
+})
+#endif /* CONFIG_FLATMEM/DISCONTIGMEM/SPARSEMEM */
+#endif /* CONFIG_OUT_OF_LINE_PFN_TO_PAGE */
+
+#endif /* __ASSEMBLY__ */
+#endif /* __KERNEL__ */
+
+#endif
diff --git a/include/asm-h8300/page.h b/include/asm-h8300/page.h
index cd35b1cc6cde..6472c9f88227 100644
--- a/include/asm-h8300/page.h
+++ b/include/asm-h8300/page.h
@@ -71,8 +71,7 @@ extern unsigned long memory_end;
 #define page_to_virt(page)      ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
 #define pfn_valid(page)         (page < max_mapnr)
 
-#define pfn_to_page(pfn)        virt_to_page(pfn_to_virt(pfn))
-#define page_to_pfn(page)       virt_to_pfn(page_to_virt(page))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
 
 #define virt_addr_valid(kaddr)  (((void *)(kaddr) >= (void *)PAGE_OFFSET) && \
                                 ((void *)(kaddr) < (void *)memory_end))
@@ -81,6 +80,7 @@ extern unsigned long memory_end;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _H8300_PAGE_H */
diff --git a/include/asm-i386/futex.h b/include/asm-i386/futex.h
index 44b9db806474..7b8ceefd010f 100644
--- a/include/asm-i386/futex.h
+++ b/include/asm-i386/futex.h
@@ -104,5 +104,32 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
         return ret;
 }
 
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        if (!access_ok(VERIFY_WRITE, uaddr, sizeof(int)))
+                return -EFAULT;
+
+        __asm__ __volatile__(
+                "1:     " LOCK_PREFIX "cmpxchgl %3, %1          \n"
+
+                "2:     .section .fixup, \"ax\"                 \n"
+                "3:     mov     %2, %0                          \n"
+                "       jmp     2b                              \n"
+                "       .previous                               \n"
+
+                "       .section __ex_table, \"a\"              \n"
+                "       .align  8                               \n"
+                "       .long   1b,3b                           \n"
+                "       .previous                               \n"
+
+                : "=a" (oldval), "=m" (*uaddr)
+                : "i" (-EFAULT), "r" (newval), "0" (oldval)
+                : "memory"
+        );
+
+        return oldval;
+}
+
 #endif
 #endif
diff --git a/include/asm-i386/kdebug.h b/include/asm-i386/kdebug.h
index 316138e89910..96d0828ce096 100644
--- a/include/asm-i386/kdebug.h
+++ b/include/asm-i386/kdebug.h
@@ -17,11 +17,9 @@ struct die_args {
         int signr;
 };
 
-/* Note - you should never unregister because that can race with NMIs.
-   If you really want to do it first unregister - then synchronize_sched - then free.
-  */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *i386die_chain;
+extern int register_die_notifier(struct notifier_block *);
+extern int unregister_die_notifier(struct notifier_block *);
+extern struct atomic_notifier_head i386die_chain;
 
 
 /* Grossly misnamed. */
@@ -51,7 +49,7 @@ static inline int notify_die(enum die_val val, const char *str,
                 .trapnr = trap,
                 .signr = sig
         };
-        return notifier_call_chain(&i386die_chain, val, &args);
+        return atomic_notifier_call_chain(&i386die_chain, val, &args);
 }
 
 #endif
diff --git a/include/asm-i386/mmzone.h b/include/asm-i386/mmzone.h
index 74f595d80579..e33e9f9e4c66 100644
--- a/include/asm-i386/mmzone.h
+++ b/include/asm-i386/mmzone.h
@@ -70,8 +70,6 @@ static inline int pfn_to_nid(unsigned long pfn)
 #endif
 }
 
-#define node_localnr(pfn, nid)          ((pfn) - node_data[nid]->node_start_pfn)
-
 /*
  * Following are macros that each numa implmentation must define.
  */
@@ -86,21 +84,6 @@ static inline int pfn_to_nid(unsigned long pfn)
 /* XXX: FIXME -- wli */
 #define kern_addr_valid(kaddr)  (0)
 
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = pfn;                                      \
-        int __node  = pfn_to_nid(__pfn);                                \
-        &NODE_DATA(__node)->node_mem_map[node_localnr(__pfn,__node)];   \
-})
-
-#define page_to_pfn(pg)                                                 \
-({                                                                      \
-        struct page *__page = pg;                                       \
-        struct zone *__zone = page_zone(__page);                        \
-        (unsigned long)(__page - __zone->zone_mem_map)                  \
-                + __zone->zone_start_pfn;                               \
-})
-
 #ifdef CONFIG_X86_NUMAQ            /* we have contiguous memory on NUMA-Q */
 #define pfn_valid(pfn)          ((pfn) < num_physpages)
 #else
diff --git a/include/asm-i386/page.h b/include/asm-i386/page.h
index 997ca5d17876..30f52a2263ba 100644
--- a/include/asm-i386/page.h
+++ b/include/asm-i386/page.h
@@ -126,8 +126,6 @@ extern int page_is_ram(unsigned long pagenr);
 #define __va(x)                 ((void *)((unsigned long)(x)+PAGE_OFFSET))
 #define pfn_to_kaddr(pfn)      __va((pfn) << PAGE_SHIFT)
 #ifdef CONFIG_FLATMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif /* CONFIG_FLATMEM */
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
@@ -141,6 +139,7 @@ extern int page_is_ram(unsigned long pagenr);
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _I386_PAGE_H */
diff --git a/include/asm-i386/processor.h b/include/asm-i386/processor.h
index feca5d961e2b..af4bfd012475 100644
--- a/include/asm-i386/processor.h
+++ b/include/asm-i386/processor.h
@@ -20,6 +20,7 @@
 #include <linux/config.h>
 #include <linux/threads.h>
 #include <asm/percpu.h>
+#include <linux/cpumask.h>
 
 /* flag for disabling the tsc */
 extern int tsc_disable;
@@ -67,6 +68,9 @@ struct cpuinfo_x86 {
         char    pad0;
         int     x86_power;
         unsigned long loops_per_jiffy;
+#ifdef CONFIG_SMP
+        cpumask_t llc_shared_map;       /* cpus sharing the last level cache */
+#endif
         unsigned char x86_max_cores;    /* cpuid returned max cores value */
         unsigned char booted_cores;     /* number of cores as seen by OS */
         unsigned char apicid;
@@ -103,6 +107,7 @@ extern struct cpuinfo_x86 cpu_data[];
 
 extern  int phys_proc_id[NR_CPUS];
 extern  int cpu_core_id[NR_CPUS];
+extern  int cpu_llc_id[NR_CPUS];
 extern char ignore_fpu_irq;
 
 extern void identify_cpu(struct cpuinfo_x86 *);
diff --git a/include/asm-i386/setup.h b/include/asm-i386/setup.h
index 826a8ca50ac8..ee941457b55d 100644
--- a/include/asm-i386/setup.h
+++ b/include/asm-i386/setup.h
@@ -6,9 +6,7 @@
 #ifndef _i386_SETUP_H
 #define _i386_SETUP_H
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
+#include <linux/pfn.h>
 
 /*
  * Reserved space for vmalloc and iomap - defined in asm/page.h
diff --git a/include/asm-i386/topology.h b/include/asm-i386/topology.h
index aa958c6ee83e..b94e5eeef917 100644
--- a/include/asm-i386/topology.h
+++ b/include/asm-i386/topology.h
@@ -112,4 +112,6 @@ extern unsigned long node_remap_size[];
 
 #endif /* CONFIG_NUMA */
 
+extern cpumask_t cpu_coregroup_map(int cpu);
+
 #endif /* _ASM_I386_TOPOLOGY_H */
diff --git a/include/asm-i386/unistd.h b/include/asm-i386/unistd.h
index d8afd0e3b81a..014e3562895b 100644
--- a/include/asm-i386/unistd.h
+++ b/include/asm-i386/unistd.h
@@ -316,8 +316,10 @@
 #define __NR_pselect6           308
 #define __NR_ppoll              309
 #define __NR_unshare            310
+#define __NR_set_robust_list    311
+#define __NR_get_robust_list    312
 
-#define NR_syscalls 311
+#define NR_syscalls 313
 
 /*
  * user-visible error numbers are in the range -1 - -128: see
diff --git a/include/asm-ia64/compat.h b/include/asm-ia64/compat.h
index c0b19106665c..40d01d80610d 100644
--- a/include/asm-ia64/compat.h
+++ b/include/asm-ia64/compat.h
@@ -189,6 +189,12 @@ compat_ptr (compat_uptr_t uptr)
         return (void __user *) (unsigned long) uptr;
 }
 
+static inline compat_uptr_t
+ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
+
 static __inline__ void __user *
 compat_alloc_user_space (long len)
 {
diff --git a/include/asm-ia64/kdebug.h b/include/asm-ia64/kdebug.h
index 8b01a083dde6..218c458ab60c 100644
--- a/include/asm-ia64/kdebug.h
+++ b/include/asm-ia64/kdebug.h
@@ -40,7 +40,7 @@ struct die_args {
 
 extern int register_die_notifier(struct notifier_block *);
 extern int unregister_die_notifier(struct notifier_block *);
-extern struct notifier_block *ia64die_chain;
+extern struct atomic_notifier_head ia64die_chain;
 
 enum die_val {
         DIE_BREAK = 1,
@@ -81,7 +81,7 @@ static inline int notify_die(enum die_val val, char *str, struct pt_regs *regs,
                 .signr  = sig
         };
 
-        return notifier_call_chain(&ia64die_chain, val, &args);
+        return atomic_notifier_call_chain(&ia64die_chain, val, &args);
 }
 
 #endif
diff --git a/include/asm-ia64/page.h b/include/asm-ia64/page.h
index 6e9aa23250c4..2087825eefa4 100644
--- a/include/asm-ia64/page.h
+++ b/include/asm-ia64/page.h
@@ -106,17 +106,25 @@ extern int ia64_pfn_valid (unsigned long pfn);
 # define ia64_pfn_valid(pfn) 1
 #endif
 
+#ifdef CONFIG_VIRTUAL_MEM_MAP
+extern struct page *vmem_map;
+#ifdef CONFIG_DISCONTIGMEM
+# define page_to_pfn(page)      ((unsigned long) (page - vmem_map))
+# define pfn_to_page(pfn)       (vmem_map + (pfn))
+#endif
+#endif
+
+#if defined(CONFIG_FLATMEM) || defined(CONFIG_SPARSEMEM)
+/* FLATMEM always configures mem_map (mem_map = vmem_map if necessary) */
+#include <asm-generic/memory_model.h>
+#endif
+
 #ifdef CONFIG_FLATMEM
 # define pfn_valid(pfn)         (((pfn) < max_mapnr) && ia64_pfn_valid(pfn))
-# define page_to_pfn(page)      ((unsigned long) (page - mem_map))
-# define pfn_to_page(pfn)       (mem_map + (pfn))
 #elif defined(CONFIG_DISCONTIGMEM)
-extern struct page *vmem_map;
 extern unsigned long min_low_pfn;
 extern unsigned long max_low_pfn;
 # define pfn_valid(pfn)         (((pfn) >= min_low_pfn) && ((pfn) < max_low_pfn) && ia64_pfn_valid(pfn))
-# define page_to_pfn(page)      ((unsigned long) (page - vmem_map))
-# define pfn_to_page(pfn)       (vmem_map + (pfn))
 #endif
 
 #define page_to_phys(page)      (page_to_pfn(page) << PAGE_SHIFT)
diff --git a/include/asm-m32r/mmzone.h b/include/asm-m32r/mmzone.h
index adc7970a77ec..9f3b5accda88 100644
--- a/include/asm-m32r/mmzone.h
+++ b/include/asm-m32r/mmzone.h
@@ -21,20 +21,6 @@ extern struct pglist_data *node_data[];
         __pgdat->node_start_pfn + __pgdat->node_spanned_pages - 1;      \
 })
 
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = pfn;                                      \
-        int __node  = pfn_to_nid(__pfn);                                \
-        &NODE_DATA(__node)->node_mem_map[node_localnr(__pfn,__node)];   \
-})
-
-#define page_to_pfn(pg)                                                 \
-({                                                                      \
-        struct page *__page = pg;                                       \
-        struct zone *__zone = page_zone(__page);                        \
-        (unsigned long)(__page - __zone->zone_mem_map)                  \
-                + __zone->zone_start_pfn;                               \
-})
 #define pmd_page(pmd)           (pfn_to_page(pmd_val(pmd) >> PAGE_SHIFT))
 /*
  * pfn_valid should be made as fast as possible, and the current definition
diff --git a/include/asm-m32r/page.h b/include/asm-m32r/page.h
index 4ab578876361..9ddbc087dbc5 100644
--- a/include/asm-m32r/page.h
+++ b/include/asm-m32r/page.h
@@ -76,9 +76,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #ifndef CONFIG_DISCONTIGMEM
 #define PFN_BASE                (CONFIG_MEMORY_START >> PAGE_SHIFT)
-#define pfn_to_page(pfn)        (mem_map + ((pfn) - PFN_BASE))
-#define page_to_pfn(page)       \
-        ((unsigned long)((page) - mem_map) + PFN_BASE)
+#define ARCH_PFN_OFFSET         PFN_BASE
 #define pfn_valid(pfn)          (((pfn) - PFN_BASE) < max_mapnr)
 #endif  /* !CONFIG_DISCONTIGMEM */
 
@@ -92,6 +90,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _ASM_M32R_PAGE_H */
diff --git a/include/asm-m32r/setup.h b/include/asm-m32r/setup.h
index 5f028dc26a9b..52f4fa29abfc 100644
--- a/include/asm-m32r/setup.h
+++ b/include/asm-m32r/setup.h
@@ -24,10 +24,6 @@
 #define RAMDISK_PROMPT_FLAG             (0x8000)
 #define RAMDISK_LOAD_FLAG               (0x4000)
 
-#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
-#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
-
 extern unsigned long memory_start;
 extern unsigned long memory_end;
 
diff --git a/include/asm-mips/compat.h b/include/asm-mips/compat.h
index 0012bd804d2d..986511db54a6 100644
--- a/include/asm-mips/compat.h
+++ b/include/asm-mips/compat.h
@@ -133,6 +133,11 @@ static inline void __user *compat_ptr(compat_uptr_t uptr)
         return (void __user *)(long)uptr;
 }
 
+static inline compat_uptr_t ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
+
 static inline void __user *compat_alloc_user_space(long len)
 {
         struct pt_regs *regs = (struct pt_regs *)
diff --git a/include/asm-mips/futex.h b/include/asm-mips/futex.h
index 2454c44a8f54..a554089991f2 100644
--- a/include/asm-mips/futex.h
+++ b/include/asm-mips/futex.h
@@ -99,5 +99,11 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
         return ret;
 }
 
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
+
 #endif
 #endif
diff --git a/include/asm-mips/mmzone.h b/include/asm-mips/mmzone.h
index 011caebac369..7bde4432092b 100644
--- a/include/asm-mips/mmzone.h
+++ b/include/asm-mips/mmzone.h
@@ -22,20 +22,6 @@
                        NODE_DATA(__n)->node_spanned_pages) : 0);\
 })
 
-#define pfn_to_page(pfn)                                        \
-({                                                              \
-        unsigned long __pfn = (pfn);                            \
-        pg_data_t *__pg = NODE_DATA(pfn_to_nid(__pfn));         \
-        __pg->node_mem_map + (__pfn - __pg->node_start_pfn);    \
-})
-
-#define page_to_pfn(p)                                          \
-({                                                              \
-        struct page *__p = (p);                                 \
-        struct zone *__z = page_zone(__p);                      \
-        ((__p - __z->zone_mem_map) + __z->zone_start_pfn);      \
-})
-
 /* XXX: FIXME -- wli */
 #define kern_addr_valid(addr)   (0)
 
diff --git a/include/asm-mips/page.h b/include/asm-mips/page.h
index ee25a779bf49..a1eab136ff6c 100644
--- a/include/asm-mips/page.h
+++ b/include/asm-mips/page.h
@@ -140,8 +140,6 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #define pfn_to_kaddr(pfn)       __va((pfn) << PAGE_SHIFT)
 
 #ifndef CONFIG_NEED_MULTIPLE_NODES
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif
 
@@ -160,6 +158,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #define WANT_PAGE_VIRTUAL
 #endif
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _ASM_PAGE_H */
diff --git a/include/asm-mips/time.h b/include/asm-mips/time.h
index 9cc3564cc2c9..d897c8bb554d 100644
--- a/include/asm-mips/time.h
+++ b/include/asm-mips/time.h
@@ -26,14 +26,14 @@ extern spinlock_t rtc_lock;
 
 /*
  * RTC ops.  By default, they point to no-RTC functions.
- *      rtc_get_time - mktime(year, mon, day, hour, min, sec) in seconds.
- *      rtc_set_time - reverse the above translation and set time to RTC.
- *      rtc_set_mmss - similar to rtc_set_time, but only min and sec need
+ *      rtc_mips_get_time - mktime(year, mon, day, hour, min, sec) in seconds.
+ *      rtc_mips_set_time - reverse the above translation and set time to RTC.
+ *      rtc_mips_set_mmss - similar to rtc_set_time, but only min and sec need
  *                      to be set.  Used by RTC sync-up.
  */
-extern unsigned long (*rtc_get_time)(void);
-extern int (*rtc_set_time)(unsigned long);
-extern int (*rtc_set_mmss)(unsigned long);
+extern unsigned long (*rtc_mips_get_time)(void);
+extern int (*rtc_mips_set_time)(unsigned long);
+extern int (*rtc_mips_set_mmss)(unsigned long);
 
 /*
  * Timer interrupt functions.
diff --git a/include/asm-parisc/compat.h b/include/asm-parisc/compat.h
index 38b918feead9..289624d8b2d4 100644
--- a/include/asm-parisc/compat.h
+++ b/include/asm-parisc/compat.h
@@ -138,6 +138,11 @@ static inline void __user *compat_ptr(compat_uptr_t uptr)
         return (void __user *)(unsigned long)uptr;
 }
 
+static inline compat_uptr_t ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
+
 static __inline__ void __user *compat_alloc_user_space(long len)
 {
         struct pt_regs *regs = &current->thread.regs;
diff --git a/include/asm-parisc/mmzone.h b/include/asm-parisc/mmzone.h
index ae039f4fd711..ceb9b73199d1 100644
--- a/include/asm-parisc/mmzone.h
+++ b/include/asm-parisc/mmzone.h
@@ -25,23 +25,6 @@ extern struct node_map_data node_data[];
         pg_data_t *__pgdat = NODE_DATA(nid);                            \
         __pgdat->node_start_pfn + __pgdat->node_spanned_pages;          \
 })
-#define node_localnr(pfn, nid)          ((pfn) - node_start_pfn(nid))
-
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = (pfn);                                    \
-        int __node  = pfn_to_nid(__pfn);                                \
-        &NODE_DATA(__node)->node_mem_map[node_localnr(__pfn,__node)];   \
-})
-
-#define page_to_pfn(pg)                                                 \
-({                                                                      \
-        struct page *__page = pg;                                       \
-        struct zone *__zone = page_zone(__page);                        \
-        BUG_ON(__zone == NULL);                                         \
-        (unsigned long)(__page - __zone->zone_mem_map)                  \
-                + __zone->zone_start_pfn;                               \
-})
 
 /* We have these possible memory map layouts:
  * Astro: 0-3.75, 67.75-68, 4-64
diff --git a/include/asm-parisc/page.h b/include/asm-parisc/page.h
index 4a6752b0afed..9f303c0c3cd7 100644
--- a/include/asm-parisc/page.h
+++ b/include/asm-parisc/page.h
@@ -130,8 +130,6 @@ extern int npmem_ranges;
 #define __va(x)                 ((void *)((unsigned long)(x)+PAGE_OFFSET))
 
 #ifndef CONFIG_DISCONTIGMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif /* CONFIG_DISCONTIGMEM */
 
@@ -152,6 +150,7 @@ extern int npmem_ranges;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _PARISC_PAGE_H */
diff --git a/include/asm-powerpc/futex.h b/include/asm-powerpc/futex.h
index 39e85f320a76..f1b3c00bc1ce 100644
--- a/include/asm-powerpc/futex.h
+++ b/include/asm-powerpc/futex.h
@@ -81,5 +81,11 @@ static inline int futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
         return ret;
 }
 
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
+
 #endif /* __KERNEL__ */
 #endif /* _ASM_POWERPC_FUTEX_H */
diff --git a/include/asm-powerpc/kdebug.h b/include/asm-powerpc/kdebug.h
index 7c16265568e0..c01786ab5fa6 100644
--- a/include/asm-powerpc/kdebug.h
+++ b/include/asm-powerpc/kdebug.h
@@ -16,13 +16,9 @@ struct die_args {
         int signr;
 };
 
-/*
-   Note - you should never unregister because that can race with NMIs.
-   If you really want to do it first unregister - then synchronize_sched -
-   then free.
- */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *powerpc_die_chain;
+extern int register_die_notifier(struct notifier_block *);
+extern int unregister_die_notifier(struct notifier_block *);
+extern struct atomic_notifier_head powerpc_die_chain;
 
 /* Grossly misnamed. */
 enum die_val {
@@ -37,7 +33,7 @@ enum die_val {
 static inline int notify_die(enum die_val val,char *str,struct pt_regs *regs,long err,int trap, int sig)
 {
         struct die_args args = { .regs=regs, .str=str, .err=err, .trapnr=trap,.signr=sig };
-        return notifier_call_chain(&powerpc_die_chain, val, &args);
+        return atomic_notifier_call_chain(&powerpc_die_chain, val, &args);
 }
 
 #endif /* __KERNEL__ */
diff --git a/include/asm-powerpc/page.h b/include/asm-powerpc/page.h
index 0b82df483f7f..2fbecebe1c92 100644
--- a/include/asm-powerpc/page.h
+++ b/include/asm-powerpc/page.h
@@ -69,8 +69,6 @@
 #endif
 
 #ifdef CONFIG_FLATMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 #endif
 
@@ -200,6 +198,7 @@ extern void copy_user_page(void *to, void *from, unsigned long vaddr,
                 struct page *p);
 extern int page_is_ram(unsigned long pfn);
 
+#include <asm-generic/memory_model.h>
 #endif /* __ASSEMBLY__ */
 
 #endif /* __KERNEL__ */
diff --git a/include/asm-ppc/page.h b/include/asm-ppc/page.h
index 538e0c8ab243..a70ba2ee552d 100644
--- a/include/asm-ppc/page.h
+++ b/include/asm-ppc/page.h
@@ -149,8 +149,7 @@ extern int page_is_ram(unsigned long pfn);
 #define __pa(x) ___pa((unsigned long)(x))
 #define __va(x) ((void *)(___va((unsigned long)(x))))
 
-#define pfn_to_page(pfn)        (mem_map + ((pfn) - PPC_PGSTART))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + PPC_PGSTART)
+#define ARCH_PFN_OFFSET         (PPC_PGSTART)
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define page_to_virt(page)      __va(page_to_pfn(page) << PAGE_SHIFT)
 
@@ -175,5 +174,6 @@ extern __inline__ int get_order(unsigned long size)
 /* We do define AT_SYSINFO_EHDR but don't use the gate mecanism */
 #define __HAVE_ARCH_GATE_AREA           1
 
+#include <asm-generic/memory_model.h>
 #endif /* __KERNEL__ */
 #endif /* _PPC_PAGE_H */
diff --git a/include/asm-s390/compat.h b/include/asm-s390/compat.h
index a007715f4aea..356a0b183539 100644
--- a/include/asm-s390/compat.h
+++ b/include/asm-s390/compat.h
@@ -128,6 +128,11 @@ static inline void __user *compat_ptr(compat_uptr_t uptr)
         return (void __user *)(unsigned long)(uptr & 0x7fffffffUL);
 }
 
+static inline compat_uptr_t ptr_to_compat(void __user *uptr)
+{
+        return (u32)(unsigned long)uptr;
+}
+
 static inline void __user *compat_alloc_user_space(long len)
 {
         unsigned long stack;
diff --git a/include/asm-s390/page.h b/include/asm-s390/page.h
index 2430c561e021..3b1138ac7e79 100644
--- a/include/asm-s390/page.h
+++ b/include/asm-s390/page.h
@@ -181,8 +181,6 @@ page_get_storage_key(unsigned long addr)
 #define PAGE_OFFSET             0x0UL
 #define __pa(x)                 (unsigned long)(x)
 #define __va(x)                 (void *)(unsigned long)(x)
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
@@ -193,6 +191,7 @@ page_get_storage_key(unsigned long addr)
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _S390_PAGE_H */
diff --git a/include/asm-sh/page.h b/include/asm-sh/page.h
index 972c3f655b2a..9c89287c3e56 100644
--- a/include/asm-sh/page.h
+++ b/include/asm-sh/page.h
@@ -105,9 +105,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 /* PFN start number, because of __MEMORY_START */
 #define PFN_START               (__MEMORY_START >> PAGE_SHIFT)
-
-#define pfn_to_page(pfn)        (mem_map + (pfn) - PFN_START)
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + PFN_START)
+#define ARCH_PFN_OFFSET         (FPN_START)
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)          (((pfn) - PFN_START) < max_mapnr)
 #define virt_addr_valid(kaddr)  pfn_valid(__pa(kaddr) >> PAGE_SHIFT)
@@ -117,6 +115,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* __ASM_SH_PAGE_H */
diff --git a/include/asm-sh64/page.h b/include/asm-sh64/page.h
index c86df90f7cbd..e4937cdabebd 100644
--- a/include/asm-sh64/page.h
+++ b/include/asm-sh64/page.h
@@ -105,9 +105,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 /* PFN start number, because of __MEMORY_START */
 #define PFN_START               (__MEMORY_START >> PAGE_SHIFT)
-
-#define pfn_to_page(pfn)        (mem_map + (pfn) - PFN_START)
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map) + PFN_START)
+#define ARCH_PFN_OFFSET         (PFN_START)
 #define virt_to_page(kaddr)     pfn_to_page(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_valid(pfn)          (((pfn) - PFN_START) < max_mapnr)
 #define virt_addr_valid(kaddr)  pfn_valid(__pa(kaddr) >> PAGE_SHIFT)
@@ -117,6 +115,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* __ASM_SH64_PAGE_H */
diff --git a/include/asm-sh64/platform.h b/include/asm-sh64/platform.h
index 7046a9014027..bd0d9c405a80 100644
--- a/include/asm-sh64/platform.h
+++ b/include/asm-sh64/platform.h
@@ -61,9 +61,4 @@ extern int platform_int_priority[NR_INTC_IRQS];
 #define code_resource (platform_parms.kram_res_p[STANDARD_KRAM_RESOURCES - 2])
 #define data_resource (platform_parms.kram_res_p[STANDARD_KRAM_RESOURCES - 1])
 
-/* Be prepared to 64-bit sign extensions */
-#define PFN_UP(x)       ((((x) + PAGE_SIZE-1) >> PAGE_SHIFT) & 0x000fffff)
-#define PFN_DOWN(x)     (((x) >> PAGE_SHIFT) & 0x000fffff)
-#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
-
 #endif  /* __ASM_SH64_PLATFORM_H */
diff --git a/include/asm-sparc/page.h b/include/asm-sparc/page.h
index 9122684f6c1e..ec3274b7ddf4 100644
--- a/include/asm-sparc/page.h
+++ b/include/asm-sparc/page.h
@@ -152,8 +152,7 @@ extern unsigned long pfn_base;
 #define virt_to_phys            __pa
 #define phys_to_virt            __va
 
-#define pfn_to_page(pfn)        (mem_map + ((pfn)-(pfn_base)))
-#define page_to_pfn(page)       ((unsigned long)(((page) - mem_map) + pfn_base))
+#define ARCH_PFN_OFFSET         (pfn_base)
 #define virt_to_page(kaddr)     (mem_map + ((((unsigned long)(kaddr)-PAGE_OFFSET)>>PAGE_SHIFT)))
 
 #define pfn_valid(pfn)          (((pfn) >= (pfn_base)) && (((pfn)-(pfn_base)) < max_mapnr))
@@ -164,6 +163,7 @@ extern unsigned long pfn_base;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _SPARC_PAGE_H */
diff --git a/include/asm-sparc64/futex.h b/include/asm-sparc64/futex.h
index 34c4b43d3f98..cd340a233156 100644
--- a/include/asm-sparc64/futex.h
+++ b/include/asm-sparc64/futex.h
@@ -83,4 +83,10 @@ static inline int futex_atomic_op_inuser(int encoded_op, int __user *uaddr)
         return ret;
 }
 
+static inline int
+futex_atomic_cmpxchg_inuser(int __user *uaddr, int oldval, int newval)
+{
+        return -ENOSYS;
+}
+
 #endif /* !(_SPARC64_FUTEX_H) */
diff --git a/include/asm-sparc64/kdebug.h b/include/asm-sparc64/kdebug.h
index 6321f5a0198d..4040d127ac3e 100644
--- a/include/asm-sparc64/kdebug.h
+++ b/include/asm-sparc64/kdebug.h
@@ -15,12 +15,9 @@ struct die_args {
         int signr;
 };
 
-/* Note - you should never unregister because that can race with NMIs.
- * If you really want to do it first unregister - then synchronize_sched
- * - then free.
- */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *sparc64die_chain;
+extern int register_die_notifier(struct notifier_block *);
+extern int unregister_die_notifier(struct notifier_block *);
+extern struct atomic_notifier_head sparc64die_chain;
 
 extern void bad_trap(struct pt_regs *, long);
 
@@ -46,7 +43,7 @@ static inline int notify_die(enum die_val val,char *str, struct pt_regs *regs,
                                  .trapnr        = trap,
                                  .signr         = sig };
 
-        return notifier_call_chain(&sparc64die_chain, val, &args);
+        return atomic_notifier_call_chain(&sparc64die_chain, val, &args);
 }
 
 #endif
diff --git a/include/asm-sparc64/page.h b/include/asm-sparc64/page.h
index 66fe4ac59fd6..aabb21906724 100644
--- a/include/asm-sparc64/page.h
+++ b/include/asm-sparc64/page.h
@@ -111,6 +111,8 @@ typedef unsigned long pgprot_t;
                                  (_AC(0x0000000070000000,UL)) : \
                                  (_AC(0xfffff80000000000,UL) + (1UL << 32UL)))
 
+#include <asm-generic/memory_model.h>
+
 #endif /* !(__ASSEMBLY__) */
 
 /* to align the pointer to the (next) page boundary */
diff --git a/include/asm-um/page.h b/include/asm-um/page.h
index 0229814af31e..41364330aff1 100644
--- a/include/asm-um/page.h
+++ b/include/asm-um/page.h
@@ -106,9 +106,6 @@ extern unsigned long uml_physmem;
 #define __pa(virt) to_phys((void *) (unsigned long) (virt))
 #define __va(phys) to_virt((unsigned long) (phys))
 
-#define page_to_pfn(page) ((page) - mem_map)
-#define pfn_to_page(pfn) (mem_map + (pfn))
-
 #define phys_to_pfn(p) ((p) >> PAGE_SHIFT)
 #define pfn_to_phys(pfn) ((pfn) << PAGE_SHIFT)
 
@@ -121,6 +118,7 @@ extern struct page *arch_validate(struct page *page, gfp_t mask, int order);
 extern void arch_free_page(struct page *page, int order);
 #define HAVE_ARCH_FREE_PAGE
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif
diff --git a/include/asm-um/uaccess.h b/include/asm-um/uaccess.h
index 2ee028b8de9d..4e460d6f5ac8 100644
--- a/include/asm-um/uaccess.h
+++ b/include/asm-um/uaccess.h
@@ -41,16 +41,16 @@
 
 #define __get_user(x, ptr) \
 ({ \
-        const __typeof__(ptr) __private_ptr = ptr; \
-        __typeof__(*(__private_ptr)) __private_val; \
-        int __private_ret = -EFAULT; \
-        (x) = (__typeof__(*(__private_ptr)))0; \
-        if (__copy_from_user(&__private_val, (__private_ptr), \
-            sizeof(*(__private_ptr))) == 0) {\
-                (x) = (__typeof__(*(__private_ptr))) __private_val; \
-                __private_ret = 0; \
-        } \
-        __private_ret; \
+        const __typeof__(ptr) __private_ptr = ptr;      \
+        __typeof__(x) __private_val;                    \
+        int __private_ret = -EFAULT;                    \
+        (x) = (__typeof__(*(__private_ptr)))0;                          \
+        if (__copy_from_user((void *) &__private_val, (__private_ptr),  \
+                             sizeof(*(__private_ptr))) == 0) {          \
+                (x) = (__typeof__(*(__private_ptr))) __private_val;     \
+                __private_ret = 0;                                      \
+        }                                                               \
+        __private_ret;                                                  \
 }) 
 
 #define get_user(x, ptr) \
@@ -89,14 +89,3 @@ struct exception_table_entry
 };
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/include/asm-v850/page.h b/include/asm-v850/page.h
index b4bc85e7b91a..ad03c46a1f92 100644
--- a/include/asm-v850/page.h
+++ b/include/asm-v850/page.h
@@ -111,8 +111,7 @@ typedef unsigned long pgprot_t;
 #define page_to_virt(page) \
   ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
 
-#define pfn_to_page(pfn)        virt_to_page (pfn_to_virt (pfn))
-#define page_to_pfn(page)       virt_to_pfn (page_to_virt (page))
+#define ARCH_PFN_OFFSET         (PAGE_OFFSET >> PAGE_SHIFT)
 #define pfn_valid(pfn)          ((pfn) < max_mapnr)
 
 #define virt_addr_valid(kaddr)                                          \
@@ -125,6 +124,7 @@ typedef unsigned long pgprot_t;
 
 #endif /* KERNEL */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* __V850_PAGE_H__ */
diff --git a/include/asm-x86_64/futex.h b/include/asm-x86_64/futex.h
index 8602c09bf89e..9804bf07b092 100644
--- a/include/asm-x86_64/futex.h
+++ b/include/asm-x86_64/futex.h
@@ -94,5 +94,32 @@ futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
         return ret;
 }
 
+static inline int
+futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+{
+        if (!access_ok(VERIFY_WRITE, uaddr, sizeof(int)))
+                return -EFAULT;
+
+        __asm__ __volatile__(
+                "1:     " LOCK_PREFIX "cmpxchgl %3, %1          \n"
+
+                "2:     .section .fixup, \"ax\"                 \n"
+                "3:     mov     %2, %0                          \n"
+                "       jmp     2b                              \n"
+                "       .previous                               \n"
+
+                "       .section __ex_table, \"a\"              \n"
+                "       .align  8                               \n"
+                "       .quad   1b,3b                           \n"
+                "       .previous                               \n"
+
+                : "=a" (oldval), "=m" (*uaddr)
+                : "i" (-EFAULT), "r" (newval), "0" (oldval)
+                : "memory"
+        );
+
+        return oldval;
+}
+
 #endif
 #endif
diff --git a/include/asm-x86_64/kdebug.h b/include/asm-x86_64/kdebug.h
index b9ed4c0c8783..cf795631d9b4 100644
--- a/include/asm-x86_64/kdebug.h
+++ b/include/asm-x86_64/kdebug.h
@@ -5,21 +5,20 @@
 
 struct pt_regs;
 
-struct die_args { 
+struct die_args {
         struct pt_regs *regs;
         const char *str;
-        long err; 
+        long err;
         int trapnr;
         int signr;
-}; 
+};
+
+extern int register_die_notifier(struct notifier_block *);
+extern int unregister_die_notifier(struct notifier_block *);
+extern struct atomic_notifier_head die_chain;
 
-/* Note - you should never unregister because that can race with NMIs.
-   If you really want to do it first unregister - then synchronize_sched - then free.
-  */
-int register_die_notifier(struct notifier_block *nb);
-extern struct notifier_block *die_chain;
 /* Grossly misnamed. */
-enum die_val { 
+enum die_val {
         DIE_OOPS = 1,
         DIE_INT3,
         DIE_DEBUG,
@@ -33,8 +32,8 @@ enum die_val {
         DIE_CALL,
         DIE_NMI_IPI,
         DIE_PAGE_FAULT,
-}; 
-        
+};
+
 static inline int notify_die(enum die_val val, const char *str,
                         struct pt_regs *regs, long err, int trap, int sig)
 {
@@ -45,7 +44,7 @@ static inline int notify_die(enum die_val val, const char *str,
                 .trapnr = trap,
                 .signr = sig
         };
-        return notifier_call_chain(&die_chain, val, &args); 
+        return atomic_notifier_call_chain(&die_chain, val, &args);
 } 
 
 extern int printk_address(unsigned long address);
diff --git a/include/asm-x86_64/mmzone.h b/include/asm-x86_64/mmzone.h
index 937f99b26883..6b18cd8f293d 100644
--- a/include/asm-x86_64/mmzone.h
+++ b/include/asm-x86_64/mmzone.h
@@ -44,12 +44,8 @@ static inline __attribute__((pure)) int phys_to_nid(unsigned long addr)
 #define pfn_to_nid(pfn) phys_to_nid((unsigned long)(pfn) << PAGE_SHIFT)
 #define kvaddr_to_nid(kaddr)    phys_to_nid(__pa(kaddr))
 
-extern struct page *pfn_to_page(unsigned long pfn);
-extern unsigned long page_to_pfn(struct page *page);
 extern int pfn_valid(unsigned long pfn);
 #endif
 
-#define local_mapnr(kvaddr) \
-        ( (__pa(kvaddr) >> PAGE_SHIFT) - node_start_pfn(kvaddr_to_nid(kvaddr)) )
 #endif
 #endif
diff --git a/include/asm-x86_64/page.h b/include/asm-x86_64/page.h
index 615e3e494929..408185bac351 100644
--- a/include/asm-x86_64/page.h
+++ b/include/asm-x86_64/page.h
@@ -123,8 +123,6 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 #define __boot_va(x)            __va(x)
 #define __boot_pa(x)            __pa(x)
 #ifdef CONFIG_FLATMEM
-#define pfn_to_page(pfn)        (mem_map + (pfn))
-#define page_to_pfn(page)       ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)          ((pfn) < end_pfn)
 #endif
 
@@ -140,6 +138,7 @@ typedef struct { unsigned long pgprot; } pgprot_t;
 
 #endif /* __KERNEL__ */
 
+#include <asm-generic/memory_model.h>
 #include <asm-generic/page.h>
 
 #endif /* _X86_64_PAGE_H */
diff --git a/include/asm-x86_64/processor.h b/include/asm-x86_64/processor.h
index 8c8d88c036ed..1aa2cee43344 100644
--- a/include/asm-x86_64/processor.h
+++ b/include/asm-x86_64/processor.h
@@ -20,6 +20,7 @@
 #include <asm/mmsegment.h>
 #include <asm/percpu.h>
 #include <linux/personality.h>
+#include <linux/cpumask.h>
 
 #define TF_MASK         0x00000100
 #define IF_MASK         0x00000200
@@ -65,6 +66,9 @@ struct cpuinfo_x86 {
         __u32   x86_power;      
         __u32   extended_cpuid_level;   /* Max extended CPUID function supported */
         unsigned long loops_per_jiffy;
+#ifdef CONFIG_SMP
+        cpumask_t llc_shared_map;       /* cpus sharing the last level cache */
+#endif
         __u8    apicid;
         __u8    booted_cores;   /* number of cores as seen by OS */
 } ____cacheline_aligned;
diff --git a/include/asm-x86_64/smp.h b/include/asm-x86_64/smp.h
index 9ccbb2cfd5c0..a4fdaeb5c397 100644
--- a/include/asm-x86_64/smp.h
+++ b/include/asm-x86_64/smp.h
@@ -56,6 +56,7 @@ extern cpumask_t cpu_sibling_map[NR_CPUS];
 extern cpumask_t cpu_core_map[NR_CPUS];
 extern u8 phys_proc_id[NR_CPUS];
 extern u8 cpu_core_id[NR_CPUS];
+extern u8 cpu_llc_id[NR_CPUS];
 
 #define SMP_TRAMPOLINE_BASE 0x6000
 
diff --git a/include/asm-x86_64/topology.h b/include/asm-x86_64/topology.h
index c642f5d9882d..9db54e9d17bb 100644
--- a/include/asm-x86_64/topology.h
+++ b/include/asm-x86_64/topology.h
@@ -68,4 +68,6 @@ extern int __node_distance(int, int);
 
 #include <asm-generic/topology.h>
 
+extern cpumask_t cpu_coregroup_map(int cpu);
+
 #endif
diff --git a/include/asm-x86_64/unistd.h b/include/asm-x86_64/unistd.h
index da0341c57949..fcc516353087 100644
--- a/include/asm-x86_64/unistd.h
+++ b/include/asm-x86_64/unistd.h
@@ -605,8 +605,12 @@ __SYSCALL(__NR_pselect6, sys_ni_syscall)	/* for now */
 __SYSCALL(__NR_ppoll,   sys_ni_syscall)         /* for now */
 #define __NR_unshare            272
 __SYSCALL(__NR_unshare, sys_unshare)
+#define __NR_set_robust_list    273
+__SYSCALL(__NR_set_robust_list, sys_set_robust_list)
+#define __NR_get_robust_list    274
+__SYSCALL(__NR_get_robust_list, sys_get_robust_list)
 
-#define __NR_syscall_max __NR_unshare
+#define __NR_syscall_max __NR_get_robust_list
 
 #ifndef __NO_STUBS
 
diff --git a/include/asm-xtensa/page.h b/include/asm-xtensa/page.h
index 8ded36f255a2..992bac5c1258 100644
--- a/include/asm-xtensa/page.h
+++ b/include/asm-xtensa/page.h
@@ -109,10 +109,7 @@ void copy_user_page(void *to,void* from,unsigned long vaddr,struct page* page);
 #define __pa(x)                 ((unsigned long) (x) - PAGE_OFFSET)
 #define __va(x)                 ((void *)((unsigned long) (x) + PAGE_OFFSET))
 #define pfn_valid(pfn)          ((unsigned long)pfn < max_mapnr)
-#ifndef CONFIG_DISCONTIGMEM
-# define pfn_to_page(pfn)       (mem_map + (pfn))
-# define page_to_pfn(page)      ((unsigned long)((page) - mem_map))
-#else
+#ifdef CONFIG_DISCONTIGMEM
 # error CONFIG_DISCONTIGMEM not supported
 #endif
 
@@ -130,4 +127,5 @@ void copy_user_page(void *to,void* from,unsigned long vaddr,struct page* page);
                                  VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
 
 #endif /* __KERNEL__ */
+#include <asm-generic/memory_model.h>
 #endif /* _XTENSA_PAGE_H */
diff --git a/include/linux/adb.h b/include/linux/adb.h
index e9fdc63483c7..b7305b178279 100644
--- a/include/linux/adb.h
+++ b/include/linux/adb.h
@@ -85,7 +85,7 @@ enum adb_message {
     ADB_MSG_POST_RESET  /* Called after resetting the bus (re-do init & register) */
 };
 extern struct adb_driver *adb_controller;
-extern struct notifier_block *adb_client_list;
+extern struct blocking_notifier_head adb_client_list;
 
 int adb_request(struct adb_request *req, void (*done)(struct adb_request *),
                 int flags, int nbytes, ...);
diff --git a/include/linux/auto_fs4.h b/include/linux/auto_fs4.h
index 9343c89d843c..0a6bc52ffe88 100644
--- a/include/linux/auto_fs4.h
+++ b/include/linux/auto_fs4.h
@@ -19,18 +19,37 @@
 #undef AUTOFS_MIN_PROTO_VERSION
 #undef AUTOFS_MAX_PROTO_VERSION
 
-#define AUTOFS_PROTO_VERSION            4
+#define AUTOFS_PROTO_VERSION            5
 #define AUTOFS_MIN_PROTO_VERSION        3
-#define AUTOFS_MAX_PROTO_VERSION        4
+#define AUTOFS_MAX_PROTO_VERSION        5
 
-#define AUTOFS_PROTO_SUBVERSION         7
+#define AUTOFS_PROTO_SUBVERSION         0
 
 /* Mask for expire behaviour */
 #define AUTOFS_EXP_IMMEDIATE            1
 #define AUTOFS_EXP_LEAVES               2
 
-/* New message type */
-#define autofs_ptype_expire_multi       2       /* Expire entry (umount request) */
+/* Daemon notification packet types */
+enum autofs_notify {
+        NFY_NONE,
+        NFY_MOUNT,
+        NFY_EXPIRE
+};
+
+/* Kernel protocol version 4 packet types */
+
+/* Expire entry (umount request) */
+#define autofs_ptype_expire_multi       2
+
+/* Kernel protocol version 5 packet types */
+
+/* Indirect mount missing and expire requests. */
+#define autofs_ptype_missing_indirect   3
+#define autofs_ptype_expire_indirect    4
+
+/* Direct mount missing and expire requests */
+#define autofs_ptype_missing_direct     5
+#define autofs_ptype_expire_direct      6
 
 /* v4 multi expire (via pipe) */
 struct autofs_packet_expire_multi {
@@ -40,14 +59,36 @@ struct autofs_packet_expire_multi {
         char name[NAME_MAX+1];
 };
 
+/* autofs v5 common packet struct */
+struct autofs_v5_packet {
+        struct autofs_packet_hdr hdr;
+        autofs_wqt_t wait_queue_token;
+        __u32 dev;
+        __u64 ino;
+        __u32 uid;
+        __u32 gid;
+        __u32 pid;
+        __u32 tgid;
+        __u32 len;
+        char name[NAME_MAX+1];
+};
+
+typedef struct autofs_v5_packet autofs_packet_missing_indirect_t;
+typedef struct autofs_v5_packet autofs_packet_expire_indirect_t;
+typedef struct autofs_v5_packet autofs_packet_missing_direct_t;
+typedef struct autofs_v5_packet autofs_packet_expire_direct_t;
+
 union autofs_packet_union {
         struct autofs_packet_hdr hdr;
         struct autofs_packet_missing missing;
         struct autofs_packet_expire expire;
         struct autofs_packet_expire_multi expire_multi;
+        struct autofs_v5_packet v5_packet;
 };
 
 #define AUTOFS_IOC_EXPIRE_MULTI         _IOW(0x93,0x66,int)
+#define AUTOFS_IOC_EXPIRE_INDIRECT      AUTOFS_IOC_EXPIRE_MULTI
+#define AUTOFS_IOC_EXPIRE_DIRECT        AUTOFS_IOC_EXPIRE_MULTI
 #define AUTOFS_IOC_PROTOSUBVER          _IOR(0x93,0x67,int)
 #define AUTOFS_IOC_ASKREGHOST           _IOR(0x93,0x68,int)
 #define AUTOFS_IOC_TOGGLEREGHOST        _IOR(0x93,0x69,int)
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 7155452fb4a8..de3eb8d8ae26 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -38,6 +38,7 @@ typedef struct bootmem_data {
         unsigned long last_pos;
         unsigned long last_success;     /* Previous allocation point.  To speed
                                          * up searching */
+        struct list_head list;
 } bootmem_data_t;
 
 extern unsigned long __init bootmem_bootmap_pages (unsigned long);
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 24d659cdbafe..6d3a654be1ae 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -147,6 +147,24 @@ typedef struct compat_sigevent {
         } _sigev_un;
 } compat_sigevent_t;
 
+struct compat_robust_list {
+        compat_uptr_t                   next;
+};
+
+struct compat_robust_list_head {
+        struct compat_robust_list       list;
+        compat_long_t                   futex_offset;
+        compat_uptr_t                   list_op_pending;
+};
+
+extern void compat_exit_robust_list(struct task_struct *curr);
+
+asmlinkage long
+compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
+                           compat_size_t len);
+asmlinkage long
+compat_sys_get_robust_list(int pid, compat_uptr_t *head_ptr,
+                           compat_size_t __user *len_ptr);
 
 long compat_sys_semctl(int first, int second, int third, void __user *uptr);
 long compat_sys_msgsnd(int first, int second, int third, void __user *uptr);
diff --git a/include/linux/compat_ioctl.h b/include/linux/compat_ioctl.h
index efb518f16bb3..89ab677cb993 100644
--- a/include/linux/compat_ioctl.h
+++ b/include/linux/compat_ioctl.h
@@ -140,6 +140,7 @@ COMPATIBLE_IOCTL(DM_TABLE_DEPS_32)
 COMPATIBLE_IOCTL(DM_TABLE_STATUS_32)
 COMPATIBLE_IOCTL(DM_LIST_VERSIONS_32)
 COMPATIBLE_IOCTL(DM_TARGET_MSG_32)
+COMPATIBLE_IOCTL(DM_DEV_SET_GEOMETRY_32)
 COMPATIBLE_IOCTL(DM_VERSION)
 COMPATIBLE_IOCTL(DM_REMOVE_ALL)
 COMPATIBLE_IOCTL(DM_LIST_DEVICES)
@@ -155,6 +156,7 @@ COMPATIBLE_IOCTL(DM_TABLE_DEPS)
 COMPATIBLE_IOCTL(DM_TABLE_STATUS)
 COMPATIBLE_IOCTL(DM_LIST_VERSIONS)
 COMPATIBLE_IOCTL(DM_TARGET_MSG)
+COMPATIBLE_IOCTL(DM_DEV_SET_GEOMETRY)
 /* Big K */
 COMPATIBLE_IOCTL(PIO_FONT)
 COMPATIBLE_IOCTL(GIO_FONT)
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 51e0e95a421a..aee10b2ea4c6 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -97,6 +97,7 @@ struct io_restrictions {
         unsigned short          hardsect_size;
         unsigned int            max_segment_size;
         unsigned long           seg_boundary_mask;
+        unsigned char           no_cluster; /* inverted so that 0 is default */
 };
 
 struct dm_target {
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
index fa75ba0d635e..c67c6786612a 100644
--- a/include/linux/dm-ioctl.h
+++ b/include/linux/dm-ioctl.h
@@ -80,6 +80,16 @@
  *
  * DM_TARGET_MSG:
  * Pass a message string to the target at a specific offset of a device.
+ *
+ * DM_DEV_SET_GEOMETRY:
+ * Set the geometry of a device by passing in a string in this format:
+ *
+ * "cylinders heads sectors_per_track start_sector"
+ *
+ * Beware that CHS geometry is nearly obsolete and only provided
+ * for compatibility with dm devices that can be booted by a PC
+ * BIOS.  See struct hd_geometry for range limits.  Also note that
+ * the geometry is erased if the device size changes.
  */
 
 /*
@@ -218,6 +228,7 @@ enum {
         /* Added later */
         DM_LIST_VERSIONS_CMD,
         DM_TARGET_MSG_CMD,
+        DM_DEV_SET_GEOMETRY_CMD
 };
 
 /*
@@ -247,6 +258,7 @@ typedef char ioctl_struct[308];
 #define DM_TABLE_STATUS_32  _IOWR(DM_IOCTL, DM_TABLE_STATUS_CMD, ioctl_struct)
 #define DM_LIST_VERSIONS_32 _IOWR(DM_IOCTL, DM_LIST_VERSIONS_CMD, ioctl_struct)
 #define DM_TARGET_MSG_32    _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, ioctl_struct)
+#define DM_DEV_SET_GEOMETRY_32  _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, ioctl_struct)
 #endif
 
 #define DM_IOCTL 0xfd
@@ -270,11 +282,12 @@ typedef char ioctl_struct[308];
 #define DM_LIST_VERSIONS _IOWR(DM_IOCTL, DM_LIST_VERSIONS_CMD, struct dm_ioctl)
 
 #define DM_TARGET_MSG    _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, struct dm_ioctl)
+#define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        5
+#define DM_VERSION_MINOR        6
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2005-10-04)"
+#define DM_VERSION_EXTRA        "-ioctl (2006-02-17)"
 
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 9d9674946956..680d913350e7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -410,6 +410,9 @@ struct block_device {
         struct list_head        bd_inodes;
         void *                  bd_holder;
         int                     bd_holders;
+#ifdef CONFIG_SYSFS
+        struct list_head        bd_holder_list;
+#endif
         struct block_device *   bd_contains;
         unsigned                bd_block_size;
         struct hd_struct *      bd_part;
@@ -1399,6 +1402,13 @@ extern int blkdev_get(struct block_device *, mode_t, unsigned);
 extern int blkdev_put(struct block_device *);
 extern int bd_claim(struct block_device *, void *);
 extern void bd_release(struct block_device *);
+#ifdef CONFIG_SYSFS
+extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
+extern void bd_release_from_disk(struct block_device *, struct gendisk *);
+#else
+#define bd_claim_by_disk(bdev, holder, disk)    bd_claim(bdev, holder)
+#define bd_release_from_disk(bdev, disk)        bd_release(bdev)
+#endif
 
 /* fs/char_dev.c */
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
diff --git a/include/linux/futex.h b/include/linux/futex.h
index 10f96c31971e..966a5b3da439 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -1,6 +1,8 @@
 #ifndef _LINUX_FUTEX_H
 #define _LINUX_FUTEX_H
 
+#include <linux/sched.h>
+
 /* Second argument to futex syscall */
 
 
@@ -11,10 +13,97 @@
 #define FUTEX_CMP_REQUEUE       4
 #define FUTEX_WAKE_OP           5
 
+/*
+ * Support for robust futexes: the kernel cleans up held futexes at
+ * thread exit time.
+ */
+
+/*
+ * Per-lock list entry - embedded in user-space locks, somewhere close
+ * to the futex field. (Note: user-space uses a double-linked list to
+ * achieve O(1) list add and remove, but the kernel only needs to know
+ * about the forward link)
+ *
+ * NOTE: this structure is part of the syscall ABI, and must not be
+ * changed.
+ */
+struct robust_list {
+        struct robust_list __user *next;
+};
+
+/*
+ * Per-thread list head:
+ *
+ * NOTE: this structure is part of the syscall ABI, and must only be
+ * changed if the change is first communicated with the glibc folks.
+ * (When an incompatible change is done, we'll increase the structure
+ *  size, which glibc will detect)
+ */
+struct robust_list_head {
+        /*
+         * The head of the list. Points back to itself if empty:
+         */
+        struct robust_list list;
+
+        /*
+         * This relative offset is set by user-space, it gives the kernel
+         * the relative position of the futex field to examine. This way
+         * we keep userspace flexible, to freely shape its data-structure,
+         * without hardcoding any particular offset into the kernel:
+         */
+        long futex_offset;
+
+        /*
+         * The death of the thread may race with userspace setting
+         * up a lock's links. So to handle this race, userspace first
+         * sets this field to the address of the to-be-taken lock,
+         * then does the lock acquire, and then adds itself to the
+         * list, and then clears this field. Hence the kernel will
+         * always have full knowledge of all locks that the thread
+         * _might_ have taken. We check the owner TID in any case,
+         * so only truly owned locks will be handled.
+         */
+        struct robust_list __user *list_op_pending;
+};
+
+/*
+ * Are there any waiters for this robust futex:
+ */
+#define FUTEX_WAITERS           0x80000000
+
+/*
+ * The kernel signals via this bit that a thread holding a futex
+ * has exited without unlocking the futex. The kernel also does
+ * a FUTEX_WAKE on such futexes, after setting the bit, to wake
+ * up any possible waiters:
+ */
+#define FUTEX_OWNER_DIED        0x40000000
+
+/*
+ * The rest of the robust-futex field is for the TID:
+ */
+#define FUTEX_TID_MASK          0x3fffffff
+
+/*
+ * This limit protects against a deliberately circular list.
+ * (Not worth introducing an rlimit for it)
+ */
+#define ROBUST_LIST_LIMIT       2048
+
 long do_futex(unsigned long uaddr, int op, int val,
                 unsigned long timeout, unsigned long uaddr2, int val2,
                 int val3);
 
+extern int handle_futex_death(u32 __user *uaddr, struct task_struct *curr);
+
+#ifdef CONFIG_FUTEX
+extern void exit_robust_list(struct task_struct *curr);
+#else
+static inline void exit_robust_list(struct task_struct *curr)
+{
+}
+#endif
+
 #define FUTEX_OP_SET            0       /* *(int *)UADDR2 = OPARG; */
 #define FUTEX_OP_ADD            1       /* *(int *)UADDR2 += OPARG; */
 #define FUTEX_OP_OR             2       /* *(int *)UADDR2 |= OPARG; */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index fd647fde5ec1..3c1b0294a742 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -78,6 +78,7 @@ struct hd_struct {
         sector_t start_sect;
         sector_t nr_sects;
         struct kobject kobj;
+        struct kobject *holder_dir;
         unsigned ios[2], sectors[2];    /* READs and WRITEs */
         int policy, partno;
 };
@@ -89,12 +90,12 @@ struct hd_struct {
 #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
 
 struct disk_stats {
-        unsigned sectors[2];            /* READs and WRITEs */
-        unsigned ios[2];
-        unsigned merges[2];
-        unsigned ticks[2];
-        unsigned io_ticks;
-        unsigned time_in_queue;
+        unsigned long sectors[2];       /* READs and WRITEs */
+        unsigned long ios[2];
+        unsigned long merges[2];
+        unsigned long ticks[2];
+        unsigned long io_ticks;
+        unsigned long time_in_queue;
 };
         
 struct gendisk {
@@ -114,6 +115,8 @@ struct gendisk {
         int number;                     /* more of the same */
         struct device *driverfs_dev;
         struct kobject kobj;
+        struct kobject *holder_dir;
+        struct kobject *slave_dir;
 
         struct timer_rand_state *random;
         int policy;
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 679b46a6a565..c8b81f419fd8 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -108,6 +108,10 @@
 #define I2C_DRIVERID_UPD64083   78      /* upd64083 video processor     */
 #define I2C_DRIVERID_UPD64031A  79      /* upd64031a video processor    */
 #define I2C_DRIVERID_SAA717X    80      /* saa717x video encoder        */
+#define I2C_DRIVERID_DS1672     81      /* Dallas/Maxim DS1672 RTC      */
+#define I2C_DRIVERID_X1205      82      /* Xicor/Intersil X1205 RTC     */
+#define I2C_DRIVERID_PCF8563    83      /* Philips PCF8563 RTC          */
+#define I2C_DRIVERID_RS5C372    84      /* Ricoh RS5C372 RTC            */
 
 #define I2C_DRIVERID_I2CDEV     900
 #define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 03d6cfaa5b8a..a3720f973ea5 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -87,7 +87,7 @@ extern int cond_resched(void);
                 (__x < 0) ? -__x : __x;         \
         })
 
-extern struct notifier_block *panic_notifier_list;
+extern struct atomic_notifier_head panic_notifier_list;
 extern long (*panic_blink)(long time);
 NORET_TYPE void panic(const char * fmt, ...)
         __attribute__ ((NORET_AND format (printf, 1, 2)));
diff --git a/include/linux/m48t86.h b/include/linux/m48t86.h
new file mode 100644
index 000000000000..9065199319d0
--- /dev/null
+++ b/include/linux/m48t86.h
@@ -0,0 +1,16 @@
+/*
+ * ST M48T86 / Dallas DS12887 RTC driver
+ * Copyright (c) 2006 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+struct m48t86_ops
+{
+        void (*writeb)(unsigned char value, unsigned long addr);
+        unsigned char (*readb)(unsigned long addr);
+};
diff --git a/include/linux/memory.h b/include/linux/memory.h
index e251dc43d0f5..8f04143ca363 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -77,7 +77,6 @@ extern int remove_memory_block(unsigned long, struct mem_section *, int);
 
 #define CONFIG_MEM_BLOCK_SIZE   (PAGES_PER_SECTION<<PAGE_SHIFT)
 
-struct notifier_block;
 
 #endif /* CONFIG_MEMORY_HOTPLUG */
 
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index ebfc238cc243..b5c21122c299 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -13,6 +13,7 @@
 #include <linux/numa.h>
 #include <linux/init.h>
 #include <linux/seqlock.h>
+#include <linux/nodemask.h>
 #include <asm/atomic.h>
 
 /* Free memory management - zoned buddy allocator.  */
@@ -225,7 +226,6 @@ struct zone {
          * Discontig memory support fields.
          */
         struct pglist_data      *zone_pgdat;
-        struct page             *zone_mem_map;
         /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
         unsigned long           zone_start_pfn;
 
@@ -307,7 +307,6 @@ typedef struct pglist_data {
         unsigned long node_spanned_pages; /* total size of physical page
                                              range, including holes */
         int node_id;
-        struct pglist_data *pgdat_next;
         wait_queue_head_t kswapd_wait;
         struct task_struct *kswapd;
         int kswapd_max_order;
@@ -324,8 +323,6 @@ typedef struct pglist_data {
 
 #include <linux/memory_hotplug.h>
 
-extern struct pglist_data *pgdat_list;
-
 void __get_zone_counts(unsigned long *active, unsigned long *inactive,
                         unsigned long *free, struct pglist_data *pgdat);
 void get_zone_counts(unsigned long *active, unsigned long *inactive,
@@ -350,57 +347,6 @@ unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
  */
 #define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
 
-/**
- * for_each_pgdat - helper macro to iterate over all nodes
- * @pgdat - pointer to a pg_data_t variable
- *
- * Meant to help with common loops of the form
- * pgdat = pgdat_list;
- * while(pgdat) {
- *      ...
- *      pgdat = pgdat->pgdat_next;
- * }
- */
-#define for_each_pgdat(pgdat) \
-        for (pgdat = pgdat_list; pgdat; pgdat = pgdat->pgdat_next)
-
-/*
- * next_zone - helper magic for for_each_zone()
- * Thanks to William Lee Irwin III for this piece of ingenuity.
- */
-static inline struct zone *next_zone(struct zone *zone)
-{
-        pg_data_t *pgdat = zone->zone_pgdat;
-
-        if (zone < pgdat->node_zones + MAX_NR_ZONES - 1)
-                zone++;
-        else if (pgdat->pgdat_next) {
-                pgdat = pgdat->pgdat_next;
-                zone = pgdat->node_zones;
-        } else
-                zone = NULL;
-
-        return zone;
-}
-
-/**
- * for_each_zone - helper macro to iterate over all memory zones
- * @zone - pointer to struct zone variable
- *
- * The user only needs to declare the zone variable, for_each_zone
- * fills it in. This basically means for_each_zone() is an
- * easier to read version of this piece of code:
- *
- * for (pgdat = pgdat_list; pgdat; pgdat = pgdat->node_next)
- *      for (i = 0; i < MAX_NR_ZONES; ++i) {
- *              struct zone * z = pgdat->node_zones + i;
- *              ...
- *      }
- * }
- */
-#define for_each_zone(zone) \
-        for (zone = pgdat_list->node_zones; zone; zone = next_zone(zone))
-
 static inline int populated_zone(struct zone *zone)
 {
         return (!!zone->present_pages);
@@ -472,6 +418,30 @@ extern struct pglist_data contig_page_data;
 
 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
 
+extern struct pglist_data *first_online_pgdat(void);
+extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
+extern struct zone *next_zone(struct zone *zone);
+
+/**
+ * for_each_pgdat - helper macro to iterate over all nodes
+ * @pgdat - pointer to a pg_data_t variable
+ */
+#define for_each_online_pgdat(pgdat)                    \
+        for (pgdat = first_online_pgdat();              \
+             pgdat;                                     \
+             pgdat = next_online_pgdat(pgdat))
+/**
+ * for_each_zone - helper macro to iterate over all memory zones
+ * @zone - pointer to struct zone variable
+ *
+ * The user only needs to declare the zone variable, for_each_zone
+ * fills it in.
+ */
+#define for_each_zone(zone)                             \
+        for (zone = (first_online_pgdat())->node_zones; \
+             zone;                                      \
+             zone = next_zone(zone))
+
 #ifdef CONFIG_SPARSEMEM
 #include <asm/sparsemem.h>
 #endif
@@ -602,17 +572,6 @@ static inline struct mem_section *__pfn_to_section(unsigned long pfn)
         return __nr_to_section(pfn_to_section_nr(pfn));
 }
 
-#define pfn_to_page(pfn)                                                \
-({                                                                      \
-        unsigned long __pfn = (pfn);                                    \
-        __section_mem_map_addr(__pfn_to_section(__pfn)) + __pfn;        \
-})
-#define page_to_pfn(page)                                               \
-({                                                                      \
-        page - __section_mem_map_addr(__nr_to_section(                  \
-                page_to_section(page)));                                \
-})
-
 static inline int pfn_valid(unsigned long pfn)
 {
         if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index f32d75c4f4cf..d54d7b278e96 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -308,29 +308,30 @@ DECLARE_PER_CPU(struct ip_conntrack_ecache, ip_conntrack_ecache);
 
 #define CONNTRACK_ECACHE(x)     (__get_cpu_var(ip_conntrack_ecache).x)
  
-extern struct notifier_block *ip_conntrack_chain;
-extern struct notifier_block *ip_conntrack_expect_chain;
+extern struct atomic_notifier_head ip_conntrack_chain;
+extern struct atomic_notifier_head ip_conntrack_expect_chain;
 
 static inline int ip_conntrack_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&ip_conntrack_chain, nb);
+        return atomic_notifier_chain_register(&ip_conntrack_chain, nb);
 }
 
 static inline int ip_conntrack_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&ip_conntrack_chain, nb);
+        return atomic_notifier_chain_unregister(&ip_conntrack_chain, nb);
 }
 
 static inline int 
 ip_conntrack_expect_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&ip_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_register(&ip_conntrack_expect_chain, nb);
 }
 
 static inline int
 ip_conntrack_expect_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&ip_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_unregister(&ip_conntrack_expect_chain,
+                        nb);
 }
 
 extern void ip_ct_deliver_cached_events(const struct ip_conntrack *ct);
@@ -355,14 +356,14 @@ static inline void ip_conntrack_event(enum ip_conntrack_events event,
                                       struct ip_conntrack *ct)
 {
         if (is_confirmed(ct) && !is_dying(ct))
-                notifier_call_chain(&ip_conntrack_chain, event, ct);
+                atomic_notifier_call_chain(&ip_conntrack_chain, event, ct);
 }
 
 static inline void 
 ip_conntrack_expect_event(enum ip_conntrack_expect_events event,
                           struct ip_conntrack_expect *exp)
 {
-        notifier_call_chain(&ip_conntrack_expect_chain, event, exp);
+        atomic_notifier_call_chain(&ip_conntrack_expect_chain, event, exp);
 }
 #else /* CONFIG_IP_NF_CONNTRACK_EVENTS */
 static inline void ip_conntrack_event_cache(enum ip_conntrack_events event, 
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index 6bad4766d3d9..d2a8abb5011a 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -67,7 +67,8 @@ struct svc_expkey {
         int                     ek_fsidtype;
         u32                     ek_fsid[3];
 
-        struct svc_export *     ek_export;
+        struct vfsmount *       ek_mnt;
+        struct dentry *         ek_dentry;
 };
 
 #define EX_SECURE(exp)          (!((exp)->ex_flags & NFSEXP_INSECURE_PORT))
@@ -85,9 +86,6 @@ void			nfsd_export_shutdown(void);
 void                    nfsd_export_flush(void);
 void                    exp_readlock(void);
 void                    exp_readunlock(void);
-struct svc_expkey *     exp_find_key(struct auth_domain *clp, 
-                                     int fsid_type, u32 *fsidv,
-                                     struct cache_req *reqp);
 struct svc_export *     exp_get_by_name(struct auth_domain *clp,
                                         struct vfsmount *mnt,
                                         struct dentry *dentry,
@@ -101,35 +99,20 @@ int			exp_rootfh(struct auth_domain *,
 int                     exp_pseudoroot(struct auth_domain *, struct svc_fh *fhp, struct cache_req *creq);
 int                     nfserrno(int errno);
 
-extern void expkey_put(struct cache_head *item, struct cache_detail *cd);
-extern void svc_export_put(struct cache_head *item, struct cache_detail *cd);
-extern struct cache_detail svc_export_cache, svc_expkey_cache;
+extern struct cache_detail svc_export_cache;
 
 static inline void exp_put(struct svc_export *exp)
 {
-        svc_export_put(&exp->h, &svc_export_cache);
+        cache_put(&exp->h, &svc_export_cache);
 }
 
 static inline void exp_get(struct svc_export *exp)
 {
         cache_get(&exp->h);
 }
-static inline struct svc_export *
+extern struct svc_export *
 exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
-         struct cache_req *reqp)
-{
-        struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
-        if (ek && !IS_ERR(ek)) {
-                struct svc_export *exp = ek->ek_export;
-                int err;
-                exp_get(exp);
-                expkey_put(&ek->h, &svc_expkey_cache);
-                if ((err = cache_check(&svc_export_cache, &exp->h, reqp)))
-                        exp = ERR_PTR(err);
-                return exp;
-        } else
-                return ERR_PTR(PTR_ERR(ek));
-}
+         struct cache_req *reqp);
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index b959a4525cbd..1a9ef3e627d1 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -350,11 +350,15 @@ extern nodemask_t node_possible_map;
 #define num_possible_nodes()    nodes_weight(node_possible_map)
 #define node_online(node)       node_isset((node), node_online_map)
 #define node_possible(node)     node_isset((node), node_possible_map)
+#define first_online_node       first_node(node_online_map)
+#define next_online_node(nid)   next_node((nid), node_online_map)
 #else
 #define num_online_nodes()      1
 #define num_possible_nodes()    1
 #define node_online(node)       ((node) == 0)
 #define node_possible(node)     ((node) == 0)
+#define first_online_node       0
+#define next_online_node(nid)   (MAX_NUMNODES)
 #endif
 
 #define any_online_node(mask)                   \
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index 5937dd6053c3..51dbab9710c7 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -10,25 +10,107 @@
 #ifndef _LINUX_NOTIFIER_H
 #define _LINUX_NOTIFIER_H
 #include <linux/errno.h>
+#include <linux/mutex.h>
+#include <linux/rwsem.h>
 
-struct notifier_block
-{
-        int (*notifier_call)(struct notifier_block *self, unsigned long, void *);
+/*
+ * Notifier chains are of three types:
+ *
+ *      Atomic notifier chains: Chain callbacks run in interrupt/atomic
+ *              context. Callouts are not allowed to block.
+ *      Blocking notifier chains: Chain callbacks run in process context.
+ *              Callouts are allowed to block.
+ *      Raw notifier chains: There are no restrictions on callbacks,
+ *              registration, or unregistration.  All locking and protection
+ *              must be provided by the caller.
+ *
+ * atomic_notifier_chain_register() may be called from an atomic context,
+ * but blocking_notifier_chain_register() must be called from a process
+ * context.  Ditto for the corresponding _unregister() routines.
+ *
+ * atomic_notifier_chain_unregister() and blocking_notifier_chain_unregister()
+ * _must not_ be called from within the call chain.
+ */
+
+struct notifier_block {
+        int (*notifier_call)(struct notifier_block *, unsigned long, void *);
         struct notifier_block *next;
         int priority;
 };
 
+struct atomic_notifier_head {
+        spinlock_t lock;
+        struct notifier_block *head;
+};
+
+struct blocking_notifier_head {
+        struct rw_semaphore rwsem;
+        struct notifier_block *head;
+};
+
+struct raw_notifier_head {
+        struct notifier_block *head;
+};
+
+#define ATOMIC_INIT_NOTIFIER_HEAD(name) do {    \
+                spin_lock_init(&(name)->lock);  \
+                (name)->head = NULL;            \
+        } while (0)
+#define BLOCKING_INIT_NOTIFIER_HEAD(name) do {  \
+                init_rwsem(&(name)->rwsem);     \
+                (name)->head = NULL;            \
+        } while (0)
+#define RAW_INIT_NOTIFIER_HEAD(name) do {       \
+                (name)->head = NULL;            \
+        } while (0)
+
+#define ATOMIC_NOTIFIER_INIT(name) {                            \
+                .lock = SPIN_LOCK_UNLOCKED,                     \
+                .head = NULL }
+#define BLOCKING_NOTIFIER_INIT(name) {                          \
+                .rwsem = __RWSEM_INITIALIZER((name).rwsem),     \
+                .head = NULL }
+#define RAW_NOTIFIER_INIT(name) {                               \
+                .head = NULL }
+
+#define ATOMIC_NOTIFIER_HEAD(name)                              \
+        struct atomic_notifier_head name =                      \
+                ATOMIC_NOTIFIER_INIT(name)
+#define BLOCKING_NOTIFIER_HEAD(name)                            \
+        struct blocking_notifier_head name =                    \
+                BLOCKING_NOTIFIER_INIT(name)
+#define RAW_NOTIFIER_HEAD(name)                                 \
+        struct raw_notifier_head name =                         \
+                RAW_NOTIFIER_INIT(name)
 
 #ifdef __KERNEL__
 
-extern int notifier_chain_register(struct notifier_block **list, struct notifier_block *n);
-extern int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n);
-extern int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v);
+extern int atomic_notifier_chain_register(struct atomic_notifier_head *,
+                struct notifier_block *);
+extern int blocking_notifier_chain_register(struct blocking_notifier_head *,
+                struct notifier_block *);
+extern int raw_notifier_chain_register(struct raw_notifier_head *,
+                struct notifier_block *);
+
+extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *,
+                struct notifier_block *);
+extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *,
+                struct notifier_block *);
+extern int raw_notifier_chain_unregister(struct raw_notifier_head *,
+                struct notifier_block *);
+
+extern int atomic_notifier_call_chain(struct atomic_notifier_head *,
+                unsigned long val, void *v);
+extern int blocking_notifier_call_chain(struct blocking_notifier_head *,
+                unsigned long val, void *v);
+extern int raw_notifier_call_chain(struct raw_notifier_head *,
+                unsigned long val, void *v);
 
 #define NOTIFY_DONE             0x0000          /* Don't care */
 #define NOTIFY_OK               0x0001          /* Suits me */
 #define NOTIFY_STOP_MASK        0x8000          /* Don't call further */
-#define NOTIFY_BAD              (NOTIFY_STOP_MASK|0x0002)       /* Bad/Veto action      */
+#define NOTIFY_BAD              (NOTIFY_STOP_MASK|0x0002)
+                                                /* Bad/Veto action */
 /*
  * Clean way to return from the notifier and stop further calls.
  */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 6f080ae59286..02f6cf20b141 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1052,6 +1052,7 @@
 #define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6600_ALT2 0x00f2
 #define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6200_ALT1 0x00f3
 #define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_GT   0x00f9
+#define PCIE_DEVICE_ID_NVIDIA_QUADRO_NVS280     0x00fd
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_SDR        0x0100
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_DDR        0x0101
 #define PCI_DEVICE_ID_NVIDIA_QUADRO             0x0103
diff --git a/include/linux/pfn.h b/include/linux/pfn.h
new file mode 100644
index 000000000000..bb01f8b92b56
--- /dev/null
+++ b/include/linux/pfn.h
@@ -0,0 +1,9 @@
+#ifndef _LINUX_PFN_H_
+#define _LINUX_PFN_H_
+
+#define PFN_ALIGN(x)    (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
+#define PFN_UP(x)       (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
+#define PFN_DOWN(x)     ((x) >> PAGE_SHIFT)
+#define PFN_PHYS(x)     ((x) << PAGE_SHIFT)
+
+#endif
diff --git a/include/linux/raid/md.h b/include/linux/raid/md.h
index b6e0bcad84e1..66b44e5e0d6e 100644
--- a/include/linux/raid/md.h
+++ b/include/linux/raid/md.h
@@ -92,7 +92,10 @@ extern void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
 extern void md_super_wait(mddev_t *mddev);
 extern int sync_page_io(struct block_device *bdev, sector_t sector, int size,
                         struct page *page, int rw);
+extern void md_do_sync(mddev_t *mddev);
+extern void md_new_event(mddev_t *mddev);
 
+extern void md_update_sb(mddev_t * mddev);
 
 #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
 
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index 617b9506c760..e2df61f5b09a 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -132,6 +132,14 @@ struct mddev_s
 
         char                            uuid[16];
 
+        /* If the array is being reshaped, we need to record the
+         * new shape and an indication of where we are up to.
+         * This is written to the superblock.
+         * If reshape_position is MaxSector, then no reshape is happening (yet).
+         */
+        sector_t                        reshape_position;
+        int                             delta_disks, new_level, new_layout, new_chunk;
+
         struct mdk_thread_s             *thread;        /* management thread */
         struct mdk_thread_s             *sync_thread;   /* doing resync or reconstruct */
         sector_t                        curr_resync;    /* blocks scheduled */
@@ -143,6 +151,10 @@ struct mddev_s
         sector_t                        resync_mismatches; /* count of sectors where
                                                             * parity/replica mismatch found
                                                             */
+
+        /* allow user-space to request suspension of IO to regions of the array */
+        sector_t                        suspend_lo;
+        sector_t                        suspend_hi;
         /* if zero, use the system-wide default */
         int                             sync_speed_min;
         int                             sync_speed_max;
@@ -157,6 +169,9 @@ struct mddev_s
          * DONE:     thread is done and is waiting to be reaped
          * REQUEST:  user-space has requested a sync (used with SYNC)
          * CHECK:    user-space request for for check-only, no repair
+         * RESHAPE:  A reshape is happening
+         *
+         * If neither SYNC or RESHAPE are set, then it is a recovery.
          */
 #define MD_RECOVERY_RUNNING     0
 #define MD_RECOVERY_SYNC        1
@@ -166,10 +181,11 @@ struct mddev_s
 #define MD_RECOVERY_NEEDED      5
 #define MD_RECOVERY_REQUESTED   6
 #define MD_RECOVERY_CHECK       7
+#define MD_RECOVERY_RESHAPE     8
         unsigned long                   recovery;
 
         int                             in_sync;        /* know to not need resync */
-        struct semaphore                reconfig_sem;
+        struct mutex                    reconfig_mutex;
         atomic_t                        active;
 
         int                             changed;        /* true if we might need to reread partition info */
@@ -249,7 +265,8 @@ struct mdk_personality
         int (*spare_active) (mddev_t *mddev);
         sector_t (*sync_request)(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster);
         int (*resize) (mddev_t *mddev, sector_t sectors);
-        int (*reshape) (mddev_t *mddev, int raid_disks);
+        int (*check_reshape) (mddev_t *mddev);
+        int (*start_reshape) (mddev_t *mddev);
         int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
         /* quiesce moves between quiescence states
          * 0 - fully active
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index c100fa5d4bfa..774e1acfb8c4 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -102,6 +102,18 @@ typedef struct mdp_device_descriptor_s {
 #define MD_SB_ERRORS            1
 
 #define MD_SB_BITMAP_PRESENT    8 /* bitmap may be present nearby */
+
+/*
+ * Notes:
+ * - if an array is being reshaped (restriped) in order to change the
+ *   the number of active devices in the array, 'raid_disks' will be
+ *   the larger of the old and new numbers.  'delta_disks' will
+ *   be the "new - old".  So if +ve, raid_disks is the new value, and
+ *   "raid_disks-delta_disks" is the old.  If -ve, raid_disks is the
+ *   old value and "raid_disks+delta_disks" is the new (smaller) value.
+ */
+
+
 typedef struct mdp_superblock_s {
         /*
          * Constant generic information
@@ -146,7 +158,13 @@ typedef struct mdp_superblock_s {
         __u32 cp_events_hi;     /* 10 high-order of checkpoint update count   */
 #endif
         __u32 recovery_cp;      /* 11 recovery checkpoint sector count        */
-        __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 12];
+        /* There are only valid for minor_version > 90 */
+        __u64 reshape_position; /* 12,13 next address in array-space for reshape */
+        __u32 new_level;        /* 14 new level we are reshaping to           */
+        __u32 delta_disks;      /* 15 change in number of raid_disks          */
+        __u32 new_layout;       /* 16 new layout                              */
+        __u32 new_chunk;        /* 17 new chunk size (bytes)                  */
+        __u32 gstate_sreserved[MD_SB_GENERIC_STATE_WORDS - 18];
 
         /*
          * Personality information
@@ -207,7 +225,14 @@ struct mdp_superblock_1 {
                                  * NOTE: signed, so bitmap can be before superblock
                                  * only meaningful of feature_map[0] is set.
                                  */
-        __u8    pad1[128-100];  /* set to 0 when written */
+
+        /* These are only valid with feature bit '4' */
+        __u64   reshape_position;       /* next address in array-space for reshape */
+        __u32   new_level;      /* new level we are reshaping to                */
+        __u32   delta_disks;    /* change in number of raid_disks               */
+        __u32   new_layout;     /* new layout                                   */
+        __u32   new_chunk;      /* new chunk size (bytes)                       */
+        __u8    pad1[128-124];  /* set to 0 when written */
 
         /* constant this-device information - 64 bytes */
         __u64   data_offset;    /* sector start of data, often 0 */
@@ -240,8 +265,9 @@ struct mdp_superblock_1 {
 
 /* feature_map bits */
 #define MD_FEATURE_BITMAP_OFFSET        1
+#define MD_FEATURE_RESHAPE_ACTIVE       4
 
-#define MD_FEATURE_ALL                  1
+#define MD_FEATURE_ALL                  5
 
 #endif 
 
diff --git a/include/linux/raid/raid5.h b/include/linux/raid/raid5.h
index 394da8207b34..914af667044f 100644
--- a/include/linux/raid/raid5.h
+++ b/include/linux/raid/raid5.h
@@ -135,6 +135,7 @@ struct stripe_head {
         atomic_t                count;                  /* nr of active thread/requests */
         spinlock_t              lock;
         int                     bm_seq; /* sequence number for bitmap flushes */
+        int                     disks;                  /* disks in stripe */
         struct r5dev {
                 struct bio      req;
                 struct bio_vec  vec;
@@ -156,6 +157,7 @@ struct stripe_head {
 #define R5_ReadError    8       /* seen a read error here recently */
 #define R5_ReWrite      9       /* have tried to over-write the readerror */
 
+#define R5_Expanded     10      /* This block now has post-expand data */
 /*
  * Write method
  */
@@ -174,7 +176,9 @@ struct stripe_head {
 #define STRIPE_DELAYED          6
 #define STRIPE_DEGRADED         7
 #define STRIPE_BIT_DELAY        8
-
+#define STRIPE_EXPANDING        9
+#define STRIPE_EXPAND_SOURCE    10
+#define STRIPE_EXPAND_READY     11
 /*
  * Plugging:
  *
@@ -211,12 +215,24 @@ struct raid5_private_data {
         int                     raid_disks, working_disks, failed_disks;
         int                     max_nr_stripes;
 
+        /* used during an expand */
+        sector_t                expand_progress;        /* MaxSector when no expand happening */
+        sector_t                expand_lo; /* from here up to expand_progress it out-of-bounds
+                                            * as we haven't flushed the metadata yet
+                                            */
+        int                     previous_raid_disks;
+
         struct list_head        handle_list; /* stripes needing handling */
         struct list_head        delayed_list; /* stripes that have plugged requests */
         struct list_head        bitmap_list; /* stripes delaying awaiting bitmap update */
         atomic_t                preread_active_stripes; /* stripes with scheduled io */
 
-        char                    cache_name[20];
+        atomic_t                reshape_stripes; /* stripes with pending writes for reshape */
+        /* unfortunately we need two cache names as we temporarily have
+         * two caches.
+         */
+        int                     active_name;
+        char                    cache_name[2][20];
         kmem_cache_t            *slab_cache; /* for allocating stripes */
 
         int                     seq_flush, seq_write;
@@ -238,9 +254,10 @@ struct raid5_private_data {
         wait_queue_head_t       wait_for_overlap;
         int                     inactive_blocked;       /* release of inactive stripes blocked,
                                                          * waiting for 25% to be free
-                                                         */        
+                                                         */
+        int                     pool_size; /* number of disks in stripeheads in pool */
         spinlock_t              device_lock;
-        struct disk_info        disks[0];
+        struct disk_info        *disks;
 };
 
 typedef struct raid5_private_data raid5_conf_t;
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index b739ac1f7ca0..ab61cd1199f2 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -91,10 +91,102 @@ struct rtc_pll_info {
 #define RTC_PLL_GET     _IOR('p', 0x11, struct rtc_pll_info)  /* Get PLL correction */
 #define RTC_PLL_SET     _IOW('p', 0x12, struct rtc_pll_info)  /* Set PLL correction */
 
+/* interrupt flags */
+#define RTC_IRQF 0x80 /* any of the following is active */
+#define RTC_PF 0x40
+#define RTC_AF 0x20
+#define RTC_UF 0x10
+
 #ifdef __KERNEL__
 
 #include <linux/interrupt.h>
 
+extern int rtc_month_days(unsigned int month, unsigned int year);
+extern int rtc_valid_tm(struct rtc_time *tm);
+extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time);
+extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm);
+
+#include <linux/device.h>
+#include <linux/seq_file.h>
+#include <linux/cdev.h>
+#include <linux/poll.h>
+#include <linux/mutex.h>
+
+extern struct class *rtc_class;
+
+struct rtc_class_ops {
+        int (*open)(struct device *);
+        void (*release)(struct device *);
+        int (*ioctl)(struct device *, unsigned int, unsigned long);
+        int (*read_time)(struct device *, struct rtc_time *);
+        int (*set_time)(struct device *, struct rtc_time *);
+        int (*read_alarm)(struct device *, struct rtc_wkalrm *);
+        int (*set_alarm)(struct device *, struct rtc_wkalrm *);
+        int (*proc)(struct device *, struct seq_file *);
+        int (*set_mmss)(struct device *, unsigned long secs);
+        int (*irq_set_state)(struct device *, int enabled);
+        int (*irq_set_freq)(struct device *, int freq);
+        int (*read_callback)(struct device *, int data);
+};
+
+#define RTC_DEVICE_NAME_SIZE 20
+struct rtc_task;
+
+struct rtc_device
+{
+        struct class_device class_dev;
+        struct module *owner;
+
+        int id;
+        char name[RTC_DEVICE_NAME_SIZE];
+
+        struct rtc_class_ops *ops;
+        struct mutex ops_lock;
+
+        struct class_device *rtc_dev;
+        struct cdev char_dev;
+        struct mutex char_lock;
+
+        unsigned long irq_data;
+        spinlock_t irq_lock;
+        wait_queue_head_t irq_queue;
+        struct fasync_struct *async_queue;
+
+        struct rtc_task *irq_task;
+        spinlock_t irq_task_lock;
+        int irq_freq;
+};
+#define to_rtc_device(d) container_of(d, struct rtc_device, class_dev)
+
+extern struct rtc_device *rtc_device_register(const char *name,
+                                        struct device *dev,
+                                        struct rtc_class_ops *ops,
+                                        struct module *owner);
+extern void rtc_device_unregister(struct rtc_device *rdev);
+extern int rtc_interface_register(struct class_interface *intf);
+
+extern int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm);
+extern int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm);
+extern int rtc_set_mmss(struct class_device *class_dev, unsigned long secs);
+extern int rtc_read_alarm(struct class_device *class_dev,
+                        struct rtc_wkalrm *alrm);
+extern int rtc_set_alarm(struct class_device *class_dev,
+                                struct rtc_wkalrm *alrm);
+extern void rtc_update_irq(struct class_device *class_dev,
+                        unsigned long num, unsigned long events);
+
+extern struct class_device *rtc_class_open(char *name);
+extern void rtc_class_close(struct class_device *class_dev);
+
+extern int rtc_irq_register(struct class_device *class_dev,
+                                struct rtc_task *task);
+extern void rtc_irq_unregister(struct class_device *class_dev,
+                                struct rtc_task *task);
+extern int rtc_irq_set_state(struct class_device *class_dev,
+                                struct rtc_task *task, int enabled);
+extern int rtc_irq_set_freq(struct class_device *class_dev,
+                                struct rtc_task *task, int freq);
+
 typedef struct rtc_task {
         void (*func)(void *private_data);
         void *private_data;
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 036d14d2bf90..20b4f0372e44 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -35,6 +35,7 @@
 #include <linux/topology.h>
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
+#include <linux/futex.h>
 
 #include <linux/auxvec.h>       /* For AT_VECTOR_SIZE */
 
@@ -872,6 +873,11 @@ struct task_struct {
         int cpuset_mems_generation;
         int cpuset_mem_spread_rotor;
 #endif
+        struct robust_list_head __user *robust_list;
+#ifdef CONFIG_COMPAT
+        struct compat_robust_list_head __user *compat_robust_list;
+#endif
+
         atomic_t fs_excl;       /* holding fs exclusive resources */
         struct rcu_head rcu;
 };
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
index c4e3ea7cf154..b5612c958cce 100644
--- a/include/linux/sunrpc/cache.h
+++ b/include/linux/sunrpc/cache.h
@@ -50,7 +50,7 @@ struct cache_head {
         time_t          last_refresh;   /* If CACHE_PENDING, this is when upcall 
                                          * was sent, else this is when update was received
                                          */
-        atomic_t        refcnt;
+        struct kref     ref;
         unsigned long   flags;
 };
 #define CACHE_VALID     0       /* Entry contains valid data */
@@ -68,8 +68,7 @@ struct cache_detail {
         atomic_t                inuse; /* active user-space update or lookup */
 
         char                    *name;
-        void                    (*cache_put)(struct cache_head *,
-                                             struct cache_detail*);
+        void                    (*cache_put)(struct kref *);
 
         void                    (*cache_request)(struct cache_detail *cd,
                                                  struct cache_head *h,
@@ -81,6 +80,11 @@ struct cache_detail {
                                               struct cache_detail *cd,
                                               struct cache_head *h);
 
+        struct cache_head *     (*alloc)(void);
+        int                     (*match)(struct cache_head *orig, struct cache_head *new);
+        void                    (*init)(struct cache_head *orig, struct cache_head *new);
+        void                    (*update)(struct cache_head *orig, struct cache_head *new);
+
         /* fields below this comment are for internal use
          * and should not be touched by cache owners
          */
@@ -123,126 +127,14 @@ struct cache_deferred_req {
                                            int too_many);
 };
 
-/*
- * just like a template in C++, this macro does cache lookup
- * for us.
- * The function is passed some sort of HANDLE from which a cache_detail
- * structure can be determined (via SETUP, DETAIL), a template
- * cache entry (type RTN*), and a "set" flag.  Using the HASHFN and the 
- * TEST, the function will try to find a matching cache entry in the cache.
- * If "set" == 0 :
- *    If an entry is found, it is returned
- *    If no entry is found, a new non-VALID entry is created.
- * If "set" == 1 and INPLACE == 0 :
- *    If no entry is found a new one is inserted with data from "template"
- *    If a non-CACHE_VALID entry is found, it is updated from template using UPDATE
- *    If a CACHE_VALID entry is found, a new entry is swapped in with data
- *       from "template"
- * If set == 1, and INPLACE == 1 :
- *    As above, except that if a CACHE_VALID entry is found, we UPDATE in place
- *       instead of swapping in a new entry.
- *
- * If the passed handle has the CACHE_NEGATIVE flag set, then UPDATE is not
- * run but insteead CACHE_NEGATIVE is set in any new item.
 
- *  In any case, the new entry is returned with a reference count.
- *
- *    
- * RTN is a struct type for a cache entry
- * MEMBER is the member of the cache which is cache_head, which must be first
- * FNAME is the name for the function   
- * ARGS are arguments to function and must contain RTN *item, int set.  May
- *   also contain something to be usedby SETUP or DETAIL to find cache_detail.
- * SETUP  locates the cache detail and makes it available as...
- * DETAIL identifies the cache detail, possibly set up by SETUP
- * HASHFN returns a hash value of the cache entry "item"
- * TEST  tests if "tmp" matches "item"
- * INIT copies key information from "item" to "new"
- * UPDATE copies content information from "item" to "tmp"
- * INPLACE is true if updates can happen inplace rather than allocating a new structure
- *
- * WARNING: any substantial changes to this must be reflected in
- *   net/sunrpc/svcauth.c(auth_domain_lookup)
- *  which is a similar routine that is open-coded.
- */
-#define DefineCacheLookup(RTN,MEMBER,FNAME,ARGS,SETUP,DETAIL,HASHFN,TEST,INIT,UPDATE,INPLACE)   \
-RTN *FNAME ARGS                                                                         \
-{                                                                                       \
-        RTN *tmp, *new=NULL;                                                            \
-        struct cache_head **hp, **head;                                                 \
-        SETUP;                                                                          \
-        head = &(DETAIL)->hash_table[HASHFN];                                           \
- retry:                                                                                 \
-        if (set||new) write_lock(&(DETAIL)->hash_lock);                                 \
-        else read_lock(&(DETAIL)->hash_lock);                                           \
-        for(hp=head; *hp != NULL; hp = &tmp->MEMBER.next) {                             \
-                tmp = container_of(*hp, RTN, MEMBER);                                   \
-                if (TEST) { /* found a match */                                         \
-                                                                                        \
-                        if (set && !INPLACE && test_bit(CACHE_VALID, &tmp->MEMBER.flags) && !new) \
-                                break;                                                  \
-                                                                                        \
-                        if (new)                                                        \
-                                {INIT;}                                                 \
-                        if (set) {                                                      \
-                                if (!INPLACE && test_bit(CACHE_VALID, &tmp->MEMBER.flags))\
-                                { /* need to swap in new */                             \
-                                        RTN *t2;                                        \
-                                                                                        \
-                                        new->MEMBER.next = tmp->MEMBER.next;            \
-                                        *hp = &new->MEMBER;                             \
-                                        tmp->MEMBER.next = NULL;                        \
-                                        t2 = tmp; tmp = new; new = t2;                  \
-                                }                                                       \
-                                if (test_bit(CACHE_NEGATIVE,  &item->MEMBER.flags))     \
-                                        set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);    \
-                                else {                                                  \
-                                        UPDATE;                                         \
-                                        clear_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);  \
-                                }                                                       \
-                        }                                                               \
-                        cache_get(&tmp->MEMBER);                                        \
-                        if (set||new) write_unlock(&(DETAIL)->hash_lock);               \
-                        else read_unlock(&(DETAIL)->hash_lock);                         \
-                        if (set)                                                        \
-                                cache_fresh(DETAIL, &tmp->MEMBER, item->MEMBER.expiry_time); \
-                        if (set && !INPLACE && new) cache_fresh(DETAIL, &new->MEMBER, 0);       \
-                        if (new) (DETAIL)->cache_put(&new->MEMBER, DETAIL);             \
-                        return tmp;                                                     \
-                }                                                                       \
-        }                                                                               \
-        /* Didn't find anything */                                                      \
-        if (new) {                                                                      \
-                INIT;                                                                   \
-                new->MEMBER.next = *head;                                               \
-                *head = &new->MEMBER;                                                   \
-                (DETAIL)->entries ++;                                                   \
-                cache_get(&new->MEMBER);                                                \
-                if (set) {                                                              \
-                        tmp = new;                                                      \
-                        if (test_bit(CACHE_NEGATIVE, &item->MEMBER.flags))              \
-                                set_bit(CACHE_NEGATIVE, &tmp->MEMBER.flags);            \
-                        else {UPDATE;}                                                  \
-                }                                                                       \
-        }                                                                               \
-        if (set||new) write_unlock(&(DETAIL)->hash_lock);                               \
-        else read_unlock(&(DETAIL)->hash_lock);                                         \
-        if (new && set)                                                                 \
-                cache_fresh(DETAIL, &new->MEMBER, item->MEMBER.expiry_time);            \
-        if (new)                                                                        \
-                return new;                                                             \
-        new = kmalloc(sizeof(*new), GFP_KERNEL);                                        \
-        if (new) {                                                                      \
-                cache_init(&new->MEMBER);                                               \
-                goto retry;                                                             \
-        }                                                                               \
-        return NULL;                                                                    \
-}
+extern struct cache_head *
+sunrpc_cache_lookup(struct cache_detail *detail,
+                    struct cache_head *key, int hash);
+extern struct cache_head *
+sunrpc_cache_update(struct cache_detail *detail,
+                    struct cache_head *new, struct cache_head *old, int hash);
 
-#define DefineSimpleCacheLookup(STRUCT,INPLACE) \
-        DefineCacheLookup(struct STRUCT, h, STRUCT##_lookup, (struct STRUCT *item, int set), /*no setup */,     \
-                          & STRUCT##_cache, STRUCT##_hash(item), STRUCT##_match(item, tmp),\
-                          STRUCT##_init(new, item), STRUCT##_update(tmp, item),INPLACE)
 
 #define cache_for_each(pos, detail, index, member)                                              \
         for (({read_lock(&(detail)->hash_lock); index = (detail)->hash_size;}) ;                \
@@ -258,22 +150,19 @@ extern void cache_clean_deferred(void *owner);
 
 static inline struct cache_head  *cache_get(struct cache_head *h)
 {
-        atomic_inc(&h->refcnt);
+        kref_get(&h->ref);
         return h;
 }
 
 
-static inline int cache_put(struct cache_head *h, struct cache_detail *cd)
+static inline void cache_put(struct cache_head *h, struct cache_detail *cd)
 {
-        if (atomic_read(&h->refcnt) <= 2 &&
+        if (atomic_read(&h->ref.refcount) <= 2 &&
             h->expiry_time < cd->nextcheck)
                 cd->nextcheck = h->expiry_time;
-        return atomic_dec_and_test(&h->refcnt);
+        kref_put(&h->ref, cd->cache_put);
 }
 
-extern void cache_init(struct cache_head *h);
-extern void cache_fresh(struct cache_detail *detail,
-                        struct cache_head *head, time_t expiry);
 extern int cache_check(struct cache_detail *detail,
                        struct cache_head *h, struct cache_req *rqstp);
 extern void cache_flush(void);
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index c119ce7cbd22..2fe2087edd66 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -45,9 +45,10 @@ struct svc_rqst;		/* forward decl */
  * of ip addresses to the given client.
  */
 struct auth_domain {
-        struct  cache_head      h;
+        struct kref             ref;
+        struct hlist_node       hash;
         char                    *name;
-        int                     flavour;
+        struct auth_ops         *flavour;
 };
 
 /*
@@ -86,6 +87,9 @@ struct auth_domain {
  *
  * domain_release()
  *   This call releases a domain.
+ * set_client()
+ *   Givens a pending request (struct svc_rqst), finds and assigns
+ *   an appropriate 'auth_domain' as the client.
  */
 struct auth_ops {
         char *  name;
@@ -117,7 +121,7 @@ extern void	svc_auth_unregister(rpc_authflavor_t flavor);
 extern struct auth_domain *unix_domain_find(char *name);
 extern void auth_domain_put(struct auth_domain *item);
 extern int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom);
-extern struct auth_domain *auth_domain_lookup(struct auth_domain *item, int set);
+extern struct auth_domain *auth_domain_lookup(char *name, struct auth_domain *new);
 extern struct auth_domain *auth_domain_find(char *name);
 extern struct auth_domain *auth_unix_lookup(struct in_addr addr);
 extern int auth_unix_forget_old(struct auth_domain *dom);
@@ -160,8 +164,6 @@ static inline unsigned long hash_mem(char *buf, int length, int bits)
         return hash >> (BITS_PER_LONG - bits);
 }
 
-extern struct cache_detail auth_domain_cache, ip_map_cache;
-
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_SUNRPC_SVCAUTH_H_ */
diff --git a/include/linux/threads.h b/include/linux/threads.h
index b59738ac6197..e646bcdf2614 100644
--- a/include/linux/threads.h
+++ b/include/linux/threads.h
@@ -28,7 +28,8 @@
 #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000)
 
 /*
- * A maximum of 4 million PIDs should be enough for a while:
+ * A maximum of 4 million PIDs should be enough for a while.
+ * [NOTE: PID/TIDs are limited to 2^29 ~= 500+ million, see futex.h.]
  */
 #define PID_MAX_LIMIT (CONFIG_BASE_SMALL ? PAGE_SIZE * 8 : \
         (sizeof(long) > 4 ? 4 * 1024 * 1024 : PID_MAX_DEFAULT))
diff --git a/include/linux/topology.h b/include/linux/topology.h
index e8eb0040ce3a..a305ae2e44b6 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -164,6 +164,15 @@
         .nr_balance_failed      = 0,                    \
 }
 
+#ifdef CONFIG_SCHED_MC
+#ifndef SD_MC_INIT
+/* for now its same as SD_CPU_INIT.
+ * TBD: Tune Domain parameters!
+ */
+#define SD_MC_INIT   SD_CPU_INIT
+#endif
+#endif
+
 #ifdef CONFIG_NUMA
 #ifndef SD_NODE_INIT
 #error Please define an appropriate SD_NODE_INIT in include/asm/topology.h!!!
diff --git a/include/linux/x1205.h b/include/linux/x1205.h
deleted file mode 100644
index 64fd3af894a5..000000000000
--- a/include/linux/x1205.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- *  x1205.h - defines for drivers/i2c/chips/x1205.c
- *  Copyright 2004 Karen Spearel
- *  Copyright 2005 Alessandro Zummo
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- */
-
-#ifndef __LINUX_X1205_H__
-#define __LINUX_X1205_H__
-
-/* commands */
-
-#define X1205_CMD_GETDATETIME   0
-#define X1205_CMD_SETTIME       1
-#define X1205_CMD_SETDATETIME   2
-#define X1205_CMD_GETALARM      3
-#define X1205_CMD_SETALARM      4
-#define X1205_CMD_GETDTRIM      5
-#define X1205_CMD_SETDTRIM      6
-#define X1205_CMD_GETATRIM      7
-#define X1205_CMD_SETATRIM      8
-
-extern int x1205_do_command(unsigned int cmd, void *arg);
-extern int x1205_direct_attach(int adapter_id,
-        struct i2c_client_address_data *address_data);
-
-#endif /* __LINUX_X1205_H__ */
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index b6f0905a4ee2..916013ca4a5c 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -300,29 +300,30 @@ DECLARE_PER_CPU(struct nf_conntrack_ecache, nf_conntrack_ecache);
 
 #define CONNTRACK_ECACHE(x)     (__get_cpu_var(nf_conntrack_ecache).x)
 
-extern struct notifier_block *nf_conntrack_chain;
-extern struct notifier_block *nf_conntrack_expect_chain;
+extern struct atomic_notifier_head nf_conntrack_chain;
+extern struct atomic_notifier_head nf_conntrack_expect_chain;
 
 static inline int nf_conntrack_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&nf_conntrack_chain, nb);
+        return atomic_notifier_chain_register(&nf_conntrack_chain, nb);
 }
 
 static inline int nf_conntrack_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&nf_conntrack_chain, nb);
+        return atomic_notifier_chain_unregister(&nf_conntrack_chain, nb);
 }
 
 static inline int
 nf_conntrack_expect_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&nf_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_register(&nf_conntrack_expect_chain, nb);
 }
 
 static inline int
 nf_conntrack_expect_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&nf_conntrack_expect_chain, nb);
+        return atomic_notifier_chain_unregister(&nf_conntrack_expect_chain,
+                        nb);
 }
 
 extern void nf_ct_deliver_cached_events(const struct nf_conn *ct);
@@ -347,14 +348,14 @@ static inline void nf_conntrack_event(enum ip_conntrack_events event,
                                       struct nf_conn *ct)
 {
         if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct))
-                notifier_call_chain(&nf_conntrack_chain, event, ct);
+                atomic_notifier_call_chain(&nf_conntrack_chain, event, ct);
 }
 
 static inline void
 nf_conntrack_expect_event(enum ip_conntrack_expect_events event,
                           struct nf_conntrack_expect *exp)
 {
-        notifier_call_chain(&nf_conntrack_expect_chain, event, exp);
+        atomic_notifier_call_chain(&nf_conntrack_expect_chain, event, exp);
 }
 #else /* CONFIG_NF_CONNTRACK_EVENTS */
 static inline void nf_conntrack_event_cache(enum ip_conntrack_events event,
diff --git a/kernel/Makefile b/kernel/Makefile
index ff1c11dc12cf..58908f9d156a 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -12,6 +12,9 @@ obj-y     = sched.o fork.o exec_domain.o panic.o printk.o profile.o \
 
 obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
 obj-$(CONFIG_FUTEX) += futex.o
+ifeq ($(CONFIG_COMPAT),y)
+obj-$(CONFIG_FUTEX) += futex_compat.o
+endif
 obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
 obj-$(CONFIG_SMP) += cpu.o spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
diff --git a/kernel/compat.c b/kernel/compat.c
index b9bdd1271f44..c1601a84f8d8 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -17,7 +17,6 @@
 #include <linux/time.h>
 #include <linux/signal.h>
 #include <linux/sched.h>        /* for MAX_SCHEDULE_TIMEOUT */
-#include <linux/futex.h>        /* for FUTEX_WAIT */
 #include <linux/syscalls.h>
 #include <linux/unistd.h>
 #include <linux/security.h>
@@ -239,28 +238,6 @@ asmlinkage long compat_sys_sigprocmask(int how, compat_old_sigset_t __user *set,
         return ret;
 }
 
-#ifdef CONFIG_FUTEX
-asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, int val,
-                struct compat_timespec __user *utime, u32 __user *uaddr2,
-                int val3)
-{
-        struct timespec t;
-        unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
-        int val2 = 0;
-
-        if ((op == FUTEX_WAIT) && utime) {
-                if (get_compat_timespec(&t, utime))
-                        return -EFAULT;
-                timeout = timespec_to_jiffies(&t) + 1;
-        }
-        if (op >= FUTEX_REQUEUE)
-                val2 = (int) (unsigned long) utime;
-
-        return do_futex((unsigned long)uaddr, op, val, timeout,
-                        (unsigned long)uaddr2, val2, val3);
-}
-#endif
-
 asmlinkage long compat_sys_setrlimit(unsigned int resource,
                 struct compat_rlimit __user *rlim)
 {
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 8be22bd80933..fe2b8d0bfe4c 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -18,7 +18,7 @@
 /* This protects CPUs going up and down... */
 static DECLARE_MUTEX(cpucontrol);
 
-static struct notifier_block *cpu_chain;
+static BLOCKING_NOTIFIER_HEAD(cpu_chain);
 
 #ifdef CONFIG_HOTPLUG_CPU
 static struct task_struct *lock_cpu_hotplug_owner;
@@ -71,21 +71,13 @@ EXPORT_SYMBOL_GPL(lock_cpu_hotplug_interruptible);
 /* Need to know about CPUs going up/down? */
 int register_cpu_notifier(struct notifier_block *nb)
 {
-        int ret;
-
-        if ((ret = lock_cpu_hotplug_interruptible()) != 0)
-                return ret;
-        ret = notifier_chain_register(&cpu_chain, nb);
-        unlock_cpu_hotplug();
-        return ret;
+        return blocking_notifier_chain_register(&cpu_chain, nb);
 }
 EXPORT_SYMBOL(register_cpu_notifier);
 
 void unregister_cpu_notifier(struct notifier_block *nb)
 {
-        lock_cpu_hotplug();
-        notifier_chain_unregister(&cpu_chain, nb);
-        unlock_cpu_hotplug();
+        blocking_notifier_chain_unregister(&cpu_chain, nb);
 }
 EXPORT_SYMBOL(unregister_cpu_notifier);
 
@@ -141,7 +133,7 @@ int cpu_down(unsigned int cpu)
                 goto out;
         }
 
-        err = notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE,
+        err = blocking_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE,
                                                 (void *)(long)cpu);
         if (err == NOTIFY_BAD) {
                 printk("%s: attempt to take down CPU %u failed\n",
@@ -159,7 +151,7 @@ int cpu_down(unsigned int cpu)
         p = __stop_machine_run(take_cpu_down, NULL, cpu);
         if (IS_ERR(p)) {
                 /* CPU didn't die: tell everyone.  Can't complain. */
-                if (notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED,
+                if (blocking_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED,
                                 (void *)(long)cpu) == NOTIFY_BAD)
                         BUG();
 
@@ -182,8 +174,8 @@ int cpu_down(unsigned int cpu)
         put_cpu();
 
         /* CPU is completely dead: tell everyone.  Too late to complain. */
-        if (notifier_call_chain(&cpu_chain, CPU_DEAD, (void *)(long)cpu)
-            == NOTIFY_BAD)
+        if (blocking_notifier_call_chain(&cpu_chain, CPU_DEAD,
+                        (void *)(long)cpu) == NOTIFY_BAD)
                 BUG();
 
         check_for_tasks(cpu);
@@ -211,7 +203,7 @@ int __devinit cpu_up(unsigned int cpu)
                 goto out;
         }
 
-        ret = notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu);
+        ret = blocking_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu);
         if (ret == NOTIFY_BAD) {
                 printk("%s: attempt to bring up CPU %u failed\n",
                                 __FUNCTION__, cpu);
@@ -226,11 +218,12 @@ int __devinit cpu_up(unsigned int cpu)
         BUG_ON(!cpu_online(cpu));
 
         /* Now call notifier in preparation. */
-        notifier_call_chain(&cpu_chain, CPU_ONLINE, hcpu);
+        blocking_notifier_call_chain(&cpu_chain, CPU_ONLINE, hcpu);
 
 out_notify:
         if (ret != 0)
-                notifier_call_chain(&cpu_chain, CPU_UP_CANCELED, hcpu);
+                blocking_notifier_call_chain(&cpu_chain,
+                                CPU_UP_CANCELED, hcpu);
 out:
         unlock_cpu_hotplug();
         return ret;
diff --git a/kernel/exit.c b/kernel/exit.c
index 8037405e136e..a8c7efc7a681 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -31,6 +31,8 @@
 #include <linux/signal.h>
 #include <linux/cn_proc.h>
 #include <linux/mutex.h>
+#include <linux/futex.h>
+#include <linux/compat.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -852,6 +854,12 @@ fastcall NORET_TYPE void do_exit(long code)
                 exit_itimers(tsk->signal);
                 acct_process(code);
         }
+        if (unlikely(tsk->robust_list))
+                exit_robust_list(tsk);
+#ifdef CONFIG_COMPAT
+        if (unlikely(tsk->compat_robust_list))
+                compat_exit_robust_list(tsk);
+#endif
         exit_mm(tsk);
 
         exit_sem(tsk);
diff --git a/kernel/fork.c b/kernel/fork.c
index e0a2b449dea6..c49bd193b058 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1061,7 +1061,10 @@ static task_t *copy_process(unsigned long clone_flags,
          * Clear TID on mm_release()?
          */
         p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
-
+        p->robust_list = NULL;
+#ifdef CONFIG_COMPAT
+        p->compat_robust_list = NULL;
+#endif
         /*
          * sigaltstack should be cleared when sharing the same VM
          */
diff --git a/kernel/futex.c b/kernel/futex.c
index 5efa2f978032..9c9b2b6b22dd 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -8,6 +8,10 @@
  *  Removed page pinning, fix privately mapped COW pages and other cleanups
  *  (C) Copyright 2003, 2004 Jamie Lokier
  *
+ *  Robust futex support started by Ingo Molnar
+ *  (C) Copyright 2006 Red Hat Inc, All Rights Reserved
+ *  Thanks to Thomas Gleixner for suggestions, analysis and fixes.
+ *
  *  Thanks to Ben LaHaise for yelling "hashed waitqueues" loudly
  *  enough at me, Linus for the original (flawed) idea, Matthew
  *  Kirkwood for proof-of-concept implementation.
@@ -829,6 +833,172 @@ error:
         goto out;
 }
 
+/*
+ * Support for robust futexes: the kernel cleans up held futexes at
+ * thread exit time.
+ *
+ * Implementation: user-space maintains a per-thread list of locks it
+ * is holding. Upon do_exit(), the kernel carefully walks this list,
+ * and marks all locks that are owned by this thread with the
+ * FUTEX_OWNER_DEAD bit, and wakes up a waiter (if any). The list is
+ * always manipulated with the lock held, so the list is private and
+ * per-thread. Userspace also maintains a per-thread 'list_op_pending'
+ * field, to allow the kernel to clean up if the thread dies after
+ * acquiring the lock, but just before it could have added itself to
+ * the list. There can only be one such pending lock.
+ */
+
+/**
+ * sys_set_robust_list - set the robust-futex list head of a task
+ * @head: pointer to the list-head
+ * @len: length of the list-head, as userspace expects
+ */
+asmlinkage long
+sys_set_robust_list(struct robust_list_head __user *head,
+                    size_t len)
+{
+        /*
+         * The kernel knows only one size for now:
+         */
+        if (unlikely(len != sizeof(*head)))
+                return -EINVAL;
+
+        current->robust_list = head;
+
+        return 0;
+}
+
+/**
+ * sys_get_robust_list - get the robust-futex list head of a task
+ * @pid: pid of the process [zero for current task]
+ * @head_ptr: pointer to a list-head pointer, the kernel fills it in
+ * @len_ptr: pointer to a length field, the kernel fills in the header size
+ */
+asmlinkage long
+sys_get_robust_list(int pid, struct robust_list_head __user **head_ptr,
+                    size_t __user *len_ptr)
+{
+        struct robust_list_head *head;
+        unsigned long ret;
+
+        if (!pid)
+                head = current->robust_list;
+        else {
+                struct task_struct *p;
+
+                ret = -ESRCH;
+                read_lock(&tasklist_lock);
+                p = find_task_by_pid(pid);
+                if (!p)
+                        goto err_unlock;
+                ret = -EPERM;
+                if ((current->euid != p->euid) && (current->euid != p->uid) &&
+                                !capable(CAP_SYS_PTRACE))
+                        goto err_unlock;
+                head = p->robust_list;
+                read_unlock(&tasklist_lock);
+        }
+
+        if (put_user(sizeof(*head), len_ptr))
+                return -EFAULT;
+        return put_user(head, head_ptr);
+
+err_unlock:
+        read_unlock(&tasklist_lock);
+
+        return ret;
+}
+
+/*
+ * Process a futex-list entry, check whether it's owned by the
+ * dying task, and do notification if so:
+ */
+int handle_futex_death(u32 __user *uaddr, struct task_struct *curr)
+{
+        u32 uval;
+
+retry:
+        if (get_user(uval, uaddr))
+                return -1;
+
+        if ((uval & FUTEX_TID_MASK) == curr->pid) {
+                /*
+                 * Ok, this dying thread is truly holding a futex
+                 * of interest. Set the OWNER_DIED bit atomically
+                 * via cmpxchg, and if the value had FUTEX_WAITERS
+                 * set, wake up a waiter (if any). (We have to do a
+                 * futex_wake() even if OWNER_DIED is already set -
+                 * to handle the rare but possible case of recursive
+                 * thread-death.) The rest of the cleanup is done in
+                 * userspace.
+                 */
+                if (futex_atomic_cmpxchg_inatomic(uaddr, uval,
+                                         uval | FUTEX_OWNER_DIED) != uval)
+                        goto retry;
+
+                if (uval & FUTEX_WAITERS)
+                        futex_wake((unsigned long)uaddr, 1);
+        }
+        return 0;
+}
+
+/*
+ * Walk curr->robust_list (very carefully, it's a userspace list!)
+ * and mark any locks found there dead, and notify any waiters.
+ *
+ * We silently return on any sign of list-walking problem.
+ */
+void exit_robust_list(struct task_struct *curr)
+{
+        struct robust_list_head __user *head = curr->robust_list;
+        struct robust_list __user *entry, *pending;
+        unsigned int limit = ROBUST_LIST_LIMIT;
+        unsigned long futex_offset;
+
+        /*
+         * Fetch the list head (which was registered earlier, via
+         * sys_set_robust_list()):
+         */
+        if (get_user(entry, &head->list.next))
+                return;
+        /*
+         * Fetch the relative futex offset:
+         */
+        if (get_user(futex_offset, &head->futex_offset))
+                return;
+        /*
+         * Fetch any possibly pending lock-add first, and handle it
+         * if it exists:
+         */
+        if (get_user(pending, &head->list_op_pending))
+                return;
+        if (pending)
+                handle_futex_death((void *)pending + futex_offset, curr);
+
+        while (entry != &head->list) {
+                /*
+                 * A pending lock might already be on the list, so
+                 * dont process it twice:
+                 */
+                if (entry != pending)
+                        if (handle_futex_death((void *)entry + futex_offset,
+                                                curr))
+                                return;
+                /*
+                 * Fetch the next entry in the list:
+                 */
+                if (get_user(entry, &entry->next))
+                        return;
+                /*
+                 * Avoid excessively long or circular lists:
+                 */
+                if (!--limit)
+                        break;
+
+                cond_resched();
+        }
+}
+
 long do_futex(unsigned long uaddr, int op, int val, unsigned long timeout,
                 unsigned long uaddr2, int val2, int val3)
 {
diff --git a/kernel/futex_compat.c b/kernel/futex_compat.c
new file mode 100644
index 000000000000..9c077cf9aa84
--- /dev/null
+++ b/kernel/futex_compat.c
@@ -0,0 +1,141 @@
+/*
+ * linux/kernel/futex_compat.c
+ *
+ * Futex compatibililty routines.
+ *
+ * Copyright 2006, Red Hat, Inc., Ingo Molnar
+ */
+
+#include <linux/linkage.h>
+#include <linux/compat.h>
+#include <linux/futex.h>
+
+#include <asm/uaccess.h>
+
+/*
+ * Walk curr->robust_list (very carefully, it's a userspace list!)
+ * and mark any locks found there dead, and notify any waiters.
+ *
+ * We silently return on any sign of list-walking problem.
+ */
+void compat_exit_robust_list(struct task_struct *curr)
+{
+        struct compat_robust_list_head __user *head = curr->compat_robust_list;
+        struct robust_list __user *entry, *pending;
+        compat_uptr_t uentry, upending;
+        unsigned int limit = ROBUST_LIST_LIMIT;
+        compat_long_t futex_offset;
+
+        /*
+         * Fetch the list head (which was registered earlier, via
+         * sys_set_robust_list()):
+         */
+        if (get_user(uentry, &head->list.next))
+                return;
+        entry = compat_ptr(uentry);
+        /*
+         * Fetch the relative futex offset:
+         */
+        if (get_user(futex_offset, &head->futex_offset))
+                return;
+        /*
+         * Fetch any possibly pending lock-add first, and handle it
+         * if it exists:
+         */
+        if (get_user(upending, &head->list_op_pending))
+                return;
+        pending = compat_ptr(upending);
+        if (upending)
+                handle_futex_death((void *)pending + futex_offset, curr);
+
+        while (compat_ptr(uentry) != &head->list) {
+                /*
+                 * A pending lock might already be on the list, so
+                 * dont process it twice:
+                 */
+                if (entry != pending)
+                        if (handle_futex_death((void *)entry + futex_offset,
+                                                curr))
+                                return;
+
+                /*
+                 * Fetch the next entry in the list:
+                 */
+                if (get_user(uentry, (compat_uptr_t *)&entry->next))
+                        return;
+                entry = compat_ptr(uentry);
+                /*
+                 * Avoid excessively long or circular lists:
+                 */
+                if (!--limit)
+                        break;
+
+                cond_resched();
+        }
+}
+
+asmlinkage long
+compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
+                           compat_size_t len)
+{
+        if (unlikely(len != sizeof(*head)))
+                return -EINVAL;
+
+        current->compat_robust_list = head;
+
+        return 0;
+}
+
+asmlinkage long
+compat_sys_get_robust_list(int pid, compat_uptr_t *head_ptr,
+                           compat_size_t __user *len_ptr)
+{
+        struct compat_robust_list_head *head;
+        unsigned long ret;
+
+        if (!pid)
+                head = current->compat_robust_list;
+        else {
+                struct task_struct *p;
+
+                ret = -ESRCH;
+                read_lock(&tasklist_lock);
+                p = find_task_by_pid(pid);
+                if (!p)
+                        goto err_unlock;
+                ret = -EPERM;
+                if ((current->euid != p->euid) && (current->euid != p->uid) &&
+                                !capable(CAP_SYS_PTRACE))
+                        goto err_unlock;
+                head = p->compat_robust_list;
+                read_unlock(&tasklist_lock);
+        }
+
+        if (put_user(sizeof(*head), len_ptr))
+                return -EFAULT;
+        return put_user(ptr_to_compat(head), head_ptr);
+
+err_unlock:
+        read_unlock(&tasklist_lock);
+
+        return ret;
+}
+
+asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val,
+                struct compat_timespec __user *utime, u32 __user *uaddr2,
+                u32 val3)
+{
+        struct timespec t;
+        unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
+        int val2 = 0;
+
+        if ((op == FUTEX_WAIT) && utime) {
+                if (get_compat_timespec(&t, utime))
+                        return -EFAULT;
+                timeout = timespec_to_jiffies(&t) + 1;
+        }
+        if (op >= FUTEX_REQUEUE)
+                val2 = (int) (unsigned long) utime;
+
+        return do_futex(uaddr, op, val, timeout, uaddr2, val2, val3);
+}
diff --git a/kernel/module.c b/kernel/module.c
index ddfe45ac2fd1..4fafd58038a0 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -64,26 +64,17 @@ static DEFINE_SPINLOCK(modlist_lock);
 static DEFINE_MUTEX(module_mutex);
 static LIST_HEAD(modules);
 
-static DEFINE_MUTEX(notify_mutex);
-static struct notifier_block * module_notify_list;
+static BLOCKING_NOTIFIER_HEAD(module_notify_list);
 
 int register_module_notifier(struct notifier_block * nb)
 {
-        int err;
-        mutex_lock(&notify_mutex);
-        err = notifier_chain_register(&module_notify_list, nb);
-        mutex_unlock(&notify_mutex);
-        return err;
+        return blocking_notifier_chain_register(&module_notify_list, nb);
 }
 EXPORT_SYMBOL(register_module_notifier);
 
 int unregister_module_notifier(struct notifier_block * nb)
 {
-        int err;
-        mutex_lock(&notify_mutex);
-        err = notifier_chain_unregister(&module_notify_list, nb);
-        mutex_unlock(&notify_mutex);
-        return err;
+        return blocking_notifier_chain_unregister(&module_notify_list, nb);
 }
 EXPORT_SYMBOL(unregister_module_notifier);
 
@@ -1816,9 +1807,8 @@ sys_init_module(void __user *umod,
         /* Drop lock so they can recurse */
         mutex_unlock(&module_mutex);
 
-        mutex_lock(&notify_mutex);
-        notifier_call_chain(&module_notify_list, MODULE_STATE_COMING, mod);
-        mutex_unlock(&notify_mutex);
+        blocking_notifier_call_chain(&module_notify_list,
+                        MODULE_STATE_COMING, mod);
 
         /* Start the module */
         if (mod->init != NULL)
diff --git a/kernel/panic.c b/kernel/panic.c
index acd95adddb93..f895c7c01d5b 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -29,7 +29,7 @@ static DEFINE_SPINLOCK(pause_on_oops_lock);
 int panic_timeout;
 EXPORT_SYMBOL(panic_timeout);
 
-struct notifier_block *panic_notifier_list;
+ATOMIC_NOTIFIER_HEAD(panic_notifier_list);
 
 EXPORT_SYMBOL(panic_notifier_list);
 
@@ -97,7 +97,7 @@ NORET_TYPE void panic(const char * fmt, ...)
         smp_send_stop();
 #endif
 
-        notifier_call_chain(&panic_notifier_list, 0, buf);
+        atomic_notifier_call_chain(&panic_notifier_list, 0, buf);
 
         if (!panic_blink)
                 panic_blink = no_blink;
diff --git a/kernel/profile.c b/kernel/profile.c
index ad81f799a9b4..5a730fdb1a2c 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -87,72 +87,52 @@ void __init profile_init(void)
  
 #ifdef CONFIG_PROFILING
  
-static DECLARE_RWSEM(profile_rwsem);
-static DEFINE_RWLOCK(handoff_lock);
-static struct notifier_block * task_exit_notifier;
-static struct notifier_block * task_free_notifier;
-static struct notifier_block * munmap_notifier;
+static BLOCKING_NOTIFIER_HEAD(task_exit_notifier);
+static ATOMIC_NOTIFIER_HEAD(task_free_notifier);
+static BLOCKING_NOTIFIER_HEAD(munmap_notifier);
  
 void profile_task_exit(struct task_struct * task)
 {
-        down_read(&profile_rwsem);
-        notifier_call_chain(&task_exit_notifier, 0, task);
-        up_read(&profile_rwsem);
+        blocking_notifier_call_chain(&task_exit_notifier, 0, task);
 }
  
 int profile_handoff_task(struct task_struct * task)
 {
         int ret;
-        read_lock(&handoff_lock);
-        ret = notifier_call_chain(&task_free_notifier, 0, task);
-        read_unlock(&handoff_lock);
+        ret = atomic_notifier_call_chain(&task_free_notifier, 0, task);
         return (ret == NOTIFY_OK) ? 1 : 0;
 }
 
 void profile_munmap(unsigned long addr)
 {
-        down_read(&profile_rwsem);
-        notifier_call_chain(&munmap_notifier, 0, (void *)addr);
-        up_read(&profile_rwsem);
+        blocking_notifier_call_chain(&munmap_notifier, 0, (void *)addr);
 }
 
 int task_handoff_register(struct notifier_block * n)
 {
-        int err = -EINVAL;
-
-        write_lock(&handoff_lock);
-        err = notifier_chain_register(&task_free_notifier, n);
-        write_unlock(&handoff_lock);
-        return err;
+        return atomic_notifier_chain_register(&task_free_notifier, n);
 }
 
 int task_handoff_unregister(struct notifier_block * n)
 {
-        int err = -EINVAL;
-
-        write_lock(&handoff_lock);
-        err = notifier_chain_unregister(&task_free_notifier, n);
-        write_unlock(&handoff_lock);
-        return err;
+        return atomic_notifier_chain_unregister(&task_free_notifier, n);
 }
 
 int profile_event_register(enum profile_type type, struct notifier_block * n)
 {
         int err = -EINVAL;
  
-        down_write(&profile_rwsem);
- 
         switch (type) {
                 case PROFILE_TASK_EXIT:
-                        err = notifier_chain_register(&task_exit_notifier, n);
+                        err = blocking_notifier_chain_register(
+                                        &task_exit_notifier, n);
                         break;
                 case PROFILE_MUNMAP:
-                        err = notifier_chain_register(&munmap_notifier, n);
+                        err = blocking_notifier_chain_register(
+                                        &munmap_notifier, n);
                         break;
         }
  
-        up_write(&profile_rwsem);
- 
         return err;
 }
 
@@ -161,18 +141,17 @@ int profile_event_unregister(enum profile_type type, struct notifier_block * n)
 {
         int err = -EINVAL;
  
-        down_write(&profile_rwsem);
- 
         switch (type) {
                 case PROFILE_TASK_EXIT:
-                        err = notifier_chain_unregister(&task_exit_notifier, n);
+                        err = blocking_notifier_chain_unregister(
+                                        &task_exit_notifier, n);
                         break;
                 case PROFILE_MUNMAP:
-                        err = notifier_chain_unregister(&munmap_notifier, n);
+                        err = blocking_notifier_chain_unregister(
+                                        &munmap_notifier, n);
                         break;
         }
 
-        up_write(&profile_rwsem);
         return err;
 }
 
diff --git a/kernel/sched.c b/kernel/sched.c
index 78acdefeccca..7854ee516b92 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -145,7 +145,8 @@
         (v1) * (v2_max) / (v1_max)
 
 #define DELTA(p) \
-        (SCALE(TASK_NICE(p), 40, MAX_BONUS) + INTERACTIVE_DELTA)
+        (SCALE(TASK_NICE(p) + 20, 40, MAX_BONUS) - 20 * MAX_BONUS / 40 + \
+                INTERACTIVE_DELTA)
 
 #define TASK_INTERACTIVE(p) \
         ((p)->prio <= (p)->static_prio - DELTA(p))
@@ -2878,13 +2879,11 @@ asmlinkage void __sched schedule(void)
          * schedule() atomically, we ignore that path for now.
          * Otherwise, whine if we are scheduling when we should not be.
          */
-        if (likely(!current->exit_state)) {
-                if (unlikely(in_atomic())) {
-                        printk(KERN_ERR "BUG: scheduling while atomic: "
-                                "%s/0x%08x/%d\n",
-                                current->comm, preempt_count(), current->pid);
-                        dump_stack();
-                }
+        if (unlikely(in_atomic() && !current->exit_state)) {
+                printk(KERN_ERR "BUG: scheduling while atomic: "
+                        "%s/0x%08x/%d\n",
+                        current->comm, preempt_count(), current->pid);
+                dump_stack();
         }
         profile_hit(SCHED_PROFILING, __builtin_return_address(0));
 
@@ -5575,11 +5574,31 @@ static int cpu_to_cpu_group(int cpu)
 }
 #endif
 
+#ifdef CONFIG_SCHED_MC
+static DEFINE_PER_CPU(struct sched_domain, core_domains);
+static struct sched_group sched_group_core[NR_CPUS];
+#endif
+
+#if defined(CONFIG_SCHED_MC) && defined(CONFIG_SCHED_SMT)
+static int cpu_to_core_group(int cpu)
+{
+        return first_cpu(cpu_sibling_map[cpu]);
+}
+#elif defined(CONFIG_SCHED_MC)
+static int cpu_to_core_group(int cpu)
+{
+        return cpu;
+}
+#endif
+
 static DEFINE_PER_CPU(struct sched_domain, phys_domains);
 static struct sched_group sched_group_phys[NR_CPUS];
 static int cpu_to_phys_group(int cpu)
 {
-#ifdef CONFIG_SCHED_SMT
+#if defined(CONFIG_SCHED_MC)
+        cpumask_t mask = cpu_coregroup_map(cpu);
+        return first_cpu(mask);
+#elif defined(CONFIG_SCHED_SMT)
         return first_cpu(cpu_sibling_map[cpu]);
 #else
         return cpu;
@@ -5602,6 +5621,32 @@ static int cpu_to_allnodes_group(int cpu)
 {
         return cpu_to_node(cpu);
 }
+static void init_numa_sched_groups_power(struct sched_group *group_head)
+{
+        struct sched_group *sg = group_head;
+        int j;
+
+        if (!sg)
+                return;
+next_sg:
+        for_each_cpu_mask(j, sg->cpumask) {
+                struct sched_domain *sd;
+
+                sd = &per_cpu(phys_domains, j);
+                if (j != first_cpu(sd->groups->cpumask)) {
+                        /*
+                         * Only add "power" once for each
+                         * physical package.
+                         */
+                        continue;
+                }
+
+                sg->cpu_power += sd->groups->cpu_power;
+        }
+        sg = sg->next;
+        if (sg != group_head)
+                goto next_sg;
+}
 #endif
 
 /*
@@ -5677,6 +5722,17 @@ void build_sched_domains(const cpumask_t *cpu_map)
                 sd->parent = p;
                 sd->groups = &sched_group_phys[group];
 
+#ifdef CONFIG_SCHED_MC
+                p = sd;
+                sd = &per_cpu(core_domains, i);
+                group = cpu_to_core_group(i);
+                *sd = SD_MC_INIT;
+                sd->span = cpu_coregroup_map(i);
+                cpus_and(sd->span, sd->span, *cpu_map);
+                sd->parent = p;
+                sd->groups = &sched_group_core[group];
+#endif
+
 #ifdef CONFIG_SCHED_SMT
                 p = sd;
                 sd = &per_cpu(cpu_domains, i);
@@ -5702,6 +5758,19 @@ void build_sched_domains(const cpumask_t *cpu_map)
         }
 #endif
 
+#ifdef CONFIG_SCHED_MC
+        /* Set up multi-core groups */
+        for_each_cpu_mask(i, *cpu_map) {
+                cpumask_t this_core_map = cpu_coregroup_map(i);
+                cpus_and(this_core_map, this_core_map, *cpu_map);
+                if (i != first_cpu(this_core_map))
+                        continue;
+                init_sched_build_groups(sched_group_core, this_core_map,
+                                        &cpu_to_core_group);
+        }
+#endif
+
+
         /* Set up physical groups */
         for (i = 0; i < MAX_NUMNODES; i++) {
                 cpumask_t nodemask = node_to_cpumask(i);
@@ -5798,51 +5867,38 @@ void build_sched_domains(const cpumask_t *cpu_map)
                 power = SCHED_LOAD_SCALE;
                 sd->groups->cpu_power = power;
 #endif
+#ifdef CONFIG_SCHED_MC
+                sd = &per_cpu(core_domains, i);
+                power = SCHED_LOAD_SCALE + (cpus_weight(sd->groups->cpumask)-1)
+                                            * SCHED_LOAD_SCALE / 10;
+                sd->groups->cpu_power = power;
 
                 sd = &per_cpu(phys_domains, i);
+
+                /*
+                 * This has to be < 2 * SCHED_LOAD_SCALE
+                 * Lets keep it SCHED_LOAD_SCALE, so that
+                 * while calculating NUMA group's cpu_power
+                 * we can simply do
+                 *  numa_group->cpu_power += phys_group->cpu_power;
+                 *
+                 * See "only add power once for each physical pkg"
+                 * comment below
+                 */
+                sd->groups->cpu_power = SCHED_LOAD_SCALE;
+#else
+                sd = &per_cpu(phys_domains, i);
                 power = SCHED_LOAD_SCALE + SCHED_LOAD_SCALE *
                                 (cpus_weight(sd->groups->cpumask)-1) / 10;
                 sd->groups->cpu_power = power;
-
-#ifdef CONFIG_NUMA
-                sd = &per_cpu(allnodes_domains, i);
-                if (sd->groups) {
-                        power = SCHED_LOAD_SCALE + SCHED_LOAD_SCALE *
-                                (cpus_weight(sd->groups->cpumask)-1) / 10;
-                        sd->groups->cpu_power = power;
-                }
 #endif
         }
 
 #ifdef CONFIG_NUMA
-        for (i = 0; i < MAX_NUMNODES; i++) {
-                struct sched_group *sg = sched_group_nodes[i];
-                int j;
-
-                if (sg == NULL)
-                        continue;
-next_sg:
-                for_each_cpu_mask(j, sg->cpumask) {
-                        struct sched_domain *sd;
-                        int power;
-
-                        sd = &per_cpu(phys_domains, j);
-                        if (j != first_cpu(sd->groups->cpumask)) {
-                                /*
-                                 * Only add "power" once for each
-                                 * physical package.
-                                 */
-                                continue;
-                        }
-                        power = SCHED_LOAD_SCALE + SCHED_LOAD_SCALE *
-                                (cpus_weight(sd->groups->cpumask)-1) / 10;
+        for (i = 0; i < MAX_NUMNODES; i++)
+                init_numa_sched_groups_power(sched_group_nodes[i]);
 
-                        sg->cpu_power += power;
-                }
-                sg = sg->next;
-                if (sg != sched_group_nodes[i])
-                        goto next_sg;
-        }
+        init_numa_sched_groups_power(sched_group_allnodes);
 #endif
 
         /* Attach the domains */
@@ -5850,6 +5906,8 @@ next_sg:
                 struct sched_domain *sd;
 #ifdef CONFIG_SCHED_SMT
                 sd = &per_cpu(cpu_domains, i);
+#elif defined(CONFIG_SCHED_MC)
+                sd = &per_cpu(core_domains, i);
 #else
                 sd = &per_cpu(phys_domains, i);
 #endif
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index d9b3d5847ed8..ced91e1ff564 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -152,5 +152,5 @@ __init void spawn_softlockup_task(void)
         cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
         register_cpu_notifier(&cpu_nfb);
 
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 }
diff --git a/kernel/sys.c b/kernel/sys.c
index 38bc73ede2ba..c93d37f71aef 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -95,99 +95,304 @@ int cad_pid = 1;
  *      and the like. 
  */
 
-static struct notifier_block *reboot_notifier_list;
-static DEFINE_RWLOCK(notifier_lock);
+static BLOCKING_NOTIFIER_HEAD(reboot_notifier_list);
+
+/*
+ *      Notifier chain core routines.  The exported routines below
+ *      are layered on top of these, with appropriate locking added.
+ */
+
+static int notifier_chain_register(struct notifier_block **nl,
+                struct notifier_block *n)
+{
+        while ((*nl) != NULL) {
+                if (n->priority > (*nl)->priority)
+                        break;
+                nl = &((*nl)->next);
+        }
+        n->next = *nl;
+        rcu_assign_pointer(*nl, n);
+        return 0;
+}
+
+static int notifier_chain_unregister(struct notifier_block **nl,
+                struct notifier_block *n)
+{
+        while ((*nl) != NULL) {
+                if ((*nl) == n) {
+                        rcu_assign_pointer(*nl, n->next);
+                        return 0;
+                }
+                nl = &((*nl)->next);
+        }
+        return -ENOENT;
+}
+
+static int __kprobes notifier_call_chain(struct notifier_block **nl,
+                unsigned long val, void *v)
+{
+        int ret = NOTIFY_DONE;
+        struct notifier_block *nb;
+
+        nb = rcu_dereference(*nl);
+        while (nb) {
+                ret = nb->notifier_call(nb, val, v);
+                if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)
+                        break;
+                nb = rcu_dereference(nb->next);
+        }
+        return ret;
+}
+
+/*
+ *      Atomic notifier chain routines.  Registration and unregistration
+ *      use a mutex, and call_chain is synchronized by RCU (no locks).
+ */
 
 /**
- *      notifier_chain_register - Add notifier to a notifier chain
- *      @list: Pointer to root list pointer
+ *      atomic_notifier_chain_register - Add notifier to an atomic notifier chain
+ *      @nh: Pointer to head of the atomic notifier chain
  *      @n: New entry in notifier chain
  *
- *      Adds a notifier to a notifier chain.
+ *      Adds a notifier to an atomic notifier chain.
  *
  *      Currently always returns zero.
  */
+
+int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
+                struct notifier_block *n)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&nh->lock, flags);
+        ret = notifier_chain_register(&nh->head, n);
+        spin_unlock_irqrestore(&nh->lock, flags);
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(atomic_notifier_chain_register);
+
+/**
+ *      atomic_notifier_chain_unregister - Remove notifier from an atomic notifier chain
+ *      @nh: Pointer to head of the atomic notifier chain
+ *      @n: Entry to remove from notifier chain
+ *
+ *      Removes a notifier from an atomic notifier chain.
+ *
+ *      Returns zero on success or %-ENOENT on failure.
+ */
+int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
+                struct notifier_block *n)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&nh->lock, flags);
+        ret = notifier_chain_unregister(&nh->head, n);
+        spin_unlock_irqrestore(&nh->lock, flags);
+        synchronize_rcu();
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(atomic_notifier_chain_unregister);
+
+/**
+ *      atomic_notifier_call_chain - Call functions in an atomic notifier chain
+ *      @nh: Pointer to head of the atomic notifier chain
+ *      @val: Value passed unmodified to notifier function
+ *      @v: Pointer passed unmodified to notifier function
+ *
+ *      Calls each function in a notifier chain in turn.  The functions
+ *      run in an atomic context, so they must not block.
+ *      This routine uses RCU to synchronize with changes to the chain.
+ *
+ *      If the return value of the notifier can be and'ed
+ *      with %NOTIFY_STOP_MASK then atomic_notifier_call_chain
+ *      will return immediately, with the return value of
+ *      the notifier function which halted execution.
+ *      Otherwise the return value is the return value
+ *      of the last notifier function called.
+ */
  
-int notifier_chain_register(struct notifier_block **list, struct notifier_block *n)
+int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
+                unsigned long val, void *v)
 {
-        write_lock(&notifier_lock);
-        while(*list)
-        {
-                if(n->priority > (*list)->priority)
-                        break;
-                list= &((*list)->next);
-        }
-        n->next = *list;
-        *list=n;
-        write_unlock(&notifier_lock);
-        return 0;
+        int ret;
+
+        rcu_read_lock();
+        ret = notifier_call_chain(&nh->head, val, v);
+        rcu_read_unlock();
+        return ret;
 }
 
-EXPORT_SYMBOL(notifier_chain_register);
+EXPORT_SYMBOL_GPL(atomic_notifier_call_chain);
+
+/*
+ *      Blocking notifier chain routines.  All access to the chain is
+ *      synchronized by an rwsem.
+ */
 
 /**
- *      notifier_chain_unregister - Remove notifier from a notifier chain
- *      @nl: Pointer to root list pointer
+ *      blocking_notifier_chain_register - Add notifier to a blocking notifier chain
+ *      @nh: Pointer to head of the blocking notifier chain
  *      @n: New entry in notifier chain
  *
- *      Removes a notifier from a notifier chain.
+ *      Adds a notifier to a blocking notifier chain.
+ *      Must be called in process context.
  *
- *      Returns zero on success, or %-ENOENT on failure.
+ *      Currently always returns zero.
  */
  
-int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n)
+int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
+                struct notifier_block *n)
 {
-        write_lock(&notifier_lock);
-        while((*nl)!=NULL)
-        {
-                if((*nl)==n)
-                {
-                        *nl=n->next;
-                        write_unlock(&notifier_lock);
-                        return 0;
-                }
-                nl=&((*nl)->next);
-        }
-        write_unlock(&notifier_lock);
-        return -ENOENT;
+        int ret;
+
+        /*
+         * This code gets used during boot-up, when task switching is
+         * not yet working and interrupts must remain disabled.  At
+         * such times we must not call down_write().
+         */
+        if (unlikely(system_state == SYSTEM_BOOTING))
+                return notifier_chain_register(&nh->head, n);
+
+        down_write(&nh->rwsem);
+        ret = notifier_chain_register(&nh->head, n);
+        up_write(&nh->rwsem);
+        return ret;
 }
 
-EXPORT_SYMBOL(notifier_chain_unregister);
+EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);
 
 /**
- *      notifier_call_chain - Call functions in a notifier chain
- *      @n: Pointer to root pointer of notifier chain
+ *      blocking_notifier_chain_unregister - Remove notifier from a blocking notifier chain
+ *      @nh: Pointer to head of the blocking notifier chain
+ *      @n: Entry to remove from notifier chain
+ *
+ *      Removes a notifier from a blocking notifier chain.
+ *      Must be called from process context.
+ *
+ *      Returns zero on success or %-ENOENT on failure.
+ */
+int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
+                struct notifier_block *n)
+{
+        int ret;
+
+        /*
+         * This code gets used during boot-up, when task switching is
+         * not yet working and interrupts must remain disabled.  At
+         * such times we must not call down_write().
+         */
+        if (unlikely(system_state == SYSTEM_BOOTING))
+                return notifier_chain_unregister(&nh->head, n);
+
+        down_write(&nh->rwsem);
+        ret = notifier_chain_unregister(&nh->head, n);
+        up_write(&nh->rwsem);
+        return ret;
+}
+
+EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
+
+/**
+ *      blocking_notifier_call_chain - Call functions in a blocking notifier chain
+ *      @nh: Pointer to head of the blocking notifier chain
  *      @val: Value passed unmodified to notifier function
  *      @v: Pointer passed unmodified to notifier function
  *
- *      Calls each function in a notifier chain in turn.
+ *      Calls each function in a notifier chain in turn.  The functions
+ *      run in a process context, so they are allowed to block.
  *
- *      If the return value of the notifier can be and'd
- *      with %NOTIFY_STOP_MASK, then notifier_call_chain
+ *      If the return value of the notifier can be and'ed
+ *      with %NOTIFY_STOP_MASK then blocking_notifier_call_chain
  *      will return immediately, with the return value of
  *      the notifier function which halted execution.
- *      Otherwise, the return value is the return value
+ *      Otherwise the return value is the return value
  *      of the last notifier function called.
  */
  
-int __kprobes notifier_call_chain(struct notifier_block **n, unsigned long val, void *v)
+int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
+                unsigned long val, void *v)
 {
-        int ret=NOTIFY_DONE;
-        struct notifier_block *nb = *n;
+        int ret;
 
-        while(nb)
-        {
-                ret=nb->notifier_call(nb,val,v);
-                if(ret&NOTIFY_STOP_MASK)
-                {
-                        return ret;
-                }
-                nb=nb->next;
-        }
+        down_read(&nh->rwsem);
+        ret = notifier_call_chain(&nh->head, val, v);
+        up_read(&nh->rwsem);
         return ret;
 }
 
-EXPORT_SYMBOL(notifier_call_chain);
+EXPORT_SYMBOL_GPL(blocking_notifier_call_chain);
+
+/*
+ *      Raw notifier chain routines.  There is no protection;
+ *      the caller must provide it.  Use at your own risk!
+ */
+
+/**
+ *      raw_notifier_chain_register - Add notifier to a raw notifier chain
+ *      @nh: Pointer to head of the raw notifier chain
+ *      @n: New entry in notifier chain
+ *
+ *      Adds a notifier to a raw notifier chain.
+ *      All locking must be provided by the caller.
+ *
+ *      Currently always returns zero.
+ */
+
+int raw_notifier_chain_register(struct raw_notifier_head *nh,
+                struct notifier_block *n)
+{
+        return notifier_chain_register(&nh->head, n);
+}
+
+EXPORT_SYMBOL_GPL(raw_notifier_chain_register);
+
+/**
+ *      raw_notifier_chain_unregister - Remove notifier from a raw notifier chain
+ *      @nh: Pointer to head of the raw notifier chain
+ *      @n: Entry to remove from notifier chain
+ *
+ *      Removes a notifier from a raw notifier chain.
+ *      All locking must be provided by the caller.
+ *
+ *      Returns zero on success or %-ENOENT on failure.
+ */
+int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
+                struct notifier_block *n)
+{
+        return notifier_chain_unregister(&nh->head, n);
+}
+
+EXPORT_SYMBOL_GPL(raw_notifier_chain_unregister);
+
+/**
+ *      raw_notifier_call_chain - Call functions in a raw notifier chain
+ *      @nh: Pointer to head of the raw notifier chain
+ *      @val: Value passed unmodified to notifier function
+ *      @v: Pointer passed unmodified to notifier function
+ *
+ *      Calls each function in a notifier chain in turn.  The functions
+ *      run in an undefined context.
+ *      All locking must be provided by the caller.
+ *
+ *      If the return value of the notifier can be and'ed
+ *      with %NOTIFY_STOP_MASK then raw_notifier_call_chain
+ *      will return immediately, with the return value of
+ *      the notifier function which halted execution.
+ *      Otherwise the return value is the return value
+ *      of the last notifier function called.
+ */
+
+int raw_notifier_call_chain(struct raw_notifier_head *nh,
+                unsigned long val, void *v)
+{
+        return notifier_call_chain(&nh->head, val, v);
+}
+
+EXPORT_SYMBOL_GPL(raw_notifier_call_chain);
 
 /**
  *      register_reboot_notifier - Register function to be called at reboot time
@@ -196,13 +401,13 @@ EXPORT_SYMBOL(notifier_call_chain);
  *      Registers a function with the list of functions
  *      to be called at reboot time.
  *
- *      Currently always returns zero, as notifier_chain_register
+ *      Currently always returns zero, as blocking_notifier_chain_register
  *      always returns zero.
  */
  
 int register_reboot_notifier(struct notifier_block * nb)
 {
-        return notifier_chain_register(&reboot_notifier_list, nb);
+        return blocking_notifier_chain_register(&reboot_notifier_list, nb);
 }
 
 EXPORT_SYMBOL(register_reboot_notifier);
@@ -219,7 +424,7 @@ EXPORT_SYMBOL(register_reboot_notifier);
  
 int unregister_reboot_notifier(struct notifier_block * nb)
 {
-        return notifier_chain_unregister(&reboot_notifier_list, nb);
+        return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
 }
 
 EXPORT_SYMBOL(unregister_reboot_notifier);
@@ -380,7 +585,7 @@ EXPORT_SYMBOL_GPL(emergency_restart);
 
 void kernel_restart_prepare(char *cmd)
 {
-        notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
+        blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
         system_state = SYSTEM_RESTART;
         device_shutdown();
 }
@@ -430,7 +635,7 @@ EXPORT_SYMBOL_GPL(kernel_kexec);
 
 void kernel_shutdown_prepare(enum system_states state)
 {
-        notifier_call_chain(&reboot_notifier_list,
+        blocking_notifier_call_chain(&reboot_notifier_list,
                 (state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL);
         system_state = state;
         device_shutdown();
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 1067090db6b1..d82864c4a617 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -42,6 +42,10 @@ cond_syscall(sys_recvmsg);
 cond_syscall(sys_socketcall);
 cond_syscall(sys_futex);
 cond_syscall(compat_sys_futex);
+cond_syscall(sys_set_robust_list);
+cond_syscall(compat_sys_set_robust_list);
+cond_syscall(sys_get_robust_list);
+cond_syscall(compat_sys_get_robust_list);
 cond_syscall(sys_epoll_create);
 cond_syscall(sys_epoll_ctl);
 cond_syscall(sys_epoll_wait);
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 7e70ab13e191..6e8a60f67c7a 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -172,7 +172,7 @@ config DEBUG_IOREMAP
 
 config DEBUG_FS
         bool "Debug Filesystem"
-        depends on DEBUG_KERNEL && SYSFS
+        depends on SYSFS
         help
           debugfs is a virtual file system that kernel developers use to put
           debugging files into.  Enable this option to be able to read and
diff --git a/mm/Makefile b/mm/Makefile
index f10c753dce6d..0b8f73f2ed16 100644
--- a/mm/Makefile
+++ b/mm/Makefile
@@ -10,7 +10,7 @@ mmu-$(CONFIG_MMU)	:= fremap.o highmem.o madvise.o memory.o mincore.o \
 obj-y                   := bootmem.o filemap.o mempool.o oom_kill.o fadvise.o \
                            page_alloc.o page-writeback.o pdflush.o \
                            readahead.o swap.o truncate.o vmscan.o \
-                           prio_tree.o util.o $(mmu-y)
+                           prio_tree.o util.o mmzone.o $(mmu-y)
 
 obj-$(CONFIG_SWAP)      += page_io.o swap_state.o swapfile.o thrash.o
 obj-$(CONFIG_HUGETLBFS) += hugetlb.o
diff --git a/mm/bootmem.c b/mm/bootmem.c
index b55bd39fc5dd..d3e3bd2ffcea 100644
--- a/mm/bootmem.c
+++ b/mm/bootmem.c
@@ -33,6 +33,7 @@ EXPORT_SYMBOL(max_pfn);		/* This is exported so
                                  * dma_get_required_mask(), which uses
                                  * it, can be an inline function */
 
+static LIST_HEAD(bdata_list);
 #ifdef CONFIG_CRASH_DUMP
 /*
  * If we have booted due to a crash, max_pfn will be a very low value. We need
@@ -52,6 +53,27 @@ unsigned long __init bootmem_bootmap_pages (unsigned long pages)
 
         return mapsize;
 }
+/*
+ * link bdata in order
+ */
+static void link_bootmem(bootmem_data_t *bdata)
+{
+        bootmem_data_t *ent;
+        if (list_empty(&bdata_list)) {
+                list_add(&bdata->list, &bdata_list);
+                return;
+        }
+        /* insert in order */
+        list_for_each_entry(ent, &bdata_list, list) {
+                if (bdata->node_boot_start < ent->node_boot_start) {
+                        list_add_tail(&bdata->list, &ent->list);
+                        return;
+                }
+        }
+        list_add_tail(&bdata->list, &bdata_list);
+        return;
+}
+
 
 /*
  * Called once to set up the allocator itself.
@@ -62,13 +84,11 @@ static unsigned long __init init_bootmem_core (pg_data_t *pgdat,
         bootmem_data_t *bdata = pgdat->bdata;
         unsigned long mapsize = ((end - start)+7)/8;
 
-        pgdat->pgdat_next = pgdat_list;
-        pgdat_list = pgdat;
-
         mapsize = ALIGN(mapsize, sizeof(long));
         bdata->node_bootmem_map = phys_to_virt(mapstart << PAGE_SHIFT);
         bdata->node_boot_start = (start << PAGE_SHIFT);
         bdata->node_low_pfn = end;
+        link_bootmem(bdata);
 
         /*
          * Initially all pages are reserved - setup_arch() has to
@@ -383,12 +403,11 @@ unsigned long __init free_all_bootmem (void)
 
 void * __init __alloc_bootmem(unsigned long size, unsigned long align, unsigned long goal)
 {
-        pg_data_t *pgdat = pgdat_list;
+        bootmem_data_t *bdata;
         void *ptr;
 
-        for_each_pgdat(pgdat)
-                if ((ptr = __alloc_bootmem_core(pgdat->bdata, size,
-                                                 align, goal, 0)))
+        list_for_each_entry(bdata, &bdata_list, list)
+                if ((ptr = __alloc_bootmem_core(bdata, size, align, goal, 0)))
                         return(ptr);
 
         /*
@@ -416,11 +435,11 @@ void * __init __alloc_bootmem_node(pg_data_t *pgdat, unsigned long size, unsigne
 
 void * __init __alloc_bootmem_low(unsigned long size, unsigned long align, unsigned long goal)
 {
-        pg_data_t *pgdat = pgdat_list;
+        bootmem_data_t *bdata;
         void *ptr;
 
-        for_each_pgdat(pgdat)
-                if ((ptr = __alloc_bootmem_core(pgdat->bdata, size,
+        list_for_each_entry(bdata, &bdata_list, list)
+                if ((ptr = __alloc_bootmem_core(bdata, size,
                                                  align, goal, LOW32LIMIT)))
                         return(ptr);
 
diff --git a/mm/mmzone.c b/mm/mmzone.c
new file mode 100644
index 000000000000..b022370e612e
--- /dev/null
+++ b/mm/mmzone.c
@@ -0,0 +1,50 @@
+/*
+ * linux/mm/mmzone.c
+ *
+ * management codes for pgdats and zones.
+ */
+
+
+#include <linux/config.h>
+#include <linux/stddef.h>
+#include <linux/mmzone.h>
+#include <linux/module.h>
+
+struct pglist_data *first_online_pgdat(void)
+{
+        return NODE_DATA(first_online_node);
+}
+
+EXPORT_SYMBOL(first_online_pgdat);
+
+struct pglist_data *next_online_pgdat(struct pglist_data *pgdat)
+{
+        int nid = next_online_node(pgdat->node_id);
+
+        if (nid == MAX_NUMNODES)
+                return NULL;
+        return NODE_DATA(nid);
+}
+EXPORT_SYMBOL(next_online_pgdat);
+
+
+/*
+ * next_zone - helper magic for for_each_zone()
+ */
+struct zone *next_zone(struct zone *zone)
+{
+        pg_data_t *pgdat = zone->zone_pgdat;
+
+        if (zone < pgdat->node_zones + MAX_NR_ZONES - 1)
+                zone++;
+        else {
+                pgdat = next_online_pgdat(pgdat);
+                if (pgdat)
+                        zone = pgdat->node_zones;
+                else
+                        zone = NULL;
+        }
+        return zone;
+}
+EXPORT_SYMBOL(next_zone);
+
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 338a02bb004d..dc523a1f270d 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -49,7 +49,6 @@ nodemask_t node_online_map __read_mostly = { { [0] = 1UL } };
 EXPORT_SYMBOL(node_online_map);
 nodemask_t node_possible_map __read_mostly = NODE_MASK_ALL;
 EXPORT_SYMBOL(node_possible_map);
-struct pglist_data *pgdat_list __read_mostly;
 unsigned long totalram_pages __read_mostly;
 unsigned long totalhigh_pages __read_mostly;
 long nr_swap_pages;
@@ -1201,7 +1200,7 @@ unsigned int nr_free_highpages (void)
         pg_data_t *pgdat;
         unsigned int pages = 0;
 
-        for_each_pgdat(pgdat)
+        for_each_online_pgdat(pgdat)
                 pages += pgdat->node_zones[ZONE_HIGHMEM].free_pages;
 
         return pages;
@@ -1343,7 +1342,7 @@ void get_zone_counts(unsigned long *active,
         *active = 0;
         *inactive = 0;
         *free = 0;
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 unsigned long l, m, n;
                 __get_zone_counts(&l, &m, &n, pgdat);
                 *active += l;
@@ -2042,7 +2041,6 @@ static __meminit void init_currently_empty_zone(struct zone *zone,
         zone_wait_table_init(zone, size);
         pgdat->nr_zones = zone_idx(zone) + 1;
 
-        zone->zone_mem_map = pfn_to_page(zone_start_pfn);
         zone->zone_start_pfn = zone_start_pfn;
 
         memmap_init(size, pgdat->node_id, zone_idx(zone), zone_start_pfn);
@@ -2170,8 +2168,9 @@ static void *frag_start(struct seq_file *m, loff_t *pos)
 {
         pg_data_t *pgdat;
         loff_t node = *pos;
-
-        for (pgdat = pgdat_list; pgdat && node; pgdat = pgdat->pgdat_next)
+        for (pgdat = first_online_pgdat();
+             pgdat && node;
+             pgdat = next_online_pgdat(pgdat))
                 --node;
 
         return pgdat;
@@ -2182,7 +2181,7 @@ static void *frag_next(struct seq_file *m, void *arg, loff_t *pos)
         pg_data_t *pgdat = (pg_data_t *)arg;
 
         (*pos)++;
-        return pgdat->pgdat_next;
+        return next_online_pgdat(pgdat);
 }
 
 static void frag_stop(struct seq_file *m, void *arg)
@@ -2483,7 +2482,7 @@ static void setup_per_zone_lowmem_reserve(void)
         struct pglist_data *pgdat;
         int j, idx;
 
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 for (j = 0; j < MAX_NR_ZONES; j++) {
                         struct zone *zone = pgdat->node_zones + j;
                         unsigned long present_pages = zone->present_pages;
@@ -2745,3 +2744,44 @@ void *__init alloc_large_system_hash(const char *tablename,
 
         return table;
 }
+
+#ifdef CONFIG_OUT_OF_LINE_PFN_TO_PAGE
+/*
+ * pfn <-> page translation. out-of-line version.
+ * (see asm-generic/memory_model.h)
+ */
+#if defined(CONFIG_FLATMEM)
+struct page *pfn_to_page(unsigned long pfn)
+{
+        return mem_map + (pfn - ARCH_PFN_OFFSET);
+}
+unsigned long page_to_pfn(struct page *page)
+{
+        return (page - mem_map) + ARCH_PFN_OFFSET;
+}
+#elif defined(CONFIG_DISCONTIGMEM)
+struct page *pfn_to_page(unsigned long pfn)
+{
+        int nid = arch_pfn_to_nid(pfn);
+        return NODE_DATA(nid)->node_mem_map + arch_local_page_offset(pfn,nid);
+}
+unsigned long page_to_pfn(struct page *page)
+{
+        struct pglist_data *pgdat = NODE_DATA(page_to_nid(page));
+        return (page - pgdat->node_mem_map) + pgdat->node_start_pfn;
+}
+#elif defined(CONFIG_SPARSEMEM)
+struct page *pfn_to_page(unsigned long pfn)
+{
+        return __section_mem_map_addr(__pfn_to_section(pfn)) + pfn;
+}
+
+unsigned long page_to_pfn(struct page *page)
+{
+        long section_id = page_to_section(page);
+        return page - __section_mem_map_addr(__nr_to_section(section_id));
+}
+#endif /* CONFIG_FLATMEM/DISCONTIGMME/SPARSEMEM */
+EXPORT_SYMBOL(pfn_to_page);
+EXPORT_SYMBOL(page_to_pfn);
+#endif /* CONFIG_OUT_OF_LINE_PFN_TO_PAGE */
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 78865c849f8f..acdf001d6941 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1305,7 +1305,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
 
         current->reclaim_state = &reclaim_state;
 repeat:
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 unsigned long freed;
 
                 freed = balance_pgdat(pgdat, nr_to_free, 0);
@@ -1335,7 +1335,7 @@ static int __devinit cpu_callback(struct notifier_block *nfb,
         cpumask_t mask;
 
         if (action == CPU_ONLINE) {
-                for_each_pgdat(pgdat) {
+                for_each_online_pgdat(pgdat) {
                         mask = node_to_cpumask(pgdat->node_id);
                         if (any_online_cpu(mask) != NR_CPUS)
                                 /* One of our CPUs online: restore mask */
@@ -1351,7 +1351,7 @@ static int __init kswapd_init(void)
         pg_data_t *pgdat;
 
         swap_setup();
-        for_each_pgdat(pgdat) {
+        for_each_online_pgdat(pgdat) {
                 pid_t pid;
 
                 pid = kernel_thread(kswapd, pgdat, CLONE_KERNEL);
diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index 9106354c781e..a49a6975092d 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -73,23 +73,23 @@ DEFINE_RWLOCK(hci_cb_list_lock);
 struct hci_proto *hci_proto[HCI_MAX_PROTO];
 
 /* HCI notifiers list */
-static struct notifier_block *hci_notifier;
+static ATOMIC_NOTIFIER_HEAD(hci_notifier);
 
 /* ---- HCI notifications ---- */
 
 int hci_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&hci_notifier, nb);
+        return atomic_notifier_chain_register(&hci_notifier, nb);
 }
 
 int hci_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&hci_notifier, nb);
+        return atomic_notifier_chain_unregister(&hci_notifier, nb);
 }
 
 static void hci_notify(struct hci_dev *hdev, int event)
 {
-        notifier_call_chain(&hci_notifier, event, hdev);
+        atomic_notifier_call_chain(&hci_notifier, event, hdev);
 }
 
 /* ---- HCI requests ---- */
diff --git a/net/core/dev.c b/net/core/dev.c
index 8e1dc3051222..a3ab11f34153 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -193,7 +193,7 @@ static inline struct hlist_head *dev_index_hash(int ifindex)
  *      Our notifier list
  */
 
-static struct notifier_block *netdev_chain;
+static BLOCKING_NOTIFIER_HEAD(netdev_chain);
 
 /*
  *      Device drivers call our routines to queue packets here. We empty the
@@ -736,7 +736,8 @@ int dev_change_name(struct net_device *dev, char *newname)
         if (!err) {
                 hlist_del(&dev->name_hlist);
                 hlist_add_head(&dev->name_hlist, dev_name_hash(dev->name));
-                notifier_call_chain(&netdev_chain, NETDEV_CHANGENAME, dev);
+                blocking_notifier_call_chain(&netdev_chain,
+                                NETDEV_CHANGENAME, dev);
         }
 
         return err;
@@ -750,7 +751,7 @@ int dev_change_name(struct net_device *dev, char *newname)
  */
 void netdev_features_change(struct net_device *dev)
 {
-        notifier_call_chain(&netdev_chain, NETDEV_FEAT_CHANGE, dev);
+        blocking_notifier_call_chain(&netdev_chain, NETDEV_FEAT_CHANGE, dev);
 }
 EXPORT_SYMBOL(netdev_features_change);
 
@@ -765,7 +766,8 @@ EXPORT_SYMBOL(netdev_features_change);
 void netdev_state_change(struct net_device *dev)
 {
         if (dev->flags & IFF_UP) {
-                notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev);
+                blocking_notifier_call_chain(&netdev_chain,
+                                NETDEV_CHANGE, dev);
                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
         }
 }
@@ -862,7 +864,7 @@ int dev_open(struct net_device *dev)
                 /*
                  *      ... and announce new interface.
                  */
-                notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
+                blocking_notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
         }
         return ret;
 }
@@ -885,7 +887,7 @@ int dev_close(struct net_device *dev)
          *      Tell people we are going down, so that they can
          *      prepare to death, when device is still operating.
          */
-        notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev);
+        blocking_notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev);
 
         dev_deactivate(dev);
 
@@ -922,7 +924,7 @@ int dev_close(struct net_device *dev)
         /*
          * Tell people we are down
          */
-        notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
+        blocking_notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
 
         return 0;
 }
@@ -953,7 +955,7 @@ int register_netdevice_notifier(struct notifier_block *nb)
         int err;
 
         rtnl_lock();
-        err = notifier_chain_register(&netdev_chain, nb);
+        err = blocking_notifier_chain_register(&netdev_chain, nb);
         if (!err) {
                 for (dev = dev_base; dev; dev = dev->next) {
                         nb->notifier_call(nb, NETDEV_REGISTER, dev);
@@ -981,7 +983,7 @@ int unregister_netdevice_notifier(struct notifier_block *nb)
         int err;
 
         rtnl_lock();
-        err = notifier_chain_unregister(&netdev_chain, nb);
+        err = blocking_notifier_chain_unregister(&netdev_chain, nb);
         rtnl_unlock();
         return err;
 }
@@ -992,12 +994,12 @@ int unregister_netdevice_notifier(struct notifier_block *nb)
  *      @v:   pointer passed unmodified to notifier function
  *
  *      Call all network notifier blocks.  Parameters and return value
- *      are as for notifier_call_chain().
+ *      are as for blocking_notifier_call_chain().
  */
 
 int call_netdevice_notifiers(unsigned long val, void *v)
 {
-        return notifier_call_chain(&netdev_chain, val, v);
+        return blocking_notifier_call_chain(&netdev_chain, val, v);
 }
 
 /* When > 0 there are consumers of rx skb time stamps */
@@ -2242,7 +2244,8 @@ int dev_change_flags(struct net_device *dev, unsigned flags)
         if (dev->flags & IFF_UP &&
             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
                                           IFF_VOLATILE)))
-                notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev);
+                blocking_notifier_call_chain(&netdev_chain,
+                                NETDEV_CHANGE, dev);
 
         if ((flags ^ dev->gflags) & IFF_PROMISC) {
                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
@@ -2286,8 +2289,8 @@ int dev_set_mtu(struct net_device *dev, int new_mtu)
         else
                 dev->mtu = new_mtu;
         if (!err && dev->flags & IFF_UP)
-                notifier_call_chain(&netdev_chain,
-                                    NETDEV_CHANGEMTU, dev);
+                blocking_notifier_call_chain(&netdev_chain,
+                                NETDEV_CHANGEMTU, dev);
         return err;
 }
 
@@ -2303,7 +2306,8 @@ int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
                 return -ENODEV;
         err = dev->set_mac_address(dev, sa);
         if (!err)
-                notifier_call_chain(&netdev_chain, NETDEV_CHANGEADDR, dev);
+                blocking_notifier_call_chain(&netdev_chain,
+                                NETDEV_CHANGEADDR, dev);
         return err;
 }
 
@@ -2359,7 +2363,7 @@ static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
                                 return -EINVAL;
                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
-                        notifier_call_chain(&netdev_chain,
+                        blocking_notifier_call_chain(&netdev_chain,
                                             NETDEV_CHANGEADDR, dev);
                         return 0;
 
@@ -2813,7 +2817,7 @@ int register_netdevice(struct net_device *dev)
         write_unlock_bh(&dev_base_lock);
 
         /* Notify protocols, that a new device appeared. */
-        notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
+        blocking_notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
 
         /* Finish registration after unlock */
         net_set_todo(dev);
@@ -2892,7 +2896,7 @@ static void netdev_wait_allrefs(struct net_device *dev)
                         rtnl_lock();
 
                         /* Rebroadcast unregister notification */
-                        notifier_call_chain(&netdev_chain,
+                        blocking_notifier_call_chain(&netdev_chain,
                                             NETDEV_UNREGISTER, dev);
 
                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
@@ -3148,7 +3152,7 @@ int unregister_netdevice(struct net_device *dev)
         /* Notify protocols, that we are about to destroy
            this device. They should clean all the things.
         */
-        notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
+        blocking_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
         
         /*
          *      Flush the multicast chain
diff --git a/net/decnet/dn_dev.c b/net/decnet/dn_dev.c
index cc7b9d9255ef..d2ae9893ca17 100644
--- a/net/decnet/dn_dev.c
+++ b/net/decnet/dn_dev.c
@@ -68,7 +68,7 @@ __le16 decnet_address = 0;
 
 static DEFINE_RWLOCK(dndev_lock);
 static struct net_device *decnet_default_device;
-static struct notifier_block *dnaddr_chain;
+static BLOCKING_NOTIFIER_HEAD(dnaddr_chain);
 
 static struct dn_dev *dn_dev_create(struct net_device *dev, int *err);
 static void dn_dev_delete(struct net_device *dev);
@@ -446,7 +446,7 @@ static void dn_dev_del_ifa(struct dn_dev *dn_db, struct dn_ifaddr **ifap, int de
         }
 
         rtmsg_ifa(RTM_DELADDR, ifa1);
-        notifier_call_chain(&dnaddr_chain, NETDEV_DOWN, ifa1);
+        blocking_notifier_call_chain(&dnaddr_chain, NETDEV_DOWN, ifa1);
         if (destroy) {
                 dn_dev_free_ifa(ifa1);
 
@@ -481,7 +481,7 @@ static int dn_dev_insert_ifa(struct dn_dev *dn_db, struct dn_ifaddr *ifa)
         dn_db->ifa_list = ifa;
 
         rtmsg_ifa(RTM_NEWADDR, ifa);
-        notifier_call_chain(&dnaddr_chain, NETDEV_UP, ifa);
+        blocking_notifier_call_chain(&dnaddr_chain, NETDEV_UP, ifa);
 
         return 0;
 }
@@ -1285,12 +1285,12 @@ void dn_dev_devices_on(void)
 
 int register_dnaddr_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&dnaddr_chain, nb);
+        return blocking_notifier_chain_register(&dnaddr_chain, nb);
 }
 
 int unregister_dnaddr_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&dnaddr_chain, nb);
+        return blocking_notifier_chain_unregister(&dnaddr_chain, nb);
 }
 
 #ifdef CONFIG_PROC_FS
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 44fdf1413e2c..81c2f7885292 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -81,7 +81,7 @@ static struct ipv4_devconf ipv4_devconf_dflt = {
 
 static void rtmsg_ifa(int event, struct in_ifaddr *);
 
-static struct notifier_block *inetaddr_chain;
+static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
 static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
                          int destroy);
 #ifdef CONFIG_SYSCTL
@@ -267,7 +267,8 @@ static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
                                 *ifap1 = ifa->ifa_next;
 
                                 rtmsg_ifa(RTM_DELADDR, ifa);
-                                notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa);
+                                blocking_notifier_call_chain(&inetaddr_chain,
+                                                NETDEV_DOWN, ifa);
                                 inet_free_ifa(ifa);
                         } else {
                                 promote = ifa;
@@ -291,7 +292,7 @@ static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
            So that, this order is correct.
          */
         rtmsg_ifa(RTM_DELADDR, ifa1);
-        notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
+        blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
 
         if (promote) {
 
@@ -303,7 +304,8 @@ static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
 
                 promote->ifa_flags &= ~IFA_F_SECONDARY;
                 rtmsg_ifa(RTM_NEWADDR, promote);
-                notifier_call_chain(&inetaddr_chain, NETDEV_UP, promote);
+                blocking_notifier_call_chain(&inetaddr_chain,
+                                NETDEV_UP, promote);
                 for (ifa = promote->ifa_next; ifa; ifa = ifa->ifa_next) {
                         if (ifa1->ifa_mask != ifa->ifa_mask ||
                             !inet_ifa_match(ifa1->ifa_address, ifa))
@@ -366,7 +368,7 @@ static int inet_insert_ifa(struct in_ifaddr *ifa)
            Notifier will trigger FIB update, so that
            listeners of netlink will know about new ifaddr */
         rtmsg_ifa(RTM_NEWADDR, ifa);
-        notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
+        blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
 
         return 0;
 }
@@ -938,12 +940,12 @@ u32 inet_confirm_addr(const struct net_device *dev, u32 dst, u32 local, int scop
 
 int register_inetaddr_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&inetaddr_chain, nb);
+        return blocking_notifier_chain_register(&inetaddr_chain, nb);
 }
 
 int unregister_inetaddr_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&inetaddr_chain, nb);
+        return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
 }
 
 /* Rename ifa_labels for a device name change. Make some effort to preserve existing
diff --git a/net/ipv4/netfilter/ip_conntrack_core.c b/net/ipv4/netfilter/ip_conntrack_core.c
index 9e34034729a6..ceaabc18202b 100644
--- a/net/ipv4/netfilter/ip_conntrack_core.c
+++ b/net/ipv4/netfilter/ip_conntrack_core.c
@@ -80,8 +80,8 @@ static int ip_conntrack_vmalloc;
 static unsigned int ip_conntrack_next_id;
 static unsigned int ip_conntrack_expect_next_id;
 #ifdef CONFIG_IP_NF_CONNTRACK_EVENTS
-struct notifier_block *ip_conntrack_chain;
-struct notifier_block *ip_conntrack_expect_chain;
+ATOMIC_NOTIFIER_HEAD(ip_conntrack_chain);
+ATOMIC_NOTIFIER_HEAD(ip_conntrack_expect_chain);
 
 DEFINE_PER_CPU(struct ip_conntrack_ecache, ip_conntrack_ecache);
 
@@ -92,7 +92,7 @@ __ip_ct_deliver_cached_events(struct ip_conntrack_ecache *ecache)
 {
         DEBUGP("ecache: delivering events for %p\n", ecache->ct);
         if (is_confirmed(ecache->ct) && !is_dying(ecache->ct) && ecache->events)
-                notifier_call_chain(&ip_conntrack_chain, ecache->events,
+                atomic_notifier_call_chain(&ip_conntrack_chain, ecache->events,
                                     ecache->ct);
         ecache->events = 0;
         ip_conntrack_put(ecache->ct);
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 01c62a0d3742..445006ee4522 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -143,7 +143,7 @@ static void inet6_prefix_notify(int event, struct inet6_dev *idev,
                                 struct prefix_info *pinfo);
 static int ipv6_chk_same_addr(const struct in6_addr *addr, struct net_device *dev);
 
-static struct notifier_block *inet6addr_chain;
+static ATOMIC_NOTIFIER_HEAD(inet6addr_chain);
 
 struct ipv6_devconf ipv6_devconf = {
         .forwarding             = 0,
@@ -593,7 +593,7 @@ out2:
         read_unlock_bh(&addrconf_lock);
 
         if (likely(err == 0))
-                notifier_call_chain(&inet6addr_chain, NETDEV_UP, ifa);
+                atomic_notifier_call_chain(&inet6addr_chain, NETDEV_UP, ifa);
         else {
                 kfree(ifa);
                 ifa = ERR_PTR(err);
@@ -688,7 +688,7 @@ static void ipv6_del_addr(struct inet6_ifaddr *ifp)
 
         ipv6_ifa_notify(RTM_DELADDR, ifp);
 
-        notifier_call_chain(&inet6addr_chain,NETDEV_DOWN,ifp);
+        atomic_notifier_call_chain(&inet6addr_chain, NETDEV_DOWN, ifp);
 
         addrconf_del_timer(ifp);
 
@@ -3767,12 +3767,12 @@ static void addrconf_sysctl_unregister(struct ipv6_devconf *p)
 
 int register_inet6addr_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&inet6addr_chain, nb);
+        return atomic_notifier_chain_register(&inet6addr_chain, nb);
 }
 
 int unregister_inet6addr_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&inet6addr_chain,nb);
+        return atomic_notifier_chain_unregister(&inet6addr_chain,nb);
 }
 
 /*
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 0ae281d9bfc3..56389c83557c 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -90,8 +90,8 @@ static int nf_conntrack_vmalloc;
 static unsigned int nf_conntrack_next_id;
 static unsigned int nf_conntrack_expect_next_id;
 #ifdef CONFIG_NF_CONNTRACK_EVENTS
-struct notifier_block *nf_conntrack_chain;
-struct notifier_block *nf_conntrack_expect_chain;
+ATOMIC_NOTIFIER_HEAD(nf_conntrack_chain);
+ATOMIC_NOTIFIER_HEAD(nf_conntrack_expect_chain);
 
 DEFINE_PER_CPU(struct nf_conntrack_ecache, nf_conntrack_ecache);
 
@@ -103,7 +103,7 @@ __nf_ct_deliver_cached_events(struct nf_conntrack_ecache *ecache)
         DEBUGP("ecache: delivering events for %p\n", ecache->ct);
         if (nf_ct_is_confirmed(ecache->ct) && !nf_ct_is_dying(ecache->ct)
             && ecache->events)
-                notifier_call_chain(&nf_conntrack_chain, ecache->events,
+                atomic_notifier_call_chain(&nf_conntrack_chain, ecache->events,
                                     ecache->ct);
 
         ecache->events = 0;
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index d00a9034cb5f..2a233ffcf618 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -123,7 +123,7 @@ static void netlink_destroy_callback(struct netlink_callback *cb);
 static DEFINE_RWLOCK(nl_table_lock);
 static atomic_t nl_table_users = ATOMIC_INIT(0);
 
-static struct notifier_block *netlink_chain;
+static ATOMIC_NOTIFIER_HEAD(netlink_chain);
 
 static u32 netlink_group_mask(u32 group)
 {
@@ -469,7 +469,8 @@ static int netlink_release(struct socket *sock)
                                                 .protocol = sk->sk_protocol,
                                                 .pid = nlk->pid,
                                           };
-                notifier_call_chain(&netlink_chain, NETLINK_URELEASE, &n);
+                atomic_notifier_call_chain(&netlink_chain,
+                                NETLINK_URELEASE, &n);
         }       
 
         if (nlk->module)
@@ -1695,12 +1696,12 @@ static struct file_operations netlink_seq_fops = {
 
 int netlink_register_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&netlink_chain, nb);
+        return atomic_notifier_chain_register(&netlink_chain, nb);
 }
 
 int netlink_unregister_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&netlink_chain, nb);
+        return atomic_notifier_chain_unregister(&netlink_chain, nb);
 }
                 
 static const struct proto_ops netlink_ops = {
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 23632d84d8d7..4d7eb9e704da 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -78,7 +78,8 @@ struct rsi {
 
 static struct cache_head *rsi_table[RSI_HASHMAX];
 static struct cache_detail rsi_cache;
-static struct rsi *rsi_lookup(struct rsi *item, int set);
+static struct rsi *rsi_update(struct rsi *new, struct rsi *old);
+static struct rsi *rsi_lookup(struct rsi *item);
 
 static void rsi_free(struct rsi *rsii)
 {
@@ -88,13 +89,11 @@ static void rsi_free(struct rsi *rsii)
         kfree(rsii->out_token.data);
 }
 
-static void rsi_put(struct cache_head *item, struct cache_detail *cd)
+static void rsi_put(struct kref *ref)
 {
-        struct rsi *rsii = container_of(item, struct rsi, h);
-        if (cache_put(item, cd)) {
-                rsi_free(rsii);
-                kfree(rsii);
-        }
+        struct rsi *rsii = container_of(ref, struct rsi, h.ref);
+        rsi_free(rsii);
+        kfree(rsii);
 }
 
 static inline int rsi_hash(struct rsi *item)
@@ -103,8 +102,10 @@ static inline int rsi_hash(struct rsi *item)
              ^ hash_mem(item->in_token.data, item->in_token.len, RSI_HASHBITS);
 }
 
-static inline int rsi_match(struct rsi *item, struct rsi *tmp)
+static int rsi_match(struct cache_head *a, struct cache_head *b)
 {
+        struct rsi *item = container_of(a, struct rsi, h);
+        struct rsi *tmp = container_of(b, struct rsi, h);
         return netobj_equal(&item->in_handle, &tmp->in_handle)
                 && netobj_equal(&item->in_token, &tmp->in_token);
 }
@@ -125,8 +126,11 @@ static inline int dup_netobj(struct xdr_netobj *dst, struct xdr_netobj *src)
         return dup_to_netobj(dst, src->data, src->len);
 }
 
-static inline void rsi_init(struct rsi *new, struct rsi *item)
+static void rsi_init(struct cache_head *cnew, struct cache_head *citem)
 {
+        struct rsi *new = container_of(cnew, struct rsi, h);
+        struct rsi *item = container_of(citem, struct rsi, h);
+
         new->out_handle.data = NULL;
         new->out_handle.len = 0;
         new->out_token.data = NULL;
@@ -141,8 +145,11 @@ static inline void rsi_init(struct rsi *new, struct rsi *item)
         item->in_token.data = NULL;
 }
 
-static inline void rsi_update(struct rsi *new, struct rsi *item)
+static void update_rsi(struct cache_head *cnew, struct cache_head *citem)
 {
+        struct rsi *new = container_of(cnew, struct rsi, h);
+        struct rsi *item = container_of(citem, struct rsi, h);
+
         BUG_ON(new->out_handle.data || new->out_token.data);
         new->out_handle.len = item->out_handle.len;
         item->out_handle.len = 0;
@@ -157,6 +164,15 @@ static inline void rsi_update(struct rsi *new, struct rsi *item)
         new->minor_status = item->minor_status;
 }
 
+static struct cache_head *rsi_alloc(void)
+{
+        struct rsi *rsii = kmalloc(sizeof(*rsii), GFP_KERNEL);
+        if (rsii)
+                return &rsii->h;
+        else
+                return NULL;
+}
+
 static void rsi_request(struct cache_detail *cd,
                        struct cache_head *h,
                        char **bpp, int *blen)
@@ -198,6 +214,10 @@ static int rsi_parse(struct cache_detail *cd,
         if (dup_to_netobj(&rsii.in_token, buf, len))
                 goto out;
 
+        rsip = rsi_lookup(&rsii);
+        if (!rsip)
+                goto out;
+
         rsii.h.flags = 0;
         /* expiry */
         expiry = get_expiry(&mesg);
@@ -240,12 +260,14 @@ static int rsi_parse(struct cache_detail *cd,
                         goto out;
         }
         rsii.h.expiry_time = expiry;
-        rsip = rsi_lookup(&rsii, 1);
+        rsip = rsi_update(&rsii, rsip);
         status = 0;
 out:
         rsi_free(&rsii);
         if (rsip)
-                rsi_put(&rsip->h, &rsi_cache);
+                cache_put(&rsip->h, &rsi_cache);
+        else
+                status = -ENOMEM;
         return status;
 }
 
@@ -257,9 +279,37 @@ static struct cache_detail rsi_cache = {
         .cache_put      = rsi_put,
         .cache_request  = rsi_request,
         .cache_parse    = rsi_parse,
+        .match          = rsi_match,
+        .init           = rsi_init,
+        .update         = update_rsi,
+        .alloc          = rsi_alloc,
 };
 
-static DefineSimpleCacheLookup(rsi, 0)
+static struct rsi *rsi_lookup(struct rsi *item)
+{
+        struct cache_head *ch;
+        int hash = rsi_hash(item);
+
+        ch = sunrpc_cache_lookup(&rsi_cache, &item->h, hash);
+        if (ch)
+                return container_of(ch, struct rsi, h);
+        else
+                return NULL;
+}
+
+static struct rsi *rsi_update(struct rsi *new, struct rsi *old)
+{
+        struct cache_head *ch;
+        int hash = rsi_hash(new);
+
+        ch = sunrpc_cache_update(&rsi_cache, &new->h,
+                                 &old->h, hash);
+        if (ch)
+                return container_of(ch, struct rsi, h);
+        else
+                return NULL;
+}
+
 
 /*
  * The rpcsec_context cache is used to store a context that is
@@ -293,7 +343,8 @@ struct rsc {
 
 static struct cache_head *rsc_table[RSC_HASHMAX];
 static struct cache_detail rsc_cache;
-static struct rsc *rsc_lookup(struct rsc *item, int set);
+static struct rsc *rsc_update(struct rsc *new, struct rsc *old);
+static struct rsc *rsc_lookup(struct rsc *item);
 
 static void rsc_free(struct rsc *rsci)
 {
@@ -304,14 +355,12 @@ static void rsc_free(struct rsc *rsci)
                 put_group_info(rsci->cred.cr_group_info);
 }
 
-static void rsc_put(struct cache_head *item, struct cache_detail *cd)
+static void rsc_put(struct kref *ref)
 {
-        struct rsc *rsci = container_of(item, struct rsc, h);
+        struct rsc *rsci = container_of(ref, struct rsc, h.ref);
 
-        if (cache_put(item, cd)) {
-                rsc_free(rsci);
-                kfree(rsci);
-        }
+        rsc_free(rsci);
+        kfree(rsci);
 }
 
 static inline int
@@ -320,15 +369,21 @@ rsc_hash(struct rsc *rsci)
         return hash_mem(rsci->handle.data, rsci->handle.len, RSC_HASHBITS);
 }
 
-static inline int
-rsc_match(struct rsc *new, struct rsc *tmp)
+static int
+rsc_match(struct cache_head *a, struct cache_head *b)
 {
+        struct rsc *new = container_of(a, struct rsc, h);
+        struct rsc *tmp = container_of(b, struct rsc, h);
+
         return netobj_equal(&new->handle, &tmp->handle);
 }
 
-static inline void
-rsc_init(struct rsc *new, struct rsc *tmp)
+static void
+rsc_init(struct cache_head *cnew, struct cache_head *ctmp)
 {
+        struct rsc *new = container_of(cnew, struct rsc, h);
+        struct rsc *tmp = container_of(ctmp, struct rsc, h);
+
         new->handle.len = tmp->handle.len;
         tmp->handle.len = 0;
         new->handle.data = tmp->handle.data;
@@ -337,9 +392,12 @@ rsc_init(struct rsc *new, struct rsc *tmp)
         new->cred.cr_group_info = NULL;
 }
 
-static inline void
-rsc_update(struct rsc *new, struct rsc *tmp)
+static void
+update_rsc(struct cache_head *cnew, struct cache_head *ctmp)
 {
+        struct rsc *new = container_of(cnew, struct rsc, h);
+        struct rsc *tmp = container_of(ctmp, struct rsc, h);
+
         new->mechctx = tmp->mechctx;
         tmp->mechctx = NULL;
         memset(&new->seqdata, 0, sizeof(new->seqdata));
@@ -348,6 +406,16 @@ rsc_update(struct rsc *new, struct rsc *tmp)
         tmp->cred.cr_group_info = NULL;
 }
 
+static struct cache_head *
+rsc_alloc(void)
+{
+        struct rsc *rsci = kmalloc(sizeof(*rsci), GFP_KERNEL);
+        if (rsci)
+                return &rsci->h;
+        else
+                return NULL;
+}
+
 static int rsc_parse(struct cache_detail *cd,
                      char *mesg, int mlen)
 {
@@ -373,6 +441,10 @@ static int rsc_parse(struct cache_detail *cd,
         if (expiry == 0)
                 goto out;
 
+        rscp = rsc_lookup(&rsci);
+        if (!rscp)
+                goto out;
+
         /* uid, or NEGATIVE */
         rv = get_int(&mesg, &rsci.cred.cr_uid);
         if (rv == -EINVAL)
@@ -428,12 +500,14 @@ static int rsc_parse(struct cache_detail *cd,
                 gss_mech_put(gm);
         }
         rsci.h.expiry_time = expiry;
-        rscp = rsc_lookup(&rsci, 1);
+        rscp = rsc_update(&rsci, rscp);
         status = 0;
 out:
         rsc_free(&rsci);
         if (rscp)
-                rsc_put(&rscp->h, &rsc_cache);
+                cache_put(&rscp->h, &rsc_cache);
+        else
+                status = -ENOMEM;
         return status;
 }
 
@@ -444,9 +518,37 @@ static struct cache_detail rsc_cache = {
         .name           = "auth.rpcsec.context",
         .cache_put      = rsc_put,
         .cache_parse    = rsc_parse,
+        .match          = rsc_match,
+        .init           = rsc_init,
+        .update         = update_rsc,
+        .alloc          = rsc_alloc,
 };
 
-static DefineSimpleCacheLookup(rsc, 0);
+static struct rsc *rsc_lookup(struct rsc *item)
+{
+        struct cache_head *ch;
+        int hash = rsc_hash(item);
+
+        ch = sunrpc_cache_lookup(&rsc_cache, &item->h, hash);
+        if (ch)
+                return container_of(ch, struct rsc, h);
+        else
+                return NULL;
+}
+
+static struct rsc *rsc_update(struct rsc *new, struct rsc *old)
+{
+        struct cache_head *ch;
+        int hash = rsc_hash(new);
+
+        ch = sunrpc_cache_update(&rsc_cache, &new->h,
+                                 &old->h, hash);
+        if (ch)
+                return container_of(ch, struct rsc, h);
+        else
+                return NULL;
+}
+
 
 static struct rsc *
 gss_svc_searchbyctx(struct xdr_netobj *handle)
@@ -457,7 +559,7 @@ gss_svc_searchbyctx(struct xdr_netobj *handle)
         memset(&rsci, 0, sizeof(rsci));
         if (dup_to_netobj(&rsci.handle, handle->data, handle->len))
                 return NULL;
-        found = rsc_lookup(&rsci, 0);
+        found = rsc_lookup(&rsci);
         rsc_free(&rsci);
         if (!found)
                 return NULL;
@@ -645,6 +747,8 @@ find_gss_auth_domain(struct gss_ctx *ctx, u32 svc)
         return auth_domain_find(name);
 }
 
+static struct auth_ops svcauthops_gss;
+
 int
 svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
 {
@@ -655,20 +759,18 @@ svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
         new = kmalloc(sizeof(*new), GFP_KERNEL);
         if (!new)
                 goto out;
-        cache_init(&new->h.h);
+        kref_init(&new->h.ref);
         new->h.name = kmalloc(strlen(name) + 1, GFP_KERNEL);
         if (!new->h.name)
                 goto out_free_dom;
         strcpy(new->h.name, name);
-        new->h.flavour = RPC_AUTH_GSS;
+        new->h.flavour = &svcauthops_gss;
         new->pseudoflavor = pseudoflavor;
-        new->h.h.expiry_time = NEVER;
 
-        test = auth_domain_lookup(&new->h, 1);
-        if (test == &new->h) {
-                BUG_ON(atomic_dec_and_test(&new->h.h.refcnt));
-        } else { /* XXX Duplicate registration? */
+        test = auth_domain_lookup(name, &new->h);
+        if (test != &new->h) { /* XXX Duplicate registration? */
                 auth_domain_put(&new->h);
+                /* dangling ref-count... */
                 goto out;
         }
         return 0;
@@ -895,7 +997,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, u32 *authp)
                         goto drop;
                 }
 
-                rsip = rsi_lookup(&rsikey, 0);
+                rsip = rsi_lookup(&rsikey);
                 rsi_free(&rsikey);
                 if (!rsip) {
                         goto drop;
@@ -970,7 +1072,7 @@ drop:
         ret = SVC_DROP;
 out:
         if (rsci)
-                rsc_put(&rsci->h, &rsc_cache);
+                cache_put(&rsci->h, &rsc_cache);
         return ret;
 }
 
@@ -1062,7 +1164,7 @@ out_err:
                 put_group_info(rqstp->rq_cred.cr_group_info);
         rqstp->rq_cred.cr_group_info = NULL;
         if (gsd->rsci)
-                rsc_put(&gsd->rsci->h, &rsc_cache);
+                cache_put(&gsd->rsci->h, &rsc_cache);
         gsd->rsci = NULL;
 
         return stat;
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 0acccfeeb284..3ac4193a78ed 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -37,16 +37,138 @@
 static void cache_defer_req(struct cache_req *req, struct cache_head *item);
 static void cache_revisit_request(struct cache_head *item);
 
-void cache_init(struct cache_head *h)
+static void cache_init(struct cache_head *h)
 {
         time_t now = get_seconds();
         h->next = NULL;
         h->flags = 0;
-        atomic_set(&h->refcnt, 1);
+        kref_init(&h->ref);
         h->expiry_time = now + CACHE_NEW_EXPIRY;
         h->last_refresh = now;
 }
 
+struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail,
+                                       struct cache_head *key, int hash)
+{
+        struct cache_head **head,  **hp;
+        struct cache_head *new = NULL;
+
+        head = &detail->hash_table[hash];
+
+        read_lock(&detail->hash_lock);
+
+        for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
+                struct cache_head *tmp = *hp;
+                if (detail->match(tmp, key)) {
+                        cache_get(tmp);
+                        read_unlock(&detail->hash_lock);
+                        return tmp;
+                }
+        }
+        read_unlock(&detail->hash_lock);
+        /* Didn't find anything, insert an empty entry */
+
+        new = detail->alloc();
+        if (!new)
+                return NULL;
+        cache_init(new);
+
+        write_lock(&detail->hash_lock);
+
+        /* check if entry appeared while we slept */
+        for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
+                struct cache_head *tmp = *hp;
+                if (detail->match(tmp, key)) {
+                        cache_get(tmp);
+                        write_unlock(&detail->hash_lock);
+                        cache_put(new, detail);
+                        return tmp;
+                }
+        }
+        detail->init(new, key);
+        new->next = *head;
+        *head = new;
+        detail->entries++;
+        cache_get(new);
+        write_unlock(&detail->hash_lock);
+
+        return new;
+}
+EXPORT_SYMBOL(sunrpc_cache_lookup);
+
+
+static void queue_loose(struct cache_detail *detail, struct cache_head *ch);
+
+static int cache_fresh_locked(struct cache_head *head, time_t expiry)
+{
+        head->expiry_time = expiry;
+        head->last_refresh = get_seconds();
+        return !test_and_set_bit(CACHE_VALID, &head->flags);
+}
+
+static void cache_fresh_unlocked(struct cache_head *head,
+                        struct cache_detail *detail, int new)
+{
+        if (new)
+                cache_revisit_request(head);
+        if (test_and_clear_bit(CACHE_PENDING, &head->flags)) {
+                cache_revisit_request(head);
+                queue_loose(detail, head);
+        }
+}
+
+struct cache_head *sunrpc_cache_update(struct cache_detail *detail,
+                                       struct cache_head *new, struct cache_head *old, int hash)
+{
+        /* The 'old' entry is to be replaced by 'new'.
+         * If 'old' is not VALID, we update it directly,
+         * otherwise we need to replace it
+         */
+        struct cache_head **head;
+        struct cache_head *tmp;
+        int is_new;
+
+        if (!test_bit(CACHE_VALID, &old->flags)) {
+                write_lock(&detail->hash_lock);
+                if (!test_bit(CACHE_VALID, &old->flags)) {
+                        if (test_bit(CACHE_NEGATIVE, &new->flags))
+                                set_bit(CACHE_NEGATIVE, &old->flags);
+                        else
+                                detail->update(old, new);
+                        is_new = cache_fresh_locked(old, new->expiry_time);
+                        write_unlock(&detail->hash_lock);
+                        cache_fresh_unlocked(old, detail, is_new);
+                        return old;
+                }
+                write_unlock(&detail->hash_lock);
+        }
+        /* We need to insert a new entry */
+        tmp = detail->alloc();
+        if (!tmp) {
+                cache_put(old, detail);
+                return NULL;
+        }
+        cache_init(tmp);
+        detail->init(tmp, old);
+        head = &detail->hash_table[hash];
+
+        write_lock(&detail->hash_lock);
+        if (test_bit(CACHE_NEGATIVE, &new->flags))
+                set_bit(CACHE_NEGATIVE, &tmp->flags);
+        else
+                detail->update(tmp, new);
+        tmp->next = *head;
+        *head = tmp;
+        cache_get(tmp);
+        is_new = cache_fresh_locked(tmp, new->expiry_time);
+        cache_fresh_locked(old, 0);
+        write_unlock(&detail->hash_lock);
+        cache_fresh_unlocked(tmp, detail, is_new);
+        cache_fresh_unlocked(old, detail, 0);
+        cache_put(old, detail);
+        return tmp;
+}
+EXPORT_SYMBOL(sunrpc_cache_update);
 
 static int cache_make_upcall(struct cache_detail *detail, struct cache_head *h);
 /*
@@ -94,7 +216,8 @@ int cache_check(struct cache_detail *detail,
                                 clear_bit(CACHE_PENDING, &h->flags);
                                 if (rv == -EAGAIN) {
                                         set_bit(CACHE_NEGATIVE, &h->flags);
-                                        cache_fresh(detail, h, get_seconds()+CACHE_NEW_EXPIRY);
+                                        cache_fresh_unlocked(h, detail,
+                                             cache_fresh_locked(h, get_seconds()+CACHE_NEW_EXPIRY));
                                         rv = -ENOENT;
                                 }
                                 break;
@@ -110,25 +233,11 @@ int cache_check(struct cache_detail *detail,
         if (rv == -EAGAIN)
                 cache_defer_req(rqstp, h);
 
-        if (rv && h)
-                detail->cache_put(h, detail);
+        if (rv)
+                cache_put(h, detail);
         return rv;
 }
 
-static void queue_loose(struct cache_detail *detail, struct cache_head *ch);
-
-void cache_fresh(struct cache_detail *detail,
-                 struct cache_head *head, time_t expiry)
-{
-
-        head->expiry_time = expiry;
-        head->last_refresh = get_seconds();
-        if (!test_and_set_bit(CACHE_VALID, &head->flags))
-                cache_revisit_request(head);
-        if (test_and_clear_bit(CACHE_PENDING, &head->flags))
-                queue_loose(detail, head);
-}
-
 /*
  * caches need to be periodically cleaned.
  * For this we maintain a list of cache_detail and
@@ -322,7 +431,7 @@ static int cache_clean(void)
                         if (test_and_clear_bit(CACHE_PENDING, &ch->flags))
                                 queue_loose(current_detail, ch);
 
-                        if (atomic_read(&ch->refcnt) == 1)
+                        if (atomic_read(&ch->ref.refcount) == 1)
                                 break;
                 }
                 if (ch) {
@@ -337,7 +446,7 @@ static int cache_clean(void)
                         current_index ++;
                 spin_unlock(&cache_list_lock);
                 if (ch)
-                        d->cache_put(ch, d);
+                        cache_put(ch, d);
         } else
                 spin_unlock(&cache_list_lock);
 
@@ -453,7 +562,7 @@ static void cache_defer_req(struct cache_req *req, struct cache_head *item)
                 /* there was one too many */
                 dreq->revisit(dreq, 1);
         }
-        if (test_bit(CACHE_VALID, &item->flags)) {
+        if (!test_bit(CACHE_PENDING, &item->flags)) {
                 /* must have just been validated... */
                 cache_revisit_request(item);
         }
@@ -614,7 +723,7 @@ cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
                     !test_bit(CACHE_PENDING, &rq->item->flags)) {
                         list_del(&rq->q.list);
                         spin_unlock(&queue_lock);
-                        cd->cache_put(rq->item, cd);
+                        cache_put(rq->item, cd);
                         kfree(rq->buf);
                         kfree(rq);
                 } else
@@ -794,10 +903,10 @@ static void queue_loose(struct cache_detail *detail, struct cache_head *ch)
                         if (cr->item != ch)
                                 continue;
                         if (cr->readers != 0)
-                                break;
+                                continue;
                         list_del(&cr->q.list);
                         spin_unlock(&queue_lock);
-                        detail->cache_put(cr->item, detail);
+                        cache_put(cr->item, detail);
                         kfree(cr->buf);
                         kfree(cr);
                         return;
@@ -1082,8 +1191,8 @@ static int c_show(struct seq_file *m, void *p)
                 return cd->cache_show(m, cd, NULL);
 
         ifdebug(CACHE)
-                seq_printf(m, "# expiry=%ld refcnt=%d\n",
-                           cp->expiry_time, atomic_read(&cp->refcnt));
+                seq_printf(m, "# expiry=%ld refcnt=%d flags=%lx\n",
+                           cp->expiry_time, atomic_read(&cp->ref.refcount), cp->flags);
         cache_get(cp);
         if (cache_check(cd, cp, NULL))
                 /* cache_check does a cache_put on failure */
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c
index 9f7373203592..769114f0f886 100644
--- a/net/sunrpc/sunrpc_syms.c
+++ b/net/sunrpc/sunrpc_syms.c
@@ -105,8 +105,6 @@ EXPORT_SYMBOL(auth_unix_lookup);
 EXPORT_SYMBOL(cache_check);
 EXPORT_SYMBOL(cache_flush);
 EXPORT_SYMBOL(cache_purge);
-EXPORT_SYMBOL(cache_fresh);
-EXPORT_SYMBOL(cache_init);
 EXPORT_SYMBOL(cache_register);
 EXPORT_SYMBOL(cache_unregister);
 EXPORT_SYMBOL(qword_add);
@@ -142,6 +140,7 @@ EXPORT_SYMBOL(nlm_debug);
 
 extern int register_rpc_pipefs(void);
 extern void unregister_rpc_pipefs(void);
+extern struct cache_detail ip_map_cache;
 
 static int __init
 init_sunrpc(void)
@@ -158,7 +157,6 @@ init_sunrpc(void)
 #ifdef CONFIG_PROC_FS
         rpc_proc_init();
 #endif
-        cache_register(&auth_domain_cache);
         cache_register(&ip_map_cache);
 out:
         return err;
@@ -169,8 +167,6 @@ cleanup_sunrpc(void)
 {
         unregister_rpc_pipefs();
         rpc_destroy_mempool();
-        if (cache_unregister(&auth_domain_cache))
-                printk(KERN_ERR "sunrpc: failed to unregister auth_domain cache\n");
         if (cache_unregister(&ip_map_cache))
                 printk(KERN_ERR "sunrpc: failed to unregister ip_map cache\n");
 #ifdef RPC_DEBUG
diff --git a/net/sunrpc/svcauth.c b/net/sunrpc/svcauth.c
index dda4f0c63511..5b28c6176806 100644
--- a/net/sunrpc/svcauth.c
+++ b/net/sunrpc/svcauth.c
@@ -106,112 +106,56 @@ svc_auth_unregister(rpc_authflavor_t flavor)
 EXPORT_SYMBOL(svc_auth_unregister);
 
 /**************************************************
- * cache for domain name to auth_domain
- * Entries are only added by flavours which will normally
- * have a structure that 'inherits' from auth_domain.
- * e.g. when an IP -> domainname is given to  auth_unix,
- * and the domain name doesn't exist, it will create a
- * auth_unix_domain and add it to this hash table.
- * If it finds the name does exist, but isn't AUTH_UNIX,
- * it will complain.
+ * 'auth_domains' are stored in a hash table indexed by name.
+ * When the last reference to an 'auth_domain' is dropped,
+ * the object is unhashed and freed.
+ * If auth_domain_lookup fails to find an entry, it will return
+ * it's second argument 'new'.  If this is non-null, it will
+ * have been atomically linked into the table.
  */
 
-/*
- * Auth auth_domain cache is somewhat different to other caches,
- * largely because the entries are possibly of different types:
- * each auth flavour has it's own type.
- * One consequence of this that DefineCacheLookup cannot
- * allocate a new structure as it cannot know the size.
- * Notice that the "INIT" code fragment is quite different
- * from other caches.  When auth_domain_lookup might be
- * creating a new domain, the new domain is passed in
- * complete and it is used as-is rather than being copied into
- * another structure.
- */
 #define DN_HASHBITS     6
 #define DN_HASHMAX      (1<<DN_HASHBITS)
 #define DN_HASHMASK     (DN_HASHMAX-1)
 
-static struct cache_head        *auth_domain_table[DN_HASHMAX];
-
-static void auth_domain_drop(struct cache_head *item, struct cache_detail *cd)
-{
-        struct auth_domain *dom = container_of(item, struct auth_domain, h);
-        if (cache_put(item,cd))
-                authtab[dom->flavour]->domain_release(dom);
-}
-
-
-struct cache_detail auth_domain_cache = {
-        .owner          = THIS_MODULE,
-        .hash_size      = DN_HASHMAX,
-        .hash_table     = auth_domain_table,
-        .name           = "auth.domain",
-        .cache_put      = auth_domain_drop,
-};
+static struct hlist_head        auth_domain_table[DN_HASHMAX];
+static spinlock_t       auth_domain_lock = SPIN_LOCK_UNLOCKED;
 
 void auth_domain_put(struct auth_domain *dom)
 {
-        auth_domain_drop(&dom->h, &auth_domain_cache);
-}
-
-static inline int auth_domain_hash(struct auth_domain *item)
-{
-        return hash_str(item->name, DN_HASHBITS);
-}
-static inline int auth_domain_match(struct auth_domain *tmp, struct auth_domain *item)
-{
-        return strcmp(tmp->name, item->name) == 0;
+        if (atomic_dec_and_lock(&dom->ref.refcount, &auth_domain_lock)) {
+                hlist_del(&dom->hash);
+                dom->flavour->domain_release(dom);
+        }
 }
 
 struct auth_domain *
-auth_domain_lookup(struct auth_domain *item, int set)
+auth_domain_lookup(char *name, struct auth_domain *new)
 {
-        struct auth_domain *tmp = NULL;
-        struct cache_head **hp, **head;
-        head = &auth_domain_cache.hash_table[auth_domain_hash(item)];
-
-        if (set)
-                write_lock(&auth_domain_cache.hash_lock);
-        else
-                read_lock(&auth_domain_cache.hash_lock);
-        for (hp=head; *hp != NULL; hp = &tmp->h.next) {
-                tmp = container_of(*hp, struct auth_domain, h);
-                if (!auth_domain_match(tmp, item))
-                        continue;
-                if (!set) {
-                        cache_get(&tmp->h);
-                        goto out_noset;
+        struct auth_domain *hp;
+        struct hlist_head *head;
+        struct hlist_node *np;
+
+        head = &auth_domain_table[hash_str(name, DN_HASHBITS)];
+
+        spin_lock(&auth_domain_lock);
+
+        hlist_for_each_entry(hp, np, head, hash) {
+                if (strcmp(hp->name, name)==0) {
+                        kref_get(&hp->ref);
+                        spin_unlock(&auth_domain_lock);
+                        return hp;
                 }
-                *hp = tmp->h.next;
-                tmp->h.next = NULL;
-                auth_domain_drop(&tmp->h, &auth_domain_cache);
-                goto out_set;
         }
-        /* Didn't find anything */
-        if (!set)
-                goto out_nada;
-        auth_domain_cache.entries++;
-out_set:
-        item->h.next = *head;
-        *head = &item->h;
-        cache_get(&item->h);
-        write_unlock(&auth_domain_cache.hash_lock);
-        cache_fresh(&auth_domain_cache, &item->h, item->h.expiry_time);
-        cache_get(&item->h);
-        return item;
-out_nada:
-        tmp = NULL;
-out_noset:
-        read_unlock(&auth_domain_cache.hash_lock);
-        return tmp;
+        if (new) {
+                hlist_add_head(&new->hash, head);
+                kref_get(&new->ref);
+        }
+        spin_unlock(&auth_domain_lock);
+        return new;
 }
 
 struct auth_domain *auth_domain_find(char *name)
 {
-        struct auth_domain *rv, ad;
-
-        ad.name = name;
-        rv = auth_domain_lookup(&ad, 0);
-        return rv;
+        return auth_domain_lookup(name, NULL);
 }
diff --git a/net/sunrpc/svcauth_unix.c b/net/sunrpc/svcauth_unix.c
index 3e6c694bbad1..7e5707e2d6b6 100644
--- a/net/sunrpc/svcauth_unix.c
+++ b/net/sunrpc/svcauth_unix.c
@@ -27,41 +27,35 @@ struct unix_domain {
         /* other stuff later */
 };
 
+extern struct auth_ops svcauth_unix;
+
 struct auth_domain *unix_domain_find(char *name)
 {
-        struct auth_domain *rv, ud;
-        struct unix_domain *new;
-
-        ud.name = name;
-        
-        rv = auth_domain_lookup(&ud, 0);
-
- foundit:
-        if (rv && rv->flavour != RPC_AUTH_UNIX) {
-                auth_domain_put(rv);
-                return NULL;
-        }
-        if (rv)
-                return rv;
-
-        new = kmalloc(sizeof(*new), GFP_KERNEL);
-        if (new == NULL)
-                return NULL;
-        cache_init(&new->h.h);
-        new->h.name = kstrdup(name, GFP_KERNEL);
-        new->h.flavour = RPC_AUTH_UNIX;
-        new->addr_changes = 0;
-        new->h.h.expiry_time = NEVER;
-
-        rv = auth_domain_lookup(&new->h, 2);
-        if (rv == &new->h) {
-                if (atomic_dec_and_test(&new->h.h.refcnt)) BUG();
-        } else {
-                auth_domain_put(&new->h);
-                goto foundit;
+        struct auth_domain *rv;
+        struct unix_domain *new = NULL;
+
+        rv = auth_domain_lookup(name, NULL);
+        while(1) {
+                if (rv) {
+                        if (new && rv != &new->h)
+                                auth_domain_put(&new->h);
+
+                        if (rv->flavour != &svcauth_unix) {
+                                auth_domain_put(rv);
+                                return NULL;
+                        }
+                        return rv;
+                }
+
+                new = kmalloc(sizeof(*new), GFP_KERNEL);
+                if (new == NULL)
+                        return NULL;
+                kref_init(&new->h.ref);
+                new->h.name = kstrdup(name, GFP_KERNEL);
+                new->h.flavour = &svcauth_unix;
+                new->addr_changes = 0;
+                rv = auth_domain_lookup(name, &new->h);
         }
-
-        return rv;
 }
 
 static void svcauth_unix_domain_release(struct auth_domain *dom)
@@ -90,15 +84,15 @@ struct ip_map {
 };
 static struct cache_head        *ip_table[IP_HASHMAX];
 
-static void ip_map_put(struct cache_head *item, struct cache_detail *cd)
+static void ip_map_put(struct kref *kref)
 {
+        struct cache_head *item = container_of(kref, struct cache_head, ref);
         struct ip_map *im = container_of(item, struct ip_map,h);
-        if (cache_put(item, cd)) {
-                if (test_bit(CACHE_VALID, &item->flags) &&
-                    !test_bit(CACHE_NEGATIVE, &item->flags))
-                        auth_domain_put(&im->m_client->h);
-                kfree(im);
-        }
+
+        if (test_bit(CACHE_VALID, &item->flags) &&
+            !test_bit(CACHE_NEGATIVE, &item->flags))
+                auth_domain_put(&im->m_client->h);
+        kfree(im);
 }
 
 #if IP_HASHBITS == 8
@@ -112,28 +106,38 @@ static inline int hash_ip(unsigned long ip)
         return (hash ^ (hash>>8)) & 0xff;
 }
 #endif
-
-static inline int ip_map_hash(struct ip_map *item)
-{
-        return hash_str(item->m_class, IP_HASHBITS) ^ 
-                hash_ip((unsigned long)item->m_addr.s_addr);
-}
-static inline int ip_map_match(struct ip_map *item, struct ip_map *tmp)
+static int ip_map_match(struct cache_head *corig, struct cache_head *cnew)
 {
-        return strcmp(tmp->m_class, item->m_class) == 0
-                && tmp->m_addr.s_addr == item->m_addr.s_addr;
+        struct ip_map *orig = container_of(corig, struct ip_map, h);
+        struct ip_map *new = container_of(cnew, struct ip_map, h);
+        return strcmp(orig->m_class, new->m_class) == 0
+                && orig->m_addr.s_addr == new->m_addr.s_addr;
 }
-static inline void ip_map_init(struct ip_map *new, struct ip_map *item)
+static void ip_map_init(struct cache_head *cnew, struct cache_head *citem)
 {
+        struct ip_map *new = container_of(cnew, struct ip_map, h);
+        struct ip_map *item = container_of(citem, struct ip_map, h);
+
         strcpy(new->m_class, item->m_class);
         new->m_addr.s_addr = item->m_addr.s_addr;
 }
-static inline void ip_map_update(struct ip_map *new, struct ip_map *item)
+static void update(struct cache_head *cnew, struct cache_head *citem)
 {
-        cache_get(&item->m_client->h.h);
+        struct ip_map *new = container_of(cnew, struct ip_map, h);
+        struct ip_map *item = container_of(citem, struct ip_map, h);
+
+        kref_get(&item->m_client->h.ref);
         new->m_client = item->m_client;
         new->m_add_change = item->m_add_change;
 }
+static struct cache_head *ip_map_alloc(void)
+{
+        struct ip_map *i = kmalloc(sizeof(*i), GFP_KERNEL);
+        if (i)
+                return &i->h;
+        else
+                return NULL;
+}
 
 static void ip_map_request(struct cache_detail *cd,
                                   struct cache_head *h,
@@ -154,7 +158,8 @@ static void ip_map_request(struct cache_detail *cd,
         (*bpp)[-1] = '\n';
 }
 
-static struct ip_map *ip_map_lookup(struct ip_map *, int);
+static struct ip_map *ip_map_lookup(char *class, struct in_addr addr);
+static int ip_map_update(struct ip_map *ipm, struct unix_domain *udom, time_t expiry);
 
 static int ip_map_parse(struct cache_detail *cd,
                           char *mesg, int mlen)
@@ -166,7 +171,11 @@ static int ip_map_parse(struct cache_detail *cd,
         int len;
         int b1,b2,b3,b4;
         char c;
-        struct ip_map ipm, *ipmp;
+        char class[8];
+        struct in_addr addr;
+        int err;
+
+        struct ip_map *ipmp;
         struct auth_domain *dom;
         time_t expiry;
 
@@ -175,7 +184,7 @@ static int ip_map_parse(struct cache_detail *cd,
         mesg[mlen-1] = 0;
 
         /* class */
-        len = qword_get(&mesg, ipm.m_class, sizeof(ipm.m_class));
+        len = qword_get(&mesg, class, sizeof(class));
         if (len <= 0) return -EINVAL;
 
         /* ip address */
@@ -200,25 +209,22 @@ static int ip_map_parse(struct cache_detail *cd,
         } else
                 dom = NULL;
 
-        ipm.m_addr.s_addr =
+        addr.s_addr =
                 htonl((((((b1<<8)|b2)<<8)|b3)<<8)|b4);
-        ipm.h.flags = 0;
-        if (dom) {
-                ipm.m_client = container_of(dom, struct unix_domain, h);
-                ipm.m_add_change = ipm.m_client->addr_changes;
+
+        ipmp = ip_map_lookup(class,addr);
+        if (ipmp) {
+                err = ip_map_update(ipmp,
+                             container_of(dom, struct unix_domain, h),
+                             expiry);
         } else
-                set_bit(CACHE_NEGATIVE, &ipm.h.flags);
-        ipm.h.expiry_time = expiry;
+                err = -ENOMEM;
 
-        ipmp = ip_map_lookup(&ipm, 1);
-        if (ipmp)
-                ip_map_put(&ipmp->h, &ip_map_cache);
         if (dom)
                 auth_domain_put(dom);
-        if (!ipmp)
-                return -ENOMEM;
+
         cache_flush();
-        return 0;
+        return err;
 }
 
 static int ip_map_show(struct seq_file *m,
@@ -262,32 +268,70 @@ struct cache_detail ip_map_cache = {
         .cache_request  = ip_map_request,
         .cache_parse    = ip_map_parse,
         .cache_show     = ip_map_show,
+        .match          = ip_map_match,
+        .init           = ip_map_init,
+        .update         = update,
+        .alloc          = ip_map_alloc,
 };
 
-static DefineSimpleCacheLookup(ip_map, 0)
+static struct ip_map *ip_map_lookup(char *class, struct in_addr addr)
+{
+        struct ip_map ip;
+        struct cache_head *ch;
+
+        strcpy(ip.m_class, class);
+        ip.m_addr = addr;
+        ch = sunrpc_cache_lookup(&ip_map_cache, &ip.h,
+                                 hash_str(class, IP_HASHBITS) ^
+                                 hash_ip((unsigned long)addr.s_addr));
+
+        if (ch)
+                return container_of(ch, struct ip_map, h);
+        else
+                return NULL;
+}
 
+static int ip_map_update(struct ip_map *ipm, struct unix_domain *udom, time_t expiry)
+{
+        struct ip_map ip;
+        struct cache_head *ch;
+
+        ip.m_client = udom;
+        ip.h.flags = 0;
+        if (!udom)
+                set_bit(CACHE_NEGATIVE, &ip.h.flags);
+        else {
+                ip.m_add_change = udom->addr_changes;
+                /* if this is from the legacy set_client system call,
+                 * we need m_add_change to be one higher
+                 */
+                if (expiry == NEVER)
+                        ip.m_add_change++;
+        }
+        ip.h.expiry_time = expiry;
+        ch = sunrpc_cache_update(&ip_map_cache,
+                                 &ip.h, &ipm->h,
+                                 hash_str(ipm->m_class, IP_HASHBITS) ^
+                                 hash_ip((unsigned long)ipm->m_addr.s_addr));
+        if (!ch)
+                return -ENOMEM;
+        cache_put(ch, &ip_map_cache);
+        return 0;
+}
 
 int auth_unix_add_addr(struct in_addr addr, struct auth_domain *dom)
 {
         struct unix_domain *udom;
-        struct ip_map ip, *ipmp;
+        struct ip_map *ipmp;
 
-        if (dom->flavour != RPC_AUTH_UNIX)
+        if (dom->flavour != &svcauth_unix)
                 return -EINVAL;
         udom = container_of(dom, struct unix_domain, h);
-        strcpy(ip.m_class, "nfsd");
-        ip.m_addr = addr;
-        ip.m_client = udom;
-        ip.m_add_change = udom->addr_changes+1;
-        ip.h.flags = 0;
-        ip.h.expiry_time = NEVER;
-        
-        ipmp = ip_map_lookup(&ip, 1);
+        ipmp = ip_map_lookup("nfsd", addr);
 
-        if (ipmp) {
-                ip_map_put(&ipmp->h, &ip_map_cache);
-                return 0;
-        } else
+        if (ipmp)
+                return ip_map_update(ipmp, udom, NEVER);
+        else
                 return -ENOMEM;
 }
 
@@ -295,7 +339,7 @@ int auth_unix_forget_old(struct auth_domain *dom)
 {
         struct unix_domain *udom;
         
-        if (dom->flavour != RPC_AUTH_UNIX)
+        if (dom->flavour != &svcauth_unix)
                 return -EINVAL;
         udom = container_of(dom, struct unix_domain, h);
         udom->addr_changes++;
@@ -310,7 +354,7 @@ struct auth_domain *auth_unix_lookup(struct in_addr addr)
         strcpy(key.m_class, "nfsd");
         key.m_addr = addr;
 
-        ipm = ip_map_lookup(&key, 0);
+        ipm = ip_map_lookup("nfsd", addr);
 
         if (!ipm)
                 return NULL;
@@ -323,31 +367,28 @@ struct auth_domain *auth_unix_lookup(struct in_addr addr)
                 rv = NULL;
         } else {
                 rv = &ipm->m_client->h;
-                cache_get(&rv->h);
+                kref_get(&rv->ref);
         }
-        ip_map_put(&ipm->h, &ip_map_cache);
+        cache_put(&ipm->h, &ip_map_cache);
         return rv;
 }
 
 void svcauth_unix_purge(void)
 {
         cache_purge(&ip_map_cache);
-        cache_purge(&auth_domain_cache);
 }
 
 static int
 svcauth_unix_set_client(struct svc_rqst *rqstp)
 {
-        struct ip_map key, *ipm;
+        struct ip_map *ipm;
 
         rqstp->rq_client = NULL;
         if (rqstp->rq_proc == 0)
                 return SVC_OK;
 
-        strcpy(key.m_class, rqstp->rq_server->sv_program->pg_class);
-        key.m_addr = rqstp->rq_addr.sin_addr;
-
-        ipm = ip_map_lookup(&key, 0);
+        ipm = ip_map_lookup(rqstp->rq_server->sv_program->pg_class,
+                            rqstp->rq_addr.sin_addr);
 
         if (ipm == NULL)
                 return SVC_DENIED;
@@ -361,8 +402,8 @@ svcauth_unix_set_client(struct svc_rqst *rqstp)
                         return SVC_DENIED;
                 case 0:
                         rqstp->rq_client = &ipm->m_client->h;
-                        cache_get(&rqstp->rq_client->h);
-                        ip_map_put(&ipm->h, &ip_map_cache);
+                        kref_get(&rqstp->rq_client->ref);
+                        cache_put(&ipm->h, &ip_map_cache);
                         break;
         }
         return SVC_OK;
diff --git a/sound/drivers/mpu401/mpu401.c b/sound/drivers/mpu401/mpu401.c
index 9d10d79e27af..9ea3059a7064 100644
--- a/sound/drivers/mpu401/mpu401.c
+++ b/sound/drivers/mpu401/mpu401.c
@@ -59,7 +59,8 @@ module_param_array(irq, int, NULL, 0444);
 MODULE_PARM_DESC(irq, "IRQ # for MPU-401 device.");
 
 static struct platform_device *platform_devices[SNDRV_CARDS];
-static int pnp_registered = 0;
+static int pnp_registered;
+static unsigned int snd_mpu401_devices;
 
 static int snd_mpu401_create(int dev, struct snd_card **rcard)
 {
@@ -197,6 +198,7 @@ static int __devinit snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev,
                 }
                 snd_card_set_dev(card, &pnp_dev->dev);
                 pnp_set_drvdata(pnp_dev, card);
+                snd_mpu401_devices++;
                 ++dev;
                 return 0;
         }
@@ -234,12 +236,11 @@ static void __init_or_module snd_mpu401_unregister_all(void)
 
 static int __init alsa_card_mpu401_init(void)
 {
-        int i, err, devices;
+        int i, err;
 
         if ((err = platform_driver_register(&snd_mpu401_driver)) < 0)
                 return err;
 
-        devices = 0;
         for (i = 0; i < SNDRV_CARDS; i++) {
                 struct platform_device *device;
                 if (! enable[i])
@@ -255,14 +256,13 @@ static int __init alsa_card_mpu401_init(void)
                         goto errout;
                 }
                 platform_devices[i] = device;
-                devices++;
+                snd_mpu401_devices++;
         }
-        if ((err = pnp_register_driver(&snd_mpu401_pnp_driver)) >= 0) {
+        err = pnp_register_driver(&snd_mpu401_pnp_driver);
+        if (!err)
                 pnp_registered = 1;
-                devices += err;
-        }
 
-        if (!devices) {
+        if (!snd_mpu401_devices) {
 #ifdef MODULE
                 printk(KERN_ERR "MPU-401 device not found or device busy\n");
 #endif
diff --git a/sound/isa/ad1816a/ad1816a.c b/sound/isa/ad1816a/ad1816a.c
index 7051f7798ed7..31f299aed281 100644
--- a/sound/isa/ad1816a/ad1816a.c
+++ b/sound/isa/ad1816a/ad1816a.c
@@ -262,6 +262,8 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard
         return 0;
 }
 
+static unsigned int __devinitdata ad1816a_devices;
+
 static int __devinit snd_ad1816a_pnp_detect(struct pnp_card_link *card,
                                             const struct pnp_card_device_id *id)
 {
@@ -275,6 +277,7 @@ static int __devinit snd_ad1816a_pnp_detect(struct pnp_card_link *card,
                 if (res < 0)
                         return res;
                 dev++;
+                ad1816a_devices++;
                 return 0;
         }
         return -ENODEV;
@@ -297,10 +300,13 @@ static struct pnp_card_driver ad1816a_pnpc_driver = {
 
 static int __init alsa_card_ad1816a_init(void)
 {
-        int cards;
+        int err;
+
+        err = pnp_register_card_driver(&ad1816a_pnpc_driver);
+        if (err)
+                return err;
 
-        cards = pnp_register_card_driver(&ad1816a_pnpc_driver);
-        if (cards <= 0) {
+        if (!ad1816a_devices) {
                 pnp_unregister_card_driver(&ad1816a_pnpc_driver);
 #ifdef MODULE
                 printk(KERN_ERR "no AD1816A based soundcards found.\n");
diff --git a/sound/isa/als100.c b/sound/isa/als100.c
index 9b77c17b3f66..a52bd8a14c9b 100644
--- a/sound/isa/als100.c
+++ b/sound/isa/als100.c
@@ -199,7 +199,7 @@ static int __devinit snd_card_als100_pnp(int dev, struct snd_card_als100 *acard,
         return 0;
 }
 
-static int __init snd_card_als100_probe(int dev,
+static int __devinit snd_card_als100_probe(int dev,
                                         struct pnp_card_link *pcard,
                                         const struct pnp_card_device_id *pid)
 {
@@ -281,6 +281,8 @@ static int __init snd_card_als100_probe(int dev,
         return 0;
 }
 
+static unsigned int __devinitdata als100_devices;
+
 static int __devinit snd_als100_pnp_detect(struct pnp_card_link *card,
                                            const struct pnp_card_device_id *id)
 {
@@ -294,6 +296,7 @@ static int __devinit snd_als100_pnp_detect(struct pnp_card_link *card,
                 if (res < 0)
                         return res;
                 dev++;
+                als100_devices++;
                 return 0;
         }
         return -ENODEV;
@@ -345,10 +348,13 @@ static struct pnp_card_driver als100_pnpc_driver = {
 
 static int __init alsa_card_als100_init(void)
 {
-        int cards;
+        int err;
+
+        err = pnp_register_card_driver(&als100_pnpc_driver);
+        if (err)
+                return err;
 
-        cards = pnp_register_card_driver(&als100_pnpc_driver);
-        if (cards <= 0) {
+        if (!als100_devices) {
                 pnp_unregister_card_driver(&als100_pnpc_driver);
 #ifdef MODULE
                 snd_printk(KERN_ERR "no ALS100 based soundcards found\n");
diff --git a/sound/isa/azt2320.c b/sound/isa/azt2320.c
index a530691bf4f7..15e59283aac6 100644
--- a/sound/isa/azt2320.c
+++ b/sound/isa/azt2320.c
@@ -310,6 +310,8 @@ static int __devinit snd_card_azt2320_probe(int dev,
         return 0;
 }
 
+static unsigned int __devinitdata azt2320_devices;
+
 static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card,
                                             const struct pnp_card_device_id *id)
 {
@@ -323,6 +325,7 @@ static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card,
                 if (res < 0)
                         return res;
                 dev++;
+                azt2320_devices++;
                 return 0;
         }
         return -ENODEV;
@@ -372,10 +375,13 @@ static struct pnp_card_driver azt2320_pnpc_driver = {
 
 static int __init alsa_card_azt2320_init(void)
 {
-        int cards;
+        int err;
+
+        err = pnp_register_card_driver(&azt2320_pnpc_driver);
+        if (err)
+                return err;
 
-        cards = pnp_register_card_driver(&azt2320_pnpc_driver);
-        if (cards <= 0) {
+        if (!azt2320_devices) {
                 pnp_unregister_card_driver(&azt2320_pnpc_driver);
 #ifdef MODULE
                 snd_printk(KERN_ERR "no AZT2320 based soundcards found\n");
diff --git a/sound/isa/cmi8330.c b/sound/isa/cmi8330.c
index fd9bb2575de8..fa63048a8b9d 100644
--- a/sound/isa/cmi8330.c
+++ b/sound/isa/cmi8330.c
@@ -175,7 +175,7 @@ MODULE_DEVICE_TABLE(pnp_card, snd_cmi8330_pnpids);
 #endif
 
 
-static struct ad1848_mix_elem snd_cmi8330_controls[] __initdata = {
+static struct ad1848_mix_elem snd_cmi8330_controls[] __devinitdata = {
 AD1848_DOUBLE("Master Playback Volume", 0, CMI8330_MASTVOL, CMI8330_MASTVOL, 4, 0, 15, 0),
 AD1848_SINGLE("Loud Playback Switch", 0, CMI8330_MUTEMUX, 6, 1, 1),
 AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 7, 7, 1, 1),
@@ -204,7 +204,7 @@ AD1848_SINGLE(SNDRV_CTL_NAME_IEC958("Input ",PLAYBACK,SWITCH), 0, CMI8330_MUTEMU
 };
 
 #ifdef ENABLE_SB_MIXER
-static struct sbmix_elem cmi8330_sb_mixers[] __initdata = {
+static struct sbmix_elem cmi8330_sb_mixers[] __devinitdata = {
 SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31),
 SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15),
 SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15),
@@ -222,7 +222,7 @@ SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6
 SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
 };
 
-static unsigned char cmi8330_sb_init_values[][2] __initdata = {
+static unsigned char cmi8330_sb_init_values[][2] __devinitdata = {
         { SB_DSP4_MASTER_DEV + 0, 0 },
         { SB_DSP4_MASTER_DEV + 1, 0 },
         { SB_DSP4_PCM_DEV + 0, 0 },
@@ -545,7 +545,7 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev)
         return snd_card_register(card);
 }
 
-static int __init snd_cmi8330_nonpnp_probe(struct platform_device *pdev)
+static int __devinit snd_cmi8330_nonpnp_probe(struct platform_device *pdev)
 {
         struct snd_card *card;
         int err;
@@ -607,6 +607,8 @@ static struct platform_driver snd_cmi8330_driver = {
 
 
 #ifdef CONFIG_PNP
+static unsigned int __devinitdata cmi8330_pnp_devices;
+
 static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *pcard,
                                             const struct pnp_card_device_id *pid)
 {
@@ -636,6 +638,7 @@ static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *pcard,
         }
         pnp_set_card_drvdata(pcard, card);
         dev++;
+        cmi8330_pnp_devices++;
         return 0;
 }
 
@@ -706,9 +709,9 @@ static int __init alsa_card_cmi8330_init(void)
 
 #ifdef CONFIG_PNP
         err = pnp_register_card_driver(&cmi8330_pnpc_driver);
-        if (err >= 0) {
+        if (!err) {
                 pnp_registered = 1;
-                cards += err;
+                cards += cmi8330_pnp_devices;
         }
 #endif
 
diff --git a/sound/isa/cs423x/cs4236.c b/sound/isa/cs423x/cs4236.c
index 4060918e0327..382bb17ef49f 100644
--- a/sound/isa/cs423x/cs4236.c
+++ b/sound/isa/cs423x/cs4236.c
@@ -133,6 +133,7 @@ static int pnpc_registered;
 static int pnp_registered;
 #endif
 #endif /* CONFIG_PNP */
+static unsigned int snd_cs423x_devices;
 
 struct snd_card_cs4236 {
         struct snd_cs4231 *chip;
@@ -564,7 +565,7 @@ static int __init snd_cs423x_nonpnp_probe(struct platform_device *pdev)
                 snd_card_free(card);
                 return err;
         }
-        
+
         platform_set_drvdata(pdev, card);
         return 0;
 }
@@ -650,6 +651,7 @@ static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev,
         }
         pnp_set_drvdata(pdev, card);
         dev++;
+        snd_cs423x_devices++;
         return 0;
 }
 
@@ -713,6 +715,7 @@ static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard,
         }
         pnp_set_card_drvdata(pcard, card);
         dev++;
+        snd_cs423x_devices++;
         return 0;
 }
 
@@ -721,7 +724,7 @@ static void __devexit snd_cs423x_pnpc_remove(struct pnp_card_link * pcard)
         snd_card_free(pnp_get_card_drvdata(pcard));
         pnp_set_card_drvdata(pcard, NULL);
 }
-                        
+
 #ifdef CONFIG_PM
 static int snd_cs423x_pnpc_suspend(struct pnp_card_link *pcard, pm_message_t state)
 {
@@ -766,7 +769,7 @@ static void __init_or_module snd_cs423x_unregister_all(void)
 
 static int __init alsa_card_cs423x_init(void)
 {
-        int i, err, cards = 0;
+        int i, err;
 
         if ((err = platform_driver_register(&cs423x_nonpnp_driver)) < 0)
                 return err;
@@ -782,24 +785,20 @@ static int __init alsa_card_cs423x_init(void)
                         goto errout;
                 }
                 platform_devices[i] = device;
-                cards++;
+                snd_cs423x_devices++;
         }
 #ifdef CONFIG_PNP
 #ifdef CS4232
-        i = pnp_register_driver(&cs4232_pnp_driver);
-        if (i >= 0) {
+        err = pnp_register_driver(&cs4232_pnp_driver);
+        if (!err)
                 pnp_registered = 1;
-                cards += i;
-        }
 #endif
-        i = pnp_register_card_driver(&cs423x_pnpc_driver);
-        if (i >= 0) {
+        err = pnp_register_card_driver(&cs423x_pnpc_driver);
+        if (!err)
                 pnpc_registered = 1;
-                cards += i;
-        }
 #endif /* CONFIG_PNP */
 
-        if (!cards) {
+        if (!snd_cs423x_devices) {
 #ifdef MODULE
                 printk(KERN_ERR IDENT " soundcard not found or device busy\n");
 #endif
diff --git a/sound/isa/dt019x.c b/sound/isa/dt019x.c
index 50e7bc5ef561..0acb4e5da47f 100644
--- a/sound/isa/dt019x.c
+++ b/sound/isa/dt019x.c
@@ -272,6 +272,8 @@ static int __devinit snd_card_dt019x_probe(int dev, struct pnp_card_link *pcard,
         return 0;
 }
 
+static unsigned int __devinitdata dt019x_devices;
+
 static int __devinit snd_dt019x_pnp_probe(struct pnp_card_link *card,
                                           const struct pnp_card_device_id *pid)
 {
@@ -285,6 +287,7 @@ static int __devinit snd_dt019x_pnp_probe(struct pnp_card_link *card,
                 if (res < 0)
                         return res;
                 dev++;
+                dt019x_devices++;
                 return 0;
         }
         return -ENODEV;
@@ -336,10 +339,13 @@ static struct pnp_card_driver dt019x_pnpc_driver = {
 
 static int __init alsa_card_dt019x_init(void)
 {
-        int cards = 0;
+        int err;
+
+        err = pnp_register_card_driver(&dt019x_pnpc_driver);
+        if (err)
+                return err;
 
-        cards = pnp_register_card_driver(&dt019x_pnpc_driver);
-        if (cards <= 0) {
+        if (!dt019x_devices) {
                 pnp_unregister_card_driver(&dt019x_pnpc_driver);
 #ifdef MODULE
                 snd_printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
diff --git a/sound/isa/es18xx.c b/sound/isa/es18xx.c
index 721955d26194..9fbc185b4cc2 100644
--- a/sound/isa/es18xx.c
+++ b/sound/isa/es18xx.c
@@ -2204,7 +2204,7 @@ static int __devinit snd_audiodrive_probe(struct snd_card *card, int dev)
         return snd_card_register(card);
 }
 
-static int __init snd_es18xx_nonpnp_probe1(int dev, struct platform_device *devptr)
+static int __devinit snd_es18xx_nonpnp_probe1(int dev, struct platform_device *devptr)
 {
         struct snd_card *card;
         int err;
@@ -2221,7 +2221,7 @@ static int __init snd_es18xx_nonpnp_probe1(int dev, struct platform_device *devp
         return 0;
 }
 
-static int __init snd_es18xx_nonpnp_probe(struct platform_device *pdev)
+static int __devinit snd_es18xx_nonpnp_probe(struct platform_device *pdev)
 {
         int dev = pdev->id;
         int err;
@@ -2297,6 +2297,8 @@ static struct platform_driver snd_es18xx_nonpnp_driver = {
 
 
 #ifdef CONFIG_PNP
+static unsigned int __devinitdata es18xx_pnp_devices;
+
 static int __devinit snd_audiodrive_pnp_detect(struct pnp_card_link *pcard,
                                                const struct pnp_card_device_id *pid)
 {
@@ -2327,6 +2329,7 @@ static int __devinit snd_audiodrive_pnp_detect(struct pnp_card_link *pcard,
 
         pnp_set_card_drvdata(pcard, card);
         dev++;
+        es18xx_pnp_devices++;
         return 0;
 }
 
@@ -2397,10 +2400,10 @@ static int __init alsa_card_es18xx_init(void)
         }
 
 #ifdef CONFIG_PNP
-        i = pnp_register_card_driver(&es18xx_pnpc_driver);
-        if (i >= 0) {
+        err = pnp_register_card_driver(&es18xx_pnpc_driver);
+        if (!err) {
                 pnp_registered = 1;
-                cards += i;
+                cards += es18xx_pnp_devices;
         }
 #endif
 
diff --git a/sound/isa/gus/interwave.c b/sound/isa/gus/interwave.c
index 2cacd0fa6871..de71b7a99c83 100644
--- a/sound/isa/gus/interwave.c
+++ b/sound/isa/gus/interwave.c
@@ -791,7 +791,7 @@ static int __devinit snd_interwave_probe(struct snd_card *card, int dev)
         return 0;
 }
 
-static int __init snd_interwave_nonpnp_probe1(int dev, struct platform_device *devptr)
+static int __devinit snd_interwave_nonpnp_probe1(int dev, struct platform_device *devptr)
 {
         struct snd_card *card;
         int err;
@@ -809,7 +809,7 @@ static int __init snd_interwave_nonpnp_probe1(int dev, struct platform_device *d
         return 0;
 }
 
-static int __init snd_interwave_nonpnp_probe(struct platform_device *pdev)
+static int __devinit snd_interwave_nonpnp_probe(struct platform_device *pdev)
 {
         int dev = pdev->id;
         int err;
@@ -867,6 +867,7 @@ static struct platform_driver snd_interwave_driver = {
 };
 
 #ifdef CONFIG_PNP
+static unsigned int __devinitdata interwave_pnp_devices;
 
 static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *pcard,
                                               const struct pnp_card_device_id *pid)
@@ -897,6 +898,7 @@ static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *pcard,
         }
         pnp_set_card_drvdata(pcard, card);
         dev++;
+        interwave_pnp_devices++;
         return 0;
 }
 
@@ -954,10 +956,10 @@ static int __init alsa_card_interwave_init(void)
         }
 
         /* ISA PnP cards */
-        i = pnp_register_card_driver(&interwave_pnpc_driver);
-        if (i >= 0) {
+        err = pnp_register_card_driver(&interwave_pnpc_driver);
+        if (!err) {
                 pnp_registered = 1;
-                cards += i;
+                cards += interwave_pnp_devices;;
         }
 
         if (!cards) {
diff --git a/sound/isa/opl3sa2.c b/sound/isa/opl3sa2.c
index 56fcd8a946a4..c906e205d7d5 100644
--- a/sound/isa/opl3sa2.c
+++ b/sound/isa/opl3sa2.c
@@ -95,6 +95,7 @@ static struct platform_device *platform_devices[SNDRV_CARDS];
 static int pnp_registered;
 static int pnpc_registered;
 #endif
+static unsigned int snd_opl3sa2_devices;
 
 /* control ports */
 #define OPL3SA2_PM_CTRL         0x01
@@ -760,6 +761,7 @@ static int __devinit snd_opl3sa2_pnp_detect(struct pnp_dev *pdev,
         }
         pnp_set_drvdata(pdev, card);
         dev++;
+        snd_opl3sa2_devices++;
         return 0;
 }
 
@@ -826,6 +828,7 @@ static int __devinit snd_opl3sa2_pnp_cdetect(struct pnp_card_link *pcard,
         }
         pnp_set_card_drvdata(pcard, card);
         dev++;
+        snd_opl3sa2_devices++;
         return 0;
 }
 
@@ -944,7 +947,7 @@ static void __init_or_module snd_opl3sa2_unregister_all(void)
 
 static int __init alsa_card_opl3sa2_init(void)
 {
-        int i, err, cards = 0;
+        int i, err;
 
         if ((err = platform_driver_register(&snd_opl3sa2_nonpnp_driver)) < 0)
                 return err;
@@ -964,23 +967,19 @@ static int __init alsa_card_opl3sa2_init(void)
                         goto errout;
                 }
                 platform_devices[i] = device;
-                cards++;
+                snd_opl3sa2_devices++;
         }
 
 #ifdef CONFIG_PNP
         err = pnp_register_driver(&opl3sa2_pnp_driver);
-        if (err >= 0) {
+        if (!err)
                 pnp_registered = 1;
-                cards += err;
-        }
         err = pnp_register_card_driver(&opl3sa2_pnpc_driver);
-        if (err >= 0) {
+        if (!err)
                 pnpc_registered = 1;
-                cards += err;
-        }
 #endif
 
-        if (!cards) {
+        if (!snd_opl3sa2_devices) {
 #ifdef MODULE
                 snd_printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
 #endif
diff --git a/sound/isa/sb/es968.c b/sound/isa/sb/es968.c
index 9da80bfa3027..d4d65b84265a 100644
--- a/sound/isa/sb/es968.c
+++ b/sound/isa/sb/es968.c
@@ -124,7 +124,7 @@ static int __devinit snd_card_es968_pnp(int dev, struct snd_card_es968 *acard,
         return 0;
 }
 
-static int __init snd_card_es968_probe(int dev,
+static int __devinit snd_card_es968_probe(int dev,
                                         struct pnp_card_link *pcard,
                                         const struct pnp_card_device_id *pid)
 {
@@ -182,6 +182,8 @@ static int __init snd_card_es968_probe(int dev,
         return 0;
 }
 
+static unsigned int __devinitdata es968_devices;
+
 static int __devinit snd_es968_pnp_detect(struct pnp_card_link *card,
                                           const struct pnp_card_device_id *id)
 {
@@ -195,6 +197,7 @@ static int __devinit snd_es968_pnp_detect(struct pnp_card_link *card,
                 if (res < 0)
                         return res;
                 dev++;
+                es968_devices++;
                 return 0;
         }
         return -ENODEV;
@@ -246,8 +249,11 @@ static struct pnp_card_driver es968_pnpc_driver = {
 
 static int __init alsa_card_es968_init(void)
 {
-        int cards = pnp_register_card_driver(&es968_pnpc_driver);
-        if (cards <= 0) {
+        int err = pnp_register_card_driver(&es968_pnpc_driver);
+        if (err)
+                return err;
+
+        if (!es968_devices) {
                 pnp_unregister_card_driver(&es968_pnpc_driver);
 #ifdef MODULE
                 snd_printk(KERN_ERR "no ES968 based soundcards found\n");
diff --git a/sound/isa/sb/sb16.c b/sound/isa/sb/sb16.c
index 5737ab76160c..21ea65925a9e 100644
--- a/sound/isa/sb/sb16.c
+++ b/sound/isa/sb/sb16.c
@@ -369,7 +369,7 @@ static struct snd_card *snd_sb16_card_new(int dev)
         return card;
 }
 
-static int __init snd_sb16_probe(struct snd_card *card, int dev)
+static int __devinit snd_sb16_probe(struct snd_card *card, int dev)
 {
         int xirq, xdma8, xdma16;
         struct snd_sb *chip;
@@ -518,7 +518,7 @@ static int snd_sb16_resume(struct snd_card *card)
 }
 #endif
 
-static int __init snd_sb16_nonpnp_probe1(int dev, struct platform_device *devptr)
+static int __devinit snd_sb16_nonpnp_probe1(int dev, struct platform_device *devptr)
 {
         struct snd_card_sb16 *acard;
         struct snd_card *card;
@@ -548,7 +548,7 @@ static int __init snd_sb16_nonpnp_probe1(int dev, struct platform_device *devptr
 }
 
 
-static int __init snd_sb16_nonpnp_probe(struct platform_device *pdev)
+static int __devinit snd_sb16_nonpnp_probe(struct platform_device *pdev)
 {
         int dev = pdev->id;
         int err;
@@ -629,6 +629,7 @@ static struct platform_driver snd_sb16_nonpnp_driver = {
 
 
 #ifdef CONFIG_PNP
+static unsigned int __devinitdata sb16_pnp_devices;
 
 static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard,
                                          const struct pnp_card_device_id *pid)
@@ -651,6 +652,7 @@ static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard,
                 }
                 pnp_set_card_drvdata(pcard, card);
                 dev++;
+                sb16_pnp_devices++;
                 return 0;
         }
 
@@ -727,10 +729,10 @@ static int __init alsa_card_sb16_init(void)
         }
 #ifdef CONFIG_PNP
         /* PnP cards at last */
-        i = pnp_register_card_driver(&sb16_pnpc_driver);
-        if (i >= 0) {
+        err = pnp_register_card_driver(&sb16_pnpc_driver);
+        if (!err) {
                 pnp_registered = 1;
-                cards += i;
+                cards += sb16_pnp_devices;
         }
 #endif
 
diff --git a/sound/isa/sscape.c b/sound/isa/sscape.c
index 29bba8cc3ef3..48e5552d3444 100644
--- a/sound/isa/sscape.c
+++ b/sound/isa/sscape.c
@@ -1255,7 +1255,7 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp)
 }
 
 
-static int __init snd_sscape_probe(struct platform_device *pdev)
+static int __devinit snd_sscape_probe(struct platform_device *pdev)
 {
         int dev = pdev->id;
         struct snd_card *card;
@@ -1469,7 +1469,7 @@ static int __init sscape_init(void)
         if (ret < 0)
                 return ret;
 #ifdef CONFIG_PNP
-        if (pnp_register_card_driver(&sscape_pnpc_driver) >= 0)
+        if (pnp_register_card_driver(&sscape_pnpc_driver) == 0)
                 pnp_registered = 1;
 #endif
         return 0;
diff --git a/sound/isa/wavefront/wavefront.c b/sound/isa/wavefront/wavefront.c
index c0115bf9065e..2f13cd5d4dcb 100644
--- a/sound/isa/wavefront/wavefront.c
+++ b/sound/isa/wavefront/wavefront.c
@@ -589,7 +589,7 @@ snd_wavefront_probe (struct snd_card *card, int dev)
         return snd_card_register(card);
 }       
 
-static int __init snd_wavefront_nonpnp_probe(struct platform_device *pdev)
+static int __devinit snd_wavefront_nonpnp_probe(struct platform_device *pdev)
 {
         int dev = pdev->id;
         struct snd_card *card;
@@ -637,6 +637,7 @@ static struct platform_driver snd_wavefront_driver = {
 
 
 #ifdef CONFIG_PNP
+static unsigned int __devinitdata wavefront_pnp_devices;
 
 static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
                                               const struct pnp_card_device_id *pid)
@@ -670,6 +671,7 @@ static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
 
         pnp_set_card_drvdata(pcard, card);
         dev++;
+        wavefront_pnp_devices++;
         return 0;
 }
 
@@ -729,10 +731,10 @@ static int __init alsa_card_wavefront_init(void)
         }
 
 #ifdef CONFIG_PNP
-        i = pnp_register_card_driver(&wavefront_pnpc_driver);
-        if (i >= 0) {
+        err = pnp_register_card_driver(&wavefront_pnpc_driver);
+        if (!err) {
                 pnp_registered = 1;
-                cards += i;
+                cards += wavefront_pnp_devices;
         }
 #endif
 
diff --git a/sound/oss/cs4232.c b/sound/oss/cs4232.c
index 7c59e2d4003a..c7f86f09c28d 100644
--- a/sound/oss/cs4232.c
+++ b/sound/oss/cs4232.c
@@ -360,6 +360,8 @@ static int __initdata synthio	= -1;
 static int __initdata synthirq  = -1;
 static int __initdata isapnp    = 1;
 
+static unsigned int cs4232_devices;
+
 MODULE_DESCRIPTION("CS4232 based soundcard driver"); 
 MODULE_AUTHOR("Hannu Savolainen, Paul Barton-Davis"); 
 MODULE_LICENSE("GPL");
@@ -421,6 +423,7 @@ static int cs4232_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev
                 return -ENODEV;
         }
         pnp_set_drvdata(dev,isapnpcfg);
+        cs4232_devices++;
         return 0;
 }
 
@@ -455,10 +458,11 @@ static int __init init_cs4232(void)
 #endif
         cfg.irq = -1;
 
-        if (isapnp &&
-            (pnp_register_driver(&cs4232_driver) > 0)
-        )
-                return 0;
+        if (isapnp) {
+                pnp_register_driver(&cs4232_driver);
+                if (cs4232_devices)
+                        return 0;
+        }
 
         if(io==-1||irq==-1||dma==-1)
         {
@@ -503,7 +507,8 @@ static int __init setup_cs4232(char *str)
         int ints[7];
 
         /* If we have isapnp cards, no need for options */
-        if (pnp_register_driver(&cs4232_driver) > 0)
+        pnp_register_driver(&cs4232_driver);
+        if (cs4232_devices)
                 return 1;
         
         str = get_options(str, ARRAY_SIZE(ints), ints);
diff --git a/sound/oss/sb_card.c b/sound/oss/sb_card.c
index 680b82e15298..d38e88abc8fa 100644
--- a/sound/oss/sb_card.c
+++ b/sound/oss/sb_card.c
@@ -52,6 +52,7 @@ static int __initdata sm_games 	= 0; /* Logitech soundman games? */
 static struct sb_card_config *legacy = NULL;
 
 #ifdef CONFIG_PNP
+static int pnp_registered;
 static int __initdata pnp       = 1;
 /*
 static int __initdata uart401   = 0;
@@ -133,7 +134,7 @@ static void sb_unload(struct sb_card_config *scc)
 }
 
 /* Register legacy card with OSS subsystem */
-static int sb_init_legacy(void)
+static int __init sb_init_legacy(void)
 {
         struct sb_module_options sbmo = {0};
 
@@ -234,6 +235,8 @@ static void sb_dev2cfg(struct pnp_dev *dev, struct sb_card_config *scc)
         }
 }
 
+static unsigned int sb_pnp_devices;
+
 /* Probe callback function for the PnP API */
 static int sb_pnp_probe(struct pnp_card_link *card, const struct pnp_card_device_id *card_id)
 {
@@ -264,6 +267,7 @@ static int sb_pnp_probe(struct pnp_card_link *card, const struct pnp_card_device
                scc->conf.dma, scc->conf.dma2);
 
         pnp_set_card_drvdata(card, scc);
+        sb_pnp_devices++;
 
         return sb_register_oss(scc, &sbmo);
 }
@@ -289,6 +293,14 @@ static struct pnp_card_driver sb_pnp_driver = {
 MODULE_DEVICE_TABLE(pnp_card, sb_pnp_card_table);
 #endif /* CONFIG_PNP */
 
+static void __init_or_module sb_unregister_all(void)
+{
+#ifdef CONFIG_PNP
+        if (pnp_registered)
+                pnp_unregister_card_driver(&sb_pnp_driver);
+#endif
+}
+
 static int __init sb_init(void)
 {
         int lres = 0;
@@ -307,17 +319,18 @@ static int __init sb_init(void)
 
 #ifdef CONFIG_PNP
         if(pnp) {
-                pres = pnp_register_card_driver(&sb_pnp_driver);
+                int err = pnp_register_card_driver(&sb_pnp_driver);
+                if (!err)
+                        pnp_registered = 1;
+                pres = sb_pnp_devices;
         }
 #endif
         printk(KERN_INFO "sb: Init: Done\n");
 
         /* If either PnP or Legacy registered a card then return
          * success */
-        if (pres <= 0 && lres <= 0) {
-#ifdef CONFIG_PNP
-                pnp_unregister_card_driver(&sb_pnp_driver);
-#endif
+        if (pres == 0 && lres <= 0) {
+                sb_unregister_all();
                 return -ENODEV;
         }
         return 0;
@@ -333,9 +346,7 @@ static void __exit sb_exit(void)
                 sb_unload(legacy);
         }
 
-#ifdef CONFIG_PNP
-        pnp_unregister_card_driver(&sb_pnp_driver);
-#endif
+        sb_unregister_all();
 
         if (smw_free) {
                 vfree(smw_free);