Merge branch 'ehci-omap-clock' into omap-fixes

510 files changed, 31303 insertions, 11326 deletions

diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking
index 33fa3e5d38fd..977d8919cc69 100644
--- a/Documentation/filesystems/Locking
+++ b/Documentation/filesystems/Locking
@@ -9,22 +9,25 @@ be able to use diff(1).
 
 --------------------------- dentry_operations --------------------------
 prototypes:
-        int (*d_revalidate)(struct dentry *, int);
-        int (*d_hash) (struct dentry *, struct qstr *);
-        int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
+        int (*d_revalidate)(struct dentry *, struct nameidata *);
+        int (*d_hash)(const struct dentry *, const struct inode *,
+                        struct qstr *);
+        int (*d_compare)(const struct dentry *, const struct inode *,
+                        const struct dentry *, const struct inode *,
+                        unsigned int, const char *, const struct qstr *);
         int (*d_delete)(struct dentry *);
         void (*d_release)(struct dentry *);
         void (*d_iput)(struct dentry *, struct inode *);
         char *(*d_dname)((struct dentry *dentry, char *buffer, int buflen);
 
 locking rules:
-                dcache_lock     rename_lock     ->d_lock        may block
-d_revalidate:   no              no              no              yes
-d_hash          no              no              no              yes
-d_compare:      no              yes             no              no 
-d_delete:       yes             no              yes             no
-d_release:      no              no              no              yes
-d_iput:         no              no              no              yes
+                rename_lock     ->d_lock        may block       rcu-walk
+d_revalidate:   no              no              yes (ref-walk)  maybe
+d_hash          no              no              no              maybe
+d_compare:      yes             no              no              maybe
+d_delete:       no              yes             no              no
+d_release:      no              no              yes             no
+d_iput:         no              no              yes             no
 d_dname:        no              no              no              no
 
 --------------------------- inode_operations --------------------------- 
@@ -44,8 +47,8 @@ ata *);
         void * (*follow_link) (struct dentry *, struct nameidata *);
         void (*put_link) (struct dentry *, struct nameidata *, void *);
         void (*truncate) (struct inode *);
-        int (*permission) (struct inode *, int, struct nameidata *);
-        int (*check_acl)(struct inode *, int);
+        int (*permission) (struct inode *, int, unsigned int);
+        int (*check_acl)(struct inode *, int, unsigned int);
         int (*setattr) (struct dentry *, struct iattr *);
         int (*getattr) (struct vfsmount *, struct dentry *, struct kstat *);
         int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
@@ -73,7 +76,7 @@ follow_link:	no
 put_link:       no
 truncate:       yes             (see below)
 setattr:        yes
-permission:     no
+permission:     no (may not block if called in rcu-walk mode)
 check_acl:      no
 getattr:        no
 setxattr:       yes
diff --git a/Documentation/filesystems/dentry-locking.txt b/Documentation/filesystems/dentry-locking.txt
deleted file mode 100644
index 79334ed5daa7..000000000000
--- a/Documentation/filesystems/dentry-locking.txt
+++ /dev/null
@@ -1,174 +0,0 @@
-RCU-based dcache locking model
-==============================
-
-On many workloads, the most common operation on dcache is to look up a
-dentry, given a parent dentry and the name of the child. Typically,
-for every open(), stat() etc., the dentry corresponding to the
-pathname will be looked up by walking the tree starting with the first
-component of the pathname and using that dentry along with the next
-component to look up the next level and so on. Since it is a frequent
-operation for workloads like multiuser environments and web servers,
-it is important to optimize this path.
-
-Prior to 2.5.10, dcache_lock was acquired in d_lookup and thus in
-every component during path look-up. Since 2.5.10 onwards, fast-walk
-algorithm changed this by holding the dcache_lock at the beginning and
-walking as many cached path component dentries as possible. This
-significantly decreases the number of acquisition of
-dcache_lock. However it also increases the lock hold time
-significantly and affects performance in large SMP machines. Since
-2.5.62 kernel, dcache has been using a new locking model that uses RCU
-to make dcache look-up lock-free.
-
-The current dcache locking model is not very different from the
-existing dcache locking model. Prior to 2.5.62 kernel, dcache_lock
-protected the hash chain, d_child, d_alias, d_lru lists as well as
-d_inode and several other things like mount look-up. RCU-based changes
-affect only the way the hash chain is protected. For everything else
-the dcache_lock must be taken for both traversing as well as
-updating. The hash chain updates too take the dcache_lock.  The
-significant change is the way d_lookup traverses the hash chain, it
-doesn't acquire the dcache_lock for this and rely on RCU to ensure
-that the dentry has not been *freed*.
-
-
-Dcache locking details
-======================
-
-For many multi-user workloads, open() and stat() on files are very
-frequently occurring operations. Both involve walking of path names to
-find the dentry corresponding to the concerned file. In 2.4 kernel,
-dcache_lock was held during look-up of each path component. Contention
-and cache-line bouncing of this global lock caused significant
-scalability problems. With the introduction of RCU in Linux kernel,
-this was worked around by making the look-up of path components during
-path walking lock-free.
-
-
-Safe lock-free look-up of dcache hash table
-===========================================
-
-Dcache is a complex data structure with the hash table entries also
-linked together in other lists. In 2.4 kernel, dcache_lock protected
-all the lists. We applied RCU only on hash chain walking. The rest of
-the lists are still protected by dcache_lock.  Some of the important
-changes are :
-
-1. The deletion from hash chain is done using hlist_del_rcu() macro
-   which doesn't initialize next pointer of the deleted dentry and
-   this allows us to walk safely lock-free while a deletion is
-   happening.
-
-2. Insertion of a dentry into the hash table is done using
-   hlist_add_head_rcu() which take care of ordering the writes - the
-   writes to the dentry must be visible before the dentry is
-   inserted. This works in conjunction with hlist_for_each_rcu(),
-   which has since been replaced by hlist_for_each_entry_rcu(), while
-   walking the hash chain. The only requirement is that all
-   initialization to the dentry must be done before
-   hlist_add_head_rcu() since we don't have dcache_lock protection
-   while traversing the hash chain. This isn't different from the
-   existing code.
-
-3. The dentry looked up without holding dcache_lock by cannot be
-   returned for walking if it is unhashed. It then may have a NULL
-   d_inode or other bogosity since RCU doesn't protect the other
-   fields in the dentry. We therefore use a flag DCACHE_UNHASHED to
-   indicate unhashed dentries and use this in conjunction with a
-   per-dentry lock (d_lock). Once looked up without the dcache_lock,
-   we acquire the per-dentry lock (d_lock) and check if the dentry is
-   unhashed. If so, the look-up is failed. If not, the reference count
-   of the dentry is increased and the dentry is returned.
-
-4. Once a dentry is looked up, it must be ensured during the path walk
-   for that component it doesn't go away. In pre-2.5.10 code, this was
-   done holding a reference to the dentry. dcache_rcu does the same.
-   In some sense, dcache_rcu path walking looks like the pre-2.5.10
-   version.
-
-5. All dentry hash chain updates must take the dcache_lock as well as
-   the per-dentry lock in that order. dput() does this to ensure that
-   a dentry that has just been looked up in another CPU doesn't get
-   deleted before dget() can be done on it.
-
-6. There are several ways to do reference counting of RCU protected
-   objects. One such example is in ipv4 route cache where deferred
-   freeing (using call_rcu()) is done as soon as the reference count
-   goes to zero. This cannot be done in the case of dentries because
-   tearing down of dentries require blocking (dentry_iput()) which
-   isn't supported from RCU callbacks. Instead, tearing down of
-   dentries happen synchronously in dput(), but actual freeing happens
-   later when RCU grace period is over. This allows safe lock-free
-   walking of the hash chains, but a matched dentry may have been
-   partially torn down. The checking of DCACHE_UNHASHED flag with
-   d_lock held detects such dentries and prevents them from being
-   returned from look-up.
-
-
-Maintaining POSIX rename semantics
-==================================
-
-Since look-up of dentries is lock-free, it can race against a
-concurrent rename operation. For example, during rename of file A to
-B, look-up of either A or B must succeed.  So, if look-up of B happens
-after A has been removed from the hash chain but not added to the new
-hash chain, it may fail.  Also, a comparison while the name is being
-written concurrently by a rename may result in false positive matches
-violating rename semantics.  Issues related to race with rename are
-handled as described below :
-
-1. Look-up can be done in two ways - d_lookup() which is safe from
-   simultaneous renames and __d_lookup() which is not.  If
-   __d_lookup() fails, it must be followed up by a d_lookup() to
-   correctly determine whether a dentry is in the hash table or
-   not. d_lookup() protects look-ups using a sequence lock
-   (rename_lock).
-
-2. The name associated with a dentry (d_name) may be changed if a
-   rename is allowed to happen simultaneously. To avoid memcmp() in
-   __d_lookup() go out of bounds due to a rename and false positive
-   comparison, the name comparison is done while holding the
-   per-dentry lock. This prevents concurrent renames during this
-   operation.
-
-3. Hash table walking during look-up may move to a different bucket as
-   the current dentry is moved to a different bucket due to rename.
-   But we use hlists in dcache hash table and they are
-   null-terminated.  So, even if a dentry moves to a different bucket,
-   hash chain walk will terminate. [with a list_head list, it may not
-   since termination is when the list_head in the original bucket is
-   reached].  Since we redo the d_parent check and compare name while
-   holding d_lock, lock-free look-up will not race against d_move().
-
-4. There can be a theoretical race when a dentry keeps coming back to
-   original bucket due to double moves. Due to this look-up may
-   consider that it has never moved and can end up in a infinite loop.
-   But this is not any worse that theoretical livelocks we already
-   have in the kernel.
-
-
-Important guidelines for filesystem developers related to dcache_rcu
-====================================================================
-
-1. Existing dcache interfaces (pre-2.5.62) exported to filesystem
-   don't change. Only dcache internal implementation changes. However
-   filesystems *must not* delete from the dentry hash chains directly
-   using the list macros like allowed earlier. They must use dcache
-   APIs like d_drop() or __d_drop() depending on the situation.
-
-2. d_flags is now protected by a per-dentry lock (d_lock). All access
-   to d_flags must be protected by it.
-
-3. For a hashed dentry, checking of d_count needs to be protected by
-   d_lock.
-
-
-Papers and other documentation on dcache locking
-================================================
-
-1. Scaling dcache with RCU (http://linuxjournal.com/article.php?sid=7124).
-
-2. http://lse.sourceforge.net/locking/dcache/dcache.html
-
-
-
diff --git a/Documentation/filesystems/path-lookup.txt b/Documentation/filesystems/path-lookup.txt
new file mode 100644
index 000000000000..eb59c8b44be9
--- /dev/null
+++ b/Documentation/filesystems/path-lookup.txt
@@ -0,0 +1,382 @@
+Path walking and name lookup locking
+====================================
+
+Path resolution is the finding a dentry corresponding to a path name string, by
+performing a path walk. Typically, for every open(), stat() etc., the path name
+will be resolved. Paths are resolved by walking the namespace tree, starting
+with the first component of the pathname (eg. root or cwd) with a known dentry,
+then finding the child of that dentry, which is named the next component in the
+path string. Then repeating the lookup from the child dentry and finding its
+child with the next element, and so on.
+
+Since it is a frequent operation for workloads like multiuser environments and
+web servers, it is important to optimize this code.
+
+Path walking synchronisation history:
+Prior to 2.5.10, dcache_lock was acquired in d_lookup (dcache hash lookup) and
+thus in every component during path look-up. Since 2.5.10 onwards, fast-walk
+algorithm changed this by holding the dcache_lock at the beginning and walking
+as many cached path component dentries as possible. This significantly
+decreases the number of acquisition of dcache_lock. However it also increases
+the lock hold time significantly and affects performance in large SMP machines.
+Since 2.5.62 kernel, dcache has been using a new locking model that uses RCU to
+make dcache look-up lock-free.
+
+All the above algorithms required taking a lock and reference count on the
+dentry that was looked up, so that may be used as the basis for walking the
+next path element. This is inefficient and unscalable. It is inefficient
+because of the locks and atomic operations required for every dentry element
+slows things down. It is not scalable because many parallel applications that
+are path-walk intensive tend to do path lookups starting from a common dentry
+(usually, the root "/" or current working directory). So contention on these
+common path elements causes lock and cacheline queueing.
+
+Since 2.6.38, RCU is used to make a significant part of the entire path walk
+(including dcache look-up) completely "store-free" (so, no locks, atomics, or
+even stores into cachelines of common dentries). This is known as "rcu-walk"
+path walking.
+
+Path walking overview
+=====================
+
+A name string specifies a start (root directory, cwd, fd-relative) and a
+sequence of elements (directory entry names), which together refer to a path in
+the namespace. A path is represented as a (dentry, vfsmount) tuple. The name
+elements are sub-strings, seperated by '/'.
+
+Name lookups will want to find a particular path that a name string refers to
+(usually the final element, or parent of final element). This is done by taking
+the path given by the name's starting point (which we know in advance -- eg.
+current->fs->cwd or current->fs->root) as the first parent of the lookup. Then
+iteratively for each subsequent name element, look up the child of the current
+parent with the given name and if it is not the desired entry, make it the
+parent for the next lookup.
+
+A parent, of course, must be a directory, and we must have appropriate
+permissions on the parent inode to be able to walk into it.
+
+Turning the child into a parent for the next lookup requires more checks and
+procedures. Symlinks essentially substitute the symlink name for the target
+name in the name string, and require some recursive path walking.  Mount points
+must be followed into (thus changing the vfsmount that subsequent path elements
+refer to), switching from the mount point path to the root of the particular
+mounted vfsmount. These behaviours are variously modified depending on the
+exact path walking flags.
+
+Path walking then must, broadly, do several particular things:
+- find the start point of the walk;
+- perform permissions and validity checks on inodes;
+- perform dcache hash name lookups on (parent, name element) tuples;
+- traverse mount points;
+- traverse symlinks;
+- lookup and create missing parts of the path on demand.
+
+Safe store-free look-up of dcache hash table
+============================================
+
+Dcache name lookup
+------------------
+In order to lookup a dcache (parent, name) tuple, we take a hash on the tuple
+and use that to select a bucket in the dcache-hash table. The list of entries
+in that bucket is then walked, and we do a full comparison of each entry
+against our (parent, name) tuple.
+
+The hash lists are RCU protected, so list walking is not serialised with
+concurrent updates (insertion, deletion from the hash). This is a standard RCU
+list application with the exception of renames, which will be covered below.
+
+Parent and name members of a dentry, as well as its membership in the dcache
+hash, and its inode are protected by the per-dentry d_lock spinlock. A
+reference is taken on the dentry (while the fields are verified under d_lock),
+and this stabilises its d_inode pointer and actual inode. This gives a stable
+point to perform the next step of our path walk against.
+
+These members are also protected by d_seq seqlock, although this offers
+read-only protection and no durability of results, so care must be taken when
+using d_seq for synchronisation (see seqcount based lookups, below).
+
+Renames
+-------
+Back to the rename case. In usual RCU protected lists, the only operations that
+will happen to an object is insertion, and then eventually removal from the
+list. The object will not be reused until an RCU grace period is complete.
+This ensures the RCU list traversal primitives can run over the object without
+problems (see RCU documentation for how this works).
+
+However when a dentry is renamed, its hash value can change, requiring it to be
+moved to a new hash list. Allocating and inserting a new alias would be
+expensive and also problematic for directory dentries. Latency would be far to
+high to wait for a grace period after removing the dentry and before inserting
+it in the new hash bucket. So what is done is to insert the dentry into the
+new list immediately.
+
+However, when the dentry's list pointers are updated to point to objects in the
+new list before waiting for a grace period, this can result in a concurrent RCU
+lookup of the old list veering off into the new (incorrect) list and missing
+the remaining dentries on the list.
+
+There is no fundamental problem with walking down the wrong list, because the
+dentry comparisons will never match. However it is fatal to miss a matching
+dentry. So a seqlock is used to detect when a rename has occurred, and so the
+lookup can be retried.
+
+         1      2      3
+        +---+  +---+  +---+
+hlist-->| N-+->| N-+->| N-+->
+head <--+-P |<-+-P |<-+-P |
+        +---+  +---+  +---+
+
+Rename of dentry 2 may require it deleted from the above list, and inserted
+into a new list. Deleting 2 gives the following list.
+
+         1             3
+        +---+         +---+     (don't worry, the longer pointers do not
+hlist-->| N-+-------->| N-+->    impose a measurable performance overhead
+head <--+-P |<--------+-P |      on modern CPUs)
+        +---+         +---+
+          ^      2      ^
+          |    +---+    |
+          |    | N-+----+
+          +----+-P |
+               +---+
+
+This is a standard RCU-list deletion, which leaves the deleted object's
+pointers intact, so a concurrent list walker that is currently looking at
+object 2 will correctly continue to object 3 when it is time to traverse the
+next object.
+
+However, when inserting object 2 onto a new list, we end up with this:
+
+         1             3
+        +---+         +---+
+hlist-->| N-+-------->| N-+->
+head <--+-P |<--------+-P |
+        +---+         +---+
+                 2
+               +---+
+               | N-+---->
+          <----+-P |
+               +---+
+
+Because we didn't wait for a grace period, there may be a concurrent lookup
+still at 2. Now when it follows 2's 'next' pointer, it will walk off into
+another list without ever having checked object 3.
+
+A related, but distinctly different, issue is that of rename atomicity versus
+lookup operations. If a file is renamed from 'A' to 'B', a lookup must only
+find either 'A' or 'B'. So if a lookup of 'A' returns NULL, a subsequent lookup
+of 'B' must succeed (note the reverse is not true).
+
+Between deleting the dentry from the old hash list, and inserting it on the new
+hash list, a lookup may find neither 'A' nor 'B' matching the dentry. The same
+rename seqlock is also used to cover this race in much the same way, by
+retrying a negative lookup result if a rename was in progress.
+
+Seqcount based lookups
+----------------------
+In refcount based dcache lookups, d_lock is used to serialise access to
+the dentry, stabilising it while comparing its name and parent and then
+taking a reference count (the reference count then gives a stable place to
+start the next part of the path walk from).
+
+As explained above, we would like to do path walking without taking locks or
+reference counts on intermediate dentries along the path. To do this, a per
+dentry seqlock (d_seq) is used to take a "coherent snapshot" of what the dentry
+looks like (its name, parent, and inode). That snapshot is then used to start
+the next part of the path walk. When loading the coherent snapshot under d_seq,
+care must be taken to load the members up-front, and use those pointers rather
+than reloading from the dentry later on (otherwise we'd have interesting things
+like d_inode going NULL underneath us, if the name was unlinked).
+
+Also important is to avoid performing any destructive operations (pretty much:
+no non-atomic stores to shared data), and to recheck the seqcount when we are
+"done" with the operation. Retry or abort if the seqcount does not match.
+Avoiding destructive or changing operations means we can easily unwind from
+failure.
+
+What this means is that a caller, provided they are holding RCU lock to
+protect the dentry object from disappearing, can perform a seqcount based
+lookup which does not increment the refcount on the dentry or write to
+it in any way. This returned dentry can be used for subsequent operations,
+provided that d_seq is rechecked after that operation is complete.
+
+Inodes are also rcu freed, so the seqcount lookup dentry's inode may also be
+queried for permissions.
+
+With this two parts of the puzzle, we can do path lookups without taking
+locks or refcounts on dentry elements.
+
+RCU-walk path walking design
+============================
+
+Path walking code now has two distinct modes, ref-walk and rcu-walk. ref-walk
+is the traditional[*] way of performing dcache lookups using d_lock to
+serialise concurrent modifications to the dentry and take a reference count on
+it. ref-walk is simple and obvious, and may sleep, take locks, etc while path
+walking is operating on each dentry. rcu-walk uses seqcount based dentry
+lookups, and can perform lookup of intermediate elements without any stores to
+shared data in the dentry or inode. rcu-walk can not be applied to all cases,
+eg. if the filesystem must sleep or perform non trivial operations, rcu-walk
+must be switched to ref-walk mode.
+
+[*] RCU is still used for the dentry hash lookup in ref-walk, but not the full
+    path walk.
+
+Where ref-walk uses a stable, refcounted ``parent'' to walk the remaining
+path string, rcu-walk uses a d_seq protected snapshot. When looking up a
+child of this parent snapshot, we open d_seq critical section on the child
+before closing d_seq critical section on the parent. This gives an interlocking
+ladder of snapshots to walk down.
+
+
+     proc 101
+      /----------------\
+     / comm:    "vi"    \
+    /  fs.root: dentry0  \
+    \  fs.cwd:  dentry2  /
+     \                  /
+      \----------------/
+
+So when vi wants to open("/home/npiggin/test.c", O_RDWR), then it will
+start from current->fs->root, which is a pinned dentry. Alternatively,
+"./test.c" would start from cwd; both names refer to the same path in
+the context of proc101.
+
+     dentry 0
+    +---------------------+   rcu-walk begins here, we note d_seq, check the
+    | name:    "/"        |   inode's permission, and then look up the next
+    | inode:   10         |   path element which is "home"...
+    | children:"home", ...|
+    +---------------------+
+              |
+     dentry 1 V
+    +---------------------+   ... which brings us here. We find dentry1 via
+    | name:    "home"     |   hash lookup, then note d_seq and compare name
+    | inode:   678        |   string and parent pointer. When we have a match,
+    | children:"npiggin"  |   we now recheck the d_seq of dentry0. Then we
+    +---------------------+   check inode and look up the next element.
+              |
+     dentry2  V
+    +---------------------+   Note: if dentry0 is now modified, lookup is
+    | name:    "npiggin"  |   not necessarily invalid, so we need only keep a
+    | inode:   543        |   parent for d_seq verification, and grandparents
+    | children:"a.c", ... |   can be forgotten.
+    +---------------------+
+              |
+     dentry3  V
+    +---------------------+   At this point we have our destination dentry.
+    | name:    "a.c"      |   We now take its d_lock, verify d_seq of this
+    | inode:   14221      |   dentry. If that checks out, we can increment
+    | children:NULL       |   its refcount because we're holding d_lock.
+    +---------------------+
+
+Taking a refcount on a dentry from rcu-walk mode, by taking its d_lock,
+re-checking its d_seq, and then incrementing its refcount is called
+"dropping rcu" or dropping from rcu-walk into ref-walk mode.
+
+It is, in some sense, a bit of a house of cards. If the seqcount check of the
+parent snapshot fails, the house comes down, because we had closed the d_seq
+section on the grandparent, so we have nothing left to stand on. In that case,
+the path walk must be fully restarted (which we do in ref-walk mode, to avoid
+live locks). It is costly to have a full restart, but fortunately they are
+quite rare.
+
+When we reach a point where sleeping is required, or a filesystem callout
+requires ref-walk, then instead of restarting the walk, we attempt to drop rcu
+at the last known good dentry we have. Avoiding a full restart in ref-walk in
+these cases is fundamental for performance and scalability because blocking
+operations such as creates and unlinks are not uncommon.
+
+The detailed design for rcu-walk is like this:
+* LOOKUP_RCU is set in nd->flags, which distinguishes rcu-walk from ref-walk.
+* Take the RCU lock for the entire path walk, starting with the acquiring
+  of the starting path (eg. root/cwd/fd-path). So now dentry refcounts are
+  not required for dentry persistence.
+* synchronize_rcu is called when unregistering a filesystem, so we can
+  access d_ops and i_ops during rcu-walk.
+* Similarly take the vfsmount lock for the entire path walk. So now mnt
+  refcounts are not required for persistence. Also we are free to perform mount
+  lookups, and to assume dentry mount points and mount roots are stable up and
+  down the path.
+* Have a per-dentry seqlock to protect the dentry name, parent, and inode,
+  so we can load this tuple atomically, and also check whether any of its
+  members have changed.
+* Dentry lookups (based on parent, candidate string tuple) recheck the parent
+  sequence after the child is found in case anything changed in the parent
+  during the path walk.
+* inode is also RCU protected so we can load d_inode and use the inode for
+  limited things.
+* i_mode, i_uid, i_gid can be tested for exec permissions during path walk.
+* i_op can be loaded.
+* When the destination dentry is reached, drop rcu there (ie. take d_lock,
+  verify d_seq, increment refcount).
+* If seqlock verification fails anywhere along the path, do a full restart
+  of the path lookup in ref-walk mode. -ECHILD tends to be used (for want of
+  a better errno) to signal an rcu-walk failure.
+
+The cases where rcu-walk cannot continue are:
+* NULL dentry (ie. any uncached path element)
+* Following links
+
+It may be possible eventually to make following links rcu-walk aware.
+
+Uncached path elements will always require dropping to ref-walk mode, at the
+very least because i_mutex needs to be grabbed, and objects allocated.
+
+Final note:
+"store-free" path walking is not strictly store free. We take vfsmount lock
+and refcounts (both of which can be made per-cpu), and we also store to the
+stack (which is essentially CPU-local), and we also have to take locks and
+refcount on final dentry.
+
+The point is that shared data, where practically possible, is not locked
+or stored into. The result is massive improvements in performance and
+scalability of path resolution.
+
+
+Interesting statistics
+======================
+
+The following table gives rcu lookup statistics for a few simple workloads
+(2s12c24t Westmere, debian non-graphical system). Ungraceful are attempts to
+drop rcu that fail due to d_seq failure and requiring the entire path lookup
+again. Other cases are successful rcu-drops that are required before the final
+element, nodentry for missing dentry, revalidate for filesystem revalidate
+routine requiring rcu drop, permission for permission check requiring drop,
+and link for symlink traversal requiring drop.
+
+     rcu-lookups     restart  nodentry          link  revalidate  permission
+bootup     47121           0      4624          1010       10283        7852
+dbench  25386793           0   6778659(26.7%)     55         549        1156
+kbuild   2696672          10     64442(2.3%)  108764(4.0%)     1        1590
+git diff   39605           0        28             2           0         106
+vfstest 24185492        4945    708725(2.9%) 1076136(4.4%)     0        2651
+
+What this shows is that failed rcu-walk lookups, ie. ones that are restarted
+entirely with ref-walk, are quite rare. Even the "vfstest" case which
+specifically has concurrent renames/mkdir/rmdir/ creat/unlink/etc to excercise
+such races is not showing a huge amount of restarts.
+
+Dropping from rcu-walk to ref-walk mean that we have encountered a dentry where
+the reference count needs to be taken for some reason. This is either because
+we have reached the target of the path walk, or because we have encountered a
+condition that can't be resolved in rcu-walk mode.  Ideally, we drop rcu-walk
+only when we have reached the target dentry, so the other statistics show where
+this does not happen.
+
+Note that a graceful drop from rcu-walk mode due to something such as the
+dentry not existing (which can be common) is not necessarily a failure of
+rcu-walk scheme, because some elements of the path may have been walked in
+rcu-walk mode. The further we get from common path elements (such as cwd or
+root), the less contended the dentry is likely to be. The closer we are to
+common path elements, the more likely they will exist in dentry cache.
+
+
+Papers and other documentation on dcache locking
+================================================
+
+1. Scaling dcache with RCU (http://linuxjournal.com/article.php?sid=7124).
+
+2. http://lse.sourceforge.net/locking/dcache/dcache.html
+
+
diff --git a/Documentation/filesystems/porting b/Documentation/filesystems/porting
index b12c89538680..07a32b42cf9c 100644
--- a/Documentation/filesystems/porting
+++ b/Documentation/filesystems/porting
@@ -216,7 +216,6 @@ had ->revalidate()) add calls in ->follow_link()/->readlink().
 ->d_parent changes are not protected by BKL anymore.  Read access is safe
 if at least one of the following is true:
         * filesystem has no cross-directory rename()
-        * dcache_lock is held
         * we know that parent had been locked (e.g. we are looking at
 ->d_parent of ->lookup() argument).
         * we are called from ->rename().
@@ -318,3 +317,71 @@ if it's zero is not *and* *never* *had* *been* enough.  Final unlink() and iput(
 may happen while the inode is in the middle of ->write_inode(); e.g. if you blindly
 free the on-disk inode, you may end up doing that while ->write_inode() is writing
 to it.
+
+---
+[mandatory]
+
+        .d_delete() now only advises the dcache as to whether or not to cache
+unreferenced dentries, and is now only called when the dentry refcount goes to
+0. Even on 0 refcount transition, it must be able to tolerate being called 0,
+1, or more times (eg. constant, idempotent).
+
+---
+[mandatory]
+
+        .d_compare() calling convention and locking rules are significantly
+changed. Read updated documentation in Documentation/filesystems/vfs.txt (and
+look at examples of other filesystems) for guidance.
+
+---
+[mandatory]
+
+        .d_hash() calling convention and locking rules are significantly
+changed. Read updated documentation in Documentation/filesystems/vfs.txt (and
+look at examples of other filesystems) for guidance.
+
+---
+[mandatory]
+        dcache_lock is gone, replaced by fine grained locks. See fs/dcache.c
+for details of what locks to replace dcache_lock with in order to protect
+particular things. Most of the time, a filesystem only needs ->d_lock, which
+protects *all* the dcache state of a given dentry.
+
+--
+[mandatory]
+
+        Filesystems must RCU-free their inodes, if they can have been accessed
+via rcu-walk path walk (basically, if the file can have had a path name in the
+vfs namespace).
+
+        i_dentry and i_rcu share storage in a union, and the vfs expects
+i_dentry to be reinitialized before it is freed, so an:
+
+  INIT_LIST_HEAD(&inode->i_dentry);
+
+must be done in the RCU callback.
+
+--
+[recommended]
+        vfs now tries to do path walking in "rcu-walk mode", which avoids
+atomic operations and scalability hazards on dentries and inodes (see
+Documentation/filesystems/path-walk.txt). d_hash and d_compare changes (above)
+are examples of the changes required to support this. For more complex
+filesystem callbacks, the vfs drops out of rcu-walk mode before the fs call, so
+no changes are required to the filesystem. However, this is costly and loses
+the benefits of rcu-walk mode. We will begin to add filesystem callbacks that
+are rcu-walk aware, shown below. Filesystems should take advantage of this
+where possible.
+
+--
+[mandatory]
+        d_revalidate is a callback that is made on every path element (if
+the filesystem provides it), which requires dropping out of rcu-walk mode. This
+may now be called in rcu-walk mode (nd->flags & LOOKUP_RCU). -ECHILD should be
+returned if the filesystem cannot handle rcu-walk. See
+Documentation/filesystems/vfs.txt for more details.
+
+        permission and check_acl are inode permission checks that are called
+on many or all directory inodes on the way down a path walk (to check for
+exec permission). These must now be rcu-walk aware (flags & IPERM_RCU). See
+Documentation/filesystems/vfs.txt for more details.
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 20899e095e7e..fbb324e2bd43 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -325,7 +325,8 @@ struct inode_operations {
         void * (*follow_link) (struct dentry *, struct nameidata *);
         void (*put_link) (struct dentry *, struct nameidata *, void *);
         void (*truncate) (struct inode *);
-        int (*permission) (struct inode *, int, struct nameidata *);
+        int (*permission) (struct inode *, int, unsigned int);
+        int (*check_acl)(struct inode *, int, unsigned int);
         int (*setattr) (struct dentry *, struct iattr *);
         int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
         int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
@@ -414,6 +415,13 @@ otherwise noted.
   permission: called by the VFS to check for access rights on a POSIX-like
         filesystem.
 
+        May be called in rcu-walk mode (flags & IPERM_RCU). If in rcu-walk
+        mode, the filesystem must check the permission without blocking or
+        storing to the inode.
+
+        If a situation is encountered that rcu-walk cannot handle, return
+        -ECHILD and it will be called again in ref-walk mode.
+
   setattr: called by the VFS to set attributes for a file. This method
         is called by chmod(2) and related system calls.
 
@@ -847,9 +855,12 @@ defined:
 
 struct dentry_operations {
         int (*d_revalidate)(struct dentry *, struct nameidata *);
-        int (*d_hash) (struct dentry *, struct qstr *);
-        int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
-        int (*d_delete)(struct dentry *);
+        int (*d_hash)(const struct dentry *, const struct inode *,
+                        struct qstr *);
+        int (*d_compare)(const struct dentry *, const struct inode *,
+                        const struct dentry *, const struct inode *,
+                        unsigned int, const char *, const struct qstr *);
+        int (*d_delete)(const struct dentry *);
         void (*d_release)(struct dentry *);
         void (*d_iput)(struct dentry *, struct inode *);
         char *(*d_dname)(struct dentry *, char *, int);
@@ -860,13 +871,45 @@ struct dentry_operations {
         dcache. Most filesystems leave this as NULL, because all their
         dentries in the dcache are valid
 
-  d_hash: called when the VFS adds a dentry to the hash table
+        d_revalidate may be called in rcu-walk mode (nd->flags & LOOKUP_RCU).
+        If in rcu-walk mode, the filesystem must revalidate the dentry without
+        blocking or storing to the dentry, d_parent and d_inode should not be
+        used without care (because they can go NULL), instead nd->inode should
+        be used.
+
+        If a situation is encountered that rcu-walk cannot handle, return
+        -ECHILD and it will be called again in ref-walk mode.
+
+  d_hash: called when the VFS adds a dentry to the hash table. The first
+        dentry passed to d_hash is the parent directory that the name is
+        to be hashed into. The inode is the dentry's inode.
+
+        Same locking and synchronisation rules as d_compare regarding
+        what is safe to dereference etc.
+
+  d_compare: called to compare a dentry name with a given name. The first
+        dentry is the parent of the dentry to be compared, the second is
+        the parent's inode, then the dentry and inode (may be NULL) of the
+        child dentry. len and name string are properties of the dentry to be
+        compared. qstr is the name to compare it with.
+
+        Must be constant and idempotent, and should not take locks if
+        possible, and should not or store into the dentry or inodes.
+        Should not dereference pointers outside the dentry or inodes without
+        lots of care (eg.  d_parent, d_inode, d_name should not be used).
+
+        However, our vfsmount is pinned, and RCU held, so the dentries and
+        inodes won't disappear, neither will our sb or filesystem module.
+        ->i_sb and ->d_sb may be used.
 
-  d_compare: called when a dentry should be compared with another
+        It is a tricky calling convention because it needs to be called under
+        "rcu-walk", ie. without any locks or references on things.
 
-  d_delete: called when the last reference to a dentry is
-        deleted. This means no-one is using the dentry, however it is
-        still valid and in the dcache
+  d_delete: called when the last reference to a dentry is dropped and the
+        dcache is deciding whether or not to cache it. Return 1 to delete
+        immediately, or 0 to cache the dentry. Default is NULL which means to
+        always cache a reachable dentry. d_delete must be constant and
+        idempotent.
 
   d_release: called when a dentry is really deallocated
 
@@ -910,14 +953,11 @@ manipulate dentries:
         the usage count)
 
   dput: close a handle for a dentry (decrements the usage count). If
-        the usage count drops to 0, the "d_delete" method is called
-        and the dentry is placed on the unused list if the dentry is
-        still in its parents hash list. Putting the dentry on the
-        unused list just means that if the system needs some RAM, it
-        goes through the unused list of dentries and deallocates them.
-        If the dentry has already been unhashed and the usage count
-        drops to 0, in this case the dentry is deallocated after the
-        "d_delete" method is called
+        the usage count drops to 0, and the dentry is still in its
+        parent's hash, the "d_delete" method is called to check whether
+        it should be cached. If it should not be cached, or if the dentry
+        is not hashed, it is deleted. Otherwise cached dentries are put
+        into an LRU list to be reclaimed on memory shortage.
 
   d_drop: this unhashes a dentry from its parents hash list. A
         subsequent call to dput() will deallocate the dentry if its
diff --git a/Documentation/scsi/ChangeLog.megaraid_sas b/Documentation/scsi/ChangeLog.megaraid_sas
index 00301ed9c371..b64d10d221ec 100644
--- a/Documentation/scsi/ChangeLog.megaraid_sas
+++ b/Documentation/scsi/ChangeLog.megaraid_sas
@@ -1,3 +1,25 @@
+Release Date    : Tues.  Dec 14, 2010 17:00:00 PST 2010 -
+                        (emaild-id:megaraidlinux@lsi.com)
+                        Adam Radford
+Current Version : 00.00.05.29-rc1
+Old Version     : 00.00.04.31-rc1
+    1. Rename megaraid_sas.c to megaraid_sas_base.c.
+    2. Update GPL headers.
+    3. Add MSI-X support and 'msix_disable' module parameter.
+    4. Use lowest memory bar (for SR-IOV VF support).
+    5. Add struct megasas_instance_temlate changes, and change all code to use
+       new instance entries:
+
+       irqreturn_t (*service_isr )(int irq, void *devp);
+       void (*tasklet)(unsigned long);
+       u32 (*init_adapter)(struct megasas_instance *);
+       u32 (*build_and_issue_cmd) (struct megasas_instance *,
+       struct scsi_cmnd *);
+       void (*issue_dcmd) (struct megasas_instance *instance,
+                              struct megasas_cmd *cmd);
+
+   6. Add code to support MegaRAID 9265/9285 controllers device id (0x5b).
+-------------------------------------------------------------------------------
 1 Release Date    : Thur.  May 03, 2010 09:12:45 PST 2009 -
                         (emaild-id:megaraidlinux@lsi.com)
                         Bo Yang
diff --git a/Documentation/usb/power-management.txt b/Documentation/usb/power-management.txt
index b29d8e56cf28..c9ffa9ced7ee 100644
--- a/Documentation/usb/power-management.txt
+++ b/Documentation/usb/power-management.txt
@@ -2,7 +2,7 @@
 
                  Alan Stern <stern@rowland.harvard.edu>
 
-                            December 11, 2009
+                            October 28, 2010
 
 
 
@@ -107,9 +107,14 @@ allowed to issue dynamic suspends.
 The user interface for controlling dynamic PM is located in the power/
 subdirectory of each USB device's sysfs directory, that is, in
 /sys/bus/usb/devices/.../power/ where "..." is the device's ID.  The
-relevant attribute files are: wakeup, control, and autosuspend.
-(There may also be a file named "level"; this file was deprecated
-as of the 2.6.35 kernel and replaced by the "control" file.)
+relevant attribute files are: wakeup, control, and
+autosuspend_delay_ms.  (There may also be a file named "level"; this
+file was deprecated as of the 2.6.35 kernel and replaced by the
+"control" file.  In 2.6.38 the "autosuspend" file will be deprecated
+and replaced by the "autosuspend_delay_ms" file.  The only difference
+is that the newer file expresses the delay in milliseconds whereas the
+older file uses seconds.  Confusingly, both files are present in 2.6.37
+but only "autosuspend" works.)
 
         power/wakeup
 
@@ -140,33 +145,36 @@ as of the 2.6.35 kernel and replaced by the "control" file.)
                 suspended and autoresume was not allowed.  This
                 setting is no longer supported.)
 
-        power/autosuspend
+        power/autosuspend_delay_ms
 
                 This file contains an integer value, which is the
-                number of seconds the device should remain idle before
-                the kernel will autosuspend it (the idle-delay time).
-                The default is 2.  0 means to autosuspend as soon as
-                the device becomes idle, and negative values mean
-                never to autosuspend.  You can write a number to the
-                file to change the autosuspend idle-delay time.
-
-Writing "-1" to power/autosuspend and writing "on" to power/control do
-essentially the same thing -- they both prevent the device from being
-autosuspended.  Yes, this is a redundancy in the API.
+                number of milliseconds the device should remain idle
+                before the kernel will autosuspend it (the idle-delay
+                time).  The default is 2000.  0 means to autosuspend
+                as soon as the device becomes idle, and negative
+                values mean never to autosuspend.  You can write a
+                number to the file to change the autosuspend
+                idle-delay time.
+
+Writing "-1" to power/autosuspend_delay_ms and writing "on" to
+power/control do essentially the same thing -- they both prevent the
+device from being autosuspended.  Yes, this is a redundancy in the
+API.
 
 (In 2.6.21 writing "0" to power/autosuspend would prevent the device
 from being autosuspended; the behavior was changed in 2.6.22.  The
 power/autosuspend attribute did not exist prior to 2.6.21, and the
 power/level attribute did not exist prior to 2.6.22.  power/control
-was added in 2.6.34.)
+was added in 2.6.34, and power/autosuspend_delay_ms was added in
+2.6.37 but did not become functional until 2.6.38.)
 
 
         Changing the default idle-delay time
         ------------------------------------
 
-The default autosuspend idle-delay time is controlled by a module
-parameter in usbcore.  You can specify the value when usbcore is
-loaded.  For example, to set it to 5 seconds instead of 2 you would
+The default autosuspend idle-delay time (in seconds) is controlled by
+a module parameter in usbcore.  You can specify the value when usbcore
+is loaded.  For example, to set it to 5 seconds instead of 2 you would
 do:
 
         modprobe usbcore autosuspend=5
@@ -234,25 +242,23 @@ every device.
 
 If a driver knows that its device has proper suspend/resume support,
 it can enable autosuspend all by itself.  For example, the video
-driver for a laptop's webcam might do this, since these devices are
-rarely used and so should normally be autosuspended.
+driver for a laptop's webcam might do this (in recent kernels they
+do), since these devices are rarely used and so should normally be
+autosuspended.
 
 Sometimes it turns out that even when a device does work okay with
-autosuspend there are still problems.  For example, there are
-experimental patches adding autosuspend support to the usbhid driver,
-which manages keyboards and mice, among other things.  Tests with a
-number of keyboards showed that typing on a suspended keyboard, while
-causing the keyboard to do a remote wakeup all right, would
-nonetheless frequently result in lost keystrokes.  Tests with mice
-showed that some of them would issue a remote-wakeup request in
-response to button presses but not to motion, and some in response to
-neither.
+autosuspend there are still problems.  For example, the usbhid driver,
+which manages keyboards and mice, has autosuspend support.  Tests with
+a number of keyboards show that typing on a suspended keyboard, while
+causing the keyboard to do a remote wakeup all right, will nonetheless
+frequently result in lost keystrokes.  Tests with mice show that some
+of them will issue a remote-wakeup request in response to button
+presses but not to motion, and some in response to neither.
 
 The kernel will not prevent you from enabling autosuspend on devices
 that can't handle it.  It is even possible in theory to damage a
-device by suspending it at the wrong time -- for example, suspending a
-USB hard disk might cause it to spin down without parking the heads.
-(Highly unlikely, but possible.)  Take care.
+device by suspending it at the wrong time.  (Highly unlikely, but
+possible.)  Take care.
 
 
         The driver interface for Power Management
@@ -336,10 +342,6 @@ autosuspend the interface's device.  When the usage counter is = 0
 then the interface is considered to be idle, and the kernel may
 autosuspend the device.
 
-(There is a similar usage counter field in struct usb_device,
-associated with the device itself rather than any of its interfaces.
-This counter is used only by the USB core.)
-
 Drivers need not be concerned about balancing changes to the usage
 counter; the USB core will undo any remaining "get"s when a driver
 is unbound from its interface.  As a corollary, drivers must not call
@@ -409,11 +411,11 @@ during autosuspend.  For example, there's not much point
 autosuspending a keyboard if the user can't cause the keyboard to do a
 remote wakeup by typing on it.  If the driver sets
 intf->needs_remote_wakeup to 1, the kernel won't autosuspend the
-device if remote wakeup isn't available or has been disabled through
-the power/wakeup attribute.  (If the device is already autosuspended,
-though, setting this flag won't cause the kernel to autoresume it.
-Normally a driver would set this flag in its probe method, at which
-time the device is guaranteed not to be autosuspended.)
+device if remote wakeup isn't available.  (If the device is already
+autosuspended, though, setting this flag won't cause the kernel to
+autoresume it.  Normally a driver would set this flag in its probe
+method, at which time the device is guaranteed not to be
+autosuspended.)
 
 If a driver does its I/O asynchronously in interrupt context, it
 should call usb_autopm_get_interface_async() before starting output and
@@ -422,20 +424,19 @@ it receives an input event, it should call
 
         usb_mark_last_busy(struct usb_device *udev);
 
-in the event handler.  This sets udev->last_busy to the current time.
-udev->last_busy is the field used for idle-delay calculations;
-updating it will cause any pending autosuspend to be moved back.  Most
-of the usb_autopm_* routines will also set the last_busy field to the
-current time.
+in the event handler.  This tells the PM core that the device was just
+busy and therefore the next autosuspend idle-delay expiration should
+be pushed back.  Many of the usb_autopm_* routines also make this call,
+so drivers need to worry only when interrupt-driven input arrives.
 
 Asynchronous operation is always subject to races.  For example, a
-driver may call one of the usb_autopm_*_interface_async() routines at
-a time when the core has just finished deciding the device has been
-idle for long enough but not yet gotten around to calling the driver's
-suspend method.  The suspend method must be responsible for
-synchronizing with the output request routine and the URB completion
-handler; it should cause autosuspends to fail with -EBUSY if the
-driver needs to use the device.
+driver may call the usb_autopm_get_interface_async() routine at a time
+when the core has just finished deciding the device has been idle for
+long enough but not yet gotten around to calling the driver's suspend
+method.  The suspend method must be responsible for synchronizing with
+the I/O request routine and the URB completion handler; it should
+cause autosuspends to fail with -EBUSY if the driver needs to use the
+device.
 
 External suspend calls should never be allowed to fail in this way,
 only autosuspend calls.  The driver can tell them apart by checking
@@ -472,7 +473,9 @@ Firstly, a device may already be autosuspended when a system suspend
 occurs.  Since system suspends are supposed to be as transparent as
 possible, the device should remain suspended following the system
 resume.  But this theory may not work out well in practice; over time
-the kernel's behavior in this regard has changed.
+the kernel's behavior in this regard has changed.  As of 2.6.37 the
+policy is to resume all devices during a system resume and let them
+handle their own runtime suspends afterward.
 
 Secondly, a dynamic power-management event may occur as a system
 suspend is underway.  The window for this is short, since system
diff --git a/arch/arm/mach-davinci/usb.c b/arch/arm/mach-davinci/usb.c
index 31f0cbea0caa..23d2b6d9fa63 100644
--- a/arch/arm/mach-davinci/usb.c
+++ b/arch/arm/mach-davinci/usb.c
@@ -64,17 +64,19 @@ static struct resource usb_resources[] = {
         {
                 .start          = IRQ_USBINT,
                 .flags          = IORESOURCE_IRQ,
+                .name           = "mc"
         },
         {
                 /* placeholder for the dedicated CPPI IRQ */
                 .flags          = IORESOURCE_IRQ,
+                .name           = "dma"
         },
 };
 
 static u64 usb_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device usb_dev = {
-        .name           = "musb_hdrc",
+        .name           = "musb-davinci",
         .id             = -1,
         .dev = {
                 .platform_data          = &usb_data,
@@ -110,6 +112,7 @@ static struct resource da8xx_usb20_resources[] = {
         {
                 .start          = IRQ_DA8XX_USB_INT,
                 .flags          = IORESOURCE_IRQ,
+                .name           = "mc",
         },
 };
 
@@ -121,6 +124,7 @@ int __init da8xx_register_usb20(unsigned mA, unsigned potpgt)
 
         usb_dev.resource = da8xx_usb20_resources;
         usb_dev.num_resources = ARRAY_SIZE(da8xx_usb20_resources);
+        usb_dev.name = "musb-da8xx";
 
         return platform_device_register(&usb_dev);
 }
diff --git a/arch/arm/mach-omap2/Kconfig b/arch/arm/mach-omap2/Kconfig
index 3e8c9e859f98..1a2cf6226a55 100644
--- a/arch/arm/mach-omap2/Kconfig
+++ b/arch/arm/mach-omap2/Kconfig
@@ -48,6 +48,7 @@ config ARCH_OMAP4
         select ARM_ERRATA_720789
         select ARCH_HAS_OPP
         select PM_OPP if PM
+        select USB_ARCH_HAS_EHCI
 
 comment "OMAP Core Type"
         depends on ARCH_OMAP2
diff --git a/arch/arm/mach-omap2/Makefile b/arch/arm/mach-omap2/Makefile
index 4ab82f6f15b1..cd7332f50b2d 100644
--- a/arch/arm/mach-omap2/Makefile
+++ b/arch/arm/mach-omap2/Makefile
@@ -209,9 +209,11 @@ obj-$(CONFIG_MACH_IGEP0030)		+= board-igep0030.o \
 obj-$(CONFIG_MACH_OMAP3_TOUCHBOOK)      += board-omap3touchbook.o \
                                            hsmmc.o
 obj-$(CONFIG_MACH_OMAP_4430SDP)         += board-4430sdp.o \
-                                           hsmmc.o
+                                           hsmmc.o \
+                                           omap_phy_internal.o
 obj-$(CONFIG_MACH_OMAP4_PANDA)          += board-omap4panda.o \
-                                           hsmmc.o
+                                           hsmmc.o \
+                                           omap_phy_internal.o
 
 obj-$(CONFIG_MACH_OMAP3517EVM)          += board-am3517evm.o
 
diff --git a/arch/arm/mach-omap2/board-4430sdp.c b/arch/arm/mach-omap2/board-4430sdp.c
index 1cb208b6e626..a70bdf28e2bc 100644
--- a/arch/arm/mach-omap2/board-4430sdp.c
+++ b/arch/arm/mach-omap2/board-4430sdp.c
@@ -44,6 +44,7 @@
 #define ETH_KS8851_IRQ                  34
 #define ETH_KS8851_POWER_ON             48
 #define ETH_KS8851_QUART                138
+#define OMAP4SDP_MDM_PWR_EN_GPIO        157
 #define OMAP4_SFH7741_SENSOR_OUTPUT_GPIO        184
 #define OMAP4_SFH7741_ENABLE_GPIO               188
 
@@ -250,12 +251,29 @@ static void __init omap_4430sdp_init_irq(void)
         gic_init_irq();
 }
 
+static const struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+        .port_mode[0]   = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1]   = EHCI_HCD_OMAP_MODE_UNKNOWN,
+        .port_mode[2]   = EHCI_HCD_OMAP_MODE_UNKNOWN,
+        .phy_reset      = false,
+        .reset_gpio_port[0]  = -EINVAL,
+        .reset_gpio_port[1]  = -EINVAL,
+        .reset_gpio_port[2]  = -EINVAL,
+};
+
 static struct omap_musb_board_data musb_board_data = {
         .interface_type         = MUSB_INTERFACE_UTMI,
-        .mode                   = MUSB_PERIPHERAL,
+        .mode                   = MUSB_OTG,
         .power                  = 100,
 };
 
+static struct twl4030_usb_data omap4_usbphy_data = {
+        .phy_init       = omap4430_phy_init,
+        .phy_exit       = omap4430_phy_exit,
+        .phy_power      = omap4430_phy_power,
+        .phy_set_clock  = omap4430_phy_set_clk,
+};
+
 static struct omap2_hsmmc_info mmc[] = {
         {
                 .mmc            = 1,
@@ -475,6 +493,7 @@ static struct twl4030_platform_data sdp4430_twldata = {
         .vaux1          = &sdp4430_vaux1,
         .vaux2          = &sdp4430_vaux2,
         .vaux3          = &sdp4430_vaux3,
+        .usb            = &omap4_usbphy_data
 };
 
 static struct i2c_board_info __initdata sdp4430_i2c_boardinfo[] = {
@@ -555,11 +574,15 @@ static void __init omap_4430sdp_init(void)
         platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
         omap_serial_init();
         omap4_twl6030_hsmmc_init(mmc);
-        /* OMAP4 SDP uses internal transceiver so register nop transceiver */
-        usb_nop_xceiv_register();
-        /* FIXME: allow multi-omap to boot until musb is updated for omap4 */
-        if (!cpu_is_omap44xx())
-                usb_musb_init(&musb_board_data);
+
+        /* Power on the ULPI PHY */
+        if (gpio_is_valid(OMAP4SDP_MDM_PWR_EN_GPIO)) {
+                /* FIXME: Assumes pad is already muxed for GPIO mode */
+                gpio_request(OMAP4SDP_MDM_PWR_EN_GPIO, "USBB1 PHY VMDM_3V3");
+                gpio_direction_output(OMAP4SDP_MDM_PWR_EN_GPIO, 1);
+        }
+        usb_ehci_init(&ehci_pdata);
+        usb_musb_init(&musb_board_data);
 
         status = omap_ethernet_init();
         if (status) {
diff --git a/arch/arm/mach-omap2/board-n8x0.c b/arch/arm/mach-omap2/board-n8x0.c
index 147d9005f320..f396756872b7 100644
--- a/arch/arm/mach-omap2/board-n8x0.c
+++ b/arch/arm/mach-omap2/board-n8x0.c
@@ -46,8 +46,7 @@ static struct device *mmc_device;
 #define TUSB6010_GPIO_ENABLE    0
 #define TUSB6010_DMACHAN        0x3f
 
-#if defined(CONFIG_USB_TUSB6010) || \
-        defined(CONFIG_USB_TUSB6010_MODULE)
+#ifdef CONFIG_USB_MUSB_TUSB6010
 /*
  * Enable or disable power to TUSB6010. When enabling, turn on 3.3 V and
  * 1.5 V voltage regulators of PM companion chip. Companion chip will then
@@ -134,7 +133,7 @@ err:
 
 static void __init n8x0_usb_init(void) {}
 
-#endif /*CONFIG_USB_TUSB6010 */
+#endif /*CONFIG_USB_MUSB_TUSB6010 */
 
 
 static struct omap2_mcspi_device_config p54spi_mcspi_config = {
diff --git a/arch/arm/mach-omap2/board-omap4panda.c b/arch/arm/mach-omap2/board-omap4panda.c
index 613bdd89bcfa..e001a048dc0c 100644
--- a/arch/arm/mach-omap2/board-omap4panda.c
+++ b/arch/arm/mach-omap2/board-omap4panda.c
@@ -144,10 +144,17 @@ error1:
 
 static struct omap_musb_board_data musb_board_data = {
         .interface_type         = MUSB_INTERFACE_UTMI,
-        .mode                   = MUSB_PERIPHERAL,
+        .mode                   = MUSB_OTG,
         .power                  = 100,
 };
 
+static struct twl4030_usb_data omap4_usbphy_data = {
+        .phy_init       = omap4430_phy_init,
+        .phy_exit       = omap4430_phy_exit,
+        .phy_power      = omap4430_phy_power,
+        .phy_set_clock  = omap4430_phy_set_clk,
+};
+
 static struct omap2_hsmmc_info mmc[] = {
         {
                 .mmc            = 1,
@@ -357,6 +364,7 @@ static struct twl4030_platform_data omap4_panda_twldata = {
         .vaux1          = &omap4_panda_vaux1,
         .vaux2          = &omap4_panda_vaux2,
         .vaux3          = &omap4_panda_vaux3,
+        .usb            = &omap4_usbphy_data,
 };
 
 static struct i2c_board_info __initdata omap4_panda_i2c_boardinfo[] = {
@@ -404,9 +412,7 @@ static void __init omap4_panda_init(void)
         /* OMAP4 Panda uses internal transceiver so register nop transceiver */
         usb_nop_xceiv_register();
         omap4_ehci_init();
-        /* FIXME: allow multi-omap to boot until musb is updated for omap4 */
-        if (!cpu_is_omap44xx())
-                usb_musb_init(&musb_board_data);
+        usb_musb_init(&musb_board_data);
 }
 
 static void __init omap4_panda_map_io(void)
diff --git a/arch/arm/mach-omap2/clock2420_data.c b/arch/arm/mach-omap2/clock2420_data.c
index ed1295f5046e..0a992bc8d0d8 100644
--- a/arch/arm/mach-omap2/clock2420_data.c
+++ b/arch/arm/mach-omap2/clock2420_data.c
@@ -1877,7 +1877,7 @@ static struct omap_clk omap2420_clks[] = {
         CLK("omap-aes", "ick",  &aes_ick,       CK_242X),
         CLK(NULL,       "pka_ick",      &pka_ick,       CK_242X),
         CLK(NULL,       "usb_fck",      &usb_fck,       CK_242X),
-        CLK("musb_hdrc",        "fck",  &osc_ck,        CK_242X),
+        CLK("musb-hdrc",        "fck",  &osc_ck,        CK_242X),
 };
 
 /*
diff --git a/arch/arm/mach-omap2/clock2430_data.c b/arch/arm/mach-omap2/clock2430_data.c
index 38341a71c6f8..c047dcd007e5 100644
--- a/arch/arm/mach-omap2/clock2430_data.c
+++ b/arch/arm/mach-omap2/clock2430_data.c
@@ -1983,7 +1983,7 @@ static struct omap_clk omap2430_clks[] = {
         CLK("omap-aes", "ick",  &aes_ick,       CK_243X),
         CLK(NULL,       "pka_ick",      &pka_ick,       CK_243X),
         CLK(NULL,       "usb_fck",      &usb_fck,       CK_243X),
-        CLK("musb_hdrc",        "ick",  &usbhs_ick,     CK_243X),
+        CLK("musb-omap2430",    "ick",  &usbhs_ick,     CK_243X),
         CLK("mmci-omap-hs.0", "ick",    &mmchs1_ick,    CK_243X),
         CLK("mmci-omap-hs.0", "fck",    &mmchs1_fck,    CK_243X),
         CLK("mmci-omap-hs.1", "ick",    &mmchs2_ick,    CK_243X),
diff --git a/arch/arm/mach-omap2/clock3xxx_data.c b/arch/arm/mach-omap2/clock3xxx_data.c
index 9ab817e6c300..403a4a1d3f9c 100644
--- a/arch/arm/mach-omap2/clock3xxx_data.c
+++ b/arch/arm/mach-omap2/clock3xxx_data.c
@@ -3286,6 +3286,7 @@ static struct omap_clk omap3xxx_clks[] = {
         CLK(NULL,       "cpefuse_fck",  &cpefuse_fck,   CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK(NULL,       "ts_fck",       &ts_fck,        CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK(NULL,       "usbtll_fck",   &usbtll_fck,    CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
+        CLK("ehci-omap.0",      "usbtll_fck",   &usbtll_fck,    CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK("omap-mcbsp.1",     "prcm_fck",     &core_96m_fck,  CK_3XXX),
         CLK("omap-mcbsp.5",     "prcm_fck",     &core_96m_fck,  CK_3XXX),
         CLK(NULL,       "core_96m_fck", &core_96m_fck,  CK_3XXX),
@@ -3313,14 +3314,15 @@ static struct omap_clk omap3xxx_clks[] = {
         CLK(NULL,       "ssi_sst_fck",  &ssi_sst_fck_3430es1,   CK_3430ES1),
         CLK(NULL,       "ssi_sst_fck",  &ssi_sst_fck_3430es2,   CK_3430ES2PLUS | CK_36XX),
         CLK(NULL,       "core_l3_ick",  &core_l3_ick,   CK_3XXX),
-        CLK("musb_hdrc",        "ick",  &hsotgusb_ick_3430es1,  CK_3430ES1),
-        CLK("musb_hdrc",        "ick",  &hsotgusb_ick_3430es2,  CK_3430ES2PLUS | CK_36XX),
+        CLK("musb-omap2430",    "ick",  &hsotgusb_ick_3430es1,  CK_3430ES1),
+        CLK("musb-omap2430",    "ick",  &hsotgusb_ick_3430es2,  CK_3430ES2PLUS | CK_36XX),
         CLK(NULL,       "sdrc_ick",     &sdrc_ick,      CK_3XXX),
         CLK(NULL,       "gpmc_fck",     &gpmc_fck,      CK_3XXX),
         CLK(NULL,       "security_l3_ick", &security_l3_ick, CK_34XX | CK_36XX),
         CLK(NULL,       "pka_ick",      &pka_ick,       CK_34XX | CK_36XX),
         CLK(NULL,       "core_l4_ick",  &core_l4_ick,   CK_3XXX),
         CLK(NULL,       "usbtll_ick",   &usbtll_ick,    CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
+        CLK("ehci-omap.0",      "usbtll_ick",   &usbtll_ick,    CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK("mmci-omap-hs.2",   "ick",  &mmchs3_ick,    CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK(NULL,       "icr_ick",      &icr_ick,       CK_34XX | CK_36XX),
         CLK("omap-aes", "ick",  &aes2_ick,      CK_34XX | CK_36XX),
@@ -3366,8 +3368,11 @@ static struct omap_clk omap3xxx_clks[] = {
         CLK(NULL,       "cam_ick",      &cam_ick,       CK_34XX | CK_36XX),
         CLK(NULL,       "csi2_96m_fck", &csi2_96m_fck,  CK_34XX | CK_36XX),
         CLK(NULL,       "usbhost_120m_fck", &usbhost_120m_fck, CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
+        CLK("ehci-omap.0",      "hs_fck", &usbhost_120m_fck, CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK(NULL,       "usbhost_48m_fck", &usbhost_48m_fck, CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
+        CLK("ehci-omap.0",      "fs_fck", &usbhost_48m_fck, CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK(NULL,       "usbhost_ick",  &usbhost_ick,   CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
+        CLK("ehci-omap.0",      "usbhost_ick",  &usbhost_ick,   CK_3430ES2PLUS | CK_AM35XX | CK_36XX),
         CLK(NULL,       "usim_fck",     &usim_fck,      CK_3430ES2PLUS | CK_36XX),
         CLK(NULL,       "gpt1_fck",     &gpt1_fck,      CK_3XXX),
         CLK(NULL,       "wkup_32k_fck", &wkup_32k_fck,  CK_3XXX),
@@ -3445,8 +3450,8 @@ static struct omap_clk omap3xxx_clks[] = {
         CLK("davinci_emac",     "phy_clk",      &emac_fck,      CK_AM35XX),
         CLK("vpfe-capture",     "master",       &vpfe_ick,      CK_AM35XX),
         CLK("vpfe-capture",     "slave",        &vpfe_fck,      CK_AM35XX),
-        CLK("musb_hdrc",        "ick",          &hsotgusb_ick_am35xx,   CK_AM35XX),
-        CLK("musb_hdrc",        "fck",          &hsotgusb_fck_am35xx,   CK_AM35XX),
+        CLK("musb-am35x",       "ick",          &hsotgusb_ick_am35xx,   CK_AM35XX),
+        CLK("musb-am35x",       "fck",          &hsotgusb_fck_am35xx,   CK_AM35XX),
         CLK(NULL,       "hecc_ck",      &hecc_ck,       CK_AM35XX),
         CLK(NULL,       "uart4_ick",    &uart4_ick_am35xx,      CK_AM35XX),
 };
diff --git a/arch/arm/mach-omap2/clock44xx_data.c b/arch/arm/mach-omap2/clock44xx_data.c
index c426adccad06..e8cb32fd7f13 100644
--- a/arch/arm/mach-omap2/clock44xx_data.c
+++ b/arch/arm/mach-omap2/clock44xx_data.c
@@ -3198,6 +3198,7 @@ static struct omap_clk omap44xx_clks[] = {
         CLK(NULL,       "uart3_fck",                    &uart3_fck,     CK_443X),
         CLK(NULL,       "uart4_fck",                    &uart4_fck,     CK_443X),
         CLK(NULL,       "usb_host_fs_fck",              &usb_host_fs_fck,       CK_443X),
+        CLK("ehci-omap.0",      "fs_fck",               &usb_host_fs_fck,       CK_443X),
         CLK(NULL,       "utmi_p1_gfclk",                &utmi_p1_gfclk, CK_443X),
         CLK(NULL,       "usb_host_hs_utmi_p1_clk",      &usb_host_hs_utmi_p1_clk,       CK_443X),
         CLK(NULL,       "utmi_p2_gfclk",                &utmi_p2_gfclk, CK_443X),
@@ -3209,14 +3210,18 @@ static struct omap_clk omap44xx_clks[] = {
         CLK(NULL,       "usb_host_hs_hsic480m_p2_clk",  &usb_host_hs_hsic480m_p2_clk,   CK_443X),
         CLK(NULL,       "usb_host_hs_func48mclk",       &usb_host_hs_func48mclk,        CK_443X),
         CLK(NULL,       "usb_host_hs_fck",              &usb_host_hs_fck,       CK_443X),
+        CLK("ehci-omap.0",      "hs_fck",               &usb_host_hs_fck,       CK_443X),
+        CLK("ehci-omap.0",      "usbhost_ick",          &dummy_ck,              CK_443X),
         CLK(NULL,       "otg_60m_gfclk",                &otg_60m_gfclk, CK_443X),
         CLK(NULL,       "usb_otg_hs_xclk",              &usb_otg_hs_xclk,       CK_443X),
-        CLK("musb_hdrc",        "ick",                          &usb_otg_hs_ick,        CK_443X),
+        CLK("musb-omap2430",    "ick",                          &usb_otg_hs_ick,        CK_443X),
         CLK(NULL,       "usb_phy_cm_clk32k",            &usb_phy_cm_clk32k,     CK_443X),
         CLK(NULL,       "usb_tll_hs_usb_ch2_clk",       &usb_tll_hs_usb_ch2_clk,        CK_443X),
         CLK(NULL,       "usb_tll_hs_usb_ch0_clk",       &usb_tll_hs_usb_ch0_clk,        CK_443X),
         CLK(NULL,       "usb_tll_hs_usb_ch1_clk",       &usb_tll_hs_usb_ch1_clk,        CK_443X),
         CLK(NULL,       "usb_tll_hs_ick",               &usb_tll_hs_ick,        CK_443X),
+        CLK("ehci-omap.0",      "usbtll_ick",           &usb_tll_hs_ick,        CK_443X),
+        CLK("ehci-omap.0",      "usbtll_fck",           &dummy_ck,      CK_443X),
         CLK(NULL,       "usim_ck",                      &usim_ck,       CK_443X),
         CLK(NULL,       "usim_fclk",                    &usim_fclk,     CK_443X),
         CLK(NULL,       "usim_fck",                     &usim_fck,      CK_443X),
diff --git a/arch/arm/mach-omap2/omap_phy_internal.c b/arch/arm/mach-omap2/omap_phy_internal.c
new file mode 100644
index 000000000000..745252c60e32
--- /dev/null
+++ b/arch/arm/mach-omap2/omap_phy_internal.c
@@ -0,0 +1,149 @@
+/*
+  * This file configures the internal USB PHY in OMAP4430. Used
+  * with TWL6030 transceiver and MUSB on OMAP4430.
+  *
+  * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; either version 2 of the License, or
+  * (at your option) any later version.
+  *
+  * Author: Hema HK <hemahk@ti.com>
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+  *
+  */
+
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/err.h>
+#include <linux/usb.h>
+
+#include <plat/usb.h>
+
+/* OMAP control module register for UTMI PHY */
+#define CONTROL_DEV_CONF                0x300
+#define PHY_PD                          0x1
+
+#define USBOTGHS_CONTROL                0x33c
+#define AVALID                          BIT(0)
+#define BVALID                          BIT(1)
+#define VBUSVALID                       BIT(2)
+#define SESSEND                         BIT(3)
+#define IDDIG                           BIT(4)
+
+static struct clk *phyclk, *clk48m, *clk32k;
+static void __iomem *ctrl_base;
+
+int omap4430_phy_init(struct device *dev)
+{
+        ctrl_base = ioremap(OMAP443X_SCM_BASE, SZ_1K);
+        if (!ctrl_base) {
+                dev_err(dev, "control module ioremap failed\n");
+                return -ENOMEM;
+        }
+        /* Power down the phy */
+        __raw_writel(PHY_PD, ctrl_base + CONTROL_DEV_CONF);
+        phyclk = clk_get(dev, "ocp2scp_usb_phy_ick");
+
+        if (IS_ERR(phyclk)) {
+                dev_err(dev, "cannot clk_get ocp2scp_usb_phy_ick\n");
+                iounmap(ctrl_base);
+                return PTR_ERR(phyclk);
+        }
+
+        clk48m = clk_get(dev, "ocp2scp_usb_phy_phy_48m");
+        if (IS_ERR(clk48m)) {
+                dev_err(dev, "cannot clk_get ocp2scp_usb_phy_phy_48m\n");
+                clk_put(phyclk);
+                iounmap(ctrl_base);
+                return PTR_ERR(clk48m);
+        }
+
+        clk32k = clk_get(dev, "usb_phy_cm_clk32k");
+        if (IS_ERR(clk32k)) {
+                dev_err(dev, "cannot clk_get usb_phy_cm_clk32k\n");
+                clk_put(phyclk);
+                clk_put(clk48m);
+                iounmap(ctrl_base);
+                return PTR_ERR(clk32k);
+        }
+        return 0;
+}
+
+int omap4430_phy_set_clk(struct device *dev, int on)
+{
+        static int state;
+
+        if (on && !state) {
+                /* Enable the phy clocks */
+                clk_enable(phyclk);
+                clk_enable(clk48m);
+                clk_enable(clk32k);
+                state = 1;
+        } else if (state) {
+                /* Disable the phy clocks */
+                clk_disable(phyclk);
+                clk_disable(clk48m);
+                clk_disable(clk32k);
+                state = 0;
+        }
+        return 0;
+}
+
+int omap4430_phy_power(struct device *dev, int ID, int on)
+{
+        if (on) {
+                /* enabled the clocks */
+                omap4430_phy_set_clk(dev, 1);
+                /* power on the phy */
+                if (__raw_readl(ctrl_base + CONTROL_DEV_CONF) & PHY_PD) {
+                        __raw_writel(~PHY_PD, ctrl_base + CONTROL_DEV_CONF);
+                        mdelay(200);
+                }
+                if (ID)
+                        /* enable VBUS valid, IDDIG groung */
+                        __raw_writel(AVALID | VBUSVALID, ctrl_base +
+                                                        USBOTGHS_CONTROL);
+                else
+                        /*
+                         * Enable VBUS Valid, AValid and IDDIG
+                         * high impedence
+                         */
+                        __raw_writel(IDDIG | AVALID | VBUSVALID,
+                                                ctrl_base + USBOTGHS_CONTROL);
+        } else {
+                /* Enable session END and IDIG to high impedence. */
+                __raw_writel(SESSEND | IDDIG, ctrl_base +
+                                        USBOTGHS_CONTROL);
+                /* Disable the clocks */
+                omap4430_phy_set_clk(dev, 0);
+                /* Power down the phy */
+                __raw_writel(PHY_PD, ctrl_base + CONTROL_DEV_CONF);
+        }
+
+        return 0;
+}
+
+int omap4430_phy_exit(struct device *dev)
+{
+        if (ctrl_base)
+                iounmap(ctrl_base);
+        if (phyclk)
+                clk_put(phyclk);
+        if (clk48m)
+                clk_put(clk48m);
+        if (clk32k)
+                clk_put(clk32k);
+
+        return 0;
+}
diff --git a/arch/arm/mach-omap2/usb-ehci.c b/arch/arm/mach-omap2/usb-ehci.c
index b11bf385d360..25eeadabc39b 100644
--- a/arch/arm/mach-omap2/usb-ehci.c
+++ b/arch/arm/mach-omap2/usb-ehci.c
@@ -34,22 +34,15 @@
 
 static struct resource ehci_resources[] = {
         {
-                .start  = OMAP34XX_EHCI_BASE,
-                .end    = OMAP34XX_EHCI_BASE + SZ_1K - 1,
                 .flags  = IORESOURCE_MEM,
         },
         {
-                .start  = OMAP34XX_UHH_CONFIG_BASE,
-                .end    = OMAP34XX_UHH_CONFIG_BASE + SZ_1K - 1,
                 .flags  = IORESOURCE_MEM,
         },
         {
-                .start  = OMAP34XX_USBTLL_BASE,
-                .end    = OMAP34XX_USBTLL_BASE + SZ_4K - 1,
                 .flags  = IORESOURCE_MEM,
         },
         {         /* general IRQ */
-                .start   = INT_34XX_EHCI_IRQ,
                 .flags   = IORESOURCE_IRQ,
         }
 };
@@ -214,13 +207,148 @@ static void setup_ehci_io_mux(const enum ehci_hcd_omap_mode *port_mode)
         return;
 }
 
+static void setup_4430ehci_io_mux(const enum ehci_hcd_omap_mode *port_mode)
+{
+        switch (port_mode[0]) {
+        case EHCI_HCD_OMAP_MODE_PHY:
+                omap_mux_init_signal("usbb1_ulpiphy_stp",
+                        OMAP_PIN_OUTPUT);
+                omap_mux_init_signal("usbb1_ulpiphy_clk",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dir",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_nxt",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat0",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat1",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat2",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat3",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat4",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat5",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat6",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpiphy_dat7",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                        break;
+        case EHCI_HCD_OMAP_MODE_TLL:
+                omap_mux_init_signal("usbb1_ulpitll_stp",
+                        OMAP_PIN_INPUT_PULLUP);
+                omap_mux_init_signal("usbb1_ulpitll_clk",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dir",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_nxt",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat0",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat1",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat2",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat3",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat4",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat5",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat6",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb1_ulpitll_dat7",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                        break;
+        case EHCI_HCD_OMAP_MODE_UNKNOWN:
+        default:
+                        break;
+        }
+        switch (port_mode[1]) {
+        case EHCI_HCD_OMAP_MODE_PHY:
+                omap_mux_init_signal("usbb2_ulpiphy_stp",
+                        OMAP_PIN_OUTPUT);
+                omap_mux_init_signal("usbb2_ulpiphy_clk",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dir",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_nxt",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat0",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat1",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat2",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat3",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat4",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat5",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat6",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpiphy_dat7",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                        break;
+        case EHCI_HCD_OMAP_MODE_TLL:
+                omap_mux_init_signal("usbb2_ulpitll_stp",
+                        OMAP_PIN_INPUT_PULLUP);
+                omap_mux_init_signal("usbb2_ulpitll_clk",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dir",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_nxt",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat0",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat1",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat2",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat3",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat4",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat5",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat6",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                omap_mux_init_signal("usbb2_ulpitll_dat7",
+                        OMAP_PIN_INPUT_PULLDOWN);
+                        break;
+        case EHCI_HCD_OMAP_MODE_UNKNOWN:
+        default:
+                        break;
+        }
+}
+
 void __init usb_ehci_init(const struct ehci_hcd_omap_platform_data *pdata)
 {
         platform_device_add_data(&ehci_device, pdata, sizeof(*pdata));
 
         /* Setup Pin IO MUX for EHCI */
-        if (cpu_is_omap34xx())
+        if (cpu_is_omap34xx()) {
+                ehci_resources[0].start = OMAP34XX_EHCI_BASE;
+                ehci_resources[0].end   = OMAP34XX_EHCI_BASE + SZ_1K - 1;
+                ehci_resources[1].start = OMAP34XX_UHH_CONFIG_BASE;
+                ehci_resources[1].end   = OMAP34XX_UHH_CONFIG_BASE + SZ_1K - 1;
+                ehci_resources[2].start = OMAP34XX_USBTLL_BASE;
+                ehci_resources[2].end   = OMAP34XX_USBTLL_BASE + SZ_4K - 1;
+                ehci_resources[3].start = INT_34XX_EHCI_IRQ;
                 setup_ehci_io_mux(pdata->port_mode);
+        } else if (cpu_is_omap44xx()) {
+                ehci_resources[0].start = OMAP44XX_HSUSB_EHCI_BASE;
+                ehci_resources[0].end   = OMAP44XX_HSUSB_EHCI_BASE + SZ_1K - 1;
+                ehci_resources[1].start = OMAP44XX_UHH_CONFIG_BASE;
+                ehci_resources[1].end   = OMAP44XX_UHH_CONFIG_BASE + SZ_2K - 1;
+                ehci_resources[2].start = OMAP44XX_USBTLL_BASE;
+                ehci_resources[2].end   = OMAP44XX_USBTLL_BASE + SZ_4K - 1;
+                ehci_resources[3].start = OMAP44XX_IRQ_EHCI;
+                setup_4430ehci_io_mux(pdata->port_mode);
+        }
 
         if (platform_device_register(&ehci_device) < 0) {
                 printk(KERN_ERR "Unable to register HS-USB (EHCI) device\n");
diff --git a/arch/arm/mach-omap2/usb-musb.c b/arch/arm/mach-omap2/usb-musb.c
index 72605584bfff..5298949d4b11 100644
--- a/arch/arm/mach-omap2/usb-musb.c
+++ b/arch/arm/mach-omap2/usb-musb.c
@@ -30,8 +30,101 @@
 #include <mach/irqs.h>
 #include <mach/am35xx.h>
 #include <plat/usb.h>
+#include "control.h"
 
-#ifdef CONFIG_USB_MUSB_SOC
+#if defined(CONFIG_USB_MUSB_OMAP2PLUS) || defined (CONFIG_USB_MUSB_AM35X)
+
+static void am35x_musb_reset(void)
+{
+        u32     regval;
+
+        /* Reset the musb interface */
+        regval = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
+
+        regval |= AM35XX_USBOTGSS_SW_RST;
+        omap_ctrl_writel(regval, AM35XX_CONTROL_IP_SW_RESET);
+
+        regval &= ~AM35XX_USBOTGSS_SW_RST;
+        omap_ctrl_writel(regval, AM35XX_CONTROL_IP_SW_RESET);
+
+        regval = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
+}
+
+static void am35x_musb_phy_power(u8 on)
+{
+        unsigned long timeout = jiffies + msecs_to_jiffies(100);
+        u32 devconf2;
+
+        if (on) {
+                /*
+                 * Start the on-chip PHY and its PLL.
+                 */
+                devconf2 = omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2);
+
+                devconf2 &= ~(CONF2_RESET | CONF2_PHYPWRDN | CONF2_OTGPWRDN);
+                devconf2 |= CONF2_PHY_PLLON;
+
+                omap_ctrl_writel(devconf2, AM35XX_CONTROL_DEVCONF2);
+
+                pr_info(KERN_INFO "Waiting for PHY clock good...\n");
+                while (!(omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2)
+                                & CONF2_PHYCLKGD)) {
+                        cpu_relax();
+
+                        if (time_after(jiffies, timeout)) {
+                                pr_err(KERN_ERR "musb PHY clock good timed out\n");
+                                break;
+                        }
+                }
+        } else {
+                /*
+                 * Power down the on-chip PHY.
+                 */
+                devconf2 = omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2);
+
+                devconf2 &= ~CONF2_PHY_PLLON;
+                devconf2 |=  CONF2_PHYPWRDN | CONF2_OTGPWRDN;
+                omap_ctrl_writel(devconf2, AM35XX_CONTROL_DEVCONF2);
+        }
+}
+
+static void am35x_musb_clear_irq(void)
+{
+        u32 regval;
+
+        regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
+        regval |= AM35XX_USBOTGSS_INT_CLR;
+        omap_ctrl_writel(regval, AM35XX_CONTROL_LVL_INTR_CLEAR);
+        regval = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
+}
+
+static void am35x_musb_set_mode(u8 musb_mode)
+{
+        u32 devconf2 = omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2);
+
+        devconf2 &= ~CONF2_OTGMODE;
+        switch (musb_mode) {
+#ifdef  CONFIG_USB_MUSB_HDRC_HCD
+        case MUSB_HOST:         /* Force VBUS valid, ID = 0 */
+                devconf2 |= CONF2_FORCE_HOST;
+                break;
+#endif
+#ifdef  CONFIG_USB_GADGET_MUSB_HDRC
+        case MUSB_PERIPHERAL:   /* Force VBUS valid, ID = 1 */
+                devconf2 |= CONF2_FORCE_DEVICE;
+                break;
+#endif
+#ifdef  CONFIG_USB_MUSB_OTG
+        case MUSB_OTG:          /* Don't override the VBUS/ID comparators */
+                devconf2 |= CONF2_NO_OVERRIDE;
+                break;
+#endif
+        default:
+                pr_info(KERN_INFO "Unsupported mode %u\n", musb_mode);
+        }
+
+        omap_ctrl_writel(devconf2, AM35XX_CONTROL_DEVCONF2);
+}
 
 static struct resource musb_resources[] = {
         [0] = { /* start and end set dynamically */
@@ -40,10 +133,12 @@ static struct resource musb_resources[] = {
         [1] = { /* general IRQ */
                 .start  = INT_243X_HS_USB_MC,
                 .flags  = IORESOURCE_IRQ,
+                .name   = "mc",
         },
         [2] = { /* DMA IRQ */
                 .start  = INT_243X_HS_USB_DMA,
                 .flags  = IORESOURCE_IRQ,
+                .name   = "dma",
         },
 };
 
@@ -75,7 +170,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = DMA_BIT_MASK(32);
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-omap2430",
         .id             = -1,
         .dev = {
                 .dma_mask               = &musb_dmamask,
@@ -91,8 +186,13 @@ void __init usb_musb_init(struct omap_musb_board_data *board_data)
         if (cpu_is_omap243x()) {
                 musb_resources[0].start = OMAP243X_HS_BASE;
         } else if (cpu_is_omap3517() || cpu_is_omap3505()) {
+                musb_device.name = "musb-am35x";
                 musb_resources[0].start = AM35XX_IPSS_USBOTGSS_BASE;
                 musb_resources[1].start = INT_35XX_USBOTG_IRQ;
+                board_data->set_phy_power = am35x_musb_phy_power;
+                board_data->clear_irq = am35x_musb_clear_irq;
+                board_data->set_mode = am35x_musb_set_mode;
+                board_data->reset = am35x_musb_reset;
         } else if (cpu_is_omap34xx()) {
                 musb_resources[0].start = OMAP34XX_HSUSB_OTG_BASE;
         } else if (cpu_is_omap44xx()) {
diff --git a/arch/arm/mach-omap2/usb-tusb6010.c b/arch/arm/mach-omap2/usb-tusb6010.c
index 30f112bd3e4d..8a3c05f3c1d6 100644
--- a/arch/arm/mach-omap2/usb-tusb6010.c
+++ b/arch/arm/mach-omap2/usb-tusb6010.c
@@ -224,7 +224,7 @@ static struct resource tusb_resources[] = {
 static u64 tusb_dmamask = ~(u32)0;
 
 static struct platform_device tusb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-tusb",
         .id             = -1,
         .dev = {
                 .dma_mask               = &tusb_dmamask,
diff --git a/arch/arm/plat-omap/include/plat/omap44xx.h b/arch/arm/plat-omap/include/plat/omap44xx.h
index 8b3f12ff5cbc..ea2b8a6306e7 100644
--- a/arch/arm/plat-omap/include/plat/omap44xx.h
+++ b/arch/arm/plat-omap/include/plat/omap44xx.h
@@ -52,5 +52,10 @@
 #define OMAP4_MMU1_BASE                 0x55082000
 #define OMAP4_MMU2_BASE                 0x4A066000
 
+#define OMAP44XX_USBTLL_BASE            (L4_44XX_BASE + 0x62000)
+#define OMAP44XX_UHH_CONFIG_BASE        (L4_44XX_BASE + 0x64000)
+#define OMAP44XX_HSUSB_OHCI_BASE        (L4_44XX_BASE + 0x64800)
+#define OMAP44XX_HSUSB_EHCI_BASE        (L4_44XX_BASE + 0x64C00)
+
 #endif /* __ASM_ARCH_OMAP44XX_H */
 
diff --git a/arch/arm/plat-omap/include/plat/usb.h b/arch/arm/plat-omap/include/plat/usb.h
index 59c7fe731f28..450a332f1009 100644
--- a/arch/arm/plat-omap/include/plat/usb.h
+++ b/arch/arm/plat-omap/include/plat/usb.h
@@ -11,6 +11,7 @@ enum ehci_hcd_omap_mode {
         EHCI_HCD_OMAP_MODE_UNKNOWN,
         EHCI_HCD_OMAP_MODE_PHY,
         EHCI_HCD_OMAP_MODE_TLL,
+        EHCI_HCD_OMAP_MODE_HSIC,
 };
 
 enum ohci_omap3_port_mode {
@@ -69,6 +70,10 @@ struct omap_musb_board_data {
         u8      mode;
         u16     power;
         unsigned extvbus:1;
+        void    (*set_phy_power)(u8 on);
+        void    (*clear_irq)(void);
+        void    (*set_mode)(u8 mode);
+        void    (*reset)(void);
 };
 
 enum musb_interface    {MUSB_INTERFACE_ULPI, MUSB_INTERFACE_UTMI};
@@ -79,6 +84,11 @@ extern void usb_ehci_init(const struct ehci_hcd_omap_platform_data *pdata);
 
 extern void usb_ohci_init(const struct ohci_hcd_omap_platform_data *pdata);
 
+extern int omap4430_phy_power(struct device *dev, int ID, int on);
+extern int omap4430_phy_set_clk(struct device *dev, int on);
+extern int omap4430_phy_init(struct device *dev);
+extern int omap4430_phy_exit(struct device *dev);
+
 #endif
 
 
diff --git a/arch/blackfin/mach-bf527/boards/ad7160eval.c b/arch/blackfin/mach-bf527/boards/ad7160eval.c
index fc767ac76381..52295fff5577 100644
--- a/arch/blackfin/mach-bf527/boards/ad7160eval.c
+++ b/arch/blackfin/mach-bf527/boards/ad7160eval.c
@@ -83,7 +83,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/blackfin/mach-bf527/boards/cm_bf527.c b/arch/blackfin/mach-bf527/boards/cm_bf527.c
index 2c31af7a320a..50533edc3994 100644
--- a/arch/blackfin/mach-bf527/boards/cm_bf527.c
+++ b/arch/blackfin/mach-bf527/boards/cm_bf527.c
@@ -82,11 +82,13 @@ static struct resource musb_resources[] = {
                 .start  = IRQ_USB_INT0,
                 .end    = IRQ_USB_INT0,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "mc"
         },
         [2] = { /* DMA IRQ */
                 .start  = IRQ_USB_DMA,
                 .end    = IRQ_USB_DMA,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "dma"
         },
 };
 
@@ -118,7 +120,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/blackfin/mach-bf527/boards/ezbrd.c b/arch/blackfin/mach-bf527/boards/ezbrd.c
index 9a736a850c5c..d06177b5fe22 100644
--- a/arch/blackfin/mach-bf527/boards/ezbrd.c
+++ b/arch/blackfin/mach-bf527/boards/ezbrd.c
@@ -46,11 +46,13 @@ static struct resource musb_resources[] = {
                 .start  = IRQ_USB_INT0,
                 .end    = IRQ_USB_INT0,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "mc"
         },
         [2] = { /* DMA IRQ */
                 .start  = IRQ_USB_DMA,
                 .end    = IRQ_USB_DMA,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "dma"
         },
 };
 
@@ -82,7 +84,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/blackfin/mach-bf527/boards/ezkit.c b/arch/blackfin/mach-bf527/boards/ezkit.c
index 9222bc00bbd3..35a88a5a5013 100644
--- a/arch/blackfin/mach-bf527/boards/ezkit.c
+++ b/arch/blackfin/mach-bf527/boards/ezkit.c
@@ -86,11 +86,13 @@ static struct resource musb_resources[] = {
                 .start  = IRQ_USB_INT0,
                 .end    = IRQ_USB_INT0,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "mc"
         },
         [2] = { /* DMA IRQ */
                 .start  = IRQ_USB_DMA,
                 .end    = IRQ_USB_DMA,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "dma"
         },
 };
 
@@ -122,7 +124,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/blackfin/mach-bf527/boards/tll6527m.c b/arch/blackfin/mach-bf527/boards/tll6527m.c
index 9ec575729e2c..130861bd2589 100644
--- a/arch/blackfin/mach-bf527/boards/tll6527m.c
+++ b/arch/blackfin/mach-bf527/boards/tll6527m.c
@@ -91,7 +91,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/blackfin/mach-bf548/boards/cm_bf548.c b/arch/blackfin/mach-bf548/boards/cm_bf548.c
index f0c0eef95ba8..4c2ee6789099 100644
--- a/arch/blackfin/mach-bf548/boards/cm_bf548.c
+++ b/arch/blackfin/mach-bf548/boards/cm_bf548.c
@@ -482,11 +482,13 @@ static struct resource musb_resources[] = {
                 .start  = IRQ_USB_INT0,
                 .end    = IRQ_USB_INT0,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "mc"
         },
         [2] = { /* DMA IRQ */
                 .start  = IRQ_USB_DMA,
                 .end    = IRQ_USB_DMA,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "dma"
         },
 };
 
@@ -518,7 +520,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/blackfin/mach-bf548/boards/ezkit.c b/arch/blackfin/mach-bf548/boards/ezkit.c
index 216e26999af9..4f03fbc4c9be 100644
--- a/arch/blackfin/mach-bf548/boards/ezkit.c
+++ b/arch/blackfin/mach-bf548/boards/ezkit.c
@@ -587,11 +587,13 @@ static struct resource musb_resources[] = {
                 .start  = IRQ_USB_INT0,
                 .end    = IRQ_USB_INT0,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "mc"
         },
         [2] = { /* DMA IRQ */
                 .start  = IRQ_USB_DMA,
                 .end    = IRQ_USB_DMA,
                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+                .name   = "dma"
         },
 };
 
@@ -623,7 +625,7 @@ static struct musb_hdrc_platform_data musb_plat = {
 static u64 musb_dmamask = ~(u32)0;
 
 static struct platform_device musb_device = {
-        .name           = "musb_hdrc",
+        .name           = "musb-blackfin",
         .id             = 0,
         .dev = {
                 .dma_mask               = &musb_dmamask,
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index 39e534f5a3b0..f099b82703d8 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -1542,7 +1542,7 @@ pfm_exit_smpl_buffer(pfm_buffer_fmt_t *fmt)
  * any operations on the root directory. However, we need a non-trivial
  * d_name - pfm: will go nicely and kill the special-casing in procfs.
  */
-static struct vfsmount *pfmfs_mnt;
+static struct vfsmount *pfmfs_mnt __read_mostly;
 
 static int __init
 init_pfm_fs(void)
@@ -2185,7 +2185,7 @@ static const struct file_operations pfm_file_ops = {
 };
 
 static int
-pfmfs_delete_dentry(struct dentry *dentry)
+pfmfs_delete_dentry(const struct dentry *dentry)
 {
         return 1;
 }
@@ -2233,7 +2233,7 @@ pfm_alloc_file(pfm_context_t *ctx)
         }
         path.mnt = mntget(pfmfs_mnt);
 
-        path.dentry->d_op = &pfmfs_dentry_operations;
+        d_set_d_op(path.dentry, &pfmfs_dentry_operations);
         d_add(path.dentry, inode);
 
         file = alloc_file(&path, FMODE_READ, &pfm_file_ops);
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 3532b92de983..856e9c398068 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -71,12 +71,18 @@ spufs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void
-spufs_destroy_inode(struct inode *inode)
+static void spufs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(spufs_inode_cache, SPUFS_I(inode));
 }
 
+static void spufs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, spufs_i_callback);
+}
+
 static void
 spufs_init_once(void *p)
 {
@@ -159,18 +165,18 @@ static void spufs_prune_dir(struct dentry *dir)
 
         mutex_lock(&dir->d_inode->i_mutex);
         list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) {
-                spin_lock(&dcache_lock);
                 spin_lock(&dentry->d_lock);
                 if (!(d_unhashed(dentry)) && dentry->d_inode) {
-                        dget_locked(dentry);
+                        dget_dlock(dentry);
                         __d_drop(dentry);
                         spin_unlock(&dentry->d_lock);
                         simple_unlink(dir->d_inode, dentry);
-                        spin_unlock(&dcache_lock);
+                        /* XXX: what was dcache_lock protecting here? Other
+                         * filesystems (IB, configfs) release dcache_lock
+                         * before unlink */
                         dput(dentry);
                 } else {
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
                 }
         }
         shrink_dcache_parent(dir);
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index e9e71120040c..fff252209f63 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -349,6 +349,7 @@ config CPU_SUBTYPE_SH7720
         select CPU_HAS_DSP
         select SYS_SUPPORTS_CMT
         select ARCH_WANT_OPTIONAL_GPIOLIB
+        select USB_ARCH_HAS_OHCI
         help
           Select SH7720 if you have a SH3-DSP SH7720 CPU.
 
@@ -357,6 +358,7 @@ config CPU_SUBTYPE_SH7721
         select CPU_SH3
         select CPU_HAS_DSP
         select SYS_SUPPORTS_CMT
+        select USB_ARCH_HAS_OHCI
         help
           Select SH7721 if you have a SH3-DSP SH7721 CPU.
 
@@ -437,6 +439,7 @@ config CPU_SUBTYPE_SH7757
 config CPU_SUBTYPE_SH7763
         bool "Support SH7763 processor"
         select CPU_SH4A
+        select USB_ARCH_HAS_OHCI
         help
           Select SH7763 if you have a SH4A SH7763(R5S77631) CPU.
 
@@ -463,6 +466,8 @@ config CPU_SUBTYPE_SH7786
         select CPU_HAS_PTEAEX
         select GENERIC_CLOCKEVENTS_BROADCAST if SMP
         select ARCH_WANT_OPTIONAL_GPIOLIB
+        select USB_ARCH_HAS_OHCI
+        select USB_ARCH_HAS_EHCI
 
 config CPU_SUBTYPE_SHX3
         bool "Support SH-X3 processor"
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7786.c b/arch/sh/kernel/cpu/sh4a/setup-sh7786.c
index c016c0004714..0170dbda1d00 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7786.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7786.c
@@ -522,10 +522,37 @@ static struct platform_device dma0_device = {
         },
 };
 
+#define USB_EHCI_START 0xffe70000
+#define USB_OHCI_START 0xffe70400
+
+static struct resource usb_ehci_resources[] = {
+        [0] = {
+                .start  = USB_EHCI_START,
+                .end    = USB_EHCI_START + 0x3ff,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 77,
+                .end    = 77,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device usb_ehci_device = {
+        .name           = "sh_ehci",
+        .id             = -1,
+        .dev = {
+                .dma_mask               = &usb_ehci_device.dev.coherent_dma_mask,
+                .coherent_dma_mask      = DMA_BIT_MASK(32),
+        },
+        .num_resources  = ARRAY_SIZE(usb_ehci_resources),
+        .resource       = usb_ehci_resources,
+};
+
 static struct resource usb_ohci_resources[] = {
         [0] = {
-                .start  = 0xffe70400,
-                .end    = 0xffe704ff,
+                .start  = USB_OHCI_START,
+                .end    = USB_OHCI_START + 0x3ff,
                 .flags  = IORESOURCE_MEM,
         },
         [1] = {
@@ -535,12 +562,11 @@ static struct resource usb_ohci_resources[] = {
         },
 };
 
-static u64 usb_ohci_dma_mask = DMA_BIT_MASK(32);
 static struct platform_device usb_ohci_device = {
         .name           = "sh_ohci",
         .id             = -1,
         .dev = {
-                .dma_mask               = &usb_ohci_dma_mask,
+                .dma_mask               = &usb_ohci_device.dev.coherent_dma_mask,
                 .coherent_dma_mask      = DMA_BIT_MASK(32),
         },
         .num_resources  = ARRAY_SIZE(usb_ohci_resources),
@@ -570,6 +596,7 @@ static struct platform_device *sh7786_early_devices[] __initdata = {
 
 static struct platform_device *sh7786_devices[] __initdata = {
         &dma0_device,
+        &usb_ehci_device,
         &usb_ohci_device,
 };
 
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 88cb04e7962b..ed1adc20c8eb 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1604,6 +1604,7 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x0004) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 3341baa86a30..5a559de22282 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -200,6 +200,8 @@
 #define USB_VENDOR_ID_ELECOM            0x056e
 #define USB_DEVICE_ID_ELECOM_BM084      0x0061
 
+#define USB_VENDOR_ID_DREAM_CHEEKY      0x1d34
+
 #define USB_VENDOR_ID_ELO               0x04E7
 #define USB_DEVICE_ID_ELO_TS2700        0x0020
 
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index 8c8afc716b98..31ae1b108aea 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -277,18 +277,14 @@ static int remove_file(struct dentry *parent, char *name)
                 goto bail;
         }
 
-        spin_lock(&dcache_lock);
         spin_lock(&tmp->d_lock);
         if (!(d_unhashed(tmp) && tmp->d_inode)) {
-                dget_locked(tmp);
+                dget_dlock(tmp);
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
-                spin_unlock(&dcache_lock);
                 simple_unlink(parent->d_inode, tmp);
-        } else {
+        } else
                 spin_unlock(&tmp->d_lock);
-                spin_unlock(&dcache_lock);
-        }
 
         ret = 0;
 bail:
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index f99bddc01716..df7fa251dcdc 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -453,17 +453,14 @@ static int remove_file(struct dentry *parent, char *name)
                 goto bail;
         }
 
-        spin_lock(&dcache_lock);
         spin_lock(&tmp->d_lock);
         if (!(d_unhashed(tmp) && tmp->d_inode)) {
-                dget_locked(tmp);
+                dget_dlock(tmp);
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
-                spin_unlock(&dcache_lock);
                 simple_unlink(parent->d_inode, tmp);
         } else {
                 spin_unlock(&tmp->d_lock);
-                spin_unlock(&dcache_lock);
         }
 
         ret = 0;
diff --git a/drivers/input/keyboard/tc3589x-keypad.c b/drivers/input/keyboard/tc3589x-keypad.c
index 69dc0cb20a00..dbbe761778d2 100644
--- a/drivers/input/keyboard/tc3589x-keypad.c
+++ b/drivers/input/keyboard/tc3589x-keypad.c
@@ -469,4 +469,4 @@ module_exit(tc3589x_keypad_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Jayeeta Banerjee/Sundar Iyer");
 MODULE_DESCRIPTION("TC35893 Keypad Driver");
-MODULE_ALIAS("platform:tc3589x-keypad")
+MODULE_ALIAS("platform:tc3589x-keypad");
diff --git a/drivers/media/video/tlg2300/pd-main.c b/drivers/media/video/tlg2300/pd-main.c
index c91424c0c135..99c81a9a4f46 100644
--- a/drivers/media/video/tlg2300/pd-main.c
+++ b/drivers/media/video/tlg2300/pd-main.c
@@ -452,7 +452,8 @@ static int poseidon_probe(struct usb_interface *interface,
 
         device_init_wakeup(&udev->dev, 1);
 #ifdef CONFIG_PM
-        pd->udev->autosuspend_delay = HZ * PM_SUSPEND_DELAY;
+        pm_runtime_set_autosuspend_delay(&pd->udev->dev,
+                        1000 * PM_SUSPEND_DELAY);
         usb_enable_autosuspend(pd->udev);
 
         if (in_hibernation(pd)) {
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index 35275ba7096f..12abd5b924b3 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -95,7 +95,8 @@
 #define twl_has_rtc()   false
 #endif
 
-#if defined(CONFIG_TWL4030_USB) || defined(CONFIG_TWL4030_USB_MODULE)
+#if defined(CONFIG_TWL4030_USB) || defined(CONFIG_TWL4030_USB_MODULE) ||\
+        defined(CONFIG_TWL6030_USB) || defined(CONFIG_TWL6030_USB_MODULE)
 #define twl_has_usb()   true
 #else
 #define twl_has_usb()   false
@@ -682,6 +683,43 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
                         usb3v1.dev = child;
                 }
         }
+        if (twl_has_usb() && pdata->usb && twl_class_is_6030()) {
+
+                static struct regulator_consumer_supply usb3v3 = {
+                        .supply =       "vusb",
+                };
+
+                if (twl_has_regulator()) {
+                        /* this is a template that gets copied */
+                        struct regulator_init_data usb_fixed = {
+                                .constraints.valid_modes_mask =
+                                        REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                                .constraints.valid_ops_mask =
+                                        REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+                        };
+
+                        child = add_regulator_linked(TWL6030_REG_VUSB,
+                                                      &usb_fixed, &usb3v3, 1);
+                        if (IS_ERR(child))
+                                return PTR_ERR(child);
+                }
+
+                child = add_child(0, "twl6030_usb",
+                        pdata->usb, sizeof(*pdata->usb),
+                        true,
+                        /* irq1 = VBUS_PRES, irq0 = USB ID */
+                        pdata->irq_base + USBOTG_INTR_OFFSET,
+                        pdata->irq_base + USB_PRES_INTR_OFFSET);
+
+                if (IS_ERR(child))
+                        return PTR_ERR(child);
+                /* we need to connect regulators to this transceiver */
+                if (twl_has_regulator() && child)
+                        usb3v3.dev = child;
+
+        }
 
         if (twl_has_watchdog()) {
                 child = add_child(0, "twl4030_wdt", NULL, 0, false, 0, 0);
@@ -815,10 +853,6 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
                 if (IS_ERR(child))
                         return PTR_ERR(child);
 
-                child = add_regulator(TWL6030_REG_VUSB, pdata->vusb);
-                if (IS_ERR(child))
-                        return PTR_ERR(child);
-
                 child = add_regulator(TWL6030_REG_VAUX1_6030, pdata->vaux1);
                 if (IS_ERR(child))
                         return PTR_ERR(child);
diff --git a/drivers/mfd/twl6030-irq.c b/drivers/mfd/twl6030-irq.c
index aaedb11d9d2c..06c8955907e9 100644
--- a/drivers/mfd/twl6030-irq.c
+++ b/drivers/mfd/twl6030-irq.c
@@ -74,7 +74,7 @@ static int twl6030_interrupt_mapping[24] = {
         USBOTG_INTR_OFFSET,     /* Bit 16       ID_WKUP                 */
         USBOTG_INTR_OFFSET,     /* Bit 17       VBUS_WKUP               */
         USBOTG_INTR_OFFSET,     /* Bit 18       ID                      */
-        USBOTG_INTR_OFFSET,     /* Bit 19       VBUS                    */
+        USB_PRES_INTR_OFFSET,   /* Bit 19       VBUS                    */
         CHARGER_INTR_OFFSET,    /* Bit 20       CHRG_CTRL               */
         CHARGER_INTR_OFFSET,    /* Bit 21       EXT_CHRG                */
         CHARGER_INTR_OFFSET,    /* Bit 22       INT_CHRG                */
@@ -128,6 +128,13 @@ static int twl6030_irq_thread(void *data)
 
                 sts.bytes[3] = 0; /* Only 24 bits are valid*/
 
+                /*
+                 * Since VBUS status bit is not reliable for VBUS disconnect
+                 * use CHARGER VBUS detection status bit instead.
+                 */
+                if (sts.bytes[2] & 0x10)
+                        sts.bytes[2] |= 0x08;
+
                 for (i = 0; sts.int_sts; sts.int_sts >>= 1, i++) {
                         local_irq_disable();
                         if (sts.int_sts & 0x1) {
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 4759d827e8c7..f511dd15fd31 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -1201,7 +1201,7 @@ err_unregister_chdev:
 static void __exit cleanup_mtdchar(void)
 {
         unregister_mtd_user(&mtdchar_notifier);
-        mntput(mtd_inode_mnt);
+        mntput_long(mtd_inode_mnt);
         unregister_filesystem(&mtd_inodefs_type);
         __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
 }
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index 10e3ab352175..298f2b0b6311 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -514,7 +514,7 @@ int i2400mu_probe(struct usb_interface *iface,
 #ifdef CONFIG_PM
         iface->needs_remote_wakeup = 1;         /* autosuspend (15s delay) */
         device_init_wakeup(dev, 1);
-        usb_dev->autosuspend_delay = 15 * HZ;
+        pm_runtime_set_autosuspend_delay(&usb_dev->dev, 15000);
         usb_enable_autosuspend(usb_dev);
 #endif
 
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 044fb22718d2..51c666fb67a4 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -45,8 +45,8 @@ static char *init_device;
 module_param_named(device, init_device, charp, 0400);
 MODULE_PARM_DESC(device, "specify initial device");
 
-static struct kmem_cache *zfcp_cache_hw_align(const char *name,
-                                              unsigned long size)
+static struct kmem_cache * __init zfcp_cache_hw_align(const char *name,
+                                                      unsigned long size)
 {
         return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
 }
@@ -311,8 +311,7 @@ int zfcp_status_read_refill(struct zfcp_adapter *adapter)
                 if (zfcp_fsf_status_read(adapter->qdio)) {
                         if (atomic_read(&adapter->stat_miss) >=
                             adapter->stat_read_buf_num) {
-                                zfcp_erp_adapter_reopen(adapter, 0, "axsref1",
-                                                        NULL);
+                                zfcp_erp_adapter_reopen(adapter, 0, "axsref1");
                                 return 1;
                         }
                         break;
@@ -459,7 +458,7 @@ void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
         sysfs_remove_group(&cdev->dev.kobj, &zfcp_sysfs_adapter_attrs);
 
         zfcp_erp_thread_kill(adapter);
-        zfcp_dbf_adapter_unregister(adapter->dbf);
+        zfcp_dbf_adapter_unregister(adapter);
         zfcp_qdio_destroy(adapter->qdio);
 
         zfcp_ccw_adapter_put(adapter); /* final put to release */
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index 0833c2b51e39..4f7852dd30c7 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -48,7 +48,7 @@ static int zfcp_ccw_activate(struct ccw_device *cdev)
 
         zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "ccresu2", NULL);
+                                "ccresu2");
         zfcp_erp_wait(adapter);
         flush_work(&adapter->scan_work);
 
@@ -182,7 +182,7 @@ static int zfcp_ccw_set_offline(struct ccw_device *cdev)
         if (!adapter)
                 return 0;
 
-        zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL);
+        zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1");
         zfcp_erp_wait(adapter);
 
         zfcp_ccw_adapter_put(adapter);
@@ -207,24 +207,24 @@ static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
         switch (event) {
         case CIO_GONE:
                 dev_warn(&cdev->dev, "The FCP device has been detached\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL);
+                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1");
                 break;
         case CIO_NO_PATH:
                 dev_warn(&cdev->dev,
                          "The CHPID for the FCP device is offline\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL);
+                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2");
                 break;
         case CIO_OPER:
                 dev_info(&cdev->dev, "The FCP device is operational again\n");
                 zfcp_erp_set_adapter_status(adapter,
                                             ZFCP_STATUS_COMMON_RUNNING);
                 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        "ccnoti4", NULL);
+                                        "ccnoti4");
                 break;
         case CIO_BOXED:
                 dev_warn(&cdev->dev, "The FCP device did not respond within "
                                      "the specified time\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL);
+                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5");
                 break;
         }
 
@@ -243,7 +243,7 @@ static void zfcp_ccw_shutdown(struct ccw_device *cdev)
         if (!adapter)
                 return;
 
-        zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL);
+        zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1");
         zfcp_erp_wait(adapter);
         zfcp_erp_thread_kill(adapter);
 
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index d692e229ecba..46342fee394d 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -288,7 +288,7 @@ void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
                     (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
                         zfcp_erp_port_reopen(port,
                                              ZFCP_STATUS_COMMON_ERP_FAILED,
-                                             "cfaac_1", NULL);
+                                             "cfaac_1");
         }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
 
@@ -299,7 +299,7 @@ void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
                     (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
                         zfcp_erp_lun_reopen(sdev,
                                             ZFCP_STATUS_COMMON_ERP_FAILED,
-                                            "cfaac_2", NULL);
+                                            "cfaac_2");
         }
 }
 
@@ -426,7 +426,7 @@ int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
                         zfcp_scsi_dev_lun(sdev),
                         (unsigned long long)zfcp_sdev->port->wwpn);
                 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
-                zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6", NULL);
+                zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6");
                 return -EACCES;
         }
 
@@ -437,7 +437,7 @@ int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
                         zfcp_scsi_dev_lun(sdev),
                         (unsigned long long)zfcp_sdev->port->wwpn);
                 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
-                zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8", NULL);
+                zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8");
                 return -EACCES;
         }
 
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 2cdd6b28ff7f..96d1462e0bf5 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -3,7 +3,7 @@
  *
  * Debug traces for zfcp.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -22,980 +22,392 @@ module_param(dbfsize, uint, 0400);
 MODULE_PARM_DESC(dbfsize,
                  "number of pages for each debug feature area (default 4)");
 
-static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len,
-                             int level, char *from, int from_len)
+static inline unsigned int zfcp_dbf_plen(unsigned int offset)
 {
-        int offset;
-        struct zfcp_dbf_dump *dump = to;
-        int room = to_len - sizeof(*dump);
-
-        for (offset = 0; offset < from_len; offset += dump->size) {
-                memset(to, 0, to_len);
-                strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
-                dump->total_size = from_len;
-                dump->offset = offset;
-                dump->size = min(from_len - offset, room);
-                memcpy(dump->data, from + offset, dump->size);
-                debug_event(dbf, level, dump, dump->size + sizeof(*dump));
-        }
+        return sizeof(struct zfcp_dbf_pay) + offset - ZFCP_DBF_PAY_MAX_REC;
 }
 
-static void zfcp_dbf_tag(char **p, const char *label, const char *tag)
+static inline
+void zfcp_dbf_pl_write(struct zfcp_dbf *dbf, void *data, u16 length, char *area,
+                       u64 req_id)
 {
-        int i;
-
-        *p += sprintf(*p, "%-24s", label);
-        for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++)
-                *p += sprintf(*p, "%c", tag[i]);
-        *p += sprintf(*p, "\n");
-}
+        struct zfcp_dbf_pay *pl = &dbf->pay_buf;
+        u16 offset = 0, rec_length;
 
-static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2)
-{
-        *buf += sprintf(*buf, "%-24s%s\n", s1, s2);
-}
+        spin_lock(&dbf->pay_lock);
+        memset(pl, 0, sizeof(*pl));
+        pl->fsf_req_id = req_id;
+        memcpy(pl->area, area, ZFCP_DBF_TAG_LEN);
 
-static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...)
-{
-        va_list arg;
+        while (offset < length) {
+                rec_length = min((u16) ZFCP_DBF_PAY_MAX_REC,
+                                 (u16) (length - offset));
+                memcpy(pl->data, data + offset, rec_length);
+                debug_event(dbf->pay, 1, pl, zfcp_dbf_plen(rec_length));
 
-        *buf += sprintf(*buf, "%-24s", s);
-        va_start(arg, format);
-        *buf += vsprintf(*buf, format, arg);
-        va_end(arg);
-        *buf += sprintf(*buf, "\n");
-}
-
-static void zfcp_dbf_outd(char **p, const char *label, char *buffer,
-                          int buflen, int offset, int total_size)
-{
-        if (!offset)
-                *p += sprintf(*p, "%-24s  ", label);
-        while (buflen--) {
-                if (offset > 0) {
-                        if ((offset % 32) == 0)
-                                *p += sprintf(*p, "\n%-24c  ", ' ');
-                        else if ((offset % 4) == 0)
-                                *p += sprintf(*p, " ");
-                }
-                *p += sprintf(*p, "%02x", *buffer++);
-                if (++offset == total_size) {
-                        *p += sprintf(*p, "\n");
-                        break;
-                }
+                offset += rec_length;
+                pl->counter++;
         }
-        if (!total_size)
-                *p += sprintf(*p, "\n");
-}
 
-static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view,
-                                int area, debug_entry_t *entry, char *out_buf)
-{
-        struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry);
-        struct timespec t;
-        char *p = out_buf;
-
-        if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) {
-                stck_to_timespec(entry->id.stck, &t);
-                zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu",
-                             t.tv_sec, t.tv_nsec);
-                zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid);
-        } else  {
-                zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset,
-                              dump->total_size);
-                if ((dump->offset + dump->size) == dump->total_size)
-                        p += sprintf(p, "\n");
-        }
-        return p - out_buf;
+        spin_unlock(&dbf->pay_lock);
 }
 
-void _zfcp_dbf_hba_fsf_response(const char *tag2, int level,
-                                struct zfcp_fsf_req *fsf_req,
-                                struct zfcp_dbf *dbf)
+/**
+ * zfcp_dbf_hba_fsf_res - trace event for fsf responses
+ * @tag: tag indicating which kind of unsolicited status has been received
+ * @req: request for which a response was received
+ */
+void zfcp_dbf_hba_fsf_res(char *tag, struct zfcp_fsf_req *req)
 {
-        struct fsf_qtcb *qtcb = fsf_req->qtcb;
-        union fsf_prot_status_qual *prot_status_qual =
-                                        &qtcb->prefix.prot_status_qual;
-        union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual;
-        struct scsi_cmnd *scsi_cmnd;
-        struct zfcp_port *port;
-        struct zfcp_unit *unit;
-        struct zfcp_send_els *send_els;
-        struct zfcp_dbf_hba_record *rec = &dbf->hba_buf;
-        struct zfcp_dbf_hba_record_response *response = &rec->u.response;
+        struct zfcp_dbf *dbf = req->adapter->dbf;
+        struct fsf_qtcb_prefix *q_pref = &req->qtcb->prefix;
+        struct fsf_qtcb_header *q_head = &req->qtcb->header;
+        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->hba_lock, flags);
         memset(rec, 0, sizeof(*rec));
-        strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE);
-        strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
-
-        response->fsf_command = fsf_req->fsf_command;
-        response->fsf_reqid = fsf_req->req_id;
-        response->fsf_seqno = fsf_req->seq_no;
-        response->fsf_issued = fsf_req->issued;
-        response->fsf_prot_status = qtcb->prefix.prot_status;
-        response->fsf_status = qtcb->header.fsf_status;
-        memcpy(response->fsf_prot_status_qual,
-               prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE);
-        memcpy(response->fsf_status_qual,
-               fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE);
-        response->fsf_req_status = fsf_req->status;
-        response->sbal_first = fsf_req->qdio_req.sbal_first;
-        response->sbal_last = fsf_req->qdio_req.sbal_last;
-        response->sbal_response = fsf_req->qdio_req.sbal_response;
-        response->pool = fsf_req->pool != NULL;
-        response->erp_action = (unsigned long)fsf_req->erp_action;
-
-        switch (fsf_req->fsf_command) {
-        case FSF_QTCB_FCP_CMND:
-                if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
-                        break;
-                scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
-                if (scsi_cmnd) {
-                        response->u.fcp.cmnd = (unsigned long)scsi_cmnd;
-                        response->u.fcp.data_dir =
-                                qtcb->bottom.io.data_direction;
-                }
-                break;
-
-        case FSF_QTCB_OPEN_PORT_WITH_DID:
-        case FSF_QTCB_CLOSE_PORT:
-        case FSF_QTCB_CLOSE_PHYSICAL_PORT:
-                port = (struct zfcp_port *)fsf_req->data;
-                response->u.port.wwpn = port->wwpn;
-                response->u.port.d_id = port->d_id;
-                response->u.port.port_handle = qtcb->header.port_handle;
-                break;
-
-        case FSF_QTCB_OPEN_LUN:
-        case FSF_QTCB_CLOSE_LUN:
-                unit = (struct zfcp_unit *)fsf_req->data;
-                port = unit->port;
-                response->u.unit.wwpn = port->wwpn;
-                response->u.unit.fcp_lun = unit->fcp_lun;
-                response->u.unit.port_handle = qtcb->header.port_handle;
-                response->u.unit.lun_handle = qtcb->header.lun_handle;
-                break;
-
-        case FSF_QTCB_SEND_ELS:
-                send_els = (struct zfcp_send_els *)fsf_req->data;
-                response->u.els.d_id = ntoh24(qtcb->bottom.support.d_id);
-                break;
-
-        case FSF_QTCB_ABORT_FCP_CMND:
-        case FSF_QTCB_SEND_GENERIC:
-        case FSF_QTCB_EXCHANGE_CONFIG_DATA:
-        case FSF_QTCB_EXCHANGE_PORT_DATA:
-        case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
-        case FSF_QTCB_UPLOAD_CONTROL_FILE:
-                break;
-        }
-
-        debug_event(dbf->hba, level, rec, sizeof(*rec));
 
-        /* have fcp channel microcode fixed to use as little as possible */
-        if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) {
-                /* adjust length skipping trailing zeros */
-                char *buf = (char *)qtcb + qtcb->header.log_start;
-                int len = qtcb->header.log_length;
-                for (; len && !buf[len - 1]; len--);
-                zfcp_dbf_hexdump(dbf->hba, rec, sizeof(*rec), level, buf,
-                                 len);
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_HBA_RES;
+        rec->fsf_req_id = req->req_id;
+        rec->fsf_req_status = req->status;
+        rec->fsf_cmd = req->fsf_command;
+        rec->fsf_seq_no = req->seq_no;
+        rec->u.res.req_issued = req->issued;
+        rec->u.res.prot_status = q_pref->prot_status;
+        rec->u.res.fsf_status = q_head->fsf_status;
+
+        memcpy(rec->u.res.prot_status_qual, &q_pref->prot_status_qual,
+               FSF_PROT_STATUS_QUAL_SIZE);
+        memcpy(rec->u.res.fsf_status_qual, &q_head->fsf_status_qual,
+               FSF_STATUS_QUALIFIER_SIZE);
+
+        if (req->fsf_command != FSF_QTCB_FCP_CMND) {
+                rec->pl_len = q_head->log_length;
+                zfcp_dbf_pl_write(dbf, (char *)q_pref + q_head->log_start,
+                                  rec->pl_len, "fsf_res", req->req_id);
         }
 
-        spin_unlock_irqrestore(&dbf->hba_lock, flags);
-}
-
-void _zfcp_dbf_hba_fsf_unsol(const char *tag, int level, struct zfcp_dbf *dbf,
-                             struct fsf_status_read_buffer *status_buffer)
-{
-        struct zfcp_dbf_hba_record *rec = &dbf->hba_buf;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dbf->hba_lock, flags);
-        memset(rec, 0, sizeof(*rec));
-        strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE);
-        strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE);
-
-        rec->u.status.failed = atomic_read(&dbf->adapter->stat_miss);
-        if (status_buffer != NULL) {
-                rec->u.status.status_type = status_buffer->status_type;
-                rec->u.status.status_subtype = status_buffer->status_subtype;
-                memcpy(&rec->u.status.queue_designator,
-                       &status_buffer->queue_designator,
-                       sizeof(struct fsf_queue_designator));
-
-                switch (status_buffer->status_type) {
-                case FSF_STATUS_READ_SENSE_DATA_AVAIL:
-                        rec->u.status.payload_size =
-                            ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL;
-                        break;
-
-                case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
-                        rec->u.status.payload_size =
-                            ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD;
-                        break;
-
-                case FSF_STATUS_READ_LINK_DOWN:
-                        switch (status_buffer->status_subtype) {
-                        case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
-                        case FSF_STATUS_READ_SUB_FDISC_FAILED:
-                                rec->u.status.payload_size =
-                                        sizeof(struct fsf_link_down_info);
-                        }
-                        break;
-
-                case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
-                        rec->u.status.payload_size =
-                            ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT;
-                        break;
-                }
-                memcpy(&rec->u.status.payload,
-                       &status_buffer->payload, rec->u.status.payload_size);
-        }
-
-        debug_event(dbf->hba, level, rec, sizeof(*rec));
+        debug_event(dbf->hba, 1, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
 /**
- * zfcp_dbf_hba_qdio - trace event for QDIO related failure
- * @qdio: qdio structure affected by this QDIO related event
- * @qdio_error: as passed by qdio module
- * @sbal_index: first buffer with error condition, as passed by qdio module
- * @sbal_count: number of buffers affected, as passed by qdio module
+ * zfcp_dbf_hba_fsf_uss - trace event for an unsolicited status buffer
+ * @tag: tag indicating which kind of unsolicited status has been received
+ * @req: request providing the unsolicited status
  */
-void zfcp_dbf_hba_qdio(struct zfcp_dbf *dbf, unsigned int qdio_error,
-                       int sbal_index, int sbal_count)
+void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req)
 {
-        struct zfcp_dbf_hba_record *r = &dbf->hba_buf;
+        struct zfcp_dbf *dbf = req->adapter->dbf;
+        struct fsf_status_read_buffer *srb = req->data;
+        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->hba_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE);
-        r->u.qdio.qdio_error = qdio_error;
-        r->u.qdio.sbal_index = sbal_index;
-        r->u.qdio.sbal_count = sbal_count;
-        debug_event(dbf->hba, 0, r, sizeof(*r));
+        memset(rec, 0, sizeof(*rec));
+
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_HBA_USS;
+        rec->fsf_req_id = req->req_id;
+        rec->fsf_req_status = req->status;
+        rec->fsf_cmd = req->fsf_command;
+
+        if (!srb)
+                goto log;
+
+        rec->u.uss.status_type = srb->status_type;
+        rec->u.uss.status_subtype = srb->status_subtype;
+        rec->u.uss.d_id = ntoh24(srb->d_id);
+        rec->u.uss.lun = srb->fcp_lun;
+        memcpy(&rec->u.uss.queue_designator, &srb->queue_designator,
+               sizeof(rec->u.uss.queue_designator));
+
+        /* status read buffer payload length */
+        rec->pl_len = (!srb->length) ? 0 : srb->length -
+                        offsetof(struct fsf_status_read_buffer, payload);
+
+        if (rec->pl_len)
+                zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len,
+                                  "fsf_uss", req->req_id);
+log:
+        debug_event(dbf->hba, 2, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
 /**
- * zfcp_dbf_hba_berr - trace event for bit error threshold
- * @dbf: dbf structure affected by this QDIO related event
- * @req: fsf request
+ * zfcp_dbf_hba_bit_err - trace event for bit error conditions
+ * @tag: tag indicating which kind of unsolicited status has been received
+ * @req: request which caused the bit_error condition
  */
-void zfcp_dbf_hba_berr(struct zfcp_dbf *dbf, struct zfcp_fsf_req *req)
+void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req)
 {
-        struct zfcp_dbf_hba_record *r = &dbf->hba_buf;
+        struct zfcp_dbf *dbf = req->adapter->dbf;
+        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
         struct fsf_status_read_buffer *sr_buf = req->data;
-        struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->hba_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE);
-        memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload));
-        debug_event(dbf->hba, 0, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->hba_lock, flags);
-}
-static void zfcp_dbf_hba_view_response(char **p,
-                                       struct zfcp_dbf_hba_record_response *r)
-{
-        struct timespec t;
-
-        zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command);
-        zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
-        zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno);
-        stck_to_timespec(r->fsf_issued, &t);
-        zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
-        zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status);
-        zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status);
-        zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual,
-                      FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE);
-        zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual,
-                      FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE);
-        zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status);
-        zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first);
-        zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last);
-        zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response);
-        zfcp_dbf_out(p, "pool", "0x%02x", r->pool);
-
-        switch (r->fsf_command) {
-        case FSF_QTCB_FCP_CMND:
-                if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
-                        break;
-                zfcp_dbf_out(p, "data_direction", "0x%04x", r->u.fcp.data_dir);
-                zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd);
-                *p += sprintf(*p, "\n");
-                break;
-
-        case FSF_QTCB_OPEN_PORT_WITH_DID:
-        case FSF_QTCB_CLOSE_PORT:
-        case FSF_QTCB_CLOSE_PHYSICAL_PORT:
-                zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn);
-                zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id);
-                zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle);
-                break;
-
-        case FSF_QTCB_OPEN_LUN:
-        case FSF_QTCB_CLOSE_LUN:
-                zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn);
-                zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun);
-                zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle);
-                zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle);
-                break;
-
-        case FSF_QTCB_SEND_ELS:
-                zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id);
-                break;
-
-        case FSF_QTCB_ABORT_FCP_CMND:
-        case FSF_QTCB_SEND_GENERIC:
-        case FSF_QTCB_EXCHANGE_CONFIG_DATA:
-        case FSF_QTCB_EXCHANGE_PORT_DATA:
-        case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
-        case FSF_QTCB_UPLOAD_CONTROL_FILE:
-                break;
-        }
-}
-
-static void zfcp_dbf_hba_view_status(char **p,
-                                     struct zfcp_dbf_hba_record_status *r)
-{
-        zfcp_dbf_out(p, "failed", "0x%02x", r->failed);
-        zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type);
-        zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype);
-        zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator,
-                      sizeof(struct fsf_queue_designator), 0,
-                      sizeof(struct fsf_queue_designator));
-        zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0,
-                      r->payload_size);
-}
-
-static void zfcp_dbf_hba_view_qdio(char **p, struct zfcp_dbf_hba_record_qdio *r)
-{
-        zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error);
-        zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index);
-        zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count);
-}
+        memset(rec, 0, sizeof(*rec));
 
-static void zfcp_dbf_hba_view_berr(char **p, struct fsf_bit_error_payload *r)
-{
-        zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count);
-        zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count);
-        zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count);
-        zfcp_dbf_out(p, "prim_seq_err", "%d",
-                     r->primitive_sequence_error_count);
-        zfcp_dbf_out(p, "inval_trans_word_err", "%d",
-                     r->invalid_transmission_word_error_count);
-        zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count);
-        zfcp_dbf_out(p, "prim_seq_event_to", "%d",
-                     r->primitive_sequence_event_timeout_count);
-        zfcp_dbf_out(p, "elast_buf_overrun_err", "%d",
-                     r->elastic_buffer_overrun_error_count);
-        zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d",
-                     r->advertised_receive_b2b_credit);
-        zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d",
-                     r->current_receive_b2b_credit);
-        zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d",
-                     r->advertised_transmit_b2b_credit);
-        zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d",
-                     r->current_transmit_b2b_credit);
-}
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_HBA_BIT;
+        rec->fsf_req_id = req->req_id;
+        rec->fsf_req_status = req->status;
+        rec->fsf_cmd = req->fsf_command;
+        memcpy(&rec->u.be, &sr_buf->payload.bit_error,
+               sizeof(struct fsf_bit_error_payload));
 
-static int zfcp_dbf_hba_view_format(debug_info_t *id, struct debug_view *view,
-                                    char *out_buf, const char *in_buf)
-{
-        struct zfcp_dbf_hba_record *r = (struct zfcp_dbf_hba_record *)in_buf;
-        char *p = out_buf;
-
-        if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
-                return 0;
-
-        zfcp_dbf_tag(&p, "tag", r->tag);
-        if (isalpha(r->tag2[0]))
-                zfcp_dbf_tag(&p, "tag2", r->tag2);
-
-        if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_response(&p, &r->u.response);
-        else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_status(&p, &r->u.status);
-        else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_qdio(&p, &r->u.qdio);
-        else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_berr(&p, &r->u.berr);
-
-        if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0)
-                p += sprintf(p, "\n");
-        return p - out_buf;
+        debug_event(dbf->hba, 1, rec, sizeof(*rec));
+        spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
-static struct debug_view zfcp_dbf_hba_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_hba_view_format,
-};
-
-static const char *zfcp_dbf_rec_tags[] = {
-        [ZFCP_REC_DBF_ID_THREAD] = "thread",
-        [ZFCP_REC_DBF_ID_TARGET] = "target",
-        [ZFCP_REC_DBF_ID_TRIGGER] = "trigger",
-        [ZFCP_REC_DBF_ID_ACTION] = "action",
-};
-
-static int zfcp_dbf_rec_view_format(debug_info_t *id, struct debug_view *view,
-                                    char *buf, const char *_rec)
+static void zfcp_dbf_set_common(struct zfcp_dbf_rec *rec,
+                                struct zfcp_adapter *adapter,
+                                struct zfcp_port *port,
+                                struct scsi_device *sdev)
 {
-        struct zfcp_dbf_rec_record *r = (struct zfcp_dbf_rec_record *)_rec;
-        char *p = buf;
-        char hint[ZFCP_DBF_ID_SIZE + 1];
-
-        memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE);
-        hint[ZFCP_DBF_ID_SIZE] = 0;
-        zfcp_dbf_outs(&p, "tag", zfcp_dbf_rec_tags[r->id]);
-        zfcp_dbf_outs(&p, "hint", hint);
-        switch (r->id) {
-        case ZFCP_REC_DBF_ID_THREAD:
-                zfcp_dbf_out(&p, "total", "%d", r->u.thread.total);
-                zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready);
-                zfcp_dbf_out(&p, "running", "%d", r->u.thread.running);
-                break;
-        case ZFCP_REC_DBF_ID_TARGET:
-                zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref);
-                zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status);
-                zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count);
-                zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id);
-                zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn);
-                zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun);
-                break;
-        case ZFCP_REC_DBF_ID_TRIGGER:
-                zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref);
-                zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action);
-                zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want);
-                zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need);
-                zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn);
-                zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun);
-                zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as);
-                zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps);
-                zfcp_dbf_out(&p, "lun_status", "0x%08x", r->u.trigger.ls);
-                break;
-        case ZFCP_REC_DBF_ID_ACTION:
-                zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action);
-                zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req);
-                zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status);
-                zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step);
-                break;
+        rec->adapter_status = atomic_read(&adapter->status);
+        if (port) {
+                rec->port_status = atomic_read(&port->status);
+                rec->wwpn = port->wwpn;
+                rec->d_id = port->d_id;
+        }
+        if (sdev) {
+                rec->lun_status = atomic_read(&sdev_to_zfcp(sdev)->status);
+                rec->lun = zfcp_scsi_dev_lun(sdev);
         }
-        p += sprintf(p, "\n");
-        return p - buf;
 }
 
-static struct debug_view zfcp_dbf_rec_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_rec_view_format,
-};
-
 /**
- * zfcp_dbf_rec_thread - trace event related to recovery thread operation
- * @id2: identifier for event
- * @dbf: reference to dbf structure
- * This function assumes that the caller is holding erp_lock.
+ * zfcp_dbf_rec_trig - trace event related to triggered recovery
+ * @tag: identifier for event
+ * @adapter: adapter on which the erp_action should run
+ * @port: remote port involved in the erp_action
+ * @sdev: scsi device involved in the erp_action
+ * @want: wanted erp_action
+ * @need: required erp_action
+ *
+ * The adapter->erp_lock has to be held.
  */
-void zfcp_dbf_rec_thread(char *id2, struct zfcp_dbf *dbf)
+void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter,
+                       struct zfcp_port *port, struct scsi_device *sdev,
+                       u8 want, u8 need)
 {
-        struct zfcp_adapter *adapter = dbf->adapter;
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
-        unsigned long flags = 0;
+        struct zfcp_dbf *dbf = adapter->dbf;
+        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
         struct list_head *entry;
-        unsigned ready = 0, running = 0, total;
-
-        list_for_each(entry, &adapter->erp_ready_head)
-                ready++;
-        list_for_each(entry, &adapter->erp_running_head)
-                running++;
-        total = adapter->erp_total_count;
-
-        spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_THREAD;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.thread.total = total;
-        r->u.thread.ready = ready;
-        r->u.thread.running = running;
-        debug_event(dbf->rec, 6, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->rec_lock, flags);
-}
-
-/**
- * zfcp_dbf_rec_thread - trace event related to recovery thread operation
- * @id2: identifier for event
- * @adapter: adapter
- * This function assumes that the caller does not hold erp_lock.
- */
-void zfcp_dbf_rec_thread_lock(char *id2, struct zfcp_dbf *dbf)
-{
-        struct zfcp_adapter *adapter = dbf->adapter;
-        unsigned long flags;
-
-        read_lock_irqsave(&adapter->erp_lock, flags);
-        zfcp_dbf_rec_thread(id2, dbf);
-        read_unlock_irqrestore(&adapter->erp_lock, flags);
-}
-
-static void zfcp_dbf_rec_target(char *id2, void *ref, struct zfcp_dbf *dbf,
-                                atomic_t *status, atomic_t *erp_count, u64 wwpn,
-                                u32 d_id, u64 fcp_lun)
-{
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_TARGET;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.target.ref = (unsigned long)ref;
-        r->u.target.status = atomic_read(status);
-        r->u.target.wwpn = wwpn;
-        r->u.target.d_id = d_id;
-        r->u.target.fcp_lun = fcp_lun;
-        r->u.target.erp_count = atomic_read(erp_count);
-        debug_event(dbf->rec, 3, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->rec_lock, flags);
-}
-
-/**
- * zfcp_dbf_rec_adapter - trace event for adapter state change
- * @id: identifier for trigger of state change
- * @ref: additional reference (e.g. request)
- * @dbf: reference to dbf structure
- */
-void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf)
-{
-        struct zfcp_adapter *adapter = dbf->adapter;
-
-        zfcp_dbf_rec_target(id, ref, dbf, &adapter->status,
-                            &adapter->erp_counter, 0, 0,
-                            ZFCP_DBF_INVALID_LUN);
-}
-
-/**
- * zfcp_dbf_rec_port - trace event for port state change
- * @id: identifier for trigger of state change
- * @ref: additional reference (e.g. request)
- * @port: port
- */
-void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port)
-{
-        struct zfcp_dbf *dbf = port->adapter->dbf;
+        memset(rec, 0, sizeof(*rec));
 
-        zfcp_dbf_rec_target(id, ref, dbf, &port->status,
-                            &port->erp_counter, port->wwpn, port->d_id,
-                            ZFCP_DBF_INVALID_LUN);
-}
+        rec->id = ZFCP_DBF_REC_TRIG;
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        zfcp_dbf_set_common(rec, adapter, port, sdev);
 
-/**
- * zfcp_dbf_rec_lun - trace event for LUN state change
- * @id: identifier for trigger of state change
- * @ref: additional reference (e.g. request)
- * @sdev: SCSI device
- */
-void zfcp_dbf_rec_lun(char *id, void *ref, struct scsi_device *sdev)
-{
-        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
-        struct zfcp_port *port = zfcp_sdev->port;
-        struct zfcp_dbf *dbf = port->adapter->dbf;
+        list_for_each(entry, &adapter->erp_ready_head)
+                rec->u.trig.ready++;
 
-        zfcp_dbf_rec_target(id, ref, dbf, &zfcp_sdev->status,
-                            &zfcp_sdev->erp_counter, port->wwpn, port->d_id,
-                            zfcp_scsi_dev_lun(sdev));
-}
+        list_for_each(entry, &adapter->erp_running_head)
+                rec->u.trig.running++;
 
-/**
- * zfcp_dbf_rec_trigger - trace event for triggered error recovery
- * @id2: identifier for error recovery trigger
- * @ref: additional reference (e.g. request)
- * @want: originally requested error recovery action
- * @need: error recovery action actually initiated
- * @action: address of error recovery action struct
- * @adapter: adapter
- * @port: port
- * @sdev: SCSI device
- */
-void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action,
-                          struct zfcp_adapter *adapter, struct zfcp_port *port,
-                          struct scsi_device *sdev)
-{
-        struct zfcp_dbf *dbf = adapter->dbf;
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
-        unsigned long flags;
+        rec->u.trig.want = want;
+        rec->u.trig.need = need;
 
-        spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_TRIGGER;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.trigger.ref = (unsigned long)ref;
-        r->u.trigger.want = want;
-        r->u.trigger.need = need;
-        r->u.trigger.action = (unsigned long)action;
-        r->u.trigger.as = atomic_read(&adapter->status);
-        if (port) {
-                r->u.trigger.ps = atomic_read(&port->status);
-                r->u.trigger.wwpn = port->wwpn;
-        }
-        if (sdev)
-                r->u.trigger.ls = atomic_read(&sdev_to_zfcp(sdev)->status);
-        r->u.trigger.fcp_lun = sdev ? zfcp_scsi_dev_lun(sdev) :
-                                      ZFCP_DBF_INVALID_LUN;
-        debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r));
+        debug_event(dbf->rec, 1, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
 
+
 /**
- * zfcp_dbf_rec_action - trace event showing progress of recovery action
- * @id2: identifier
- * @erp_action: error recovery action struct pointer
+ * zfcp_dbf_rec_run - trace event related to running recovery
+ * @tag: identifier for event
+ * @erp: erp_action running
  */
-void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action)
+void zfcp_dbf_rec_run(char *tag, struct zfcp_erp_action *erp)
 {
-        struct zfcp_dbf *dbf = erp_action->adapter->dbf;
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
+        struct zfcp_dbf *dbf = erp->adapter->dbf;
+        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_ACTION;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.action.action = (unsigned long)erp_action;
-        r->u.action.status = erp_action->status;
-        r->u.action.step = erp_action->step;
-        r->u.action.fsf_req = erp_action->fsf_req_id;
-        debug_event(dbf->rec, 5, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->rec_lock, flags);
-}
+        memset(rec, 0, sizeof(*rec));
 
-/**
- * zfcp_dbf_san_ct_request - trace event for issued CT request
- * @fsf_req: request containing issued CT data
- * @d_id: destination id where ct request is sent to
- */
-void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req, u32 d_id)
-{
-        struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data;
-        struct zfcp_adapter *adapter = fsf_req->adapter;
-        struct zfcp_dbf *dbf = adapter->dbf;
-        struct fc_ct_hdr *hdr = sg_virt(ct->req);
-        struct zfcp_dbf_san_record *r = &dbf->san_buf;
-        struct zfcp_dbf_san_record_ct_request *oct = &r->u.ct_req;
-        int level = 3;
-        unsigned long flags;
+        rec->id = ZFCP_DBF_REC_RUN;
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev);
 
-        spin_lock_irqsave(&dbf->san_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE);
-        r->fsf_reqid = fsf_req->req_id;
-        r->fsf_seqno = fsf_req->seq_no;
-        oct->d_id = d_id;
-        oct->cmd_req_code = hdr->ct_cmd;
-        oct->revision = hdr->ct_rev;
-        oct->gs_type = hdr->ct_fs_type;
-        oct->gs_subtype = hdr->ct_fs_subtype;
-        oct->options = hdr->ct_options;
-        oct->max_res_size = hdr->ct_mr_size;
-        oct->len = min((int)ct->req->length - (int)sizeof(struct fc_ct_hdr),
-                       ZFCP_DBF_SAN_MAX_PAYLOAD);
-        debug_event(dbf->san, level, r, sizeof(*r));
-        zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level,
-                         (void *)hdr + sizeof(struct fc_ct_hdr), oct->len);
-        spin_unlock_irqrestore(&dbf->san_lock, flags);
-}
+        rec->u.run.fsf_req_id = erp->fsf_req_id;
+        rec->u.run.rec_status = erp->status;
+        rec->u.run.rec_step = erp->step;
+        rec->u.run.rec_action = erp->action;
 
-/**
- * zfcp_dbf_san_ct_response - trace event for completion of CT request
- * @fsf_req: request containing CT response
- */
-void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req)
-{
-        struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data;
-        struct zfcp_adapter *adapter = fsf_req->adapter;
-        struct fc_ct_hdr *hdr = sg_virt(ct->resp);
-        struct zfcp_dbf *dbf = adapter->dbf;
-        struct zfcp_dbf_san_record *r = &dbf->san_buf;
-        struct zfcp_dbf_san_record_ct_response *rct = &r->u.ct_resp;
-        int level = 3;
-        unsigned long flags;
+        if (erp->sdev)
+                rec->u.run.rec_count =
+                        atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter);
+        else if (erp->port)
+                rec->u.run.rec_count = atomic_read(&erp->port->erp_counter);
+        else
+                rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter);
 
-        spin_lock_irqsave(&dbf->san_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
-        r->fsf_reqid = fsf_req->req_id;
-        r->fsf_seqno = fsf_req->seq_no;
-        rct->cmd_rsp_code = hdr->ct_cmd;
-        rct->revision = hdr->ct_rev;
-        rct->reason_code = hdr->ct_reason;
-        rct->expl = hdr->ct_explan;
-        rct->vendor_unique = hdr->ct_vendor;
-        rct->max_res_size = hdr->ct_mr_size;
-        rct->len = min((int)ct->resp->length - (int)sizeof(struct fc_ct_hdr),
-                       ZFCP_DBF_SAN_MAX_PAYLOAD);
-        debug_event(dbf->san, level, r, sizeof(*r));
-        zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level,
-                         (void *)hdr + sizeof(struct fc_ct_hdr), rct->len);
-        spin_unlock_irqrestore(&dbf->san_lock, flags);
+        debug_event(dbf->rec, 1, rec, sizeof(*rec));
+        spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
 
-static void zfcp_dbf_san_els(const char *tag, int level,
-                             struct zfcp_fsf_req *fsf_req, u32 d_id,
-                             void *buffer, int buflen)
+static inline
+void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf, void *data, u8 id, u16 len,
+                  u64 req_id, u32 d_id)
 {
-        struct zfcp_adapter *adapter = fsf_req->adapter;
-        struct zfcp_dbf *dbf = adapter->dbf;
-        struct zfcp_dbf_san_record *rec = &dbf->san_buf;
+        struct zfcp_dbf_san *rec = &dbf->san_buf;
+        u16 rec_len;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->san_lock, flags);
         memset(rec, 0, sizeof(*rec));
-        strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
-        rec->fsf_reqid = fsf_req->req_id;
-        rec->fsf_seqno = fsf_req->seq_no;
-        rec->u.els.d_id = d_id;
-        debug_event(dbf->san, level, rec, sizeof(*rec));
-        zfcp_dbf_hexdump(dbf->san, rec, sizeof(*rec), level,
-                         buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD));
+
+        rec->id = id;
+        rec->fsf_req_id = req_id;
+        rec->d_id = d_id;
+        rec_len = min(len, (u16)ZFCP_DBF_SAN_MAX_PAYLOAD);
+        memcpy(rec->payload, data, rec_len);
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+
+        debug_event(dbf->san, 1, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->san_lock, flags);
 }
 
 /**
- * zfcp_dbf_san_els_request - trace event for issued ELS
- * @fsf_req: request containing issued ELS
+ * zfcp_dbf_san_req - trace event for issued SAN request
+ * @tag: indentifier for event
+ * @fsf_req: request containing issued CT data
+ * d_id: destination ID
  */
-void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id)
 {
-        struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data;
-        u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id);
+        struct zfcp_dbf *dbf = fsf->adapter->dbf;
+        struct zfcp_fsf_ct_els *ct_els = fsf->data;
+        u16 length;
 
-        zfcp_dbf_san_els("oels", 2, fsf_req, d_id,
-                         sg_virt(els->req), els->req->length);
+        length = (u16)(ct_els->req->length + FC_CT_HDR_LEN);
+        zfcp_dbf_san(tag, dbf, sg_virt(ct_els->req), ZFCP_DBF_SAN_REQ, length,
+                     fsf->req_id, d_id);
 }
 
 /**
- * zfcp_dbf_san_els_response - trace event for completed ELS
- * @fsf_req: request containing ELS response
+ * zfcp_dbf_san_res - trace event for received SAN request
+ * @tag: indentifier for event
+ * @fsf_req: request containing issued CT data
  */
-void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf)
 {
-        struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data;
-        u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id);
+        struct zfcp_dbf *dbf = fsf->adapter->dbf;
+        struct zfcp_fsf_ct_els *ct_els = fsf->data;
+        u16 length;
 
-        zfcp_dbf_san_els("rels", 2, fsf_req, d_id,
-                               sg_virt(els->resp), els->resp->length);
+        length = (u16)(ct_els->resp->length + FC_CT_HDR_LEN);
+        zfcp_dbf_san(tag, dbf, sg_virt(ct_els->resp), ZFCP_DBF_SAN_RES, length,
+                     fsf->req_id, 0);
 }
 
 /**
- * zfcp_dbf_san_incoming_els - trace event for incomig ELS
- * @fsf_req: request containing unsolicited status buffer with incoming ELS
+ * zfcp_dbf_san_in_els - trace event for incoming ELS
+ * @tag: indentifier for event
+ * @fsf_req: request containing issued CT data
  */
-void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf)
 {
-        struct fsf_status_read_buffer *buf =
-                        (struct fsf_status_read_buffer *)fsf_req->data;
-        int length = (int)buf->length -
-                     (int)((void *)&buf->payload - (void *)buf);
+        struct zfcp_dbf *dbf = fsf->adapter->dbf;
+        struct fsf_status_read_buffer *srb =
+                (struct fsf_status_read_buffer *) fsf->data;
+        u16 length;
 
-        zfcp_dbf_san_els("iels", 1, fsf_req, ntoh24(buf->d_id),
-                               (void *)buf->payload.data, length);
-}
-
-static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view,
-                                    char *out_buf, const char *in_buf)
-{
-        struct zfcp_dbf_san_record *r = (struct zfcp_dbf_san_record *)in_buf;
-        char *p = out_buf;
-
-        if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
-                return 0;
-
-        zfcp_dbf_tag(&p, "tag", r->tag);
-        zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
-        zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
-
-        if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) {
-                struct zfcp_dbf_san_record_ct_request *ct = &r->u.ct_req;
-                zfcp_dbf_out(&p, "d_id", "0x%06x", ct->d_id);
-                zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code);
-                zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
-                zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type);
-                zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype);
-                zfcp_dbf_out(&p, "options", "0x%02x", ct->options);
-                zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
-        } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) {
-                struct zfcp_dbf_san_record_ct_response *ct = &r->u.ct_resp;
-                zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code);
-                zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
-                zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code);
-                zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl);
-                zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique);
-                zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
-        } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 ||
-                   strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 ||
-                   strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) {
-                struct zfcp_dbf_san_record_els *els = &r->u.els;
-                zfcp_dbf_out(&p, "d_id", "0x%06x", els->d_id);
-        }
-        return p - out_buf;
+        length = (u16)(srb->length -
+                        offsetof(struct fsf_status_read_buffer, payload));
+        zfcp_dbf_san(tag, dbf, srb->payload.data, ZFCP_DBF_SAN_ELS, length,
+                     fsf->req_id, ntoh24(srb->d_id));
 }
 
-static struct debug_view zfcp_dbf_san_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_san_view_format,
-};
-
-void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
-                    struct zfcp_dbf *dbf, struct scsi_cmnd *scsi_cmnd,
-                    struct zfcp_fsf_req *fsf_req, unsigned long old_req_id)
+/**
+ * zfcp_dbf_scsi - trace event for scsi commands
+ * @tag: identifier for event
+ * @sc: pointer to struct scsi_cmnd
+ * @fsf: pointer to struct zfcp_fsf_req
+ */
+void zfcp_dbf_scsi(char *tag, struct scsi_cmnd *sc, struct zfcp_fsf_req *fsf)
 {
-        struct zfcp_dbf_scsi_record *rec = &dbf->scsi_buf;
-        struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec;
-        unsigned long flags;
+        struct zfcp_adapter *adapter =
+                (struct zfcp_adapter *) sc->device->host->hostdata[0];
+        struct zfcp_dbf *dbf = adapter->dbf;
+        struct zfcp_dbf_scsi *rec = &dbf->scsi_buf;
         struct fcp_resp_with_ext *fcp_rsp;
-        struct fcp_resp_rsp_info *fcp_rsp_info = NULL;
-        char *fcp_sns_info = NULL;
-        int offset = 0, buflen = 0;
+        struct fcp_resp_rsp_info *fcp_rsp_info;
+        unsigned long flags;
 
         spin_lock_irqsave(&dbf->scsi_lock, flags);
-        do {
-                memset(rec, 0, sizeof(*rec));
-                if (offset == 0) {
-                        strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
-                        strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
-                        if (scsi_cmnd != NULL) {
-                                if (scsi_cmnd->device) {
-                                        rec->scsi_id = scsi_cmnd->device->id;
-                                        rec->scsi_lun = scsi_cmnd->device->lun;
-                                }
-                                rec->scsi_result = scsi_cmnd->result;
-                                rec->scsi_cmnd = (unsigned long)scsi_cmnd;
-                                memcpy(rec->scsi_opcode, scsi_cmnd->cmnd,
-                                        min((int)scsi_cmnd->cmd_len,
-                                                ZFCP_DBF_SCSI_OPCODE));
-                                rec->scsi_retries = scsi_cmnd->retries;
-                                rec->scsi_allowed = scsi_cmnd->allowed;
-                        }
-                        if (fsf_req != NULL) {
-                                fcp_rsp = (struct fcp_resp_with_ext *)
-                                        &(fsf_req->qtcb->bottom.io.fcp_rsp);
-                                fcp_rsp_info = (struct fcp_resp_rsp_info *)
-                                        &fcp_rsp[1];
-                                fcp_sns_info = (char *) &fcp_rsp[1];
-                                if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL)
-                                        fcp_sns_info += fcp_rsp->ext.fr_sns_len;
-
-                                rec->rsp_validity = fcp_rsp->resp.fr_flags;
-                                rec->rsp_scsi_status = fcp_rsp->resp.fr_status;
-                                rec->rsp_resid = fcp_rsp->ext.fr_resid;
-                                if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL)
-                                        rec->rsp_code = fcp_rsp_info->rsp_code;
-                                if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
-                                        buflen = min(fcp_rsp->ext.fr_sns_len,
-                                           (u32)ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO);
-                                        rec->sns_info_len = buflen;
-                                        memcpy(rec->sns_info, fcp_sns_info,
-                                               min(buflen,
-                                                   ZFCP_DBF_SCSI_FCP_SNS_INFO));
-                                        offset += min(buflen,
-                                                      ZFCP_DBF_SCSI_FCP_SNS_INFO);
-                                }
-
-                                rec->fsf_reqid = fsf_req->req_id;
-                                rec->fsf_seqno = fsf_req->seq_no;
-                                rec->fsf_issued = fsf_req->issued;
-                        }
-                        rec->old_fsf_reqid = old_req_id;
-                } else {
-                        strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
-                        dump->total_size = buflen;
-                        dump->offset = offset;
-                        dump->size = min(buflen - offset,
-                                         (int)sizeof(struct
-                                                     zfcp_dbf_scsi_record) -
-                                         (int)sizeof(struct zfcp_dbf_dump));
-                        memcpy(dump->data, fcp_sns_info + offset, dump->size);
-                        offset += dump->size;
-                }
-                debug_event(dbf->scsi, level, rec, sizeof(*rec));
-        } while (offset < buflen);
-        spin_unlock_irqrestore(&dbf->scsi_lock, flags);
-}
+        memset(rec, 0, sizeof(*rec));
 
-static int zfcp_dbf_scsi_view_format(debug_info_t *id, struct debug_view *view,
-                                     char *out_buf, const char *in_buf)
-{
-        struct zfcp_dbf_scsi_record *r = (struct zfcp_dbf_scsi_record *)in_buf;
-        struct timespec t;
-        char *p = out_buf;
-
-        if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
-                return 0;
-
-        zfcp_dbf_tag(&p, "tag", r->tag);
-        zfcp_dbf_tag(&p, "tag2", r->tag2);
-        zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id);
-        zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun);
-        zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result);
-        zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd);
-        zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE,
-                      0, ZFCP_DBF_SCSI_OPCODE);
-        zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries);
-        zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed);
-        if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid);
-        zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
-        zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
-        stck_to_timespec(r->fsf_issued, &t);
-        zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
-
-        if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) {
-                zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity);
-                zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x",
-                             r->rsp_scsi_status);
-                zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid);
-                zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code);
-                zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len);
-                zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info,
-                              min((int)r->sns_info_len,
-                              ZFCP_DBF_SCSI_FCP_SNS_INFO), 0,
-                              r->sns_info_len);
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_SCSI_CMND;
+        rec->scsi_result = sc->result;
+        rec->scsi_retries = sc->retries;
+        rec->scsi_allowed = sc->allowed;
+        rec->scsi_id = sc->device->id;
+        rec->scsi_lun = sc->device->lun;
+        rec->host_scribble = (unsigned long)sc->host_scribble;
+
+        memcpy(rec->scsi_opcode, sc->cmnd,
+               min((int)sc->cmd_len, ZFCP_DBF_SCSI_OPCODE));
+
+        if (fsf) {
+                rec->fsf_req_id = fsf->req_id;
+                fcp_rsp = (struct fcp_resp_with_ext *)
+                                &(fsf->qtcb->bottom.io.fcp_rsp);
+                memcpy(&rec->fcp_rsp, fcp_rsp, FCP_RESP_WITH_EXT);
+                if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) {
+                        fcp_rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
+                        rec->fcp_rsp_info = fcp_rsp_info->rsp_code;
+                }
+                if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
+                        rec->pl_len = min((u16)SCSI_SENSE_BUFFERSIZE,
+                                          (u16)ZFCP_DBF_PAY_MAX_REC);
+                        zfcp_dbf_pl_write(dbf, sc->sense_buffer, rec->pl_len,
+                                          "fcp_sns", fsf->req_id);
+                }
         }
-        p += sprintf(p, "\n");
-        return p - out_buf;
-}
 
-static struct debug_view zfcp_dbf_scsi_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_scsi_view_format,
-};
+        debug_event(dbf->scsi, 1, rec, sizeof(*rec));
+        spin_unlock_irqrestore(&dbf->scsi_lock, flags);
+}
 
-static debug_info_t *zfcp_dbf_reg(const char *name, int level,
-                                  struct debug_view *view, int size)
+static debug_info_t *zfcp_dbf_reg(const char *name, int size, int rec_size)
 {
         struct debug_info *d;
 
-        d = debug_register(name, dbfsize, level, size);
+        d = debug_register(name, size, 1, rec_size);
         if (!d)
                 return NULL;
 
         debug_register_view(d, &debug_hex_ascii_view);
-        debug_register_view(d, view);
-        debug_set_level(d, level);
+        debug_set_level(d, 3);
 
         return d;
 }
 
+static void zfcp_dbf_unregister(struct zfcp_dbf *dbf)
+{
+        if (!dbf)
+                return;
+
+        debug_unregister(dbf->scsi);
+        debug_unregister(dbf->san);
+        debug_unregister(dbf->hba);
+        debug_unregister(dbf->pay);
+        debug_unregister(dbf->rec);
+        kfree(dbf);
+}
+
 /**
  * zfcp_adapter_debug_register - registers debug feature for an adapter
  * @adapter: pointer to adapter for which debug features should be registered
@@ -1003,69 +415,66 @@ static debug_info_t *zfcp_dbf_reg(const char *name, int level,
  */
 int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter)
 {
-        char dbf_name[DEBUG_MAX_NAME_LEN];
+        char name[DEBUG_MAX_NAME_LEN];
         struct zfcp_dbf *dbf;
 
         dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL);
         if (!dbf)
                 return -ENOMEM;
 
-        dbf->adapter = adapter;
-
+        spin_lock_init(&dbf->pay_lock);
         spin_lock_init(&dbf->hba_lock);
         spin_lock_init(&dbf->san_lock);
         spin_lock_init(&dbf->scsi_lock);
         spin_lock_init(&dbf->rec_lock);
 
         /* debug feature area which records recovery activity */
-        sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev));
-        dbf->rec = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_rec_view,
-                                sizeof(struct zfcp_dbf_rec_record));
+        sprintf(name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev));
+        dbf->rec = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_rec));
         if (!dbf->rec)
                 goto err_out;
 
         /* debug feature area which records HBA (FSF and QDIO) conditions */
-        sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev));
-        dbf->hba = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_hba_view,
-                                sizeof(struct zfcp_dbf_hba_record));
+        sprintf(name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev));
+        dbf->hba = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_hba));
         if (!dbf->hba)
                 goto err_out;
 
+        /* debug feature area which records payload info */
+        sprintf(name, "zfcp_%s_pay", dev_name(&adapter->ccw_device->dev));
+        dbf->pay = zfcp_dbf_reg(name, dbfsize * 2, sizeof(struct zfcp_dbf_pay));
+        if (!dbf->pay)
+                goto err_out;
+
         /* debug feature area which records SAN command failures and recovery */
-        sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev));
-        dbf->san = zfcp_dbf_reg(dbf_name, 6, &zfcp_dbf_san_view,
-                                sizeof(struct zfcp_dbf_san_record));
+        sprintf(name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev));
+        dbf->san = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_san));
         if (!dbf->san)
                 goto err_out;
 
         /* debug feature area which records SCSI command failures and recovery */
-        sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev));
-        dbf->scsi = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_scsi_view,
-                                 sizeof(struct zfcp_dbf_scsi_record));
+        sprintf(name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev));
+        dbf->scsi = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_scsi));
         if (!dbf->scsi)
                 goto err_out;
 
         adapter->dbf = dbf;
-        return 0;
 
+        return 0;
 err_out:
-        zfcp_dbf_adapter_unregister(dbf);
+        zfcp_dbf_unregister(dbf);
         return -ENOMEM;
 }
 
 /**
  * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
- * @dbf: pointer to dbf for which debug features should be unregistered
+ * @adapter: pointer to adapter for which debug features should be unregistered
  */
-void zfcp_dbf_adapter_unregister(struct zfcp_dbf *dbf)
+void zfcp_dbf_adapter_unregister(struct zfcp_adapter *adapter)
 {
-        if (!dbf)
-                return;
-        debug_unregister(dbf->scsi);
-        debug_unregister(dbf->san);
-        debug_unregister(dbf->hba);
-        debug_unregister(dbf->rec);
-        dbf->adapter->dbf = NULL;
-        kfree(dbf);
+        struct zfcp_dbf *dbf = adapter->dbf;
+
+        adapter->dbf = NULL;
+        zfcp_dbf_unregister(dbf);
 }
 
diff --git a/drivers/s390/scsi/zfcp_dbf.h b/drivers/s390/scsi/zfcp_dbf.h
index 04081b1b62b4..714f087eb7a9 100644
--- a/drivers/s390/scsi/zfcp_dbf.h
+++ b/drivers/s390/scsi/zfcp_dbf.h
@@ -1,22 +1,8 @@
 /*
- * This file is part of the zfcp device driver for
- * FCP adapters for IBM System z9 and zSeries.
+ * zfcp device driver
+ * debug feature declarations
  *
- * Copyright IBM Corp. 2008, 2009
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Copyright IBM Corp. 2008, 2010
  */
 
 #ifndef ZFCP_DBF_H
@@ -27,322 +13,350 @@
 #include "zfcp_fsf.h"
 #include "zfcp_def.h"
 
-#define ZFCP_DBF_TAG_SIZE      4
-#define ZFCP_DBF_ID_SIZE       7
+#define ZFCP_DBF_TAG_LEN       7
 
 #define ZFCP_DBF_INVALID_LUN    0xFFFFFFFFFFFFFFFFull
 
-struct zfcp_dbf_dump {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u32 total_size;         /* size of total dump data */
-        u32 offset;             /* how much data has being already dumped */
-        u32 size;               /* how much data comes with this record */
-        u8 data[];              /* dump data */
-} __attribute__ ((packed));
-
-struct zfcp_dbf_rec_record_thread {
-        u32 total;
+/**
+ * struct zfcp_dbf_rec_trigger - trace record for triggered recovery action
+ * @ready: number of ready recovery actions
+ * @running: number of running recovery actions
+ * @want: wanted recovery action
+ * @need: needed recovery action
+ */
+struct zfcp_dbf_rec_trigger {
         u32 ready;
         u32 running;
-};
-
-struct zfcp_dbf_rec_record_target {
-        u64 ref;
-        u32 status;
-        u32 d_id;
-        u64 wwpn;
-        u64 fcp_lun;
-        u32 erp_count;
-};
-
-struct zfcp_dbf_rec_record_trigger {
         u8 want;
         u8 need;
-        u32 as;
-        u32 ps;
-        u32 ls;
-        u64 ref;
-        u64 action;
-        u64 wwpn;
-        u64 fcp_lun;
-};
+} __packed;
 
-struct zfcp_dbf_rec_record_action {
-        u32 status;
-        u32 step;
-        u64 action;
-        u64 fsf_req;
+/**
+ * struct zfcp_dbf_rec_running - trace record for running recovery
+ * @fsf_req_id: request id for fsf requests
+ * @rec_status: status of the fsf request
+ * @rec_step: current step of the recovery action
+ * rec_count: recovery counter
+ */
+struct zfcp_dbf_rec_running {
+        u64 fsf_req_id;
+        u32 rec_status;
+        u16 rec_step;
+        u8 rec_action;
+        u8 rec_count;
+} __packed;
+
+/**
+ * enum zfcp_dbf_rec_id - recovery trace record id
+ * @ZFCP_DBF_REC_TRIG: triggered recovery identifier
+ * @ZFCP_DBF_REC_RUN: running recovery identifier
+ */
+enum zfcp_dbf_rec_id {
+        ZFCP_DBF_REC_TRIG       = 1,
+        ZFCP_DBF_REC_RUN        = 2,
 };
 
-struct zfcp_dbf_rec_record {
+/**
+ * struct zfcp_dbf_rec - trace record for error recovery actions
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @lun: logical unit number
+ * @wwpn: word wide port number
+ * @d_id: destination ID
+ * @adapter_status: current status of the adapter
+ * @port_status: current status of the port
+ * @lun_status: current status of the lun
+ * @u.trig: structure zfcp_dbf_rec_trigger
+ * @u.run: structure zfcp_dbf_rec_running
+ */
+struct zfcp_dbf_rec {
         u8 id;
-        char id2[7];
+        char tag[ZFCP_DBF_TAG_LEN];
+        u64 lun;
+        u64 wwpn;
+        u32 d_id;
+        u32 adapter_status;
+        u32 port_status;
+        u32 lun_status;
         union {
-                struct zfcp_dbf_rec_record_action action;
-                struct zfcp_dbf_rec_record_thread thread;
-                struct zfcp_dbf_rec_record_target target;
-                struct zfcp_dbf_rec_record_trigger trigger;
+                struct zfcp_dbf_rec_trigger trig;
+                struct zfcp_dbf_rec_running run;
         } u;
-};
+} __packed;
 
-enum {
-        ZFCP_REC_DBF_ID_ACTION,
-        ZFCP_REC_DBF_ID_THREAD,
-        ZFCP_REC_DBF_ID_TARGET,
-        ZFCP_REC_DBF_ID_TRIGGER,
+/**
+ * enum zfcp_dbf_san_id - SAN trace record identifier
+ * @ZFCP_DBF_SAN_REQ: request trace record id
+ * @ZFCP_DBF_SAN_RES: response trace record id
+ * @ZFCP_DBF_SAN_ELS: extended link service record id
+ */
+enum zfcp_dbf_san_id {
+        ZFCP_DBF_SAN_REQ        = 1,
+        ZFCP_DBF_SAN_RES        = 2,
+        ZFCP_DBF_SAN_ELS        = 3,
 };
 
-struct zfcp_dbf_hba_record_response {
-        u32 fsf_command;
-        u64 fsf_reqid;
-        u32 fsf_seqno;
-        u64 fsf_issued;
-        u32 fsf_prot_status;
+/** struct zfcp_dbf_san - trace record for SAN requests and responses
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @fsf_req_id: request id for fsf requests
+ * @payload: unformatted information related to request/response
+ * @d_id: destination id
+ */
+struct zfcp_dbf_san {
+        u8 id;
+        char tag[ZFCP_DBF_TAG_LEN];
+        u64 fsf_req_id;
+        u32 d_id;
+#define ZFCP_DBF_SAN_MAX_PAYLOAD (FC_CT_HDR_LEN + 32)
+        char payload[ZFCP_DBF_SAN_MAX_PAYLOAD];
+} __packed;
+
+/**
+ * struct zfcp_dbf_hba_res - trace record for hba responses
+ * @req_issued: timestamp when request was issued
+ * @prot_status: protocol status
+ * @prot_status_qual: protocol status qualifier
+ * @fsf_status: fsf status
+ * @fsf_status_qual: fsf status qualifier
+ */
+struct zfcp_dbf_hba_res {
+        u64 req_issued;
+        u32 prot_status;
+        u8  prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE];
         u32 fsf_status;
-        u8 fsf_prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE];
-        u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
-        u32 fsf_req_status;
-        u8 sbal_first;
-        u8 sbal_last;
-        u8 sbal_response;
-        u8 pool;
-        u64 erp_action;
-        union {
-                struct {
-                        u64 cmnd;
-                        u32 data_dir;
-                } fcp;
-                struct {
-                        u64 wwpn;
-                        u32 d_id;
-                        u32 port_handle;
-                } port;
-                struct {
-                        u64 wwpn;
-                        u64 fcp_lun;
-                        u32 port_handle;
-                        u32 lun_handle;
-                } unit;
-                struct {
-                        u32 d_id;
-                } els;
-        } u;
-} __attribute__ ((packed));
+        u8  fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
+} __packed;
 
-struct zfcp_dbf_hba_record_status {
-        u8 failed;
+/**
+ * struct zfcp_dbf_hba_uss - trace record for unsolicited status
+ * @status_type: type of unsolicited status
+ * @status_subtype: subtype of unsolicited status
+ * @d_id: destination ID
+ * @lun: logical unit number
+ * @queue_designator: queue designator
+ */
+struct zfcp_dbf_hba_uss {
         u32 status_type;
         u32 status_subtype;
-        struct fsf_queue_designator
-         queue_designator;
-        u32 payload_size;
-#define ZFCP_DBF_UNSOL_PAYLOAD                          80
-#define ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL         32
-#define ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD      56
-#define ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT     2 * sizeof(u32)
-        u8 payload[ZFCP_DBF_UNSOL_PAYLOAD];
-} __attribute__ ((packed));
-
-struct zfcp_dbf_hba_record_qdio {
-        u32 qdio_error;
-        u8 sbal_index;
-        u8 sbal_count;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_hba_record {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u8 tag2[ZFCP_DBF_TAG_SIZE];
-        union {
-                struct zfcp_dbf_hba_record_response response;
-                struct zfcp_dbf_hba_record_status status;
-                struct zfcp_dbf_hba_record_qdio qdio;
-                struct fsf_bit_error_payload berr;
-        } u;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_san_record_ct_request {
-        u16 cmd_req_code;
-        u8 revision;
-        u8 gs_type;
-        u8 gs_subtype;
-        u8 options;
-        u16 max_res_size;
-        u32 len;
-        u32 d_id;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_san_record_ct_response {
-        u16 cmd_rsp_code;
-        u8 revision;
-        u8 reason_code;
-        u8 expl;
-        u8 vendor_unique;
-        u16 max_res_size;
-        u32 len;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_san_record_els {
         u32 d_id;
-} __attribute__ ((packed));
+        u64 lun;
+        u64 queue_designator;
+} __packed;
 
-struct zfcp_dbf_san_record {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u64 fsf_reqid;
-        u32 fsf_seqno;
+/**
+ * enum zfcp_dbf_hba_id - HBA trace record identifier
+ * @ZFCP_DBF_HBA_RES: response trace record
+ * @ZFCP_DBF_HBA_USS: unsolicited status trace record
+ * @ZFCP_DBF_HBA_BIT: bit error trace record
+ */
+enum zfcp_dbf_hba_id {
+        ZFCP_DBF_HBA_RES        = 1,
+        ZFCP_DBF_HBA_USS        = 2,
+        ZFCP_DBF_HBA_BIT        = 3,
+};
+
+/**
+ * struct zfcp_dbf_hba - common trace record for HBA records
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @fsf_req_id: request id for fsf requests
+ * @fsf_req_status: status of fsf request
+ * @fsf_cmd: fsf command
+ * @fsf_seq_no: fsf sequence number
+ * @pl_len: length of payload stored as zfcp_dbf_pay
+ * @u: record type specific data
+ */
+struct zfcp_dbf_hba {
+        u8 id;
+        char tag[ZFCP_DBF_TAG_LEN];
+        u64 fsf_req_id;
+        u32 fsf_req_status;
+        u32 fsf_cmd;
+        u32 fsf_seq_no;
+        u16 pl_len;
         union {
-                struct zfcp_dbf_san_record_ct_request ct_req;
-                struct zfcp_dbf_san_record_ct_response ct_resp;
-                struct zfcp_dbf_san_record_els els;
+                struct zfcp_dbf_hba_res res;
+                struct zfcp_dbf_hba_uss uss;
+                struct fsf_bit_error_payload be;
         } u;
-} __attribute__ ((packed));
+} __packed;
 
-#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
+/**
+ * enum zfcp_dbf_scsi_id - scsi trace record identifier
+ * @ZFCP_DBF_SCSI_CMND: scsi command trace record
+ */
+enum zfcp_dbf_scsi_id {
+        ZFCP_DBF_SCSI_CMND      = 1,
+};
 
-struct zfcp_dbf_scsi_record {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u8 tag2[ZFCP_DBF_TAG_SIZE];
+/**
+ * struct zfcp_dbf_scsi - common trace record for SCSI records
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @scsi_id: scsi device id
+ * @scsi_lun: scsi device logical unit number
+ * @scsi_result: scsi result
+ * @scsi_retries: current retry number of scsi request
+ * @scsi_allowed: allowed retries
+ * @fcp_rsp_info: FCP response info
+ * @scsi_opcode: scsi opcode
+ * @fsf_req_id: request id of fsf request
+ * @host_scribble: LLD specific data attached to SCSI request
+ * @pl_len: length of paload stored as zfcp_dbf_pay
+ * @fsf_rsp: response for fsf request
+ */
+struct zfcp_dbf_scsi {
+        u8 id;
+        char tag[ZFCP_DBF_TAG_LEN];
         u32 scsi_id;
         u32 scsi_lun;
         u32 scsi_result;
-        u64 scsi_cmnd;
-#define ZFCP_DBF_SCSI_OPCODE    16
-        u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
         u8 scsi_retries;
         u8 scsi_allowed;
-        u64 fsf_reqid;
-        u32 fsf_seqno;
-        u64 fsf_issued;
-        u64 old_fsf_reqid;
-        u8 rsp_validity;
-        u8 rsp_scsi_status;
-        u32 rsp_resid;
-        u8 rsp_code;
-#define ZFCP_DBF_SCSI_FCP_SNS_INFO      16
-#define ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO  256
-        u32 sns_info_len;
-        u8 sns_info[ZFCP_DBF_SCSI_FCP_SNS_INFO];
-} __attribute__ ((packed));
+        u8 fcp_rsp_info;
+#define ZFCP_DBF_SCSI_OPCODE    16
+        u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
+        u64 fsf_req_id;
+        u64 host_scribble;
+        u16 pl_len;
+        struct fcp_resp_with_ext fcp_rsp;
+} __packed;
 
+/**
+ * struct zfcp_dbf_pay - trace record for unformatted payload information
+ * @area: area this record is originated from
+ * @counter: ascending record number
+ * @fsf_req_id: request id of fsf request
+ * @data: unformatted data
+ */
+struct zfcp_dbf_pay {
+        u8 counter;
+        char area[ZFCP_DBF_TAG_LEN];
+        u64 fsf_req_id;
+#define ZFCP_DBF_PAY_MAX_REC 0x100
+        char data[ZFCP_DBF_PAY_MAX_REC];
+} __packed;
+
+/**
+ * struct zfcp_dbf - main dbf trace structure
+ * @pay: reference to payload trace area
+ * @rec: reference to recovery trace area
+ * @hba: reference to hba trace area
+ * @san: reference to san trace area
+ * @scsi: reference to scsi trace area
+ * @pay_lock: lock protecting payload trace buffer
+ * @rec_lock: lock protecting recovery trace buffer
+ * @hba_lock: lock protecting hba trace buffer
+ * @san_lock: lock protecting san trace buffer
+ * @scsi_lock: lock protecting scsi trace buffer
+ * @pay_buf: pre-allocated buffer for payload
+ * @rec_buf: pre-allocated buffer for recovery
+ * @hba_buf: pre-allocated buffer for hba
+ * @san_buf: pre-allocated buffer for san
+ * @scsi_buf: pre-allocated buffer for scsi
+ */
 struct zfcp_dbf {
+        debug_info_t                    *pay;
         debug_info_t                    *rec;
         debug_info_t                    *hba;
         debug_info_t                    *san;
         debug_info_t                    *scsi;
+        spinlock_t                      pay_lock;
         spinlock_t                      rec_lock;
         spinlock_t                      hba_lock;
         spinlock_t                      san_lock;
         spinlock_t                      scsi_lock;
-        struct zfcp_dbf_rec_record      rec_buf;
-        struct zfcp_dbf_hba_record      hba_buf;
-        struct zfcp_dbf_san_record      san_buf;
-        struct zfcp_dbf_scsi_record     scsi_buf;
-        struct zfcp_adapter             *adapter;
+        struct zfcp_dbf_pay             pay_buf;
+        struct zfcp_dbf_rec             rec_buf;
+        struct zfcp_dbf_hba             hba_buf;
+        struct zfcp_dbf_san             san_buf;
+        struct zfcp_dbf_scsi            scsi_buf;
 };
 
 static inline
-void zfcp_dbf_hba_fsf_resp(const char *tag2, int level,
-                           struct zfcp_fsf_req *req, struct zfcp_dbf *dbf)
+void zfcp_dbf_hba_fsf_resp(char *tag, int level, struct zfcp_fsf_req *req)
 {
-        if (level <= dbf->hba->level)
-                _zfcp_dbf_hba_fsf_response(tag2, level, req, dbf);
+        if (level <= req->adapter->dbf->hba->level)
+                zfcp_dbf_hba_fsf_res(tag, req);
 }
 
 /**
  * zfcp_dbf_hba_fsf_response - trace event for request completion
- * @fsf_req: request that has been completed
+ * @req: request that has been completed
  */
-static inline void zfcp_dbf_hba_fsf_response(struct zfcp_fsf_req *req)
+static inline
+void zfcp_dbf_hba_fsf_response(struct zfcp_fsf_req *req)
 {
-        struct zfcp_dbf *dbf = req->adapter->dbf;
         struct fsf_qtcb *qtcb = req->qtcb;
 
         if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) &&
             (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) {
-                zfcp_dbf_hba_fsf_resp("perr", 1, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_perr", 1, req);
 
         } else if (qtcb->header.fsf_status != FSF_GOOD) {
-                zfcp_dbf_hba_fsf_resp("ferr", 1, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_ferr", 1, req);
 
         } else if ((req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) ||
                    (req->fsf_command == FSF_QTCB_OPEN_LUN)) {
-                zfcp_dbf_hba_fsf_resp("open", 4, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_open", 4, req);
 
         } else if (qtcb->header.log_length) {
-                zfcp_dbf_hba_fsf_resp("qtcb", 5, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_qtcb", 5, req);
 
         } else {
-                zfcp_dbf_hba_fsf_resp("norm", 6, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_norm", 6, req);
         }
- }
-
-/**
- * zfcp_dbf_hba_fsf_unsol - trace event for an unsolicited status buffer
- * @tag: tag indicating which kind of unsolicited status has been received
- * @dbf: reference to dbf structure
- * @status_buffer: buffer containing payload of unsolicited status
- */
-static inline
-void zfcp_dbf_hba_fsf_unsol(const char *tag, struct zfcp_dbf *dbf,
-                            struct fsf_status_read_buffer *buf)
-{
-        int level = 2;
-
-        if (level <= dbf->hba->level)
-                _zfcp_dbf_hba_fsf_unsol(tag, level, dbf, buf);
 }
 
 static inline
-void zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
-                   struct zfcp_dbf *dbf, struct scsi_cmnd *scmd,
-                   struct zfcp_fsf_req *req, unsigned long old_id)
+void _zfcp_dbf_scsi(char *tag, int level, struct scsi_cmnd *scmd,
+                   struct zfcp_fsf_req *req)
 {
-        if (level <= dbf->scsi->level)
-                _zfcp_dbf_scsi(tag, tag2, level, dbf, scmd, req, old_id);
+        struct zfcp_adapter *adapter = (struct zfcp_adapter *)
+                                        scmd->device->host->hostdata[0];
+
+        if (level <= adapter->dbf->scsi->level)
+                zfcp_dbf_scsi(tag, scmd, req);
 }
 
 /**
  * zfcp_dbf_scsi_result - trace event for SCSI command completion
- * @dbf: adapter dbf trace
  * @scmd: SCSI command pointer
  * @req: FSF request used to issue SCSI command
  */
 static inline
-void zfcp_dbf_scsi_result(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd,
-                          struct zfcp_fsf_req *req)
+void zfcp_dbf_scsi_result(struct scsi_cmnd *scmd, struct zfcp_fsf_req *req)
 {
         if (scmd->result != 0)
-                zfcp_dbf_scsi("rslt", "erro", 3, dbf, scmd, req, 0);
+                _zfcp_dbf_scsi("rsl_err", 3, scmd, req);
         else if (scmd->retries > 0)
-                zfcp_dbf_scsi("rslt", "retr", 4, dbf, scmd, req, 0);
+                _zfcp_dbf_scsi("rsl_ret", 4, scmd, req);
         else
-                zfcp_dbf_scsi("rslt", "norm", 6, dbf, scmd, req, 0);
+                _zfcp_dbf_scsi("rsl_nor", 6, scmd, req);
 }
 
 /**
  * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command
- * @dbf: adapter dbf trace
  * @scmd: SCSI command pointer
  */
 static inline
-void zfcp_dbf_scsi_fail_send(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd)
+void zfcp_dbf_scsi_fail_send(struct scsi_cmnd *scmd)
 {
-        zfcp_dbf_scsi("rslt", "fail", 4, dbf, scmd, NULL, 0);
+        _zfcp_dbf_scsi("rsl_fai", 4, scmd, NULL);
 }
 
 /**
  * zfcp_dbf_scsi_abort - trace event for SCSI command abort
  * @tag: tag indicating success or failure of abort operation
- * @adapter: adapter thas has been used to issue SCSI command to be aborted
  * @scmd: SCSI command to be aborted
- * @new_req: request containing abort (might be NULL)
- * @old_id: identifier of request containg SCSI command to be aborted
+ * @fsf_req: request containing abort (might be NULL)
  */
 static inline
-void zfcp_dbf_scsi_abort(const char *tag, struct zfcp_dbf *dbf,
-                         struct scsi_cmnd *scmd, struct zfcp_fsf_req *new_req,
-                         unsigned long old_id)
+void zfcp_dbf_scsi_abort(char *tag, struct scsi_cmnd *scmd,
+                         struct zfcp_fsf_req *fsf_req)
 {
-        zfcp_dbf_scsi("abrt", tag, 1, dbf, scmd, new_req, old_id);
+        _zfcp_dbf_scsi(tag, 1, scmd, fsf_req);
 }
 
 /**
@@ -352,12 +366,17 @@ void zfcp_dbf_scsi_abort(const char *tag, struct zfcp_dbf *dbf,
  * @flag: indicates type of reset (Target Reset, Logical Unit Reset)
  */
 static inline
-void zfcp_dbf_scsi_devreset(const char *tag, struct scsi_cmnd *scmnd, u8 flag)
+void zfcp_dbf_scsi_devreset(char *tag, struct scsi_cmnd *scmnd, u8 flag)
 {
-        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scmnd->device);
+        char tmp_tag[ZFCP_DBF_TAG_LEN];
+
+        if (flag == FCP_TMF_TGT_RESET)
+                memcpy(tmp_tag, "tr_", 3);
+        else
+                memcpy(tmp_tag, "lr_", 3);
 
-        zfcp_dbf_scsi(flag == FCP_TMF_TGT_RESET ? "trst" : "lrst", tag, 1,
-                      zfcp_sdev->port->adapter->dbf, scmnd, NULL, 0);
+        memcpy(&tmp_tag[3], tag, 4);
+        _zfcp_dbf_scsi(tmp_tag, 1, scmnd, NULL);
 }
 
 #endif /* ZFCP_DBF_H */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index 0bcd5806bd9a..e003e306f870 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -76,9 +76,9 @@ static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
         struct zfcp_adapter *adapter = act->adapter;
 
         list_move(&act->list, &act->adapter->erp_ready_head);
-        zfcp_dbf_rec_action("erardy1", act);
+        zfcp_dbf_rec_run("erardy1", act);
         wake_up(&adapter->erp_ready_wq);
-        zfcp_dbf_rec_thread("erardy2", adapter->dbf);
+        zfcp_dbf_rec_run("erardy2", act);
 }
 
 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
@@ -236,10 +236,10 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
                                    struct zfcp_port *port,
                                    struct scsi_device *sdev,
-                                   char *id, void *ref, u32 act_status)
+                                   char *id, u32 act_status)
 {
         int retval = 1, need;
-        struct zfcp_erp_action *act = NULL;
+        struct zfcp_erp_action *act;
 
         if (!adapter->erp_thread)
                 return -EIO;
@@ -255,15 +255,14 @@ static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
         ++adapter->erp_total_count;
         list_add_tail(&act->list, &adapter->erp_ready_head);
         wake_up(&adapter->erp_ready_wq);
-        zfcp_dbf_rec_thread("eracte1", adapter->dbf);
         retval = 0;
  out:
-        zfcp_dbf_rec_trigger(id, ref, want, need, act, adapter, port, sdev);
+        zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
         return retval;
 }
 
 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
-                                    int clear_mask, char *id, void *ref)
+                                    int clear_mask, char *id)
 {
         zfcp_erp_adapter_block(adapter, clear_mask);
         zfcp_scsi_schedule_rports_block(adapter);
@@ -275,7 +274,7 @@ static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
                 return -EIO;
         }
         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
-                                       adapter, NULL, NULL, id, ref, 0);
+                                       adapter, NULL, NULL, id, 0);
 }
 
 /**
@@ -283,10 +282,8 @@ static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
  * @adapter: Adapter to reopen.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
-                             char *id, void *ref)
+void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
 {
         unsigned long flags;
 
@@ -299,7 +296,7 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
                                             ZFCP_STATUS_COMMON_ERP_FAILED);
         else
                 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
-                                        NULL, NULL, id, ref, 0);
+                                        NULL, NULL, id, 0);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
@@ -308,13 +305,12 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
  * @adapter: Adapter to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
-                               char *id, void *ref)
+                               char *id)
 {
         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
-        zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref);
+        zfcp_erp_adapter_reopen(adapter, clear | flags, id);
 }
 
 /**
@@ -322,13 +318,11 @@ void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
  * @port: Port to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id,
-                            void *ref)
+void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id)
 {
         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
-        zfcp_erp_port_reopen(port, clear | flags, id, ref);
+        zfcp_erp_port_reopen(port, clear | flags, id);
 }
 
 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
@@ -337,8 +331,8 @@ static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear);
 }
 
-static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
-                                         int clear, char *id, void *ref)
+static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
+                                         char *id)
 {
         zfcp_erp_port_block(port, clear);
         zfcp_scsi_schedule_rport_block(port);
@@ -347,28 +341,26 @@ static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
                 return;
 
         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
-                                port->adapter, port, NULL, id, ref, 0);
+                                port->adapter, port, NULL, id, 0);
 }
 
 /**
  * zfcp_erp_port_forced_reopen - Forced close of port and open again
  * @port: Port to force close and to reopen.
+ * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id,
-                                 void *ref)
+void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id)
 {
         unsigned long flags;
         struct zfcp_adapter *adapter = port->adapter;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        _zfcp_erp_port_forced_reopen(port, clear, id, ref);
+        _zfcp_erp_port_forced_reopen(port, clear, id);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
-static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
-                                 void *ref)
+static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
 {
         zfcp_erp_port_block(port, clear);
         zfcp_scsi_schedule_rport_block(port);
@@ -380,24 +372,25 @@ static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
         }
 
         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
-                                       port->adapter, port, NULL, id, ref, 0);
+                                       port->adapter, port, NULL, id, 0);
 }
 
 /**
  * zfcp_erp_port_reopen - trigger remote port recovery
  * @port: port to recover
  * @clear_mask: flags in port status to be cleared
+ * @id: Id for debug trace event.
  *
  * Returns 0 if recovery has been triggered, < 0 if not.
  */
-int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, void *ref)
+int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
 {
         int retval;
         unsigned long flags;
         struct zfcp_adapter *adapter = port->adapter;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        retval = _zfcp_erp_port_reopen(port, clear, id, ref);
+        retval = _zfcp_erp_port_reopen(port, clear, id);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 
         return retval;
@@ -410,7 +403,7 @@ static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
 }
 
 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
-                                 void *ref, u32 act_status)
+                                 u32 act_status)
 {
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
@@ -421,17 +414,18 @@ static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
                 return;
 
         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
-                                zfcp_sdev->port, sdev, id, ref, act_status);
+                                zfcp_sdev->port, sdev, id, act_status);
 }
 
 /**
  * zfcp_erp_lun_reopen - initiate reopen of a LUN
  * @sdev: SCSI device / LUN to be reopened
  * @clear_mask: specifies flags in LUN status to be cleared
+ * @id: Id for debug trace event.
+ *
  * Return: 0 on success, < 0 on error
  */
-void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
-                         void *ref)
+void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
 {
         unsigned long flags;
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
@@ -439,7 +433,7 @@ void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
         struct zfcp_adapter *adapter = port->adapter;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        _zfcp_erp_lun_reopen(sdev, clear, id, ref, 0);
+        _zfcp_erp_lun_reopen(sdev, clear, id, 0);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
@@ -448,13 +442,11 @@ void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
  * @sdev: SCSI device / LUN to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id,
-                           void *ref)
+void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
 {
         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
-        zfcp_erp_lun_reopen(sdev, clear | flags, id, ref);
+        zfcp_erp_lun_reopen(sdev, clear | flags, id);
 }
 
 /**
@@ -476,7 +468,7 @@ void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
         int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        _zfcp_erp_lun_reopen(sdev, clear, id, NULL, ZFCP_STATUS_ERP_NO_REF);
+        _zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 
         zfcp_erp_wait(adapter);
@@ -490,14 +482,14 @@ static int status_change_set(unsigned long mask, atomic_t *status)
 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
 {
         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
-                zfcp_dbf_rec_adapter("eraubl1", NULL, adapter->dbf);
+                zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
 }
 
 static void zfcp_erp_port_unblock(struct zfcp_port *port)
 {
         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
-                zfcp_dbf_rec_port("erpubl1", NULL, port);
+                zfcp_dbf_rec_run("erpubl1", &port->erp_action);
         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
 }
 
@@ -506,14 +498,14 @@ static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 
         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status))
-                zfcp_dbf_rec_lun("erlubl1", NULL, sdev);
+                zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
 }
 
 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 {
         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
-        zfcp_dbf_rec_action("erator1", erp_action);
+        zfcp_dbf_rec_run("erator1", erp_action);
 }
 
 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
@@ -530,11 +522,11 @@ static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
                 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
                                    ZFCP_STATUS_ERP_TIMEDOUT)) {
                         req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
-                        zfcp_dbf_rec_action("erscf_1", act);
+                        zfcp_dbf_rec_run("erscf_1", act);
                         req->erp_action = NULL;
                 }
                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
-                        zfcp_dbf_rec_action("erscf_2", act);
+                        zfcp_dbf_rec_run("erscf_2", act);
                 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
                         act->fsf_req_id = 0;
         } else
@@ -585,40 +577,40 @@ static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
 }
 
 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
-                                      int clear, char *id, void *ref)
+                                      int clear, char *id)
 {
         struct zfcp_port *port;
 
         read_lock(&adapter->port_list_lock);
         list_for_each_entry(port, &adapter->port_list, list)
-                _zfcp_erp_port_reopen(port, clear, id, ref);
+                _zfcp_erp_port_reopen(port, clear, id);
         read_unlock(&adapter->port_list_lock);
 }
 
 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
-                                     char *id, void *ref)
+                                     char *id)
 {
         struct scsi_device *sdev;
 
         shost_for_each_device(sdev, port->adapter->scsi_host)
                 if (sdev_to_zfcp(sdev)->port == port)
-                        _zfcp_erp_lun_reopen(sdev, clear, id, ref, 0);
+                        _zfcp_erp_lun_reopen(sdev, clear, id, 0);
 }
 
 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
 {
         switch (act->action) {
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
-                _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1", NULL);
+                _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
-                _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2", NULL);
+                _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT:
-                _zfcp_erp_port_reopen(act->port, 0, "ersff_3", NULL);
+                _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_LUN:
-                _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", NULL, 0);
+                _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
                 break;
         }
 }
@@ -627,13 +619,13 @@ static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
 {
         switch (act->action) {
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
-                _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1", NULL);
+                _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
-                _zfcp_erp_port_reopen(act->port, 0, "ersfs_2", NULL);
+                _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT:
-                _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3", NULL);
+                _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
                 break;
         }
 }
@@ -652,17 +644,6 @@ static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
         read_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
-static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
-{
-        struct zfcp_qdio *qdio = act->adapter->qdio;
-
-        if (zfcp_qdio_open(qdio))
-                return ZFCP_ERP_FAILED;
-        init_waitqueue_head(&qdio->req_q_wq);
-        atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
-        return ZFCP_ERP_SUCCEEDED;
-}
-
 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
 {
         struct zfcp_port *port;
@@ -670,7 +651,7 @@ static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
                                  adapter->peer_d_id);
         if (IS_ERR(port)) /* error or port already attached */
                 return;
-        _zfcp_erp_port_reopen(port, 0, "ereptp1", NULL);
+        _zfcp_erp_port_reopen(port, 0, "ereptp1");
 }
 
 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
@@ -693,10 +674,8 @@ static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
                         return ZFCP_ERP_FAILED;
                 }
 
-                zfcp_dbf_rec_thread_lock("erasfx1", adapter->dbf);
                 wait_event(adapter->erp_ready_wq,
                            !list_empty(&adapter->erp_ready_head));
-                zfcp_dbf_rec_thread_lock("erasfx2", adapter->dbf);
                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
                         break;
 
@@ -735,10 +714,10 @@ static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
         if (ret)
                 return ZFCP_ERP_FAILED;
 
-        zfcp_dbf_rec_thread_lock("erasox1", adapter->dbf);
+        zfcp_dbf_rec_run("erasox1", act);
         wait_event(adapter->erp_ready_wq,
                    !list_empty(&adapter->erp_ready_head));
-        zfcp_dbf_rec_thread_lock("erasox2", adapter->dbf);
+        zfcp_dbf_rec_run("erasox2", act);
         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
                 return ZFCP_ERP_FAILED;
 
@@ -788,7 +767,7 @@ static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
 {
         struct zfcp_adapter *adapter = act->adapter;
 
-        if (zfcp_erp_adapter_strategy_open_qdio(act)) {
+        if (zfcp_qdio_open(adapter->qdio)) {
                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
                                   ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
                                   &adapter->status);
@@ -1166,7 +1145,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
                         _zfcp_erp_adapter_reopen(adapter,
                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
-                                                 "ersscg1", NULL);
+                                                 "ersscg1");
                         return ZFCP_ERP_EXIT;
                 }
                 break;
@@ -1176,7 +1155,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
                         _zfcp_erp_port_reopen(port,
                                               ZFCP_STATUS_COMMON_ERP_FAILED,
-                                              "ersscg2", NULL);
+                                              "ersscg2");
                         return ZFCP_ERP_EXIT;
                 }
                 break;
@@ -1186,7 +1165,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
                 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
                         _zfcp_erp_lun_reopen(sdev,
                                              ZFCP_STATUS_COMMON_ERP_FAILED,
-                                             "ersscg3", NULL, 0);
+                                             "ersscg3", 0);
                         return ZFCP_ERP_EXIT;
                 }
                 break;
@@ -1206,7 +1185,7 @@ static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
         }
 
         list_del(&erp_action->list);
-        zfcp_dbf_rec_action("eractd1", erp_action);
+        zfcp_dbf_rec_run("eractd1", erp_action);
 
         switch (erp_action->action) {
         case ZFCP_ERP_ACTION_REOPEN_LUN:
@@ -1313,7 +1292,7 @@ static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
                 }
                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
-                        _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1", NULL);
+                        _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
                 else {
                         zfcp_erp_strategy_memwait(erp_action);
                         retval = ZFCP_ERP_CONTINUES;
@@ -1357,11 +1336,9 @@ static int zfcp_erp_thread(void *data)
         unsigned long flags;
 
         for (;;) {
-                zfcp_dbf_rec_thread_lock("erthrd1", adapter->dbf);
                 wait_event_interruptible(adapter->erp_ready_wq,
                            !list_empty(&adapter->erp_ready_head) ||
                            kthread_should_stop());
-                zfcp_dbf_rec_thread_lock("erthrd2", adapter->dbf);
 
                 if (kthread_should_stop())
                         break;
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index bf8f3e514839..6e325284fbe7 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -45,47 +45,33 @@ extern void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *);
 
 /* zfcp_dbf.c */
 extern int zfcp_dbf_adapter_register(struct zfcp_adapter *);
-extern void zfcp_dbf_adapter_unregister(struct zfcp_dbf *);
-extern void zfcp_dbf_rec_thread(char *, struct zfcp_dbf *);
-extern void zfcp_dbf_rec_thread_lock(char *, struct zfcp_dbf *);
-extern void zfcp_dbf_rec_adapter(char *, void *, struct zfcp_dbf *);
-extern void zfcp_dbf_rec_port(char *, void *, struct zfcp_port *);
-extern void zfcp_dbf_rec_lun(char *, void *, struct scsi_device *);
-extern void zfcp_dbf_rec_trigger(char *, void *, u8, u8, void *,
-                                 struct zfcp_adapter *, struct zfcp_port *,
-                                 struct scsi_device *);
-extern void zfcp_dbf_rec_action(char *, struct zfcp_erp_action *);
-extern void _zfcp_dbf_hba_fsf_response(const char *, int, struct zfcp_fsf_req *,
-                                       struct zfcp_dbf *);
-extern void _zfcp_dbf_hba_fsf_unsol(const char *, int level, struct zfcp_dbf *,
-                                          struct fsf_status_read_buffer *);
-extern void zfcp_dbf_hba_qdio(struct zfcp_dbf *, unsigned int, int, int);
+extern void zfcp_dbf_adapter_unregister(struct zfcp_adapter *);
+extern void zfcp_dbf_rec_trig(char *, struct zfcp_adapter *,
+                              struct zfcp_port *, struct scsi_device *, u8, u8);
+extern void zfcp_dbf_rec_run(char *, struct zfcp_erp_action *);
+extern void zfcp_dbf_hba_fsf_uss(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_hba_fsf_res(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_hba_bit_err(char *, struct zfcp_fsf_req *);
 extern void zfcp_dbf_hba_berr(struct zfcp_dbf *, struct zfcp_fsf_req *);
-extern void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *, u32);
-extern void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *);
-extern void zfcp_dbf_san_els_request(struct zfcp_fsf_req *);
-extern void zfcp_dbf_san_els_response(struct zfcp_fsf_req *);
-extern void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *);
-extern void _zfcp_dbf_scsi(const char *, const char *, int, struct zfcp_dbf *,
-                           struct scsi_cmnd *, struct zfcp_fsf_req *,
-                           unsigned long);
+extern void zfcp_dbf_san_req(char *, struct zfcp_fsf_req *, u32);
+extern void zfcp_dbf_san_res(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_san_in_els(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_scsi(char *, struct scsi_cmnd *, struct zfcp_fsf_req *);
 
 /* zfcp_erp.c */
 extern void zfcp_erp_set_adapter_status(struct zfcp_adapter *, u32);
 extern void zfcp_erp_clear_adapter_status(struct zfcp_adapter *, u32);
-extern void zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, char *, void *);
-extern void zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, char *,
-                                      void *);
+extern void zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, char *);
+extern void zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, char *);
 extern void zfcp_erp_set_port_status(struct zfcp_port *, u32);
 extern void zfcp_erp_clear_port_status(struct zfcp_port *, u32);
-extern int  zfcp_erp_port_reopen(struct zfcp_port *, int, char *, void *);
-extern void zfcp_erp_port_shutdown(struct zfcp_port *, int, char *, void *);
-extern void zfcp_erp_port_forced_reopen(struct zfcp_port *, int, char *,
-                                        void *);
+extern int  zfcp_erp_port_reopen(struct zfcp_port *, int, char *);
+extern void zfcp_erp_port_shutdown(struct zfcp_port *, int, char *);
+extern void zfcp_erp_port_forced_reopen(struct zfcp_port *, int, char *);
 extern void zfcp_erp_set_lun_status(struct scsi_device *, u32);
 extern void zfcp_erp_clear_lun_status(struct scsi_device *, u32);
-extern void zfcp_erp_lun_reopen(struct scsi_device *, int, char *, void *);
-extern void zfcp_erp_lun_shutdown(struct scsi_device *, int, char *, void *);
+extern void zfcp_erp_lun_reopen(struct scsi_device *, int, char *);
+extern void zfcp_erp_lun_shutdown(struct scsi_device *, int, char *);
 extern void zfcp_erp_lun_shutdown_wait(struct scsi_device *, char *);
 extern int  zfcp_erp_thread_setup(struct zfcp_adapter *);
 extern void zfcp_erp_thread_kill(struct zfcp_adapter *);
@@ -149,6 +135,8 @@ extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *, struct zfcp_qdio_req *,
 extern int zfcp_qdio_open(struct zfcp_qdio *);
 extern void zfcp_qdio_close(struct zfcp_qdio *);
 extern void zfcp_qdio_siosl(struct zfcp_adapter *);
+extern struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *,
+                                             struct qdio_buffer *);
 
 /* zfcp_scsi.c */
 extern struct zfcp_data zfcp_data;
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index 86fd905df48b..30cf91a787a3 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -174,7 +174,7 @@ static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
                 if (!port->d_id)
                         zfcp_erp_port_reopen(port,
                                              ZFCP_STATUS_COMMON_ERP_FAILED,
-                                             "fcrscn1", NULL);
+                                             "fcrscn1");
         }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
@@ -215,7 +215,7 @@ static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
         read_lock_irqsave(&adapter->port_list_lock, flags);
         list_for_each_entry(port, &adapter->port_list, list)
                 if (port->wwpn == wwpn) {
-                        zfcp_erp_port_forced_reopen(port, 0, "fciwwp1", req);
+                        zfcp_erp_port_forced_reopen(port, 0, "fciwwp1");
                         break;
                 }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
@@ -251,7 +251,7 @@ void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
                 (struct fsf_status_read_buffer *) fsf_req->data;
         unsigned int els_type = status_buffer->payload.data[0];
 
-        zfcp_dbf_san_incoming_els(fsf_req);
+        zfcp_dbf_san_in_els("fciels1", fsf_req);
         if (els_type == ELS_PLOGI)
                 zfcp_fc_incoming_plogi(fsf_req);
         else if (els_type == ELS_LOGO)
@@ -360,7 +360,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
         ret = zfcp_fc_ns_gid_pn(port);
         if (ret) {
                 /* could not issue gid_pn for some reason */
-                zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1", NULL);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1");
                 goto out;
         }
 
@@ -369,7 +369,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
                 goto out;
         }
 
-        zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL);
+        zfcp_erp_port_reopen(port, 0, "fcgpn_3");
 out:
         put_device(&port->dev);
 }
@@ -426,7 +426,7 @@ static void zfcp_fc_adisc_handler(void *data)
         if (adisc->els.status) {
                 /* request rejected or timed out */
                 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                            "fcadh_1", NULL);
+                                            "fcadh_1");
                 goto out;
         }
 
@@ -436,7 +436,7 @@ static void zfcp_fc_adisc_handler(void *data)
         if ((port->wwpn != adisc_resp->adisc_wwpn) ||
             !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
                 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                     "fcadh_2", NULL);
+                                     "fcadh_2");
                 goto out;
         }
 
@@ -507,7 +507,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
 
         /* send of ADISC was not possible */
         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
-        zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL);
+        zfcp_erp_port_forced_reopen(port, 0, "fcltwk1");
 
 out:
         put_device(&port->dev);
@@ -659,7 +659,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
                 port = zfcp_port_enqueue(adapter, acc->fp_wwpn,
                                          ZFCP_STATUS_COMMON_NOESC, d_id);
                 if (!IS_ERR(port))
-                        zfcp_erp_port_reopen(port, 0, "fcegpf1", NULL);
+                        zfcp_erp_port_reopen(port, 0, "fcegpf1");
                 else if (PTR_ERR(port) != -EEXIST)
                         ret = PTR_ERR(port);
         }
@@ -671,7 +671,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
         write_unlock_irqrestore(&adapter->port_list_lock, flags);
 
         list_for_each_entry_safe(port, tmp, &remove_lh, list) {
-                zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL);
+                zfcp_erp_port_shutdown(port, 0, "fcegpf2");
                 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
         }
 
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 2eb7dd56ab80..60ff9d172c79 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -23,7 +23,7 @@ static void zfcp_fsf_request_timeout_handler(unsigned long data)
         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
         zfcp_qdio_siosl(adapter);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "fsrth_1", NULL);
+                                "fsrth_1");
 }
 
 static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
@@ -65,7 +65,7 @@ static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
 {
         dev_err(&req->adapter->ccw_device->dev, "FCP device not "
                 "operational because of an unsupported FC class\n");
-        zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1", req);
+        zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1");
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
@@ -98,7 +98,7 @@ static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
         read_lock_irqsave(&adapter->port_list_lock, flags);
         list_for_each_entry(port, &adapter->port_list, list)
                 if (port->d_id == d_id) {
-                        zfcp_erp_port_reopen(port, 0, "fssrpc1", req);
+                        zfcp_erp_port_reopen(port, 0, "fssrpc1");
                         break;
                 }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
@@ -211,13 +211,13 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
         struct fsf_status_read_buffer *sr_buf = req->data;
 
         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
-                zfcp_dbf_hba_fsf_unsol("dism", adapter->dbf, sr_buf);
+                zfcp_dbf_hba_fsf_uss("fssrh_1", req);
                 mempool_free(sr_buf, adapter->pool.status_read_data);
                 zfcp_fsf_req_free(req);
                 return;
         }
 
-        zfcp_dbf_hba_fsf_unsol("read", adapter->dbf, sr_buf);
+        zfcp_dbf_hba_fsf_uss("fssrh_2", req);
 
         switch (sr_buf->status_type) {
         case FSF_STATUS_READ_PORT_CLOSED:
@@ -232,7 +232,7 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
                 dev_warn(&adapter->ccw_device->dev,
                          "The error threshold for checksum statistics "
                          "has been exceeded\n");
-                zfcp_dbf_hba_berr(adapter->dbf, req);
+                zfcp_dbf_hba_bit_err("fssrh_3", req);
                 break;
         case FSF_STATUS_READ_LINK_DOWN:
                 zfcp_fsf_status_read_link_down(req);
@@ -247,7 +247,7 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
                 zfcp_erp_adapter_reopen(adapter,
                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
                                         ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        "fssrh_2", req);
+                                        "fssrh_2");
                 zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKUP, 0);
 
                 break;
@@ -287,7 +287,7 @@ static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
                         "The FCP adapter reported a problem "
                         "that cannot be recovered\n");
                 zfcp_qdio_siosl(req->adapter);
-                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1", req);
+                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1");
                 break;
         }
         /* all non-return stats set FSFREQ_ERROR*/
@@ -304,7 +304,7 @@ static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
                 dev_err(&req->adapter->ccw_device->dev,
                         "The FCP adapter does not recognize the command 0x%x\n",
                         req->qtcb->header.fsf_command);
-                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1", req);
+                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -335,17 +335,17 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                         "QTCB version 0x%x not supported by FCP adapter "
                         "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
                         psq->word[0], psq->word[1]);
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1");
                 break;
         case FSF_PROT_ERROR_STATE:
         case FSF_PROT_SEQ_NUMB_ERROR:
-                zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fspse_2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PROT_UNSUPP_QTCB_TYPE:
                 dev_err(&adapter->ccw_device->dev,
                         "The QTCB type is not supported by the FCP adapter\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3");
                 break;
         case FSF_PROT_HOST_CONNECTION_INITIALIZING:
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
@@ -355,12 +355,12 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "0x%Lx is an ambiguous request identifier\n",
                         (unsigned long long)qtcb->bottom.support.req_handle);
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4");
                 break;
         case FSF_PROT_LINK_DOWN:
                 zfcp_fsf_link_down_info_eval(req, &psq->link_down_info);
                 /* go through reopen to flush pending requests */
-                zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fspse_6");
                 break;
         case FSF_PROT_REEST_QUEUE:
                 /* All ports should be marked as ready to run again */
@@ -369,14 +369,14 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                 zfcp_erp_adapter_reopen(adapter,
                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
                                         ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        "fspse_8", req);
+                                        "fspse_8");
                 break;
         default:
                 dev_err(&adapter->ccw_device->dev,
                         "0x%x is not a valid transfer protocol status\n",
                         qtcb->prefix.prot_status);
                 zfcp_qdio_siosl(adapter);
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9");
         }
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
@@ -482,7 +482,7 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "Unknown or unsupported arbitrated loop "
                         "fibre channel topology detected\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1");
                 return -EIO;
         }
 
@@ -518,7 +518,7 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                                 "FCP adapter maximum QTCB size (%d bytes) "
                                 "is too small\n",
                                 bottom->max_qtcb_size);
-                        zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1", req);
+                        zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1");
                         return;
                 }
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
@@ -536,7 +536,7 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                         &qtcb->header.fsf_status_qual.link_down_info);
                 break;
         default:
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3");
                 return;
         }
 
@@ -552,14 +552,14 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "The FCP adapter only supports newer "
                         "control block versions\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4");
                 return;
         }
         if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
                 dev_err(&adapter->ccw_device->dev,
                         "The FCP adapter only supports older "
                         "control block versions\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5");
         }
 }
 
@@ -700,7 +700,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
                 del_timer(&req->timer);
                 /* lookup request again, list might have changed */
                 zfcp_reqlist_find_rm(adapter->req_list, req_id);
-                zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1");
                 return -EIO;
         }
 
@@ -754,10 +754,11 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
         goto out;
 
 failed_req_send:
+        req->data = NULL;
         mempool_free(sr_buf, adapter->pool.status_read_data);
 failed_buf:
+        zfcp_dbf_hba_fsf_uss("fssr__1", req);
         zfcp_fsf_req_free(req);
-        zfcp_dbf_hba_fsf_unsol("fail", adapter->dbf, NULL);
 out:
         spin_unlock_irq(&qdio->req_q_lock);
         return retval;
@@ -776,14 +777,13 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
         case FSF_PORT_HANDLE_NOT_VALID:
                 if (fsq->word[0] == fsq->word[1]) {
                         zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0,
-                                                "fsafch1", req);
+                                                "fsafch1");
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
         case FSF_LUN_HANDLE_NOT_VALID:
                 if (fsq->word[0] == fsq->word[1]) {
-                        zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2",
-                                             req);
+                        zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2");
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
@@ -794,14 +794,13 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
                 zfcp_erp_set_port_status(zfcp_sdev->port,
                                          ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_port_reopen(zfcp_sdev->port,
-                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3",
-                                     req);
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
                 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                    "fsafch4", req);
+                                    "fsafch4");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -882,7 +881,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
 
         switch (header->fsf_status) {
         case FSF_GOOD:
-                zfcp_dbf_san_ct_response(req);
+                zfcp_dbf_san_res("fsscth1", req);
                 ct->status = 0;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -902,7 +901,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsscth1");
                 /* fall through */
         case FSF_GENERIC_COMMAND_REJECTED:
         case FSF_PAYLOAD_SIZE_MISMATCH:
@@ -1025,7 +1024,7 @@ int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
         req->qtcb->header.port_handle = wka_port->handle;
         req->data = ct;
 
-        zfcp_dbf_san_ct_request(req, wka_port->d_id);
+        zfcp_dbf_san_req("fssct_1", req, wka_port->d_id);
 
         ret = zfcp_fsf_req_send(req);
         if (ret)
@@ -1053,7 +1052,7 @@ static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
 
         switch (header->fsf_status) {
         case FSF_GOOD:
-                zfcp_dbf_san_els_response(req);
+                zfcp_dbf_san_res("fsselh1", req);
                 send_els->status = 0;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -1127,7 +1126,7 @@ int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
         req->handler = zfcp_fsf_send_els_handler;
         req->data = els;
 
-        zfcp_dbf_san_els_request(req);
+        zfcp_dbf_san_req("fssels1", req, d_id);
 
         ret = zfcp_fsf_req_send(req);
         if (ret)
@@ -1448,7 +1447,7 @@ static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1", req);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1580,7 +1579,7 @@ static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
 
         if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1", req);
+                zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1");
         }
 
         wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
@@ -1638,7 +1637,7 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
 
         switch (header->fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1", req);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ACCESS_DENIED:
@@ -1654,7 +1653,7 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
                                                   &sdev_to_zfcp(sdev)->status);
                 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                     "fscpph2", req);
+                                     "fscpph2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1743,7 +1742,7 @@ static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
         switch (header->fsf_status) {
 
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1");
                 /* fall through */
         case FSF_LUN_ALREADY_OPEN:
                 break;
@@ -1755,8 +1754,7 @@ static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
                 zfcp_erp_set_port_status(zfcp_sdev->port,
                                          ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_port_reopen(zfcp_sdev->port,
-                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2",
-                                     req);
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_SHARING_VIOLATION:
@@ -1852,20 +1850,18 @@ static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1",
-                                        req);
+                zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_HANDLE_NOT_VALID:
-                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2", req);
+                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
                 zfcp_erp_set_port_status(zfcp_sdev->port,
                                          ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_port_reopen(zfcp_sdev->port,
-                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3",
-                                     req);
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -2002,13 +1998,12 @@ static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
         switch (header->fsf_status) {
         case FSF_HANDLE_MISMATCH:
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fssfch1",
-                                        req);
+                zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fssfch1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_FCPLUN_NOT_VALID:
         case FSF_LUN_HANDLE_NOT_VALID:
-                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2", req);
+                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -2026,7 +2021,7 @@ static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
                         (unsigned long long)zfcp_scsi_dev_lun(sdev),
                         (unsigned long long)zfcp_sdev->port->wwpn);
                 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
-                                          "fssfch3", req);
+                                          "fssfch3");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_CMND_LENGTH_NOT_VALID:
@@ -2037,21 +2032,20 @@ static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
                         (unsigned long long)zfcp_scsi_dev_lun(sdev),
                         (unsigned long long)zfcp_sdev->port->wwpn);
                 zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
-                                          "fssfch4", req);
+                                          "fssfch4");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
                 zfcp_erp_set_port_status(zfcp_sdev->port,
                                          ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_port_reopen(zfcp_sdev->port,
-                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5",
-                                     req);
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
                 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
                 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                    "fssfch6", req);
+                                    "fssfch6");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -2104,7 +2098,7 @@ static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
 
 skip_fsfstatus:
         zfcp_fsf_req_trace(req, scpnt);
-        zfcp_dbf_scsi_result(req->adapter->dbf, scpnt, req);
+        zfcp_dbf_scsi_result(scpnt, req);
 
         scpnt->host_scribble = NULL;
         (scpnt->scsi_done) (scpnt);
@@ -2420,3 +2414,12 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
                         break;
         }
 }
+
+struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *qdio,
+                                      struct qdio_buffer *sbal)
+{
+        struct qdio_buffer_element *sbale = &sbal->element[0];
+        u64 req_id = (unsigned long) sbale->addr;
+
+        return zfcp_reqlist_find(qdio->adapter->req_list, req_id);
+}
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index a0554beb4179..2511f92302dd 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -41,7 +41,7 @@ static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id,
                 zfcp_qdio_siosl(adapter);
         zfcp_erp_adapter_reopen(adapter,
                                 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
-                                ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL);
+                                ZFCP_STATUS_COMMON_ERP_FAILED, id);
 }
 
 static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
@@ -74,7 +74,6 @@ static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
         struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
 
         if (unlikely(qdio_err)) {
-                zfcp_dbf_hba_qdio(qdio->adapter->dbf, qdio_err, idx, count);
                 zfcp_qdio_handler_error(qdio, "qdireq1", qdio_err);
                 return;
         }
@@ -97,7 +96,6 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
         int sbal_idx, sbal_no;
 
         if (unlikely(qdio_err)) {
-                zfcp_dbf_hba_qdio(qdio->adapter->dbf, qdio_err, idx, count);
                 zfcp_qdio_handler_error(qdio, "qdires1", qdio_err);
                 return;
         }
@@ -116,7 +114,7 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
          * put SBALs back to response queue
          */
         if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count))
-                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2", NULL);
+                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2");
 }
 
 static struct qdio_buffer_element *
@@ -236,7 +234,7 @@ int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
         if (!ret) {
                 atomic_inc(&qdio->req_q_full);
                 /* assume hanging outbound queue, try queue recovery */
-                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1", NULL);
+                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1");
         }
 
         spin_lock_irq(&qdio->req_q_lock);
@@ -309,6 +307,7 @@ static int zfcp_qdio_allocate(struct zfcp_qdio *qdio)
                 return -ENOMEM;
 
         zfcp_qdio_setup_init_data(&init_data, qdio);
+        init_waitqueue_head(&qdio->req_q_wq);
 
         return qdio_allocate(&init_data);
 }
@@ -393,6 +392,7 @@ int zfcp_qdio_open(struct zfcp_qdio *qdio)
         /* set index of first avalable SBALS / number of available SBALS */
         qdio->req_q_idx = 0;
         atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q);
+        atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status);
 
         return 0;
 
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 63529ed801eb..ddb5800823a9 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -30,6 +30,10 @@ module_param_named(dif, enable_dif, bool, 0600);
 MODULE_PARM_DESC(dif, "Enable DIF/DIX data integrity support");
 #endif
 
+static bool allow_lun_scan = 1;
+module_param(allow_lun_scan, bool, 0600);
+MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
+
 static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
                                         int reason)
 {
@@ -68,11 +72,8 @@ static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
 
 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
 {
-        struct zfcp_adapter *adapter =
-                (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
-
         set_host_byte(scpnt, result);
-        zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
+        zfcp_dbf_scsi_fail_send(scpnt);
         scpnt->scsi_done(scpnt);
 }
 
@@ -80,7 +81,6 @@ static
 int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
 {
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
-        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
         struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
         int    status, scsi_result, ret;
 
@@ -91,7 +91,7 @@ int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
         scsi_result = fc_remote_port_chkready(rport);
         if (unlikely(scsi_result)) {
                 scpnt->result = scsi_result;
-                zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
+                zfcp_dbf_scsi_fail_send(scpnt);
                 scpnt->scsi_done(scpnt);
                 return 0;
         }
@@ -134,6 +134,7 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
         struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         struct zfcp_port *port;
         struct zfcp_unit *unit;
+        int npiv = adapter->connection_features & FSF_FEATURE_NPIV_MODE;
 
         port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
         if (!port)
@@ -143,7 +144,7 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
         if (unit)
                 put_device(&unit->dev);
 
-        if (!unit && !(adapter->connection_features & FSF_FEATURE_NPIV_MODE)) {
+        if (!unit && !(allow_lun_scan && npiv)) {
                 put_device(&port->dev);
                 return -ENXIO;
         }
@@ -158,7 +159,7 @@ static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
         spin_lock_init(&zfcp_sdev->latencies.lock);
 
         zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
-        zfcp_erp_lun_reopen(sdev, 0, "scsla_1", NULL);
+        zfcp_erp_lun_reopen(sdev, 0, "scsla_1");
         zfcp_erp_wait(port->adapter);
 
         return 0;
@@ -182,8 +183,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
         old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);
         if (!old_req) {
                 write_unlock_irqrestore(&adapter->abort_lock, flags);
-                zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL,
-                                    old_reqid);
+                zfcp_dbf_scsi_abort("abrt_or", scpnt, NULL);
                 return FAILED; /* completion could be in progress */
         }
         old_req->data = NULL;
@@ -198,29 +198,32 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
 
                 zfcp_erp_wait(adapter);
                 ret = fc_block_scsi_eh(scpnt);
-                if (ret)
+                if (ret) {
+                        zfcp_dbf_scsi_abort("abrt_bl", scpnt, NULL);
                         return ret;
+                }
                 if (!(atomic_read(&adapter->status) &
                       ZFCP_STATUS_COMMON_RUNNING)) {
-                        zfcp_dbf_scsi_abort("nres", adapter->dbf, scpnt, NULL,
-                                            old_reqid);
+                        zfcp_dbf_scsi_abort("abrt_ru", scpnt, NULL);
                         return SUCCESS;
                 }
         }
-        if (!abrt_req)
+        if (!abrt_req) {
+                zfcp_dbf_scsi_abort("abrt_ar", scpnt, NULL);
                 return FAILED;
+        }
 
         wait_for_completion(&abrt_req->completion);
 
         if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
-                dbf_tag = "okay";
+                dbf_tag = "abrt_ok";
         else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
-                dbf_tag = "lte2";
+                dbf_tag = "abrt_nn";
         else {
-                dbf_tag = "fail";
+                dbf_tag = "abrt_fa";
                 retval = FAILED;
         }
-        zfcp_dbf_scsi_abort(dbf_tag, adapter->dbf, scpnt, abrt_req, old_reqid);
+        zfcp_dbf_scsi_abort(dbf_tag, scpnt, abrt_req);
         zfcp_fsf_req_free(abrt_req);
         return retval;
 }
@@ -280,7 +283,7 @@ static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
         struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
         int ret;
 
-        zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt);
+        zfcp_erp_adapter_reopen(adapter, 0, "schrh_1");
         zfcp_erp_wait(adapter);
         ret = fc_block_scsi_eh(scpnt);
         if (ret)
@@ -518,7 +521,7 @@ static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
         port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
 
         if (port) {
-                zfcp_erp_port_forced_reopen(port, 0, "sctrpi1", NULL);
+                zfcp_erp_port_forced_reopen(port, 0, "sctrpi1");
                 put_device(&port->dev);
         }
 }
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c
index 2f2c54f4718f..cdc4ff78a7ba 100644
--- a/drivers/s390/scsi/zfcp_sysfs.c
+++ b/drivers/s390/scsi/zfcp_sysfs.c
@@ -105,8 +105,7 @@ static ssize_t zfcp_sysfs_port_failed_store(struct device *dev,
                 return -EINVAL;
 
         zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_RUNNING);
-        zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, "sypfai2",
-                             NULL);
+        zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, "sypfai2");
         zfcp_erp_wait(port->adapter);
 
         return count;
@@ -148,7 +147,7 @@ static ssize_t zfcp_sysfs_unit_failed_store(struct device *dev,
         if (sdev) {
                 zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
                 zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                    "syufai2", NULL);
+                                    "syufai2");
                 zfcp_erp_wait(unit->port->adapter);
         } else
                 zfcp_unit_scsi_scan(unit);
@@ -198,7 +197,7 @@ static ssize_t zfcp_sysfs_adapter_failed_store(struct device *dev,
 
         zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "syafai2", NULL);
+                                "syafai2");
         zfcp_erp_wait(adapter);
 out:
         zfcp_ccw_adapter_put(adapter);
@@ -256,7 +255,7 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
 
         put_device(&port->dev);
 
-        zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL);
+        zfcp_erp_port_shutdown(port, 0, "syprs_1");
         zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
  out:
         zfcp_ccw_adapter_put(adapter);
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 17e3df4f016f..1cadcd6b7da6 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -1171,9 +1171,8 @@ static int arcmsr_build_ccb(struct AdapterControlBlock *acb,
         arcmsr_cdb->msgPages = arccdbsize/0x100 + (arccdbsize % 0x100 ? 1 : 0);
         if ( arccdbsize > 256)
                 arcmsr_cdb->Flags |= ARCMSR_CDB_FLAG_SGL_BSIZE;
-        if (pcmd->cmnd[0]|WRITE_6 || pcmd->cmnd[0]|WRITE_10 || pcmd->cmnd[0]|WRITE_12 ){
+        if (pcmd->sc_data_direction == DMA_TO_DEVICE)
                 arcmsr_cdb->Flags |= ARCMSR_CDB_FLAG_WRITE;
-        }
         ccb->arc_cdb_size = arccdbsize;
         return SUCCESS;
 }
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 75a85aa9e882..79cefbe31367 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -3785,7 +3785,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
         dma_addr_t paddr;
 
         io_task->cmd_bhs = pci_pool_alloc(beiscsi_sess->bhs_pool,
-                                          GFP_KERNEL, &paddr);
+                                          GFP_ATOMIC, &paddr);
         if (!io_task->cmd_bhs)
                 return -ENOMEM;
         io_task->bhs_pa.u.a64.address = paddr;
@@ -3914,7 +3914,8 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
                         io_task->psgl_handle = NULL;
                 }
         } else {
-                if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN)
+                if (task->hdr &&
+                   ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN))
                         return;
                 if (io_task->psgl_handle) {
                         spin_lock(&phba->mgmt_sgl_lock);
diff --git a/drivers/scsi/bfa/Makefile b/drivers/scsi/bfa/Makefile
index d2eefd3e3bd5..4ce6f4942327 100644
--- a/drivers/scsi/bfa/Makefile
+++ b/drivers/scsi/bfa/Makefile
@@ -3,6 +3,4 @@ obj-$(CONFIG_SCSI_BFA_FC) := bfa.o
 bfa-y := bfad.o bfad_im.o bfad_attr.o bfad_debugfs.o
 bfa-y += bfa_ioc.o bfa_ioc_cb.o bfa_ioc_ct.o bfa_hw_cb.o bfa_hw_ct.o
 bfa-y += bfa_fcs.o bfa_fcs_lport.o bfa_fcs_rport.o bfa_fcs_fcpim.o bfa_fcbuild.o
-bfa-y += bfa_port.o bfa_fcpim.o bfa_core.o bfa_drv.o bfa_svc.o
-
-ccflags-y := -DBFA_PERF_BUILD
+bfa-y += bfa_port.o bfa_fcpim.o bfa_core.o bfa_svc.o
diff --git a/drivers/scsi/bfa/bfa.h b/drivers/scsi/bfa/bfa.h
index ff2bd07161f7..7be6b5a8114b 100644
--- a/drivers/scsi/bfa/bfa.h
+++ b/drivers/scsi/bfa/bfa.h
@@ -17,7 +17,7 @@
 #ifndef __BFA_H__
 #define __BFA_H__
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 #include "bfa_cs.h"
 #include "bfa_plog.h"
 #include "bfa_defs_svc.h"
@@ -33,7 +33,6 @@ typedef void    (*bfa_cb_cbfn_t) (void *cbarg, bfa_boolean_t complete);
  * Interrupt message handlers
  */
 void bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m);
-void bfa_isr_bind(enum bfi_mclass mc, bfa_isr_func_t isr_func);
 
 /*
  * Request and response queue related defines
@@ -121,8 +120,8 @@ bfa_reqq_winit(struct bfa_reqq_wait_s *wqe, void (*qresume) (void *cbarg),
                                                                         \
                 struct list_head *waitq = bfa_reqq(__bfa, __reqq);      \
                                                                         \
-                bfa_assert(((__reqq) < BFI_IOC_MAX_CQS));      \
-                bfa_assert((__wqe)->qresume && (__wqe)->cbarg);      \
+                WARN_ON(((__reqq) >= BFI_IOC_MAX_CQS));                 \
+                WARN_ON(!((__wqe)->qresume && (__wqe)->cbarg));         \
                                                                         \
                 list_add_tail(&(__wqe)->qe, waitq);      \
         } while (0)
@@ -297,7 +296,6 @@ void bfa_iocfc_attach(struct bfa_s *bfa, void *bfad,
                       struct bfa_iocfc_cfg_s *cfg,
                       struct bfa_meminfo_s *meminfo,
                       struct bfa_pcidev_s *pcidev);
-void bfa_iocfc_detach(struct bfa_s *bfa);
 void bfa_iocfc_init(struct bfa_s *bfa);
 void bfa_iocfc_start(struct bfa_s *bfa);
 void bfa_iocfc_stop(struct bfa_s *bfa);
@@ -333,12 +331,9 @@ void bfa_hwct_msix_getvecs(struct bfa_s *bfa, u32 *vecmap, u32 *nvecs,
                            u32 *maxvec);
 void bfa_hwct_msix_get_rme_range(struct bfa_s *bfa, u32 *start,
                                  u32 *end);
-void bfa_com_port_attach(struct bfa_s *bfa, struct bfa_meminfo_s *mi);
 void bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns);
 wwn_t bfa_iocfc_get_pwwn(struct bfa_s *bfa);
 wwn_t bfa_iocfc_get_nwwn(struct bfa_s *bfa);
-void bfa_iocfc_get_pbc_boot_cfg(struct bfa_s *bfa,
-                                struct bfa_boot_pbc_s *pbcfg);
 int bfa_iocfc_get_pbc_vports(struct bfa_s *bfa,
                                 struct bfi_pbc_vport_s *pbc_vport);
 
@@ -386,19 +381,11 @@ void bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg,
 void bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
                 struct bfa_meminfo_s *meminfo,
                 struct bfa_pcidev_s *pcidev);
-void bfa_init_trc(struct bfa_s *bfa, struct bfa_trc_mod_s *trcmod);
-void bfa_init_plog(struct bfa_s *bfa, struct bfa_plog_s *plog);
 void bfa_detach(struct bfa_s *bfa);
-void bfa_init(struct bfa_s *bfa);
-void bfa_start(struct bfa_s *bfa);
-void bfa_stop(struct bfa_s *bfa);
-void bfa_attach_fcs(struct bfa_s *bfa);
 void bfa_cb_init(void *bfad, bfa_status_t status);
 void bfa_cb_updateq(void *bfad, bfa_status_t status);
 
 bfa_boolean_t bfa_intx(struct bfa_s *bfa);
-void bfa_intx_disable(struct bfa_s *bfa);
-void bfa_intx_enable(struct bfa_s *bfa);
 void bfa_isr_enable(struct bfa_s *bfa);
 void bfa_isr_disable(struct bfa_s *bfa);
 
@@ -408,31 +395,14 @@ void bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q);
 
 typedef void (*bfa_cb_ioc_t) (void *cbarg, enum bfa_status status);
 void bfa_iocfc_get_attr(struct bfa_s *bfa, struct bfa_iocfc_attr_s *attr);
-void bfa_get_attr(struct bfa_s *bfa, struct bfa_ioc_attr_s *ioc_attr);
 
-void bfa_adapter_get_attr(struct bfa_s *bfa,
-                          struct bfa_adapter_attr_s *ad_attr);
-u64 bfa_adapter_get_id(struct bfa_s *bfa);
 
 bfa_status_t bfa_iocfc_israttr_set(struct bfa_s *bfa,
                                    struct bfa_iocfc_intr_attr_s *attr);
 
 void bfa_iocfc_enable(struct bfa_s *bfa);
 void bfa_iocfc_disable(struct bfa_s *bfa);
-void bfa_chip_reset(struct bfa_s *bfa);
-void bfa_timer_tick(struct bfa_s *bfa);
 #define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout)         \
         bfa_timer_begin(&(_bfa)->timer_mod, _timer, _timercb, _arg, _timeout)
 
-/*
- * BFA debug API functions
- */
-bfa_status_t bfa_debug_fwtrc(struct bfa_s *bfa, void *trcdata, int *trclen);
-bfa_status_t bfa_debug_fwsave(struct bfa_s *bfa, void *trcdata, int *trclen);
-bfa_status_t bfa_debug_fwcore(struct bfa_s *bfa, void *buf,
-                              u32 *offset, int *buflen);
-void bfa_debug_fwsave_clear(struct bfa_s *bfa);
-bfa_status_t bfa_fw_stats_get(struct bfa_s *bfa, void *data);
-bfa_status_t bfa_fw_stats_clear(struct bfa_s *bfa);
-
 #endif /* __BFA_H__ */
diff --git a/drivers/scsi/bfa/bfa_cb_ioim.h b/drivers/scsi/bfa/bfa_cb_ioim.h
deleted file mode 100644
index 6f021015f1f6..000000000000
--- a/drivers/scsi/bfa/bfa_cb_ioim.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
- * All rights reserved
- * www.brocade.com
- *
- * Linux driver for Brocade Fibre Channel Host Bus Adapter.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License (GPL) Version 2 as
- * published by the Free Software Foundation
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-
-#ifndef __BFA_HCB_IOIM_H__
-#define __BFA_HCB_IOIM_H__
-
-#include "bfa_os_inc.h"
-/*
- * task attribute values in FCP-2 FCP_CMND IU
- */
-#define SIMPLE_Q    0
-#define HEAD_OF_Q   1
-#define ORDERED_Q   2
-#define ACA_Q       4
-#define UNTAGGED    5
-
-static inline lun_t
-bfad_int_to_lun(u32 luno)
-{
-        union {
-                u16     scsi_lun[4];
-                lun_t           bfa_lun;
-        } lun;
-
-        lun.bfa_lun     = 0;
-        lun.scsi_lun[0] = cpu_to_be16(luno);
-
-        return lun.bfa_lun;
-}
-
-/*
- * Get LUN for the I/O request
- */
-#define bfa_cb_ioim_get_lun(__dio)      \
-        bfad_int_to_lun(((struct scsi_cmnd *)__dio)->device->lun)
-
-/*
- * Get CDB for the I/O request
- */
-static inline u8 *
-bfa_cb_ioim_get_cdb(struct bfad_ioim_s *dio)
-{
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
-
-        return (u8 *) cmnd->cmnd;
-}
-
-/*
- * Get I/O direction (read/write) for the I/O request
- */
-static inline enum fcp_iodir
-bfa_cb_ioim_get_iodir(struct bfad_ioim_s *dio)
-{
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
-        enum dma_data_direction dmadir;
-
-        dmadir = cmnd->sc_data_direction;
-        if (dmadir == DMA_TO_DEVICE)
-                return FCP_IODIR_WRITE;
-        else if (dmadir == DMA_FROM_DEVICE)
-                return FCP_IODIR_READ;
-        else
-                return FCP_IODIR_NONE;
-}
-
-/*
- * Get IO size in bytes for the I/O request
- */
-static inline u32
-bfa_cb_ioim_get_size(struct bfad_ioim_s *dio)
-{
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
-
-        return scsi_bufflen(cmnd);
-}
-
-/*
- * Get timeout for the I/O request
- */
-static inline u8
-bfa_cb_ioim_get_timeout(struct bfad_ioim_s *dio)
-{
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
-        /*
-         * TBD: need a timeout for scsi passthru
-         */
-        if (cmnd->device->host == NULL)
-                return 4;
-
-        return 0;
-}
-
-/*
- * Get Command Reference Number for the I/O request. 0 if none.
- */
-static inline u8
-bfa_cb_ioim_get_crn(struct bfad_ioim_s *dio)
-{
-        return 0;
-}
-
-/*
- * Get SAM-3 priority for the I/O request. 0 is default.
- */
-static inline u8
-bfa_cb_ioim_get_priority(struct bfad_ioim_s *dio)
-{
-        return 0;
-}
-
-/*
- * Get task attributes for the I/O request. Default is FCP_TASK_ATTR_SIMPLE(0).
- */
-static inline u8
-bfa_cb_ioim_get_taskattr(struct bfad_ioim_s *dio)
-{
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
-        u8      task_attr = UNTAGGED;
-
-        if (cmnd->device->tagged_supported) {
-                switch (cmnd->tag) {
-                case HEAD_OF_QUEUE_TAG:
-                        task_attr = HEAD_OF_Q;
-                        break;
-                case ORDERED_QUEUE_TAG:
-                        task_attr = ORDERED_Q;
-                        break;
-                default:
-                        task_attr = SIMPLE_Q;
-                        break;
-                }
-        }
-
-        return task_attr;
-}
-
-/*
- * Get CDB length in bytes for the I/O request. Default is FCP_CMND_CDB_LEN(16).
- */
-static inline u8
-bfa_cb_ioim_get_cdblen(struct bfad_ioim_s *dio)
-{
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
-
-        return cmnd->cmd_len;
-}
-
-/*
- * Assign queue to be used for the I/O request. This value depends on whether
- * the driver wants to use the queues via any specific algorithm. Currently,
- * this is not supported.
- */
-#define bfa_cb_ioim_get_reqq(__dio) BFA_FALSE
-
-#endif /* __BFA_HCB_IOIM_H__ */
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 2345f48dc57f..1cd5c8b0618d 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -15,13 +15,100 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_modules.h"
 #include "bfi_ctreg.h"
-#include "bfad_drv.h"
 
 BFA_TRC_FILE(HAL, CORE);
 
 /*
+ * BFA module list terminated by NULL
+ */
+static struct bfa_module_s *hal_mods[] = {
+        &hal_mod_sgpg,
+        &hal_mod_fcport,
+        &hal_mod_fcxp,
+        &hal_mod_lps,
+        &hal_mod_uf,
+        &hal_mod_rport,
+        &hal_mod_fcpim,
+        NULL
+};
+
+/*
+ * Message handlers for various modules.
+ */
+static bfa_isr_func_t  bfa_isrs[BFI_MC_MAX] = {
+        bfa_isr_unhandled,      /* NONE */
+        bfa_isr_unhandled,      /* BFI_MC_IOC */
+        bfa_isr_unhandled,      /* BFI_MC_DIAG */
+        bfa_isr_unhandled,      /* BFI_MC_FLASH */
+        bfa_isr_unhandled,      /* BFI_MC_CEE */
+        bfa_fcport_isr,         /* BFI_MC_FCPORT */
+        bfa_isr_unhandled,      /* BFI_MC_IOCFC */
+        bfa_isr_unhandled,      /* BFI_MC_LL */
+        bfa_uf_isr,             /* BFI_MC_UF */
+        bfa_fcxp_isr,           /* BFI_MC_FCXP */
+        bfa_lps_isr,            /* BFI_MC_LPS */
+        bfa_rport_isr,          /* BFI_MC_RPORT */
+        bfa_itnim_isr,          /* BFI_MC_ITNIM */
+        bfa_isr_unhandled,      /* BFI_MC_IOIM_READ */
+        bfa_isr_unhandled,      /* BFI_MC_IOIM_WRITE */
+        bfa_isr_unhandled,      /* BFI_MC_IOIM_IO */
+        bfa_ioim_isr,           /* BFI_MC_IOIM */
+        bfa_ioim_good_comp_isr, /* BFI_MC_IOIM_IOCOM */
+        bfa_tskim_isr,          /* BFI_MC_TSKIM */
+        bfa_isr_unhandled,      /* BFI_MC_SBOOT */
+        bfa_isr_unhandled,      /* BFI_MC_IPFC */
+        bfa_isr_unhandled,      /* BFI_MC_PORT */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+        bfa_isr_unhandled,      /* --------- */
+};
+/*
+ * Message handlers for mailbox command classes
+ */
+static bfa_ioc_mbox_mcfunc_t  bfa_mbox_isrs[BFI_MC_MAX] = {
+        NULL,
+        NULL,           /* BFI_MC_IOC   */
+        NULL,           /* BFI_MC_DIAG  */
+        NULL,           /* BFI_MC_FLASH */
+        NULL,           /* BFI_MC_CEE   */
+        NULL,           /* BFI_MC_PORT  */
+        bfa_iocfc_isr,  /* BFI_MC_IOCFC */
+        NULL,
+};
+
+
+
+static void
+bfa_com_port_attach(struct bfa_s *bfa, struct bfa_meminfo_s *mi)
+{
+        struct bfa_port_s       *port = &bfa->modules.port;
+        u32                     dm_len;
+        u8                      *dm_kva;
+        u64                     dm_pa;
+
+        dm_len = bfa_port_meminfo();
+        dm_kva = bfa_meminfo_dma_virt(mi);
+        dm_pa  = bfa_meminfo_dma_phys(mi);
+
+        memset(port, 0, sizeof(struct bfa_port_s));
+        bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod);
+        bfa_port_mem_claim(port, dm_kva, dm_pa);
+
+        bfa_meminfo_dma_virt(mi) = dm_kva + dm_len;
+        bfa_meminfo_dma_phys(mi) = dm_pa + dm_len;
+}
+
+/*
  * BFA IOC FC related definitions
  */
 
@@ -67,18 +154,6 @@ static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn;
  * BFA Interrupt handling functions
  */
 static void
-bfa_msix_errint(struct bfa_s *bfa, u32 intr)
-{
-        bfa_ioc_error_isr(&bfa->ioc);
-}
-
-static void
-bfa_msix_lpu(struct bfa_s *bfa)
-{
-        bfa_ioc_mbox_isr(&bfa->ioc);
-}
-
-static void
 bfa_reqq_resume(struct bfa_s *bfa, int qid)
 {
         struct list_head *waitq, *qe, *qen;
@@ -104,9 +179,6 @@ bfa_msix_all(struct bfa_s *bfa, int vec)
         bfa_intx(bfa);
 }
 
-/*
- *  hal_intr_api
- */
 bfa_boolean_t
 bfa_intx(struct bfa_s *bfa)
 {
@@ -151,18 +223,6 @@ bfa_intx(struct bfa_s *bfa)
 }
 
 void
-bfa_intx_enable(struct bfa_s *bfa)
-{
-        writel(bfa->iocfc.intr_mask, bfa->iocfc.bfa_regs.intr_mask);
-}
-
-void
-bfa_intx_disable(struct bfa_s *bfa)
-{
-        writel(-1L, bfa->iocfc.bfa_regs.intr_mask);
-}
-
-void
 bfa_isr_enable(struct bfa_s *bfa)
 {
         u32 intr_unmask;
@@ -225,7 +285,7 @@ bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m)
         bfa_trc(bfa, m->mhdr.msg_class);
         bfa_trc(bfa, m->mhdr.msg_id);
         bfa_trc(bfa, m->mhdr.mtag.i2htok);
-        bfa_assert(0);
+        WARN_ON(1);
         bfa_trc_stop(bfa->trcmod);
 }
 
@@ -236,8 +296,6 @@ bfa_msix_rspq(struct bfa_s *bfa, int qid)
         u32 pi, ci;
         struct list_head *waitq;
 
-        bfa_trc_fp(bfa, qid);
-
         qid &= (BFI_IOC_MAX_CQS - 1);
 
         bfa->iocfc.hwif.hw_rspq_ack(bfa, qid);
@@ -245,16 +303,10 @@ bfa_msix_rspq(struct bfa_s *bfa, int qid)
         ci = bfa_rspq_ci(bfa, qid);
         pi = bfa_rspq_pi(bfa, qid);
 
-        bfa_trc_fp(bfa, ci);
-        bfa_trc_fp(bfa, pi);
-
         if (bfa->rme_process) {
                 while (ci != pi) {
                         m = bfa_rspq_elem(bfa, qid, ci);
-                        bfa_assert_fp(m->mhdr.msg_class < BFI_MC_MAX);
-
                         bfa_isrs[m->mhdr.msg_class] (bfa, m);
-
                         CQ_INCR(ci, bfa->iocfc.cfg.drvcfg.num_rspq_elems);
                 }
         }
@@ -282,7 +334,7 @@ bfa_msix_lpu_err(struct bfa_s *bfa, int vec)
         intr = readl(bfa->iocfc.bfa_regs.intr_status);
 
         if (intr & (__HFN_INT_MBOX_LPU0 | __HFN_INT_MBOX_LPU1))
-                bfa_msix_lpu(bfa);
+                bfa_ioc_mbox_isr(&bfa->ioc);
 
         intr &= (__HFN_INT_ERR_EMC | __HFN_INT_ERR_LPU0 |
                 __HFN_INT_ERR_LPU1 | __HFN_INT_ERR_PSS | __HFN_INT_LL_HALT);
@@ -313,22 +365,16 @@ bfa_msix_lpu_err(struct bfa_s *bfa, int vec)
                 }
 
                 writel(intr, bfa->iocfc.bfa_regs.intr_status);
-                bfa_msix_errint(bfa, intr);
+                bfa_ioc_error_isr(&bfa->ioc);
         }
 }
 
-void
-bfa_isr_bind(enum bfi_mclass mc, bfa_isr_func_t isr_func)
-{
-        bfa_isrs[mc] = isr_func;
-}
-
 /*
  * BFA IOC FC related functions
  */
 
 /*
- *  hal_ioc_pvt BFA IOC private functions
+ *  BFA IOC private functions
  */
 
 static void
@@ -379,7 +425,7 @@ bfa_iocfc_send_cfg(void *bfa_arg)
         struct bfa_iocfc_cfg_s  *cfg = &iocfc->cfg;
         int             i;
 
-        bfa_assert(cfg->fwcfg.num_cqs <= BFI_IOC_MAX_CQS);
+        WARN_ON(cfg->fwcfg.num_cqs > BFI_IOC_MAX_CQS);
         bfa_trc(bfa, cfg->fwcfg.num_cqs);
 
         bfa_iocfc_reset_queues(bfa);
@@ -488,8 +534,8 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg,
          * First allocate dma memory for IOC.
          */
         bfa_ioc_mem_claim(&bfa->ioc, dm_kva, dm_pa);
-        dm_kva += bfa_ioc_meminfo();
-        dm_pa  += bfa_ioc_meminfo();
+        dm_kva += BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ);
+        dm_pa  += BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ);
 
         /*
          * Claim DMA-able memory for the request/response queues and for shadow
@@ -552,7 +598,7 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg,
         bfa_meminfo_dma_virt(meminfo) = dm_kva;
         bfa_meminfo_dma_phys(meminfo) = dm_pa;
 
-        dbgsz = bfa_ioc_debug_trcsz(bfa_auto_recover);
+        dbgsz = (bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
         if (dbgsz > 0) {
                 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_meminfo_kva(meminfo));
                 bfa_meminfo_kva(meminfo) += dbgsz;
@@ -699,7 +745,7 @@ bfa_iocfc_disable_cbfn(void *bfa_arg)
                 bfa_cb_queue(bfa, &bfa->iocfc.stop_hcb_qe, bfa_iocfc_stop_cb,
                              bfa);
         else {
-                bfa_assert(bfa->iocfc.action == BFA_IOCFC_ACT_DISABLE);
+                WARN_ON(bfa->iocfc.action != BFA_IOCFC_ACT_DISABLE);
                 bfa_cb_queue(bfa, &bfa->iocfc.dis_hcb_qe, bfa_iocfc_disable_cb,
                              bfa);
         }
@@ -735,9 +781,6 @@ bfa_iocfc_reset_cbfn(void *bfa_arg)
         bfa_isr_enable(bfa);
 }
 
-/*
- *  hal_ioc_public
- */
 
 /*
  * Query IOC memory requirement information.
@@ -747,11 +790,11 @@ bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
                   u32 *dm_len)
 {
         /* dma memory for IOC */
-        *dm_len += bfa_ioc_meminfo();
+        *dm_len += BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ);
 
         bfa_iocfc_fw_cfg_sz(cfg, dm_len);
         bfa_iocfc_cqs_sz(cfg, dm_len);
-        *km_len += bfa_ioc_debug_trcsz(bfa_auto_recover);
+        *km_len += (bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
 }
 
 /*
@@ -783,7 +826,7 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 
         bfa_iocfc_init_mem(bfa, bfad, cfg, pcidev);
         bfa_iocfc_mem_claim(bfa, cfg, meminfo);
-        bfa_timer_init(&bfa->timer_mod);
+        INIT_LIST_HEAD(&bfa->timer_mod.timer_q);
 
         INIT_LIST_HEAD(&bfa->comp_q);
         for (i = 0; i < BFI_IOC_MAX_CQS; i++)
@@ -794,15 +837,6 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
  * Query IOC memory requirement information.
  */
 void
-bfa_iocfc_detach(struct bfa_s *bfa)
-{
-        bfa_ioc_detach(&bfa->ioc);
-}
-
-/*
- * Query IOC memory requirement information.
- */
-void
 bfa_iocfc_init(struct bfa_s *bfa)
 {
         bfa->iocfc.action = BFA_IOCFC_ACT_INIT;
@@ -852,23 +886,11 @@ bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m)
                 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK);
                 break;
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
 void
-bfa_adapter_get_attr(struct bfa_s *bfa, struct bfa_adapter_attr_s *ad_attr)
-{
-        bfa_ioc_get_adapter_attr(&bfa->ioc, ad_attr);
-}
-
-u64
-bfa_adapter_get_id(struct bfa_s *bfa)
-{
-        return bfa_ioc_get_adid(&bfa->ioc);
-}
-
-void
 bfa_iocfc_get_attr(struct bfa_s *bfa, struct bfa_iocfc_attr_s *attr)
 {
         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
@@ -976,18 +998,6 @@ bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns)
         memcpy(wwns, cfgrsp->bootwwns.wwn, sizeof(cfgrsp->bootwwns.wwn));
 }
 
-void
-bfa_iocfc_get_pbc_boot_cfg(struct bfa_s *bfa, struct bfa_boot_pbc_s *pbcfg)
-{
-        struct bfa_iocfc_s *iocfc = &bfa->iocfc;
-        struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
-
-        pbcfg->enable = cfgrsp->pbc_cfg.boot_enabled;
-        pbcfg->nbluns = cfgrsp->pbc_cfg.nbluns;
-        pbcfg->speed = cfgrsp->pbc_cfg.port_speed;
-        memcpy(pbcfg->pblun, cfgrsp->pbc_cfg.blun, sizeof(pbcfg->pblun));
-}
-
 int
 bfa_iocfc_get_pbc_vports(struct bfa_s *bfa, struct bfi_pbc_vport_s *pbc_vport)
 {
@@ -998,9 +1008,6 @@ bfa_iocfc_get_pbc_vports(struct bfa_s *bfa, struct bfi_pbc_vport_s *pbc_vport)
         return cfgrsp->pbc_cfg.nvports;
 }
 
-/*
- *  hal_api
- */
 
 /*
  * Use this function query the memory requirement of the BFA library.
@@ -1036,7 +1043,7 @@ bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo)
         int             i;
         u32     km_len = 0, dm_len = 0;
 
-        bfa_assert((cfg != NULL) && (meminfo != NULL));
+        WARN_ON((cfg == NULL) || (meminfo == NULL));
 
         memset((void *)meminfo, 0, sizeof(struct bfa_meminfo_s));
         meminfo->meminfo[BFA_MEM_TYPE_KVA - 1].mem_type =
@@ -1090,7 +1097,7 @@ bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 
         bfa->fcs = BFA_FALSE;
 
-        bfa_assert((cfg != NULL) && (meminfo != NULL));
+        WARN_ON((cfg == NULL) || (meminfo == NULL));
 
         /*
          * initialize all memory pointers for iterative allocation
@@ -1129,79 +1136,7 @@ bfa_detach(struct bfa_s *bfa)
 
         for (i = 0; hal_mods[i]; i++)
                 hal_mods[i]->detach(bfa);
-
-        bfa_iocfc_detach(bfa);
-}
-
-
-void
-bfa_init_trc(struct bfa_s *bfa, struct bfa_trc_mod_s *trcmod)
-{
-        bfa->trcmod = trcmod;
-}
-
-void
-bfa_init_plog(struct bfa_s *bfa, struct bfa_plog_s *plog)
-{
-        bfa->plog = plog;
-}
-
-/*
- * Initialize IOC.
- *
- * This function will return immediately, when the IOC initialization is
- * completed, the bfa_cb_init() will be called.
- *
- * @param[in]   bfa     instance
- *
- * @return void
- *
- * Special Considerations:
- *
- * @note
- * When this function returns, the driver should register the interrupt service
- * routine(s) and enable the device interrupts. If this is not done,
- * bfa_cb_init() will never get called
- */
-void
-bfa_init(struct bfa_s *bfa)
-{
-        bfa_iocfc_init(bfa);
-}
-
-/*
- * Use this function initiate the IOC configuration setup. This function
- * will return immediately.
- *
- * @param[in]   bfa     instance
- *
- * @return None
- */
-void
-bfa_start(struct bfa_s *bfa)
-{
-        bfa_iocfc_start(bfa);
-}
-
-/*
- * Use this function quiese the IOC. This function will return immediately,
- * when the IOC is actually stopped, the bfad->comp will be set.
- *
- * @param[in]bfa - pointer to bfa_t.
- *
- * @return None
- *
- * Special Considerations:
- * bfad->comp can be set before or after bfa_stop() returns.
- *
- * @note
- * In case of any failure, we could handle it automatically by doing a
- * reset and then succeed the bfa_stop() call.
- */
-void
-bfa_stop(struct bfa_s *bfa)
-{
-        bfa_iocfc_stop(bfa);
+        bfa_ioc_detach(&bfa->ioc);
 }
 
 void
@@ -1237,20 +1172,6 @@ bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
         }
 }
 
-void
-bfa_attach_fcs(struct bfa_s *bfa)
-{
-        bfa->fcs = BFA_TRUE;
-}
-
-/*
- * Periodic timer heart beat from driver
- */
-void
-bfa_timer_tick(struct bfa_s *bfa)
-{
-        bfa_timer_beat(&bfa->timer_mod);
-}
 
 /*
  * Return the list of PCI vendor/device id lists supported by this
@@ -1321,89 +1242,3 @@ bfa_cfg_get_min(struct bfa_iocfc_cfg_s *cfg)
         cfg->drvcfg.num_rspq_elems = BFA_RSPQ_NELEMS_MIN;
         cfg->drvcfg.min_cfg        = BFA_TRUE;
 }
-
-void
-bfa_get_attr(struct bfa_s *bfa, struct bfa_ioc_attr_s *ioc_attr)
-{
-        bfa_ioc_get_attr(&bfa->ioc, ioc_attr);
-}
-
-/*
- * Retrieve firmware trace information on IOC failure.
- */
-bfa_status_t
-bfa_debug_fwsave(struct bfa_s *bfa, void *trcdata, int *trclen)
-{
-        return bfa_ioc_debug_fwsave(&bfa->ioc, trcdata, trclen);
-}
-
-/*
- * Clear the saved firmware trace information of an IOC.
- */
-void
-bfa_debug_fwsave_clear(struct bfa_s *bfa)
-{
-        bfa_ioc_debug_fwsave_clear(&bfa->ioc);
-}
-
-/*
- * Fetch firmware trace data.
- *
- * @param[in]           bfa                     BFA instance
- * @param[out]          trcdata         Firmware trace buffer
- * @param[in,out]       trclen          Firmware trace buffer len
- *
- * @retval BFA_STATUS_OK                        Firmware trace is fetched.
- * @retval BFA_STATUS_INPROGRESS        Firmware trace fetch is in progress.
- */
-bfa_status_t
-bfa_debug_fwtrc(struct bfa_s *bfa, void *trcdata, int *trclen)
-{
-        return bfa_ioc_debug_fwtrc(&bfa->ioc, trcdata, trclen);
-}
-
-/*
- * Dump firmware memory.
- *
- * @param[in]           bfa             BFA instance
- * @param[out]          buf             buffer for dump
- * @param[in,out]       offset          smem offset to start read
- * @param[in,out]       buflen          length of buffer
- *
- * @retval BFA_STATUS_OK                Firmware memory is dumped.
- * @retval BFA_STATUS_INPROGRESS        Firmware memory dump is in progress.
- */
-bfa_status_t
-bfa_debug_fwcore(struct bfa_s *bfa, void *buf, u32 *offset, int *buflen)
-{
-        return bfa_ioc_debug_fwcore(&bfa->ioc, buf, offset, buflen);
-}
-/*
- * Reset hw semaphore & usage cnt regs and initialize.
- */
-void
-bfa_chip_reset(struct bfa_s *bfa)
-{
-        bfa_ioc_ownership_reset(&bfa->ioc);
-        bfa_ioc_pll_init(&bfa->ioc);
-}
-
-/*
- * Fetch firmware statistics data.
- *
- * @param[in]           bfa             BFA instance
- * @param[out]          data            Firmware stats buffer
- *
- * @retval BFA_STATUS_OK                Firmware trace is fetched.
- */
-bfa_status_t
-bfa_fw_stats_get(struct bfa_s *bfa, void *data)
-{
-        return bfa_ioc_fw_stats_get(&bfa->ioc, data);
-}
-
-bfa_status_t
-bfa_fw_stats_clear(struct bfa_s *bfa)
-{
-        return bfa_ioc_fw_stats_clear(&bfa->ioc);
-}
diff --git a/drivers/scsi/bfa/bfa_cs.h b/drivers/scsi/bfa/bfa_cs.h
index 99f242b9aa31..12bfeed268eb 100644
--- a/drivers/scsi/bfa/bfa_cs.h
+++ b/drivers/scsi/bfa/bfa_cs.h
@@ -22,7 +22,7 @@
 #ifndef __BFA_CS_H__
 #define __BFA_CS_H__
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 
 /*
  * BFA TRC
@@ -32,12 +32,20 @@
 #define BFA_TRC_MAX     (4 * 1024)
 #endif
 
+#define BFA_TRC_TS(_trcm)                               \
+        ({                                              \
+                struct timeval tv;                      \
+                                                        \
+                do_gettimeofday(&tv);                   \
+                (tv.tv_sec*1000000+tv.tv_usec);         \
+        })
+
 #ifndef BFA_TRC_TS
 #define BFA_TRC_TS(_trcm)       ((_trcm)->ticks++)
 #endif
 
 struct bfa_trc_s {
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u16     fileno;
         u16     line;
 #else
@@ -99,13 +107,6 @@ bfa_trc_stop(struct bfa_trc_mod_s *trcm)
         trcm->stopped = 1;
 }
 
-#ifdef FWTRC
-extern void dc_flush(void *data);
-#else
-#define dc_flush(data)
-#endif
-
-
 static inline void
 __bfa_trc(struct bfa_trc_mod_s *trcm, int fileno, int line, u64 data)
 {
@@ -119,12 +120,10 @@ __bfa_trc(struct bfa_trc_mod_s *trcm, int fileno, int line, u64 data)
         trc->line = (u16) line;
         trc->data.u64 = data;
         trc->timestamp = BFA_TRC_TS(trcm);
-        dc_flush(trc);
 
         trcm->tail = (trcm->tail + 1) & (BFA_TRC_MAX - 1);
         if (trcm->tail == trcm->head)
                 trcm->head = (trcm->head + 1) & (BFA_TRC_MAX - 1);
-        dc_flush(trcm);
 }
 
 
@@ -141,42 +140,18 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
         trc->line = (u16) line;
         trc->data.u32.u32 = data;
         trc->timestamp = BFA_TRC_TS(trcm);
-        dc_flush(trc);
 
         trcm->tail = (trcm->tail + 1) & (BFA_TRC_MAX - 1);
         if (trcm->tail == trcm->head)
                 trcm->head = (trcm->head + 1) & (BFA_TRC_MAX - 1);
-        dc_flush(trcm);
 }
 
-#ifndef BFA_PERF_BUILD
-#define bfa_trc_fp(_trcp, _data)        bfa_trc(_trcp, _data)
-#else
-#define bfa_trc_fp(_trcp, _data)
-#endif
-
-/*
- * @ BFA LOG interfaces
- */
-#define bfa_assert(__cond)      do {                                    \
-        if (!(__cond)) {                                                \
-                printk(KERN_ERR "assert(%s) failed at %s:%d\\n",         \
-                #__cond, __FILE__, __LINE__);                           \
-        }                                                               \
-} while (0)
-
 #define bfa_sm_fault(__mod, __event)    do {                            \
         bfa_trc(__mod, (((u32)0xDEAD << 16) | __event));                \
         printk(KERN_ERR "Assertion failure: %s:%d: %d",                 \
                 __FILE__, __LINE__, (__event));                         \
 } while (0)
 
-#ifndef BFA_PERF_BUILD
-#define bfa_assert_fp(__cond)   bfa_assert(__cond)
-#else
-#define bfa_assert_fp(__cond)
-#endif
-
 /* BFA queue definitions */
 #define bfa_q_first(_q) ((void *)(((struct list_head *) (_q))->next))
 #define bfa_q_next(_qe) (((struct list_head *) (_qe))->next)
@@ -199,7 +174,6 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
                 bfa_q_prev(bfa_q_next(*((struct list_head **) _qe))) =  \
                                 (struct list_head *) (_q);              \
                 bfa_q_next(_q) = bfa_q_next(*((struct list_head **) _qe));\
-                BFA_Q_DBG_INIT(*((struct list_head **) _qe));           \
         } else {                                                        \
                 *((struct list_head **) (_qe)) = (struct list_head *) NULL;\
         }                                                               \
@@ -214,7 +188,6 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
                 bfa_q_next(bfa_q_prev(*((struct list_head **) _qe))) =  \
                         (struct list_head *) (_q);                      \
                 bfa_q_prev(_q) = bfa_q_prev(*(struct list_head **) _qe);\
-                BFA_Q_DBG_INIT(*((struct list_head **) _qe));           \
         } else {                                                        \
                 *((struct list_head **) (_qe)) = (struct list_head *) NULL;\
         }                                                               \
@@ -236,16 +209,6 @@ bfa_q_is_on_q_func(struct list_head *q, struct list_head *qe)
         return 0;
 }
 
-/*
- * #ifdef BFA_DEBUG (Using bfa_assert to check for debug_build is not
- * consistent across modules)
- */
-#ifndef BFA_PERF_BUILD
-#define BFA_Q_DBG_INIT(_qe) bfa_q_qe_init(_qe)
-#else
-#define BFA_Q_DBG_INIT(_qe)
-#endif
-
 #define bfa_q_is_on_q(_q, _qe)      \
         bfa_q_is_on_q_func(_q, (struct list_head *)(_qe))
 
@@ -361,4 +324,43 @@ bfa_wc_wait(struct bfa_wc_s *wc)
         bfa_wc_down(wc);
 }
 
+static inline void
+wwn2str(char *wwn_str, u64 wwn)
+{
+        union {
+                u64 wwn;
+                u8 byte[8];
+        } w;
+
+        w.wwn = wwn;
+        sprintf(wwn_str, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", w.byte[0],
+                w.byte[1], w.byte[2], w.byte[3], w.byte[4], w.byte[5],
+                w.byte[6], w.byte[7]);
+}
+
+static inline void
+fcid2str(char *fcid_str, u32 fcid)
+{
+        union {
+                u32 fcid;
+                u8 byte[4];
+        } f;
+
+        f.fcid = fcid;
+        sprintf(fcid_str, "%02x:%02x:%02x", f.byte[1], f.byte[2], f.byte[3]);
+}
+
+#define bfa_swap_3b(_x)                         \
+        ((((_x) & 0xff) << 16) |                \
+        ((_x) & 0x00ff00) |                     \
+        (((_x) & 0xff0000) >> 16))
+
+#ifndef __BIG_ENDIAN
+#define bfa_hton3b(_x)  bfa_swap_3b(_x)
+#else
+#define bfa_hton3b(_x)  (_x)
+#endif
+
+#define bfa_ntoh3b(_x)  bfa_hton3b(_x)
+
 #endif /* __BFA_CS_H__ */
diff --git a/drivers/scsi/bfa/bfa_defs.h b/drivers/scsi/bfa/bfa_defs.h
index 4b5b9e35abb9..d85f93aea465 100644
--- a/drivers/scsi/bfa/bfa_defs.h
+++ b/drivers/scsi/bfa/bfa_defs.h
@@ -19,7 +19,7 @@
 #define __BFA_DEFS_H__
 
 #include "bfa_fc.h"
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 
 #define BFA_MFG_SERIALNUM_SIZE                  11
 #define STRSZ(_n)                               (((_n) + 4) & ~3)
@@ -446,8 +446,8 @@ enum bfa_boot_bootopt {
  * Boot lun information.
  */
 struct bfa_boot_bootlun_s {
-        wwn_t   pwwn;   /*  port wwn of target */
-        lun_t   lun;    /*  64-bit lun */
+        wwn_t   pwwn;           /*  port wwn of target */
+        struct scsi_lun   lun;  /*  64-bit lun */
 };
 #pragma pack()
 
diff --git a/drivers/scsi/bfa/bfa_defs_svc.h b/drivers/scsi/bfa/bfa_defs_svc.h
index e24e9f7ca81f..648c84176722 100644
--- a/drivers/scsi/bfa/bfa_defs_svc.h
+++ b/drivers/scsi/bfa/bfa_defs_svc.h
@@ -34,8 +34,8 @@
 struct bfa_iocfc_intr_attr_s {
         u8              coalesce;       /*  enable/disable coalescing */
         u8              rsvd[3];
-        u16     latency;        /*  latency in microseconds   */
-        u16     delay;          /*  delay in microseconds     */
+        __be16  latency;        /*  latency in microseconds   */
+        __be16  delay;          /*  delay in microseconds     */
 };
 
 /*
@@ -743,7 +743,7 @@ struct bfa_port_cfg_s {
         u8       qos_enabled;   /*  qos enabled or not          */
         u8       cfg_hardalpa;  /*  is hard alpa configured     */
         u8       hardalpa;      /*  configured hard alpa        */
-        u16 maxfrsize;  /*  maximum frame size          */
+        __be16   maxfrsize;     /*  maximum frame size          */
         u8       rx_bbcredit;   /*  receive buffer credits      */
         u8       tx_bbcredit;   /*  transmit buffer credits     */
         u8       ratelimit;     /*  ratelimit enabled or not    */
@@ -843,7 +843,7 @@ struct bfa_fcport_fcf_s {
         u8       fka_disabled;   /*  FKA is disabled      */
         u8       maxsz_verified; /*  FCoE max size verified   */
         u8       fc_map[3];      /*  FC map                */
-        u16     vlan;      /*  FCoE vlan tag/priority   */
+        __be16   vlan;     /*  FCoE vlan tag/priority   */
         u32     fka_adv_per;    /*  FIP  ka advert. period   */
         mac_t      mac;     /*  FCF mac           */
 };
diff --git a/drivers/scsi/bfa/bfa_drv.c b/drivers/scsi/bfa/bfa_drv.c
deleted file mode 100644
index 0222d7c88a9a..000000000000
--- a/drivers/scsi/bfa/bfa_drv.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
- * All rights reserved
- * www.brocade.com
- *
- * Linux driver for Brocade Fibre Channel Host Bus Adapter.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License (GPL) Version 2 as
- * published by the Free Software Foundation
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-
-#include "bfa_modules.h"
-
-/*
- * BFA module list terminated by NULL
- */
-struct bfa_module_s *hal_mods[] = {
-        &hal_mod_sgpg,
-        &hal_mod_fcport,
-        &hal_mod_fcxp,
-        &hal_mod_lps,
-        &hal_mod_uf,
-        &hal_mod_rport,
-        &hal_mod_fcpim,
-        NULL
-};
-
-/*
- * Message handlers for various modules.
- */
-bfa_isr_func_t  bfa_isrs[BFI_MC_MAX] = {
-        bfa_isr_unhandled,      /* NONE */
-        bfa_isr_unhandled,      /* BFI_MC_IOC */
-        bfa_isr_unhandled,      /* BFI_MC_DIAG */
-        bfa_isr_unhandled,      /* BFI_MC_FLASH */
-        bfa_isr_unhandled,      /* BFI_MC_CEE */
-        bfa_fcport_isr,         /* BFI_MC_FCPORT */
-        bfa_isr_unhandled,      /* BFI_MC_IOCFC */
-        bfa_isr_unhandled,      /* BFI_MC_LL */
-        bfa_uf_isr,             /* BFI_MC_UF */
-        bfa_fcxp_isr,           /* BFI_MC_FCXP */
-        bfa_lps_isr,            /* BFI_MC_LPS */
-        bfa_rport_isr,          /* BFI_MC_RPORT */
-        bfa_itnim_isr,          /* BFI_MC_ITNIM */
-        bfa_isr_unhandled,      /* BFI_MC_IOIM_READ */
-        bfa_isr_unhandled,      /* BFI_MC_IOIM_WRITE */
-        bfa_isr_unhandled,      /* BFI_MC_IOIM_IO */
-        bfa_ioim_isr,           /* BFI_MC_IOIM */
-        bfa_ioim_good_comp_isr, /* BFI_MC_IOIM_IOCOM */
-        bfa_tskim_isr,          /* BFI_MC_TSKIM */
-        bfa_isr_unhandled,      /* BFI_MC_SBOOT */
-        bfa_isr_unhandled,      /* BFI_MC_IPFC */
-        bfa_isr_unhandled,      /* BFI_MC_PORT */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-        bfa_isr_unhandled,      /* --------- */
-};
-
-
-/*
- * Message handlers for mailbox command classes
- */
-bfa_ioc_mbox_mcfunc_t  bfa_mbox_isrs[BFI_MC_MAX] = {
-        NULL,
-        NULL,                   /* BFI_MC_IOC   */
-        NULL,                   /* BFI_MC_DIAG  */
-        NULL,           /* BFI_MC_FLASH */
-        NULL,                   /* BFI_MC_CEE   */
-        NULL,                   /* BFI_MC_PORT  */
-        bfa_iocfc_isr,          /* BFI_MC_IOCFC */
-        NULL,
-};
-
-
-
-void
-bfa_com_port_attach(struct bfa_s *bfa, struct bfa_meminfo_s *mi)
-{
-        struct bfa_port_s       *port = &bfa->modules.port;
-        u32             dm_len;
-        u8                      *dm_kva;
-        u64             dm_pa;
-
-        dm_len = bfa_port_meminfo();
-        dm_kva = bfa_meminfo_dma_virt(mi);
-        dm_pa  = bfa_meminfo_dma_phys(mi);
-
-        memset(port, 0, sizeof(struct bfa_port_s));
-        bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod);
-        bfa_port_mem_claim(port, dm_kva, dm_pa);
-
-        bfa_meminfo_dma_virt(mi) = dm_kva + dm_len;
-        bfa_meminfo_dma_phys(mi) = dm_pa + dm_len;
-}
diff --git a/drivers/scsi/bfa/bfa_fc.h b/drivers/scsi/bfa/bfa_fc.h
index e929d25b09e3..8e764fae8dc9 100644
--- a/drivers/scsi/bfa/bfa_fc.h
+++ b/drivers/scsi/bfa/bfa_fc.h
@@ -18,14 +18,12 @@
 #ifndef __BFA_FC_H__
 #define __BFA_FC_H__
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 
 typedef u64 wwn_t;
-typedef u64 lun_t;
 
 #define WWN_NULL        (0)
 #define FC_SYMNAME_MAX  256     /*  max name server symbolic name size */
-#define FC_ALPA_MAX     128
 
 #pragma pack(1)
 
@@ -40,7 +38,6 @@ struct mac_s { u8 mac[MAC_ADDRLEN]; };
 struct scsi_cdb_s {
         u8         scsi_cdb[SCSI_MAX_CDBLEN];
 };
-#define scsi_cdb_t struct scsi_cdb_s
 
 /* ------------------------------------------------------------
  * SCSI status byte values
@@ -63,7 +60,7 @@ struct scsi_cdb_s {
  * Fibre Channel Header Structure (FCHS) definition
  */
 struct fchs_s {
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u32        routing:4;   /* routing bits */
         u32        cat_info:4;  /* category info */
 #else
@@ -75,34 +72,19 @@ struct fchs_s {
         u32        cs_ctl:8;    /* class specific control */
         u32        s_id:24;     /* source identifier */
 
-        u32        type:8;              /* data structure type */
+        u32        type:8;      /* data structure type */
         u32        f_ctl:24;    /* initial frame control */
 
-        u8         seq_id;              /* sequence identifier */
-        u8         df_ctl;              /* data field control */
+        u8         seq_id;      /* sequence identifier */
+        u8         df_ctl;      /* data field control */
         u16        seq_cnt;     /* sequence count */
 
-        u16        ox_id;               /* originator exchange ID */
-        u16        rx_id;               /* responder exchange ID */
+        __be16     ox_id;       /* originator exchange ID */
+        u16        rx_id;       /* responder exchange ID */
 
         u32        ro;          /* relative offset */
 };
 
-#define FC_SOF_LEN              4
-#define FC_EOF_LEN              4
-#define FC_CRC_LEN              4
-
-/*
- * Fibre Channel BB_E Header Structure
- */
-struct fcbbehs_s {
-        u16     ver_rsvd;
-        u32     rsvd[2];
-        u32     rsvd__sof;
-};
-
-#define FC_SEQ_ID_MAX           256
-
 /*
  * routing bit definitions
  */
@@ -149,22 +131,6 @@ enum {
 };
 
 /*
- * information category for Link Control
- */
-enum {
-        FC_CAT_ACK_1            = 0x00,
-        FC_CAT_ACK_0_N          = 0x01,
-        FC_CAT_P_RJT            = 0x02,
-        FC_CAT_F_RJT            = 0x03,
-        FC_CAT_P_BSY            = 0x04,
-        FC_CAT_F_BSY_DATA       = 0x05,
-        FC_CAT_F_BSY_LINK_CTL   = 0x06,
-        FC_CAT_F_LCR            = 0x07,
-        FC_CAT_NTY              = 0x08,
-        FC_CAT_END              = 0x09,
-};
-
-/*
  * Type Field Definitions. FC-PH Section 18.5 pg. 165
  */
 enum {
@@ -182,10 +148,6 @@ enum {
         FC_TYPE_MAX             = 256,  /* 256 FC-4 types */
 };
 
-struct fc_fc4types_s {
-        u8         bits[FC_TYPE_MAX / 8];
-};
-
 /*
  * Frame Control Definitions. FC-PH Table-45. pg. 168
  */
@@ -288,7 +250,6 @@ enum {
         FC_ELS_AUTH = 0x90,     /* Authentication. Ref FC-SP */
         FC_ELS_RFCN = 0x97,     /* Request Fabric Change Notification. Ref
                                  *FC-SP */
-
 };
 
 /*
@@ -314,12 +275,12 @@ enum {
  * FC-PH-x. Figure-76. pg. 308.
  */
 struct fc_plogi_csp_s {
-        u8         verhi;       /* FC-PH high version */
-        u8         verlo;       /* FC-PH low version */
-        u16        bbcred;      /* BB_Credit */
+        u8              verhi;          /* FC-PH high version */
+        u8              verlo;          /* FC-PH low version */
+        __be16          bbcred;         /* BB_Credit */
 
-#ifdef __BIGENDIAN
-        u8         ciro:1,              /* continuously increasing RO */
+#ifdef __BIG_ENDIAN
+        u8              ciro:1,         /* continuously increasing RO */
                         rro:1,          /* random relative offset */
                         npiv_supp:1,    /* NPIV supported */
                         port_type:1,    /* N_Port/F_port */
@@ -328,7 +289,7 @@ struct fc_plogi_csp_s {
                         vvl_info:1,     /* VVL Info included */
                         reserved1:1;
 
-        u8         hg_supp:1,
+        u8              hg_supp:1,
                         query_dbc:1,
                         security:1,
                         sync_cap:1,
@@ -337,7 +298,7 @@ struct fc_plogi_csp_s {
                         cisc:1,         /* continuously increasing seq count */
                         payload:1;
 #else
-        u8         reserved2:2,
+        u8              reserved2:2,
                         resolution:1,   /* ms/ns ED_TOV resolution */
                         altbbcred:1,    /* alternate BB_Credit */
                         port_type:1,    /* N_Port/F_port */
@@ -345,7 +306,7 @@ struct fc_plogi_csp_s {
                         rro:1,          /* random relative offset */
                         ciro:1;         /* continuously increasing RO */
 
-        u8         payload:1,
+        u8              payload:1,
                         cisc:1,         /* continuously increasing seq count */
                         dh_dup_supp:1,
                         r_t_tov:1,
@@ -354,13 +315,10 @@ struct fc_plogi_csp_s {
                         query_dbc:1,
                         hg_supp:1;
 #endif
-
-        u16        rxsz;                /* recieve data_field size */
-
-        u16        conseq;
-        u16        ro_bitmap;
-
-        u32        e_d_tov;
+        __be16          rxsz;           /* recieve data_field size */
+        __be16          conseq;
+        __be16          ro_bitmap;
+        __be32          e_d_tov;
 };
 
 /*
@@ -368,12 +326,11 @@ struct fc_plogi_csp_s {
  * FC-PH-x. Figure 78. pg. 318.
  */
 struct fc_plogi_clp_s {
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u32        class_valid:1;
         u32        intermix:1;  /* class intermix supported if set =1.
-                                         * valid only for class1. Reserved for
-                                         * class2 & class3
-                                         */
+                                 * valid only for class1. Reserved for
+                                 * class2 & class3 */
         u32        reserved1:2;
         u32        sequential:1;
         u32        reserved2:3;
@@ -382,12 +339,10 @@ struct fc_plogi_clp_s {
         u32        sequential:1;
         u32        reserved1:2;
         u32        intermix:1;  /* class intermix supported if set =1.
-                                         * valid only for class1. Reserved for
-                                         * class2 & class3
-                                         */
+                                 * valid only for class1. Reserved for
+                                 * class2 & class3 */
         u32        class_valid:1;
 #endif
-
         u32        reserved3:24;
 
         u32        reserved4:16;
@@ -395,7 +350,7 @@ struct fc_plogi_clp_s {
 
         u32        reserved5:8;
         u32        conseq:8;
-        u32        e2e_credit:16;       /* end to end credit */
+        u32        e2e_credit:16; /* end to end credit */
 
         u32        reserved7:8;
         u32        ospx:8;
@@ -409,24 +364,24 @@ struct fc_plogi_clp_s {
  * PLOGI els command and reply payload
  */
 struct fc_logi_s {
-        struct fc_els_cmd_s els_cmd;    /* ELS command code */
-        struct fc_plogi_csp_s csp;              /* common service params */
-        wwn_t           port_name;
-        wwn_t           node_name;
-        struct fc_plogi_clp_s class1;           /* class 1 service parameters */
-        struct fc_plogi_clp_s class2;           /* class 2 service parameters */
-        struct fc_plogi_clp_s class3;           /* class 3 service parameters */
-        struct fc_plogi_clp_s class4;           /* class 4 service parameters */
-        u8         vvl[16];     /* vendor version level */
+        struct fc_els_cmd_s     els_cmd;        /* ELS command code */
+        struct fc_plogi_csp_s   csp;            /* common service params */
+        wwn_t                   port_name;
+        wwn_t                   node_name;
+        struct fc_plogi_clp_s   class1;         /* class 1 service parameters */
+        struct fc_plogi_clp_s   class2;         /* class 2 service parameters */
+        struct fc_plogi_clp_s   class3;         /* class 3 service parameters */
+        struct fc_plogi_clp_s   class4;         /* class 4 service parameters */
+        u8                      vvl[16];        /* vendor version level */
 };
 
 /*
  * LOGO els command payload
  */
 struct fc_logo_s {
-        struct fc_els_cmd_s els_cmd;    /* ELS command code */
-        u32        res1:8;
-        u32        nport_id:24; /* N_Port identifier of source */
+        struct fc_els_cmd_s     els_cmd;        /* ELS command code */
+        u32                     res1:8;
+        u32             nport_id:24;    /* N_Port identifier of source */
         wwn_t           orig_port_name; /* Port name of the LOGO originator */
 };
 
@@ -435,12 +390,12 @@ struct fc_logo_s {
  */
 struct fc_adisc_s {
         struct fc_els_cmd_s els_cmd;    /* ELS command code */
-        u32        res1:8;
-        u32        orig_HA:24;  /* originator hard address */
-        wwn_t           orig_port_name; /* originator port name */
-        wwn_t           orig_node_name; /* originator node name */
-        u32        res2:8;
-        u32        nport_id:24; /* originator NPortID */
+        u32             res1:8;
+        u32             orig_HA:24;     /* originator hard address */
+        wwn_t           orig_port_name; /* originator port name */
+        wwn_t           orig_node_name; /* originator node name */
+        u32             res2:8;
+        u32             nport_id:24;    /* originator NPortID */
 };
 
 /*
@@ -466,7 +421,7 @@ struct fc_exch_status_blk_s {
 struct fc_res_s {
         struct fc_els_cmd_s els_cmd;    /* ELS command code */
         u32        res1:8;
-        u32        nport_id:24; /* N_Port identifier of source */
+        u32        nport_id:24;         /* N_Port identifier of source */
         u32        oxid:16;
         u32        rxid:16;
         u8         assoc_hdr[32];
@@ -512,8 +467,8 @@ struct fc_rec_acc_s {
         u32        orig_id:24;  /* N_Port id of exchange originator */
         u32        res2:8;
         u32        resp_id:24;  /* N_Port id of exchange responder */
-        u32        count;               /* data transfer count */
-        u32        e_stat;              /* exchange status */
+        u32        count;       /* data transfer count */
+        u32        e_stat;      /* exchange status */
 };
 
 /*
@@ -533,7 +488,7 @@ struct fc_rsi_s {
  */
 struct fc_prli_params_s {
         u32        reserved:16;
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u32        reserved1:5;
         u32        rec_support:1;
         u32        task_retry_id:1;
@@ -575,7 +530,7 @@ enum {
 struct fc_prli_params_page_s {
         u32        type:8;
         u32        codext:8;
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u32        origprocasv:1;
         u32        rsppav:1;
         u32        imagepair:1;
@@ -611,18 +566,14 @@ struct fc_prli_s {
 struct fc_prlo_params_page_s {
         u32        type:8;
         u32        type_ext:8;
-#ifdef __BIGENDIAN
-        u32        opa_valid:1; /* originator process associator
-                                         * valid
-                                         */
+#ifdef __BIG_ENDIAN
+        u32        opa_valid:1; /* originator process associator valid */
         u32        rpa_valid:1; /* responder process associator valid */
         u32        res1:14;
 #else
         u32        res1:14;
         u32        rpa_valid:1; /* responder process associator valid */
-        u32        opa_valid:1; /* originator process associator
-                                         * valid
-                                         */
+        u32        opa_valid:1; /* originator process associator valid */
 #endif
         u32        orig_process_assc;
         u32        resp_process_assc;
@@ -647,18 +598,14 @@ struct fc_prlo_acc_params_page_s {
         u32        type:8;
         u32        type_ext:8;
 
-#ifdef __BIGENDIAN
-        u32        opa_valid:1; /* originator process associator
-                                         * valid
-                                         */
+#ifdef __BIG_ENDIAN
+        u32        opa_valid:1; /* originator process associator valid */
         u32        rpa_valid:1; /* responder process associator valid */
         u32        res1:14;
 #else
         u32        res1:14;
         u32        rpa_valid:1; /* responder process associator valid */
-        u32        opa_valid:1; /* originator process associator
-                                         * valid
-                                         */
+        u32        opa_valid:1; /* originator process associator valid */
 #endif
         u32        orig_process_assc;
         u32        resp_process_assc;
@@ -715,9 +662,9 @@ enum {
  * LS_RJT els reply payload
  */
 struct fc_ls_rjt_s {
-        struct fc_els_cmd_s els_cmd;            /* ELS command code */
+        struct fc_els_cmd_s els_cmd;    /* ELS command code */
         u32        res1:8;
-        u32        reason_code:8;               /* Reason code for reject */
+        u32        reason_code:8;       /* Reason code for reject */
         u32        reason_code_expl:8;  /* Reason code explanation */
         u32        vendor_unique:8;     /* Vendor specific */
 };
@@ -779,12 +726,12 @@ struct fc_rrq_s {
  */
 struct fc_ba_acc_s {
         u32        seq_id_valid:8;      /* set to 0x00 for Abort Exchange */
-        u32        seq_id:8;    /* invalid for Abort Exchange */
+        u32        seq_id:8;            /* invalid for Abort Exchange */
         u32        res2:16;
-        u32        ox_id:16;    /* OX_ID from ABTS frame */
-        u32        rx_id:16;    /* RX_ID from ABTS frame */
+        u32        ox_id:16;            /* OX_ID from ABTS frame */
+        u32        rx_id:16;            /* RX_ID from ABTS frame */
         u32        low_seq_cnt:16;      /* set to 0x0000 for Abort Exchange */
-        u32        high_seq_cnt:16;/* set to 0xFFFF for Abort Exchange */
+        u32        high_seq_cnt:16;     /* set to 0xFFFF for Abort Exchange */
 };
 
 /*
@@ -794,17 +741,17 @@ struct fc_ba_rjt_s {
         u32        res1:8;              /* Reserved */
         u32        reason_code:8;       /* reason code for reject */
         u32        reason_expl:8;       /* reason code explanation */
-        u32        vendor_unique:8;/* vendor unique reason code,set to 0 */
+        u32        vendor_unique:8; /* vendor unique reason code,set to 0 */
 };
 
 /*
  * TPRLO logout parameter page
  */
 struct fc_tprlo_params_page_s {
-u32        type:8;
-u32        type_ext:8;
+        u32        type:8;
+        u32        type_ext:8;
 
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u32        opa_valid:1;
         u32        rpa_valid:1;
         u32        tpo_nport_valid:1;
@@ -864,16 +811,16 @@ enum fc_rscn_format {
 };
 
 struct fc_rscn_event_s {
-        u32        format:2;
-        u32        qualifier:4;
-        u32        resvd:2;
-        u32        portid:24;
+        u32     format:2;
+        u32     qualifier:4;
+        u32     resvd:2;
+        u32     portid:24;
 };
 
 struct fc_rscn_pl_s {
-        u8         command;
-        u8         pagelen;
-        u16        payldlen;
+        u8      command;
+        u8      pagelen;
+        __be16  payldlen;
         struct fc_rscn_event_s event[1];
 };
 
@@ -887,7 +834,6 @@ struct fc_echo_s {
 /*
  * RNID els command
  */
-
 #define RNID_NODEID_DATA_FORMAT_COMMON                  0x00
 #define RNID_NODEID_DATA_FORMAT_FCP3                    0x08
 #define RNID_NODEID_DATA_FORMAT_DISCOVERY               0xDF
@@ -920,15 +866,15 @@ struct fc_rnid_cmd_s {
  */
 
 struct fc_rnid_common_id_data_s {
-        wwn_t           port_name;
+        wwn_t           port_name;
         wwn_t           node_name;
 };
 
 struct fc_rnid_general_topology_data_s {
         u32        vendor_unique[4];
-        u32        asso_type;
+        __be32     asso_type;
         u32        phy_port_num;
-        u32        num_attached_nodes;
+        __be32     num_attached_nodes;
         u32        node_mgmt:8;
         u32        ip_version:8;
         u32        udp_tcp_port_num:16;
@@ -980,59 +926,17 @@ enum fc_rpsc_op_speed {
         RPSC_OP_SPEED_8G = 0x0800,
         RPSC_OP_SPEED_16G = 0x0400,
 
-        RPSC_OP_SPEED_NOT_EST = 0x0001, /*! speed not established */
+        RPSC_OP_SPEED_NOT_EST = 0x0001, /* speed not established */
 };
 
 struct fc_rpsc_speed_info_s {
-        u16        port_speed_cap;      /*! see enum fc_rpsc_speed_cap */
-        u16        port_op_speed;       /*! see enum fc_rpsc_op_speed */
-};
-
-enum link_e2e_beacon_subcmd {
-        LINK_E2E_BEACON_ON = 1,
-        LINK_E2E_BEACON_OFF = 2
-};
-
-enum beacon_type {
-        BEACON_TYPE_NORMAL      = 1,    /*! Normal Beaconing. Green */
-        BEACON_TYPE_WARN        = 2,    /*! Warning Beaconing. Yellow/Amber */
-        BEACON_TYPE_CRITICAL    = 3     /*! Critical Beaconing. Red */
-};
-
-struct link_e2e_beacon_param_s {
-        u8         beacon_type; /* Beacon Type. See enum beacon_type */
-        u8         beacon_frequency;
-                                        /* Beacon frequency. Number of blinks
-                                         * per 10 seconds
-                                         */
-        u16        beacon_duration;/* Beacon duration (in Seconds). The
-                                         * command operation should be
-                                         * terminated at the end of this
-                                         * timeout value.
-                                         *
-                                         * Ignored if diag_sub_cmd is
-                                         * LINK_E2E_BEACON_OFF.
-                                         *
-                                         * If 0, beaconing will continue till a
-                                         * BEACON OFF request is received
-                                         */
-};
-
-/*
- * Link E2E beacon request/good response format.
- * For LS_RJTs use struct fc_ls_rjt_s
- */
-struct link_e2e_beacon_req_s {
-        u32        ls_code;     /*! FC_ELS_E2E_LBEACON in requests *
-                                         *or FC_ELS_ACC in good replies */
-        u32        ls_sub_cmd;  /*! See enum link_e2e_beacon_subcmd */
-        struct link_e2e_beacon_param_s beacon_parm;
+        __be16        port_speed_cap;   /* see enum fc_rpsc_speed_cap */
+        __be16        port_op_speed;    /* see enum fc_rpsc_op_speed */
 };
 
 /*
  * If RPSC request is sent to the Domain Controller, the request is for
- * all the ports within that domain (TODO - I don't think FOS implements
- * this...).
+ * all the ports within that domain.
  */
 struct fc_rpsc_cmd_s {
         struct fc_els_cmd_s els_cmd;
@@ -1056,9 +960,9 @@ struct fc_rpsc_acc_s {
 
 struct fc_rpsc2_cmd_s {
         struct fc_els_cmd_s els_cmd;
-        u32     token;
+        __be32  token;
         u16     resvd;
-        u16     num_pids;       /* Number of pids in the request */
+        __be16  num_pids;               /* Number of pids in the request */
         struct  {
                 u32     rsvd1:8;
                 u32     pid:24;         /* port identifier */
@@ -1072,16 +976,17 @@ enum fc_rpsc2_port_type {
         RPSC2_PORT_TYPE_NPIV_PORT  = 0x5f,
         RPSC2_PORT_TYPE_NPORT_TRUNK  = 0x6f,
 };
+
 /*
  * RPSC2 portInfo entry structure
  */
 struct fc_rpsc2_port_info_s {
-    u32    pid;        /* PID */
-    u16    resvd1;
-    u16    index;      /* port number / index */
-    u8     resvd2;
-    u8     type;        /* port type N/NL/... */
-    u16    speed;      /* port Operating Speed */
+        __be32  pid;            /* PID */
+        u16     resvd1;
+        __be16  index;          /* port number / index */
+        u8      resvd2;
+        u8      type;           /* port type N/NL/... */
+        __be16  speed;          /* port Operating Speed */
 };
 
 /*
@@ -1090,8 +995,8 @@ struct fc_rpsc2_port_info_s {
 struct fc_rpsc2_acc_s {
         u8        els_cmd;
         u8        resvd;
-    u16       num_pids;  /* Number of pids in the request */
-    struct fc_rpsc2_port_info_s port_info[1];    /* port information */
+        __be16    num_pids; /* Number of pids in the request */
+        struct fc_rpsc2_port_info_s port_info[1]; /* port information */
 };
 
 /*
@@ -1110,18 +1015,14 @@ struct fc_symname_s {
         u8         symname[FC_SYMNAME_MAX];
 };
 
-struct fc_alpabm_s {
-        u8         alpa_bm[FC_ALPA_MAX / 8];
-};
-
 /*
  * protocol default timeout values
  */
-#define FC_ED_TOV               2
-#define FC_REC_TOV              (FC_ED_TOV + 1)
-#define FC_RA_TOV               10
-#define FC_ELS_TOV              (2 * FC_RA_TOV)
-#define FC_FCCT_TOV             (3 * FC_RA_TOV)
+#define FC_ED_TOV       2
+#define FC_REC_TOV      (FC_ED_TOV + 1)
+#define FC_RA_TOV       10
+#define FC_ELS_TOV      (2 * FC_RA_TOV)
+#define FC_FCCT_TOV     (3 * FC_RA_TOV)
 
 /*
  * virtual fabric related defines
@@ -1157,50 +1058,34 @@ enum {
 };
 
 /*
- * SRR FC-4 LS payload
- */
-struct fc_srr_s {
-        u32     ls_cmd;
-        u32        ox_id:16;    /* ox-id */
-        u32        rx_id:16;    /* rx-id */
-        u32        ro;          /* relative offset */
-        u32        r_ctl:8;             /* R_CTL for I.U. */
-        u32        res:24;
-};
-
-
-/*
  * FCP_CMND definitions
  */
 #define FCP_CMND_CDB_LEN    16
 #define FCP_CMND_LUN_LEN    8
 
 struct fcp_cmnd_s {
-        lun_t           lun;            /* 64-bit LU number */
-        u8         crn;         /* command reference number */
-#ifdef __BIGENDIAN
-        u8         resvd:1,
+        struct scsi_lun lun;            /* 64-bit LU number */
+        u8              crn;            /* command reference number */
+#ifdef __BIG_ENDIAN
+        u8              resvd:1,
                         priority:4,     /* FCP-3: SAM-3 priority */
                         taskattr:3;     /* scsi task attribute */
 #else
-        u8         taskattr:3,  /* scsi task attribute */
+        u8              taskattr:3,     /* scsi task attribute */
                         priority:4,     /* FCP-3: SAM-3 priority */
                         resvd:1;
 #endif
-        u8         tm_flags;    /* task management flags */
-#ifdef __BIGENDIAN
-        u8         addl_cdb_len:6,      /* additional CDB length words */
+        u8              tm_flags;       /* task management flags */
+#ifdef __BIG_ENDIAN
+        u8              addl_cdb_len:6, /* additional CDB length words */
                         iodir:2;        /* read/write FCP_DATA IUs */
 #else
-        u8         iodir:2,     /* read/write FCP_DATA IUs */
+        u8              iodir:2,        /* read/write FCP_DATA IUs */
                         addl_cdb_len:6; /* additional CDB length */
 #endif
-        scsi_cdb_t      cdb;
+        struct scsi_cdb_s      cdb;
 
-        /*
-         * !!! additional cdb bytes follows here!!!
-         */
-        u32        fcp_dl;      /* bytes to be transferred */
+        __be32        fcp_dl;   /* bytes to be transferred */
 };
 
 #define fcp_cmnd_cdb_len(_cmnd) ((_cmnd)->addl_cdb_len * 4 + FCP_CMND_CDB_LEN)
@@ -1210,21 +1095,10 @@ struct fcp_cmnd_s {
  * struct fcp_cmnd_s .iodir field values
  */
 enum fcp_iodir {
-        FCP_IODIR_NONE  = 0,
+        FCP_IODIR_NONE  = 0,
         FCP_IODIR_WRITE = 1,
-        FCP_IODIR_READ  = 2,
-        FCP_IODIR_RW    = 3,
-};
-
-/*
- * Task attribute field
- */
-enum {
-        FCP_TASK_ATTR_SIMPLE    = 0,
-        FCP_TASK_ATTR_HOQ       = 1,
-        FCP_TASK_ATTR_ORDERED   = 2,
-        FCP_TASK_ATTR_ACA       = 4,
-        FCP_TASK_ATTR_UNTAGGED  = 5,    /* obsolete in FCP-3 */
+        FCP_IODIR_READ  = 2,
+        FCP_IODIR_RW    = 3,
 };
 
 /*
@@ -1239,58 +1113,40 @@ enum fcp_tm_cmnd {
 };
 
 /*
- * FCP_XFER_RDY IU defines
- */
-struct fcp_xfer_rdy_s {
-        u32        data_ro;
-        u32        burst_len;
-        u32        reserved;
-};
-
-/*
  * FCP_RSP residue flags
  */
 enum fcp_residue {
-        FCP_NO_RESIDUE = 0,     /* no residue */
-        FCP_RESID_OVER = 1,     /* more data left that was not sent */
-        FCP_RESID_UNDER = 2,    /* less data than requested */
-};
-
-enum {
-        FCP_RSPINFO_GOOD = 0,
-        FCP_RSPINFO_DATALEN_MISMATCH = 1,
-        FCP_RSPINFO_CMND_INVALID = 2,
-        FCP_RSPINFO_ROLEN_MISMATCH = 3,
-        FCP_RSPINFO_TM_NOT_SUPP = 4,
-        FCP_RSPINFO_TM_FAILED = 5,
+        FCP_NO_RESIDUE = 0,     /* no residue */
+        FCP_RESID_OVER = 1,     /* more data left that was not sent */
+        FCP_RESID_UNDER = 2,    /* less data than requested */
 };
 
 struct fcp_rspinfo_s {
         u32        res0:24;
-        u32        rsp_code:8;  /* response code (as above) */
+        u32        rsp_code:8;          /* response code (as above) */
         u32        res1;
 };
 
 struct fcp_resp_s {
-        u32        reserved[2]; /* 2 words reserved */
+        u32        reserved[2];         /* 2 words reserved */
         u16        reserved2;
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u8         reserved3:3;
         u8         fcp_conf_req:1;      /* FCP_CONF is requested */
         u8         resid_flags:2;       /* underflow/overflow */
-        u8         sns_len_valid:1;/* sense len is valid */
-        u8         rsp_len_valid:1;/* response len is valid */
+        u8         sns_len_valid:1;     /* sense len is valid */
+        u8         rsp_len_valid:1;     /* response len is valid */
 #else
-        u8         rsp_len_valid:1;/* response len is valid */
-        u8         sns_len_valid:1;/* sense len is valid */
+        u8         rsp_len_valid:1;     /* response len is valid */
+        u8         sns_len_valid:1;     /* sense len is valid */
         u8         resid_flags:2;       /* underflow/overflow */
         u8         fcp_conf_req:1;      /* FCP_CONF is requested */
         u8         reserved3:3;
 #endif
-        u8         scsi_status; /* one byte SCSI status */
-        u32        residue;     /* residual data bytes */
-        u32        sns_len;     /* length od sense info */
-        u32        rsp_len;     /* length of response info */
+        u8         scsi_status;         /* one byte SCSI status */
+        u32        residue;             /* residual data bytes */
+        u32        sns_len;             /* length od sense info */
+        u32        rsp_len;             /* length of response info */
 };
 
 #define fcp_snslen(__fcprsp)    ((__fcprsp)->sns_len_valid ?            \
@@ -1300,12 +1156,6 @@ struct fcp_resp_s {
 #define fcp_rspinfo(__fcprsp)   ((struct fcp_rspinfo_s *)((__fcprsp) + 1))
 #define fcp_snsinfo(__fcprsp)   (((u8 *)fcp_rspinfo(__fcprsp)) +        \
                                                 fcp_rsplen(__fcprsp))
-
-struct fcp_cmnd_fr_s {
-        struct fchs_s fchs;
-        struct fcp_cmnd_s fcp;
-};
-
 /*
  * CT
  */
@@ -1379,7 +1229,7 @@ enum {
         CT_RSN_LOGICAL_BUSY     = 0x05,
         CT_RSN_PROTO_ERR        = 0x07,
         CT_RSN_UNABLE_TO_PERF   = 0x09,
-        CT_RSN_NOT_SUPP                 = 0x0B,
+        CT_RSN_NOT_SUPP         = 0x0B,
         CT_RSN_SERVER_NOT_AVBL  = 0x0D,
         CT_RSN_SESSION_COULD_NOT_BE_ESTBD = 0x0E,
         CT_RSN_VENDOR_SPECIFIC  = 0xFF,
@@ -1419,10 +1269,10 @@ enum {
  * defintions for the explanation code for all servers
  */
 enum {
-        CT_EXP_AUTH_EXCEPTION                   = 0xF1,
-        CT_EXP_DB_FULL                                  = 0xF2,
-        CT_EXP_DB_EMPTY                                 = 0xF3,
-        CT_EXP_PROCESSING_REQ                   = 0xF4,
+        CT_EXP_AUTH_EXCEPTION           = 0xF1,
+        CT_EXP_DB_FULL                  = 0xF2,
+        CT_EXP_DB_EMPTY                 = 0xF3,
+        CT_EXP_PROCESSING_REQ           = 0xF4,
         CT_EXP_UNABLE_TO_VERIFY_CONN    = 0xF5,
         CT_EXP_DEVICES_NOT_IN_CMN_ZONE  = 0xF6
 };
@@ -1446,7 +1296,7 @@ enum {
         GS_RFF_ID       = 0x021F,       /* Register FC4 Feature         */
 };
 
-struct fcgs_id_req_s{
+struct fcgs_id_req_s {
         u32 rsvd:8;
         u32 dap:24; /* port identifier */
 };
@@ -1460,7 +1310,7 @@ struct fcgs_gidpn_req_s {
 
 struct fcgs_gidpn_resp_s {
         u32     rsvd:8;
-        u32     dap:24; /* port identifier */
+        u32     dap:24;         /* port identifier */
 };
 
 /*
@@ -1469,22 +1319,21 @@ struct fcgs_gidpn_resp_s {
 struct fcgs_rftid_req_s {
         u32     rsvd:8;
         u32     dap:24;         /* port identifier */
-        u32     fc4_type[8];    /* fc4 types */
+        __be32  fc4_type[8];    /* fc4 types */
 };
 
 /*
  * RFF_ID : Register FC4 features.
  */
-
 #define FC_GS_FCP_FC4_FEATURE_INITIATOR  0x02
 #define FC_GS_FCP_FC4_FEATURE_TARGET     0x01
 
 struct fcgs_rffid_req_s {
-    u32    rsvd:8;
-    u32    dap:24;              /* port identifier      */
-    u32    rsvd1:16;
-    u32    fc4ftr_bits:8;               /* fc4 feature bits     */
-    u32    fc4_type:8;          /* corresponding FC4 Type */
+        u32     rsvd:8;
+        u32     dap:24;         /* port identifier */
+        u32     rsvd1:16;
+        u32     fc4ftr_bits:8;  /* fc4 feature bits */
+        u32     fc4_type:8;             /* corresponding FC4 Type */
 };
 
 /*
@@ -1495,16 +1344,16 @@ struct fcgs_gidft_req_s {
         u8      domain_id;      /* domain, 0 - all fabric */
         u8      area_id;        /* area, 0 - whole domain */
         u8      fc4_type;       /* FC_TYPE_FCP for SCSI devices */
-};              /* GID_FT Request */
+};
 
 /*
  * GID_FT Response
  */
 struct fcgs_gidft_resp_s {
-        u8              last:1; /* last port identifier flag */
-        u8              reserved:7;
-        u32     pid:24; /* port identifier */
-};              /* GID_FT Response */
+        u8      last:1;         /* last port identifier flag */
+        u8      reserved:7;
+        u32     pid:24;         /* port identifier */
+};
 
 /*
  * RSPN_ID
@@ -1512,8 +1361,8 @@ struct fcgs_gidft_resp_s {
 struct fcgs_rspnid_req_s {
         u32     rsvd:8;
         u32     dap:24;         /* port identifier */
-        u8              spn_len;        /* symbolic port name length */
-        u8              spn[256];       /* symbolic port name */
+        u8      spn_len;        /* symbolic port name length */
+        u8      spn[256];       /* symbolic port name */
 };
 
 /*
@@ -1522,7 +1371,7 @@ struct fcgs_rspnid_req_s {
 struct fcgs_rpnid_req_s {
         u32     rsvd:8;
         u32     port_id:24;
-        wwn_t           port_name;
+        wwn_t   port_name;
 };
 
 /*
@@ -1531,7 +1380,7 @@ struct fcgs_rpnid_req_s {
 struct fcgs_rnnid_req_s {
         u32     rsvd:8;
         u32     port_id:24;
-        wwn_t           node_name;
+        wwn_t   node_name;
 };
 
 /*
@@ -1565,8 +1414,8 @@ struct fcgs_ganxt_req_s {
  * GA_NXT Response
  */
 struct fcgs_ganxt_rsp_s {
-        u32     port_type:8;    /* Port Type */
-        u32     port_id:24;     /* Port Identifier */
+        u32             port_type:8;    /* Port Type */
+        u32             port_id:24;     /* Port Identifier */
         wwn_t           port_name;      /* Port Name */
         u8              spn_len;        /* Length of Symbolic Port Name */
         char            spn[255];       /* Symbolic Port Name */
@@ -1575,19 +1424,14 @@ struct fcgs_ganxt_rsp_s {
         char            snn[255];       /* Symbolic Node Name */
         u8              ipa[8];         /* Initial Process Associator */
         u8              ip[16];         /* IP Address */
-        u32     cos;            /* Class of Service */
-        u32     fc4types[8];    /* FC-4 TYPEs */
-        wwn_t           fabric_port_name;
-                                        /* Fabric Port Name */
-        u32     rsvd:8;         /* Reserved */
-        u32     hard_addr:24;   /* Hard Address */
+        u32             cos;            /* Class of Service */
+        u32             fc4types[8];    /* FC-4 TYPEs */
+        wwn_t           fabric_port_name; /* Fabric Port Name */
+        u32             rsvd:8;         /* Reserved */
+        u32             hard_addr:24;   /* Hard Address */
 };
 
 /*
- * Fabric Config Server
- */
-
-/*
  * Command codes for Fabric Configuration Server
  */
 enum {
@@ -1598,159 +1442,9 @@ enum {
 };
 
 /*
- * Source or Destination Port Tags.
- */
-enum {
-        GS_FTRACE_TAG_NPORT_ID          = 1,
-        GS_FTRACE_TAG_NPORT_NAME        = 2,
-};
-
-/*
-* Port Value : Could be a Port id or wwn
- */
-union fcgs_port_val_u {
-        u32     nport_id;
-        wwn_t           nport_wwn;
-};
-
-#define GS_FTRACE_MAX_HOP_COUNT 20
-#define GS_FTRACE_REVISION      1
-
-/*
- * Ftrace Related Structures.
- */
-
-/*
- * STR (Switch Trace) Reject Reason Codes. From FC-SW.
- */
-enum {
-        GS_FTRACE_STR_CMD_COMPLETED_SUCC        = 0,
-        GS_FTRACE_STR_CMD_NOT_SUPP_IN_NEXT_SWITCH,
-        GS_FTRACE_STR_NO_RESP_FROM_NEXT_SWITCH,
-        GS_FTRACE_STR_MAX_HOP_CNT_REACHED,
-        GS_FTRACE_STR_SRC_PORT_NOT_FOUND,
-        GS_FTRACE_STR_DST_PORT_NOT_FOUND,
-        GS_FTRACE_STR_DEVICES_NOT_IN_COMMON_ZONE,
-        GS_FTRACE_STR_NO_ROUTE_BW_PORTS,
-        GS_FTRACE_STR_NO_ADDL_EXPLN,
-        GS_FTRACE_STR_FABRIC_BUSY,
-        GS_FTRACE_STR_FABRIC_BUILD_IN_PROGRESS,
-        GS_FTRACE_STR_VENDOR_SPECIFIC_ERR_START = 0xf0,
-        GS_FTRACE_STR_VENDOR_SPECIFIC_ERR_END = 0xff,
-};
-
-/*
- * Ftrace Request
- */
-struct fcgs_ftrace_req_s {
-        u32     revision;
-        u16     src_port_tag;   /* Source Port tag */
-        u16     src_port_len;   /* Source Port len */
-        union fcgs_port_val_u src_port_val;     /* Source Port value */
-        u16     dst_port_tag;   /* Destination Port tag */
-        u16     dst_port_len;   /* Destination Port len */
-        union fcgs_port_val_u dst_port_val;     /* Destination Port value */
-        u32     token;
-        u8              vendor_id[8];   /* T10 Vendor Identifier */
-        u8              vendor_info[8]; /* Vendor specific Info */
-        u32     max_hop_cnt;    /* Max Hop Count */
-};
-
-/*
- * Path info structure
- */
-struct fcgs_ftrace_path_info_s {
-        wwn_t           switch_name;            /* Switch WWN */
-        u32     domain_id;
-        wwn_t           ingress_port_name;      /* Ingress ports wwn */
-        u32     ingress_phys_port_num;  /* Ingress ports physical port
-                                                 * number
-                                                 */
-        wwn_t           egress_port_name;       /* Ingress ports wwn */
-        u32     egress_phys_port_num;   /* Ingress ports physical port
-                                                 * number
-                                                 */
-};
-
-/*
- * Ftrace Acc Response
- */
-struct fcgs_ftrace_resp_s {
-        u32     revision;
-        u32     token;
-        u8              vendor_id[8];           /* T10 Vendor Identifier */
-        u8              vendor_info[8];         /* Vendor specific Info */
-        u32     str_rej_reason_code;    /* STR Reject Reason Code */
-        u32     num_path_info_entries;  /* No. of path info entries */
-        /*
-         * path info entry/entries.
-         */
-        struct fcgs_ftrace_path_info_s path_info[1];
-
-};
-
-/*
-* Fabric Config Server : FCPing
- */
-
-/*
- * FC Ping Request
- */
-struct fcgs_fcping_req_s {
-        u32     revision;
-        u16     port_tag;
-        u16     port_len;       /* Port len */
-        union fcgs_port_val_u port_val; /* Port value */
-        u32     token;
-};
-
-/*
- * FC Ping Response
- */
-struct fcgs_fcping_resp_s {
-        u32     token;
-};
-
-/*
- * Command codes for zone server query.
- */
-enum {
-        ZS_GZME = 0x0124,       /* Get zone member extended */
-};
-
-/*
- * ZS GZME request
- */
-#define ZS_GZME_ZNAMELEN        32
-struct zs_gzme_req_s {
-        u8      znamelen;
-        u8      rsvd[3];
-        u8      zname[ZS_GZME_ZNAMELEN];
-};
-
-enum zs_mbr_type {
-        ZS_MBR_TYPE_PWWN        = 1,
-        ZS_MBR_TYPE_DOMPORT     = 2,
-        ZS_MBR_TYPE_PORTID      = 3,
-        ZS_MBR_TYPE_NWWN        = 4,
-};
-
-struct zs_mbr_wwn_s {
-        u8      mbr_type;
-        u8      rsvd[3];
-        wwn_t   wwn;
-};
-
-struct zs_query_resp_s {
-        u32     nmbrs;  /*  number of zone members */
-        struct zs_mbr_wwn_s     mbr[1];
-};
-
-/*
  * GMAL Command ( Get ( interconnect Element) Management Address List)
  * To retrieve the IP Address of a Switch.
  */
-
 #define CT_GMAL_RESP_PREFIX_TELNET       "telnet://"
 #define CT_GMAL_RESP_PREFIX_HTTP         "http://"
 
@@ -1764,7 +1458,7 @@ struct fcgs_req_s {
 
 /* Accept Response to GMAL */
 struct fcgs_gmal_resp_s {
-        u32     ms_len;   /* Num of entries */
+        __be32  ms_len;   /* Num of entries */
         u8      ms_ma[256];
 };
 
@@ -1775,9 +1469,6 @@ struct fcgs_gmal_entry_s {
 };
 
 /*
- * FDMI
- */
-/*
  * FDMI Command Codes
  */
 #define FDMI_GRHL               0x0100
@@ -1856,8 +1547,8 @@ enum fdmi_port_attribute_type {
  * FDMI attribute
  */
 struct fdmi_attr_s {
-        u16        type;
-        u16        len;
+        __be16        type;
+        __be16        len;
         u8         value[1];
 };
 
@@ -1865,7 +1556,7 @@ struct fdmi_attr_s {
  * HBA Attribute Block
  */
 struct fdmi_hba_attr_s {
-        u32        attr_count;  /* # of attributes */
+        __be32        attr_count;       /* # of attributes */
         struct fdmi_attr_s hba_attr;    /* n attributes */
 };
 
@@ -1873,15 +1564,15 @@ struct fdmi_hba_attr_s {
  * Registered Port List
  */
 struct fdmi_port_list_s {
-        u32        num_ports;   /* number Of Port Entries */
-        wwn_t           port_entry;     /* one or more */
+        __be32          num_ports;      /* number Of Port Entries */
+        wwn_t           port_entry;     /* one or more */
 };
 
 /*
  * Port Attribute Block
  */
 struct fdmi_port_attr_s {
-        u32        attr_count;  /* # of attributes */
+        __be32        attr_count;       /* # of attributes */
         struct fdmi_attr_s port_attr;   /* n attributes */
 };
 
@@ -1889,7 +1580,7 @@ struct fdmi_port_attr_s {
  * FDMI Register HBA Attributes
  */
 struct fdmi_rhba_s {
-        wwn_t           hba_id;         /* HBA Identifier */
+        wwn_t                   hba_id;         /* HBA Identifier */
         struct fdmi_port_list_s port_list;      /* Registered Port List */
         struct fdmi_hba_attr_s hba_attr_blk;    /* HBA attribute block */
 };
@@ -1898,8 +1589,8 @@ struct fdmi_rhba_s {
  * FDMI Register Port
  */
 struct fdmi_rprt_s {
-        wwn_t           hba_id;         /* HBA Identifier */
-        wwn_t           port_name;      /* Port wwn */
+        wwn_t                   hba_id;         /* HBA Identifier */
+        wwn_t                   port_name;      /* Port wwn */
         struct fdmi_port_attr_s port_attr_blk;  /* Port Attr Block */
 };
 
@@ -1907,7 +1598,7 @@ struct fdmi_rprt_s {
  * FDMI Register Port Attributes
  */
 struct fdmi_rpa_s {
-        wwn_t           port_name;      /* port wwn */
+        wwn_t                   port_name;      /* port wwn */
         struct fdmi_port_attr_s port_attr_blk;  /* Port Attr Block */
 };
 
diff --git a/drivers/scsi/bfa/bfa_fcbuild.c b/drivers/scsi/bfa/bfa_fcbuild.c
index 9c725314b513..b7e253451654 100644
--- a/drivers/scsi/bfa/bfa_fcbuild.c
+++ b/drivers/scsi/bfa/bfa_fcbuild.c
@@ -18,16 +18,16 @@
  * fcbuild.c - FC link service frame building and parsing routines
  */
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 #include "bfa_fcbuild.h"
 
 /*
  * static build functions
  */
 static void     fc_els_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
-                                 u16 ox_id);
+                                 __be16 ox_id);
 static void     fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
-                                 u16 ox_id);
+                                 __be16 ox_id);
 static struct fchs_s fc_els_req_tmpl;
 static struct fchs_s fc_els_rsp_tmpl;
 static struct fchs_s fc_bls_req_tmpl;
@@ -48,7 +48,7 @@ fcbuild_init(void)
         fc_els_req_tmpl.cat_info = FC_CAT_LD_REQUEST;
         fc_els_req_tmpl.type = FC_TYPE_ELS;
         fc_els_req_tmpl.f_ctl =
-                bfa_os_hton3b(FCTL_SEQ_INI | FCTL_FS_EXCH | FCTL_END_SEQ |
+                bfa_hton3b(FCTL_SEQ_INI | FCTL_FS_EXCH | FCTL_END_SEQ |
                               FCTL_SI_XFER);
         fc_els_req_tmpl.rx_id = FC_RXID_ANY;
 
@@ -59,7 +59,7 @@ fcbuild_init(void)
         fc_els_rsp_tmpl.cat_info = FC_CAT_LD_REPLY;
         fc_els_rsp_tmpl.type = FC_TYPE_ELS;
         fc_els_rsp_tmpl.f_ctl =
-                bfa_os_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH |
+                bfa_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH |
                               FCTL_END_SEQ | FCTL_SI_XFER);
         fc_els_rsp_tmpl.rx_id = FC_RXID_ANY;
 
@@ -68,7 +68,7 @@ fcbuild_init(void)
          */
         fc_bls_req_tmpl.routing = FC_RTG_BASIC_LINK;
         fc_bls_req_tmpl.type = FC_TYPE_BLS;
-        fc_bls_req_tmpl.f_ctl = bfa_os_hton3b(FCTL_END_SEQ | FCTL_SI_XFER);
+        fc_bls_req_tmpl.f_ctl = bfa_hton3b(FCTL_END_SEQ | FCTL_SI_XFER);
         fc_bls_req_tmpl.rx_id = FC_RXID_ANY;
 
         /*
@@ -78,7 +78,7 @@ fcbuild_init(void)
         fc_bls_rsp_tmpl.cat_info = FC_CAT_BA_ACC;
         fc_bls_rsp_tmpl.type = FC_TYPE_BLS;
         fc_bls_rsp_tmpl.f_ctl =
-                bfa_os_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH |
+                bfa_hton3b(FCTL_EC_RESP | FCTL_SEQ_INI | FCTL_LS_EXCH |
                               FCTL_END_SEQ | FCTL_SI_XFER);
         fc_bls_rsp_tmpl.rx_id = FC_RXID_ANY;
 
@@ -129,7 +129,7 @@ fcbuild_init(void)
         fcp_fchs_tmpl.cat_info = FC_CAT_UNSOLICIT_CMD;
         fcp_fchs_tmpl.type = FC_TYPE_FCP;
         fcp_fchs_tmpl.f_ctl =
-                bfa_os_hton3b(FCTL_FS_EXCH | FCTL_END_SEQ | FCTL_SI_XFER);
+                bfa_hton3b(FCTL_FS_EXCH | FCTL_END_SEQ | FCTL_SI_XFER);
         fcp_fchs_tmpl.seq_id = 1;
         fcp_fchs_tmpl.rx_id = FC_RXID_ANY;
 }
@@ -143,7 +143,7 @@ fc_gs_fchdr_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u32 ox_id)
         fchs->cat_info = FC_CAT_UNSOLICIT_CTRL;
         fchs->type = FC_TYPE_SERVICES;
         fchs->f_ctl =
-                bfa_os_hton3b(FCTL_SEQ_INI | FCTL_FS_EXCH | FCTL_END_SEQ |
+                bfa_hton3b(FCTL_SEQ_INI | FCTL_FS_EXCH | FCTL_END_SEQ |
                               FCTL_SI_XFER);
         fchs->rx_id = FC_RXID_ANY;
         fchs->d_id = (d_id);
@@ -157,7 +157,7 @@ fc_gs_fchdr_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u32 ox_id)
 }
 
 void
-fc_els_req_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
+fc_els_req_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id)
 {
         memcpy(fchs, &fc_els_req_tmpl, sizeof(struct fchs_s));
         fchs->d_id = (d_id);
@@ -166,7 +166,7 @@ fc_els_req_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
 }
 
 static void
-fc_els_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
+fc_els_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id)
 {
         memcpy(fchs, &fc_els_rsp_tmpl, sizeof(struct fchs_s));
         fchs->d_id = d_id;
@@ -196,7 +196,7 @@ fc_els_rsp_parse(struct fchs_s *fchs, int len)
 }
 
 static void
-fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
+fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id)
 {
         memcpy(fchs, &fc_bls_rsp_tmpl, sizeof(struct fchs_s));
         fchs->d_id = d_id;
@@ -206,7 +206,7 @@ fc_bls_rsp_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
 
 static          u16
 fc_plogi_x_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
-                 u16 ox_id, wwn_t port_name, wwn_t node_name,
+                 __be16 ox_id, wwn_t port_name, wwn_t node_name,
                  u16 pdu_size, u8 els_code)
 {
         struct fc_logi_s *plogi = (struct fc_logi_s *) (pld);
@@ -232,8 +232,8 @@ fc_flogi_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
                 u16 ox_id, wwn_t port_name, wwn_t node_name, u16 pdu_size,
                u8 set_npiv, u8 set_auth, u16 local_bb_credits)
 {
-        u32        d_id = bfa_os_hton3b(FC_FABRIC_PORT);
-        u32     *vvl_info;
+        u32        d_id = bfa_hton3b(FC_FABRIC_PORT);
+        __be32  *vvl_info;
 
         memcpy(flogi, &plogi_tmpl, sizeof(struct fc_logi_s));
 
@@ -267,7 +267,7 @@ fc_flogi_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
 
 u16
 fc_flogi_acc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
-                   u16 ox_id, wwn_t port_name, wwn_t node_name,
+                   __be16 ox_id, wwn_t port_name, wwn_t node_name,
                    u16 pdu_size, u16 local_bb_credits)
 {
         u32        d_id = 0;
@@ -289,7 +289,7 @@ u16
 fc_fdisc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
                 u16 ox_id, wwn_t port_name, wwn_t node_name, u16 pdu_size)
 {
-        u32        d_id = bfa_os_hton3b(FC_FABRIC_PORT);
+        u32        d_id = bfa_hton3b(FC_FABRIC_PORT);
 
         memcpy(flogi, &plogi_tmpl, sizeof(struct fc_logi_s));
 
@@ -392,7 +392,7 @@ fc_prli_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
 
 u16
 fc_prli_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
-                  u16 ox_id, enum bfa_lport_role role)
+                  __be16 ox_id, enum bfa_lport_role role)
 {
         struct fc_prli_s *prli = (struct fc_prli_s *) (pld);
 
@@ -456,9 +456,9 @@ fc_logo_build(struct fchs_s *fchs, struct fc_logo_s *logo, u32 d_id, u32 s_id,
         return sizeof(struct fc_logo_s);
 }
 
-static          u16
+static u16
 fc_adisc_x_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
-                 u32 s_id, u16 ox_id, wwn_t port_name,
+                 u32 s_id, __be16 ox_id, wwn_t port_name,
                  wwn_t node_name, u8 els_code)
 {
         memset(adisc, '\0', sizeof(struct fc_adisc_s));
@@ -480,7 +480,7 @@ fc_adisc_x_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
 
 u16
 fc_adisc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
-                u32 s_id, u16 ox_id, wwn_t port_name, wwn_t node_name)
+                u32 s_id, __be16 ox_id, wwn_t port_name, wwn_t node_name)
 {
         return fc_adisc_x_build(fchs, adisc, d_id, s_id, ox_id, port_name,
                                 node_name, FC_ELS_ADISC);
@@ -488,7 +488,7 @@ fc_adisc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
 
 u16
 fc_adisc_acc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
-                   u32 s_id, u16 ox_id, wwn_t port_name,
+                   u32 s_id, __be16 ox_id, wwn_t port_name,
                    wwn_t node_name)
 {
         return fc_adisc_x_build(fchs, adisc, d_id, s_id, ox_id, port_name,
@@ -592,7 +592,7 @@ fc_rrq_build(struct fchs_s *fchs, struct fc_rrq_s *rrq, u32 d_id, u32 s_id,
 
 u16
 fc_logo_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
-                  u16 ox_id)
+                  __be16 ox_id)
 {
         struct fc_els_cmd_s *acc = pld;
 
@@ -606,7 +606,7 @@ fc_logo_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
 
 u16
 fc_ls_rjt_build(struct fchs_s *fchs, struct fc_ls_rjt_s *ls_rjt, u32 d_id,
-                u32 s_id, u16 ox_id, u8 reason_code,
+                u32 s_id, __be16 ox_id, u8 reason_code,
                 u8 reason_code_expl)
 {
         fc_els_rsp_build(fchs, d_id, s_id, ox_id);
@@ -622,7 +622,7 @@ fc_ls_rjt_build(struct fchs_s *fchs, struct fc_ls_rjt_s *ls_rjt, u32 d_id,
 
 u16
 fc_ba_acc_build(struct fchs_s *fchs, struct fc_ba_acc_s *ba_acc, u32 d_id,
-                u32 s_id, u16 ox_id, u16 rx_id)
+                u32 s_id, __be16 ox_id, u16 rx_id)
 {
         fc_bls_rsp_build(fchs, d_id, s_id, ox_id);
 
@@ -638,7 +638,7 @@ fc_ba_acc_build(struct fchs_s *fchs, struct fc_ba_acc_s *ba_acc, u32 d_id,
 
 u16
 fc_ls_acc_build(struct fchs_s *fchs, struct fc_els_cmd_s *els_cmd, u32 d_id,
-                u32 s_id, u16 ox_id)
+                u32 s_id, __be16 ox_id)
 {
         fc_els_rsp_build(fchs, d_id, s_id, ox_id);
         memset(els_cmd, 0, sizeof(struct fc_els_cmd_s));
@@ -666,7 +666,7 @@ fc_logout_params_pages(struct fchs_s *fc_frame, u8 els_code)
 
 u16
 fc_tprlo_acc_build(struct fchs_s *fchs, struct fc_tprlo_acc_s *tprlo_acc,
-                u32 d_id, u32 s_id, u16 ox_id, int num_pages)
+                u32 d_id, u32 s_id, __be16 ox_id, int num_pages)
 {
         int             page;
 
@@ -690,7 +690,7 @@ fc_tprlo_acc_build(struct fchs_s *fchs, struct fc_tprlo_acc_s *tprlo_acc,
 
 u16
 fc_prlo_acc_build(struct fchs_s *fchs, struct fc_prlo_acc_s *prlo_acc, u32 d_id,
-                  u32 s_id, u16 ox_id, int num_pages)
+                  u32 s_id, __be16 ox_id, int num_pages)
 {
         int             page;
 
@@ -728,7 +728,7 @@ fc_rnid_build(struct fchs_s *fchs, struct fc_rnid_cmd_s *rnid, u32 d_id,
 
 u16
 fc_rnid_acc_build(struct fchs_s *fchs, struct fc_rnid_acc_s *rnid_acc, u32 d_id,
-                  u32 s_id, u16 ox_id, u32 data_format,
+                  u32 s_id, __be16 ox_id, u32 data_format,
                   struct fc_rnid_common_id_data_s *common_id_data,
                   struct fc_rnid_general_topology_data_s *gen_topo_data)
 {
@@ -770,10 +770,10 @@ u16
 fc_rpsc2_build(struct fchs_s *fchs, struct fc_rpsc2_cmd_s *rpsc2, u32 d_id,
                 u32 s_id, u32 *pid_list, u16 npids)
 {
-        u32 dctlr_id = FC_DOMAIN_CTRLR(bfa_os_hton3b(d_id));
+        u32 dctlr_id = FC_DOMAIN_CTRLR(bfa_hton3b(d_id));
         int i = 0;
 
-        fc_els_req_build(fchs, bfa_os_hton3b(dctlr_id), s_id, 0);
+        fc_els_req_build(fchs, bfa_hton3b(dctlr_id), s_id, 0);
 
         memset(rpsc2, 0, sizeof(struct fc_rpsc2_cmd_s));
 
@@ -788,7 +788,7 @@ fc_rpsc2_build(struct fchs_s *fchs, struct fc_rpsc2_cmd_s *rpsc2, u32 d_id,
 
 u16
 fc_rpsc_acc_build(struct fchs_s *fchs, struct fc_rpsc_acc_s *rpsc_acc,
-                u32 d_id, u32 s_id, u16 ox_id,
+                u32 d_id, u32 s_id, __be16 ox_id,
                   struct fc_rpsc_speed_info_s *oper_speed)
 {
         memset(rpsc_acc, 0, sizeof(struct fc_rpsc_acc_s));
@@ -807,11 +807,6 @@ fc_rpsc_acc_build(struct fchs_s *fchs, struct fc_rpsc_acc_s *rpsc_acc,
         return sizeof(struct fc_rpsc_acc_s);
 }
 
-/*
- * TBD -
- * . get rid of unnecessary memsets
- */
-
 u16
 fc_logo_rsp_parse(struct fchs_s *fchs, int len)
 {
@@ -995,7 +990,7 @@ fc_rrq_rsp_parse(struct fchs_s *fchs, int len)
 }
 
 u16
-fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
+fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id, __be16 ox_id,
                 u32 reason_code, u32 reason_expl)
 {
         struct fc_ba_rjt_s *ba_rjt = (struct fc_ba_rjt_s *) (fchs + 1);
@@ -1045,7 +1040,7 @@ fc_gidpn_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_gidpn_req_s *gidpn = (struct fcgs_gidpn_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
         fc_gs_cthdr_build(cthdr, s_id, GS_GID_PN);
@@ -1061,7 +1056,7 @@ fc_gpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         fcgs_gpnid_req_t *gpnid = (fcgs_gpnid_req_t *) (cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
         fc_gs_cthdr_build(cthdr, s_id, GS_GPN_ID);
@@ -1077,7 +1072,7 @@ fc_gnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         fcgs_gnnid_req_t *gnnid = (fcgs_gnnid_req_t *) (cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
         fc_gs_cthdr_build(cthdr, s_id, GS_GNN_ID);
@@ -1104,7 +1099,7 @@ u16
 fc_scr_build(struct fchs_s *fchs, struct fc_scr_s *scr,
                 u8 set_br_reg, u32 s_id, u16 ox_id)
 {
-        u32        d_id = bfa_os_hton3b(FC_FABRIC_CONTROLLER);
+        u32        d_id = bfa_hton3b(FC_FABRIC_CONTROLLER);
 
         fc_els_req_build(fchs, d_id, s_id, ox_id);
 
@@ -1121,7 +1116,7 @@ u16
 fc_rscn_build(struct fchs_s *fchs, struct fc_rscn_pl_s *rscn,
                 u32 s_id, u16 ox_id)
 {
-        u32        d_id = bfa_os_hton3b(FC_FABRIC_CONTROLLER);
+        u32        d_id = bfa_hton3b(FC_FABRIC_CONTROLLER);
         u16        payldlen;
 
         fc_els_req_build(fchs, d_id, s_id, ox_id);
@@ -1143,7 +1138,7 @@ fc_rftid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rftid_req_s *rftid = (struct fcgs_rftid_req_s *)(cthdr + 1);
-        u32        type_value, d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        type_value, d_id = bfa_hton3b(FC_NAME_SERVER);
         u8         index;
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
@@ -1167,7 +1162,7 @@ fc_rftid_build_sol(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rftid_req_s *rftid = (struct fcgs_rftid_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
         fc_gs_cthdr_build(cthdr, s_id, GS_RFT_ID);
@@ -1187,7 +1182,7 @@ fc_rffid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rffid_req_s *rffid = (struct fcgs_rffid_req_s *)(cthdr + 1);
-        u32         d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32         d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
         fc_gs_cthdr_build(cthdr, s_id, GS_RFF_ID);
@@ -1209,7 +1204,7 @@ fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rspnid_req_s *rspnid =
                         (struct fcgs_rspnid_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, ox_id);
         fc_gs_cthdr_build(cthdr, s_id, GS_RSPN_ID);
@@ -1229,7 +1224,7 @@ fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id, u8 fc4_type)
 
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_gidft_req_s *gidft = (struct fcgs_gidft_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
 
@@ -1249,7 +1244,7 @@ fc_rpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rpnid_req_s *rpnid = (struct fcgs_rpnid_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_cthdr_build(cthdr, s_id, GS_RPN_ID);
@@ -1267,7 +1262,7 @@ fc_rnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rnnid_req_s *rnnid = (struct fcgs_rnnid_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_cthdr_build(cthdr, s_id, GS_RNN_ID);
@@ -1286,7 +1281,7 @@ fc_rcsid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rcsid_req_s *rcsid =
                         (struct fcgs_rcsid_req_s *) (cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_cthdr_build(cthdr, s_id, GS_RCS_ID);
@@ -1304,7 +1299,7 @@ fc_rptid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_rptid_req_s *rptid = (struct fcgs_rptid_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_cthdr_build(cthdr, s_id, GS_RPT_ID);
@@ -1321,7 +1316,7 @@ fc_ganxt_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id)
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         struct fcgs_ganxt_req_s *ganxt = (struct fcgs_ganxt_req_s *)(cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_NAME_SERVER);
+        u32        d_id = bfa_hton3b(FC_NAME_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_cthdr_build(cthdr, s_id, GS_GA_NXT);
@@ -1341,7 +1336,7 @@ fc_fdmi_reqhdr_build(struct fchs_s *fchs, void *pyld, u32 s_id,
 {
 
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
-        u32        d_id = bfa_os_hton3b(FC_MGMT_SERVER);
+        u32        d_id = bfa_hton3b(FC_MGMT_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_fdmi_cthdr_build(cthdr, s_id, cmd_code);
@@ -1356,7 +1351,7 @@ void
 fc_get_fc4type_bitmask(u8 fc4_type, u8 *bit_mask)
 {
         u8         index;
-        u32       *ptr = (u32 *) bit_mask;
+        __be32       *ptr = (__be32 *) bit_mask;
         u32        type_value;
 
         /*
@@ -1377,7 +1372,7 @@ fc_gmal_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         fcgs_gmal_req_t *gmal = (fcgs_gmal_req_t *) (cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_MGMT_SERVER);
+        u32        d_id = bfa_hton3b(FC_MGMT_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_ms_cthdr_build(cthdr, s_id, GS_FC_GMAL_CMD,
@@ -1397,7 +1392,7 @@ fc_gfn_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
 {
         struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
         fcgs_gfn_req_t *gfn = (fcgs_gfn_req_t *) (cthdr + 1);
-        u32        d_id = bfa_os_hton3b(FC_MGMT_SERVER);
+        u32        d_id = bfa_hton3b(FC_MGMT_SERVER);
 
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_ms_cthdr_build(cthdr, s_id, GS_FC_GFN_CMD,
diff --git a/drivers/scsi/bfa/bfa_fcbuild.h b/drivers/scsi/bfa/bfa_fcbuild.h
index 73abd02e53cc..ece51ec7620b 100644
--- a/drivers/scsi/bfa/bfa_fcbuild.h
+++ b/drivers/scsi/bfa/bfa_fcbuild.h
@@ -21,7 +21,7 @@
 #ifndef __FCBUILD_H__
 #define __FCBUILD_H__
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 #include "bfa_fc.h"
 #include "bfa_defs_fcs.h"
 
@@ -138,7 +138,7 @@ u16        fc_fdisc_build(struct fchs_s *buf, struct fc_logi_s *flogi, u32 s_id,
                                u16 pdu_size);
 
 u16        fc_flogi_acc_build(struct fchs_s *fchs, struct fc_logi_s *flogi,
-                                   u32 s_id, u16 ox_id,
+                                   u32 s_id, __be16 ox_id,
                                    wwn_t port_name, wwn_t node_name,
                                    u16 pdu_size,
                                    u16 local_bb_credits);
@@ -186,7 +186,7 @@ u16        fc_plogi_acc_build(struct fchs_s *fchs, void *pld, u32 d_id,
                                    u16 pdu_size);
 
 u16        fc_adisc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc,
-                        u32 d_id, u32 s_id, u16 ox_id, wwn_t port_name,
+                        u32 d_id, u32 s_id, __be16 ox_id, wwn_t port_name,
                                wwn_t node_name);
 
 enum fc_parse_status fc_adisc_parse(struct fchs_s *fchs, void *pld,
@@ -196,20 +196,20 @@ enum fc_parse_status fc_adisc_rsp_parse(struct fc_adisc_s *adisc, int len,
                                  wwn_t port_name, wwn_t node_name);
 
 u16        fc_adisc_acc_build(struct fchs_s *fchs, struct fc_adisc_s *adisc,
-                                   u32 d_id, u32 s_id, u16 ox_id,
+                                   u32 d_id, u32 s_id, __be16 ox_id,
                                    wwn_t port_name, wwn_t node_name);
 u16        fc_ls_rjt_build(struct fchs_s *fchs, struct fc_ls_rjt_s *ls_rjt,
-                                u32 d_id, u32 s_id, u16 ox_id,
+                                u32 d_id, u32 s_id, __be16 ox_id,
                                 u8 reason_code, u8 reason_code_expl);
 u16        fc_ls_acc_build(struct fchs_s *fchs, struct fc_els_cmd_s *els_cmd,
-                                u32 d_id, u32 s_id, u16 ox_id);
+                                u32 d_id, u32 s_id, __be16 ox_id);
 u16        fc_prli_build(struct fchs_s *fchs, void *pld, u32 d_id,
                               u32 s_id, u16 ox_id);
 
 enum fc_parse_status fc_prli_rsp_parse(struct fc_prli_s *prli, int len);
 
 u16        fc_prli_acc_build(struct fchs_s *fchs, void *pld, u32 d_id,
-                                  u32 s_id, u16 ox_id,
+                                  u32 s_id, __be16 ox_id,
                                   enum bfa_lport_role role);
 
 u16        fc_rnid_build(struct fchs_s *fchs, struct fc_rnid_cmd_s *rnid,
@@ -218,7 +218,7 @@ u16        fc_rnid_build(struct fchs_s *fchs, struct fc_rnid_cmd_s *rnid,
 
 u16        fc_rnid_acc_build(struct fchs_s *fchs,
                         struct fc_rnid_acc_s *rnid_acc, u32 d_id, u32 s_id,
-                        u16 ox_id, u32 data_format,
+                        __be16 ox_id, u32 data_format,
                         struct fc_rnid_common_id_data_s *common_id_data,
                         struct fc_rnid_general_topology_data_s *gen_topo_data);
 
@@ -228,7 +228,7 @@ u16        fc_rpsc_build(struct fchs_s *fchs, struct fc_rpsc_cmd_s *rpsc,
                               u32 d_id, u32 s_id, u16 ox_id);
 u16        fc_rpsc_acc_build(struct fchs_s *fchs,
                         struct fc_rpsc_acc_s *rpsc_acc, u32 d_id, u32 s_id,
-                        u16 ox_id, struct fc_rpsc_speed_info_s *oper_speed);
+                        __be16 ox_id, struct fc_rpsc_speed_info_s *oper_speed);
 u16        fc_gid_ft_build(struct fchs_s *fchs, void *pld, u32 s_id,
                                 u8 fc4_type);
 
@@ -251,7 +251,7 @@ u16        fc_logo_build(struct fchs_s *fchs, struct fc_logo_s *logo, u32 d_id,
                               u32 s_id, u16 ox_id, wwn_t port_name);
 
 u16        fc_logo_acc_build(struct fchs_s *fchs, void *pld, u32 d_id,
-                                  u32 s_id, u16 ox_id);
+                                  u32 s_id, __be16 ox_id);
 
 u16        fc_fdmi_reqhdr_build(struct fchs_s *fchs, void *pyld, u32 s_id,
                                      u16 cmd_code);
@@ -261,7 +261,7 @@ u16	fc_gfn_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn);
 void            fc_get_fc4type_bitmask(u8 fc4_type, u8 *bit_mask);
 
 void            fc_els_req_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
-                                         u16 ox_id);
+                                         __be16 ox_id);
 
 enum fc_parse_status    fc_els_rsp_parse(struct fchs_s *fchs, int len);
 
@@ -274,15 +274,15 @@ enum fc_parse_status	fc_pdisc_parse(struct fchs_s *fchs, wwn_t node_name,
                                         wwn_t port_name);
 
 u16 fc_ba_acc_build(struct fchs_s *fchs, struct fc_ba_acc_s *ba_acc, u32 d_id,
-                u32 s_id, u16 ox_id, u16 rx_id);
+                u32 s_id, __be16 ox_id, u16 rx_id);
 
 int fc_logout_params_pages(struct fchs_s *fc_frame, u8 els_code);
 
 u16 fc_tprlo_acc_build(struct fchs_s *fchs, struct fc_tprlo_acc_s *tprlo_acc,
-                u32 d_id, u32 s_id, u16 ox_id, int num_pages);
+                u32 d_id, u32 s_id, __be16 ox_id, int num_pages);
 
 u16 fc_prlo_acc_build(struct fchs_s *fchs, struct fc_prlo_acc_s *prlo_acc,
-                u32 d_id, u32 s_id, u16 ox_id, int num_pages);
+                u32 d_id, u32 s_id, __be16 ox_id, int num_pages);
 
 u16 fc_logo_rsp_parse(struct fchs_s *fchs, int len);
 
@@ -304,7 +304,7 @@ u16 fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
 u16 fc_tprlo_rsp_parse(struct fchs_s *fchs, int len);
 
 u16 fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
-                u16 ox_id, u32 reason_code, u32 reason_expl);
+                __be16 ox_id, u32 reason_code, u32 reason_expl);
 
 u16 fc_gnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
                 u32 port_id);
diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index 135c4427801c..9c410b21db6d 100644
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -15,17 +15,12 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_modules.h"
-#include "bfa_cb_ioim.h"
 
 BFA_TRC_FILE(HAL, FCPIM);
 BFA_MODULE(fcpim);
 
-
-#define bfa_fcpim_add_iostats(__l, __r, __stats)        \
-        (__l->__stats += __r->__stats)
-
-
 /*
  *  BFA ITNIM Related definitions
  */
@@ -37,12 +32,12 @@ static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
 #define bfa_fcpim_additn(__itnim)                                       \
         list_add_tail(&(__itnim)->qe, &(__itnim)->fcpim->itnim_q)
 #define bfa_fcpim_delitn(__itnim)       do {                            \
-        bfa_assert(bfa_q_is_on_q(&(__itnim)->fcpim->itnim_q, __itnim));      \
+        WARN_ON(!bfa_q_is_on_q(&(__itnim)->fcpim->itnim_q, __itnim));   \
         bfa_itnim_update_del_itn_stats(__itnim);      \
         list_del(&(__itnim)->qe);      \
-        bfa_assert(list_empty(&(__itnim)->io_q));      \
-        bfa_assert(list_empty(&(__itnim)->io_cleanup_q));      \
-        bfa_assert(list_empty(&(__itnim)->pending_q));      \
+        WARN_ON(!list_empty(&(__itnim)->io_q));                         \
+        WARN_ON(!list_empty(&(__itnim)->io_cleanup_q));                 \
+        WARN_ON(!list_empty(&(__itnim)->pending_q));                    \
 } while (0)
 
 #define bfa_itnim_online_cb(__itnim) do {                               \
@@ -73,10 +68,8 @@ static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
 } while (0)
 
 /*
- *  bfa_itnim_sm BFA itnim state machine
+ *  itnim state machine event
  */
-
-
 enum bfa_itnim_event {
         BFA_ITNIM_SM_CREATE = 1,        /*  itnim is created */
         BFA_ITNIM_SM_ONLINE = 2,        /*  itnim is online */
@@ -107,9 +100,6 @@ enum bfa_itnim_event {
         if ((__fcpim)->profile_start)                                   \
                 (__fcpim)->profile_start(__ioim);                       \
 } while (0)
-/*
- *  hal_ioim_sm
- */
 
 /*
  * IO state machine events
@@ -221,8 +211,7 @@ static void     bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
  * forward declaration for BFA IOIM functions
  */
 static bfa_boolean_t    bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim);
-static bfa_boolean_t    bfa_ioim_sge_setup(struct bfa_ioim_s *ioim);
-static void             bfa_ioim_sgpg_setup(struct bfa_ioim_s *ioim);
+static bfa_boolean_t    bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim);
 static bfa_boolean_t    bfa_ioim_send_abort(struct bfa_ioim_s *ioim);
 static void             bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim);
 static void __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete);
@@ -232,7 +221,6 @@ static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
 static bfa_boolean_t    bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);
 
-
 /*
  * forward declaration of BFA IO state machine
  */
@@ -260,14 +248,13 @@ static void     bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim,
                                         enum bfa_ioim_event event);
 static void     bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim,
                                         enum bfa_ioim_event event);
-
 /*
  * forward declaration for BFA TSKIM functions
  */
 static void     __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete);
 static void     __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete);
 static bfa_boolean_t bfa_tskim_match_scope(struct bfa_tskim_s *tskim,
-                                        lun_t lun);
+                                        struct scsi_lun lun);
 static void     bfa_tskim_gather_ios(struct bfa_tskim_s *tskim);
 static void     bfa_tskim_cleanp_comp(void *tskim_cbarg);
 static void     bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim);
@@ -275,7 +262,6 @@ static bfa_boolean_t bfa_tskim_send(struct bfa_tskim_s *tskim);
 static bfa_boolean_t bfa_tskim_send_abort(struct bfa_tskim_s *tskim);
 static void     bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim);
 
-
 /*
  * forward declaration of BFA TSKIM state machine
  */
@@ -293,13 +279,12 @@ static void     bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
                                         enum bfa_tskim_event event);
 static void     bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim,
                                         enum bfa_tskim_event event);
-
 /*
- *  hal_fcpim_mod BFA FCP Initiator Mode module
+ *  BFA FCP Initiator Mode module
  */
 
 /*
- *      Compute and return memory needed by FCP(im) module.
+ * Compute and return memory needed by FCP(im) module.
  */
 static void
 bfa_fcpim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
@@ -357,10 +342,6 @@ bfa_fcpim_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 static void
 bfa_fcpim_detach(struct bfa_s *bfa)
 {
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-
-        bfa_ioim_detach(fcpim);
-        bfa_tskim_detach(fcpim);
 }
 
 static void
@@ -387,56 +368,6 @@ bfa_fcpim_iocdisable(struct bfa_s *bfa)
 }
 
 void
-bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,
-                struct bfa_itnim_iostats_s *rstats)
-{
-        bfa_fcpim_add_iostats(lstats, rstats, total_ios);
-        bfa_fcpim_add_iostats(lstats, rstats, qresumes);
-        bfa_fcpim_add_iostats(lstats, rstats, no_iotags);
-        bfa_fcpim_add_iostats(lstats, rstats, io_aborts);
-        bfa_fcpim_add_iostats(lstats, rstats, no_tskims);
-        bfa_fcpim_add_iostats(lstats, rstats, iocomp_ok);
-        bfa_fcpim_add_iostats(lstats, rstats, iocomp_underrun);
-        bfa_fcpim_add_iostats(lstats, rstats, iocomp_overrun);
-        bfa_fcpim_add_iostats(lstats, rstats, iocomp_aborted);
-        bfa_fcpim_add_iostats(lstats, rstats, iocomp_timedout);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_nexus_abort);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_proto_err);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_dif_err);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_sqer_needed);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_res_free);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_hostabrts);
-        bfa_fcpim_add_iostats(lstats, rstats, iocom_utags);
-        bfa_fcpim_add_iostats(lstats, rstats, io_cleanups);
-        bfa_fcpim_add_iostats(lstats, rstats, io_tmaborts);
-        bfa_fcpim_add_iostats(lstats, rstats, onlines);
-        bfa_fcpim_add_iostats(lstats, rstats, offlines);
-        bfa_fcpim_add_iostats(lstats, rstats, creates);
-        bfa_fcpim_add_iostats(lstats, rstats, deletes);
-        bfa_fcpim_add_iostats(lstats, rstats, create_comps);
-        bfa_fcpim_add_iostats(lstats, rstats, delete_comps);
-        bfa_fcpim_add_iostats(lstats, rstats, sler_events);
-        bfa_fcpim_add_iostats(lstats, rstats, fw_create);
-        bfa_fcpim_add_iostats(lstats, rstats, fw_delete);
-        bfa_fcpim_add_iostats(lstats, rstats, ioc_disabled);
-        bfa_fcpim_add_iostats(lstats, rstats, cleanup_comps);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_cmnds);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_fw_rsps);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_success);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_failures);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_io_comps);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_qresumes);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_iocdowns);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_cleanups);
-        bfa_fcpim_add_iostats(lstats, rstats, tm_cleanup_comps);
-        bfa_fcpim_add_iostats(lstats, rstats, io_comps);
-        bfa_fcpim_add_iostats(lstats, rstats, input_reqs);
-        bfa_fcpim_add_iostats(lstats, rstats, output_reqs);
-        bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);
-        bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);
-}
-
-void
 bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov)
 {
         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
@@ -454,128 +385,6 @@ bfa_fcpim_path_tov_get(struct bfa_s *bfa)
         return fcpim->path_tov / 1000;
 }
 
-bfa_status_t
-bfa_fcpim_port_iostats(struct bfa_s *bfa, struct bfa_itnim_iostats_s *stats,
-        u8 lp_tag)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        struct list_head *qe, *qen;
-        struct bfa_itnim_s *itnim;
-
-        /* accumulate IO stats from itnim */
-        memset(stats, 0, sizeof(struct bfa_itnim_iostats_s));
-        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
-                itnim = (struct bfa_itnim_s *) qe;
-                if (itnim->rport->rport_info.lp_tag != lp_tag)
-                        continue;
-                bfa_fcpim_add_stats(stats, &(itnim->stats));
-        }
-        return BFA_STATUS_OK;
-}
-bfa_status_t
-bfa_fcpim_get_modstats(struct bfa_s *bfa, struct bfa_itnim_iostats_s *modstats)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        struct list_head *qe, *qen;
-        struct bfa_itnim_s *itnim;
-
-        /* accumulate IO stats from itnim */
-        memset(modstats, 0, sizeof(struct bfa_itnim_iostats_s));
-        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
-                itnim = (struct bfa_itnim_s *) qe;
-                bfa_fcpim_add_stats(modstats, &(itnim->stats));
-        }
-        return BFA_STATUS_OK;
-}
-
-bfa_status_t
-bfa_fcpim_get_del_itn_stats(struct bfa_s *bfa,
-         struct bfa_fcpim_del_itn_stats_s *modstats)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-
-        *modstats = fcpim->del_itn_stats;
-
-        return BFA_STATUS_OK;
-}
-
-
-bfa_status_t
-bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time)
-{
-        struct bfa_itnim_s *itnim;
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        struct list_head *qe, *qen;
-
-        /* accumulate IO stats from itnim */
-        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
-                itnim = (struct bfa_itnim_s *) qe;
-                bfa_itnim_clear_stats(itnim);
-        }
-        fcpim->io_profile = BFA_TRUE;
-        fcpim->io_profile_start_time = time;
-        fcpim->profile_comp = bfa_ioim_profile_comp;
-        fcpim->profile_start = bfa_ioim_profile_start;
-
-        return BFA_STATUS_OK;
-}
-bfa_status_t
-bfa_fcpim_profile_off(struct bfa_s *bfa)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        fcpim->io_profile = BFA_FALSE;
-        fcpim->io_profile_start_time = 0;
-        fcpim->profile_comp = NULL;
-        fcpim->profile_start = NULL;
-        return BFA_STATUS_OK;
-}
-
-bfa_status_t
-bfa_fcpim_port_clear_iostats(struct bfa_s *bfa, u8 lp_tag)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        struct list_head *qe, *qen;
-        struct bfa_itnim_s *itnim;
-
-        /* clear IO stats from all active itnims */
-        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
-                itnim = (struct bfa_itnim_s *) qe;
-                if (itnim->rport->rport_info.lp_tag != lp_tag)
-                        continue;
-                bfa_itnim_clear_stats(itnim);
-        }
-        return BFA_STATUS_OK;
-
-}
-
-bfa_status_t
-bfa_fcpim_clr_modstats(struct bfa_s *bfa)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        struct list_head *qe, *qen;
-        struct bfa_itnim_s *itnim;
-
-        /* clear IO stats from all active itnims */
-        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
-                itnim = (struct bfa_itnim_s *) qe;
-                bfa_itnim_clear_stats(itnim);
-        }
-        memset(&fcpim->del_itn_stats, 0,
-                sizeof(struct bfa_fcpim_del_itn_stats_s));
-
-        return BFA_STATUS_OK;
-}
-
-void
-bfa_fcpim_qdepth_set(struct bfa_s *bfa, u16 q_depth)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-
-        bfa_assert(q_depth <= BFA_IOCFC_QDEPTH_MAX);
-
-        fcpim->q_depth = q_depth;
-}
-
 u16
 bfa_fcpim_qdepth_get(struct bfa_s *bfa)
 {
@@ -584,32 +393,12 @@ bfa_fcpim_qdepth_get(struct bfa_s *bfa)
         return fcpim->q_depth;
 }
 
-void
-bfa_fcpim_update_ioredirect(struct bfa_s *bfa)
-{
-        bfa_boolean_t ioredirect;
-
-        /*
-         * IO redirection is turned off when QoS is enabled and vice versa
-         */
-        ioredirect = bfa_fcport_is_qos_enabled(bfa) ? BFA_FALSE : BFA_TRUE;
-}
-
-void
-bfa_fcpim_set_ioredirect(struct bfa_s *bfa, bfa_boolean_t state)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
-        fcpim->ioredirect = state;
-}
-
-
-
 /*
  *  BFA ITNIM module state machine functions
  */
 
 /*
- *      Beginning/unallocated state - no events expected.
+ * Beginning/unallocated state - no events expected.
  */
 static void
 bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
@@ -630,7 +419,7 @@ bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 }
 
 /*
- *      Beginning state, only online event expected.
+ * Beginning state, only online event expected.
  */
 static void
 bfa_itnim_sm_created(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
@@ -733,7 +522,7 @@ bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
 }
 
 /*
- *      Waiting for itnim create response from firmware, a delete is pending.
+ * Waiting for itnim create response from firmware, a delete is pending.
  */
 static void
 bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
@@ -761,7 +550,7 @@ bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
 }
 
 /*
- *      Online state - normal parking state.
+ * Online state - normal parking state.
  */
 static void
 bfa_itnim_sm_online(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
@@ -803,7 +592,7 @@ bfa_itnim_sm_online(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 }
 
 /*
- *      Second level error recovery need.
+ * Second level error recovery need.
  */
 static void
 bfa_itnim_sm_sler(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
@@ -834,7 +623,7 @@ bfa_itnim_sm_sler(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 }
 
 /*
- *      Going offline. Waiting for active IO cleanup.
+ * Going offline. Waiting for active IO cleanup.
  */
 static void
 bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
@@ -871,7 +660,7 @@ bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
 }
 
 /*
- *      Deleting itnim. Waiting for active IO cleanup.
+ * Deleting itnim. Waiting for active IO cleanup.
  */
 static void
 bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
@@ -956,7 +745,7 @@ bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
 }
 
 /*
- *      Offline state.
+ * Offline state.
  */
 static void
 bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
@@ -987,9 +776,6 @@ bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
         }
 }
 
-/*
- *      IOC h/w failed state.
- */
 static void
 bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
                                 enum bfa_itnim_event event)
@@ -1024,7 +810,7 @@ bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
 }
 
 /*
- *      Itnim is deleted, waiting for firmware response to delete.
+ * Itnim is deleted, waiting for firmware response to delete.
  */
 static void
 bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
@@ -1069,7 +855,7 @@ bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
 }
 
 /*
- *      Initiate cleanup of all IOs on an IOC failure.
+ * Initiate cleanup of all IOs on an IOC failure.
  */
 static void
 bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim)
@@ -1103,7 +889,7 @@ bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim)
 }
 
 /*
- *      IO cleanup completion
+ * IO cleanup completion
  */
 static void
 bfa_itnim_cleanp_comp(void *itnim_cbarg)
@@ -1115,7 +901,7 @@ bfa_itnim_cleanp_comp(void *itnim_cbarg)
 }
 
 /*
- *      Initiate cleanup of all IOs.
+ * Initiate cleanup of all IOs.
  */
 static void
 bfa_itnim_cleanup(struct bfa_itnim_s *itnim)
@@ -1187,9 +973,6 @@ bfa_itnim_qresume(void *cbarg)
         bfa_sm_send_event(itnim, BFA_ITNIM_SM_QRESUME);
 }
 
-
-
-
 /*
  *  bfa_itnim_public
  */
@@ -1401,7 +1184,7 @@ bfa_itnim_iotov_start(struct bfa_itnim_s *itnim)
         if (itnim->fcpim->path_tov > 0) {
 
                 itnim->iotov_active = BFA_TRUE;
-                bfa_assert(bfa_itnim_hold_io(itnim));
+                WARN_ON(!bfa_itnim_hold_io(itnim));
                 bfa_timer_start(itnim->bfa, &itnim->timer,
                         bfa_itnim_iotov, itnim, itnim->fcpim->path_tov);
         }
@@ -1457,14 +1240,12 @@ bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim)
         fcpim->del_itn_stats.del_tm_iocdowns += itnim->stats.tm_iocdowns;
 }
 
-
-
 /*
- *  bfa_itnim_public
+ * bfa_itnim_public
  */
 
 /*
- *      Itnim interrupt processing.
+ * Itnim interrupt processing.
  */
 void
 bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
@@ -1481,7 +1262,7 @@ bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         case BFI_ITNIM_I2H_CREATE_RSP:
                 itnim = BFA_ITNIM_FROM_TAG(fcpim,
                                                 msg.create_rsp->bfa_handle);
-                bfa_assert(msg.create_rsp->status == BFA_STATUS_OK);
+                WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
                 bfa_stats(itnim, create_comps);
                 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
                 break;
@@ -1489,7 +1270,7 @@ bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         case BFI_ITNIM_I2H_DELETE_RSP:
                 itnim = BFA_ITNIM_FROM_TAG(fcpim,
                                                 msg.delete_rsp->bfa_handle);
-                bfa_assert(msg.delete_rsp->status == BFA_STATUS_OK);
+                WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
                 bfa_stats(itnim, delete_comps);
                 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
                 break;
@@ -1503,14 +1284,12 @@ bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 
         default:
                 bfa_trc(bfa, m->mhdr.msg_id);
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
-
-
 /*
- *  bfa_itnim_api
+ * bfa_itnim_api
  */
 
 struct bfa_itnim_s *
@@ -1520,7 +1299,7 @@ bfa_itnim_create(struct bfa_s *bfa, struct bfa_rport_s *rport, void *ditn)
         struct bfa_itnim_s *itnim;
 
         itnim = BFA_ITNIM_FROM_TAG(fcpim, rport->rport_tag);
-        bfa_assert(itnim->rport == rport);
+        WARN_ON(itnim->rport != rport);
 
         itnim->ditn = ditn;
 
@@ -1568,31 +1347,6 @@ bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable));
 }
 
-bfa_status_t
-bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
-                struct bfa_itnim_ioprofile_s *ioprofile)
-{
-        struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(itnim->bfa);
-        if (!fcpim->io_profile)
-                return BFA_STATUS_IOPROFILE_OFF;
-
-        itnim->ioprofile.index = BFA_IOBUCKET_MAX;
-        itnim->ioprofile.io_profile_start_time =
-                bfa_io_profile_start_time(itnim->bfa);
-        itnim->ioprofile.clock_res_mul = bfa_io_lat_clock_res_mul;
-        itnim->ioprofile.clock_res_div = bfa_io_lat_clock_res_div;
-        *ioprofile = itnim->ioprofile;
-
-        return BFA_STATUS_OK;
-}
-
-void
-bfa_itnim_get_stats(struct bfa_itnim_s *itnim,
-        struct bfa_itnim_iostats_s *stats)
-{
-        *stats = itnim->stats;
-}
-
 void
 bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
 {
@@ -1608,14 +1362,11 @@ bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
  */
 
 /*
- *      IO is not started (unallocated).
+ * IO is not started (unallocated).
  */
 static void
 bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 {
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
-        bfa_trc_fp(ioim->bfa, event);
-
         switch (event) {
         case BFA_IOIM_SM_START:
                 if (!bfa_itnim_is_online(ioim->itnim)) {
@@ -1635,7 +1386,7 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 }
 
                 if (ioim->nsges > BFI_SGE_INLINE) {
-                        if (!bfa_ioim_sge_setup(ioim)) {
+                        if (!bfa_ioim_sgpg_alloc(ioim)) {
                                 bfa_sm_set_state(ioim, bfa_ioim_sm_sgalloc);
                                 return;
                         }
@@ -1662,7 +1413,7 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                  * requests immediately.
                  */
                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
-                bfa_assert(bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
+                WARN_ON(!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
                                 __bfa_cb_ioim_abort, ioim);
                 break;
@@ -1673,7 +1424,7 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
- *      IO is waiting for SG pages.
+ * IO is waiting for SG pages.
  */
 static void
 bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
@@ -1720,14 +1471,11 @@ bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
- *      IO is active.
+ * IO is active.
  */
 static void
 bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 {
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
-        bfa_trc_fp(ioim->bfa, event);
-
         switch (event) {
         case BFA_IOIM_SM_COMP_GOOD:
                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
@@ -1786,8 +1534,8 @@ bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         case BFA_IOIM_SM_SQRETRY:
-                if (bfa_ioim_get_iotag(ioim) != BFA_TRUE) {
-                        /* max retry completed free IO */
+                if (bfa_ioim_maxretry_reached(ioim)) {
+                        /* max retry reached, free IO */
                         bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
                         bfa_ioim_move_to_comp_q(ioim);
                         bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
@@ -1804,17 +1552,15 @@ bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
-*       IO is retried with new tag.
-*/
+ * IO is retried with new tag.
+ */
 static void
 bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 {
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
-        bfa_trc_fp(ioim->bfa, event);
-
         switch (event) {
         case BFA_IOIM_SM_FREE:
                 /* abts and rrq done. Now retry the IO with new tag */
+                bfa_ioim_update_iotag(ioim);
                 if (!bfa_ioim_send_ioreq(ioim)) {
                         bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
                         break;
@@ -1858,7 +1604,7 @@ bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
- *      IO is being aborted, waiting for completion from firmware.
+ * IO is being aborted, waiting for completion from firmware.
  */
 static void
 bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
@@ -1894,7 +1640,7 @@ bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         case BFA_IOIM_SM_CLEANUP:
-                bfa_assert(ioim->iosp->abort_explicit == BFA_TRUE);
+                WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
                 ioim->iosp->abort_explicit = BFA_FALSE;
 
                 if (bfa_ioim_send_abort(ioim))
@@ -1981,7 +1727,7 @@ bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
- *      IO is waiting for room in request CQ
+ * IO is waiting for room in request CQ
  */
 static void
 bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
@@ -2025,7 +1771,7 @@ bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
- *      Active IO is being aborted, waiting for room in request CQ.
+ * Active IO is being aborted, waiting for room in request CQ.
  */
 static void
 bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
@@ -2040,7 +1786,7 @@ bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         case BFA_IOIM_SM_CLEANUP:
-                bfa_assert(ioim->iosp->abort_explicit == BFA_TRUE);
+                WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
                 ioim->iosp->abort_explicit = BFA_FALSE;
                 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
                 break;
@@ -2076,7 +1822,7 @@ bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 /*
- *      Active IO is being cleaned up, waiting for room in request CQ.
+ * Active IO is being cleaned up, waiting for room in request CQ.
  */
 static void
 bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
@@ -2131,9 +1877,6 @@ bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 static void
 bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 {
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
-        bfa_trc_fp(ioim->bfa, event);
-
         switch (event) {
         case BFA_IOIM_SM_HCB:
                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
@@ -2213,11 +1956,6 @@ bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 }
 
 
-
-/*
- *  hal_ioim_private
- */
-
 static void
 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
 {
@@ -2323,7 +2061,7 @@ bfa_ioim_sgpg_alloced(void *cbarg)
 
         ioim->nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
         list_splice_tail_init(&ioim->iosp->sgpg_wqe.sgpg_q, &ioim->sgpg_q);
-        bfa_ioim_sgpg_setup(ioim);
+        ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
         bfa_sm_send_event(ioim, BFA_IOIM_SM_SGALLOCED);
 }
 
@@ -2335,13 +2073,16 @@ bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
 {
         struct bfa_itnim_s *itnim = ioim->itnim;
         struct bfi_ioim_req_s *m;
-        static struct fcp_cmnd_s cmnd_z0 = { 0 };
-        struct bfi_sge_s      *sge;
+        static struct fcp_cmnd_s cmnd_z0 = { { { 0 } } };
+        struct bfi_sge_s *sge, *sgpge;
         u32     pgdlen = 0;
         u32     fcp_dl;
         u64 addr;
         struct scatterlist *sg;
+        struct bfa_sgpg_s *sgpg;
         struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
+        u32 i, sge_id, pgcumsz;
+        enum dma_data_direction dmadir;
 
         /*
          * check for room in queue to send request now
@@ -2359,22 +2100,61 @@ bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
          */
         m->io_tag = cpu_to_be16(ioim->iotag);
         m->rport_hdl = ioim->itnim->rport->fw_handle;
-        m->io_timeout = bfa_cb_ioim_get_timeout(ioim->dio);
+        m->io_timeout = 0;
 
-        /*
-         * build inline IO SG element here
-         */
         sge = &m->sges[0];
-        if (ioim->nsges) {
-                sg = (struct scatterlist *)scsi_sglist(cmnd);
-                addr = bfa_os_sgaddr(sg_dma_address(sg));
-                sge->sga = *(union bfi_addr_u *) &addr;
-                pgdlen = sg_dma_len(sg);
-                sge->sg_len = pgdlen;
-                sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
+        sgpg = ioim->sgpg;
+        sge_id = 0;
+        sgpge = NULL;
+        pgcumsz = 0;
+        scsi_for_each_sg(cmnd, sg, ioim->nsges, i) {
+                if (i == 0) {
+                        /* build inline IO SG element */
+                        addr = bfa_sgaddr_le(sg_dma_address(sg));
+                        sge->sga = *(union bfi_addr_u *) &addr;
+                        pgdlen = sg_dma_len(sg);
+                        sge->sg_len = pgdlen;
+                        sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
                                         BFI_SGE_DATA_CPL : BFI_SGE_DATA_LAST;
-                bfa_sge_to_be(sge);
-                sge++;
+                        bfa_sge_to_be(sge);
+                        sge++;
+                } else {
+                        if (sge_id == 0)
+                                sgpge = sgpg->sgpg->sges;
+
+                        addr = bfa_sgaddr_le(sg_dma_address(sg));
+                        sgpge->sga = *(union bfi_addr_u *) &addr;
+                        sgpge->sg_len = sg_dma_len(sg);
+                        pgcumsz += sgpge->sg_len;
+
+                        /* set flags */
+                        if (i < (ioim->nsges - 1) &&
+                                        sge_id < (BFI_SGPG_DATA_SGES - 1))
+                                sgpge->flags = BFI_SGE_DATA;
+                        else if (i < (ioim->nsges - 1))
+                                sgpge->flags = BFI_SGE_DATA_CPL;
+                        else
+                                sgpge->flags = BFI_SGE_DATA_LAST;
+
+                        bfa_sge_to_le(sgpge);
+
+                        sgpge++;
+                        if (i == (ioim->nsges - 1)) {
+                                sgpge->flags = BFI_SGE_PGDLEN;
+                                sgpge->sga.a32.addr_lo = 0;
+                                sgpge->sga.a32.addr_hi = 0;
+                                sgpge->sg_len = pgcumsz;
+                                bfa_sge_to_le(sgpge);
+                        } else if (++sge_id == BFI_SGPG_DATA_SGES) {
+                                sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
+                                sgpge->flags = BFI_SGE_LINK;
+                                sgpge->sga = sgpg->sgpg_pa;
+                                sgpge->sg_len = pgcumsz;
+                                bfa_sge_to_le(sgpge);
+                                sge_id = 0;
+                                pgcumsz = 0;
+                        }
+                }
         }
 
         if (ioim->nsges > BFI_SGE_INLINE) {
@@ -2391,10 +2171,17 @@ bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
          * set up I/O command parameters
          */
         m->cmnd = cmnd_z0;
-        m->cmnd.lun = bfa_cb_ioim_get_lun(ioim->dio);
-        m->cmnd.iodir = bfa_cb_ioim_get_iodir(ioim->dio);
-        m->cmnd.cdb = *(scsi_cdb_t *)bfa_cb_ioim_get_cdb(ioim->dio);
-        fcp_dl = bfa_cb_ioim_get_size(ioim->dio);
+        int_to_scsilun(cmnd->device->lun, &m->cmnd.lun);
+        dmadir = cmnd->sc_data_direction;
+        if (dmadir == DMA_TO_DEVICE)
+                m->cmnd.iodir = FCP_IODIR_WRITE;
+        else if (dmadir == DMA_FROM_DEVICE)
+                m->cmnd.iodir = FCP_IODIR_READ;
+        else
+                m->cmnd.iodir = FCP_IODIR_NONE;
+
+        m->cmnd.cdb = *(struct scsi_cdb_s *) cmnd->cmnd;
+        fcp_dl = scsi_bufflen(cmnd);
         m->cmnd.fcp_dl = cpu_to_be32(fcp_dl);
 
         /*
@@ -2418,28 +2205,9 @@ bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
                 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
         }
         if (itnim->seq_rec ||
-            (bfa_cb_ioim_get_size(ioim->dio) & (sizeof(u32) - 1)))
+            (scsi_bufflen(cmnd) & (sizeof(u32) - 1)))
                 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
 
-#ifdef IOIM_ADVANCED
-        m->cmnd.crn = bfa_cb_ioim_get_crn(ioim->dio);
-        m->cmnd.priority = bfa_cb_ioim_get_priority(ioim->dio);
-        m->cmnd.taskattr = bfa_cb_ioim_get_taskattr(ioim->dio);
-
-        /*
-         * Handle large CDB (>16 bytes).
-         */
-        m->cmnd.addl_cdb_len = (bfa_cb_ioim_get_cdblen(ioim->dio) -
-                                        FCP_CMND_CDB_LEN) / sizeof(u32);
-        if (m->cmnd.addl_cdb_len) {
-                memcpy(&m->cmnd.cdb + 1, (scsi_cdb_t *)
-                                bfa_cb_ioim_get_cdb(ioim->dio) + 1,
-                                m->cmnd.addl_cdb_len * sizeof(u32));
-                fcp_cmnd_fcpdl(&m->cmnd) =
-                                cpu_to_be32(bfa_cb_ioim_get_size(ioim->dio));
-        }
-#endif
-
         /*
          * queue I/O message to firmware
          */
@@ -2452,11 +2220,11 @@ bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
  * at queuing time.
  */
 static bfa_boolean_t
-bfa_ioim_sge_setup(struct bfa_ioim_s *ioim)
+bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim)
 {
         u16     nsgpgs;
 
-        bfa_assert(ioim->nsges > BFI_SGE_INLINE);
+        WARN_ON(ioim->nsges <= BFI_SGE_INLINE);
 
         /*
          * allocate SG pages needed
@@ -2472,73 +2240,11 @@ bfa_ioim_sge_setup(struct bfa_ioim_s *ioim)
         }
 
         ioim->nsgpgs = nsgpgs;
-        bfa_ioim_sgpg_setup(ioim);
+        ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
 
         return BFA_TRUE;
 }
 
-static void
-bfa_ioim_sgpg_setup(struct bfa_ioim_s *ioim)
-{
-        int             sgeid, nsges, i;
-        struct bfi_sge_s      *sge;
-        struct bfa_sgpg_s *sgpg;
-        u32     pgcumsz;
-        u64        addr;
-        struct scatterlist *sg;
-        struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
-
-        sgeid = BFI_SGE_INLINE;
-        ioim->sgpg = sgpg = bfa_q_first(&ioim->sgpg_q);
-
-        sg = scsi_sglist(cmnd);
-        sg = sg_next(sg);
-
-        do {
-                sge = sgpg->sgpg->sges;
-                nsges = ioim->nsges - sgeid;
-                if (nsges > BFI_SGPG_DATA_SGES)
-                        nsges = BFI_SGPG_DATA_SGES;
-
-                pgcumsz = 0;
-                for (i = 0; i < nsges; i++, sge++, sgeid++, sg = sg_next(sg)) {
-                        addr = bfa_os_sgaddr(sg_dma_address(sg));
-                        sge->sga = *(union bfi_addr_u *) &addr;
-                        sge->sg_len = sg_dma_len(sg);
-                        pgcumsz += sge->sg_len;
-
-                        /*
-                         * set flags
-                         */
-                        if (i < (nsges - 1))
-                                sge->flags = BFI_SGE_DATA;
-                        else if (sgeid < (ioim->nsges - 1))
-                                sge->flags = BFI_SGE_DATA_CPL;
-                        else
-                                sge->flags = BFI_SGE_DATA_LAST;
-
-                        bfa_sge_to_le(sge);
-                }
-
-                sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
-
-                /*
-                 * set the link element of each page
-                 */
-                if (sgeid == ioim->nsges) {
-                        sge->flags = BFI_SGE_PGDLEN;
-                        sge->sga.a32.addr_lo = 0;
-                        sge->sga.a32.addr_hi = 0;
-                } else {
-                        sge->flags = BFI_SGE_LINK;
-                        sge->sga = sgpg->sgpg_pa;
-                }
-                sge->sg_len = pgcumsz;
-
-                bfa_sge_to_le(sge);
-        } while (sgeid < ioim->nsges);
-}
-
 /*
  * Send I/O abort request to firmware.
  */
@@ -2605,7 +2311,7 @@ bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim)
                 }
                 bfa_itnim_iodone(ioim->itnim);
         } else
-                bfa_tskim_iodone(ioim->iosp->tskim);
+                bfa_wc_down(&ioim->iosp->tskim->wc);
 }
 
 static bfa_boolean_t
@@ -2623,9 +2329,6 @@ bfa_ioim_is_abortable(struct bfa_ioim_s *ioim)
         return BFA_TRUE;
 }
 
-/*
- *      or after the link comes back.
- */
 void
 bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
 {
@@ -2653,11 +2356,6 @@ bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
 }
 
 
-
-/*
- *  hal_ioim_friend
- */
-
 /*
  * Memory allocation and initialization.
  */
@@ -2722,14 +2420,6 @@ bfa_ioim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
         }
 }
 
-/*
- * Driver detach time call.
- */
-void
-bfa_ioim_detach(struct bfa_fcpim_mod_s *fcpim)
-{
-}
-
 void
 bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 {
@@ -2742,7 +2432,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         iotag = be16_to_cpu(rsp->io_tag);
 
         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
-        bfa_assert(ioim->iotag == iotag);
+        WARN_ON(ioim->iotag != iotag);
 
         bfa_trc(ioim->bfa, ioim->iotag);
         bfa_trc(ioim->bfa, rsp->io_status);
@@ -2773,13 +2463,13 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 
         case BFI_IOIM_STS_PROTO_ERR:
                 bfa_stats(ioim->itnim, iocom_proto_err);
-                bfa_assert(rsp->reuse_io_tag);
+                WARN_ON(!rsp->reuse_io_tag);
                 evt = BFA_IOIM_SM_COMP;
                 break;
 
         case BFI_IOIM_STS_SQER_NEEDED:
                 bfa_stats(ioim->itnim, iocom_sqer_needed);
-                bfa_assert(rsp->reuse_io_tag == 0);
+                WARN_ON(rsp->reuse_io_tag != 0);
                 evt = BFA_IOIM_SM_SQRETRY;
                 break;
 
@@ -2808,7 +2498,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                 break;
 
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 
         bfa_sm_send_event(ioim, evt);
@@ -2825,39 +2515,12 @@ bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         iotag = be16_to_cpu(rsp->io_tag);
 
         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
-        bfa_assert(ioim->iotag == iotag);
+        WARN_ON(BFA_IOIM_TAG_2_ID(ioim->iotag) != iotag);
 
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
         bfa_ioim_cb_profile_comp(fcpim, ioim);
-
         bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
 }
 
-void
-bfa_ioim_profile_start(struct bfa_ioim_s *ioim)
-{
-        ioim->start_time = jiffies;
-}
-
-void
-bfa_ioim_profile_comp(struct bfa_ioim_s *ioim)
-{
-        u32 fcp_dl = bfa_cb_ioim_get_size(ioim->dio);
-        u32 index = bfa_ioim_get_index(fcp_dl);
-        u64 end_time = jiffies;
-        struct bfa_itnim_latency_s *io_lat =
-                        &(ioim->itnim->ioprofile.io_latency);
-        u32 val = (u32)(end_time - ioim->start_time);
-
-        bfa_itnim_ioprofile_update(ioim->itnim, index);
-
-        io_lat->count[index]++;
-        io_lat->min[index] = (io_lat->min[index] < val) ?
-                io_lat->min[index] : val;
-        io_lat->max[index] = (io_lat->max[index] > val) ?
-                io_lat->max[index] : val;
-        io_lat->avg[index] += val;
-}
 /*
  * Called by itnim to clean up IO while going offline.
  */
@@ -2903,11 +2566,6 @@ bfa_ioim_tov(struct bfa_ioim_s *ioim)
 }
 
 
-
-/*
- *  hal_ioim_api
- */
-
 /*
  * Allocate IOIM resource for initiator mode I/O request.
  */
@@ -2936,7 +2594,6 @@ bfa_ioim_alloc(struct bfa_s *bfa, struct bfad_ioim_s *dio,
         fcpim->ios_active++;
 
         list_add_tail(&ioim->qe, &itnim->io_q);
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
 
         return ioim;
 }
@@ -2946,18 +2603,13 @@ bfa_ioim_free(struct bfa_ioim_s *ioim)
 {
         struct bfa_fcpim_mod_s *fcpim = ioim->fcpim;
 
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
-        bfa_assert_fp(bfa_sm_cmp_state(ioim, bfa_ioim_sm_uninit));
-
-        bfa_assert_fp(list_empty(&ioim->sgpg_q) ||
-                        (ioim->nsges > BFI_SGE_INLINE));
-
         if (ioim->nsgpgs > 0)
                 bfa_sgpg_mfree(ioim->bfa, &ioim->sgpg_q, ioim->nsgpgs);
 
         bfa_stats(ioim->itnim, io_comps);
         fcpim->ios_active--;
 
+        ioim->iotag &= BFA_IOIM_IOTAG_MASK;
         list_del(&ioim->qe);
         list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
 }
@@ -2965,16 +2617,13 @@ bfa_ioim_free(struct bfa_ioim_s *ioim)
 void
 bfa_ioim_start(struct bfa_ioim_s *ioim)
 {
-        bfa_trc_fp(ioim->bfa, ioim->iotag);
-
         bfa_ioim_cb_profile_start(ioim->fcpim, ioim);
 
         /*
          * Obtain the queue over which this request has to be issued
          */
         ioim->reqq = bfa_fcpim_ioredirect_enabled(ioim->bfa) ?
-                        bfa_cb_ioim_get_reqq(ioim->dio) :
-                        bfa_itnim_get_reqq(ioim);
+                        BFA_FALSE : bfa_itnim_get_reqq(ioim);
 
         bfa_sm_send_event(ioim, BFA_IOIM_SM_START);
 }
@@ -2997,13 +2646,12 @@ bfa_ioim_abort(struct bfa_ioim_s *ioim)
         return BFA_STATUS_OK;
 }
 
-
 /*
  *  BFA TSKIM state machine functions
  */
 
 /*
- *      Task management command beginning state.
+ * Task management command beginning state.
  */
 static void
 bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
@@ -3040,9 +2688,8 @@ bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
 }
 
 /*
- * brief
- *      TM command is active, awaiting completion from firmware to
- *      cleanup IO requests in TM scope.
+ * TM command is active, awaiting completion from firmware to
+ * cleanup IO requests in TM scope.
  */
 static void
 bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
@@ -3077,8 +2724,8 @@ bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
 }
 
 /*
- *      An active TM is being cleaned up since ITN is offline. Awaiting cleanup
- *      completion event from firmware.
+ * An active TM is being cleaned up since ITN is offline. Awaiting cleanup
+ * completion event from firmware.
  */
 static void
 bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
@@ -3138,7 +2785,7 @@ bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
 }
 
 /*
- *      Task management command is waiting for room in request CQ
+ * Task management command is waiting for room in request CQ
  */
 static void
 bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
@@ -3173,8 +2820,8 @@ bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
 }
 
 /*
- *      Task management command is active, awaiting for room in request CQ
- *      to send clean up request.
+ * Task management command is active, awaiting for room in request CQ
+ * to send clean up request.
  */
 static void
 bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
@@ -3186,10 +2833,8 @@ bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
         case BFA_TSKIM_SM_DONE:
                 bfa_reqq_wcancel(&tskim->reqq_wait);
                 /*
-                 *
                  * Fall through !!!
                  */
-
         case BFA_TSKIM_SM_QRESUME:
                 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
                 bfa_tskim_send_abort(tskim);
@@ -3208,7 +2853,7 @@ bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
 }
 
 /*
- *      BFA callback is pending
+ * BFA callback is pending
  */
 static void
 bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
@@ -3233,12 +2878,6 @@ bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
         }
 }
 
-
-
-/*
- *  hal_tskim_private
- */
-
 static void
 __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete)
 {
@@ -3268,8 +2907,8 @@ __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete)
                                 BFI_TSKIM_STS_FAILED);
 }
 
-static  bfa_boolean_t
-bfa_tskim_match_scope(struct bfa_tskim_s *tskim, lun_t lun)
+static bfa_boolean_t
+bfa_tskim_match_scope(struct bfa_tskim_s *tskim, struct scsi_lun lun)
 {
         switch (tskim->tm_cmnd) {
         case FCP_TM_TARGET_RESET:
@@ -3279,24 +2918,26 @@ bfa_tskim_match_scope(struct bfa_tskim_s *tskim, lun_t lun)
         case FCP_TM_CLEAR_TASK_SET:
         case FCP_TM_LUN_RESET:
         case FCP_TM_CLEAR_ACA:
-                return (tskim->lun == lun);
+                return !memcmp(&tskim->lun, &lun, sizeof(lun));
 
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 
         return BFA_FALSE;
 }
 
 /*
- *      Gather affected IO requests and task management commands.
+ * Gather affected IO requests and task management commands.
  */
 static void
 bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
 {
         struct bfa_itnim_s *itnim = tskim->itnim;
         struct bfa_ioim_s *ioim;
-        struct list_head        *qe, *qen;
+        struct list_head *qe, *qen;
+        struct scsi_cmnd *cmnd;
+        struct scsi_lun scsilun;
 
         INIT_LIST_HEAD(&tskim->io_q);
 
@@ -3305,8 +2946,9 @@ bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
          */
         list_for_each_safe(qe, qen, &itnim->io_q) {
                 ioim = (struct bfa_ioim_s *) qe;
-                if (bfa_tskim_match_scope
-                        (tskim, bfa_cb_ioim_get_lun(ioim->dio))) {
+                cmnd = (struct scsi_cmnd *) ioim->dio;
+                int_to_scsilun(cmnd->device->lun, &scsilun);
+                if (bfa_tskim_match_scope(tskim, scsilun)) {
                         list_del(&ioim->qe);
                         list_add_tail(&ioim->qe, &tskim->io_q);
                 }
@@ -3317,8 +2959,9 @@ bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
          */
         list_for_each_safe(qe, qen, &itnim->pending_q) {
                 ioim = (struct bfa_ioim_s *) qe;
-                if (bfa_tskim_match_scope
-                        (tskim, bfa_cb_ioim_get_lun(ioim->dio))) {
+                cmnd = (struct scsi_cmnd *) ioim->dio;
+                int_to_scsilun(cmnd->device->lun, &scsilun);
+                if (bfa_tskim_match_scope(tskim, scsilun)) {
                         list_del(&ioim->qe);
                         list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
                         bfa_ioim_tov(ioim);
@@ -3327,7 +2970,7 @@ bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
 }
 
 /*
- *      IO cleanup completion
+ * IO cleanup completion
  */
 static void
 bfa_tskim_cleanp_comp(void *tskim_cbarg)
@@ -3339,7 +2982,7 @@ bfa_tskim_cleanp_comp(void *tskim_cbarg)
 }
 
 /*
- *      Gather affected IO requests and task management commands.
+ * Gather affected IO requests and task management commands.
  */
 static void
 bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim)
@@ -3359,7 +3002,7 @@ bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim)
 }
 
 /*
- *      Send task management request to firmware.
+ * Send task management request to firmware.
  */
 static bfa_boolean_t
 bfa_tskim_send(struct bfa_tskim_s *tskim)
@@ -3394,7 +3037,7 @@ bfa_tskim_send(struct bfa_tskim_s *tskim)
 }
 
 /*
- *      Send abort request to cleanup an active TM to firmware.
+ * Send abort request to cleanup an active TM to firmware.
  */
 static bfa_boolean_t
 bfa_tskim_send_abort(struct bfa_tskim_s *tskim)
@@ -3425,7 +3068,7 @@ bfa_tskim_send_abort(struct bfa_tskim_s *tskim)
 }
 
 /*
- *      Call to resume task management cmnd waiting for room in request queue.
+ * Call to resume task management cmnd waiting for room in request queue.
  */
 static void
 bfa_tskim_qresume(void *cbarg)
@@ -3451,12 +3094,6 @@ bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim)
         }
 }
 
-
-
-/*
- *  hal_tskim_friend
- */
-
 /*
  * Notification on completions from related ioim.
  */
@@ -3489,7 +3126,7 @@ bfa_tskim_cleanup(struct bfa_tskim_s *tskim)
 }
 
 /*
- *      Memory allocation and initialization.
+ * Memory allocation and initialization.
  */
 void
 bfa_tskim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
@@ -3522,14 +3159,6 @@ bfa_tskim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
 }
 
 void
-bfa_tskim_detach(struct bfa_fcpim_mod_s *fcpim)
-{
-        /*
-        * @todo
-        */
-}
-
-void
 bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 {
         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
@@ -3538,7 +3167,7 @@ bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         u16     tsk_tag = be16_to_cpu(rsp->tsk_tag);
 
         tskim = BFA_TSKIM_FROM_TAG(fcpim, tsk_tag);
-        bfa_assert(tskim->tsk_tag == tsk_tag);
+        WARN_ON(tskim->tsk_tag != tsk_tag);
 
         tskim->tsk_status = rsp->tsk_status;
 
@@ -3556,12 +3185,6 @@ bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 }
 
 
-
-/*
- *  hal_tskim_api
- */
-
-
 struct bfa_tskim_s *
 bfa_tskim_alloc(struct bfa_s *bfa, struct bfad_tskim_s *dtsk)
 {
@@ -3579,13 +3202,13 @@ bfa_tskim_alloc(struct bfa_s *bfa, struct bfad_tskim_s *dtsk)
 void
 bfa_tskim_free(struct bfa_tskim_s *tskim)
 {
-        bfa_assert(bfa_q_is_on_q_func(&tskim->itnim->tsk_q, &tskim->qe));
+        WARN_ON(!bfa_q_is_on_q_func(&tskim->itnim->tsk_q, &tskim->qe));
         list_del(&tskim->qe);
         list_add_tail(&tskim->qe, &tskim->fcpim->tskim_free_q);
 }
 
 /*
- *      Start a task management command.
+ * Start a task management command.
  *
  * @param[in]   tskim   BFA task management command instance
  * @param[in]   itnim   i-t nexus for the task management command
@@ -3596,7 +3219,8 @@ bfa_tskim_free(struct bfa_tskim_s *tskim)
  * @return None.
  */
 void
-bfa_tskim_start(struct bfa_tskim_s *tskim, struct bfa_itnim_s *itnim, lun_t lun,
+bfa_tskim_start(struct bfa_tskim_s *tskim, struct bfa_itnim_s *itnim,
+                        struct scsi_lun lun,
                         enum fcp_tm_cmnd tm_cmnd, u8 tsecs)
 {
         tskim->itnim    = itnim;
diff --git a/drivers/scsi/bfa/bfa_fcpim.h b/drivers/scsi/bfa/bfa_fcpim.h
index db53717eeb4b..1e38dade8423 100644
--- a/drivers/scsi/bfa/bfa_fcpim.h
+++ b/drivers/scsi/bfa/bfa_fcpim.h
@@ -41,7 +41,7 @@
         (__itnim->ioprofile.iocomps[__index]++)
 
 #define BFA_IOIM_RETRY_TAG_OFFSET 11
-#define BFA_IOIM_RETRY_TAG_MASK 0x07ff /* 2K IOs */
+#define BFA_IOIM_IOTAG_MASK 0x07ff /* 2K IOs */
 #define BFA_IOIM_RETRY_MAX 7
 
 /* Buckets are are 512 bytes to 2MB */
@@ -94,12 +94,12 @@ struct bfa_fcpim_mod_s {
         struct list_head        ioim_resfree_q; /*  IOs waiting for f/w */
         struct list_head        ioim_comp_q;    /*  IO global comp Q    */
         struct list_head        tskim_free_q;
-        u32             ios_active;     /*  current active IOs  */
-        u32             delay_comp;
+        u32                     ios_active;     /*  current active IOs  */
+        u32                     delay_comp;
         struct bfa_fcpim_del_itn_stats_s del_itn_stats;
         bfa_boolean_t           ioredirect;
         bfa_boolean_t           io_profile;
-        u32             io_profile_start_time;
+        u32                     io_profile_start_time;
         bfa_fcpim_profile_t     profile_comp;
         bfa_fcpim_profile_t     profile_start;
 };
@@ -114,25 +114,24 @@ struct bfa_ioim_s {
         struct bfa_fcpim_mod_s  *fcpim;         /*  parent fcpim module */
         struct bfa_itnim_s      *itnim;         /*  i-t-n nexus for this IO  */
         struct bfad_ioim_s      *dio;           /*  driver IO handle    */
-        u16             iotag;          /*  FWI IO tag  */
-        u16             abort_tag;      /*  unqiue abort request tag */
-        u16             nsges;          /*  number of SG elements */
-        u16             nsgpgs;         /*  number of SG pages  */
+        u16                     iotag;          /*  FWI IO tag  */
+        u16                     abort_tag;      /*  unqiue abort request tag */
+        u16                     nsges;          /*  number of SG elements */
+        u16                     nsgpgs;         /*  number of SG pages  */
         struct bfa_sgpg_s       *sgpg;          /*  first SG page       */
         struct list_head        sgpg_q;         /*  allocated SG pages  */
         struct bfa_cb_qe_s      hcb_qe;         /*  bfa callback qelem  */
         bfa_cb_cbfn_t           io_cbfn;        /*  IO completion handler */
-        struct bfa_ioim_sp_s *iosp;             /*  slow-path IO handling */
-        u8              reqq;           /*  Request queue for I/O */
-        u64 start_time;                 /*  IO's Profile start val */
+        struct bfa_ioim_sp_s    *iosp;          /*  slow-path IO handling */
+        u8                      reqq;           /*  Request queue for I/O */
+        u64                     start_time;     /*  IO's Profile start val */
 };
 
-
 struct bfa_ioim_sp_s {
         struct bfi_msg_s        comp_rspmsg;    /*  IO comp f/w response */
         u8                      *snsinfo;       /*  sense info for this IO   */
-        struct bfa_sgpg_wqe_s sgpg_wqe; /*  waitq elem for sgpg */
-        struct bfa_reqq_wait_s reqq_wait;       /*  to wait for room in reqq */
+        struct bfa_sgpg_wqe_s   sgpg_wqe;       /*  waitq elem for sgpg */
+        struct bfa_reqq_wait_s  reqq_wait;      /*  to wait for room in reqq */
         bfa_boolean_t           abort_explicit; /*  aborted by OS       */
         struct bfa_tskim_s      *tskim;         /*  Relevant TM cmd     */
 };
@@ -143,35 +142,34 @@ struct bfa_ioim_sp_s {
 struct bfa_tskim_s {
         struct list_head        qe;
         bfa_sm_t                sm;
-        struct bfa_s    *bfa;   /*  BFA module  */
+        struct bfa_s            *bfa;   /*  BFA module  */
         struct bfa_fcpim_mod_s  *fcpim; /*  parent fcpim module */
         struct bfa_itnim_s      *itnim; /*  i-t-n nexus for this IO  */
-        struct bfad_tskim_s     *dtsk;   /*  driver task mgmt cmnd      */
-        bfa_boolean_t   notify; /*  notify itnim on TM comp  */
-        lun_t   lun;    /*  lun if applicable   */
-        enum fcp_tm_cmnd        tm_cmnd;        /*  task management command  */
-        u16     tsk_tag;        /*  FWI IO tag  */
-        u8      tsecs;  /*  timeout in seconds  */
+        struct bfad_tskim_s     *dtsk;  /*  driver task mgmt cmnd       */
+        bfa_boolean_t           notify; /*  notify itnim on TM comp  */
+        struct scsi_lun         lun;    /*  lun if applicable   */
+        enum fcp_tm_cmnd        tm_cmnd; /*  task management command  */
+        u16                     tsk_tag; /*  FWI IO tag */
+        u8                      tsecs;  /*  timeout in seconds  */
         struct bfa_reqq_wait_s  reqq_wait;   /*  to wait for room in reqq */
         struct list_head        io_q;   /*  queue of affected IOs       */
-        struct bfa_wc_s wc;     /*  waiting counter     */
+        struct bfa_wc_s         wc;     /*  waiting counter     */
         struct bfa_cb_qe_s      hcb_qe; /*  bfa callback qelem  */
         enum bfi_tskim_status   tsk_status;  /*  TM status      */
 };
 
-
 /*
  * BFA i-t-n (initiator mode)
  */
 struct bfa_itnim_s {
-        struct list_head        qe;             /*  queue element       */
-        bfa_sm_t          sm;           /*  i-t-n im BFA state machine  */
-        struct bfa_s    *bfa;           /*  bfa instance        */
-        struct bfa_rport_s *rport;      /*  bfa rport   */
-        void    *ditn;          /*  driver i-t-n structure      */
+        struct list_head        qe;     /*  queue element       */
+        bfa_sm_t                sm;     /*  i-t-n im BFA state machine  */
+        struct bfa_s            *bfa;   /*  bfa instance        */
+        struct bfa_rport_s      *rport; /*  bfa rport   */
+        void                    *ditn;  /*  driver i-t-n structure      */
         struct bfi_mhdr_s       mhdr;   /*  pre-built mhdr      */
-        u8      msg_no;         /*  itnim/rport firmware handle */
-        u8      reqq;           /*  CQ for requests     */
+        u8                      msg_no; /*  itnim/rport firmware handle */
+        u8                      reqq;   /*  CQ for requests     */
         struct bfa_cb_qe_s      hcb_qe; /*  bfa callback qelem  */
         struct list_head pending_q;     /*  queue of pending IO requests */
         struct list_head io_q;          /*  queue of active IO requests */
@@ -181,19 +179,19 @@ struct bfa_itnim_s {
         bfa_boolean_t   seq_rec;        /*  SQER supported      */
         bfa_boolean_t   is_online;      /*  itnim is ONLINE for IO      */
         bfa_boolean_t   iotov_active;   /*  IO TOV timer is active       */
-        struct bfa_wc_s wc;     /*  waiting counter     */
-        struct bfa_timer_s timer;       /*  pending IO TOV               */
+        struct bfa_wc_s wc;             /*  waiting counter     */
+        struct bfa_timer_s timer;       /*  pending IO TOV       */
         struct bfa_reqq_wait_s reqq_wait; /*  to wait for room in reqq */
         struct bfa_fcpim_mod_s *fcpim;  /*  fcpim module        */
         struct bfa_itnim_iostats_s      stats;
         struct bfa_itnim_ioprofile_s  ioprofile;
 };
 
-
 #define bfa_itnim_is_online(_itnim) ((_itnim)->is_online)
 #define BFA_FCPIM_MOD(_hal) (&(_hal)->modules.fcpim_mod)
+#define BFA_IOIM_TAG_2_ID(_iotag)       ((_iotag) & BFA_IOIM_IOTAG_MASK)
 #define BFA_IOIM_FROM_TAG(_fcpim, _iotag)       \
-        (&fcpim->ioim_arr[(_iotag & BFA_IOIM_RETRY_TAG_MASK)])
+        (&fcpim->ioim_arr[(_iotag & BFA_IOIM_IOTAG_MASK)])
 #define BFA_TSKIM_FROM_TAG(_fcpim, _tmtag)      \
         (&fcpim->tskim_arr[_tmtag & (fcpim->num_tskim_reqs - 1)])
 
@@ -201,26 +199,26 @@ struct bfa_itnim_s {
         (_bfa->modules.fcpim_mod.io_profile_start_time)
 #define bfa_fcpim_get_io_profile(_bfa)  \
         (_bfa->modules.fcpim_mod.io_profile)
+#define bfa_ioim_update_iotag(__ioim) do {                              \
+        uint16_t k = (__ioim)->iotag >> BFA_IOIM_RETRY_TAG_OFFSET;      \
+        k++; (__ioim)->iotag &= BFA_IOIM_IOTAG_MASK;                    \
+        (__ioim)->iotag |= k << BFA_IOIM_RETRY_TAG_OFFSET;              \
+} while (0)
 
 static inline bfa_boolean_t
-bfa_ioim_get_iotag(struct bfa_ioim_s *ioim)
+bfa_ioim_maxretry_reached(struct bfa_ioim_s *ioim)
 {
-        u16 k = ioim->iotag;
-
-        k >>= BFA_IOIM_RETRY_TAG_OFFSET; k++;
-
-        if (k > BFA_IOIM_RETRY_MAX)
+        uint16_t k = ioim->iotag >> BFA_IOIM_RETRY_TAG_OFFSET;
+        if (k < BFA_IOIM_RETRY_MAX)
                 return BFA_FALSE;
-        ioim->iotag &= BFA_IOIM_RETRY_TAG_MASK;
-        ioim->iotag |= k<<BFA_IOIM_RETRY_TAG_OFFSET;
         return BFA_TRUE;
 }
+
 /*
  * function prototypes
  */
 void    bfa_ioim_attach(struct bfa_fcpim_mod_s *fcpim,
                                         struct bfa_meminfo_s *minfo);
-void    bfa_ioim_detach(struct bfa_fcpim_mod_s *fcpim);
 void    bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
 void    bfa_ioim_good_comp_isr(struct bfa_s *bfa,
                                         struct bfi_msg_s *msg);
@@ -232,7 +230,6 @@ void	bfa_ioim_tov(struct bfa_ioim_s *ioim);
 
 void    bfa_tskim_attach(struct bfa_fcpim_mod_s *fcpim,
                                         struct bfa_meminfo_s *minfo);
-void    bfa_tskim_detach(struct bfa_fcpim_mod_s *fcpim);
 void    bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
 void    bfa_tskim_iodone(struct bfa_tskim_s *tskim);
 void    bfa_tskim_iocdisable(struct bfa_tskim_s *tskim);
@@ -248,32 +245,14 @@ void	bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
 void    bfa_itnim_iodone(struct bfa_itnim_s *itnim);
 void    bfa_itnim_tskdone(struct bfa_itnim_s *itnim);
 bfa_boolean_t   bfa_itnim_hold_io(struct bfa_itnim_s *itnim);
-void bfa_ioim_profile_comp(struct bfa_ioim_s *ioim);
-void bfa_ioim_profile_start(struct bfa_ioim_s *ioim);
-
 
 /*
  * bfa fcpim module API functions
  */
-void            bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov);
+void    bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov);
 u16     bfa_fcpim_path_tov_get(struct bfa_s *bfa);
-void            bfa_fcpim_qdepth_set(struct bfa_s *bfa, u16 q_depth);
 u16     bfa_fcpim_qdepth_get(struct bfa_s *bfa);
-bfa_status_t bfa_fcpim_get_modstats(struct bfa_s *bfa,
-         struct bfa_itnim_iostats_s *modstats);
-bfa_status_t bfa_fcpim_port_iostats(struct bfa_s *bfa,
-                struct bfa_itnim_iostats_s *stats, u8 lp_tag);
-bfa_status_t bfa_fcpim_get_del_itn_stats(struct bfa_s *bfa,
-         struct bfa_fcpim_del_itn_stats_s *modstats);
-bfa_status_t bfa_fcpim_port_clear_iostats(struct bfa_s *bfa, u8 lp_tag);
-void bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *fcpim_stats,
-                struct bfa_itnim_iostats_s *itnim_stats);
-bfa_status_t bfa_fcpim_clr_modstats(struct bfa_s *bfa);
-void            bfa_fcpim_set_ioredirect(struct bfa_s *bfa,
-                                bfa_boolean_t state);
-void            bfa_fcpim_update_ioredirect(struct bfa_s *bfa);
-bfa_status_t bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time);
-bfa_status_t bfa_fcpim_profile_off(struct bfa_s *bfa);
+
 #define bfa_fcpim_ioredirect_enabled(__bfa)                             \
         (((struct bfa_fcpim_mod_s *)(BFA_FCPIM_MOD(__bfa)))->ioredirect)
 
@@ -291,48 +270,33 @@ bfa_status_t bfa_fcpim_profile_off(struct bfa_s *bfa);
  * bfa itnim API functions
  */
 struct bfa_itnim_s *bfa_itnim_create(struct bfa_s *bfa,
-                                        struct bfa_rport_s *rport, void *itnim);
-void            bfa_itnim_delete(struct bfa_itnim_s *itnim);
-void            bfa_itnim_online(struct bfa_itnim_s *itnim,
-                                 bfa_boolean_t seq_rec);
-void            bfa_itnim_offline(struct bfa_itnim_s *itnim);
-void            bfa_itnim_get_stats(struct bfa_itnim_s *itnim,
-                        struct bfa_itnim_iostats_s *stats);
-void            bfa_itnim_clear_stats(struct bfa_itnim_s *itnim);
-bfa_status_t    bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
-                struct bfa_itnim_ioprofile_s *ioprofile);
+                struct bfa_rport_s *rport, void *itnim);
+void bfa_itnim_delete(struct bfa_itnim_s *itnim);
+void bfa_itnim_online(struct bfa_itnim_s *itnim, bfa_boolean_t seq_rec);
+void bfa_itnim_offline(struct bfa_itnim_s *itnim);
+void bfa_itnim_clear_stats(struct bfa_itnim_s *itnim);
+bfa_status_t bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
+                        struct bfa_itnim_ioprofile_s *ioprofile);
+
 #define bfa_itnim_get_reqq(__ioim) (((struct bfa_ioim_s *)__ioim)->itnim->reqq)
 
 /*
- *      BFA completion callback for bfa_itnim_online().
- *
- * @param[in]           itnim           FCS or driver itnim instance
- *
- * return None
+ * BFA completion callback for bfa_itnim_online().
  */
 void    bfa_cb_itnim_online(void *itnim);
 
 /*
- *      BFA completion callback for bfa_itnim_offline().
- *
- * @param[in]           itnim           FCS or driver itnim instance
- *
- * return None
+ * BFA completion callback for bfa_itnim_offline().
  */
 void    bfa_cb_itnim_offline(void *itnim);
 void    bfa_cb_itnim_tov_begin(void *itnim);
 void    bfa_cb_itnim_tov(void *itnim);
 
 /*
- *      BFA notification to FCS/driver for second level error recovery.
- *
+ * BFA notification to FCS/driver for second level error recovery.
  * Atleast one I/O request has timedout and target is unresponsive to
  * repeated abort requests. Second level error recovery should be initiated
  * by starting implicit logout and recovery procedures.
- *
- * @param[in]           itnim           FCS or driver itnim instance
- *
- * return None
  */
 void    bfa_cb_itnim_sler(void *itnim);
 
@@ -349,10 +313,8 @@ void		bfa_ioim_start(struct bfa_ioim_s *ioim);
 bfa_status_t    bfa_ioim_abort(struct bfa_ioim_s *ioim);
 void            bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim,
                                       bfa_boolean_t iotov);
-
-
 /*
- *      I/O completion notification.
+ * I/O completion notification.
  *
  * @param[in]           dio                     driver IO structure
  * @param[in]           io_status               IO completion status
@@ -363,39 +325,31 @@ void		bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim,
  *
  * @return None
  */
-void    bfa_cb_ioim_done(void *bfad, struct bfad_ioim_s *dio,
-                                  enum bfi_ioim_status io_status,
-                                  u8 scsi_status, int sns_len,
-                                  u8 *sns_info, s32 residue);
+void bfa_cb_ioim_done(void *bfad, struct bfad_ioim_s *dio,
+                        enum bfi_ioim_status io_status,
+                        u8 scsi_status, int sns_len,
+                        u8 *sns_info, s32 residue);
 
 /*
- *      I/O good completion notification.
- *
- * @param[in]           dio                     driver IO structure
- *
- * @return None
+ * I/O good completion notification.
  */
-void    bfa_cb_ioim_good_comp(void *bfad, struct bfad_ioim_s *dio);
+void bfa_cb_ioim_good_comp(void *bfad, struct bfad_ioim_s *dio);
 
 /*
- *      I/O abort completion notification
- *
- * @param[in]           dio                     driver IO that was aborted
- *
- * @return None
+ * I/O abort completion notification
  */
-void    bfa_cb_ioim_abort(void *bfad, struct bfad_ioim_s *dio);
+void bfa_cb_ioim_abort(void *bfad, struct bfad_ioim_s *dio);
 
 /*
  * bfa tskim API functions
  */
-struct bfa_tskim_s      *bfa_tskim_alloc(struct bfa_s *bfa,
-                                        struct bfad_tskim_s *dtsk);
-void            bfa_tskim_free(struct bfa_tskim_s *tskim);
-void            bfa_tskim_start(struct bfa_tskim_s *tskim,
-                                struct bfa_itnim_s *itnim, lun_t lun,
-                                enum fcp_tm_cmnd tm, u8 t_secs);
-void            bfa_cb_tskim_done(void *bfad, struct bfad_tskim_s *dtsk,
-                                  enum bfi_tskim_status tsk_status);
+struct bfa_tskim_s *bfa_tskim_alloc(struct bfa_s *bfa,
+                        struct bfad_tskim_s *dtsk);
+void bfa_tskim_free(struct bfa_tskim_s *tskim);
+void bfa_tskim_start(struct bfa_tskim_s *tskim,
+                        struct bfa_itnim_s *itnim, struct scsi_lun lun,
+                        enum fcp_tm_cmnd tm, u8 t_secs);
+void bfa_cb_tskim_done(void *bfad, struct bfad_tskim_s *dtsk,
+                        enum bfi_tskim_status tsk_status);
 
 #endif /* __BFA_FCPIM_H__ */
diff --git a/drivers/scsi/bfa/bfa_fcs.c b/drivers/scsi/bfa/bfa_fcs.c
index 045d7e87b632..f674f9318629 100644
--- a/drivers/scsi/bfa/bfa_fcs.c
+++ b/drivers/scsi/bfa/bfa_fcs.c
@@ -19,9 +19,9 @@
  *  bfa_fcs.c BFA FCS main
  */
 
+#include "bfad_drv.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
-#include "bfad_drv.h"
 
 BFA_TRC_FILE(FCS, FCS);
 
@@ -76,7 +76,7 @@ bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
         fcs->bfad = bfad;
         fcs->min_cfg = min_cfg;
 
-        bfa_attach_fcs(bfa);
+        bfa->fcs = BFA_TRUE;
         fcbuild_init();
 
         for (i = 0; i < sizeof(fcs_modules) / sizeof(fcs_modules[0]); i++) {
@@ -110,14 +110,6 @@ bfa_fcs_init(struct bfa_fcs_s *fcs)
         }
 }
 
-/*
- * Start FCS operations.
- */
-void
-bfa_fcs_start(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_fabric_modstart(fcs);
-}
 
 /*
  *      brief
@@ -140,22 +132,6 @@ bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
 
 /*
  *      brief
- *              FCS FDMI Driver Parameter Initialization
- *
- *      param[in]               fcs             FCS instance
- *      param[in]               fdmi_enable     TRUE/FALSE
- *
- *      return None
- */
-void
-bfa_fcs_set_fdmi_param(struct bfa_fcs_s *fcs, bfa_boolean_t fdmi_enable)
-{
-
-        fcs->fdmi_enabled = fdmi_enable;
-
-}
-/*
- *      brief
  *              FCS instance cleanup and exit.
  *
  *      param[in]               fcs                     FCS instance
@@ -184,18 +160,6 @@ bfa_fcs_exit(struct bfa_fcs_s *fcs)
 }
 
 
-void
-bfa_fcs_trc_init(struct bfa_fcs_s *fcs, struct bfa_trc_mod_s *trcmod)
-{
-        fcs->trcmod = trcmod;
-}
-
-void
-bfa_fcs_modexit_comp(struct bfa_fcs_s *fcs)
-{
-        bfa_wc_down(&fcs->wc);
-}
-
 /*
  * Fabric module implementation.
  */
@@ -232,31 +196,6 @@ static void bfa_fcs_fabric_flogiacc_comp(void *fcsarg,
                                          u32 rsp_len,
                                          u32 resid_len,
                                          struct fchs_s *rspfchs);
-/*
- *  fcs_fabric_sm fabric state machine functions
- */
-
-/*
- * Fabric state machine events
- */
-enum bfa_fcs_fabric_event {
-        BFA_FCS_FABRIC_SM_CREATE        = 1,    /*  create from driver        */
-        BFA_FCS_FABRIC_SM_DELETE        = 2,    /*  delete from driver        */
-        BFA_FCS_FABRIC_SM_LINK_DOWN     = 3,    /*  link down from port      */
-        BFA_FCS_FABRIC_SM_LINK_UP       = 4,    /*  link up from port         */
-        BFA_FCS_FABRIC_SM_CONT_OP       = 5,    /*  flogi/auth continue op   */
-        BFA_FCS_FABRIC_SM_RETRY_OP      = 6,    /*  flogi/auth retry op      */
-        BFA_FCS_FABRIC_SM_NO_FABRIC     = 7,    /*  from flogi/auth           */
-        BFA_FCS_FABRIC_SM_PERF_EVFP     = 8,    /*  from flogi/auth           */
-        BFA_FCS_FABRIC_SM_ISOLATE       = 9,    /*  from EVFP processing     */
-        BFA_FCS_FABRIC_SM_NO_TAGGING    = 10,   /*  no VFT tagging from EVFP */
-        BFA_FCS_FABRIC_SM_DELAYED       = 11,   /*  timeout delay event      */
-        BFA_FCS_FABRIC_SM_AUTH_FAILED   = 12,   /*  auth failed       */
-        BFA_FCS_FABRIC_SM_AUTH_SUCCESS  = 13,   /*  auth successful           */
-        BFA_FCS_FABRIC_SM_DELCOMP       = 14,   /*  all vports deleted event */
-        BFA_FCS_FABRIC_SM_LOOPBACK      = 15,   /*  Received our own FLOGI   */
-        BFA_FCS_FABRIC_SM_START         = 16,   /*  from driver       */
-};
 
 static void     bfa_fcs_fabric_sm_uninit(struct bfa_fcs_fabric_s *fabric,
                                          enum bfa_fcs_fabric_event event);
@@ -270,14 +209,8 @@ static void	bfa_fcs_fabric_sm_flogi_retry(struct bfa_fcs_fabric_s *fabric,
                                               enum bfa_fcs_fabric_event event);
 static void     bfa_fcs_fabric_sm_auth(struct bfa_fcs_fabric_s *fabric,
                                        enum bfa_fcs_fabric_event event);
-static void     bfa_fcs_fabric_sm_auth_failed(struct bfa_fcs_fabric_s *fabric,
-                                              enum bfa_fcs_fabric_event event);
-static void     bfa_fcs_fabric_sm_loopback(struct bfa_fcs_fabric_s *fabric,
-                                           enum bfa_fcs_fabric_event event);
 static void     bfa_fcs_fabric_sm_nofabric(struct bfa_fcs_fabric_s *fabric,
                                            enum bfa_fcs_fabric_event event);
-static void     bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
-                                         enum bfa_fcs_fabric_event event);
 static void     bfa_fcs_fabric_sm_evfp(struct bfa_fcs_fabric_s *fabric,
                                        enum bfa_fcs_fabric_event event);
 static void     bfa_fcs_fabric_sm_evfp_done(struct bfa_fcs_fabric_s *fabric,
@@ -337,7 +270,7 @@ bfa_fcs_fabric_sm_created(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_DELETE:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_uninit);
-                bfa_fcs_modexit_comp(fabric->fcs);
+                bfa_wc_down(&fabric->fcs->wc);
                 break;
 
         default:
@@ -410,7 +343,7 @@ bfa_fcs_fabric_sm_flogi(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_LOOPBACK:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_loopback);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 bfa_fcs_fabric_set_opertype(fabric);
                 break;
 
@@ -424,12 +357,12 @@ bfa_fcs_fabric_sm_flogi(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_LINK_DOWN:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 break;
 
         case BFA_FCS_FABRIC_SM_DELETE:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_deleting);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 bfa_fcs_fabric_delete(fabric);
                 break;
 
@@ -481,7 +414,7 @@ bfa_fcs_fabric_sm_auth(struct bfa_fcs_fabric_s *fabric,
         switch (event) {
         case BFA_FCS_FABRIC_SM_AUTH_FAILED:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_auth_failed);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 break;
 
         case BFA_FCS_FABRIC_SM_AUTH_SUCCESS:
@@ -495,7 +428,7 @@ bfa_fcs_fabric_sm_auth(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_LINK_DOWN:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 break;
 
         case BFA_FCS_FABRIC_SM_DELETE:
@@ -511,7 +444,7 @@ bfa_fcs_fabric_sm_auth(struct bfa_fcs_fabric_s *fabric,
 /*
  *   Authentication failed
  */
-static void
+void
 bfa_fcs_fabric_sm_auth_failed(struct bfa_fcs_fabric_s *fabric,
                               enum bfa_fcs_fabric_event event)
 {
@@ -537,7 +470,7 @@ bfa_fcs_fabric_sm_auth_failed(struct bfa_fcs_fabric_s *fabric,
 /*
  *   Port is in loopback mode.
  */
-static void
+void
 bfa_fcs_fabric_sm_loopback(struct bfa_fcs_fabric_s *fabric,
                            enum bfa_fcs_fabric_event event)
 {
@@ -573,7 +506,7 @@ bfa_fcs_fabric_sm_nofabric(struct bfa_fcs_fabric_s *fabric,
         switch (event) {
         case BFA_FCS_FABRIC_SM_LINK_DOWN:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 bfa_fcs_fabric_notify_offline(fabric);
                 break;
 
@@ -596,7 +529,7 @@ bfa_fcs_fabric_sm_nofabric(struct bfa_fcs_fabric_s *fabric,
 /*
  *   Fabric is online - normal operating state.
  */
-static void
+void
 bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
                          enum bfa_fcs_fabric_event event)
 {
@@ -606,7 +539,7 @@ bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
         switch (event) {
         case BFA_FCS_FABRIC_SM_LINK_DOWN:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_linkdown);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 bfa_fcs_fabric_notify_offline(fabric);
                 break;
 
@@ -617,7 +550,7 @@ bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_AUTH_FAILED:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_auth_failed);
-                bfa_lps_discard(fabric->lps);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
                 break;
 
         case BFA_FCS_FABRIC_SM_AUTH_SUCCESS:
@@ -697,7 +630,7 @@ bfa_fcs_fabric_sm_deleting(struct bfa_fcs_fabric_s *fabric,
         switch (event) {
         case BFA_FCS_FABRIC_SM_DELCOMP:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_uninit);
-                bfa_fcs_modexit_comp(fabric->fcs);
+                bfa_wc_down(&fabric->fcs->wc);
                 break;
 
         case BFA_FCS_FABRIC_SM_LINK_UP:
@@ -724,8 +657,8 @@ bfa_fcs_fabric_init(struct bfa_fcs_fabric_s *fabric)
         struct bfa_lport_cfg_s *port_cfg = &fabric->bport.port_cfg;
 
         port_cfg->roles = BFA_LPORT_ROLE_FCP_IM;
-        port_cfg->nwwn = bfa_ioc_get_nwwn(&fabric->fcs->bfa->ioc);
-        port_cfg->pwwn = bfa_ioc_get_pwwn(&fabric->fcs->bfa->ioc);
+        port_cfg->nwwn = fabric->fcs->bfa->ioc.attr->nwwn;
+        port_cfg->pwwn = fabric->fcs->bfa->ioc.attr->pwwn;
 }
 
 /*
@@ -813,7 +746,7 @@ bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status)
                 return;
 
         case BFA_STATUS_EPROTOCOL:
-                switch (bfa_lps_get_extstatus(fabric->lps)) {
+                switch (fabric->lps->ext_status) {
                 case BFA_EPROTO_BAD_ACCEPT:
                         fabric->stats.flogi_acc_err++;
                         break;
@@ -840,26 +773,26 @@ bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status)
                 return;
         }
 
-        fabric->bb_credit = bfa_lps_get_peer_bbcredit(fabric->lps);
+        fabric->bb_credit = fabric->lps->pr_bbcred;
         bfa_trc(fabric->fcs, fabric->bb_credit);
 
-        if (!bfa_lps_is_brcd_fabric(fabric->lps))
-                fabric->fabric_name =  bfa_lps_get_peer_nwwn(fabric->lps);
+        if (!(fabric->lps->brcd_switch))
+                fabric->fabric_name =  fabric->lps->pr_nwwn;
 
         /*
          * Check port type. It should be 1 = F-port.
          */
-        if (bfa_lps_is_fport(fabric->lps)) {
-                fabric->bport.pid = bfa_lps_get_pid(fabric->lps);
-                fabric->is_npiv = bfa_lps_is_npiv_en(fabric->lps);
-                fabric->is_auth = bfa_lps_is_authreq(fabric->lps);
+        if (fabric->lps->fport) {
+                fabric->bport.pid = fabric->lps->lp_pid;
+                fabric->is_npiv = fabric->lps->npiv_en;
+                fabric->is_auth = fabric->lps->auth_req;
                 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_CONT_OP);
         } else {
                 /*
                  * Nport-2-Nport direct attached
                  */
                 fabric->bport.port_topo.pn2n.rem_port_wwn =
-                        bfa_lps_get_peer_pwwn(fabric->lps);
+                        fabric->lps->pr_pwwn;
                 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_NO_FABRIC);
         }
 
@@ -987,7 +920,7 @@ bfa_fcs_fabric_attach(struct bfa_fcs_s *fcs)
         INIT_LIST_HEAD(&fabric->vport_q);
         INIT_LIST_HEAD(&fabric->vf_q);
         fabric->lps = bfa_lps_alloc(fcs->bfa);
-        bfa_assert(fabric->lps);
+        WARN_ON(!fabric->lps);
 
         /*
          * Initialize fabric delete completion handler. Fabric deletion is
@@ -1038,31 +971,6 @@ bfa_fcs_fabric_modstart(struct bfa_fcs_s *fcs)
         bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_START);
 }
 
-/*
- *   Suspend fabric activity as part of driver suspend.
- */
-void
-bfa_fcs_fabric_modsusp(struct bfa_fcs_s *fcs)
-{
-}
-
-bfa_boolean_t
-bfa_fcs_fabric_is_loopback(struct bfa_fcs_fabric_s *fabric)
-{
-        return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_loopback);
-}
-
-bfa_boolean_t
-bfa_fcs_fabric_is_auth_failed(struct bfa_fcs_fabric_s *fabric)
-{
-        return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_auth_failed);
-}
-
-enum bfa_port_type
-bfa_fcs_fabric_port_type(struct bfa_fcs_fabric_s *fabric)
-{
-        return fabric->oper_type;
-}
 
 /*
  *   Link up notification from BFA physical port module.
@@ -1123,40 +1031,6 @@ bfa_fcs_fabric_delvport(struct bfa_fcs_fabric_s *fabric,
         bfa_wc_down(&fabric->wc);
 }
 
-/*
- *   Base port is deleted.
- */
-void
-bfa_fcs_fabric_port_delete_comp(struct bfa_fcs_fabric_s *fabric)
-{
-        bfa_wc_down(&fabric->wc);
-}
-
-
-/*
- *    Check if fabric is online.
- *
- *   param[in] fabric - Fabric instance. This can be a base fabric or vf.
- *
- *   @return  TRUE/FALSE
- */
-int
-bfa_fcs_fabric_is_online(struct bfa_fcs_fabric_s *fabric)
-{
-        return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_online);
-}
-
-/*
- *      brief
- *
- */
-bfa_status_t
-bfa_fcs_fabric_addvf(struct bfa_fcs_fabric_s *vf, struct bfa_fcs_s *fcs,
-                     struct bfa_lport_cfg_s *port_cfg, struct bfad_vf_s *vf_drv)
-{
-        bfa_sm_set_state(vf, bfa_fcs_fabric_sm_uninit);
-        return BFA_STATUS_OK;
-}
 
 /*
  * Lookup for a vport withing a fabric given its pwwn
@@ -1176,18 +1050,6 @@ bfa_fcs_fabric_vport_lookup(struct bfa_fcs_fabric_s *fabric, wwn_t pwwn)
         return NULL;
 }
 
-/*
- *    In a given fabric, return the number of lports.
- *
- *   param[in] fabric - Fabric instance. This can be a base fabric or vf.
- *
- *   @return : 1 or more.
- */
-u16
-bfa_fcs_fabric_vport_count(struct bfa_fcs_fabric_s *fabric)
-{
-        return fabric->num_vports;
-}
 
 /*
  *  Get OUI of the attached switch.
@@ -1207,7 +1069,7 @@ bfa_fcs_fabric_get_switch_oui(struct bfa_fcs_fabric_s *fabric)
         u8 *tmp;
         u16 oui;
 
-        fab_nwwn = bfa_lps_get_peer_nwwn(fabric->lps);
+        fab_nwwn = fabric->lps->pr_nwwn;
 
         tmp = (u8 *)&fab_nwwn;
         oui = (tmp[3] << 8) | tmp[4];
@@ -1235,7 +1097,7 @@ bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric, struct fchs_s *fchs,
          * external loopback cable is in place. Our own FLOGI frames are
          * sometimes looped back when switch port gets temporarily bypassed.
          */
-        if ((pid == bfa_os_ntoh3b(FC_FABRIC_PORT)) &&
+        if ((pid == bfa_ntoh3b(FC_FABRIC_PORT)) &&
             (els_cmd->els_code == FC_ELS_FLOGI) &&
             (flogi->port_name == bfa_fcs_lport_get_pwwn(&fabric->bport))) {
                 bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_LOOPBACK);
@@ -1245,7 +1107,7 @@ bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric, struct fchs_s *fchs,
         /*
          * FLOGI/EVFP exchanges should be consumed by base fabric.
          */
-        if (fchs->d_id == bfa_os_hton3b(FC_FABRIC_PORT)) {
+        if (fchs->d_id == bfa_hton3b(FC_FABRIC_PORT)) {
                 bfa_trc(fabric->fcs, pid);
                 bfa_fcs_fabric_process_uf(fabric, fchs, len);
                 return;
@@ -1358,13 +1220,13 @@ bfa_fcs_fabric_send_flogi_acc(struct bfa_fcs_fabric_s *fabric)
                 return;
 
         reqlen = fc_flogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
-                                    bfa_os_hton3b(FC_FABRIC_PORT),
+                                    bfa_hton3b(FC_FABRIC_PORT),
                                     n2n_port->reply_oxid, pcfg->pwwn,
                                     pcfg->nwwn,
                                     bfa_fcport_get_maxfrsize(bfa),
                                     bfa_fcport_get_rx_bbcredit(bfa));
 
-        bfa_fcxp_send(fcxp, NULL, fabric->vf_id, bfa_lps_get_tag(fabric->lps),
+        bfa_fcxp_send(fcxp, NULL, fabric->vf_id, fabric->lps->lp_tag,
                       BFA_FALSE, FC_CLASS_3,
                       reqlen, &fchs, bfa_fcs_fabric_flogiacc_comp, fabric,
                       FC_MAX_PDUSZ, 0);
@@ -1455,7 +1317,7 @@ bfa_fcs_port_event_handler(void *cbarg, enum bfa_port_linkstate event)
                 break;
 
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -1502,7 +1364,7 @@ bfa_fcs_uf_recv(void *cbarg, struct bfa_uf_s *uf)
                  * drop frame if vfid is unknown
                  */
                 if (!fabric) {
-                        bfa_assert(0);
+                        WARN_ON(1);
                         bfa_stats(fcs, uf.vfid_unknown);
                         bfa_uf_free(uf);
                         return;
diff --git a/drivers/scsi/bfa/bfa_fcs.h b/drivers/scsi/bfa/bfa_fcs.h
index 9cb6a55977c3..0fd63168573f 100644
--- a/drivers/scsi/bfa/bfa_fcs.h
+++ b/drivers/scsi/bfa/bfa_fcs.h
@@ -27,6 +27,22 @@
 #define BFA_FCS_OS_STR_LEN              64
 
 /*
+ *  lps_pvt BFA LPS private functions
+ */
+
+enum bfa_lps_event {
+        BFA_LPS_SM_LOGIN        = 1,    /* login request from user      */
+        BFA_LPS_SM_LOGOUT       = 2,    /* logout request from user     */
+        BFA_LPS_SM_FWRSP        = 3,    /* f/w response to login/logout */
+        BFA_LPS_SM_RESUME       = 4,    /* space present in reqq queue  */
+        BFA_LPS_SM_DELETE       = 5,    /* lps delete from user         */
+        BFA_LPS_SM_OFFLINE      = 6,    /* Link is offline              */
+        BFA_LPS_SM_RX_CVL       = 7,    /* Rx clear virtual link        */
+        BFA_LPS_SM_SET_N2N_PID  = 8,    /* Set assigned PID for n2n */
+};
+
+
+/*
  * !!! Only append to the enums defined here to avoid any versioning
  * !!! needed between trace utility and driver version
  */
@@ -41,13 +57,12 @@ enum {
 struct bfa_fcs_s;
 
 #define __fcs_min_cfg(__fcs)       ((__fcs)->min_cfg)
-void bfa_fcs_modexit_comp(struct bfa_fcs_s *fcs);
 
 #define BFA_FCS_BRCD_SWITCH_OUI  0x051e
 #define N2N_LOCAL_PID       0x010000
 #define N2N_REMOTE_PID          0x020000
 #define BFA_FCS_RETRY_TIMEOUT 2000
-#define BFA_FCS_PID_IS_WKA(pid)  ((bfa_os_ntoh3b(pid) > 0xFFF000) ?  1 : 0)
+#define BFA_FCS_PID_IS_WKA(pid)  ((bfa_ntoh3b(pid) > 0xFFF000) ?  1 : 0)
 
 
 
@@ -109,7 +124,7 @@ struct bfa_fcs_lport_loop_s {
 
 struct bfa_fcs_lport_n2n_s {
         u32        rsvd;
-        u16        reply_oxid;  /*  ox_id from the req flogi to be
+        __be16     reply_oxid;  /*  ox_id from the req flogi to be
                                          *used in flogi acc */
         wwn_t           rem_port_wwn;   /*  Attached port's wwn */
 };
@@ -316,8 +331,6 @@ void            bfa_fcs_lport_add_rport(struct bfa_fcs_lport_s *port,
                                        struct bfa_fcs_rport_s *rport);
 void            bfa_fcs_lport_del_rport(struct bfa_fcs_lport_s *port,
                                        struct bfa_fcs_rport_s *rport);
-void bfa_fcs_lport_modinit(struct bfa_fcs_s *fcs);
-void bfa_fcs_lport_modexit(struct bfa_fcs_s *fcs);
 void            bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *vport);
@@ -359,9 +372,6 @@ bfa_status_t bfa_fcs_vport_start(struct bfa_fcs_vport_s *vport);
 bfa_status_t bfa_fcs_vport_stop(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_get_attr(struct bfa_fcs_vport_s *vport,
                             struct bfa_vport_attr_s *vport_attr);
-void bfa_fcs_vport_get_stats(struct bfa_fcs_vport_s *vport,
-                             struct bfa_vport_stats_s *vport_stats);
-void bfa_fcs_vport_clr_stats(struct bfa_fcs_vport_s *vport);
 struct bfa_fcs_vport_s *bfa_fcs_vport_lookup(struct bfa_fcs_s *fcs,
                                              u16 vf_id, wwn_t vpwwn);
 void bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport);
@@ -406,7 +416,7 @@ struct bfa_fcs_rport_s {
         struct bfad_rport_s     *rp_drv;        /*  driver peer instance */
         u32     pid;    /*  port ID of rport */
         u16     maxfrsize;      /*  maximum frame size */
-        u16     reply_oxid;     /*  OX_ID of inbound requests */
+        __be16  reply_oxid;     /*  OX_ID of inbound requests */
         enum fc_cos     fc_cos; /*  FC classes of service supp */
         bfa_boolean_t   cisc;   /*  CISC capable device */
         bfa_boolean_t   prlo;   /*  processing prlo or LOGO */
@@ -437,32 +447,18 @@ bfa_fcs_rport_get_halrport(struct bfa_fcs_rport_s *rport)
 /*
  * bfa fcs rport API functions
  */
-bfa_status_t bfa_fcs_rport_add(struct bfa_fcs_lport_s *port, wwn_t *pwwn,
-                               struct bfa_fcs_rport_s *rport,
-                               struct bfad_rport_s *rport_drv);
-bfa_status_t bfa_fcs_rport_remove(struct bfa_fcs_rport_s *rport);
-void bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
-                            struct bfa_rport_attr_s *attr);
-void bfa_fcs_rport_get_stats(struct bfa_fcs_rport_s *rport,
-                             struct bfa_rport_stats_s *stats);
-void bfa_fcs_rport_clear_stats(struct bfa_fcs_rport_s *rport);
 struct bfa_fcs_rport_s *bfa_fcs_rport_lookup(struct bfa_fcs_lport_s *port,
                                              wwn_t rpwwn);
 struct bfa_fcs_rport_s *bfa_fcs_rport_lookup_by_nwwn(
         struct bfa_fcs_lport_s *port, wwn_t rnwwn);
 void bfa_fcs_rport_set_del_timeout(u8 rport_tmo);
 
-void bfa_fcs_rport_set_speed(struct bfa_fcs_rport_s *rport,
-                             enum bfa_port_speed speed);
 void bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport,
          struct fchs_s *fchs, u16 len);
 void bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport);
 
 struct bfa_fcs_rport_s *bfa_fcs_rport_create(struct bfa_fcs_lport_s *port,
          u32 pid);
-void bfa_fcs_rport_delete(struct bfa_fcs_rport_s *rport);
-void bfa_fcs_rport_online(struct bfa_fcs_rport_s *rport);
-void bfa_fcs_rport_offline(struct bfa_fcs_rport_s *rport);
 void bfa_fcs_rport_start(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
                          struct fc_logi_s *plogi_rsp);
 void bfa_fcs_rport_plogi_create(struct bfa_fcs_lport_s *port,
@@ -470,10 +466,8 @@ void bfa_fcs_rport_plogi_create(struct bfa_fcs_lport_s *port,
                                 struct fc_logi_s *plogi);
 void bfa_fcs_rport_plogi(struct bfa_fcs_rport_s *rport, struct fchs_s *fchs,
                          struct fc_logi_s *plogi);
-void bfa_fcs_rport_logo_imp(struct bfa_fcs_rport_s *rport);
-void bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, u16 ox_id);
+void bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, __be16 ox_id);
 
-void bfa_fcs_rport_itnim_ack(struct bfa_fcs_rport_s *rport);
 void bfa_fcs_rport_itntm_ack(struct bfa_fcs_rport_s *rport);
 void bfa_fcs_rport_fcptm_offline_done(struct bfa_fcs_rport_s *rport);
 int  bfa_fcs_rport_get_state(struct bfa_fcs_rport_s *rport);
@@ -618,7 +612,7 @@ struct bfa_fcs_fdmi_hba_attr_s {
         u8         option_rom_ver[BFA_VERSION_LEN];
         u8         fw_version[8];
         u8         os_name[256];
-        u32        max_ct_pyld;
+        __be32        max_ct_pyld;
 };
 
 /*
@@ -626,9 +620,9 @@ struct bfa_fcs_fdmi_hba_attr_s {
  */
 struct bfa_fcs_fdmi_port_attr_s {
         u8         supp_fc4_types[32];  /* supported FC4 types */
-        u32        supp_speed;  /* supported speed */
-        u32        curr_speed;  /* current Speed */
-        u32        max_frm_size;        /* max frame size */
+        __be32        supp_speed;       /* supported speed */
+        __be32        curr_speed;       /* current Speed */
+        __be32        max_frm_size;     /* max frame size */
         u8         os_device_name[256]; /* OS device Name */
         u8         host_name[256];      /* host name */
 };
@@ -664,6 +658,57 @@ struct bfa_fcs_s {
 };
 
 /*
+ *  fcs_fabric_sm fabric state machine functions
+ */
+
+/*
+ * Fabric state machine events
+ */
+enum bfa_fcs_fabric_event {
+        BFA_FCS_FABRIC_SM_CREATE        = 1,    /*  create from driver        */
+        BFA_FCS_FABRIC_SM_DELETE        = 2,    /*  delete from driver        */
+        BFA_FCS_FABRIC_SM_LINK_DOWN     = 3,    /*  link down from port      */
+        BFA_FCS_FABRIC_SM_LINK_UP       = 4,    /*  link up from port         */
+        BFA_FCS_FABRIC_SM_CONT_OP       = 5,    /*  flogi/auth continue op   */
+        BFA_FCS_FABRIC_SM_RETRY_OP      = 6,    /*  flogi/auth retry op      */
+        BFA_FCS_FABRIC_SM_NO_FABRIC     = 7,    /*  from flogi/auth           */
+        BFA_FCS_FABRIC_SM_PERF_EVFP     = 8,    /*  from flogi/auth           */
+        BFA_FCS_FABRIC_SM_ISOLATE       = 9,    /*  from EVFP processing     */
+        BFA_FCS_FABRIC_SM_NO_TAGGING    = 10,   /*  no VFT tagging from EVFP */
+        BFA_FCS_FABRIC_SM_DELAYED       = 11,   /*  timeout delay event      */
+        BFA_FCS_FABRIC_SM_AUTH_FAILED   = 12,   /*  auth failed       */
+        BFA_FCS_FABRIC_SM_AUTH_SUCCESS  = 13,   /*  auth successful           */
+        BFA_FCS_FABRIC_SM_DELCOMP       = 14,   /*  all vports deleted event */
+        BFA_FCS_FABRIC_SM_LOOPBACK      = 15,   /*  Received our own FLOGI   */
+        BFA_FCS_FABRIC_SM_START         = 16,   /*  from driver       */
+};
+
+/*
+ *  fcs_rport_sm FCS rport state machine events
+ */
+
+enum rport_event {
+        RPSM_EVENT_PLOGI_SEND   = 1,    /*  new rport; start with PLOGI */
+        RPSM_EVENT_PLOGI_RCVD   = 2,    /*  Inbound PLOGI from remote port */
+        RPSM_EVENT_PLOGI_COMP   = 3,    /*  PLOGI completed to rport    */
+        RPSM_EVENT_LOGO_RCVD    = 4,    /*  LOGO from remote device     */
+        RPSM_EVENT_LOGO_IMP     = 5,    /*  implicit logo for SLER      */
+        RPSM_EVENT_FCXP_SENT    = 6,    /*  Frame from has been sent    */
+        RPSM_EVENT_DELETE       = 7,    /*  RPORT delete request        */
+        RPSM_EVENT_SCN          = 8,    /*  state change notification   */
+        RPSM_EVENT_ACCEPTED     = 9,    /*  Good response from remote device */
+        RPSM_EVENT_FAILED       = 10,   /*  Request to rport failed.    */
+        RPSM_EVENT_TIMEOUT      = 11,   /*  Rport SM timeout event      */
+        RPSM_EVENT_HCB_ONLINE  = 12,    /*  BFA rport online callback   */
+        RPSM_EVENT_HCB_OFFLINE = 13,    /*  BFA rport offline callback  */
+        RPSM_EVENT_FC4_OFFLINE = 14,    /*  FC-4 offline complete       */
+        RPSM_EVENT_ADDRESS_CHANGE = 15, /*  Rport's PID has changed     */
+        RPSM_EVENT_ADDRESS_DISC = 16,   /*  Need to Discover rport's PID */
+        RPSM_EVENT_PRLO_RCVD   = 17,    /*  PRLO from remote device     */
+        RPSM_EVENT_PLOGI_RETRY = 18,    /*  Retry PLOGI continously */
+};
+
+/*
  * bfa fcs API functions
  */
 void bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa,
@@ -672,16 +717,12 @@ void bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa,
 void bfa_fcs_init(struct bfa_fcs_s *fcs);
 void bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
                               struct bfa_fcs_driver_info_s *driver_info);
-void bfa_fcs_set_fdmi_param(struct bfa_fcs_s *fcs, bfa_boolean_t fdmi_enable);
 void bfa_fcs_exit(struct bfa_fcs_s *fcs);
-void bfa_fcs_trc_init(struct bfa_fcs_s *fcs, struct bfa_trc_mod_s *trcmod);
-void            bfa_fcs_start(struct bfa_fcs_s *fcs);
 
 /*
  * bfa fcs vf public functions
  */
 bfa_fcs_vf_t *bfa_fcs_vf_lookup(struct bfa_fcs_s *fcs, u16 vf_id);
-u16 bfa_fcs_fabric_vport_count(struct bfa_fcs_fabric_s *fabric);
 
 /*
  * fabric protected interface functions
@@ -689,32 +730,29 @@ u16 bfa_fcs_fabric_vport_count(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_fabric_attach(struct bfa_fcs_s *fcs);
 void bfa_fcs_fabric_modinit(struct bfa_fcs_s *fcs);
 void bfa_fcs_fabric_modexit(struct bfa_fcs_s *fcs);
-void bfa_fcs_fabric_modsusp(struct bfa_fcs_s *fcs);
 void bfa_fcs_fabric_link_up(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_fabric_link_down(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_fabric_addvport(struct bfa_fcs_fabric_s *fabric,
         struct bfa_fcs_vport_s *vport);
 void bfa_fcs_fabric_delvport(struct bfa_fcs_fabric_s *fabric,
         struct bfa_fcs_vport_s *vport);
-int bfa_fcs_fabric_is_online(struct bfa_fcs_fabric_s *fabric);
 struct bfa_fcs_vport_s *bfa_fcs_fabric_vport_lookup(
                 struct bfa_fcs_fabric_s *fabric, wwn_t pwwn);
 void bfa_fcs_fabric_modstart(struct bfa_fcs_s *fcs);
 void bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric,
                 struct fchs_s *fchs, u16 len);
-bfa_boolean_t   bfa_fcs_fabric_is_loopback(struct bfa_fcs_fabric_s *fabric);
-bfa_boolean_t   bfa_fcs_fabric_is_auth_failed(struct bfa_fcs_fabric_s *fabric);
-enum bfa_port_type bfa_fcs_fabric_port_type(struct bfa_fcs_fabric_s *fabric);
 void    bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric);
-void    bfa_fcs_fabric_port_delete_comp(struct bfa_fcs_fabric_s *fabric);
-bfa_status_t    bfa_fcs_fabric_addvf(struct bfa_fcs_fabric_s *vf,
-                        struct bfa_fcs_s *fcs, struct bfa_lport_cfg_s *port_cfg,
-                        struct bfad_vf_s *vf_drv);
 void bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric,
                wwn_t fabric_name);
 u16 bfa_fcs_fabric_get_switch_oui(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_uf_attach(struct bfa_fcs_s *fcs);
 void bfa_fcs_port_attach(struct bfa_fcs_s *fcs);
+void bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
+                        enum bfa_fcs_fabric_event event);
+void bfa_fcs_fabric_sm_loopback(struct bfa_fcs_fabric_s *fabric,
+                        enum bfa_fcs_fabric_event event);
+void bfa_fcs_fabric_sm_auth_failed(struct bfa_fcs_fabric_s *fabric,
+                        enum bfa_fcs_fabric_event event);
 
 /*
  * BFA FCS callback interfaces
diff --git a/drivers/scsi/bfa/bfa_fcs_fcpim.c b/drivers/scsi/bfa/bfa_fcs_fcpim.c
index 413b58eef93a..e7b49f4cb51f 100644
--- a/drivers/scsi/bfa/bfa_fcs_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcs_fcpim.c
@@ -19,9 +19,9 @@
  *  fcpim.c - FCP initiator mode i-t nexus state machine
  */
 
+#include "bfad_drv.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
-#include "bfad_drv.h"
 #include "bfad_im.h"
 
 BFA_TRC_FILE(FCS, FCPIM);
@@ -103,7 +103,7 @@ bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         case BFA_FCS_ITNIM_SM_OFFLINE:
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_INITIATOR:
@@ -140,7 +140,7 @@ bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_OFFLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
                 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe);
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -181,7 +181,7 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_OFFLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
                 bfa_fcxp_discard(itnim->fcxp);
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_INITIATOR:
@@ -217,7 +217,7 @@ bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
                 } else {
                         /* invoke target offline */
                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
-                        bfa_fcs_rport_logo_imp(itnim->rport);
+                        bfa_sm_send_event(itnim->rport, RPSM_EVENT_LOGO_IMP);
                 }
                 break;
 
@@ -225,7 +225,7 @@ bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_OFFLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
                 bfa_timer_stop(&itnim->timer);
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_INITIATOR:
@@ -269,7 +269,7 @@ bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_OFFLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
                 bfa_itnim_offline(itnim->bfa_itnim);
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -330,7 +330,7 @@ bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim,
         switch (event) {
         case BFA_FCS_ITNIM_SM_HCB_OFFLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -358,7 +358,7 @@ bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
         switch (event) {
         case BFA_FCS_ITNIM_SM_OFFLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
-                bfa_fcs_rport_itnim_ack(itnim->rport);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_RSP_ERROR:
@@ -536,7 +536,7 @@ bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport)
         if (bfa_itnim == NULL) {
                 bfa_trc(port->fcs, rport->pwwn);
                 bfa_fcb_itnim_free(port->fcs->bfad, itnim_drv);
-                bfa_assert(0);
+                WARN_ON(1);
                 return NULL;
         }
 
@@ -688,7 +688,7 @@ bfa_cb_itnim_sler(void *cb_arg)
 
         itnim->stats.sler++;
         bfa_trc(itnim->fcs, itnim->rport->pwwn);
-        bfa_fcs_rport_logo_imp(itnim->rport);
+        bfa_sm_send_event(itnim->rport, RPSM_EVENT_LOGO_IMP);
 }
 
 struct bfa_fcs_itnim_s *
@@ -700,7 +700,7 @@ bfa_fcs_itnim_lookup(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
         if (!rport)
                 return NULL;
 
-        bfa_assert(rport->itnim != NULL);
+        WARN_ON(rport->itnim == NULL);
         return rport->itnim;
 }
 
@@ -729,7 +729,7 @@ bfa_fcs_itnim_stats_get(struct bfa_fcs_lport_s *port, wwn_t rpwwn,
 {
         struct bfa_fcs_itnim_s *itnim = NULL;
 
-        bfa_assert(port != NULL);
+        WARN_ON(port == NULL);
 
         itnim = bfa_fcs_itnim_lookup(port, rpwwn);
 
@@ -746,7 +746,7 @@ bfa_fcs_itnim_stats_clear(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
 {
         struct bfa_fcs_itnim_s *itnim = NULL;
 
-        bfa_assert(port != NULL);
+        WARN_ON(port == NULL);
 
         itnim = bfa_fcs_itnim_lookup(port, rpwwn);
 
@@ -778,6 +778,6 @@ bfa_fcs_fcpim_uf_recv(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index 8d651309302b..4e2eb92ba028 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -15,10 +15,10 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
 #include "bfa_fc.h"
-#include "bfad_drv.h"
 
 BFA_TRC_FILE(FCS, PORT);
 
@@ -159,7 +159,7 @@ bfa_fcs_lport_sm_online(
                         bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting);
                         list_for_each_safe(qe, qen, &port->rport_q) {
                                 rport = (struct bfa_fcs_rport_s *) qe;
-                                bfa_fcs_rport_delete(rport);
+                                bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
                         }
                 }
                 break;
@@ -197,7 +197,7 @@ bfa_fcs_lport_sm_offline(
                         bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting);
                         list_for_each_safe(qe, qen, &port->rport_q) {
                                 rport = (struct bfa_fcs_rport_s *) qe;
-                                bfa_fcs_rport_delete(rport);
+                                bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
                         }
                 }
                 break;
@@ -309,6 +309,7 @@ bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
                         return;
                 }
                 port->pid  = rx_fchs->d_id;
+                bfa_lps_set_n2n_pid(port->fabric->lps, rx_fchs->d_id);
         }
 
         /*
@@ -323,6 +324,7 @@ bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
                         (memcmp((void *)&bfa_fcs_lport_get_pwwn(port),
                         (void *)&plogi->port_name, sizeof(wwn_t)) < 0)) {
                         port->pid  = rx_fchs->d_id;
+                        bfa_lps_set_n2n_pid(port->fabric->lps, rx_fchs->d_id);
                         rport->pid = rx_fchs->s_id;
                 }
                 bfa_fcs_rport_plogi(rport, rx_fchs, plogi);
@@ -349,8 +351,8 @@ bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
                  * This is a different device with the same pid. Old device
                  * disappeared. Send implicit LOGO to old device.
                  */
-                bfa_assert(rport->pwwn != plogi->port_name);
-                bfa_fcs_rport_logo_imp(rport);
+                WARN_ON(rport->pwwn == plogi->port_name);
+                bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
 
                 /*
                  * Inbound PLOGI from a new device (with old PID).
@@ -362,7 +364,7 @@ bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
         /*
          * PLOGI crossing each other.
          */
-        bfa_assert(rport->pwwn == WWN_NULL);
+        WARN_ON(rport->pwwn != WWN_NULL);
         bfa_fcs_rport_plogi(rport, rx_fchs, plogi);
 }
 
@@ -511,7 +513,8 @@ bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
         __port_action[port->fabric->fab_type].offline(port);
 
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
-        if (bfa_fcs_fabric_is_online(port->fabric) == BFA_TRUE)
+        if (bfa_sm_cmp_state(port->fabric,
+                        bfa_fcs_fabric_sm_online) == BFA_TRUE)
                 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                 "Logical port lost fabric connectivity: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
@@ -522,26 +525,26 @@ bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
 
         list_for_each_safe(qe, qen, &port->rport_q) {
                 rport = (struct bfa_fcs_rport_s *) qe;
-                bfa_fcs_rport_offline(rport);
+                bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
         }
 }
 
 static void
 bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port)
 {
-        bfa_assert(0);
+        WARN_ON(1);
 }
 
 static void
 bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port)
 {
-        bfa_assert(0);
+        WARN_ON(1);
 }
 
 static void
 bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port)
 {
-        bfa_assert(0);
+        WARN_ON(1);
 }
 
 static void
@@ -584,33 +587,11 @@ bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port)
                                 port->vport ? port->vport->vport_drv : NULL);
                 bfa_fcs_vport_delete_comp(port->vport);
         } else {
-                 bfa_fcs_fabric_port_delete_comp(port->fabric);
+                bfa_wc_down(&port->fabric->wc);
         }
 }
 
 
-
-/*
- *  fcs_lport_api BFA FCS port API
- */
-/*
- *   Module initialization
- */
-void
-bfa_fcs_lport_modinit(struct bfa_fcs_s *fcs)
-{
-
-}
-
-/*
- *   Module cleanup
- */
-void
-bfa_fcs_lport_modexit(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_modexit_comp(fcs);
-}
-
 /*
  * Unsolicited frame receive handling.
  */
@@ -623,6 +604,7 @@ bfa_fcs_lport_uf_recv(struct bfa_fcs_lport_s *lport,
         struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
 
         bfa_stats(lport, uf_recvs);
+        bfa_trc(lport->fcs, fchs->type);
 
         if (!bfa_fcs_lport_is_online(lport)) {
                 bfa_stats(lport, uf_recv_drops);
@@ -682,8 +664,11 @@ bfa_fcs_lport_uf_recv(struct bfa_fcs_lport_s *lport,
          * Only handles ELS frames for now.
          */
         if (fchs->type != FC_TYPE_ELS) {
-                bfa_trc(lport->fcs, fchs->type);
-                bfa_assert(0);
+                bfa_trc(lport->fcs, fchs->s_id);
+                bfa_trc(lport->fcs, fchs->d_id);
+                /* ignore type FC_TYPE_FC_FSS */
+                if (fchs->type != FC_TYPE_FC_FSS)
+                        bfa_sm_fault(lport->fcs, fchs->type);
                 return;
         }
 
@@ -792,7 +777,7 @@ bfa_fcs_lport_del_rport(
         struct bfa_fcs_lport_s *port,
         struct bfa_fcs_rport_s *rport)
 {
-        bfa_assert(bfa_q_is_on_q(&port->rport_q, rport));
+        WARN_ON(!bfa_q_is_on_q(&port->rport_q, rport));
         list_del(&rport->qe);
         port->num_rports--;
 
@@ -850,8 +835,8 @@ bfa_fcs_lport_attach(struct bfa_fcs_lport_s *lport, struct bfa_fcs_s *fcs,
         lport->fcs = fcs;
         lport->fabric = bfa_fcs_vf_lookup(fcs, vf_id);
         lport->vport = vport;
-        lport->lp_tag = (vport) ? bfa_lps_get_tag(vport->lps) :
-                                  bfa_lps_get_tag(lport->fabric->lps);
+        lport->lp_tag = (vport) ? vport->lps->lp_tag :
+                                  lport->fabric->lps->lp_tag;
 
         INIT_LIST_HEAD(&lport->rport_q);
         lport->num_rports = 0;
@@ -903,10 +888,12 @@ bfa_fcs_lport_get_attr(
         port_attr->port_cfg = port->port_cfg;
 
         if (port->fabric) {
-                port_attr->port_type = bfa_fcs_fabric_port_type(port->fabric);
-                port_attr->loopback = bfa_fcs_fabric_is_loopback(port->fabric);
+                port_attr->port_type = port->fabric->oper_type;
+                port_attr->loopback = bfa_sm_cmp_state(port->fabric,
+                                bfa_fcs_fabric_sm_loopback);
                 port_attr->authfail =
-                        bfa_fcs_fabric_is_auth_failed(port->fabric);
+                        bfa_sm_cmp_state(port->fabric,
+                                bfa_fcs_fabric_sm_auth_failed);
                 port_attr->fabric_name  = bfa_fcs_lport_get_fabric_name(port);
                 memcpy(port_attr->fabric_ip_addr,
                         bfa_fcs_lport_get_fabric_ipaddr(port),
@@ -915,10 +902,10 @@ bfa_fcs_lport_get_attr(
                 if (port->vport != NULL) {
                         port_attr->port_type = BFA_PORT_TYPE_VPORT;
                         port_attr->fpma_mac =
-                                bfa_lps_get_lp_mac(port->vport->lps);
+                                port->vport->lps->lp_mac;
                 } else {
                         port_attr->fpma_mac =
-                                bfa_lps_get_lp_mac(port->fabric->lps);
+                                port->fabric->lps->lp_mac;
                 }
         } else {
                 port_attr->port_type = BFA_PORT_TYPE_UNKNOWN;
@@ -998,6 +985,7 @@ bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port)
             ((void *)&pcfg->pwwn, (void *)&n2n_port->rem_port_wwn,
              sizeof(wwn_t)) > 0) {
                 port->pid = N2N_LOCAL_PID;
+                bfa_lps_set_n2n_pid(port->fabric->lps, N2N_LOCAL_PID);
                 /*
                  * First, check if we know the device by pwwn.
                  */
@@ -1007,7 +995,7 @@ bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port)
                         bfa_trc(port->fcs, rport->pid);
                         bfa_trc(port->fcs, rport->pwwn);
                         rport->pid = N2N_REMOTE_PID;
-                        bfa_fcs_rport_online(rport);
+                        bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND);
                         return;
                 }
 
@@ -1017,10 +1005,10 @@ bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port)
                  */
                 if (port->num_rports > 0) {
                         rport = bfa_fcs_lport_get_rport_by_pid(port, 0);
-                        bfa_assert(rport != NULL);
+                        WARN_ON(rport == NULL);
                         if (rport) {
                                 bfa_trc(port->fcs, rport->pwwn);
-                                bfa_fcs_rport_delete(rport);
+                                bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
                         }
                 }
                 bfa_fcs_rport_create(port, N2N_REMOTE_PID);
@@ -1569,6 +1557,7 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
         struct fdmi_attr_s *attr;
         u8        *curr_ptr;
         u16        len, count;
+        u16     templen;
 
         /*
          * get hba attributes
@@ -1594,69 +1583,69 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NODENAME);
-        attr->len = sizeof(wwn_t);
-        memcpy(attr->value, &bfa_fcs_lport_get_nwwn(port), attr->len);
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = sizeof(wwn_t);
+        memcpy(attr->value, &bfa_fcs_lport_get_nwwn(port), templen);
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Manufacturer
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MANUFACTURER);
-        attr->len = (u16) strlen(fcs_hba_attr->manufacturer);
-        memcpy(attr->value, fcs_hba_attr->manufacturer, attr->len);
-        attr->len = fc_roundup(attr->len, sizeof(u32));
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = (u16) strlen(fcs_hba_attr->manufacturer);
+        memcpy(attr->value, fcs_hba_attr->manufacturer, templen);
+        templen = fc_roundup(templen, sizeof(u32));
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Serial Number
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_SERIALNUM);
-        attr->len = (u16) strlen(fcs_hba_attr->serial_num);
-        memcpy(attr->value, fcs_hba_attr->serial_num, attr->len);
-        attr->len = fc_roundup(attr->len, sizeof(u32));
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = (u16) strlen(fcs_hba_attr->serial_num);
+        memcpy(attr->value, fcs_hba_attr->serial_num, templen);
+        templen = fc_roundup(templen, sizeof(u32));
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Model
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL);
-        attr->len = (u16) strlen(fcs_hba_attr->model);
-        memcpy(attr->value, fcs_hba_attr->model, attr->len);
-        attr->len = fc_roundup(attr->len, sizeof(u32));
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = (u16) strlen(fcs_hba_attr->model);
+        memcpy(attr->value, fcs_hba_attr->model, templen);
+        templen = fc_roundup(templen, sizeof(u32));
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Model Desc
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL_DESC);
-        attr->len = (u16) strlen(fcs_hba_attr->model_desc);
-        memcpy(attr->value, fcs_hba_attr->model_desc, attr->len);
-        attr->len = fc_roundup(attr->len, sizeof(u32));
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = (u16) strlen(fcs_hba_attr->model_desc);
+        memcpy(attr->value, fcs_hba_attr->model_desc, templen);
+        templen = fc_roundup(templen, sizeof(u32));
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * H/W Version
@@ -1664,14 +1653,14 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
         if (fcs_hba_attr->hw_version[0] != '\0') {
                 attr = (struct fdmi_attr_s *) curr_ptr;
                 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_HW_VERSION);
-                attr->len = (u16) strlen(fcs_hba_attr->hw_version);
-                memcpy(attr->value, fcs_hba_attr->hw_version, attr->len);
-                attr->len = fc_roundup(attr->len, sizeof(u32));
-                curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-                len += attr->len;
+                templen = (u16) strlen(fcs_hba_attr->hw_version);
+                memcpy(attr->value, fcs_hba_attr->hw_version, templen);
+                templen = fc_roundup(templen, sizeof(u32));
+                curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+                len += templen;
                 count++;
-                attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                                         sizeof(attr->len));
+                attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                                         sizeof(templen));
         }
 
         /*
@@ -1679,14 +1668,14 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_DRIVER_VERSION);
-        attr->len = (u16) strlen(fcs_hba_attr->driver_version);
-        memcpy(attr->value, fcs_hba_attr->driver_version, attr->len);
-        attr->len = fc_roundup(attr->len, sizeof(u32));
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;;
+        templen = (u16) strlen(fcs_hba_attr->driver_version);
+        memcpy(attr->value, fcs_hba_attr->driver_version, templen);
+        templen = fc_roundup(templen, sizeof(u32));
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Option Rom Version
@@ -1694,14 +1683,14 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
         if (fcs_hba_attr->option_rom_ver[0] != '\0') {
                 attr = (struct fdmi_attr_s *) curr_ptr;
                 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_ROM_VERSION);
-                attr->len = (u16) strlen(fcs_hba_attr->option_rom_ver);
-                memcpy(attr->value, fcs_hba_attr->option_rom_ver, attr->len);
-                attr->len = fc_roundup(attr->len, sizeof(u32));
-                curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-                len += attr->len;
+                templen = (u16) strlen(fcs_hba_attr->option_rom_ver);
+                memcpy(attr->value, fcs_hba_attr->option_rom_ver, templen);
+                templen = fc_roundup(templen, sizeof(u32));
+                curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+                len += templen;
                 count++;
-                attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                                         sizeof(attr->len));
+                attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                                         sizeof(templen));
         }
 
         /*
@@ -1709,14 +1698,14 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FW_VERSION);
-        attr->len = (u16) strlen(fcs_hba_attr->driver_version);
-        memcpy(attr->value, fcs_hba_attr->driver_version, attr->len);
-        attr->len = fc_roundup(attr->len, sizeof(u32));
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = (u16) strlen(fcs_hba_attr->driver_version);
+        memcpy(attr->value, fcs_hba_attr->driver_version, templen);
+        templen = fc_roundup(templen, sizeof(u32));
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * OS Name
@@ -1724,14 +1713,14 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
         if (fcs_hba_attr->os_name[0] != '\0') {
                 attr = (struct fdmi_attr_s *) curr_ptr;
                 attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_OS_NAME);
-                attr->len = (u16) strlen(fcs_hba_attr->os_name);
-                memcpy(attr->value, fcs_hba_attr->os_name, attr->len);
-                attr->len = fc_roundup(attr->len, sizeof(u32));
-                curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-                len += attr->len;
+                templen = (u16) strlen(fcs_hba_attr->os_name);
+                memcpy(attr->value, fcs_hba_attr->os_name, templen);
+                templen = fc_roundup(templen, sizeof(u32));
+                curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+                len += templen;
                 count++;
-                attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                                        sizeof(attr->len));
+                attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                                        sizeof(templen));
         }
 
         /*
@@ -1739,12 +1728,12 @@ bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MAX_CT);
-        attr->len = sizeof(fcs_hba_attr->max_ct_pyld);
-        memcpy(attr->value, &fcs_hba_attr->max_ct_pyld, attr->len);
-        len += attr->len;
+        templen = sizeof(fcs_hba_attr->max_ct_pyld);
+        memcpy(attr->value, &fcs_hba_attr->max_ct_pyld, templen);
+        len += templen;
         count++;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Update size of payload
@@ -1845,6 +1834,7 @@ bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi,
         u8        *curr_ptr;
         u16        len;
         u8      count = 0;
+        u16     templen;
 
         /*
          * get port attributes
@@ -1863,54 +1853,54 @@ bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi,
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FC4_TYPES);
-        attr->len = sizeof(fcs_port_attr.supp_fc4_types);
-        memcpy(attr->value, fcs_port_attr.supp_fc4_types, attr->len);
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = sizeof(fcs_port_attr.supp_fc4_types);
+        memcpy(attr->value, fcs_port_attr.supp_fc4_types, templen);
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         ++count;
         attr->len =
-                cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+                cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * Supported Speed
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_SUPP_SPEED);
-        attr->len = sizeof(fcs_port_attr.supp_speed);
-        memcpy(attr->value, &fcs_port_attr.supp_speed, attr->len);
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = sizeof(fcs_port_attr.supp_speed);
+        memcpy(attr->value, &fcs_port_attr.supp_speed, templen);
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         ++count;
         attr->len =
-                cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+                cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * current Port Speed
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_SPEED);
-        attr->len = sizeof(fcs_port_attr.curr_speed);
-        memcpy(attr->value, &fcs_port_attr.curr_speed, attr->len);
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = sizeof(fcs_port_attr.curr_speed);
+        memcpy(attr->value, &fcs_port_attr.curr_speed, templen);
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         ++count;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * max frame size
          */
         attr = (struct fdmi_attr_s *) curr_ptr;
         attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FRAME_SIZE);
-        attr->len = sizeof(fcs_port_attr.max_frm_size);
-        memcpy(attr->value, &fcs_port_attr.max_frm_size, attr->len);
-        curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-        len += attr->len;
+        templen = sizeof(fcs_port_attr.max_frm_size);
+        memcpy(attr->value, &fcs_port_attr.max_frm_size, templen);
+        curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+        len += templen;
         ++count;
-        attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                             sizeof(attr->len));
+        attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                             sizeof(templen));
 
         /*
          * OS Device Name
@@ -1918,14 +1908,14 @@ bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi,
         if (fcs_port_attr.os_device_name[0] != '\0') {
                 attr = (struct fdmi_attr_s *) curr_ptr;
                 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_DEV_NAME);
-                attr->len = (u16) strlen(fcs_port_attr.os_device_name);
-                memcpy(attr->value, fcs_port_attr.os_device_name, attr->len);
-                attr->len = fc_roundup(attr->len, sizeof(u32));
-                curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-                len += attr->len;
+                templen = (u16) strlen(fcs_port_attr.os_device_name);
+                memcpy(attr->value, fcs_port_attr.os_device_name, templen);
+                templen = fc_roundup(templen, sizeof(u32));
+                curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+                len += templen;
                 ++count;
-                attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                                        sizeof(attr->len));
+                attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                                        sizeof(templen));
         }
         /*
          * Host Name
@@ -1933,14 +1923,14 @@ bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi,
         if (fcs_port_attr.host_name[0] != '\0') {
                 attr = (struct fdmi_attr_s *) curr_ptr;
                 attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_HOST_NAME);
-                attr->len = (u16) strlen(fcs_port_attr.host_name);
-                memcpy(attr->value, fcs_port_attr.host_name, attr->len);
-                attr->len = fc_roundup(attr->len, sizeof(u32));
-                curr_ptr += sizeof(attr->type) + sizeof(attr->len) + attr->len;
-                len += attr->len;
+                templen = (u16) strlen(fcs_port_attr.host_name);
+                memcpy(attr->value, fcs_port_attr.host_name, templen);
+                templen = fc_roundup(templen, sizeof(u32));
+                curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
+                len += templen;
                 ++count;
-                attr->len = cpu_to_be16(attr->len + sizeof(attr->type) +
-                                sizeof(attr->len));
+                attr->len = cpu_to_be16(templen + sizeof(attr->type) +
+                                sizeof(templen));
         }
 
         /*
@@ -2103,7 +2093,7 @@ bfa_fcs_lport_fdmi_timeout(void *arg)
         bfa_sm_send_event(fdmi, FDMISM_EVENT_TIMEOUT);
 }
 
-void
+static void
 bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
                          struct bfa_fcs_fdmi_hba_attr_s *hba_attr)
 {
@@ -2147,7 +2137,7 @@ bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
         hba_attr->max_ct_pyld = cpu_to_be32(FC_MAX_PDUSZ);
 }
 
-void
+static void
 bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi,
                           struct bfa_fcs_fdmi_port_attr_s *port_attr)
 {
@@ -2560,7 +2550,7 @@ bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         len = fc_gmal_req_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
                              bfa_fcs_lport_get_fcid(port),
-                                 bfa_lps_get_peer_nwwn(port->fabric->lps));
+                                 port->fabric->lps->pr_nwwn);
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                           FC_CLASS_3, len, &fchs,
@@ -2760,7 +2750,7 @@ bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         len = fc_gfn_req_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
                              bfa_fcs_lport_get_fcid(port),
-                                 bfa_lps_get_peer_nwwn(port->fabric->lps));
+                                 port->fabric->lps->pr_nwwn);
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                           FC_CLASS_3, len, &fchs,
@@ -2836,7 +2826,7 @@ bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         ms->fcxp = fcxp;
 
         len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
-                             bfa_os_hton3b(FC_MGMT_SERVER),
+                             bfa_hton3b(FC_MGMT_SERVER),
                              bfa_fcs_lport_get_fcid(port), 0,
                              port->port_cfg.pwwn, port->port_cfg.nwwn,
                                  bfa_fcport_get_maxfrsize(port->fcs->bfa));
@@ -3593,7 +3583,7 @@ fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
         ns->fcxp = fcxp;
 
         len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
-                             bfa_os_hton3b(FC_NAME_SERVER),
+                             bfa_hton3b(FC_NAME_SERVER),
                              bfa_fcs_lport_get_fcid(port), 0,
                              port->port_cfg.pwwn, port->port_cfg.nwwn,
                                  bfa_fcport_get_maxfrsize(port->fcs->bfa));
@@ -4150,7 +4140,7 @@ bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port)
         bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
 }
 
-void
+static void
 bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port)
 {
 
@@ -4163,7 +4153,7 @@ bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port)
 
         for (ii = 0 ; ii < nwwns; ++ii) {
                 rport = bfa_fcs_rport_create_by_wwn(port, wwns[ii]);
-                bfa_assert(rport);
+                WARN_ON(!rport);
         }
 }
 
@@ -4352,8 +4342,8 @@ bfa_fcs_lport_scn_send_scr(void *scn_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         /* Handle VU registrations for Base port only */
         if ((!port->vport) && bfa_ioc_get_fcmode(&port->fcs->bfa->ioc)) {
                 len = fc_scr_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
-                                bfa_lps_is_brcd_fabric(port->fabric->lps),
-                                                        port->pid, 0);
+                                port->fabric->lps->brcd_switch,
+                                port->pid, 0);
         } else {
             len = fc_scr_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
                                     BFA_FALSE,
@@ -4626,7 +4616,7 @@ bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s *port,
 
 
                 default:
-                        bfa_assert(0);
+                        WARN_ON(1);
                         nsquery = BFA_TRUE;
                 }
         }
@@ -4672,7 +4662,7 @@ bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, int index,
 
         while ((qe != qh) && (i < nrports)) {
                 rport = (struct bfa_fcs_rport_s *) qe;
-                if (bfa_os_ntoh3b(rport->pid) > 0xFFF000) {
+                if (bfa_ntoh3b(rport->pid) > 0xFFF000) {
                         qe = bfa_q_next(qe);
                         bfa_trc(fcs, (u32) rport->pwwn);
                         bfa_trc(fcs, rport->pid);
@@ -4720,7 +4710,7 @@ bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
 
         while ((qe != qh) && (i < *nrports)) {
                 rport = (struct bfa_fcs_rport_s *) qe;
-                if (bfa_os_ntoh3b(rport->pid) > 0xFFF000) {
+                if (bfa_ntoh3b(rport->pid) > 0xFFF000) {
                         qe = bfa_q_next(qe);
                         bfa_trc(fcs, (u32) rport->pwwn);
                         bfa_trc(fcs, rport->pid);
@@ -4771,7 +4761,7 @@ bfa_fcs_lport_get_rport_max_speed(bfa_fcs_lport_t *port)
 
         while (qe != qh) {
                 rport = (struct bfa_fcs_rport_s *) qe;
-                if ((bfa_os_ntoh3b(rport->pid) > 0xFFF000) ||
+                if ((bfa_ntoh3b(rport->pid) > 0xFFF000) ||
                         (bfa_fcs_rport_get_state(rport) ==
                           BFA_RPORT_OFFLINE)) {
                         qe = bfa_q_next(qe);
@@ -4807,7 +4797,7 @@ bfa_fcs_lookup_port(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t lpwwn)
         struct bfa_fcs_vport_s *vport;
         bfa_fcs_vf_t   *vf;
 
-        bfa_assert(fcs != NULL);
+        WARN_ON(fcs == NULL);
 
         vf = bfa_fcs_vf_lookup(fcs, vf_id);
         if (vf == NULL) {
@@ -4853,7 +4843,7 @@ bfa_fcs_lport_get_info(struct bfa_fcs_lport_s *port,
                 port_info->max_vports_supp =
                         bfa_lps_get_max_vport(port->fcs->bfa);
                 port_info->num_vports_inuse =
-                        bfa_fcs_fabric_vport_count(port->fabric);
+                        port->fabric->num_vports;
                 port_info->max_rports_supp = BFA_FCS_MAX_RPORTS_SUPP;
                 port_info->num_rports_inuse = port->num_rports;
         } else {
@@ -4997,7 +4987,8 @@ bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport,
 
         switch (event) {
         case BFA_FCS_VPORT_SM_START:
-                if (bfa_fcs_fabric_is_online(__vport_fabric(vport))
+                if (bfa_sm_cmp_state(__vport_fabric(vport),
+                                        bfa_fcs_fabric_sm_online)
                     && bfa_fcs_fabric_npiv_capable(__vport_fabric(vport))) {
                         bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
                         bfa_fcs_vport_do_fdisc(vport);
@@ -5080,13 +5071,13 @@ bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport,
         switch (event) {
         case BFA_FCS_VPORT_SM_DELETE:
                 bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
-                bfa_lps_discard(vport->lps);
+                bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
                 bfa_fcs_lport_delete(&vport->lport);
                 break;
 
         case BFA_FCS_VPORT_SM_OFFLINE:
                 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
-                bfa_lps_discard(vport->lps);
+                bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
                 break;
 
         case BFA_FCS_VPORT_SM_RSP_OK:
@@ -5166,7 +5157,7 @@ bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport,
 
         case BFA_FCS_VPORT_SM_OFFLINE:
                 bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
-                bfa_lps_discard(vport->lps);
+                bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
                 bfa_fcs_lport_offline(&vport->lport);
                 break;
 
@@ -5266,7 +5257,7 @@ bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
 
         switch (event) {
         case BFA_FCS_VPORT_SM_OFFLINE:
-                bfa_lps_discard(vport->lps);
+                bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
                 /*
                  * !!! fall through !!!
                  */
@@ -5305,14 +5296,14 @@ bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport)
 static void
 bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s *vport)
 {
-        u8              lsrjt_rsn = bfa_lps_get_lsrjt_rsn(vport->lps);
-        u8              lsrjt_expl = bfa_lps_get_lsrjt_expl(vport->lps);
+        u8              lsrjt_rsn = vport->lps->lsrjt_rsn;
+        u8              lsrjt_expl = vport->lps->lsrjt_expl;
 
         bfa_trc(__vport_fcs(vport), lsrjt_rsn);
         bfa_trc(__vport_fcs(vport), lsrjt_expl);
 
         /* For certain reason codes, we don't want to retry. */
-        switch (bfa_lps_get_lsrjt_expl(vport->lps)) {
+        switch (vport->lps->lsrjt_expl) {
         case FC_LS_RJT_EXP_INV_PORT_NAME: /* by brocade */
         case FC_LS_RJT_EXP_INVALID_NPORT_ID: /* by Cisco */
                 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
@@ -5476,7 +5467,7 @@ bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
         if (bfa_fcs_vport_lookup(fcs, vf_id, vport_cfg->pwwn) != NULL)
                 return BFA_STATUS_VPORT_EXISTS;
 
-        if (bfa_fcs_fabric_vport_count(&fcs->fabric) ==
+        if (fcs->fabric.num_vports ==
                         bfa_lps_get_max_vport(fcs->bfa))
                 return BFA_STATUS_VPORT_MAX;
 
@@ -5618,33 +5609,6 @@ bfa_fcs_vport_get_attr(struct bfa_fcs_vport_s *vport,
         attr->vport_state = bfa_sm_to_state(vport_sm_table, vport->sm);
 }
 
-/*
- *      Use this function to get vport's statistics.
- *
- *      param[in]       vport   pointer to bfa_fcs_vport_t.
- *      param[out]      stats   pointer to return vport statistics in
- *
- *      return None
- */
-void
-bfa_fcs_vport_get_stats(struct bfa_fcs_vport_s *vport,
-                        struct bfa_vport_stats_s *stats)
-{
-        *stats = vport->vport_stats;
-}
-
-/*
- *      Use this function to clear vport's statistics.
- *
- *      param[in]       vport   pointer to bfa_fcs_vport_t.
- *
- *      return None
- */
-void
-bfa_fcs_vport_clr_stats(struct bfa_fcs_vport_s *vport)
-{
-        memset(&vport->vport_stats, 0, sizeof(struct bfa_vport_stats_s));
-}
 
 /*
  *      Lookup a virtual port. Excludes base port from lookup.
@@ -5684,7 +5648,7 @@ bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status)
                 /*
                  * Initialiaze the V-Port fields
                  */
-                __vport_fcid(vport) = bfa_lps_get_pid(vport->lps);
+                __vport_fcid(vport) = vport->lps->lp_pid;
                 vport->vport_stats.fdisc_accepts++;
                 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK);
                 break;
@@ -5697,7 +5661,7 @@ bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status)
                 break;
 
         case BFA_STATUS_EPROTOCOL:
-                switch (bfa_lps_get_extstatus(vport->lps)) {
+                switch (vport->lps->ext_status) {
                 case BFA_EPROTO_BAD_ACCEPT:
                         vport->vport_stats.fdisc_acc_bad++;
                         break;
diff --git a/drivers/scsi/bfa/bfa_fcs_rport.c b/drivers/scsi/bfa/bfa_fcs_rport.c
index cf4a6e73e60d..caaee6f06937 100644
--- a/drivers/scsi/bfa/bfa_fcs_rport.c
+++ b/drivers/scsi/bfa/bfa_fcs_rport.c
@@ -19,9 +19,9 @@
  *  rport.c Remote port implementation.
  */
 
+#include "bfad_drv.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
-#include "bfad_drv.h"
 
 BFA_TRC_FILE(FCS, RPORT);
 
@@ -75,30 +75,6 @@ static void	bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport,
 static void     bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
                                 struct fchs_s *rx_fchs, u16 len);
 static void bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport);
-/*
- *  fcs_rport_sm FCS rport state machine events
- */
-
-enum rport_event {
-        RPSM_EVENT_PLOGI_SEND   = 1,    /*  new rport; start with PLOGI */
-        RPSM_EVENT_PLOGI_RCVD   = 2,    /*  Inbound PLOGI from remote port */
-        RPSM_EVENT_PLOGI_COMP   = 3,    /*  PLOGI completed to rport    */
-        RPSM_EVENT_LOGO_RCVD    = 4,    /*  LOGO from remote device     */
-        RPSM_EVENT_LOGO_IMP     = 5,    /*  implicit logo for SLER      */
-        RPSM_EVENT_FCXP_SENT    = 6,    /*  Frame from has been sent    */
-        RPSM_EVENT_DELETE       = 7,    /*  RPORT delete request        */
-        RPSM_EVENT_SCN          = 8,    /*  state change notification   */
-        RPSM_EVENT_ACCEPTED     = 9,    /*  Good response from remote device */
-        RPSM_EVENT_FAILED       = 10,   /*  Request to rport failed.    */
-        RPSM_EVENT_TIMEOUT      = 11,   /*  Rport SM timeout event      */
-        RPSM_EVENT_HCB_ONLINE  = 12,    /*  BFA rport online callback   */
-        RPSM_EVENT_HCB_OFFLINE = 13,    /*  BFA rport offline callback  */
-        RPSM_EVENT_FC4_OFFLINE = 14,    /*  FC-4 offline complete       */
-        RPSM_EVENT_ADDRESS_CHANGE = 15, /*  Rport's PID has changed     */
-        RPSM_EVENT_ADDRESS_DISC = 16,   /*  Need to Discover rport's PID */
-        RPSM_EVENT_PRLO_RCVD   = 17,    /*  PRLO from remote device     */
-        RPSM_EVENT_PLOGI_RETRY = 18,    /*  Retry PLOGI continously */
-};
 
 static void     bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport,
                                         enum rport_event event);
@@ -498,24 +474,24 @@ bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
 
         case RPSM_EVENT_LOGO_RCVD:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 break;
 
         case RPSM_EVENT_LOGO_IMP:
         case RPSM_EVENT_ADDRESS_CHANGE:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 break;
 
         case RPSM_EVENT_PLOGI_RCVD:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 bfa_fcs_rport_send_plogiacc(rport, NULL);
                 break;
 
         case RPSM_EVENT_DELETE:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 break;
 
         case RPSM_EVENT_SCN:
@@ -824,7 +800,7 @@ bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
         switch (event) {
         case RPSM_EVENT_FC4_OFFLINE:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 break;
 
         case RPSM_EVENT_DELETE:
@@ -856,7 +832,7 @@ bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
         switch (event) {
         case RPSM_EVENT_FC4_OFFLINE:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 break;
 
         default:
@@ -878,7 +854,7 @@ bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
         switch (event) {
         case RPSM_EVENT_FC4_OFFLINE:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
-                bfa_rport_offline(rport->bfa_rport);
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
                 break;
 
         case RPSM_EVENT_SCN:
@@ -1459,7 +1435,7 @@ bfa_fcs_rport_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
                         twin->stats.plogi_rcvd    += rport->stats.plogi_rcvd;
                         twin->stats.plogi_accs++;
 
-                        bfa_fcs_rport_delete(rport);
+                        bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
 
                         bfa_fcs_rport_update(twin, plogi_rsp);
                         twin->pid = rsp_fchs->s_id;
@@ -1992,13 +1968,14 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
         /*
          * allocate FC-4s
          */
-        bfa_assert(bfa_fcs_lport_is_initiator(port));
+        WARN_ON(!bfa_fcs_lport_is_initiator(port));
 
         if (bfa_fcs_lport_is_initiator(port)) {
                 rport->itnim = bfa_fcs_itnim_create(rport);
                 if (!rport->itnim) {
                         bfa_trc(fcs, rpid);
-                        bfa_rport_delete(rport->bfa_rport);
+                        bfa_sm_send_event(rport->bfa_rport,
+                                                BFA_RPORT_SM_DELETE);
                         kfree(rport_drv);
                         return NULL;
                 }
@@ -2032,7 +2009,7 @@ bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport)
                         bfa_fcs_rpf_rport_offline(rport);
         }
 
-        bfa_rport_delete(rport->bfa_rport);
+        bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);
         bfa_fcs_lport_del_rport(port, rport);
         kfree(rport->rp_drv);
 }
@@ -2307,40 +2284,8 @@ bfa_fcs_rport_plogi(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,
         bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RCVD);
 }
 
-/*
- * Called by bport/vport to delete a remote port instance.
- *
- * Rport delete is called under the following conditions:
- *              - vport is deleted
- *              - vf is deleted
- *              - explicit request from OS to delete rport
- */
-void
-bfa_fcs_rport_delete(struct bfa_fcs_rport_s *rport)
-{
-        bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
-}
 
 /*
- * Called by bport/vport to  when a target goes offline.
- *
- */
-void
-bfa_fcs_rport_offline(struct bfa_fcs_rport_s *rport)
-{
-        bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
-}
-
-/*
- * Called by bport in n2n when a target (attached port) becomes online.
- *
- */
-void
-bfa_fcs_rport_online(struct bfa_fcs_rport_s *rport)
-{
-        bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND);
-}
-/*
  *      Called by bport/vport to notify SCN for the remote port
  */
 void
@@ -2350,23 +2295,6 @@ bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport)
         bfa_sm_send_event(rport, RPSM_EVENT_SCN);
 }
 
-/*
- *      Called by       fcpim to notify that the ITN cleanup is done.
- */
-void
-bfa_fcs_rport_itnim_ack(struct bfa_fcs_rport_s *rport)
-{
-        bfa_sm_send_event(rport, RPSM_EVENT_FC4_OFFLINE);
-}
-
-/*
- *      Called by fcptm to notify that the ITN cleanup is done.
- */
-void
-bfa_fcs_rport_tin_ack(struct bfa_fcs_rport_s *rport)
-{
-        bfa_sm_send_event(rport, RPSM_EVENT_FC4_OFFLINE);
-}
 
 /*
  *      brief
@@ -2465,15 +2393,6 @@ bfa_cb_rport_qos_scn_prio(void *cbarg,
  *              Called to process any unsolicted frames from this remote port
  */
 void
-bfa_fcs_rport_logo_imp(struct bfa_fcs_rport_s *rport)
-{
-        bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
-}
-
-/*
- *              Called to process any unsolicted frames from this remote port
- */
-void
 bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport,
                         struct fchs_s *fchs, u16 len)
 {
@@ -2586,6 +2505,7 @@ bfa_fcs_rport_get_state(struct bfa_fcs_rport_s *rport)
         return bfa_sm_to_state(rport_sm_table, rport->sm);
 }
 
+
 /*
  *      brief
  *               Called by the Driver to set rport delete/ageout timeout
@@ -2602,7 +2522,7 @@ bfa_fcs_rport_set_del_timeout(u8 rport_tmo)
                 bfa_fcs_rport_del_timeout = rport_tmo * 1000;
 }
 void
-bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, u16 ox_id)
+bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, __be16 ox_id)
 {
         bfa_trc(rport->fcs, rport->pid);
 
@@ -2621,106 +2541,6 @@ bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, u16 ox_id)
  *  fcs_rport_api FCS rport API.
  */
 
-/*
- *      Direct API to add a target by port wwn. This interface is used, for
- *      example, by bios when target pwwn is known from boot lun configuration.
- */
-bfa_status_t
-bfa_fcs_rport_add(struct bfa_fcs_lport_s *port, wwn_t *pwwn,
-                struct bfa_fcs_rport_s *rport, struct bfad_rport_s *rport_drv)
-{
-        bfa_trc(port->fcs, *pwwn);
-
-        return BFA_STATUS_OK;
-}
-
-/*
- *      Direct API to remove a target and its associated resources. This
- *      interface is used, for example, by driver to remove target
- *      ports from the target list for a VM.
- */
-bfa_status_t
-bfa_fcs_rport_remove(struct bfa_fcs_rport_s *rport_in)
-{
-
-        struct bfa_fcs_rport_s *rport;
-
-        bfa_trc(rport_in->fcs, rport_in->pwwn);
-
-        rport = bfa_fcs_lport_get_rport_by_pwwn(rport_in->port, rport_in->pwwn);
-        if (rport == NULL) {
-                /*
-                 * TBD Error handling
-                 */
-                bfa_trc(rport_in->fcs, rport_in->pid);
-                return BFA_STATUS_UNKNOWN_RWWN;
-        }
-
-        /*
-         * TBD if this remote port is online, send a logo
-         */
-        return BFA_STATUS_OK;
-
-}
-
-/*
- *      Remote device status for display/debug.
- */
-void
-bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
-                        struct bfa_rport_attr_s *rport_attr)
-{
-        struct bfa_rport_qos_attr_s qos_attr;
-        bfa_fcs_lport_t *port = rport->port;
-        bfa_port_speed_t rport_speed = rport->rpf.rpsc_speed;
-
-        memset(rport_attr, 0, sizeof(struct bfa_rport_attr_s));
-
-        rport_attr->pid = rport->pid;
-        rport_attr->pwwn = rport->pwwn;
-        rport_attr->nwwn = rport->nwwn;
-        rport_attr->cos_supported = rport->fc_cos;
-        rport_attr->df_sz = rport->maxfrsize;
-        rport_attr->state = bfa_fcs_rport_get_state(rport);
-        rport_attr->fc_cos = rport->fc_cos;
-        rport_attr->cisc = rport->cisc;
-        rport_attr->scsi_function = rport->scsi_function;
-        rport_attr->curr_speed  = rport->rpf.rpsc_speed;
-        rport_attr->assigned_speed  = rport->rpf.assigned_speed;
-
-        bfa_rport_get_qos_attr(rport->bfa_rport, &qos_attr);
-        rport_attr->qos_attr = qos_attr;
-
-        rport_attr->trl_enforced = BFA_FALSE;
-        if (bfa_fcport_is_ratelim(port->fcs->bfa)) {
-                if (rport_speed == BFA_PORT_SPEED_UNKNOWN) {
-                        /* Use default ratelim speed setting */
-                        rport_speed =
-                                bfa_fcport_get_ratelim_speed(rport->fcs->bfa);
-                }
-
-                if (rport_speed < bfa_fcs_lport_get_rport_max_speed(port))
-                        rport_attr->trl_enforced = BFA_TRUE;
-        }
-}
-
-/*
- *      Per remote device statistics.
- */
-void
-bfa_fcs_rport_get_stats(struct bfa_fcs_rport_s *rport,
-                        struct bfa_rport_stats_s *stats)
-{
-        *stats = rport->stats;
-}
-
-void
-bfa_fcs_rport_clear_stats(struct bfa_fcs_rport_s *rport)
-{
-        memset((char *)&rport->stats, 0,
-                        sizeof(struct bfa_rport_stats_s));
-}
-
 struct bfa_fcs_rport_s *
 bfa_fcs_rport_lookup(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
 {
@@ -2752,22 +2572,6 @@ bfa_fcs_rport_lookup_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t rnwwn)
 }
 
 /*
- * This API is to set the Rport's speed. Should be used when RPSC is not
- * supported by the rport.
- */
-void
-bfa_fcs_rport_set_speed(struct bfa_fcs_rport_s *rport, bfa_port_speed_t speed)
-{
-        rport->rpf.assigned_speed  = speed;
-
-        /* Set this speed in f/w only if the RPSC speed is not available */
-        if (rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
-                bfa_rport_speed(rport->bfa_rport, speed);
-}
-
-
-
-/*
  * Remote port features (RPF) implementation.
  */
 
@@ -2827,7 +2631,7 @@ bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
         case RPFSM_EVENT_RPORT_ONLINE:
                 /* Send RPSC2 to a Brocade fabric only. */
                 if ((!BFA_FCS_PID_IS_WKA(rport->pid)) &&
-                        ((bfa_lps_is_brcd_fabric(rport->port->fabric->lps)) ||
+                        ((rport->port->fabric->lps->brcd_switch) ||
                         (bfa_fcs_fabric_get_switch_oui(fabric) ==
                                                 BFA_FCS_BRCD_SWITCH_OUI))) {
                         bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
@@ -3093,7 +2897,7 @@ bfa_fcs_rpf_rpsc2_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
                 num_ents = be16_to_cpu(rpsc2_acc->num_pids);
                 bfa_trc(rport->fcs, num_ents);
                 if (num_ents > 0) {
-                        bfa_assert(rpsc2_acc->port_info[0].pid != rport->pid);
+                        WARN_ON(rpsc2_acc->port_info[0].pid == rport->pid);
                         bfa_trc(rport->fcs,
                                 be16_to_cpu(rpsc2_acc->port_info[0].pid));
                         bfa_trc(rport->fcs,
diff --git a/drivers/scsi/bfa/bfa_hw_cb.c b/drivers/scsi/bfa/bfa_hw_cb.c
index d8464ae60070..977e681ec803 100644
--- a/drivers/scsi/bfa/bfa_hw_cb.c
+++ b/drivers/scsi/bfa/bfa_hw_cb.c
@@ -15,6 +15,7 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_modules.h"
 #include "bfi_cbreg.h"
 
@@ -110,7 +111,7 @@ bfa_hwcb_msix_init(struct bfa_s *bfa, int nvecs)
 {
         int i;
 
-        bfa_assert((nvecs == 1) || (nvecs == __HFN_NUMINTS));
+        WARN_ON((nvecs != 1) && (nvecs != __HFN_NUMINTS));
 
         bfa->msix.nvecs = nvecs;
         if (nvecs == 1) {
diff --git a/drivers/scsi/bfa/bfa_hw_ct.c b/drivers/scsi/bfa/bfa_hw_ct.c
index b0efbc713ffe..21018d98a07b 100644
--- a/drivers/scsi/bfa/bfa_hw_ct.c
+++ b/drivers/scsi/bfa/bfa_hw_ct.c
@@ -15,6 +15,7 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_modules.h"
 #include "bfi_ctreg.h"
 
@@ -116,7 +117,7 @@ bfa_hwct_msix_getvecs(struct bfa_s *bfa, u32 *msix_vecs_bmap,
 void
 bfa_hwct_msix_init(struct bfa_s *bfa, int nvecs)
 {
-        bfa_assert((nvecs == 1) || (nvecs == BFA_MSIX_CT_MAX));
+        WARN_ON((nvecs != 1) && (nvecs != BFA_MSIX_CT_MAX));
         bfa_trc(bfa, nvecs);
 
         bfa->msix.nvecs = nvecs;
@@ -143,7 +144,7 @@ bfa_hwct_msix_install(struct bfa_s *bfa)
         for (; i <= BFA_MSIX_RME_Q3; i++)
                 bfa->msix.handler[i] = bfa_msix_rspq;
 
-        bfa_assert(i == BFA_MSIX_LPU_ERR);
+        WARN_ON(i != BFA_MSIX_LPU_ERR);
         bfa->msix.handler[BFA_MSIX_LPU_ERR] = bfa_msix_lpu_err;
 }
 
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index 9f4aa391ea9d..c1f72c49196f 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -15,11 +15,11 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_ioc.h"
 #include "bfi_ctreg.h"
 #include "bfa_defs.h"
 #include "bfa_defs_svc.h"
-#include "bfad_drv.h"
 
 BFA_TRC_FILE(CNA, IOC);
 
@@ -29,7 +29,7 @@ BFA_TRC_FILE(CNA, IOC);
 #define BFA_IOC_TOV             3000    /* msecs */
 #define BFA_IOC_HWSEM_TOV       500     /* msecs */
 #define BFA_IOC_HB_TOV          500     /* msecs */
-#define BFA_IOC_HWINIT_MAX      2
+#define BFA_IOC_HWINIT_MAX      5
 #define BFA_IOC_TOV_RECOVER      BFA_IOC_HB_TOV
 
 #define bfa_ioc_timer_start(__ioc)                                      \
@@ -42,11 +42,6 @@ BFA_TRC_FILE(CNA, IOC);
                         bfa_ioc_hb_check, (__ioc), BFA_IOC_HB_TOV)
 #define bfa_hb_timer_stop(__ioc)        bfa_timer_stop(&(__ioc)->hb_timer)
 
-#define BFA_DBG_FWTRC_ENTS      (BFI_IOC_TRC_ENTS)
-#define BFA_DBG_FWTRC_LEN                                       \
-        (BFA_DBG_FWTRC_ENTS * sizeof(struct bfa_trc_s) +        \
-         (sizeof(struct bfa_trc_mod_s) -                        \
-          BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
 #define BFA_DBG_FWTRC_OFF(_fn)  (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
 
 /*
@@ -59,17 +54,16 @@ BFA_TRC_FILE(CNA, IOC);
                         ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
-#define bfa_ioc_notify_hbfail(__ioc)                    \
-                        ((__ioc)->ioc_hwif->ioc_notify_hbfail(__ioc))
-
-#ifdef BFA_IOC_IS_UEFI
-#define bfa_ioc_is_bios_optrom(__ioc) (0)
-#define bfa_ioc_is_uefi(__ioc) BFA_IOC_IS_UEFI
-#else
-#define bfa_ioc_is_bios_optrom(__ioc)   \
-        (bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(__ioc)) < BFA_IOC_FWIMG_MINSZ)
-#define bfa_ioc_is_uefi(__ioc) (0)
-#endif
+#define bfa_ioc_notify_fail(__ioc)              \
+                        ((__ioc)->ioc_hwif->ioc_notify_fail(__ioc))
+#define bfa_ioc_sync_join(__ioc)                \
+                        ((__ioc)->ioc_hwif->ioc_sync_join(__ioc))
+#define bfa_ioc_sync_leave(__ioc)               \
+                        ((__ioc)->ioc_hwif->ioc_sync_leave(__ioc))
+#define bfa_ioc_sync_ack(__ioc)                 \
+                        ((__ioc)->ioc_hwif->ioc_sync_ack(__ioc))
+#define bfa_ioc_sync_complete(__ioc)            \
+                        ((__ioc)->ioc_hwif->ioc_sync_complete(__ioc))
 
 #define bfa_ioc_mbox_cmd_pending(__ioc)         \
                         (!list_empty(&((__ioc)->mbox_mod.cmd_q)) || \
@@ -81,29 +75,22 @@ bfa_boolean_t bfa_auto_recover = BFA_TRUE;
  * forward declarations
  */
 static void bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);
-static void bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc);
 static void bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);
 static void bfa_ioc_timeout(void *ioc);
 static void bfa_ioc_send_enable(struct bfa_ioc_s *ioc);
 static void bfa_ioc_send_disable(struct bfa_ioc_s *ioc);
 static void bfa_ioc_send_getattr(struct bfa_ioc_s *ioc);
 static void bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
-static void bfa_ioc_hb_stop(struct bfa_ioc_s *ioc);
-static void bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force);
 static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
 static void bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_recover(struct bfa_ioc_s *ioc);
 static void bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc);
 static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
 static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
-static void bfa_ioc_pf_enabled(struct bfa_ioc_s *ioc);
-static void bfa_ioc_pf_disabled(struct bfa_ioc_s *ioc);
-static void bfa_ioc_pf_failed(struct bfa_ioc_s *ioc);
+static void bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc);
+static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc);
 static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);
 
-/*
- *  hal_ioc_sm
- */
 
 /*
  * IOC state machine definitions/declarations
@@ -116,10 +103,11 @@ enum ioc_event {
         IOC_E_ENABLED           = 5,    /*  f/w enabled         */
         IOC_E_FWRSP_GETATTR     = 6,    /*  IOC get attribute response  */
         IOC_E_DISABLED          = 7,    /*  f/w disabled                */
-        IOC_E_FAILED            = 8,    /*  failure notice by iocpf sm  */
-        IOC_E_HBFAIL            = 9,    /*  heartbeat failure           */
-        IOC_E_HWERROR           = 10,   /*  hardware error interrupt    */
-        IOC_E_TIMEOUT           = 11,   /*  timeout                     */
+        IOC_E_INITFAILED        = 8,    /*  failure notice by iocpf sm  */
+        IOC_E_PFFAILED          = 9,    /*  failure notice by iocpf sm  */
+        IOC_E_HBFAIL            = 10,   /*  heartbeat failure           */
+        IOC_E_HWERROR           = 11,   /*  hardware error interrupt    */
+        IOC_E_TIMEOUT           = 12,   /*  timeout                     */
 };
 
 bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event);
@@ -127,7 +115,7 @@ bfa_fsm_state_decl(bfa_ioc, reset, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, enabling, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, getattr, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, op, struct bfa_ioc_s, enum ioc_event);
-bfa_fsm_state_decl(bfa_ioc, initfail, struct bfa_ioc_s, enum ioc_event);
+bfa_fsm_state_decl(bfa_ioc, fail_retry, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
@@ -138,7 +126,7 @@ static struct bfa_sm_table_s ioc_sm_table[] = {
         {BFA_SM(bfa_ioc_sm_enabling), BFA_IOC_ENABLING},
         {BFA_SM(bfa_ioc_sm_getattr), BFA_IOC_GETATTR},
         {BFA_SM(bfa_ioc_sm_op), BFA_IOC_OPERATIONAL},
-        {BFA_SM(bfa_ioc_sm_initfail), BFA_IOC_INITFAIL},
+        {BFA_SM(bfa_ioc_sm_fail_retry), BFA_IOC_INITFAIL},
         {BFA_SM(bfa_ioc_sm_fail), BFA_IOC_FAIL},
         {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
         {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
@@ -165,12 +153,6 @@ static struct bfa_sm_table_s ioc_sm_table[] = {
 /*
  * Forward declareations for iocpf state machine
  */
-static void bfa_iocpf_enable(struct bfa_ioc_s *ioc);
-static void bfa_iocpf_disable(struct bfa_ioc_s *ioc);
-static void bfa_iocpf_fail(struct bfa_ioc_s *ioc);
-static void bfa_iocpf_initfail(struct bfa_ioc_s *ioc);
-static void bfa_iocpf_getattrfail(struct bfa_ioc_s *ioc);
-static void bfa_iocpf_stop(struct bfa_ioc_s *ioc);
 static void bfa_iocpf_timeout(void *ioc_arg);
 static void bfa_iocpf_sem_timeout(void *ioc_arg);
 
@@ -213,9 +195,14 @@ bfa_fsm_state_decl(bfa_iocpf, semwait, struct bfa_iocpf_s, enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, hwinit, struct bfa_iocpf_s, enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, enabling, struct bfa_iocpf_s, enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, ready, struct bfa_iocpf_s, enum iocpf_event);
+bfa_fsm_state_decl(bfa_iocpf, initfail_sync, struct bfa_iocpf_s,
+                                                enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, initfail, struct bfa_iocpf_s, enum iocpf_event);
+bfa_fsm_state_decl(bfa_iocpf, fail_sync, struct bfa_iocpf_s, enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, fail, struct bfa_iocpf_s, enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, disabling, struct bfa_iocpf_s, enum iocpf_event);
+bfa_fsm_state_decl(bfa_iocpf, disabling_sync, struct bfa_iocpf_s,
+                                                enum iocpf_event);
 bfa_fsm_state_decl(bfa_iocpf, disabled, struct bfa_iocpf_s, enum iocpf_event);
 
 static struct bfa_sm_table_s iocpf_sm_table[] = {
@@ -226,9 +213,12 @@ static struct bfa_sm_table_s iocpf_sm_table[] = {
         {BFA_SM(bfa_iocpf_sm_hwinit), BFA_IOCPF_HWINIT},
         {BFA_SM(bfa_iocpf_sm_enabling), BFA_IOCPF_HWINIT},
         {BFA_SM(bfa_iocpf_sm_ready), BFA_IOCPF_READY},
+        {BFA_SM(bfa_iocpf_sm_initfail_sync), BFA_IOCPF_INITFAIL},
         {BFA_SM(bfa_iocpf_sm_initfail), BFA_IOCPF_INITFAIL},
+        {BFA_SM(bfa_iocpf_sm_fail_sync), BFA_IOCPF_FAIL},
         {BFA_SM(bfa_iocpf_sm_fail), BFA_IOCPF_FAIL},
         {BFA_SM(bfa_iocpf_sm_disabling), BFA_IOCPF_DISABLING},
+        {BFA_SM(bfa_iocpf_sm_disabling_sync), BFA_IOCPF_DISABLING},
         {BFA_SM(bfa_iocpf_sm_disabled), BFA_IOCPF_DISABLED},
 };
 
@@ -301,7 +291,7 @@ bfa_ioc_sm_reset(struct bfa_ioc_s *ioc, enum ioc_event event)
 static void
 bfa_ioc_sm_enabling_entry(struct bfa_ioc_s *ioc)
 {
-        bfa_iocpf_enable(ioc);
+        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_ENABLE);
 }
 
 /*
@@ -318,13 +308,13 @@ bfa_ioc_sm_enabling(struct bfa_ioc_s *ioc, enum ioc_event event)
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
                 break;
 
-        case IOC_E_FAILED:
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
-                break;
-
+        case IOC_E_PFFAILED:
+                /* !!! fall through !!! */
         case IOC_E_HWERROR:
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
-                bfa_iocpf_initfail(ioc);
+                ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
+                bfa_fsm_set_state(ioc, bfa_ioc_sm_fail_retry);
+                if (event != IOC_E_PFFAILED)
+                        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
                 break;
 
         case IOC_E_DISABLE:
@@ -333,7 +323,7 @@ bfa_ioc_sm_enabling(struct bfa_ioc_s *ioc, enum ioc_event event)
 
         case IOC_E_DETACH:
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
-                bfa_iocpf_stop(ioc);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
                 break;
 
         case IOC_E_ENABLE:
@@ -367,18 +357,16 @@ bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
                 break;
 
-        case IOC_E_FAILED:
-                bfa_ioc_timer_stop(ioc);
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
                 break;
-
+        case IOC_E_PFFAILED:
         case IOC_E_HWERROR:
                 bfa_ioc_timer_stop(ioc);
-                /* fall through */
-
+                /* !!! fall through !!! */
         case IOC_E_TIMEOUT:
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
-                bfa_iocpf_getattrfail(ioc);
+                ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
+                bfa_fsm_set_state(ioc, bfa_ioc_sm_fail_retry);
+                if (event != IOC_E_PFFAILED)
+                        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
                 break;
 
         case IOC_E_DISABLE:
@@ -415,22 +403,24 @@ bfa_ioc_sm_op(struct bfa_ioc_s *ioc, enum ioc_event event)
                 break;
 
         case IOC_E_DISABLE:
-                bfa_ioc_hb_stop(ioc);
+                bfa_hb_timer_stop(ioc);
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
                 break;
 
-        case IOC_E_FAILED:
-                bfa_ioc_hb_stop(ioc);
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
-                break;
-
+        case IOC_E_PFFAILED:
         case IOC_E_HWERROR:
-                bfa_ioc_hb_stop(ioc);
+                bfa_hb_timer_stop(ioc);
                 /* !!! fall through !!! */
-
         case IOC_E_HBFAIL:
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
-                bfa_iocpf_fail(ioc);
+                bfa_ioc_fail_notify(ioc);
+
+                if (ioc->iocpf.auto_recover)
+                        bfa_fsm_set_state(ioc, bfa_ioc_sm_fail_retry);
+                else
+                        bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
+
+                if (event != IOC_E_PFFAILED)
+                        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
                 break;
 
         default:
@@ -443,7 +433,7 @@ static void
 bfa_ioc_sm_disabling_entry(struct bfa_ioc_s *ioc)
 {
         struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
-        bfa_iocpf_disable(ioc);
+        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
         BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC disabled\n");
 }
 
@@ -466,7 +456,7 @@ bfa_ioc_sm_disabling(struct bfa_ioc_s *ioc, enum ioc_event event)
                  * after iocpf sm completes failure processing and
                  * moves to disabled state.
                  */
-                bfa_iocpf_fail(ioc);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
                 break;
 
         default:
@@ -499,7 +489,7 @@ bfa_ioc_sm_disabled(struct bfa_ioc_s *ioc, enum ioc_event event)
 
         case IOC_E_DETACH:
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
-                bfa_iocpf_stop(ioc);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
                 break;
 
         default:
@@ -509,16 +499,16 @@ bfa_ioc_sm_disabled(struct bfa_ioc_s *ioc, enum ioc_event event)
 
 
 static void
-bfa_ioc_sm_initfail_entry(struct bfa_ioc_s *ioc)
+bfa_ioc_sm_fail_retry_entry(struct bfa_ioc_s *ioc)
 {
-        ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
+        bfa_trc(ioc, 0);
 }
 
 /*
- * Hardware initialization failed.
+ * Hardware initialization retry.
  */
 static void
-bfa_ioc_sm_initfail(struct bfa_ioc_s *ioc, enum ioc_event event)
+bfa_ioc_sm_fail_retry(struct bfa_ioc_s *ioc, enum ioc_event event)
 {
         bfa_trc(ioc, event);
 
@@ -527,11 +517,21 @@ bfa_ioc_sm_initfail(struct bfa_ioc_s *ioc, enum ioc_event event)
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
                 break;
 
-        case IOC_E_FAILED:
+        case IOC_E_PFFAILED:
+        case IOC_E_HWERROR:
                 /*
-                 * Initialization failure during iocpf init retry.
+                 * Initialization retry failed.
                  */
                 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
+                if (event != IOC_E_PFFAILED)
+                        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
+                break;
+
+        case IOC_E_INITFAILED:
+                bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
+                break;
+
+        case IOC_E_ENABLE:
                 break;
 
         case IOC_E_DISABLE:
@@ -540,7 +540,7 @@ bfa_ioc_sm_initfail(struct bfa_ioc_s *ioc, enum ioc_event event)
 
         case IOC_E_DETACH:
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
-                bfa_iocpf_stop(ioc);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
                 break;
 
         default:
@@ -552,21 +552,7 @@ bfa_ioc_sm_initfail(struct bfa_ioc_s *ioc, enum ioc_event event)
 static void
 bfa_ioc_sm_fail_entry(struct bfa_ioc_s *ioc)
 {
-        struct list_head                        *qe;
-        struct bfa_ioc_hbfail_notify_s  *notify;
-        struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
-
-        /*
-         * Notify driver and common modules registered for notification.
-         */
-        ioc->cbfn->hbfail_cbfn(ioc->bfa);
-        list_for_each(qe, &ioc->hb_notify_q) {
-                notify = (struct bfa_ioc_hbfail_notify_s *) qe;
-                notify->cbfn(notify->cbarg);
-        }
-
-        BFA_LOG(KERN_CRIT, bfad, bfa_log_level,
-                "Heart Beat of IOC has failed\n");
+        bfa_trc(ioc, 0);
 }
 
 /*
@@ -579,23 +565,19 @@ bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
 
         switch (event) {
 
-        case IOC_E_FAILED:
-                /*
-                 * Initialization failure during iocpf recovery.
-                 * !!! Fall through !!!
-                 */
         case IOC_E_ENABLE:
                 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
                 break;
 
-        case IOC_E_ENABLED:
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
-                break;
-
         case IOC_E_DISABLE:
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
                 break;
 
+        case IOC_E_DETACH:
+                bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
+                bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
+                break;
+
         case IOC_E_HWERROR:
                 /*
                  * HB failure notification, ignore.
@@ -606,13 +588,10 @@ bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
         }
 }
 
-
-
 /*
  * IOCPF State Machine
  */
 
-
 /*
  * Reset entry actions -- initialize state machine
  */
@@ -668,22 +647,29 @@ bfa_iocpf_sm_fwcheck(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         switch (event) {
         case IOCPF_E_SEMLOCKED:
                 if (bfa_ioc_firmware_lock(ioc)) {
-                        iocpf->retry_count = 0;
-                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
+                        if (bfa_ioc_sync_complete(ioc)) {
+                                iocpf->retry_count = 0;
+                                bfa_ioc_sync_join(ioc);
+                                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
+                        } else {
+                                bfa_ioc_firmware_unlock(ioc);
+                                writel(1, ioc->ioc_regs.ioc_sem_reg);
+                                bfa_sem_timer_start(ioc);
+                        }
                 } else {
-                        bfa_ioc_hw_sem_release(ioc);
+                        writel(1, ioc->ioc_regs.ioc_sem_reg);
                         bfa_fsm_set_state(iocpf, bfa_iocpf_sm_mismatch);
                 }
                 break;
 
         case IOCPF_E_DISABLE:
-                bfa_ioc_hw_sem_get_cancel(ioc);
+                bfa_sem_timer_stop(ioc);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
-                bfa_ioc_pf_disabled(ioc);
+                bfa_fsm_send_event(ioc, IOC_E_DISABLED);
                 break;
 
         case IOCPF_E_STOP:
-                bfa_ioc_hw_sem_get_cancel(ioc);
+                bfa_sem_timer_stop(ioc);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
                 break;
 
@@ -726,7 +712,7 @@ bfa_iocpf_sm_mismatch(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         case IOCPF_E_DISABLE:
                 bfa_iocpf_timer_stop(ioc);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
-                bfa_ioc_pf_disabled(ioc);
+                bfa_fsm_send_event(ioc, IOC_E_DISABLED);
                 break;
 
         case IOCPF_E_STOP:
@@ -760,13 +746,18 @@ bfa_iocpf_sm_semwait(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
 
         switch (event) {
         case IOCPF_E_SEMLOCKED:
-                iocpf->retry_count = 0;
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
+                if (bfa_ioc_sync_complete(ioc)) {
+                        bfa_ioc_sync_join(ioc);
+                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
+                } else {
+                        writel(1, ioc->ioc_regs.ioc_sem_reg);
+                        bfa_sem_timer_start(ioc);
+                }
                 break;
 
         case IOCPF_E_DISABLE:
-                bfa_ioc_hw_sem_get_cancel(ioc);
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
+                bfa_sem_timer_stop(ioc);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
                 break;
 
         default:
@@ -774,12 +765,11 @@ bfa_iocpf_sm_semwait(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         }
 }
 
-
 static void
 bfa_iocpf_sm_hwinit_entry(struct bfa_iocpf_s *iocpf)
 {
         bfa_iocpf_timer_start(iocpf->ioc);
-        bfa_ioc_reset(iocpf->ioc, BFA_FALSE);
+        bfa_ioc_hwinit(iocpf->ioc, BFA_FALSE);
 }
 
 /*
@@ -806,23 +796,16 @@ bfa_iocpf_sm_hwinit(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
                  */
 
         case IOCPF_E_TIMEOUT:
-                iocpf->retry_count++;
-                if (iocpf->retry_count < BFA_IOC_HWINIT_MAX) {
-                        bfa_iocpf_timer_start(ioc);
-                        bfa_ioc_reset(ioc, BFA_TRUE);
-                        break;
-                }
-
-                bfa_ioc_hw_sem_release(ioc);
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
-
+                writel(1, ioc->ioc_regs.ioc_sem_reg);
                 if (event == IOCPF_E_TIMEOUT)
-                        bfa_ioc_pf_failed(ioc);
+                        bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
                 break;
 
         case IOCPF_E_DISABLE:
-                bfa_ioc_hw_sem_release(ioc);
                 bfa_iocpf_timer_stop(ioc);
+                bfa_ioc_sync_leave(ioc);
+                writel(1, ioc->ioc_regs.ioc_sem_reg);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
                 break;
 
@@ -831,7 +814,6 @@ bfa_iocpf_sm_hwinit(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         }
 }
 
-
 static void
 bfa_iocpf_sm_enabling_entry(struct bfa_iocpf_s *iocpf)
 {
@@ -853,7 +835,7 @@ bfa_iocpf_sm_enabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         switch (event) {
         case IOCPF_E_FWRSP_ENABLE:
                 bfa_iocpf_timer_stop(ioc);
-                bfa_ioc_hw_sem_release(ioc);
+                writel(1, ioc->ioc_regs.ioc_sem_reg);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_ready);
                 break;
 
@@ -864,23 +846,15 @@ bfa_iocpf_sm_enabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
                  */
 
         case IOCPF_E_TIMEOUT:
-                iocpf->retry_count++;
-                if (iocpf->retry_count < BFA_IOC_HWINIT_MAX) {
-                        writel(BFI_IOC_UNINIT, ioc->ioc_regs.ioc_fwstate);
-                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
-                        break;
-                }
-
-                bfa_ioc_hw_sem_release(ioc);
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
-
+                writel(1, ioc->ioc_regs.ioc_sem_reg);
                 if (event == IOCPF_E_TIMEOUT)
-                        bfa_ioc_pf_failed(ioc);
+                        bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
                 break;
 
         case IOCPF_E_DISABLE:
                 bfa_iocpf_timer_stop(ioc);
-                bfa_ioc_hw_sem_release(ioc);
+                writel(1, ioc->ioc_regs.ioc_sem_reg);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
                 break;
 
@@ -893,12 +867,10 @@ bfa_iocpf_sm_enabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         }
 }
 
-
-
 static void
 bfa_iocpf_sm_ready_entry(struct bfa_iocpf_s *iocpf)
 {
-        bfa_ioc_pf_enabled(iocpf->ioc);
+        bfa_fsm_send_event(iocpf->ioc, IOC_E_ENABLED);
 }
 
 static void
@@ -914,20 +886,21 @@ bfa_iocpf_sm_ready(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
                 break;
 
         case IOCPF_E_GETATTRFAIL:
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
                 break;
 
         case IOCPF_E_FAIL:
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail_sync);
                 break;
 
         case IOCPF_E_FWREADY:
-                if (bfa_ioc_is_operational(ioc))
-                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
-                else
-                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
-
-                bfa_ioc_pf_failed(ioc);
+                if (bfa_ioc_is_operational(ioc)) {
+                        bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
+                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail_sync);
+                } else {
+                        bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
+                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
+                }
                 break;
 
         default:
@@ -935,7 +908,6 @@ bfa_iocpf_sm_ready(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         }
 }
 
-
 static void
 bfa_iocpf_sm_disabling_entry(struct bfa_iocpf_s *iocpf)
 {
@@ -957,7 +929,7 @@ bfa_iocpf_sm_disabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         case IOCPF_E_FWRSP_DISABLE:
         case IOCPF_E_FWREADY:
                 bfa_iocpf_timer_stop(ioc);
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
                 break;
 
         case IOCPF_E_FAIL:
@@ -968,7 +940,7 @@ bfa_iocpf_sm_disabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
 
         case IOCPF_E_TIMEOUT:
                 writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
                 break;
 
         case IOCPF_E_FWRSP_ENABLE:
@@ -979,13 +951,44 @@ bfa_iocpf_sm_disabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         }
 }
 
+static void
+bfa_iocpf_sm_disabling_sync_entry(struct bfa_iocpf_s *iocpf)
+{
+        bfa_ioc_hw_sem_get(iocpf->ioc);
+}
+
+/*
+ * IOC hb ack request is being removed.
+ */
+static void
+bfa_iocpf_sm_disabling_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
+{
+        struct bfa_ioc_s *ioc = iocpf->ioc;
+
+        bfa_trc(ioc, event);
+
+        switch (event) {
+        case IOCPF_E_SEMLOCKED:
+                bfa_ioc_sync_leave(ioc);
+                writel(1, ioc->ioc_regs.ioc_sem_reg);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
+                break;
+
+        case IOCPF_E_FAIL:
+                break;
+
+        default:
+                bfa_sm_fault(ioc, event);
+        }
+}
+
 /*
  * IOC disable completion entry.
  */
 static void
 bfa_iocpf_sm_disabled_entry(struct bfa_iocpf_s *iocpf)
 {
-        bfa_ioc_pf_disabled(iocpf->ioc);
+        bfa_fsm_send_event(iocpf->ioc, IOC_E_DISABLED);
 }
 
 static void
@@ -997,6 +1000,7 @@ bfa_iocpf_sm_disabled(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
 
         switch (event) {
         case IOCPF_E_ENABLE:
+                iocpf->retry_count = 0;
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
                 break;
 
@@ -1010,11 +1014,64 @@ bfa_iocpf_sm_disabled(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         }
 }
 
+static void
+bfa_iocpf_sm_initfail_sync_entry(struct bfa_iocpf_s *iocpf)
+{
+        bfa_ioc_hw_sem_get(iocpf->ioc);
+}
+
+/*
+ * Hardware initialization failed.
+ */
+static void
+bfa_iocpf_sm_initfail_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
+{
+        struct bfa_ioc_s *ioc = iocpf->ioc;
+
+        bfa_trc(ioc, event);
+
+        switch (event) {
+        case IOCPF_E_SEMLOCKED:
+                bfa_ioc_notify_fail(ioc);
+                bfa_ioc_sync_ack(ioc);
+                iocpf->retry_count++;
+                if (iocpf->retry_count >= BFA_IOC_HWINIT_MAX) {
+                        bfa_ioc_sync_leave(ioc);
+                        writel(1, ioc->ioc_regs.ioc_sem_reg);
+                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
+                } else {
+                        if (bfa_ioc_sync_complete(ioc))
+                                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
+                        else {
+                                writel(1, ioc->ioc_regs.ioc_sem_reg);
+                                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
+                        }
+                }
+                break;
+
+        case IOCPF_E_DISABLE:
+                bfa_sem_timer_stop(ioc);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
+                break;
+
+        case IOCPF_E_STOP:
+                bfa_sem_timer_stop(ioc);
+                bfa_ioc_firmware_unlock(ioc);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
+                break;
+
+        case IOCPF_E_FAIL:
+                break;
+
+        default:
+                bfa_sm_fault(ioc, event);
+        }
+}
 
 static void
 bfa_iocpf_sm_initfail_entry(struct bfa_iocpf_s *iocpf)
 {
-        bfa_iocpf_timer_start(iocpf->ioc);
+        bfa_fsm_send_event(iocpf->ioc, IOC_E_INITFAILED);
 }
 
 /*
@@ -1029,47 +1086,77 @@ bfa_iocpf_sm_initfail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
 
         switch (event) {
         case IOCPF_E_DISABLE:
-                bfa_iocpf_timer_stop(ioc);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
                 break;
 
         case IOCPF_E_STOP:
-                bfa_iocpf_timer_stop(ioc);
                 bfa_ioc_firmware_unlock(ioc);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
                 break;
 
-        case IOCPF_E_TIMEOUT:
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
-                break;
-
         default:
                 bfa_sm_fault(ioc, event);
         }
 }
 
-
 static void
-bfa_iocpf_sm_fail_entry(struct bfa_iocpf_s *iocpf)
+bfa_iocpf_sm_fail_sync_entry(struct bfa_iocpf_s *iocpf)
 {
         /*
          * Mark IOC as failed in hardware and stop firmware.
          */
         bfa_ioc_lpu_stop(iocpf->ioc);
-        writel(BFI_IOC_FAIL, iocpf->ioc->ioc_regs.ioc_fwstate);
-
-        /*
-         * Notify other functions on HB failure.
-         */
-        bfa_ioc_notify_hbfail(iocpf->ioc);
 
         /*
          * Flush any queued up mailbox requests.
          */
         bfa_ioc_mbox_hbfail(iocpf->ioc);
 
-        if (iocpf->auto_recover)
-                bfa_iocpf_recovery_timer_start(iocpf->ioc);
+        bfa_ioc_hw_sem_get(iocpf->ioc);
+}
+
+static void
+bfa_iocpf_sm_fail_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
+{
+        struct bfa_ioc_s *ioc = iocpf->ioc;
+
+        bfa_trc(ioc, event);
+
+        switch (event) {
+        case IOCPF_E_SEMLOCKED:
+                iocpf->retry_count = 0;
+                bfa_ioc_sync_ack(ioc);
+                bfa_ioc_notify_fail(ioc);
+                if (!iocpf->auto_recover) {
+                        bfa_ioc_sync_leave(ioc);
+                        writel(1, ioc->ioc_regs.ioc_sem_reg);
+                        bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
+                } else {
+                        if (bfa_ioc_sync_complete(ioc))
+                                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
+                        else {
+                                writel(1, ioc->ioc_regs.ioc_sem_reg);
+                                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
+                        }
+                }
+                break;
+
+        case IOCPF_E_DISABLE:
+                bfa_sem_timer_stop(ioc);
+                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
+                break;
+
+        case IOCPF_E_FAIL:
+                break;
+
+        default:
+                bfa_sm_fault(ioc, event);
+        }
+}
+
+static void
+bfa_iocpf_sm_fail_entry(struct bfa_iocpf_s *iocpf)
+{
 }
 
 /*
@@ -1084,24 +1171,16 @@ bfa_iocpf_sm_fail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
 
         switch (event) {
         case IOCPF_E_DISABLE:
-                if (iocpf->auto_recover)
-                        bfa_iocpf_timer_stop(ioc);
                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
                 break;
 
-        case IOCPF_E_TIMEOUT:
-                bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
-                break;
-
         default:
                 bfa_sm_fault(ioc, event);
         }
 }
 
-
-
 /*
- *  hal_ioc_pvt BFA IOC private functions
+ *  BFA IOC private functions
  */
 
 static void
@@ -1139,16 +1218,10 @@ bfa_ioc_sem_get(void __iomem *sem_reg)
         if (r32 == 0)
                 return BFA_TRUE;
 
-        bfa_assert(cnt < BFA_SEM_SPINCNT);
+        WARN_ON(cnt >= BFA_SEM_SPINCNT);
         return BFA_FALSE;
 }
 
-void
-bfa_ioc_sem_release(void __iomem *sem_reg)
-{
-        writel(1, sem_reg);
-}
-
 static void
 bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
 {
@@ -1167,18 +1240,6 @@ bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
         bfa_sem_timer_start(ioc);
 }
 
-void
-bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc)
-{
-        writel(1, ioc->ioc_regs.ioc_sem_reg);
-}
-
-static void
-bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc)
-{
-        bfa_sem_timer_stop(ioc);
-}
-
 /*
  * Initialize LPU local memory (aka secondary memory / SRAM)
  */
@@ -1212,7 +1273,7 @@ bfa_ioc_lmem_init(struct bfa_ioc_s *ioc)
          * If memory initialization is not successful, IOC timeout will catch
          * such failures.
          */
-        bfa_assert(pss_ctl & __PSS_LMEM_INIT_DONE);
+        WARN_ON(!(pss_ctl & __PSS_LMEM_INIT_DONE));
         bfa_trc(ioc, pss_ctl);
 
         pss_ctl &= ~(__PSS_LMEM_INIT_DONE | __PSS_LMEM_INIT_EN);
@@ -1258,8 +1319,8 @@ bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
         int             i;
         u32     *fwsig = (u32 *) fwhdr;
 
-        pgnum = bfa_ioc_smem_pgnum(ioc, loff);
-        pgoff = bfa_ioc_smem_pgoff(ioc, loff);
+        pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
+        pgoff = PSS_SMEM_PGOFF(loff);
         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
 
         for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));
@@ -1304,12 +1365,6 @@ bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc, u32 boot_env)
 {
         struct bfi_ioc_image_hdr_s fwhdr, *drv_fwhdr;
 
-        /*
-         * If bios/efi boot (flash based) -- return true
-         */
-        if (bfa_ioc_is_bios_optrom(ioc))
-                return BFA_TRUE;
-
         bfa_ioc_fwver_get(ioc, &fwhdr);
         drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
                 bfa_cb_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
@@ -1342,7 +1397,6 @@ bfa_ioc_msgflush(struct bfa_ioc_s *ioc)
                 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
 }
 
-
 static void
 bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
 {
@@ -1362,22 +1416,6 @@ bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
         boot_env = BFI_BOOT_LOADER_OS;
 
         /*
-         * Flash based firmware boot BIOS env.
-         */
-        if (bfa_ioc_is_bios_optrom(ioc)) {
-                boot_type = BFI_BOOT_TYPE_FLASH;
-                boot_env = BFI_BOOT_LOADER_BIOS;
-        }
-
-        /*
-         * Flash based firmware boot UEFI env.
-         */
-        if (bfa_ioc_is_uefi(ioc)) {
-                boot_type = BFI_BOOT_TYPE_FLASH;
-                boot_env = BFI_BOOT_LOADER_UEFI;
-        }
-
-        /*
          * check if firmware is valid
          */
         fwvalid = (ioc_fwstate == BFI_IOC_UNINIT) ?
@@ -1405,8 +1443,7 @@ bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
          * convergence, IOC will be in operational state when 2nd driver
          * is loaded.
          */
-        if (ioc_fwstate == BFI_IOC_DISABLED ||
-            (!bfa_ioc_is_bios_optrom(ioc) && ioc_fwstate == BFI_IOC_OP)) {
+        if (ioc_fwstate == BFI_IOC_DISABLED || ioc_fwstate == BFI_IOC_OP) {
 
                 /*
                  * When using MSI-X any pending firmware ready event should
@@ -1442,7 +1479,7 @@ bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len)
         bfa_trc(ioc, msgp[0]);
         bfa_trc(ioc, len);
 
-        bfa_assert(len <= BFI_IOC_MSGLEN_MAX);
+        WARN_ON(len > BFI_IOC_MSGLEN_MAX);
 
         /*
          * first write msg to mailbox registers
@@ -1465,12 +1502,12 @@ static void
 bfa_ioc_send_enable(struct bfa_ioc_s *ioc)
 {
         struct bfi_ioc_ctrl_req_s enable_req;
-        struct bfa_timeval_s tv;
+        struct timeval tv;
 
         bfi_h2i_set(enable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_ENABLE_REQ,
                     bfa_ioc_portid(ioc));
         enable_req.ioc_class = ioc->ioc_mc;
-        bfa_os_gettimeofday(&tv);
+        do_gettimeofday(&tv);
         enable_req.tv_sec = be32_to_cpu(tv.tv_sec);
         bfa_ioc_mbox_send(ioc, &enable_req, sizeof(struct bfi_ioc_ctrl_req_s));
 }
@@ -1504,7 +1541,6 @@ bfa_ioc_hb_check(void *cbarg)
 
         hb_count = readl(ioc->ioc_regs.heartbeat);
         if (ioc->hb_count == hb_count) {
-                printk(KERN_CRIT "Firmware heartbeat failure at %d", hb_count);
                 bfa_ioc_recover(ioc);
                 return;
         } else {
@@ -1522,13 +1558,6 @@ bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc)
         bfa_hb_timer_start(ioc);
 }
 
-static void
-bfa_ioc_hb_stop(struct bfa_ioc_s *ioc)
-{
-        bfa_hb_timer_stop(ioc);
-}
-
-
 /*
  *      Initiate a full firmware download.
  */
@@ -1550,8 +1579,8 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
         bfa_trc(ioc, bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)));
         fwimg = bfa_cb_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), chunkno);
 
-        pgnum = bfa_ioc_smem_pgnum(ioc, loff);
-        pgoff = bfa_ioc_smem_pgoff(ioc, loff);
+        pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
+        pgoff = PSS_SMEM_PGOFF(loff);
 
         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
 
@@ -1581,7 +1610,8 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
                 }
         }
 
-        writel(bfa_ioc_smem_pgnum(ioc, 0), ioc->ioc_regs.host_page_num_fn);
+        writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
+                        ioc->ioc_regs.host_page_num_fn);
 
         /*
          * Set boot type and boot param at the end.
@@ -1592,11 +1622,6 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
                         swab32(boot_env));
 }
 
-static void
-bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force)
-{
-        bfa_ioc_hwinit(ioc, force);
-}
 
 /*
  * Update BFA configuration from firmware configuration.
@@ -1683,12 +1708,13 @@ bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc)
 static bfa_status_t
 bfa_ioc_smem_read(struct bfa_ioc_s *ioc, void *tbuf, u32 soff, u32 sz)
 {
-        u32 pgnum, loff, r32;
+        u32 pgnum, loff;
+        __be32 r32;
         int i, len;
         u32 *buf = tbuf;
 
-        pgnum = bfa_ioc_smem_pgnum(ioc, soff);
-        loff = bfa_ioc_smem_pgoff(ioc, soff);
+        pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, soff);
+        loff = PSS_SMEM_PGOFF(soff);
         bfa_trc(ioc, pgnum);
         bfa_trc(ioc, loff);
         bfa_trc(ioc, sz);
@@ -1719,11 +1745,12 @@ bfa_ioc_smem_read(struct bfa_ioc_s *ioc, void *tbuf, u32 soff, u32 sz)
                         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
                 }
         }
-        writel(bfa_ioc_smem_pgnum(ioc, 0), ioc->ioc_regs.host_page_num_fn);
+        writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
+                        ioc->ioc_regs.host_page_num_fn);
         /*
          *  release semaphore.
          */
-        bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
+        writel(1, ioc->ioc_regs.ioc_init_sem_reg);
 
         bfa_trc(ioc, pgnum);
         return BFA_STATUS_OK;
@@ -1742,8 +1769,8 @@ bfa_ioc_smem_clr(struct bfa_ioc_s *ioc, u32 soff, u32 sz)
         int i, len;
         u32 pgnum, loff;
 
-        pgnum = bfa_ioc_smem_pgnum(ioc, soff);
-        loff = bfa_ioc_smem_pgoff(ioc, soff);
+        pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, soff);
+        loff = PSS_SMEM_PGOFF(soff);
         bfa_trc(ioc, pgnum);
         bfa_trc(ioc, loff);
         bfa_trc(ioc, sz);
@@ -1773,35 +1800,38 @@ bfa_ioc_smem_clr(struct bfa_ioc_s *ioc, u32 soff, u32 sz)
                         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
                 }
         }
-        writel(bfa_ioc_smem_pgnum(ioc, 0), ioc->ioc_regs.host_page_num_fn);
+        writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
+                        ioc->ioc_regs.host_page_num_fn);
 
         /*
          *  release semaphore.
          */
-        bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
+        writel(1, ioc->ioc_regs.ioc_init_sem_reg);
         bfa_trc(ioc, pgnum);
         return BFA_STATUS_OK;
 }
 
-/*
- * hal iocpf to ioc interface
- */
 static void
-bfa_ioc_pf_enabled(struct bfa_ioc_s *ioc)
+bfa_ioc_fail_notify(struct bfa_ioc_s *ioc)
 {
-        bfa_fsm_send_event(ioc, IOC_E_ENABLED);
-}
+        struct list_head                *qe;
+        struct bfa_ioc_hbfail_notify_s  *notify;
+        struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
 
-static void
-bfa_ioc_pf_disabled(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(ioc, IOC_E_DISABLED);
-}
+        /*
+         * Notify driver and common modules registered for notification.
+         */
+        ioc->cbfn->hbfail_cbfn(ioc->bfa);
+        list_for_each(qe, &ioc->hb_notify_q) {
+                notify = (struct bfa_ioc_hbfail_notify_s *) qe;
+                notify->cbfn(notify->cbarg);
+        }
+
+        bfa_ioc_debug_save_ftrc(ioc);
+
+        BFA_LOG(KERN_CRIT, bfad, bfa_log_level,
+                "Heart Beat of IOC has failed\n");
 
-static void
-bfa_ioc_pf_failed(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(ioc, IOC_E_FAILED);
 }
 
 static void
@@ -1817,12 +1847,6 @@ bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc)
                 "with the driver version\n");
 }
 
-
-
-/*
- *  hal_ioc_public
- */
-
 bfa_status_t
 bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
 {
@@ -1838,7 +1862,7 @@ bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
         /*
          *  release semaphore.
          */
-        bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
+        writel(1, ioc->ioc_regs.ioc_init_sem_reg);
 
         return BFA_STATUS_OK;
 }
@@ -1909,7 +1933,7 @@ bfa_ioc_is_initialized(struct bfa_ioc_s *ioc)
 void
 bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg)
 {
-        u32     *msgp = mbmsg;
+        __be32  *msgp = mbmsg;
         u32     r32;
         int             i;
 
@@ -1962,7 +1986,7 @@ bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
 
         default:
                 bfa_trc(ioc, msg->mh.msg_id);
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -2043,15 +2067,6 @@ bfa_ioc_mem_claim(struct bfa_ioc_s *ioc,  u8 *dm_kva, u64 dm_pa)
         ioc->attr = (struct bfi_ioc_attr_s *) dm_kva;
 }
 
-/*
- * Return size of dma memory required.
- */
-u32
-bfa_ioc_meminfo(void)
-{
-        return BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ);
-}
-
 void
 bfa_ioc_enable(struct bfa_ioc_s *ioc)
 {
@@ -2068,18 +2083,6 @@ bfa_ioc_disable(struct bfa_ioc_s *ioc)
         bfa_fsm_send_event(ioc, IOC_E_DISABLE);
 }
 
-/*
- * Returns memory required for saving firmware trace in case of crash.
- * Driver must call this interface to allocate memory required for
- * automatic saving of firmware trace. Driver should call
- * bfa_ioc_debug_memclaim() right after bfa_ioc_attach() to setup this
- * trace memory.
- */
-int
-bfa_ioc_debug_trcsz(bfa_boolean_t auto_recover)
-{
-        return (auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
-}
 
 /*
  * Initialize memory for saving firmware trace. Driver must initialize
@@ -2089,19 +2092,7 @@ void
 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
 {
         ioc->dbg_fwsave     = dbg_fwsave;
-        ioc->dbg_fwsave_len = bfa_ioc_debug_trcsz(ioc->iocpf.auto_recover);
-}
-
-u32
-bfa_ioc_smem_pgnum(struct bfa_ioc_s *ioc, u32 fmaddr)
-{
-        return PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, fmaddr);
-}
-
-u32
-bfa_ioc_smem_pgoff(struct bfa_ioc_s *ioc, u32 fmaddr)
-{
-        return PSS_SMEM_PGOFF(fmaddr);
+        ioc->dbg_fwsave_len = (ioc->iocpf.auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
 }
 
 /*
@@ -2265,14 +2256,13 @@ bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc)
 }
 
 /*
- * Add to IOC heartbeat failure notification queue. To be used by common
- * modules such as cee, port, diag.
+ * Reset IOC fwstate registers.
  */
 void
-bfa_ioc_hbfail_register(struct bfa_ioc_s *ioc,
-                        struct bfa_ioc_hbfail_notify_s *notify)
+bfa_ioc_reset_fwstate(struct bfa_ioc_s *ioc)
 {
-        list_add_tail(&notify->qe, &ioc->hb_notify_q);
+        writel(BFI_IOC_UNINIT, ioc->ioc_regs.ioc_fwstate);
+        writel(BFI_IOC_UNINIT, ioc->ioc_regs.alt_ioc_fwstate);
 }
 
 #define BFA_MFG_NAME "Brocade"
@@ -2306,7 +2296,7 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
         else
                 ad_attr->prototype = 0;
 
-        ad_attr->pwwn = bfa_ioc_get_pwwn(ioc);
+        ad_attr->pwwn = ioc->attr->pwwn;
         ad_attr->mac  = bfa_ioc_get_mac(ioc);
 
         ad_attr->pcie_gen = ioc_attr->pcie_gen;
@@ -2317,7 +2307,8 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
         bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
 
         ad_attr->cna_capable = ioc->cna;
-        ad_attr->trunk_capable = (ad_attr->nports > 1) && !ioc->cna;
+        ad_attr->trunk_capable = (ad_attr->nports > 1) && !ioc->cna &&
+                                !ad_attr->is_mezz;
 }
 
 enum bfa_ioc_type_e
@@ -2330,7 +2321,7 @@ bfa_ioc_get_type(struct bfa_ioc_s *ioc)
         else if (ioc->ioc_mc == BFI_MC_LL)
                 return BFA_IOC_TYPE_LL;
         else {
-                bfa_assert(ioc->ioc_mc == BFI_MC_LL);
+                WARN_ON(ioc->ioc_mc != BFI_MC_LL);
                 return BFA_IOC_TYPE_LL;
         }
 }
@@ -2354,7 +2345,7 @@ bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)
 void
 bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)
 {
-        bfa_assert(chip_rev);
+        WARN_ON(!chip_rev);
 
         memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
 
@@ -2386,7 +2377,7 @@ bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)
 {
         struct bfi_ioc_attr_s   *ioc_attr;
 
-        bfa_assert(model);
+        WARN_ON(!model);
         memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
 
         ioc_attr = ioc->attr;
@@ -2455,27 +2446,6 @@ bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)
         bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
 }
 
-/*
- *  hal_wwn_public
- */
-wwn_t
-bfa_ioc_get_pwwn(struct bfa_ioc_s *ioc)
-{
-        return ioc->attr->pwwn;
-}
-
-wwn_t
-bfa_ioc_get_nwwn(struct bfa_ioc_s *ioc)
-{
-        return ioc->attr->nwwn;
-}
-
-u64
-bfa_ioc_get_adid(struct bfa_ioc_s *ioc)
-{
-        return ioc->attr->mfg_pwwn;
-}
-
 mac_t
 bfa_ioc_get_mac(struct bfa_ioc_s *ioc)
 {
@@ -2488,18 +2458,6 @@ bfa_ioc_get_mac(struct bfa_ioc_s *ioc)
                 return ioc->attr->mac;
 }
 
-wwn_t
-bfa_ioc_get_mfg_pwwn(struct bfa_ioc_s *ioc)
-{
-        return ioc->attr->mfg_pwwn;
-}
-
-wwn_t
-bfa_ioc_get_mfg_nwwn(struct bfa_ioc_s *ioc)
-{
-        return ioc->attr->mfg_nwwn;
-}
-
 mac_t
 bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc)
 {
@@ -2541,14 +2499,6 @@ bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
         return BFA_STATUS_OK;
 }
 
-/*
- * Clear saved firmware trace
- */
-void
-bfa_ioc_debug_fwsave_clear(struct bfa_ioc_s *ioc)
-{
-        ioc->dbg_fwsave_once = BFA_TRUE;
-}
 
 /*
  * Retrieve saved firmware trace from a prior IOC failure.
@@ -2701,13 +2651,16 @@ bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc)
  * Save firmware trace if configured.
  */
 static void
-bfa_ioc_debug_save(struct bfa_ioc_s *ioc)
+bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc)
 {
         int             tlen;
 
-        if (ioc->dbg_fwsave_len) {
-                tlen = ioc->dbg_fwsave_len;
-                bfa_ioc_debug_fwtrc(ioc, ioc->dbg_fwsave, &tlen);
+        if (ioc->dbg_fwsave_once) {
+                ioc->dbg_fwsave_once = BFA_FALSE;
+                if (ioc->dbg_fwsave_len) {
+                        tlen = ioc->dbg_fwsave_len;
+                        bfa_ioc_debug_fwtrc(ioc, ioc->dbg_fwsave, &tlen);
+                }
         }
 }
 
@@ -2717,11 +2670,6 @@ bfa_ioc_debug_save(struct bfa_ioc_s *ioc)
 static void
 bfa_ioc_recover(struct bfa_ioc_s *ioc)
 {
-        if (ioc->dbg_fwsave_once) {
-                ioc->dbg_fwsave_once = BFA_FALSE;
-                bfa_ioc_debug_save(ioc);
-        }
-
         bfa_ioc_stats(ioc, ioc_hbfails);
         bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
 }
@@ -2734,45 +2682,8 @@ bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc)
 }
 
 /*
- *  hal_iocpf_pvt BFA IOC PF private functions
+ *  BFA IOC PF private functions
  */
-
-static void
-bfa_iocpf_enable(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_ENABLE);
-}
-
-static void
-bfa_iocpf_disable(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
-}
-
-static void
-bfa_iocpf_fail(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
-}
-
-static void
-bfa_iocpf_initfail(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
-}
-
-static void
-bfa_iocpf_getattrfail(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
-}
-
-static void
-bfa_iocpf_stop(struct bfa_ioc_s *ioc)
-{
-        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
-}
-
 static void
 bfa_iocpf_timeout(void *ioc_arg)
 {
@@ -2794,12 +2705,6 @@ bfa_iocpf_sem_timeout(void *ioc_arg)
  *  bfa timer function
  */
 void
-bfa_timer_init(struct bfa_timer_mod_s *mod)
-{
-        INIT_LIST_HEAD(&mod->timer_q);
-}
-
-void
 bfa_timer_beat(struct bfa_timer_mod_s *mod)
 {
         struct list_head *qh = &mod->timer_q;
@@ -2843,8 +2748,8 @@ bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
                     void (*timercb) (void *), void *arg, unsigned int timeout)
 {
 
-        bfa_assert(timercb != NULL);
-        bfa_assert(!bfa_q_is_on_q(&mod->timer_q, timer));
+        WARN_ON(timercb == NULL);
+        WARN_ON(bfa_q_is_on_q(&mod->timer_q, timer));
 
         timer->timeout = timeout;
         timer->timercb = timercb;
@@ -2859,7 +2764,7 @@ bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
 void
 bfa_timer_stop(struct bfa_timer_s *timer)
 {
-        bfa_assert(!list_empty(&timer->qe));
+        WARN_ON(list_empty(&timer->qe));
 
         list_del(&timer->qe);
 }
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index 9c407a87a1a1..ec9cf08b0e7f 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -18,10 +18,15 @@
 #ifndef __BFA_IOC_H__
 #define __BFA_IOC_H__
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 #include "bfa_cs.h"
 #include "bfi.h"
 
+#define BFA_DBG_FWTRC_ENTS      (BFI_IOC_TRC_ENTS)
+#define BFA_DBG_FWTRC_LEN                                       \
+        (BFA_DBG_FWTRC_ENTS * sizeof(struct bfa_trc_s) +        \
+        (sizeof(struct bfa_trc_mod_s) -                         \
+        BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
 /*
  * BFA timer declarations
  */
@@ -47,7 +52,6 @@ struct bfa_timer_mod_s {
 #define BFA_TIMER_FREQ 200 /* specified in millisecs */
 
 void bfa_timer_beat(struct bfa_timer_mod_s *mod);
-void bfa_timer_init(struct bfa_timer_mod_s *mod);
 void bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
                         bfa_timer_cbfn_t timercb, void *arg,
                         unsigned int timeout);
@@ -70,7 +74,7 @@ struct bfa_sge_s {
 #define bfa_swap_words(_x)  (   \
         ((_x) << 32) | ((_x) >> 32))
 
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
 #define bfa_sge_to_be(_x)
 #define bfa_sge_to_le(_x)       bfa_sge_word_swap(_x)
 #define bfa_sgaddr_le(_x)       bfa_swap_words(_x)
@@ -115,8 +119,8 @@ struct bfa_dma_s {
 static inline void
 __bfa_dma_addr_set(union bfi_addr_u *dma_addr, u64 pa)
 {
-        dma_addr->a32.addr_lo = (u32) pa;
-        dma_addr->a32.addr_hi = (u32) (bfa_os_u32(pa));
+        dma_addr->a32.addr_lo = (__be32) pa;
+        dma_addr->a32.addr_hi = (__be32) (pa >> 32);
 }
 
 
@@ -125,8 +129,8 @@ __bfa_dma_addr_set(union bfi_addr_u *dma_addr, u64 pa)
 static inline void
 __bfa_dma_be_addr_set(union bfi_addr_u *dma_addr, u64 pa)
 {
-        dma_addr->a32.addr_lo = (u32) cpu_to_be32(pa);
-        dma_addr->a32.addr_hi = (u32) cpu_to_be32(bfa_os_u32(pa));
+        dma_addr->a32.addr_lo = cpu_to_be32(pa);
+        dma_addr->a32.addr_hi = cpu_to_be32(pa >> 32);
 }
 
 struct bfa_ioc_regs_s {
@@ -145,8 +149,11 @@ struct bfa_ioc_regs_s {
         void __iomem *host_page_num_fn;
         void __iomem *heartbeat;
         void __iomem *ioc_fwstate;
+        void __iomem *alt_ioc_fwstate;
         void __iomem *ll_halt;
+        void __iomem *alt_ll_halt;
         void __iomem *err_set;
+        void __iomem *ioc_fail_sync;
         void __iomem *shirq_isr_next;
         void __iomem *shirq_msk_next;
         void __iomem *smem_page_start;
@@ -254,8 +261,12 @@ struct bfa_ioc_hwif_s {
         void            (*ioc_map_port) (struct bfa_ioc_s *ioc);
         void            (*ioc_isr_mode_set)     (struct bfa_ioc_s *ioc,
                                         bfa_boolean_t msix);
-        void            (*ioc_notify_hbfail)    (struct bfa_ioc_s *ioc);
+        void            (*ioc_notify_fail)      (struct bfa_ioc_s *ioc);
         void            (*ioc_ownership_reset)  (struct bfa_ioc_s *ioc);
+        void            (*ioc_sync_join)        (struct bfa_ioc_s *ioc);
+        void            (*ioc_sync_leave)       (struct bfa_ioc_s *ioc);
+        void            (*ioc_sync_ack)         (struct bfa_ioc_s *ioc);
+        bfa_boolean_t   (*ioc_sync_complete)    (struct bfa_ioc_s *ioc);
 };
 
 #define bfa_ioc_pcifn(__ioc)            ((__ioc)->pcidev.pci_func)
@@ -325,7 +336,6 @@ void bfa_ioc_auto_recover(bfa_boolean_t auto_recover);
 void bfa_ioc_detach(struct bfa_ioc_s *ioc);
 void bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
                 enum bfi_mclass mc);
-u32 bfa_ioc_meminfo(void);
 void bfa_ioc_mem_claim(struct bfa_ioc_s *ioc,  u8 *dm_kva, u64 dm_pa);
 void bfa_ioc_enable(struct bfa_ioc_s *ioc);
 void bfa_ioc_disable(struct bfa_ioc_s *ioc);
@@ -340,6 +350,7 @@ bfa_boolean_t bfa_ioc_is_initialized(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_is_disabled(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc);
+void bfa_ioc_reset_fwstate(struct bfa_ioc_s *ioc);
 enum bfa_ioc_type_e bfa_ioc_get_type(struct bfa_ioc_s *ioc);
 void bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num);
 void bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver);
@@ -353,24 +364,16 @@ enum bfa_ioc_state bfa_ioc_get_state(struct bfa_ioc_s *ioc);
 void bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr);
 void bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
                 struct bfa_adapter_attr_s *ad_attr);
-int bfa_ioc_debug_trcsz(bfa_boolean_t auto_recover);
 void bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave);
 bfa_status_t bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata,
                 int *trclen);
-void bfa_ioc_debug_fwsave_clear(struct bfa_ioc_s *ioc);
 bfa_status_t bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata,
                                  int *trclen);
 bfa_status_t bfa_ioc_debug_fwcore(struct bfa_ioc_s *ioc, void *buf,
         u32 *offset, int *buflen);
-u32 bfa_ioc_smem_pgnum(struct bfa_ioc_s *ioc, u32 fmaddr);
-u32 bfa_ioc_smem_pgoff(struct bfa_ioc_s *ioc, u32 fmaddr);
 void bfa_ioc_set_fcmode(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_get_fcmode(struct bfa_ioc_s *ioc);
-void bfa_ioc_hbfail_register(struct bfa_ioc_s *ioc,
-        struct bfa_ioc_hbfail_notify_s *notify);
 bfa_boolean_t bfa_ioc_sem_get(void __iomem *sem_reg);
-void bfa_ioc_sem_release(void __iomem *sem_reg);
-void bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc);
 void bfa_ioc_fwver_get(struct bfa_ioc_s *ioc,
                         struct bfi_ioc_image_hdr_s *fwhdr);
 bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
@@ -381,13 +384,8 @@ bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc);
 /*
  * bfa mfg wwn API functions
  */
-wwn_t bfa_ioc_get_pwwn(struct bfa_ioc_s *ioc);
-wwn_t bfa_ioc_get_nwwn(struct bfa_ioc_s *ioc);
 mac_t bfa_ioc_get_mac(struct bfa_ioc_s *ioc);
-wwn_t bfa_ioc_get_mfg_pwwn(struct bfa_ioc_s *ioc);
-wwn_t bfa_ioc_get_mfg_nwwn(struct bfa_ioc_s *ioc);
 mac_t bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc);
-u64 bfa_ioc_get_adid(struct bfa_ioc_s *ioc);
 
 /*
  * F/W Image Size & Chunk
@@ -421,7 +419,7 @@ bfa_cb_image_get_chunk(int type, u32 off)
                 return bfi_image_ct_cna_get_chunk(off); break;
         case BFI_IMAGE_CB_FC:
                 return bfi_image_cb_fc_get_chunk(off);  break;
-        default: return 0;
+        default: return NULL;
         }
 }
 
diff --git a/drivers/scsi/bfa/bfa_ioc_cb.c b/drivers/scsi/bfa/bfa_ioc_cb.c
index 909945043850..e4a0713185b6 100644
--- a/drivers/scsi/bfa/bfa_ioc_cb.c
+++ b/drivers/scsi/bfa/bfa_ioc_cb.c
@@ -15,6 +15,7 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_ioc.h"
 #include "bfi_cbreg.h"
 #include "bfa_defs.h"
@@ -29,10 +30,14 @@ static void bfa_ioc_cb_firmware_unlock(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_reg_init(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_map_port(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
-static void bfa_ioc_cb_notify_hbfail(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_notify_fail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_ownership_reset(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_sync_join(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_sync_leave(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_sync_ack(struct bfa_ioc_s *ioc);
+static bfa_boolean_t bfa_ioc_cb_sync_complete(struct bfa_ioc_s *ioc);
 
-struct bfa_ioc_hwif_s hwif_cb;
+static struct bfa_ioc_hwif_s hwif_cb;
 
 /*
  * Called from bfa_ioc_attach() to map asic specific calls.
@@ -46,8 +51,12 @@ bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc)
         hwif_cb.ioc_reg_init = bfa_ioc_cb_reg_init;
         hwif_cb.ioc_map_port = bfa_ioc_cb_map_port;
         hwif_cb.ioc_isr_mode_set = bfa_ioc_cb_isr_mode_set;
-        hwif_cb.ioc_notify_hbfail = bfa_ioc_cb_notify_hbfail;
+        hwif_cb.ioc_notify_fail = bfa_ioc_cb_notify_fail;
         hwif_cb.ioc_ownership_reset = bfa_ioc_cb_ownership_reset;
+        hwif_cb.ioc_sync_join = bfa_ioc_cb_sync_join;
+        hwif_cb.ioc_sync_leave = bfa_ioc_cb_sync_leave;
+        hwif_cb.ioc_sync_ack = bfa_ioc_cb_sync_ack;
+        hwif_cb.ioc_sync_complete = bfa_ioc_cb_sync_complete;
 
         ioc->ioc_hwif = &hwif_cb;
 }
@@ -58,6 +67,21 @@ bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc)
 static bfa_boolean_t
 bfa_ioc_cb_firmware_lock(struct bfa_ioc_s *ioc)
 {
+        struct bfi_ioc_image_hdr_s fwhdr;
+        uint32_t fwstate = readl(ioc->ioc_regs.ioc_fwstate);
+
+        if (fwstate == BFI_IOC_UNINIT)
+                return BFA_TRUE;
+
+        bfa_ioc_fwver_get(ioc, &fwhdr);
+
+        if (swab32(fwhdr.exec) == BFI_BOOT_TYPE_NORMAL)
+                return BFA_TRUE;
+
+        bfa_trc(ioc, fwstate);
+        bfa_trc(ioc, fwhdr.exec);
+        writel(BFI_IOC_UNINIT, ioc->ioc_regs.ioc_fwstate);
+
         return BFA_TRUE;
 }
 
@@ -70,7 +94,7 @@ bfa_ioc_cb_firmware_unlock(struct bfa_ioc_s *ioc)
  * Notify other functions on HB failure.
  */
 static void
-bfa_ioc_cb_notify_hbfail(struct bfa_ioc_s *ioc)
+bfa_ioc_cb_notify_fail(struct bfa_ioc_s *ioc)
 {
         writel(__PSS_ERR_STATUS_SET, ioc->ioc_regs.err_set);
         readl(ioc->ioc_regs.err_set);
@@ -108,9 +132,11 @@ bfa_ioc_cb_reg_init(struct bfa_ioc_s *ioc)
         if (ioc->port_id == 0) {
                 ioc->ioc_regs.heartbeat = rb + BFA_IOC0_HBEAT_REG;
                 ioc->ioc_regs.ioc_fwstate = rb + BFA_IOC0_STATE_REG;
+                ioc->ioc_regs.alt_ioc_fwstate = rb + BFA_IOC1_STATE_REG;
         } else {
                 ioc->ioc_regs.heartbeat = (rb + BFA_IOC1_HBEAT_REG);
                 ioc->ioc_regs.ioc_fwstate = (rb + BFA_IOC1_STATE_REG);
+                ioc->ioc_regs.alt_ioc_fwstate = (rb + BFA_IOC0_STATE_REG);
         }
 
         /*
@@ -181,10 +207,71 @@ bfa_ioc_cb_ownership_reset(struct bfa_ioc_s *ioc)
          * will lock it instead of clearing it.
          */
         readl(ioc->ioc_regs.ioc_sem_reg);
-        bfa_ioc_hw_sem_release(ioc);
+        writel(1, ioc->ioc_regs.ioc_sem_reg);
 }
 
+/*
+ * Synchronized IOC failure processing routines
+ */
+static void
+bfa_ioc_cb_sync_join(struct bfa_ioc_s *ioc)
+{
+}
 
+static void
+bfa_ioc_cb_sync_leave(struct bfa_ioc_s *ioc)
+{
+}
+
+static void
+bfa_ioc_cb_sync_ack(struct bfa_ioc_s *ioc)
+{
+        writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
+}
+
+static bfa_boolean_t
+bfa_ioc_cb_sync_complete(struct bfa_ioc_s *ioc)
+{
+        uint32_t fwstate, alt_fwstate;
+        fwstate = readl(ioc->ioc_regs.ioc_fwstate);
+
+        /*
+         * At this point, this IOC is hoding the hw sem in the
+         * start path (fwcheck) OR in the disable/enable path
+         * OR to check if the other IOC has acknowledged failure.
+         *
+         * So, this IOC can be in UNINIT, INITING, DISABLED, FAIL
+         * or in MEMTEST states. In a normal scenario, this IOC
+         * can not be in OP state when this function is called.
+         *
+         * However, this IOC could still be in OP state when
+         * the OS driver is starting up, if the OptROM code has
+         * left it in that state.
+         *
+         * If we had marked this IOC's fwstate as BFI_IOC_FAIL
+         * in the failure case and now, if the fwstate is not
+         * BFI_IOC_FAIL it implies that the other PCI fn have
+         * reinitialized the ASIC or this IOC got disabled, so
+         * return TRUE.
+         */
+        if (fwstate == BFI_IOC_UNINIT ||
+                fwstate == BFI_IOC_INITING ||
+                fwstate == BFI_IOC_DISABLED ||
+                fwstate == BFI_IOC_MEMTEST ||
+                fwstate == BFI_IOC_OP)
+                return BFA_TRUE;
+        else {
+                alt_fwstate = readl(ioc->ioc_regs.alt_ioc_fwstate);
+                if (alt_fwstate == BFI_IOC_FAIL ||
+                        alt_fwstate == BFI_IOC_DISABLED ||
+                        alt_fwstate == BFI_IOC_UNINIT ||
+                        alt_fwstate == BFI_IOC_INITING ||
+                        alt_fwstate == BFI_IOC_MEMTEST)
+                        return BFA_TRUE;
+                else
+                        return BFA_FALSE;
+        }
+}
 
 bfa_status_t
 bfa_ioc_cb_pll_init(void __iomem *rb, bfa_boolean_t fcmode)
diff --git a/drivers/scsi/bfa/bfa_ioc_ct.c b/drivers/scsi/bfa/bfa_ioc_ct.c
index 115730c0aa77..008d129ddfcd 100644
--- a/drivers/scsi/bfa/bfa_ioc_ct.c
+++ b/drivers/scsi/bfa/bfa_ioc_ct.c
@@ -15,12 +15,22 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_ioc.h"
 #include "bfi_ctreg.h"
 #include "bfa_defs.h"
 
 BFA_TRC_FILE(CNA, IOC_CT);
 
+#define bfa_ioc_ct_sync_pos(__ioc)      \
+                ((uint32_t) (1 << bfa_ioc_pcifn(__ioc)))
+#define BFA_IOC_SYNC_REQD_SH    16
+#define bfa_ioc_ct_get_sync_ackd(__val) (__val & 0x0000ffff)
+#define bfa_ioc_ct_clear_sync_ackd(__val)       (__val & 0xffff0000)
+#define bfa_ioc_ct_get_sync_reqd(__val) (__val >> BFA_IOC_SYNC_REQD_SH)
+#define bfa_ioc_ct_sync_reqd_pos(__ioc) \
+                        (bfa_ioc_ct_sync_pos(__ioc) << BFA_IOC_SYNC_REQD_SH)
+
 /*
  * forward declarations
  */
@@ -29,10 +39,14 @@ static void bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
-static void bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_notify_fail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_sync_join(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_sync_leave(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_sync_ack(struct bfa_ioc_s *ioc);
+static bfa_boolean_t bfa_ioc_ct_sync_complete(struct bfa_ioc_s *ioc);
 
-struct bfa_ioc_hwif_s hwif_ct;
+static struct bfa_ioc_hwif_s hwif_ct;
 
 /*
  * Called from bfa_ioc_attach() to map asic specific calls.
@@ -46,8 +60,12 @@ bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc)
         hwif_ct.ioc_reg_init = bfa_ioc_ct_reg_init;
         hwif_ct.ioc_map_port = bfa_ioc_ct_map_port;
         hwif_ct.ioc_isr_mode_set = bfa_ioc_ct_isr_mode_set;
-        hwif_ct.ioc_notify_hbfail = bfa_ioc_ct_notify_hbfail;
+        hwif_ct.ioc_notify_fail = bfa_ioc_ct_notify_fail;
         hwif_ct.ioc_ownership_reset = bfa_ioc_ct_ownership_reset;
+        hwif_ct.ioc_sync_join = bfa_ioc_ct_sync_join;
+        hwif_ct.ioc_sync_leave = bfa_ioc_ct_sync_leave;
+        hwif_ct.ioc_sync_ack = bfa_ioc_ct_sync_ack;
+        hwif_ct.ioc_sync_complete = bfa_ioc_ct_sync_complete;
 
         ioc->ioc_hwif = &hwif_ct;
 }
@@ -83,7 +101,8 @@ bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc)
          */
         if (usecnt == 0) {
                 writel(1, ioc->ioc_regs.ioc_usage_reg);
-                bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+                writel(1, ioc->ioc_regs.ioc_usage_sem_reg);
+                writel(0, ioc->ioc_regs.ioc_fail_sync);
                 bfa_trc(ioc, usecnt);
                 return BFA_TRUE;
         }
@@ -94,14 +113,14 @@ bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc)
         /*
          * Use count cannot be non-zero and chip in uninitialized state.
          */
-        bfa_assert(ioc_fwstate != BFI_IOC_UNINIT);
+        WARN_ON(ioc_fwstate == BFI_IOC_UNINIT);
 
         /*
          * Check if another driver with a different firmware is active
          */
         bfa_ioc_fwver_get(ioc, &fwhdr);
         if (!bfa_ioc_fwver_cmp(ioc, &fwhdr)) {
-                bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+                writel(1, ioc->ioc_regs.ioc_usage_sem_reg);
                 bfa_trc(ioc, usecnt);
                 return BFA_FALSE;
         }
@@ -111,7 +130,7 @@ bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc)
          */
         usecnt++;
         writel(usecnt, ioc->ioc_regs.ioc_usage_reg);
-        bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+        writel(1, ioc->ioc_regs.ioc_usage_sem_reg);
         bfa_trc(ioc, usecnt);
         return BFA_TRUE;
 }
@@ -139,25 +158,27 @@ bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc)
          */
         bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
         usecnt = readl(ioc->ioc_regs.ioc_usage_reg);
-        bfa_assert(usecnt > 0);
+        WARN_ON(usecnt <= 0);
 
         usecnt--;
         writel(usecnt, ioc->ioc_regs.ioc_usage_reg);
         bfa_trc(ioc, usecnt);
 
-        bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+        writel(1, ioc->ioc_regs.ioc_usage_sem_reg);
 }
 
 /*
  * Notify other functions on HB failure.
  */
 static void
-bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc)
+bfa_ioc_ct_notify_fail(struct bfa_ioc_s *ioc)
 {
         if (ioc->cna) {
                 writel(__FW_INIT_HALT_P, ioc->ioc_regs.ll_halt);
+                writel(__FW_INIT_HALT_P, ioc->ioc_regs.alt_ll_halt);
                 /* Wait for halt to take effect */
                 readl(ioc->ioc_regs.ll_halt);
+                readl(ioc->ioc_regs.alt_ll_halt);
         } else {
                 writel(__PSS_ERR_STATUS_SET, ioc->ioc_regs.err_set);
                 readl(ioc->ioc_regs.err_set);
@@ -209,15 +230,19 @@ bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc)
         if (ioc->port_id == 0) {
                 ioc->ioc_regs.heartbeat = rb + BFA_IOC0_HBEAT_REG;
                 ioc->ioc_regs.ioc_fwstate = rb + BFA_IOC0_STATE_REG;
+                ioc->ioc_regs.alt_ioc_fwstate = rb + BFA_IOC1_STATE_REG;
                 ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].hfn;
                 ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].lpu;
                 ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P0;
+                ioc->ioc_regs.alt_ll_halt = rb + FW_INIT_HALT_P1;
         } else {
                 ioc->ioc_regs.heartbeat = (rb + BFA_IOC1_HBEAT_REG);
                 ioc->ioc_regs.ioc_fwstate = (rb + BFA_IOC1_STATE_REG);
+                ioc->ioc_regs.alt_ioc_fwstate = rb + BFA_IOC0_STATE_REG;
                 ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].hfn;
                 ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].lpu;
                 ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P1;
+                ioc->ioc_regs.alt_ll_halt = rb + FW_INIT_HALT_P0;
         }
 
         /*
@@ -235,6 +260,7 @@ bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc)
         ioc->ioc_regs.ioc_usage_sem_reg = (rb + HOST_SEM1_REG);
         ioc->ioc_regs.ioc_init_sem_reg = (rb + HOST_SEM2_REG);
         ioc->ioc_regs.ioc_usage_reg = (rb + BFA_FW_USE_COUNT);
+        ioc->ioc_regs.ioc_fail_sync = (rb + BFA_IOC_FAIL_SYNC);
 
         /*
          * sram memory access
@@ -313,7 +339,7 @@ bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc)
         if (ioc->cna) {
                 bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
                 writel(0, ioc->ioc_regs.ioc_usage_reg);
-                bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+                writel(1, ioc->ioc_regs.ioc_usage_sem_reg);
         }
 
         /*
@@ -322,10 +348,80 @@ bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc)
          * will lock it instead of clearing it.
          */
         readl(ioc->ioc_regs.ioc_sem_reg);
-        bfa_ioc_hw_sem_release(ioc);
+        writel(1, ioc->ioc_regs.ioc_sem_reg);
+}
+
+/*
+ * Synchronized IOC failure processing routines
+ */
+static void
+bfa_ioc_ct_sync_join(struct bfa_ioc_s *ioc)
+{
+        uint32_t r32 = readl(ioc->ioc_regs.ioc_fail_sync);
+        uint32_t sync_pos = bfa_ioc_ct_sync_reqd_pos(ioc);
+
+        writel((r32 | sync_pos), ioc->ioc_regs.ioc_fail_sync);
+}
+
+static void
+bfa_ioc_ct_sync_leave(struct bfa_ioc_s *ioc)
+{
+        uint32_t r32 = readl(ioc->ioc_regs.ioc_fail_sync);
+        uint32_t sync_msk = bfa_ioc_ct_sync_reqd_pos(ioc) |
+                                        bfa_ioc_ct_sync_pos(ioc);
+
+        writel((r32 & ~sync_msk), ioc->ioc_regs.ioc_fail_sync);
+}
+
+static void
+bfa_ioc_ct_sync_ack(struct bfa_ioc_s *ioc)
+{
+        uint32_t r32 = readl(ioc->ioc_regs.ioc_fail_sync);
+
+        writel((r32 | bfa_ioc_ct_sync_pos(ioc)),
+                ioc->ioc_regs.ioc_fail_sync);
 }
 
+static bfa_boolean_t
+bfa_ioc_ct_sync_complete(struct bfa_ioc_s *ioc)
+{
+        uint32_t r32 = readl(ioc->ioc_regs.ioc_fail_sync);
+        uint32_t sync_reqd = bfa_ioc_ct_get_sync_reqd(r32);
+        uint32_t sync_ackd = bfa_ioc_ct_get_sync_ackd(r32);
+        uint32_t tmp_ackd;
+
+        if (sync_ackd == 0)
+                return BFA_TRUE;
+
+        /*
+         * The check below is to see whether any other PCI fn
+         * has reinitialized the ASIC (reset sync_ackd bits)
+         * and failed again while this IOC was waiting for hw
+         * semaphore (in bfa_iocpf_sm_semwait()).
+         */
+        tmp_ackd = sync_ackd;
+        if ((sync_reqd &  bfa_ioc_ct_sync_pos(ioc)) &&
+                !(sync_ackd & bfa_ioc_ct_sync_pos(ioc)))
+                sync_ackd |= bfa_ioc_ct_sync_pos(ioc);
+
+        if (sync_reqd == sync_ackd) {
+                writel(bfa_ioc_ct_clear_sync_ackd(r32),
+                        ioc->ioc_regs.ioc_fail_sync);
+                writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
+                writel(BFI_IOC_FAIL, ioc->ioc_regs.alt_ioc_fwstate);
+                return BFA_TRUE;
+        }
+
+        /*
+         * If another PCI fn reinitialized and failed again while
+         * this IOC was waiting for hw sem, the sync_ackd bit for
+         * this IOC need to be set again to allow reinitialization.
+         */
+        if (tmp_ackd != sync_ackd)
+                writel((r32 | sync_ackd), ioc->ioc_regs.ioc_fail_sync);
 
+        return BFA_FALSE;
+}
 
 /*
  * Check the firmware state to know if pll_init has been completed already
diff --git a/drivers/scsi/bfa/bfa_modules.h b/drivers/scsi/bfa/bfa_modules.h
index 15407ab39e77..ab79ff6fdeea 100644
--- a/drivers/scsi/bfa/bfa_modules.h
+++ b/drivers/scsi/bfa/bfa_modules.h
@@ -99,7 +99,6 @@ struct bfa_module_s {
         void (*iocdisable) (struct bfa_s *bfa);
 };
 
-extern struct bfa_module_s *hal_mods[];
 
 struct bfa_s {
         void                    *bfad;          /*  BFA driver instance    */
@@ -116,8 +115,6 @@ struct bfa_s {
         struct bfa_msix_s       msix;
 };
 
-extern bfa_isr_func_t bfa_isrs[BFI_MC_MAX];
-extern bfa_ioc_mbox_mcfunc_t  bfa_mbox_isrs[];
 extern bfa_boolean_t bfa_auto_recover;
 extern struct bfa_module_s hal_mod_sgpg;
 extern struct bfa_module_s hal_mod_fcport;
diff --git a/drivers/scsi/bfa/bfa_os_inc.h b/drivers/scsi/bfa/bfa_os_inc.h
deleted file mode 100644
index 65df62ef437f..000000000000
--- a/drivers/scsi/bfa/bfa_os_inc.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
- * All rights reserved
- * www.brocade.com
- *
- * Linux driver for Brocade Fibre Channel Host Bus Adapter.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License (GPL) Version 2 as
- * published by the Free Software Foundation
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-
-#ifndef __BFA_OS_INC_H__
-#define __BFA_OS_INC_H__
-
-#include <linux/types.h>
-#include <linux/version.h>
-#include <linux/pci.h>
-#include <linux/dma-mapping.h>
-#include <linux/idr.h>
-#include <linux/interrupt.h>
-#include <linux/cdev.h>
-#include <linux/fs.h>
-#include <linux/delay.h>
-#include <linux/vmalloc.h>
-#include <linux/workqueue.h>
-#include <linux/bitops.h>
-#include <scsi/scsi.h>
-#include <scsi/scsi_host.h>
-#include <scsi/scsi_tcq.h>
-#include <scsi/scsi_transport_fc.h>
-#include <scsi/scsi_transport.h>
-
-#ifdef __BIG_ENDIAN
-#define __BIGENDIAN
-#endif
-
-static inline u64 bfa_os_get_log_time(void)
-{
-        u64 system_time = 0;
-        struct timeval tv;
-        do_gettimeofday(&tv);
-
-        /* We are interested in seconds only. */
-        system_time = tv.tv_sec;
-        return system_time;
-}
-
-#define bfa_io_lat_clock_res_div HZ
-#define bfa_io_lat_clock_res_mul 1000
-
-#define BFA_LOG(level, bfad, mask, fmt, arg...)                         \
-do {                                                                    \
-        if (((mask) == 4) || (level[1] <= '4'))                         \
-                dev_printk(level, &((bfad)->pcidev)->dev, fmt, ##arg);  \
-} while (0)
-
-#define bfa_swap_3b(_x)                         \
-        ((((_x) & 0xff) << 16) |                \
-        ((_x) & 0x00ff00) |                     \
-        (((_x) & 0xff0000) >> 16))
-
-#define bfa_os_swap_sgaddr(_x)  ((u64)(                                 \
-        (((u64)(_x) & (u64)0x00000000000000ffull) << 32)        |       \
-        (((u64)(_x) & (u64)0x000000000000ff00ull) << 32)        |       \
-        (((u64)(_x) & (u64)0x0000000000ff0000ull) << 32)        |       \
-        (((u64)(_x) & (u64)0x00000000ff000000ull) << 32)        |       \
-        (((u64)(_x) & (u64)0x000000ff00000000ull) >> 32)        |       \
-        (((u64)(_x) & (u64)0x0000ff0000000000ull) >> 32)        |       \
-        (((u64)(_x) & (u64)0x00ff000000000000ull) >> 32)        |       \
-        (((u64)(_x) & (u64)0xff00000000000000ull) >> 32)))
-
-#ifndef __BIGENDIAN
-#define bfa_os_hton3b(_x)  bfa_swap_3b(_x)
-#define bfa_os_sgaddr(_x)  (_x)
-#else
-#define bfa_os_hton3b(_x)  (_x)
-#define bfa_os_sgaddr(_x)  bfa_os_swap_sgaddr(_x)
-#endif
-
-#define bfa_os_ntoh3b(_x)  bfa_os_hton3b(_x)
-#define bfa_os_u32(__pa64) ((__pa64) >> 32)
-
-#define BFA_TRC_TS(_trcm)                               \
-        ({                                              \
-                struct timeval tv;                      \
-                                                        \
-                do_gettimeofday(&tv);                   \
-                (tv.tv_sec*1000000+tv.tv_usec);         \
-         })
-
-#define boolean_t int
-
-/*
- * For current time stamp, OS API will fill-in
- */
-struct bfa_timeval_s {
-        u32     tv_sec;         /*  seconds        */
-        u32     tv_usec;        /*  microseconds   */
-};
-
-static inline void
-bfa_os_gettimeofday(struct bfa_timeval_s *tv)
-{
-        struct timeval  tmp_tv;
-
-        do_gettimeofday(&tmp_tv);
-        tv->tv_sec = (u32) tmp_tv.tv_sec;
-        tv->tv_usec = (u32) tmp_tv.tv_usec;
-}
-
-static inline void
-wwn2str(char *wwn_str, u64 wwn)
-{
-        union {
-                u64 wwn;
-                u8 byte[8];
-        } w;
-
-        w.wwn = wwn;
-        sprintf(wwn_str, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", w.byte[0],
-                w.byte[1], w.byte[2], w.byte[3], w.byte[4], w.byte[5],
-                w.byte[6], w.byte[7]);
-}
-
-static inline void
-fcid2str(char *fcid_str, u32 fcid)
-{
-        union {
-                u32 fcid;
-                u8 byte[4];
-        } f;
-
-        f.fcid = fcid;
-        sprintf(fcid_str, "%02x:%02x:%02x", f.byte[1], f.byte[2], f.byte[3]);
-}
-
-#endif /* __BFA_OS_INC_H__ */
diff --git a/drivers/scsi/bfa/bfa_plog.h b/drivers/scsi/bfa/bfa_plog.h
index 501f0ed35cf0..1c9baa68339b 100644
--- a/drivers/scsi/bfa/bfa_plog.h
+++ b/drivers/scsi/bfa/bfa_plog.h
@@ -151,9 +151,5 @@ void bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
 void bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
                         enum bfa_plog_eid event, u16 misc,
                         struct fchs_s *fchdr, u32 pld_w0);
-void bfa_plog_clear(struct bfa_plog_s *plog);
-void bfa_plog_enable(struct bfa_plog_s *plog);
-void bfa_plog_disable(struct bfa_plog_s *plog);
-bfa_boolean_t   bfa_plog_get_setting(struct bfa_plog_s *plog);
 
 #endif /* __BFA_PORTLOG_H__ */
diff --git a/drivers/scsi/bfa/bfa_port.c b/drivers/scsi/bfa/bfa_port.c
index fff96226a383..3f8e9d6066ec 100644
--- a/drivers/scsi/bfa/bfa_port.c
+++ b/drivers/scsi/bfa/bfa_port.c
@@ -15,6 +15,7 @@
  * General Public License for more details.
  */
 
+#include "bfad_drv.h"
 #include "bfa_defs_svc.h"
 #include "bfa_port.h"
 #include "bfi.h"
@@ -29,14 +30,14 @@ static void
 bfa_port_stats_swap(struct bfa_port_s *port, union bfa_port_stats_u *stats)
 {
         u32    *dip = (u32 *) stats;
-        u32    t0, t1;
+        __be32    t0, t1;
         int         i;
 
         for (i = 0; i < sizeof(union bfa_port_stats_u)/sizeof(u32);
                 i += 2) {
                 t0 = dip[i];
                 t1 = dip[i + 1];
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
                 dip[i] = be32_to_cpu(t0);
                 dip[i + 1] = be32_to_cpu(t1);
 #else
@@ -96,13 +97,13 @@ bfa_port_get_stats_isr(struct bfa_port_s *port, bfa_status_t status)
         port->stats_busy = BFA_FALSE;
 
         if (status == BFA_STATUS_OK) {
-                struct bfa_timeval_s tv;
+                struct timeval tv;
 
                 memcpy(port->stats, port->stats_dma.kva,
                        sizeof(union bfa_port_stats_u));
                 bfa_port_stats_swap(port, port->stats);
 
-                bfa_os_gettimeofday(&tv);
+                do_gettimeofday(&tv);
                 port->stats->fc.secs_reset = tv.tv_sec - port->stats_reset_time;
         }
 
@@ -124,7 +125,7 @@ bfa_port_get_stats_isr(struct bfa_port_s *port, bfa_status_t status)
 static void
 bfa_port_clear_stats_isr(struct bfa_port_s *port, bfa_status_t status)
 {
-        struct bfa_timeval_s tv;
+        struct timeval tv;
 
         port->stats_status = status;
         port->stats_busy   = BFA_FALSE;
@@ -132,7 +133,7 @@ bfa_port_clear_stats_isr(struct bfa_port_s *port, bfa_status_t status)
         /*
         * re-initialize time stamp for stats reset
         */
-        bfa_os_gettimeofday(&tv);
+        do_gettimeofday(&tv);
         port->stats_reset_time = tv.tv_sec;
 
         if (port->stats_cbfn) {
@@ -185,7 +186,7 @@ bfa_port_isr(void *cbarg, struct bfi_mbmsg_s *m)
                 break;
 
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -432,9 +433,9 @@ void
 bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
                  void *dev, struct bfa_trc_mod_s *trcmod)
 {
-        struct bfa_timeval_s tv;
+        struct timeval tv;
 
-        bfa_assert(port);
+        WARN_ON(!port);
 
         port->dev    = dev;
         port->ioc    = ioc;
@@ -447,27 +448,13 @@ bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
 
         bfa_ioc_mbox_regisr(port->ioc, BFI_MC_PORT, bfa_port_isr, port);
         bfa_ioc_hbfail_init(&port->hbfail, bfa_port_hbfail, port);
-        bfa_ioc_hbfail_register(port->ioc, &port->hbfail);
+        list_add_tail(&port->hbfail.qe, &port->ioc->hb_notify_q);
 
         /*
          * initialize time stamp for stats reset
          */
-        bfa_os_gettimeofday(&tv);
+        do_gettimeofday(&tv);
         port->stats_reset_time = tv.tv_sec;
 
         bfa_trc(port, 0);
 }
-
-/*
- * bfa_port_detach()
- *
- *
- * @param[in] port - Pointer to the Port module data structure
- *
- * @return void
- */
-void
-bfa_port_detach(struct bfa_port_s *port)
-{
-        bfa_trc(port, 0);
-}
diff --git a/drivers/scsi/bfa/bfa_port.h b/drivers/scsi/bfa/bfa_port.h
index dbce9dfd056b..c4ee9db6b470 100644
--- a/drivers/scsi/bfa/bfa_port.h
+++ b/drivers/scsi/bfa/bfa_port.h
@@ -48,7 +48,6 @@ struct bfa_port_s {
 
 void         bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
                                 void *dev, struct bfa_trc_mod_s *trcmod);
-void         bfa_port_detach(struct bfa_port_s *port);
 void         bfa_port_hbfail(void *arg);
 
 bfa_status_t bfa_port_get_stats(struct bfa_port_s *port,
diff --git a/drivers/scsi/bfa/bfa_svc.c b/drivers/scsi/bfa/bfa_svc.c
index 37e16ac8f249..1d34921f88bf 100644
--- a/drivers/scsi/bfa/bfa_svc.c
+++ b/drivers/scsi/bfa/bfa_svc.c
@@ -15,11 +15,10 @@
  * General Public License for more details.
  */
 
-#include "bfa_os_inc.h"
+#include "bfad_drv.h"
 #include "bfa_plog.h"
 #include "bfa_cs.h"
 #include "bfa_modules.h"
-#include "bfad_drv.h"
 
 BFA_TRC_FILE(HAL, FCXP);
 BFA_MODULE(fcxp);
@@ -41,19 +40,6 @@ BFA_MODULE(uf);
 #define BFA_LPS_MAX_VPORTS_SUPP_CB  255
 #define BFA_LPS_MAX_VPORTS_SUPP_CT  190
 
-/*
- *  lps_pvt BFA LPS private functions
- */
-
-enum bfa_lps_event {
-        BFA_LPS_SM_LOGIN        = 1,    /* login request from user      */
-        BFA_LPS_SM_LOGOUT       = 2,    /* logout request from user     */
-        BFA_LPS_SM_FWRSP        = 3,    /* f/w response to login/logout */
-        BFA_LPS_SM_RESUME       = 4,    /* space present in reqq queue  */
-        BFA_LPS_SM_DELETE       = 5,    /* lps delete from user         */
-        BFA_LPS_SM_OFFLINE      = 6,    /* Link is offline              */
-        BFA_LPS_SM_RX_CVL       = 7,    /* Rx clear virtual link        */
-};
 
 /*
  * FC PORT related definitions
@@ -66,7 +52,6 @@ enum bfa_lps_event {
         ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
         (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
 
-
 /*
  * BFA port state machine events
  */
@@ -113,19 +98,6 @@ enum bfa_fcport_ln_sm_event {
                 }                                                       \
 } while (0)
 
-
-enum bfa_rport_event {
-        BFA_RPORT_SM_CREATE     = 1,    /*  rport create event          */
-        BFA_RPORT_SM_DELETE     = 2,    /*  deleting an existing rport  */
-        BFA_RPORT_SM_ONLINE     = 3,    /*  rport is online             */
-        BFA_RPORT_SM_OFFLINE    = 4,    /*  rport is offline            */
-        BFA_RPORT_SM_FWRSP      = 5,    /*  firmware response           */
-        BFA_RPORT_SM_HWFAIL     = 6,    /*  IOC h/w failure             */
-        BFA_RPORT_SM_QOS_SCN    = 7,    /*  QoS SCN from firmware       */
-        BFA_RPORT_SM_SET_SPEED  = 8,    /*  Set Rport Speed             */
-        BFA_RPORT_SM_QRESUME    = 9,    /*  space in requeue queue      */
-};
-
 /*
  * forward declarations FCXP related functions
  */
@@ -159,6 +131,7 @@ static void bfa_lps_reqq_resume(void *lps_arg);
 static void bfa_lps_free(struct bfa_lps_s *lps);
 static void bfa_lps_send_login(struct bfa_lps_s *lps);
 static void bfa_lps_send_logout(struct bfa_lps_s *lps);
+static void bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps);
 static void bfa_lps_login_comp(struct bfa_lps_s *lps);
 static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
 static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
@@ -171,6 +144,8 @@ static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
 static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
                                         event);
 static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
+static void bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps,
+                                        enum bfa_lps_event event);
 static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
 static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
                                         event);
@@ -312,6 +287,18 @@ plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
         return 0;
 }
 
+static u64
+bfa_get_log_time(void)
+{
+        u64 system_time = 0;
+        struct timeval tv;
+        do_gettimeofday(&tv);
+
+        /* We are interested in seconds only. */
+        system_time = tv.tv_sec;
+        return system_time;
+}
+
 static void
 bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
 {
@@ -322,7 +309,7 @@ bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
                 return;
 
         if (plkd_validate_logrec(pl_rec)) {
-                bfa_assert(0);
+                WARN_ON(1);
                 return;
         }
 
@@ -332,7 +319,7 @@ bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
 
         memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
 
-        pl_recp->tv = bfa_os_get_log_time();
+        pl_recp->tv = bfa_get_log_time();
         BFA_PL_LOG_REC_INCR(plog->tail);
 
         if (plog->head == plog->tail)
@@ -437,29 +424,6 @@ bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
         }
 }
 
-void
-bfa_plog_clear(struct bfa_plog_s *plog)
-{
-        plog->head = plog->tail = 0;
-}
-
-void
-bfa_plog_enable(struct bfa_plog_s *plog)
-{
-        plog->plog_enabled = 1;
-}
-
-void
-bfa_plog_disable(struct bfa_plog_s *plog)
-{
-        plog->plog_enabled = 0;
-}
-
-bfa_boolean_t
-bfa_plog_get_setting(struct bfa_plog_s *plog)
-{
-        return (bfa_boolean_t)plog->plog_enabled;
-}
 
 /*
  *  fcxp_pvt BFA FCXP private functions
@@ -637,15 +601,15 @@ bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
                bfa_fcxp_get_sglen_t sglen_cbfn)
 {
 
-        bfa_assert(bfa != NULL);
+        WARN_ON(bfa == NULL);
 
         bfa_trc(bfa, fcxp->fcxp_tag);
 
         if (n_sgles == 0) {
                 *use_ibuf = 1;
         } else {
-                bfa_assert(*sga_cbfn != NULL);
-                bfa_assert(*sglen_cbfn != NULL);
+                WARN_ON(*sga_cbfn == NULL);
+                WARN_ON(*sglen_cbfn == NULL);
 
                 *use_ibuf = 0;
                 *r_sga_cbfn = sga_cbfn;
@@ -657,7 +621,7 @@ bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
                  * alloc required sgpgs
                  */
                 if (n_sgles > BFI_SGE_INLINE)
-                        bfa_assert(0);
+                        WARN_ON(1);
         }
 
 }
@@ -671,7 +635,7 @@ bfa_fcxp_init(struct bfa_fcxp_s *fcxp,
                bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
 {
 
-        bfa_assert(bfa != NULL);
+        WARN_ON(bfa == NULL);
 
         bfa_trc(bfa, fcxp->fcxp_tag);
 
@@ -708,7 +672,7 @@ bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
                 return;
         }
 
-        bfa_assert(bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
+        WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
         list_del(&fcxp->qe);
         list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
 }
@@ -757,7 +721,7 @@ hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
 
         fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
 
-        bfa_assert(fcxp->send_cbfn != NULL);
+        WARN_ON(fcxp->send_cbfn == NULL);
 
         hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
 
@@ -913,13 +877,13 @@ bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
                                         BFA_FCXP_REQ_PLD_PA(fcxp));
         } else {
                 if (fcxp->nreq_sgles > 0) {
-                        bfa_assert(fcxp->nreq_sgles == 1);
+                        WARN_ON(fcxp->nreq_sgles != 1);
                         hal_fcxp_set_local_sges(send_req->req_sge,
                                                 reqi->req_tot_len,
                                                 fcxp->req_sga_cbfn(fcxp->caller,
                                                                    0));
                 } else {
-                        bfa_assert(reqi->req_tot_len == 0);
+                        WARN_ON(reqi->req_tot_len != 0);
                         hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
                 }
         }
@@ -928,20 +892,20 @@ bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
          * setup rsp sgles
          */
         if (fcxp->use_irspbuf == 1) {
-                bfa_assert(rspi->rsp_maxlen <= BFA_FCXP_MAX_LBUF_SZ);
+                WARN_ON(rspi->rsp_maxlen > BFA_FCXP_MAX_LBUF_SZ);
 
                 hal_fcxp_set_local_sges(send_req->rsp_sge, rspi->rsp_maxlen,
                                         BFA_FCXP_RSP_PLD_PA(fcxp));
 
         } else {
                 if (fcxp->nrsp_sgles > 0) {
-                        bfa_assert(fcxp->nrsp_sgles == 1);
+                        WARN_ON(fcxp->nrsp_sgles != 1);
                         hal_fcxp_set_local_sges(send_req->rsp_sge,
                                                 rspi->rsp_maxlen,
                                                 fcxp->rsp_sga_cbfn(fcxp->caller,
                                                                    0));
                 } else {
-                        bfa_assert(rspi->rsp_maxlen == 0);
+                        WARN_ON(rspi->rsp_maxlen != 0);
                         hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
                 }
         }
@@ -955,10 +919,6 @@ bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
 }
 
 /*
- *  hal_fcxp_api BFA FCXP API
- */
-
-/*
  * Allocate an FCXP instance to send a response or to send a request
  * that has a response. Request/response buffers are allocated by caller.
  *
@@ -990,7 +950,7 @@ bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
 {
         struct bfa_fcxp_s *fcxp = NULL;
 
-        bfa_assert(bfa != NULL);
+        WARN_ON(bfa == NULL);
 
         fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
         if (fcxp == NULL)
@@ -1017,7 +977,7 @@ bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
         struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
         void    *reqbuf;
 
-        bfa_assert(fcxp->use_ireqbuf == 1);
+        WARN_ON(fcxp->use_ireqbuf != 1);
         reqbuf = ((u8 *)mod->req_pld_list_kva) +
                 fcxp->fcxp_tag * mod->req_pld_sz;
         return reqbuf;
@@ -1044,7 +1004,7 @@ bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
         struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
         void    *rspbuf;
 
-        bfa_assert(fcxp->use_irspbuf == 1);
+        WARN_ON(fcxp->use_irspbuf != 1);
 
         rspbuf = ((u8 *)mod->rsp_pld_list_kva) +
                 fcxp->fcxp_tag * mod->rsp_pld_sz;
@@ -1052,7 +1012,7 @@ bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
 }
 
 /*
- *              Free the BFA FCXP
+ * Free the BFA FCXP
  *
  * @param[in]   fcxp                    BFA fcxp pointer
  *
@@ -1063,7 +1023,7 @@ bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
 {
         struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
 
-        bfa_assert(fcxp != NULL);
+        WARN_ON(fcxp == NULL);
         bfa_trc(mod->bfa, fcxp->fcxp_tag);
         bfa_fcxp_put(fcxp);
 }
@@ -1142,7 +1102,7 @@ bfa_status_t
 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
 {
         bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
-        bfa_assert(0);
+        WARN_ON(1);
         return BFA_STATUS_OK;
 }
 
@@ -1157,7 +1117,7 @@ bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
 {
         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 
-        bfa_assert(list_empty(&mod->fcxp_free_q));
+        WARN_ON(!list_empty(&mod->fcxp_free_q));
 
         wqe->alloc_cbfn = alloc_cbfn;
         wqe->alloc_cbarg = alloc_cbarg;
@@ -1178,7 +1138,7 @@ bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
 {
         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 
-        bfa_assert(bfa_q_is_on_q(&mod->wait_q, wqe));
+        WARN_ON(!bfa_q_is_on_q(&mod->wait_q, wqe));
         list_del(&wqe->qe);
 }
 
@@ -1199,12 +1159,6 @@ bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
         fcxp->send_cbfn = bfa_fcxp_null_comp;
 }
 
-
-
-/*
- *  hal_fcxp_public BFA FCXP public functions
- */
-
 void
 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
 {
@@ -1215,7 +1169,7 @@ bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
 
         default:
                 bfa_trc(bfa, msg->mhdr.msg_id);
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -1303,6 +1257,12 @@ bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
                         else
                                 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
                                         BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
+                        /* If N2N, send the assigned PID to FW */
+                        bfa_trc(lps->bfa, lps->fport);
+                        bfa_trc(lps->bfa, lps->lp_pid);
+
+                        if (!lps->fport && lps->lp_pid)
+                                bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
                 } else {
                         bfa_sm_set_state(lps, bfa_lps_sm_init);
                         if (lps->fdisc)
@@ -1321,6 +1281,11 @@ bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 bfa_sm_set_state(lps, bfa_lps_sm_init);
                 break;
 
+        case BFA_LPS_SM_SET_N2N_PID:
+                bfa_trc(lps->bfa, lps->fport);
+                bfa_trc(lps->bfa, lps->lp_pid);
+                break;
+
         default:
                 bfa_sm_fault(lps->bfa, event);
         }
@@ -1389,9 +1354,59 @@ bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
                         BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
                 break;
 
+        case BFA_LPS_SM_SET_N2N_PID:
+                if (bfa_reqq_full(lps->bfa, lps->reqq)) {
+                        bfa_sm_set_state(lps, bfa_lps_sm_online_n2n_pid_wait);
+                        bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
+                } else
+                        bfa_lps_send_set_n2n_pid(lps);
+                break;
+
+        case BFA_LPS_SM_OFFLINE:
+        case BFA_LPS_SM_DELETE:
+                bfa_sm_set_state(lps, bfa_lps_sm_init);
+                break;
+
+        default:
+                bfa_sm_fault(lps->bfa, event);
+        }
+}
+
+/*
+ * login complete
+ */
+static void
+bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, enum bfa_lps_event event)
+{
+        bfa_trc(lps->bfa, lps->lp_tag);
+        bfa_trc(lps->bfa, event);
+
+        switch (event) {
+        case BFA_LPS_SM_RESUME:
+                bfa_sm_set_state(lps, bfa_lps_sm_online);
+                bfa_lps_send_set_n2n_pid(lps);
+                break;
+
+        case BFA_LPS_SM_LOGOUT:
+                bfa_sm_set_state(lps, bfa_lps_sm_logowait);
+                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                        BFA_PL_EID_LOGO, 0, "Logout");
+                break;
+
+        case BFA_LPS_SM_RX_CVL:
+                bfa_sm_set_state(lps, bfa_lps_sm_init);
+                bfa_reqq_wcancel(&lps->wqe);
+
+                /* Let the vport module know about this event */
+                bfa_lps_cvl_event(lps);
+                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                        BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
+                break;
+
         case BFA_LPS_SM_OFFLINE:
         case BFA_LPS_SM_DELETE:
                 bfa_sm_set_state(lps, bfa_lps_sm_init);
+                bfa_reqq_wcancel(&lps->wqe);
                 break;
 
         default:
@@ -1540,15 +1555,16 @@ bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
         struct bfa_lps_s        *lps;
 
-        bfa_assert(rsp->lp_tag < mod->num_lps);
+        WARN_ON(rsp->lp_tag >= mod->num_lps);
         lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
 
         lps->status = rsp->status;
         switch (rsp->status) {
         case BFA_STATUS_OK:
                 lps->fport      = rsp->f_port;
+                if (lps->fport)
+                        lps->lp_pid = rsp->lp_pid;
                 lps->npiv_en    = rsp->npiv_en;
-                lps->lp_pid     = rsp->lp_pid;
                 lps->pr_bbcred  = be16_to_cpu(rsp->bb_credit);
                 lps->pr_pwwn    = rsp->port_name;
                 lps->pr_nwwn    = rsp->node_name;
@@ -1587,7 +1603,7 @@ bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
         struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
         struct bfa_lps_s        *lps;
 
-        bfa_assert(rsp->lp_tag < mod->num_lps);
+        WARN_ON(rsp->lp_tag >= mod->num_lps);
         lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
 
         bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
@@ -1640,7 +1656,7 @@ bfa_lps_send_login(struct bfa_lps_s *lps)
         struct bfi_lps_login_req_s      *m;
 
         m = bfa_reqq_next(lps->bfa, lps->reqq);
-        bfa_assert(m);
+        WARN_ON(!m);
 
         bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
                 bfa_lpuid(lps->bfa));
@@ -1665,7 +1681,7 @@ bfa_lps_send_logout(struct bfa_lps_s *lps)
         struct bfi_lps_logout_req_s *m;
 
         m = bfa_reqq_next(lps->bfa, lps->reqq);
-        bfa_assert(m);
+        WARN_ON(!m);
 
         bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
                 bfa_lpuid(lps->bfa));
@@ -1676,6 +1692,25 @@ bfa_lps_send_logout(struct bfa_lps_s *lps)
 }
 
 /*
+ * send n2n pid set request to firmware
+ */
+static void
+bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps)
+{
+        struct bfi_lps_n2n_pid_req_s *m;
+
+        m = bfa_reqq_next(lps->bfa, lps->reqq);
+        WARN_ON(!m);
+
+        bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_N2N_PID_REQ,
+                bfa_lpuid(lps->bfa));
+
+        m->lp_tag = lps->lp_tag;
+        m->lp_pid = lps->lp_pid;
+        bfa_reqq_produce(lps->bfa, lps->reqq);
+}
+
+/*
  * Indirect login completion handler for non-fcs
  */
 static void
@@ -1853,14 +1888,6 @@ bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn,
         bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
 }
 
-/*
- * Initiate a lport logout (flogi).
- */
-void
-bfa_lps_flogo(struct bfa_lps_s *lps)
-{
-        bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
-}
 
 /*
  * Initiate a lport FDSIC logout.
@@ -1871,24 +1898,6 @@ bfa_lps_fdisclogo(struct bfa_lps_s *lps)
         bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
 }
 
-/*
- * Discard a pending login request -- should be called only for
- * link down handling.
- */
-void
-bfa_lps_discard(struct bfa_lps_s *lps)
-{
-        bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
-}
-
-/*
- * Return lport services tag
- */
-u8
-bfa_lps_get_tag(struct bfa_lps_s *lps)
-{
-        return lps->lp_tag;
-}
 
 /*
  * Return lport services tag given the pid
@@ -1909,55 +1918,6 @@ bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid)
         return 0;
 }
 
-/*
- * return if fabric login indicates support for NPIV
- */
-bfa_boolean_t
-bfa_lps_is_npiv_en(struct bfa_lps_s *lps)
-{
-        return lps->npiv_en;
-}
-
-/*
- * Return TRUE if attached to F-Port, else return FALSE
- */
-bfa_boolean_t
-bfa_lps_is_fport(struct bfa_lps_s *lps)
-{
-        return lps->fport;
-}
-
-/*
- * Return TRUE if attached to a Brocade Fabric
- */
-bfa_boolean_t
-bfa_lps_is_brcd_fabric(struct bfa_lps_s *lps)
-{
-        return lps->brcd_switch;
-}
-/*
- * return TRUE if authentication is required
- */
-bfa_boolean_t
-bfa_lps_is_authreq(struct bfa_lps_s *lps)
-{
-        return lps->auth_req;
-}
-
-bfa_eproto_status_t
-bfa_lps_get_extstatus(struct bfa_lps_s *lps)
-{
-        return lps->ext_status;
-}
-
-/*
- * return port id assigned to the lport
- */
-u32
-bfa_lps_get_pid(struct bfa_lps_s *lps)
-{
-        return lps->lp_pid;
-}
 
 /*
  * return port id assigned to the base lport
@@ -1971,57 +1931,16 @@ bfa_lps_get_base_pid(struct bfa_s *bfa)
 }
 
 /*
- * Return bb_credit assigned in FLOGI response
- */
-u16
-bfa_lps_get_peer_bbcredit(struct bfa_lps_s *lps)
-{
-        return lps->pr_bbcred;
-}
-
-/*
- * Return peer port name
- */
-wwn_t
-bfa_lps_get_peer_pwwn(struct bfa_lps_s *lps)
-{
-        return lps->pr_pwwn;
-}
-
-/*
- * Return peer node name
- */
-wwn_t
-bfa_lps_get_peer_nwwn(struct bfa_lps_s *lps)
-{
-        return lps->pr_nwwn;
-}
-
-/*
- * return reason code if login request is rejected
- */
-u8
-bfa_lps_get_lsrjt_rsn(struct bfa_lps_s *lps)
-{
-        return lps->lsrjt_rsn;
-}
-
-/*
- * return explanation code if login request is rejected
+ * Set PID in case of n2n (which is assigned during PLOGI)
  */
-u8
-bfa_lps_get_lsrjt_expl(struct bfa_lps_s *lps)
+void
+bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, uint32_t n2n_pid)
 {
-        return lps->lsrjt_expl;
-}
+        bfa_trc(lps->bfa, lps->lp_tag);
+        bfa_trc(lps->bfa, n2n_pid);
 
-/*
- * Return fpma/spma MAC for lport
- */
-mac_t
-bfa_lps_get_lp_mac(struct bfa_lps_s *lps)
-{
-        return lps->lp_mac;
+        lps->lp_pid = n2n_pid;
+        bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
 }
 
 /*
@@ -2050,7 +1969,7 @@ bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 
         default:
                 bfa_trc(bfa, m->mhdr.msg_id);
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -2068,6 +1987,8 @@ bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
                 /*
                  * Start event after IOC is configured and BFA is started.
                  */
+                fcport->use_flash_cfg = BFA_TRUE;
+
                 if (bfa_fcport_send_enable(fcport)) {
                         bfa_trc(fcport->bfa, BFA_TRUE);
                         bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
@@ -2178,7 +2099,7 @@ bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
                 bfa_fcport_update_linkinfo(fcport);
                 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
 
-                bfa_assert(fcport->event_cbfn);
+                WARN_ON(!fcport->event_cbfn);
                 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
                 break;
 
@@ -2229,7 +2150,7 @@ bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
         case BFA_FCPORT_SM_LINKUP:
                 bfa_fcport_update_linkinfo(fcport);
                 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
-                bfa_assert(fcport->event_cbfn);
+                WARN_ON(!fcport->event_cbfn);
                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                                 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
                 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
@@ -2803,12 +2724,6 @@ bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
         }
 }
 
-
-
-/*
- *  hal_port_private
- */
-
 static void
 __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
 {
@@ -2839,7 +2754,7 @@ bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
                 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
                 break;
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -2906,7 +2821,7 @@ bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
         struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
         struct bfa_fcport_ln_s *ln = &fcport->ln;
-        struct bfa_timeval_s tv;
+        struct timeval tv;
 
         memset(fcport, 0, sizeof(struct bfa_fcport_s));
         fcport->bfa = bfa;
@@ -2920,7 +2835,7 @@ bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         /*
          * initialize time stamp for stats reset
          */
-        bfa_os_gettimeofday(&tv);
+        do_gettimeofday(&tv);
         fcport->stats_reset_time = tv.tv_sec;
 
         /*
@@ -3039,6 +2954,7 @@ bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
         m->port_cfg = fcport->cfg;
         m->msgtag = fcport->msgtag;
         m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
+         m->use_flash_cfg = fcport->use_flash_cfg;
         bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
         bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
         bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
@@ -3089,8 +3005,8 @@ bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
 static void
 bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
 {
-        fcport->pwwn = bfa_ioc_get_pwwn(&fcport->bfa->ioc);
-        fcport->nwwn = bfa_ioc_get_nwwn(&fcport->bfa->ioc);
+        fcport->pwwn = fcport->bfa->ioc.attr->pwwn;
+        fcport->nwwn = fcport->bfa->ioc.attr->nwwn;
 
         bfa_trc(fcport->bfa, fcport->pwwn);
         bfa_trc(fcport->bfa, fcport->nwwn);
@@ -3127,7 +3043,7 @@ bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
         struct bfa_qos_stats_s *s)
 {
         u32     *dip = (u32 *) d;
-        u32     *sip = (u32 *) s;
+        __be32  *sip = (__be32 *) s;
         int             i;
 
         /* Now swap the 32 bit fields */
@@ -3140,12 +3056,12 @@ bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
         struct bfa_fcoe_stats_s *s)
 {
         u32     *dip = (u32 *) d;
-        u32     *sip = (u32 *) s;
+        __be32  *sip = (__be32 *) s;
         int             i;
 
         for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
              i = i + 2) {
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
                 dip[i] = be32_to_cpu(sip[i]);
                 dip[i + 1] = be32_to_cpu(sip[i + 1]);
 #else
@@ -3162,7 +3078,7 @@ __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
 
         if (complete) {
                 if (fcport->stats_status == BFA_STATUS_OK) {
-                        struct bfa_timeval_s tv;
+                        struct timeval tv;
 
                         /* Swap FC QoS or FCoE stats */
                         if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
@@ -3174,7 +3090,7 @@ __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
                                         &fcport->stats_ret->fcoe,
                                         &fcport->stats->fcoe);
 
-                                bfa_os_gettimeofday(&tv);
+                                do_gettimeofday(&tv);
                                 fcport->stats_ret->fcoe.secs_reset =
                                         tv.tv_sec - fcport->stats_reset_time;
                         }
@@ -3233,12 +3149,12 @@ __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
         struct bfa_fcport_s *fcport = cbarg;
 
         if (complete) {
-                struct bfa_timeval_s tv;
+                struct timeval tv;
 
                 /*
                  * re-initialize time stamp for stats reset
                  */
-                bfa_os_gettimeofday(&tv);
+                do_gettimeofday(&tv);
                 fcport->stats_reset_time = tv.tv_sec;
 
                 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
@@ -3303,8 +3219,8 @@ bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
         int link_bm = 0;
 
         bfa_trc(fcport->bfa, fcport->cfg.trunked);
-        bfa_assert(scn->trunk_state == BFA_TRUNK_ONLINE ||
-                   scn->trunk_state == BFA_TRUNK_OFFLINE);
+        WARN_ON(scn->trunk_state != BFA_TRUNK_ONLINE &&
+                   scn->trunk_state != BFA_TRUNK_OFFLINE);
 
         bfa_trc(fcport->bfa, trunk->attr.state);
         bfa_trc(fcport->bfa, scn->trunk_state);
@@ -3396,12 +3312,6 @@ bfa_trunk_iocdisable(struct bfa_s *bfa)
         }
 }
 
-
-
-/*
- *  hal_port_public
- */
-
 /*
  * Called to initialize port attributes
  */
@@ -3419,9 +3329,9 @@ bfa_fcport_init(struct bfa_s *bfa)
         fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
         fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
 
-        bfa_assert(fcport->cfg.maxfrsize);
-        bfa_assert(fcport->cfg.rx_bbcredit);
-        bfa_assert(fcport->speed_sup);
+        WARN_ON(!fcport->cfg.maxfrsize);
+        WARN_ON(!fcport->cfg.rx_bbcredit);
+        WARN_ON(!fcport->speed_sup);
 }
 
 /*
@@ -3441,8 +3351,28 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
 
         switch (msg->mhdr.msg_id) {
         case BFI_FCPORT_I2H_ENABLE_RSP:
-                if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
+                if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
+
+                        if (fcport->use_flash_cfg) {
+                                fcport->cfg = i2hmsg.penable_rsp->port_cfg;
+                                fcport->cfg.maxfrsize =
+                                        cpu_to_be16(fcport->cfg.maxfrsize);
+                                fcport->cfg.path_tov =
+                                        cpu_to_be16(fcport->cfg.path_tov);
+                                fcport->cfg.q_depth =
+                                        cpu_to_be16(fcport->cfg.q_depth);
+
+                                if (fcport->cfg.trunked)
+                                        fcport->trunk.attr.state =
+                                                BFA_TRUNK_OFFLINE;
+                                else
+                                        fcport->trunk.attr.state =
+                                                BFA_TRUNK_DISABLED;
+                                fcport->use_flash_cfg = BFA_FALSE;
+                        }
+
                         bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
+                }
                 break;
 
         case BFI_FCPORT_I2H_DISABLE_RSP:
@@ -3498,17 +3428,11 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
                 break;
 
         default:
-                bfa_assert(0);
+                WARN_ON(1);
         break;
         }
 }
 
-
-
-/*
- *  hal_port_api
- */
-
 /*
  * Registered callback for port events.
  */
@@ -3732,8 +3656,8 @@ bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
         attr->nwwn = fcport->nwwn;
         attr->pwwn = fcport->pwwn;
 
-        attr->factorypwwn =  bfa_ioc_get_mfg_pwwn(&bfa->ioc);
-        attr->factorynwwn =  bfa_ioc_get_mfg_nwwn(&bfa->ioc);
+        attr->factorypwwn =  bfa->ioc.attr->mfg_pwwn;
+        attr->factorynwwn =  bfa->ioc.attr->mfg_nwwn;
 
         memcpy(&attr->pport_cfg, &fcport->cfg,
                 sizeof(struct bfa_port_cfg_s));
@@ -3751,7 +3675,7 @@ bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
         /* beacon attributes */
         attr->beacon = fcport->beacon;
         attr->link_e2e_beacon = fcport->link_e2e_beacon;
-        attr->plog_enabled = bfa_plog_get_setting(fcport->bfa->plog);
+        attr->plog_enabled = (bfa_boolean_t)fcport->bfa->plog->plog_enabled;
         attr->io_profile = bfa_fcpim_get_io_profile(fcport->bfa);
 
         attr->pport_cfg.path_tov  = bfa_fcpim_path_tov_get(bfa);
@@ -3818,89 +3742,6 @@ bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
         return BFA_STATUS_OK;
 }
 
-/*
- * Fetch FCQoS port statistics
- */
-bfa_status_t
-bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
-        bfa_cb_port_t cbfn, void *cbarg)
-{
-        /* Meaningful only for FC mode */
-        bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
-
-        return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
-}
-
-/*
- * Reset FCoE port statistics
- */
-bfa_status_t
-bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
-{
-        /* Meaningful only for FC mode */
-        bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
-
-        return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
-}
-
-/*
- * Fetch FCQoS port statistics
- */
-bfa_status_t
-bfa_fcport_get_fcoe_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
-        bfa_cb_port_t cbfn, void *cbarg)
-{
-        /* Meaningful only for FCoE mode */
-        bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
-
-        return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
-}
-
-/*
- * Reset FCoE port statistics
- */
-bfa_status_t
-bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
-{
-        /* Meaningful only for FCoE mode */
-        bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
-
-        return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
-}
-
-void
-bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-
-        qos_attr->state = fcport->qos_attr.state;
-        qos_attr->total_bb_cr = be32_to_cpu(fcport->qos_attr.total_bb_cr);
-}
-
-void
-bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
-        struct bfa_qos_vc_attr_s *qos_vc_attr)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-        struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
-        u32 i = 0;
-
-        qos_vc_attr->total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
-        qos_vc_attr->shared_credit  = be16_to_cpu(bfa_vc_attr->shared_credit);
-        qos_vc_attr->elp_opmode_flags  =
-                        be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
-
-        /* Individual VC info */
-        while (i < qos_vc_attr->total_vc_count) {
-                qos_vc_attr->vc_info[i].vc_credit       =
-                                bfa_vc_attr->vc_info[i].vc_credit;
-                qos_vc_attr->vc_info[i].borrow_credit   =
-                                bfa_vc_attr->vc_info[i].borrow_credit;
-                qos_vc_attr->vc_info[i].priority        =
-                                bfa_vc_attr->vc_info[i].priority;
-                ++i;
-        }
-}
 
 /*
  * Fetch port attributes.
@@ -3924,60 +3765,6 @@ bfa_fcport_is_ratelim(struct bfa_s *bfa)
 
 }
 
-void
-bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-        enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
-
-        bfa_trc(bfa, on_off);
-        bfa_trc(bfa, fcport->cfg.qos_enabled);
-
-        bfa_trc(bfa, ioc_type);
-
-        if (ioc_type == BFA_IOC_TYPE_FC) {
-                fcport->cfg.qos_enabled = on_off;
-                /*
-                 * Notify fcpim of the change in QoS state
-                 */
-                bfa_fcpim_update_ioredirect(bfa);
-        }
-}
-
-void
-bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-
-        bfa_trc(bfa, on_off);
-        bfa_trc(bfa, fcport->cfg.ratelimit);
-
-        fcport->cfg.ratelimit = on_off;
-        if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
-                fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
-}
-
-/*
- * Configure default minimum ratelim speed
- */
-bfa_status_t
-bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-
-        bfa_trc(bfa, speed);
-
-        /* Auto and speeds greater than the supported speed, are invalid */
-        if ((speed == BFA_PORT_SPEED_AUTO) || (speed > fcport->speed_sup)) {
-                bfa_trc(bfa, fcport->speed_sup);
-                return BFA_STATUS_UNSUPP_SPEED;
-        }
-
-        fcport->cfg.trl_def_speed = speed;
-
-        return BFA_STATUS_OK;
-}
-
 /*
  * Get default minimum ratelim speed
  */
@@ -3990,32 +3777,6 @@ bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
         return fcport->cfg.trl_def_speed;
 
 }
-void
-bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-
-        bfa_trc(bfa, status);
-        bfa_trc(bfa, fcport->diag_busy);
-
-        fcport->diag_busy = status;
-}
-
-void
-bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
-        bfa_boolean_t link_e2e_beacon)
-{
-        struct bfa_s *bfa = dev;
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-
-        bfa_trc(bfa, beacon);
-        bfa_trc(bfa, link_e2e_beacon);
-        bfa_trc(bfa, fcport->beacon);
-        bfa_trc(bfa, fcport->link_e2e_beacon);
-
-        fcport->beacon = beacon;
-        fcport->link_e2e_beacon = link_e2e_beacon;
-}
 
 bfa_boolean_t
 bfa_fcport_is_linkup(struct bfa_s *bfa)
@@ -4036,63 +3797,6 @@ bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
         return fcport->cfg.qos_enabled;
 }
 
-bfa_status_t
-bfa_trunk_get_attr(struct bfa_s *bfa, struct bfa_trunk_attr_s *attr)
-
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
-
-        bfa_trc(bfa, fcport->cfg.trunked);
-        bfa_trc(bfa, trunk->attr.state);
-        *attr = trunk->attr;
-        attr->port_id = bfa_lps_get_base_pid(bfa);
-
-        return BFA_STATUS_OK;
-}
-
-void
-bfa_trunk_enable_cfg(struct bfa_s *bfa)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
-
-        bfa_trc(bfa, 1);
-        trunk->attr.state = BFA_TRUNK_OFFLINE;
-        fcport->cfg.trunked = BFA_TRUE;
-}
-
-bfa_status_t
-bfa_trunk_enable(struct bfa_s *bfa)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
-
-        bfa_trc(bfa, 1);
-
-        trunk->attr.state   = BFA_TRUNK_OFFLINE;
-        bfa_fcport_disable(bfa);
-        fcport->cfg.trunked = BFA_TRUE;
-        bfa_fcport_enable(bfa);
-
-        return BFA_STATUS_OK;
-}
-
-bfa_status_t
-bfa_trunk_disable(struct bfa_s *bfa)
-{
-        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
-        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
-
-        bfa_trc(bfa, 0);
-        trunk->attr.state   = BFA_TRUNK_DISABLED;
-        bfa_fcport_disable(bfa);
-        fcport->cfg.trunked = BFA_FALSE;
-        bfa_fcport_enable(bfa);
-        return BFA_STATUS_OK;
-}
-
-
 /*
  * Rport State machine functions
  */
@@ -4606,8 +4310,8 @@ bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         mod->rps_list = rp;
         mod->num_rports = cfg->fwcfg.num_rports;
 
-        bfa_assert(mod->num_rports &&
-                   !(mod->num_rports & (mod->num_rports - 1)));
+        WARN_ON(!mod->num_rports ||
+                   (mod->num_rports & (mod->num_rports - 1)));
 
         for (i = 0; i < mod->num_rports; i++, rp++) {
                 memset(rp, 0, sizeof(struct bfa_rport_s));
@@ -4675,7 +4379,7 @@ bfa_rport_free(struct bfa_rport_s *rport)
 {
         struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
 
-        bfa_assert(bfa_q_is_on_q(&mod->rp_active_q, rport));
+        WARN_ON(!bfa_q_is_on_q(&mod->rp_active_q, rport));
         list_del(&rport->qe);
         list_add_tail(&rport->qe, &mod->rp_free_q);
 }
@@ -4788,13 +4492,13 @@ bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
                 rp->fw_handle = msg.create_rsp->fw_handle;
                 rp->qos_attr = msg.create_rsp->qos_attr;
-                bfa_assert(msg.create_rsp->status == BFA_STATUS_OK);
+                WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
                 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
                 break;
 
         case BFI_RPORT_I2H_DELETE_RSP:
                 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
-                bfa_assert(msg.delete_rsp->status == BFA_STATUS_OK);
+                WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
                 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
                 break;
 
@@ -4806,7 +4510,7 @@ bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
 
         default:
                 bfa_trc(bfa, m->mhdr.msg_id);
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
@@ -4828,24 +4532,18 @@ bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
 
         rp->bfa = bfa;
         rp->rport_drv = rport_drv;
-        bfa_rport_clear_stats(rp);
+        memset(&rp->stats, 0, sizeof(rp->stats));
 
-        bfa_assert(bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
+        WARN_ON(!bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
         bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
 
         return rp;
 }
 
 void
-bfa_rport_delete(struct bfa_rport_s *rport)
-{
-        bfa_sm_send_event(rport, BFA_RPORT_SM_DELETE);
-}
-
-void
 bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
 {
-        bfa_assert(rport_info->max_frmsz != 0);
+        WARN_ON(rport_info->max_frmsz == 0);
 
         /*
          * Some JBODs are seen to be not setting PDU size correctly in PLOGI
@@ -4861,43 +4559,15 @@ bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
 }
 
 void
-bfa_rport_offline(struct bfa_rport_s *rport)
-{
-        bfa_sm_send_event(rport, BFA_RPORT_SM_OFFLINE);
-}
-
-void
 bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
 {
-        bfa_assert(speed != 0);
-        bfa_assert(speed != BFA_PORT_SPEED_AUTO);
+        WARN_ON(speed == 0);
+        WARN_ON(speed == BFA_PORT_SPEED_AUTO);
 
         rport->rport_info.speed = speed;
         bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
 }
 
-void
-bfa_rport_get_stats(struct bfa_rport_s *rport,
-        struct bfa_rport_hal_stats_s *stats)
-{
-        *stats = rport->stats;
-}
-
-void
-bfa_rport_get_qos_attr(struct bfa_rport_s *rport,
-                                        struct bfa_rport_qos_attr_s *qos_attr)
-{
-        qos_attr->qos_priority  = rport->qos_attr.qos_priority;
-        qos_attr->qos_flow_id  = be32_to_cpu(rport->qos_attr.qos_flow_id);
-
-}
-
-void
-bfa_rport_clear_stats(struct bfa_rport_s *rport)
-{
-        memset(&rport->stats, 0, sizeof(rport->stats));
-}
-
 
 /*
  * SGPG related functions
@@ -4952,7 +4622,7 @@ bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         sgpg_pa.pa = mod->sgpg_arr_pa;
         mod->free_sgpgs = mod->num_sgpgs;
 
-        bfa_assert(!(sgpg_pa.pa & (sizeof(struct bfi_sgpg_s) - 1)));
+        WARN_ON(sgpg_pa.pa & (sizeof(struct bfi_sgpg_s) - 1));
 
         for (i = 0; i < mod->num_sgpgs; i++) {
                 memset(hsgpg, 0, sizeof(*hsgpg));
@@ -4993,12 +4663,6 @@ bfa_sgpg_iocdisable(struct bfa_s *bfa)
 {
 }
 
-
-
-/*
- *  hal_sgpg_public BFA SGPG public functions
- */
-
 bfa_status_t
 bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
 {
@@ -5006,14 +4670,12 @@ bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
         struct bfa_sgpg_s *hsgpg;
         int i;
 
-        bfa_trc_fp(bfa, nsgpgs);
-
         if (mod->free_sgpgs < nsgpgs)
                 return BFA_STATUS_ENOMEM;
 
         for (i = 0; i < nsgpgs; i++) {
                 bfa_q_deq(&mod->sgpg_q, &hsgpg);
-                bfa_assert(hsgpg);
+                WARN_ON(!hsgpg);
                 list_add_tail(&hsgpg->qe, sgpg_q);
         }
 
@@ -5027,10 +4689,8 @@ bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
         struct bfa_sgpg_wqe_s *wqe;
 
-        bfa_trc_fp(bfa, nsgpg);
-
         mod->free_sgpgs += nsgpg;
-        bfa_assert(mod->free_sgpgs <= mod->num_sgpgs);
+        WARN_ON(mod->free_sgpgs > mod->num_sgpgs);
 
         list_splice_tail_init(sgpg_q, &mod->sgpg_q);
 
@@ -5060,8 +4720,8 @@ bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
 {
         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
 
-        bfa_assert(nsgpg > 0);
-        bfa_assert(nsgpg > mod->free_sgpgs);
+        WARN_ON(nsgpg <= 0);
+        WARN_ON(nsgpg <= mod->free_sgpgs);
 
         wqe->nsgpg_total = wqe->nsgpg = nsgpg;
 
@@ -5072,7 +4732,7 @@ bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
                 /*
                  * no one else is waiting for SGPG
                  */
-                bfa_assert(list_empty(&mod->sgpg_wait_q));
+                WARN_ON(!list_empty(&mod->sgpg_wait_q));
                 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
                 wqe->nsgpg -= mod->free_sgpgs;
                 mod->free_sgpgs = 0;
@@ -5086,7 +4746,7 @@ bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
 {
         struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
 
-        bfa_assert(bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
+        WARN_ON(!bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
         list_del(&wqe->qe);
 
         if (wqe->nsgpg_total != wqe->nsgpg)
@@ -5318,7 +4978,7 @@ uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
         uf->data_ptr = buf;
         uf->data_len = m->xfr_len;
 
-        bfa_assert(uf->data_len >= sizeof(struct fchs_s));
+        WARN_ON(uf->data_len < sizeof(struct fchs_s));
 
         if (uf->data_len == sizeof(struct fchs_s)) {
                 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
@@ -5361,12 +5021,6 @@ bfa_uf_start(struct bfa_s *bfa)
         bfa_uf_post_all(BFA_UF_MOD(bfa));
 }
 
-
-
-/*
- *  hal_uf_api
- */
-
 /*
  * Register handler for all unsolicted recieve frames.
  *
@@ -5414,7 +5068,7 @@ bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
 
         default:
                 bfa_trc(bfa, msg->mhdr.msg_id);
-                bfa_assert(0);
+                WARN_ON(1);
         }
 }
 
diff --git a/drivers/scsi/bfa/bfa_svc.h b/drivers/scsi/bfa/bfa_svc.h
index e2349d5cdb93..331ad992a581 100644
--- a/drivers/scsi/bfa/bfa_svc.h
+++ b/drivers/scsi/bfa/bfa_svc.h
@@ -220,6 +220,18 @@ void	bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
 /*
  * RPORT related defines
  */
+enum bfa_rport_event {
+        BFA_RPORT_SM_CREATE     = 1,    /*  rport create event          */
+        BFA_RPORT_SM_DELETE     = 2,    /*  deleting an existing rport  */
+        BFA_RPORT_SM_ONLINE     = 3,    /*  rport is online             */
+        BFA_RPORT_SM_OFFLINE    = 4,    /*  rport is offline            */
+        BFA_RPORT_SM_FWRSP      = 5,    /*  firmware response           */
+        BFA_RPORT_SM_HWFAIL     = 6,    /*  IOC h/w failure             */
+        BFA_RPORT_SM_QOS_SCN    = 7,    /*  QoS SCN from firmware       */
+        BFA_RPORT_SM_SET_SPEED  = 8,    /*  Set Rport Speed             */
+        BFA_RPORT_SM_QRESUME    = 9,    /*  space in requeue queue      */
+};
+
 #define BFA_RPORT_MIN   4
 
 struct bfa_rport_mod_s {
@@ -432,6 +444,7 @@ struct bfa_fcport_s {
         u8                      myalpa; /*  my ALPA in LOOP topology */
         u8                      rsvd[3];
         struct bfa_port_cfg_s   cfg;    /*  current port configuration */
+        bfa_boolean_t           use_flash_cfg; /* get port cfg from flash */
         struct bfa_qos_attr_s  qos_attr;   /* QoS Attributes */
         struct bfa_qos_vc_attr_s qos_vc_attr;  /*  VC info from ELP */
         struct bfa_reqq_wait_s  reqq_wait;
@@ -500,30 +513,9 @@ void bfa_fcport_event_register(struct bfa_s *bfa,
                         void (*event_cbfn) (void *cbarg,
                         enum bfa_port_linkstate event), void *event_cbarg);
 bfa_boolean_t bfa_fcport_is_disabled(struct bfa_s *bfa);
-void bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off);
-void bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off);
-bfa_status_t bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa,
-                                          enum bfa_port_speed speed);
 enum bfa_port_speed bfa_fcport_get_ratelim_speed(struct bfa_s *bfa);
 
 void bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit);
-void bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status);
-void bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
-                       bfa_boolean_t link_e2e_beacon);
-void bfa_fcport_qos_get_attr(struct bfa_s *bfa,
-                             struct bfa_qos_attr_s *qos_attr);
-void bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
-                                struct bfa_qos_vc_attr_s *qos_vc_attr);
-bfa_status_t bfa_fcport_get_qos_stats(struct bfa_s *bfa,
-                                      union bfa_fcport_stats_u *stats,
-                                      bfa_cb_port_t cbfn, void *cbarg);
-bfa_status_t bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn,
-                                        void *cbarg);
-bfa_status_t bfa_fcport_get_fcoe_stats(struct bfa_s *bfa,
-                                       union bfa_fcport_stats_u *stats,
-                                       bfa_cb_port_t cbfn, void *cbarg);
-bfa_status_t bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn,
-                                         void *cbarg);
 bfa_boolean_t     bfa_fcport_is_ratelim(struct bfa_s *bfa);
 bfa_boolean_t   bfa_fcport_is_linkup(struct bfa_s *bfa);
 bfa_status_t bfa_fcport_get_stats(struct bfa_s *bfa,
@@ -537,14 +529,9 @@ bfa_boolean_t bfa_fcport_is_qos_enabled(struct bfa_s *bfa);
  * bfa rport API functions
  */
 struct bfa_rport_s *bfa_rport_create(struct bfa_s *bfa, void *rport_drv);
-void bfa_rport_delete(struct bfa_rport_s *rport);
 void bfa_rport_online(struct bfa_rport_s *rport,
                       struct bfa_rport_info_s *rport_info);
-void bfa_rport_offline(struct bfa_rport_s *rport);
 void bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed);
-void bfa_rport_get_stats(struct bfa_rport_s *rport,
-                         struct bfa_rport_hal_stats_s *stats);
-void bfa_rport_clear_stats(struct bfa_rport_s *rport);
 void bfa_cb_rport_online(void *rport);
 void bfa_cb_rport_offline(void *rport);
 void bfa_cb_rport_qos_scn_flowid(void *rport,
@@ -553,8 +540,6 @@ void bfa_cb_rport_qos_scn_flowid(void *rport,
 void bfa_cb_rport_qos_scn_prio(void *rport,
                                struct bfa_rport_qos_attr_s old_qos_attr,
                                struct bfa_rport_qos_attr_s new_qos_attr);
-void bfa_rport_get_qos_attr(struct bfa_rport_s *rport,
-                            struct bfa_rport_qos_attr_s *qos_attr);
 
 /*
  * bfa fcxp API functions
@@ -619,38 +604,18 @@ void bfa_uf_free(struct bfa_uf_s *uf);
 u32 bfa_lps_get_max_vport(struct bfa_s *bfa);
 struct bfa_lps_s *bfa_lps_alloc(struct bfa_s *bfa);
 void bfa_lps_delete(struct bfa_lps_s *lps);
-void bfa_lps_discard(struct bfa_lps_s *lps);
 void bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa,
                    u16 pdusz, wwn_t pwwn, wwn_t nwwn,
                    bfa_boolean_t auth_en);
 void bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz,
                    wwn_t pwwn, wwn_t nwwn);
-void bfa_lps_flogo(struct bfa_lps_s *lps);
 void bfa_lps_fdisclogo(struct bfa_lps_s *lps);
-u8 bfa_lps_get_tag(struct bfa_lps_s *lps);
-bfa_boolean_t bfa_lps_is_npiv_en(struct bfa_lps_s *lps);
-bfa_boolean_t bfa_lps_is_fport(struct bfa_lps_s *lps);
-bfa_boolean_t bfa_lps_is_brcd_fabric(struct bfa_lps_s *lps);
-bfa_boolean_t bfa_lps_is_authreq(struct bfa_lps_s *lps);
-bfa_eproto_status_t bfa_lps_get_extstatus(struct bfa_lps_s *lps);
-u32 bfa_lps_get_pid(struct bfa_lps_s *lps);
+void bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, u32 n2n_pid);
 u32 bfa_lps_get_base_pid(struct bfa_s *bfa);
 u8 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid);
-u16 bfa_lps_get_peer_bbcredit(struct bfa_lps_s *lps);
-wwn_t bfa_lps_get_peer_pwwn(struct bfa_lps_s *lps);
-wwn_t bfa_lps_get_peer_nwwn(struct bfa_lps_s *lps);
-u8 bfa_lps_get_lsrjt_rsn(struct bfa_lps_s *lps);
-u8 bfa_lps_get_lsrjt_expl(struct bfa_lps_s *lps);
-mac_t bfa_lps_get_lp_mac(struct bfa_lps_s *lps);
 void bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status);
 void bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status);
 void bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg);
 void bfa_cb_lps_cvl_event(void *bfad, void *uarg);
 
-void bfa_trunk_enable_cfg(struct bfa_s *bfa);
-bfa_status_t bfa_trunk_enable(struct bfa_s *bfa);
-bfa_status_t bfa_trunk_disable(struct bfa_s *bfa);
-bfa_status_t bfa_trunk_get_attr(struct bfa_s *bfa,
-                struct bfa_trunk_attr_s *attr);
-
 #endif /* __BFA_SVC_H__ */
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 6797720213b2..44524cf55d33 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -32,7 +32,6 @@
 #include "bfad_drv.h"
 #include "bfad_im.h"
 #include "bfa_fcs.h"
-#include "bfa_os_inc.h"
 #include "bfa_defs.h"
 #include "bfa.h"
 
@@ -61,12 +60,12 @@ int		msix_disable_cb = 0, msix_disable_ct = 0;
 u32     bfi_image_ct_fc_size, bfi_image_ct_cna_size, bfi_image_cb_fc_size;
 u32     *bfi_image_ct_fc, *bfi_image_ct_cna, *bfi_image_cb_fc;
 
-const char *msix_name_ct[] = {
+static const char *msix_name_ct[] = {
         "cpe0", "cpe1", "cpe2", "cpe3",
         "rme0", "rme1", "rme2", "rme3",
         "ctrl" };
 
-const char *msix_name_cb[] = {
+static const char *msix_name_cb[] = {
         "cpe0", "cpe1", "cpe2", "cpe3",
         "rme0", "rme1", "rme2", "rme3",
         "eemc", "elpu0", "elpu1", "epss", "mlpu" };
@@ -206,7 +205,7 @@ bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event)
                 }
 
                 spin_lock_irqsave(&bfad->bfad_lock, flags);
-                bfa_init(&bfad->bfa);
+                bfa_iocfc_init(&bfad->bfa);
                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
                 /* Set up interrupt handler for each vectors */
@@ -533,7 +532,7 @@ bfad_hal_mem_release(struct bfad_s *bfad)
                                         (dma_addr_t) meminfo_elem->dma);
                                 break;
                         default:
-                                bfa_assert(0);
+                                WARN_ON(1);
                                 break;
                         }
                 }
@@ -725,7 +724,7 @@ bfad_bfa_tmo(unsigned long data)
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
 
-        bfa_timer_tick(&bfad->bfa);
+        bfa_timer_beat(&bfad->bfa.timer_mod);
 
         bfa_comp_deq(&bfad->bfa, &doneq);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -882,8 +881,8 @@ bfad_drv_init(struct bfad_s *bfad)
                 goto out_hal_mem_alloc_failure;
         }
 
-        bfa_init_trc(&bfad->bfa, bfad->trcmod);
-        bfa_init_plog(&bfad->bfa, &bfad->plog_buf);
+        bfad->bfa.trcmod = bfad->trcmod;
+        bfad->bfa.plog = &bfad->plog_buf;
         bfa_plog_init(&bfad->plog_buf);
         bfa_plog_str(&bfad->plog_buf, BFA_PL_MID_DRVR, BFA_PL_EID_DRIVER_START,
                      0, "Driver Attach");
@@ -893,9 +892,9 @@ bfad_drv_init(struct bfad_s *bfad)
 
         /* FCS INIT */
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        bfa_fcs_trc_init(&bfad->bfa_fcs, bfad->trcmod);
+        bfad->bfa_fcs.trcmod = bfad->trcmod;
         bfa_fcs_attach(&bfad->bfa_fcs, &bfad->bfa, bfad, BFA_FALSE);
-        bfa_fcs_set_fdmi_param(&bfad->bfa_fcs, fdmi_enable);
+        bfad->bfa_fcs.fdmi_enabled = fdmi_enable;
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
         bfad->bfad_flags |= BFAD_DRV_INIT_DONE;
@@ -913,7 +912,7 @@ bfad_drv_uninit(struct bfad_s *bfad)
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         init_completion(&bfad->comp);
-        bfa_stop(&bfad->bfa);
+        bfa_iocfc_stop(&bfad->bfa);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         wait_for_completion(&bfad->comp);
 
@@ -932,8 +931,8 @@ bfad_drv_start(struct bfad_s *bfad)
         unsigned long   flags;
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        bfa_start(&bfad->bfa);
-        bfa_fcs_start(&bfad->bfa_fcs);
+        bfa_iocfc_start(&bfad->bfa);
+        bfa_fcs_fabric_modstart(&bfad->bfa_fcs);
         bfad->bfad_flags |= BFAD_HAL_START_DONE;
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
@@ -963,7 +962,7 @@ bfad_stop(struct bfad_s *bfad)
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         init_completion(&bfad->comp);
-        bfa_stop(&bfad->bfa);
+        bfa_iocfc_stop(&bfad->bfa);
         bfad->bfad_flags &= ~BFAD_HAL_START_DONE;
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         wait_for_completion(&bfad->comp);
@@ -1102,15 +1101,15 @@ bfad_start_ops(struct bfad_s *bfad) {
 
         /*
          * If bfa_linkup_delay is set to -1 default; try to retrive the
-         * value using the bfad_os_get_linkup_delay(); else use the
+         * value using the bfad_get_linkup_delay(); else use the
          * passed in module param value as the bfa_linkup_delay.
          */
         if (bfa_linkup_delay < 0) {
-                bfa_linkup_delay = bfad_os_get_linkup_delay(bfad);
-                bfad_os_rport_online_wait(bfad);
+                bfa_linkup_delay = bfad_get_linkup_delay(bfad);
+                bfad_rport_online_wait(bfad);
                 bfa_linkup_delay = -1;
         } else
-                bfad_os_rport_online_wait(bfad);
+                bfad_rport_online_wait(bfad);
 
         BFA_LOG(KERN_INFO, bfad, bfa_log_level, "bfa device claimed\n");
 
@@ -1167,7 +1166,6 @@ bfad_intx(int irq, void *dev_id)
                 spin_lock_irqsave(&bfad->bfad_lock, flags);
                 bfa_comp_free(&bfad->bfa, &doneq);
                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
-                bfa_trc_fp(bfad, irq);
         }
 
         return IRQ_HANDLED;
@@ -1524,7 +1522,7 @@ bfad_init(void)
         if (strcmp(FCPI_NAME, " fcpim") == 0)
                 supported_fc4s |= BFA_LPORT_ROLE_FCP_IM;
 
-        bfa_ioc_auto_recover(ioc_auto_recover);
+        bfa_auto_recover = ioc_auto_recover;
         bfa_fcs_rport_set_del_timeout(rport_del_timeout);
 
         error = pci_register_driver(&bfad_pci_driver);
diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index ed9fff440b5c..a94ea4235433 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -25,7 +25,7 @@
 /*
  * FC transport template entry, get SCSI target port ID.
  */
-void
+static void
 bfad_im_get_starget_port_id(struct scsi_target *starget)
 {
         struct Scsi_Host *shost;
@@ -40,7 +40,7 @@ bfad_im_get_starget_port_id(struct scsi_target *starget)
         bfad = im_port->bfad;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
 
-        itnim = bfad_os_get_itnim(im_port, starget->id);
+        itnim = bfad_get_itnim(im_port, starget->id);
         if (itnim)
                 fc_id = bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim);
 
@@ -51,7 +51,7 @@ bfad_im_get_starget_port_id(struct scsi_target *starget)
 /*
  * FC transport template entry, get SCSI target nwwn.
  */
-void
+static void
 bfad_im_get_starget_node_name(struct scsi_target *starget)
 {
         struct Scsi_Host *shost;
@@ -66,7 +66,7 @@ bfad_im_get_starget_node_name(struct scsi_target *starget)
         bfad = im_port->bfad;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
 
-        itnim = bfad_os_get_itnim(im_port, starget->id);
+        itnim = bfad_get_itnim(im_port, starget->id);
         if (itnim)
                 node_name = bfa_fcs_itnim_get_nwwn(&itnim->fcs_itnim);
 
@@ -77,7 +77,7 @@ bfad_im_get_starget_node_name(struct scsi_target *starget)
 /*
  * FC transport template entry, get SCSI target pwwn.
  */
-void
+static void
 bfad_im_get_starget_port_name(struct scsi_target *starget)
 {
         struct Scsi_Host *shost;
@@ -92,7 +92,7 @@ bfad_im_get_starget_port_name(struct scsi_target *starget)
         bfad = im_port->bfad;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
 
-        itnim = bfad_os_get_itnim(im_port, starget->id);
+        itnim = bfad_get_itnim(im_port, starget->id);
         if (itnim)
                 port_name = bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim);
 
@@ -103,7 +103,7 @@ bfad_im_get_starget_port_name(struct scsi_target *starget)
 /*
  * FC transport template entry, get SCSI host port ID.
  */
-void
+static void
 bfad_im_get_host_port_id(struct Scsi_Host *shost)
 {
         struct bfad_im_port_s *im_port =
@@ -111,7 +111,7 @@ bfad_im_get_host_port_id(struct Scsi_Host *shost)
         struct bfad_port_s    *port = im_port->port;
 
         fc_host_port_id(shost) =
-                        bfa_os_hton3b(bfa_fcs_lport_get_fcid(port->fcs_port));
+                        bfa_hton3b(bfa_fcs_lport_get_fcid(port->fcs_port));
 }
 
 /*
@@ -487,7 +487,7 @@ bfad_im_vport_delete(struct fc_vport *fc_vport)
         wait_for_completion(vport->comp_del);
 
 free_scsi_host:
-        bfad_os_scsi_host_free(bfad, im_port);
+        bfad_scsi_host_free(bfad, im_port);
 
         kfree(vport);
 
diff --git a/drivers/scsi/bfa/bfad_debugfs.c b/drivers/scsi/bfa/bfad_debugfs.c
index 1fedeeb4ac1f..c66e32eced7b 100644
--- a/drivers/scsi/bfa/bfad_debugfs.c
+++ b/drivers/scsi/bfa/bfad_debugfs.c
@@ -90,7 +90,7 @@ bfad_debugfs_open_fwtrc(struct inode *inode, struct file *file)
         memset(fw_debug->debug_buffer, 0, fw_debug->buffer_len);
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        rc = bfa_debug_fwtrc(&bfad->bfa,
+        rc = bfa_ioc_debug_fwtrc(&bfad->bfa.ioc,
                         fw_debug->debug_buffer,
                         &fw_debug->buffer_len);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -134,7 +134,7 @@ bfad_debugfs_open_fwsave(struct inode *inode, struct file *file)
         memset(fw_debug->debug_buffer, 0, fw_debug->buffer_len);
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        rc = bfa_debug_fwsave(&bfad->bfa,
+        rc = bfa_ioc_debug_fwsave(&bfad->bfa.ioc,
                         fw_debug->debug_buffer,
                         &fw_debug->buffer_len);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -208,7 +208,7 @@ bfad_debugfs_read(struct file *file, char __user *buf,
         if (!debug || !debug->debug_buffer)
                 return 0;
 
-        return memory_read_from_buffer(buf, nbytes, pos,
+        return simple_read_from_buffer(buf, nbytes, pos,
                                 debug->debug_buffer, debug->buffer_len);
 }
 
@@ -254,7 +254,7 @@ bfad_debugfs_read_regrd(struct file *file, char __user *buf,
         if (!bfad->regdata)
                 return 0;
 
-        rc = memory_read_from_buffer(buf, nbytes, pos,
+        rc = simple_read_from_buffer(buf, nbytes, pos,
                         bfad->regdata, bfad->reglen);
 
         if ((*pos + nbytes) >= bfad->reglen) {
@@ -279,15 +279,31 @@ bfad_debugfs_write_regrd(struct file *file, const char __user *buf,
         u32 *regbuf;
         void __iomem *rb, *reg_addr;
         unsigned long flags;
+        void *kern_buf;
 
-        rc = sscanf(buf, "%x:%x", &addr, &len);
+        kern_buf = kzalloc(nbytes, GFP_KERNEL);
+
+        if (!kern_buf) {
+                printk(KERN_INFO "bfad[%d]: Failed to allocate buffer\n",
+                                bfad->inst_no);
+                return -ENOMEM;
+        }
+
+        if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
+                kfree(kern_buf);
+                return -ENOMEM;
+        }
+
+        rc = sscanf(kern_buf, "%x:%x", &addr, &len);
         if (rc < 2) {
                 printk(KERN_INFO
                         "bfad[%d]: %s failed to read user buf\n",
                         bfad->inst_no, __func__);
+                kfree(kern_buf);
                 return -EINVAL;
         }
 
+        kfree(kern_buf);
         kfree(bfad->regdata);
         bfad->regdata = NULL;
         bfad->reglen = 0;
@@ -339,14 +355,30 @@ bfad_debugfs_write_regwr(struct file *file, const char __user *buf,
         int addr, val, rc;
         void __iomem *reg_addr;
         unsigned long flags;
+        void *kern_buf;
+
+        kern_buf = kzalloc(nbytes, GFP_KERNEL);
+
+        if (!kern_buf) {
+                printk(KERN_INFO "bfad[%d]: Failed to allocate buffer\n",
+                                bfad->inst_no);
+                return -ENOMEM;
+        }
+
+        if (copy_from_user(kern_buf, (void  __user *)buf, nbytes)) {
+                kfree(kern_buf);
+                return -ENOMEM;
+        }
 
-        rc = sscanf(buf, "%x:%x", &addr, &val);
+        rc = sscanf(kern_buf, "%x:%x", &addr, &val);
         if (rc < 2) {
                 printk(KERN_INFO
                         "bfad[%d]: %s failed to read user buf\n",
                         bfad->inst_no, __func__);
+                kfree(kern_buf);
                 return -EINVAL;
         }
+        kfree(kern_buf);
 
         addr &= BFA_REG_ADDRMSK(bfa); /* offset only 17 bit and word align */
 
@@ -359,7 +391,7 @@ bfad_debugfs_write_regwr(struct file *file, const char __user *buf,
                 return -EINVAL;
         }
 
-        reg_addr = (u32 *) ((u8 *) bfa_ioc_bar0(ioc) + addr);
+        reg_addr = (bfa_ioc_bar0(ioc)) + addr;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         writel(val, reg_addr);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
diff --git a/drivers/scsi/bfa/bfad_drv.h b/drivers/scsi/bfa/bfad_drv.h
index d5ce2349ac59..7f9ea90254cd 100644
--- a/drivers/scsi/bfa/bfad_drv.h
+++ b/drivers/scsi/bfa/bfad_drv.h
@@ -26,7 +26,23 @@
 #ifndef __BFAD_DRV_H__
 #define __BFAD_DRV_H__
 
-#include "bfa_os_inc.h"
+#include <linux/types.h>
+#include <linux/version.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/idr.h>
+#include <linux/interrupt.h>
+#include <linux/cdev.h>
+#include <linux/fs.h>
+#include <linux/delay.h>
+#include <linux/vmalloc.h>
+#include <linux/workqueue.h>
+#include <linux/bitops.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_tcq.h>
+#include <scsi/scsi_transport_fc.h>
+#include <scsi/scsi_transport.h>
 
 #include "bfa_modules.h"
 #include "bfa_fcs.h"
@@ -39,7 +55,7 @@
 #ifdef BFA_DRIVER_VERSION
 #define BFAD_DRIVER_VERSION    BFA_DRIVER_VERSION
 #else
-#define BFAD_DRIVER_VERSION    "2.3.2.0"
+#define BFAD_DRIVER_VERSION    "2.3.2.3"
 #endif
 
 #define BFAD_PROTO_NAME FCPI_NAME
@@ -263,28 +279,21 @@ struct bfad_hal_comp {
  */
 #define nextLowerInt(x)                         \
 do {                                            \
-        int i;                                  \
+        int __i;                                  \
         (*x)--;                                 \
-        for (i = 1; i < (sizeof(int)*8); i <<= 1) \
-                (*x) = (*x) | (*x) >> i;        \
+        for (__i = 1; __i < (sizeof(int)*8); __i <<= 1) \
+                (*x) = (*x) | (*x) >> __i;      \
         (*x)++;                                 \
         (*x) = (*x) >> 1;                       \
 } while (0)
 
 
-#define list_remove_head(list, entry, type, member)             \
-do {                                                            \
-        entry = NULL;                                           \
-        if (!list_empty(list)) {                                \
-                entry = list_entry((list)->next, type, member); \
-                list_del_init(&entry->member);                  \
-        }                                                       \
+#define BFA_LOG(level, bfad, mask, fmt, arg...)                         \
+do {                                                                    \
+        if (((mask) == 4) || (level[1] <= '4'))                         \
+                dev_printk(level, &((bfad)->pcidev)->dev, fmt, ##arg);  \
 } while (0)
 
-#define list_get_first(list, type, member)                              \
-((list_empty(list)) ? NULL :                                            \
-        list_entry((list)->next, type, member))
-
 bfa_status_t    bfad_vport_create(struct bfad_s *bfad, u16 vf_id,
                                   struct bfa_lport_cfg_s *port_cfg,
                                   struct device *dev);
@@ -316,8 +325,8 @@ void		bfad_debugfs_exit(struct bfad_port_s *port);
 
 void bfad_pci_remove(struct pci_dev *pdev);
 int bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid);
-void bfad_os_rport_online_wait(struct bfad_s *bfad);
-int bfad_os_get_linkup_delay(struct bfad_s *bfad);
+void bfad_rport_online_wait(struct bfad_s *bfad);
+int bfad_get_linkup_delay(struct bfad_s *bfad);
 int bfad_install_msix_handler(struct bfad_s *bfad);
 
 extern struct idr bfad_im_port_index;
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index fbad5e9b2402..c2b36179e8e8 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -21,7 +21,6 @@
 
 #include "bfad_drv.h"
 #include "bfad_im.h"
-#include "bfa_cb_ioim.h"
 #include "bfa_fcs.h"
 
 BFA_TRC_FILE(LDRV, IM);
@@ -93,10 +92,10 @@ bfa_cb_ioim_done(void *drv, struct bfad_ioim_s *dio,
                 if (!cmnd->result && itnim &&
                          (bfa_lun_queue_depth > cmnd->device->queue_depth)) {
                         /* Queue depth adjustment for good status completion */
-                        bfad_os_ramp_up_qdepth(itnim, cmnd->device);
+                        bfad_ramp_up_qdepth(itnim, cmnd->device);
                 } else if (cmnd->result == SAM_STAT_TASK_SET_FULL && itnim) {
                         /* qfull handling */
-                        bfad_os_handle_qfull(itnim, cmnd->device);
+                        bfad_handle_qfull(itnim, cmnd->device);
                 }
         }
 
@@ -124,7 +123,7 @@ bfa_cb_ioim_good_comp(void *drv, struct bfad_ioim_s *dio)
                 if (itnim_data) {
                         itnim = itnim_data->itnim;
                         if (itnim)
-                                bfad_os_ramp_up_qdepth(itnim, cmnd->device);
+                                bfad_ramp_up_qdepth(itnim, cmnd->device);
                 }
         }
 
@@ -183,7 +182,7 @@ bfad_im_info(struct Scsi_Host *shost)
         bfa_get_adapter_model(bfa, model);
 
         memset(bfa_buf, 0, sizeof(bfa_buf));
-        if (ioc->ctdev)
+        if (ioc->ctdev && !ioc->fcmode)
                 snprintf(bfa_buf, sizeof(bfa_buf),
                 "Brocade FCOE Adapter, " "model: %s hwpath: %s driver: %s",
                  model, bfad->pci_name, BFAD_DRIVER_VERSION);
@@ -258,6 +257,7 @@ bfad_im_target_reset_send(struct bfad_s *bfad, struct scsi_cmnd *cmnd,
         struct bfa_tskim_s *tskim;
         struct bfa_itnim_s *bfa_itnim;
         bfa_status_t    rc = BFA_STATUS_OK;
+        struct scsi_lun scsilun;
 
         tskim = bfa_tskim_alloc(&bfad->bfa, (struct bfad_tskim_s *) cmnd);
         if (!tskim) {
@@ -274,7 +274,8 @@ bfad_im_target_reset_send(struct bfad_s *bfad, struct scsi_cmnd *cmnd,
         cmnd->host_scribble = NULL;
         cmnd->SCp.Status = 0;
         bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim->fcs_itnim);
-        bfa_tskim_start(tskim, bfa_itnim, (lun_t)0,
+        memset(&scsilun, 0, sizeof(scsilun));
+        bfa_tskim_start(tskim, bfa_itnim, scsilun,
                             FCP_TM_TARGET_RESET, BFAD_TARGET_RESET_TMO);
 out:
         return rc;
@@ -301,6 +302,7 @@ bfad_im_reset_lun_handler(struct scsi_cmnd *cmnd)
         int             rc = SUCCESS;
         unsigned long   flags;
         enum bfi_tskim_status task_status;
+        struct scsi_lun scsilun;
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         itnim = itnim_data->itnim;
@@ -327,8 +329,8 @@ bfad_im_reset_lun_handler(struct scsi_cmnd *cmnd)
         cmnd->SCp.ptr = (char *)&wq;
         cmnd->SCp.Status = 0;
         bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim->fcs_itnim);
-        bfa_tskim_start(tskim, bfa_itnim,
-                            bfad_int_to_lun(cmnd->device->lun),
+        int_to_scsilun(cmnd->device->lun, &scsilun);
+        bfa_tskim_start(tskim, bfa_itnim, scsilun,
                             FCP_TM_LUN_RESET, BFAD_LUN_RESET_TMO);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
@@ -364,7 +366,7 @@ bfad_im_reset_bus_handler(struct scsi_cmnd *cmnd)
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         for (i = 0; i < MAX_FCP_TARGET; i++) {
-                itnim = bfad_os_get_itnim(im_port, i);
+                itnim = bfad_get_itnim(im_port, i);
                 if (itnim) {
                         cmnd->SCp.ptr = (char *)&wq;
                         rc = bfad_im_target_reset_send(bfad, cmnd, itnim);
@@ -447,7 +449,7 @@ bfa_fcb_itnim_free(struct bfad_s *bfad, struct bfad_itnim_s *itnim_drv)
         struct bfad_im_s        *im = itnim_drv->im;
 
         /* online to free state transtion should not happen */
-        bfa_assert(itnim_drv->state != ITNIM_STATE_ONLINE);
+        WARN_ON(itnim_drv->state == ITNIM_STATE_ONLINE);
 
         itnim_drv->queue_work = 1;
         /* offline request is not yet done, use the same request to free */
@@ -545,7 +547,7 @@ bfad_im_scsi_host_alloc(struct bfad_s *bfad, struct bfad_im_port_s *im_port,
 
         mutex_unlock(&bfad_mutex);
 
-        im_port->shost = bfad_os_scsi_host_alloc(im_port, bfad);
+        im_port->shost = bfad_scsi_host_alloc(im_port, bfad);
         if (!im_port->shost) {
                 error = 1;
                 goto out_free_idr;
@@ -571,7 +573,7 @@ bfad_im_scsi_host_alloc(struct bfad_s *bfad, struct bfad_im_port_s *im_port,
         }
 
         /* setup host fixed attribute if the lk supports */
-        bfad_os_fc_host_init(im_port);
+        bfad_fc_host_init(im_port);
 
         return 0;
 
@@ -662,7 +664,7 @@ bfad_im_port_clean(struct bfad_im_port_s *im_port)
         }
 
         /* the itnim_mapped_list must be empty at this time */
-        bfa_assert(list_empty(&im_port->itnim_mapped_list));
+        WARN_ON(!list_empty(&im_port->itnim_mapped_list));
 
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 }
@@ -682,7 +684,7 @@ bfad_im_probe(struct bfad_s *bfad)
         bfad->im = im;
         im->bfad = bfad;
 
-        if (bfad_os_thread_workq(bfad) != BFA_STATUS_OK) {
+        if (bfad_thread_workq(bfad) != BFA_STATUS_OK) {
                 kfree(im);
                 rc = BFA_STATUS_FAILED;
         }
@@ -695,14 +697,14 @@ void
 bfad_im_probe_undo(struct bfad_s *bfad)
 {
         if (bfad->im) {
-                bfad_os_destroy_workq(bfad->im);
+                bfad_destroy_workq(bfad->im);
                 kfree(bfad->im);
                 bfad->im = NULL;
         }
 }
 
 struct Scsi_Host *
-bfad_os_scsi_host_alloc(struct bfad_im_port_s *im_port, struct bfad_s *bfad)
+bfad_scsi_host_alloc(struct bfad_im_port_s *im_port, struct bfad_s *bfad)
 {
         struct scsi_host_template *sht;
 
@@ -717,7 +719,7 @@ bfad_os_scsi_host_alloc(struct bfad_im_port_s *im_port, struct bfad_s *bfad)
 }
 
 void
-bfad_os_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port)
+bfad_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port)
 {
         if (!(im_port->flags & BFAD_PORT_DELETE))
                 flush_workqueue(bfad->im->drv_workq);
@@ -727,7 +729,7 @@ bfad_os_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port)
 }
 
 void
-bfad_os_destroy_workq(struct bfad_im_s *im)
+bfad_destroy_workq(struct bfad_im_s *im)
 {
         if (im && im->drv_workq) {
                 flush_workqueue(im->drv_workq);
@@ -737,7 +739,7 @@ bfad_os_destroy_workq(struct bfad_im_s *im)
 }
 
 bfa_status_t
-bfad_os_thread_workq(struct bfad_s *bfad)
+bfad_thread_workq(struct bfad_s *bfad)
 {
         struct bfad_im_s      *im = bfad->im;
 
@@ -841,7 +843,7 @@ bfad_im_module_exit(void)
 }
 
 void
-bfad_os_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
+bfad_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
 {
         struct scsi_device *tmp_sdev;
 
@@ -869,7 +871,7 @@ bfad_os_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
 }
 
 void
-bfad_os_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
+bfad_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
 {
         struct scsi_device *tmp_sdev;
 
@@ -883,7 +885,7 @@ bfad_os_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
 }
 
 struct bfad_itnim_s *
-bfad_os_get_itnim(struct bfad_im_port_s *im_port, int id)
+bfad_get_itnim(struct bfad_im_port_s *im_port, int id)
 {
         struct bfad_itnim_s   *itnim = NULL;
 
@@ -922,7 +924,7 @@ bfad_im_supported_speeds(struct bfa_s *bfa)
         if (!ioc_attr)
                 return 0;
 
-        bfa_get_attr(bfa, ioc_attr);
+        bfa_ioc_get_attr(&bfa->ioc, ioc_attr);
         if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_8GBPS) {
                 if (ioc_attr->adapter_attr.is_mezz) {
                         supported_speed |= FC_PORTSPEED_8GBIT |
@@ -944,7 +946,7 @@ bfad_im_supported_speeds(struct bfa_s *bfa)
 }
 
 void
-bfad_os_fc_host_init(struct bfad_im_port_s *im_port)
+bfad_fc_host_init(struct bfad_im_port_s *im_port)
 {
         struct Scsi_Host *host = im_port->shost;
         struct bfad_s         *bfad = im_port->bfad;
@@ -988,7 +990,7 @@ bfad_im_fc_rport_add(struct bfad_im_port_s *im_port, struct bfad_itnim_s *itnim)
         rport_ids.port_name =
                 cpu_to_be64(bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim));
         rport_ids.port_id =
-                bfa_os_hton3b(bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim));
+                bfa_hton3b(bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim));
         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
 
         itnim->fc_rport = fc_rport =
@@ -1109,7 +1111,7 @@ bfad_im_itnim_work_handler(struct work_struct *work)
                 kfree(itnim);
                 break;
         default:
-                bfa_assert(0);
+                WARN_ON(1);
                 break;
         }
 
@@ -1172,7 +1174,6 @@ bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd
         }
 
         cmnd->host_scribble = (char *)hal_io;
-        bfa_trc_fp(bfad, hal_io->iotag);
         bfa_ioim_start(hal_io);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
@@ -1190,7 +1191,7 @@ out_fail_cmd:
 static DEF_SCSI_QCMD(bfad_im_queuecommand)
 
 void
-bfad_os_rport_online_wait(struct bfad_s *bfad)
+bfad_rport_online_wait(struct bfad_s *bfad)
 {
         int i;
         int rport_delay = 10;
@@ -1218,7 +1219,7 @@ bfad_os_rport_online_wait(struct bfad_s *bfad)
 }
 
 int
-bfad_os_get_linkup_delay(struct bfad_s *bfad)
+bfad_get_linkup_delay(struct bfad_s *bfad)
 {
         u8              nwwns = 0;
         wwn_t           wwns[BFA_PREBOOT_BOOTLUN_MAX];
diff --git a/drivers/scsi/bfa/bfad_im.h b/drivers/scsi/bfa/bfad_im.h
index b038c0e08921..bfee63b16fa9 100644
--- a/drivers/scsi/bfa/bfad_im.h
+++ b/drivers/scsi/bfa/bfad_im.h
@@ -117,17 +117,17 @@ struct bfad_im_s {
         char            drv_workq_name[KOBJ_NAME_LEN];
 };
 
-struct Scsi_Host *bfad_os_scsi_host_alloc(struct bfad_im_port_s *im_port,
+struct Scsi_Host *bfad_scsi_host_alloc(struct bfad_im_port_s *im_port,
                                 struct bfad_s *);
-bfa_status_t bfad_os_thread_workq(struct bfad_s *bfad);
-void bfad_os_destroy_workq(struct bfad_im_s *im);
-void bfad_os_fc_host_init(struct bfad_im_port_s *im_port);
-void bfad_os_scsi_host_free(struct bfad_s *bfad,
+bfa_status_t bfad_thread_workq(struct bfad_s *bfad);
+void bfad_destroy_workq(struct bfad_im_s *im);
+void bfad_fc_host_init(struct bfad_im_port_s *im_port);
+void bfad_scsi_host_free(struct bfad_s *bfad,
                                  struct bfad_im_port_s *im_port);
-void bfad_os_ramp_up_qdepth(struct bfad_itnim_s *itnim,
+void bfad_ramp_up_qdepth(struct bfad_itnim_s *itnim,
                                  struct scsi_device *sdev);
-void bfad_os_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev);
-struct bfad_itnim_s *bfad_os_get_itnim(struct bfad_im_port_s *im_port, int id);
+void bfad_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev);
+struct bfad_itnim_s *bfad_get_itnim(struct bfad_im_port_s *im_port, int id);
 
 extern struct scsi_host_template bfad_im_scsi_host_template;
 extern struct scsi_host_template bfad_im_vport_template;
diff --git a/drivers/scsi/bfa/bfi.h b/drivers/scsi/bfa/bfi.h
index 58796d1284b7..72b69a0c3b51 100644
--- a/drivers/scsi/bfa/bfi.h
+++ b/drivers/scsi/bfa/bfi.h
@@ -95,8 +95,8 @@ enum {
  */
 union bfi_addr_u {
         struct {
-                u32     addr_lo;
-                u32     addr_hi;
+                __be32  addr_lo;
+                __be32  addr_hi;
         } a32;
 };
 
@@ -104,7 +104,7 @@ union bfi_addr_u {
  * Scatter Gather Element
  */
 struct bfi_sge_s {
-#ifdef __BIGENDIAN
+#ifdef __BIG_ENDIAN
         u32     flags:2,
                         rsvd:2,
                         sg_len:28;
@@ -399,7 +399,7 @@ union bfi_ioc_i2h_msg_u {
  */
 struct bfi_pbc_blun_s {
         wwn_t           tgt_pwwn;
-        lun_t           tgt_lun;
+        struct scsi_lun tgt_lun;
 };
 
 /*
diff --git a/drivers/scsi/bfa/bfi_cbreg.h b/drivers/scsi/bfa/bfi_cbreg.h
index 6f03ed382c69..39ad42b66b5b 100644
--- a/drivers/scsi/bfa/bfi_cbreg.h
+++ b/drivers/scsi/bfa/bfi_cbreg.h
@@ -208,6 +208,7 @@
 #define BFA_IOC1_HBEAT_REG               HOST_SEM2_INFO_REG
 #define BFA_IOC1_STATE_REG               HOST_SEM3_INFO_REG
 #define BFA_FW_USE_COUNT                 HOST_SEM4_INFO_REG
+#define BFA_IOC_FAIL_SYNC                HOST_SEM5_INFO_REG
 
 #define CPE_Q_DEPTH(__n) \
         (CPE_Q0_DEPTH + (__n) * (CPE_Q1_DEPTH - CPE_Q0_DEPTH))
diff --git a/drivers/scsi/bfa/bfi_ctreg.h b/drivers/scsi/bfa/bfi_ctreg.h
index 62b86a4b0e4b..fc4ce4a5a183 100644
--- a/drivers/scsi/bfa/bfi_ctreg.h
+++ b/drivers/scsi/bfa/bfi_ctreg.h
@@ -522,6 +522,7 @@ enum {
 #define BFA_IOC1_HBEAT_REG              HOST_SEM2_INFO_REG
 #define BFA_IOC1_STATE_REG              HOST_SEM3_INFO_REG
 #define BFA_FW_USE_COUNT                 HOST_SEM4_INFO_REG
+#define BFA_IOC_FAIL_SYNC               HOST_SEM5_INFO_REG
 
 #define CPE_DEPTH_Q(__n) \
         (CPE_DEPTH_Q0 + (__n) * (CPE_DEPTH_Q1 - CPE_DEPTH_Q0))
@@ -539,22 +540,30 @@ enum {
         (RME_PI_PTR_Q0 + (__n) * (RME_PI_PTR_Q1 - RME_PI_PTR_Q0))
 #define RME_CI_PTR_Q(__n) \
         (RME_CI_PTR_Q0 + (__n) * (RME_CI_PTR_Q1 - RME_CI_PTR_Q0))
-#define HQM_QSET_RXQ_DRBL_P0(__n) (HQM_QSET0_RXQ_DRBL_P0 + (__n) \
-        * (HQM_QSET1_RXQ_DRBL_P0 - HQM_QSET0_RXQ_DRBL_P0))
-#define HQM_QSET_TXQ_DRBL_P0(__n) (HQM_QSET0_TXQ_DRBL_P0 + (__n) \
-        * (HQM_QSET1_TXQ_DRBL_P0 - HQM_QSET0_TXQ_DRBL_P0))
-#define HQM_QSET_IB_DRBL_1_P0(__n) (HQM_QSET0_IB_DRBL_1_P0 + (__n) \
-        * (HQM_QSET1_IB_DRBL_1_P0 - HQM_QSET0_IB_DRBL_1_P0))
-#define HQM_QSET_IB_DRBL_2_P0(__n) (HQM_QSET0_IB_DRBL_2_P0 + (__n) \
-        * (HQM_QSET1_IB_DRBL_2_P0 - HQM_QSET0_IB_DRBL_2_P0))
-#define HQM_QSET_RXQ_DRBL_P1(__n) (HQM_QSET0_RXQ_DRBL_P1 + (__n) \
-        * (HQM_QSET1_RXQ_DRBL_P1 - HQM_QSET0_RXQ_DRBL_P1))
-#define HQM_QSET_TXQ_DRBL_P1(__n) (HQM_QSET0_TXQ_DRBL_P1 + (__n) \
-        * (HQM_QSET1_TXQ_DRBL_P1 - HQM_QSET0_TXQ_DRBL_P1))
-#define HQM_QSET_IB_DRBL_1_P1(__n) (HQM_QSET0_IB_DRBL_1_P1 + (__n) \
-        * (HQM_QSET1_IB_DRBL_1_P1 - HQM_QSET0_IB_DRBL_1_P1))
-#define HQM_QSET_IB_DRBL_2_P1(__n) (HQM_QSET0_IB_DRBL_2_P1 + (__n) \
-        * (HQM_QSET1_IB_DRBL_2_P1 - HQM_QSET0_IB_DRBL_2_P1))
+#define HQM_QSET_RXQ_DRBL_P0(__n) \
+        (HQM_QSET0_RXQ_DRBL_P0 + (__n) *        \
+        (HQM_QSET1_RXQ_DRBL_P0 - HQM_QSET0_RXQ_DRBL_P0))
+#define HQM_QSET_TXQ_DRBL_P0(__n) \
+        (HQM_QSET0_TXQ_DRBL_P0 + (__n) *        \
+        (HQM_QSET1_TXQ_DRBL_P0 - HQM_QSET0_TXQ_DRBL_P0))
+#define HQM_QSET_IB_DRBL_1_P0(__n) \
+        (HQM_QSET0_IB_DRBL_1_P0 + (__n) *       \
+        (HQM_QSET1_IB_DRBL_1_P0 - HQM_QSET0_IB_DRBL_1_P0))
+#define HQM_QSET_IB_DRBL_2_P0(__n) \
+        (HQM_QSET0_IB_DRBL_2_P0 + (__n) *       \
+        (HQM_QSET1_IB_DRBL_2_P0 - HQM_QSET0_IB_DRBL_2_P0))
+#define HQM_QSET_RXQ_DRBL_P1(__n) \
+        (HQM_QSET0_RXQ_DRBL_P1 + (__n) *        \
+        (HQM_QSET1_RXQ_DRBL_P1 - HQM_QSET0_RXQ_DRBL_P1))
+#define HQM_QSET_TXQ_DRBL_P1(__n) \
+        (HQM_QSET0_TXQ_DRBL_P1 + (__n) *        \
+        (HQM_QSET1_TXQ_DRBL_P1 - HQM_QSET0_TXQ_DRBL_P1))
+#define HQM_QSET_IB_DRBL_1_P1(__n) \
+        (HQM_QSET0_IB_DRBL_1_P1 + (__n) *       \
+        (HQM_QSET1_IB_DRBL_1_P1 - HQM_QSET0_IB_DRBL_1_P1))
+#define HQM_QSET_IB_DRBL_2_P1(__n) \
+        (HQM_QSET0_IB_DRBL_2_P1 + (__n) *       \
+        (HQM_QSET1_IB_DRBL_2_P1 - HQM_QSET0_IB_DRBL_2_P1))
 
 #define CPE_Q_NUM(__fn, __q) (((__fn) << 2) + (__q))
 #define RME_Q_NUM(__fn, __q) (((__fn) << 2) + (__q))
diff --git a/drivers/scsi/bfa/bfi_ms.h b/drivers/scsi/bfa/bfi_ms.h
index fa9f6fb9d45b..19e888a57555 100644
--- a/drivers/scsi/bfa/bfi_ms.h
+++ b/drivers/scsi/bfa/bfi_ms.h
@@ -47,10 +47,10 @@ struct bfi_iocfc_cfg_s {
          */
         union bfi_addr_u  req_cq_ba[BFI_IOC_MAX_CQS];
         union bfi_addr_u  req_shadow_ci[BFI_IOC_MAX_CQS];
-        u16    req_cq_elems[BFI_IOC_MAX_CQS];
+        __be16    req_cq_elems[BFI_IOC_MAX_CQS];
         union bfi_addr_u  rsp_cq_ba[BFI_IOC_MAX_CQS];
         union bfi_addr_u  rsp_shadow_pi[BFI_IOC_MAX_CQS];
-        u16    rsp_cq_elems[BFI_IOC_MAX_CQS];
+        __be16    rsp_cq_elems[BFI_IOC_MAX_CQS];
 
         union bfi_addr_u  stats_addr;   /*  DMA-able address for stats    */
         union bfi_addr_u  cfgrsp_addr;  /*  config response dma address  */
@@ -102,8 +102,8 @@ struct bfi_iocfc_set_intr_req_s {
         struct bfi_mhdr_s mh;           /*  common msg header           */
         u8              coalesce;       /*  enable intr coalescing      */
         u8              rsvd[3];
-        u16     delay;          /*  delay timer 0..1125us       */
-        u16     latency;        /*  latency timer 0..225us      */
+        __be16  delay;          /*  delay timer 0..1125us       */
+        __be16  latency;        /*  latency timer 0..225us      */
 };
 
 
@@ -188,7 +188,8 @@ struct bfi_fcport_rsp_s {
         struct bfi_mhdr_s  mh;          /*  common msg header               */
         u8                 status;      /*  port enable status              */
         u8                 rsvd[3];
-        u32        msgtag;      /*  msgtag for reply                */
+        struct  bfa_port_cfg_s port_cfg;/* port configuration   */
+        u32     msgtag;                 /* msgtag for reply     */
 };
 
 /*
@@ -202,7 +203,8 @@ struct bfi_fcport_enable_req_s {
         struct bfa_port_cfg_s port_cfg; /*  port configuration      */
         union bfi_addr_u   stats_dma_addr; /*  DMA address for stats        */
         u32        msgtag;      /*  msgtag for reply                */
-        u32        rsvd2;
+        u8      use_flash_cfg;  /* get prot cfg from flash */
+        u8      rsvd2[3];
 };
 
 /*
@@ -210,7 +212,7 @@ struct bfi_fcport_enable_req_s {
  */
 struct bfi_fcport_set_svc_params_req_s {
         struct bfi_mhdr_s  mh;          /*  msg header */
-        u16        tx_bbcredit; /*  Tx credits */
+        __be16     tx_bbcredit; /*  Tx credits */
         u16        rsvd;
 };
 
@@ -231,7 +233,7 @@ struct bfi_fcport_trunk_link_s {
         u8                      state;          /* bfa_trunk_link_state_t */
         u8                      speed;          /* bfa_port_speed_t */
         u8                      rsvd;
-        u32             deskew;
+        __be32          deskew;
 };
 
 #define BFI_FCPORT_MAX_LINKS    2
@@ -284,17 +286,17 @@ enum bfi_fcxp_i2h {
  */
 struct bfi_fcxp_send_req_s {
         struct bfi_mhdr_s  mh;          /*  Common msg header               */
-        u16     fcxp_tag;       /*  driver request tag              */
-        u16     max_frmsz;      /*  max send frame size     */
-        u16     vf_id;          /*  vsan tag if applicable          */
+        __be16  fcxp_tag;       /*  driver request tag              */
+        __be16  max_frmsz;      /*  max send frame size     */
+        __be16  vf_id;          /*  vsan tag if applicable          */
         u16     rport_fw_hndl;  /*  FW Handle for the remote port  */
         u8       class;         /*  FC class used for req/rsp       */
         u8       rsp_timeout;   /*  timeout in secs, 0-no response */
         u8       cts;           /*  continue sequence               */
         u8       lp_tag;        /*  lport tag                       */
         struct fchs_s   fchs;   /*  request FC header structure    */
-        u32     req_len;        /*  request payload length          */
-        u32     rsp_maxlen;     /*  max response length expected   */
+        __be32  req_len;        /*  request payload length          */
+        __be32  rsp_maxlen;     /*  max response length expected   */
         struct bfi_sge_s   req_sge[BFA_FCXP_MAX_SGES];  /*  request buf    */
         struct bfi_sge_s   rsp_sge[BFA_FCXP_MAX_SGES];  /*  response buf   */
 };
@@ -304,11 +306,11 @@ struct bfi_fcxp_send_req_s {
  */
 struct bfi_fcxp_send_rsp_s {
         struct bfi_mhdr_s  mh;          /*  Common msg header               */
-        u16     fcxp_tag;       /*  send request tag                */
+        __be16  fcxp_tag;       /*  send request tag                */
         u8       req_status;    /*  request status                  */
         u8       rsvd;
-        u32     rsp_len;        /*  actual response length          */
-        u32     residue_len;    /*  residual response length        */
+        __be32  rsp_len;        /*  actual response length          */
+        __be32  residue_len;    /*  residual response length        */
         struct fchs_s   fchs;   /*  response FC header structure   */
 };
 
@@ -325,7 +327,7 @@ enum bfi_uf_i2h {
 struct bfi_uf_buf_post_s {
         struct bfi_mhdr_s  mh;          /*  Common msg header           */
         u16     buf_tag;        /*  buffer tag                  */
-        u16     buf_len;        /*  total buffer length */
+        __be16  buf_len;        /*  total buffer length */
         struct bfi_sge_s   sge[BFA_UF_MAX_SGES]; /*  buffer DMA SGEs    */
 };
 
@@ -340,6 +342,7 @@ struct bfi_uf_frm_rcvd_s {
 enum bfi_lps_h2i_msgs {
         BFI_LPS_H2I_LOGIN_REQ   = 1,
         BFI_LPS_H2I_LOGOUT_REQ  = 2,
+        BFI_LPS_H2I_N2N_PID_REQ = 3,
 };
 
 enum bfi_lps_i2h_msgs {
@@ -352,7 +355,7 @@ struct bfi_lps_login_req_s {
         struct bfi_mhdr_s  mh;          /*  common msg header           */
         u8              lp_tag;
         u8              alpa;
-        u16     pdu_size;
+        __be16          pdu_size;
         wwn_t           pwwn;
         wwn_t           nwwn;
         u8              fdisc;
@@ -368,7 +371,7 @@ struct bfi_lps_login_rsp_s {
         u8              lsrjt_expl;
         wwn_t           port_name;
         wwn_t           node_name;
-        u16     bb_credit;
+        __be16          bb_credit;
         u8              f_port;
         u8              npiv_en;
         u32     lp_pid:24;
@@ -399,10 +402,17 @@ struct bfi_lps_cvl_event_s {
         u8              rsvd[3];
 };
 
+struct bfi_lps_n2n_pid_req_s {
+        struct bfi_mhdr_s       mh;     /*  common msg header           */
+        u8      lp_tag;
+        u32     lp_pid:24;
+};
+
 union bfi_lps_h2i_msg_u {
         struct bfi_mhdr_s               *msg;
         struct bfi_lps_login_req_s      *login_req;
         struct bfi_lps_logout_req_s     *logout_req;
+        struct bfi_lps_n2n_pid_req_s    *n2n_pid_req;
 };
 
 union bfi_lps_i2h_msg_u {
@@ -427,7 +437,7 @@ enum bfi_rport_i2h_msgs {
 struct bfi_rport_create_req_s {
         struct bfi_mhdr_s  mh;          /*  common msg header           */
         u16     bfa_handle;     /*  host rport handle           */
-        u16     max_frmsz;      /*  max rcv pdu size            */
+        __be16  max_frmsz;      /*  max rcv pdu size            */
         u32     pid:24, /*  remote port ID              */
                 lp_tag:8;       /*  local port tag              */
         u32     local_pid:24,   /*  local port ID               */
@@ -583,7 +593,7 @@ struct bfi_ioim_dif_s {
  */
 struct bfi_ioim_req_s {
         struct bfi_mhdr_s  mh;          /*  Common msg header            */
-        u16     io_tag;         /*  I/O tag                      */
+        __be16  io_tag;         /*  I/O tag                      */
         u16     rport_hdl;      /*  itnim/rport firmware handle */
         struct fcp_cmnd_s       cmnd;   /*  IO request info     */
 
@@ -689,7 +699,7 @@ enum bfi_ioim_status {
  */
 struct bfi_ioim_rsp_s {
         struct bfi_mhdr_s       mh;     /*  common msg header           */
-        u16     io_tag;         /*  completed IO tag             */
+        __be16  io_tag;         /*  completed IO tag             */
         u16     bfa_rport_hndl; /*  releated rport handle        */
         u8      io_status;      /*  IO completion status         */
         u8      reuse_io_tag;   /*  IO tag can be reused        */
@@ -698,13 +708,13 @@ struct bfi_ioim_rsp_s {
         u8              sns_len;        /*  scsi sense length            */
         u8              resid_flags;    /*  IO residue flags             */
         u8              rsvd_a;
-        u32     residue;        /*  IO residual length in bytes */
+        __be32  residue;        /*  IO residual length in bytes */
         u32     rsvd_b[3];
 };
 
 struct bfi_ioim_abort_req_s {
         struct bfi_mhdr_s  mh;  /*  Common msg header  */
-        u16     io_tag; /*  I/O tag     */
+        __be16  io_tag; /*  I/O tag     */
         u16     abort_tag;      /*  unique request tag */
 };
 
@@ -723,9 +733,9 @@ enum bfi_tskim_i2h {
 
 struct bfi_tskim_req_s {
         struct bfi_mhdr_s  mh;  /*  Common msg header   */
-        u16     tsk_tag;        /*  task management tag */
+        __be16  tsk_tag;        /*  task management tag */
         u16     itn_fhdl;       /*  itn firmware handle */
-        lun_t   lun;    /*  LU number   */
+        struct  scsi_lun lun;   /*  LU number   */
         u8      tm_flags;       /*  see enum fcp_tm_cmnd        */
         u8      t_secs; /*  Timeout value in seconds    */
         u8      rsvd[2];
@@ -733,7 +743,7 @@ struct bfi_tskim_req_s {
 
 struct bfi_tskim_abortreq_s {
         struct bfi_mhdr_s  mh;  /*  Common msg header   */
-        u16     tsk_tag;        /*  task management tag */
+        __be16  tsk_tag;        /*  task management tag */
         u16     rsvd;
 };
 
@@ -755,7 +765,7 @@ enum bfi_tskim_status {
 
 struct bfi_tskim_rsp_s {
         struct bfi_mhdr_s  mh;          /*  Common msg header            */
-        u16     tsk_tag;        /*  task mgmt cmnd tag           */
+        __be16  tsk_tag;        /*  task mgmt cmnd tag           */
         u8      tsk_status;     /*  @ref bfi_tskim_status */
         u8      rsvd;
 };
diff --git a/drivers/scsi/bnx2i/57xx_iscsi_constants.h b/drivers/scsi/bnx2i/57xx_iscsi_constants.h
index 1b6f86b2482d..30e6bdbd65af 100644
--- a/drivers/scsi/bnx2i/57xx_iscsi_constants.h
+++ b/drivers/scsi/bnx2i/57xx_iscsi_constants.h
@@ -1,12 +1,13 @@
 /* 57xx_iscsi_constants.h: Broadcom NetXtreme II iSCSI HSI
  *
- * Copyright (c) 2006 - 2009 Broadcom Corporation
+ * Copyright (c) 2006 - 2010 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 #ifndef __57XX_ISCSI_CONSTANTS_H_
 #define __57XX_ISCSI_CONSTANTS_H_
diff --git a/drivers/scsi/bnx2i/57xx_iscsi_hsi.h b/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
index 36af1afef9b6..dad6c8a34317 100644
--- a/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
+++ b/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
@@ -1,12 +1,13 @@
 /* 57xx_iscsi_hsi.h: Broadcom NetXtreme II iSCSI HSI.
  *
- * Copyright (c) 2006 - 2009 Broadcom Corporation
+ * Copyright (c) 2006 - 2010 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 #ifndef __57XX_ISCSI_HSI_LINUX_LE__
 #define __57XX_ISCSI_HSI_LINUX_LE__
diff --git a/drivers/scsi/bnx2i/bnx2i.h b/drivers/scsi/bnx2i/bnx2i.h
index a44b1b33fa18..e1ca5fe7e6bb 100644
--- a/drivers/scsi/bnx2i/bnx2i.h
+++ b/drivers/scsi/bnx2i/bnx2i.h
@@ -1,6 +1,6 @@
 /* bnx2i.h: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2009 Broadcom Corporation
+ * Copyright (c) 2006 - 2010 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
@@ -9,6 +9,7 @@
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 
 #ifndef _BNX2I_H_
@@ -649,6 +650,7 @@ enum {
         EP_STATE_OFLD_FAILED            = 0x8000000,
         EP_STATE_CONNECT_FAILED         = 0x10000000,
         EP_STATE_DISCONN_TIMEDOUT       = 0x20000000,
+        EP_STATE_OFLD_FAILED_CID_BUSY   = 0x80000000,
 };
 
 /**
@@ -717,14 +719,11 @@ extern struct device_attribute *bnx2i_dev_attributes[];
  * Function Prototypes
  */
 extern void bnx2i_identify_device(struct bnx2i_hba *hba);
-extern void bnx2i_register_device(struct bnx2i_hba *hba);
 
 extern void bnx2i_ulp_init(struct cnic_dev *dev);
 extern void bnx2i_ulp_exit(struct cnic_dev *dev);
 extern void bnx2i_start(void *handle);
 extern void bnx2i_stop(void *handle);
-extern void bnx2i_reg_dev_all(void);
-extern void bnx2i_unreg_dev_all(void);
 extern struct bnx2i_hba *get_adapter_list_head(void);
 
 struct bnx2i_conn *bnx2i_get_conn_from_id(struct bnx2i_hba *hba,
@@ -761,11 +760,11 @@ extern int bnx2i_send_iscsi_logout(struct bnx2i_conn *conn,
                                    struct iscsi_task *mtask);
 extern void bnx2i_send_cmd_cleanup_req(struct bnx2i_hba *hba,
                                        struct bnx2i_cmd *cmd);
-extern void bnx2i_send_conn_ofld_req(struct bnx2i_hba *hba,
-                                     struct bnx2i_endpoint *ep);
-extern void bnx2i_update_iscsi_conn(struct iscsi_conn *conn);
-extern void bnx2i_send_conn_destroy(struct bnx2i_hba *hba,
+extern int bnx2i_send_conn_ofld_req(struct bnx2i_hba *hba,
                                     struct bnx2i_endpoint *ep);
+extern void bnx2i_update_iscsi_conn(struct iscsi_conn *conn);
+extern int bnx2i_send_conn_destroy(struct bnx2i_hba *hba,
+                                   struct bnx2i_endpoint *ep);
 
 extern int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba,
                                struct bnx2i_endpoint *ep);
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index 2f9622ebbd84..96505e3ab986 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -1,6 +1,6 @@
 /* bnx2i_hwi.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2009 Broadcom Corporation
+ * Copyright (c) 2006 - 2010 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
@@ -9,6 +9,7 @@
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 
 #include <linux/gfp.h>
@@ -385,6 +386,7 @@ int bnx2i_send_iscsi_tmf(struct bnx2i_conn *bnx2i_conn,
         struct bnx2i_cmd *bnx2i_cmd;
         struct bnx2i_tmf_request *tmfabort_wqe;
         u32 dword;
+        u32 scsi_lun[2];
 
         bnx2i_cmd = (struct bnx2i_cmd *)mtask->dd_data;
         tmfabort_hdr = (struct iscsi_tm *)mtask->hdr;
@@ -426,7 +428,10 @@ int bnx2i_send_iscsi_tmf(struct bnx2i_conn *bnx2i_conn,
         default:
                 tmfabort_wqe->ref_itt = RESERVED_ITT;
         }
-        memcpy(tmfabort_wqe->lun, tmfabort_hdr->lun, sizeof(struct scsi_lun));
+        memcpy(scsi_lun, tmfabort_hdr->lun, sizeof(struct scsi_lun));
+        tmfabort_wqe->lun[0] = be32_to_cpu(scsi_lun[0]);
+        tmfabort_wqe->lun[1] = be32_to_cpu(scsi_lun[1]);
+
         tmfabort_wqe->ref_cmd_sn = be32_to_cpu(tmfabort_hdr->refcmdsn);
 
         tmfabort_wqe->bd_list_addr_lo = (u32) bnx2i_conn->hba->mp_bd_dma;
@@ -697,10 +702,11 @@ void bnx2i_send_cmd_cleanup_req(struct bnx2i_hba *hba, struct bnx2i_cmd *cmd)
  * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE to initiate
  *      iscsi connection context clean-up process
  */
-void bnx2i_send_conn_destroy(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
+int bnx2i_send_conn_destroy(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 {
         struct kwqe *kwqe_arr[2];
         struct iscsi_kwqe_conn_destroy conn_cleanup;
+        int rc = -EINVAL;
 
         memset(&conn_cleanup, 0x00, sizeof(struct iscsi_kwqe_conn_destroy));
 
@@ -717,7 +723,9 @@ void bnx2i_send_conn_destroy(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 
         kwqe_arr[0] = (struct kwqe *) &conn_cleanup;
         if (hba->cnic && hba->cnic->submit_kwqes)
-                hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, 1);
+                rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, 1);
+
+        return rc;
 }
 
 
@@ -728,8 +736,8 @@ void bnx2i_send_conn_destroy(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
  *
  * 5706/5708/5709 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
  */
-static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba,
-                                          struct bnx2i_endpoint *ep)
+static int bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba,
+                                         struct bnx2i_endpoint *ep)
 {
         struct kwqe *kwqe_arr[2];
         struct iscsi_kwqe_conn_offload1 ofld_req1;
@@ -737,6 +745,7 @@ static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba,
         dma_addr_t dma_addr;
         int num_kwqes = 2;
         u32 *ptbl;
+        int rc = -EINVAL;
 
         ofld_req1.hdr.op_code = ISCSI_KWQE_OPCODE_OFFLOAD_CONN1;
         ofld_req1.hdr.flags =
@@ -774,7 +783,9 @@ static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba,
         ofld_req2.num_additional_wqes = 0;
 
         if (hba->cnic && hba->cnic->submit_kwqes)
-                hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes);
+                rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes);
+
+        return rc;
 }
 
 
@@ -785,8 +796,8 @@ static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba,
  *
  * 57710 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
  */
-static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba,
-                                           struct bnx2i_endpoint *ep)
+static int bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba,
+                                          struct bnx2i_endpoint *ep)
 {
         struct kwqe *kwqe_arr[5];
         struct iscsi_kwqe_conn_offload1 ofld_req1;
@@ -795,6 +806,7 @@ static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba,
         dma_addr_t dma_addr;
         int num_kwqes = 2;
         u32 *ptbl;
+        int rc = -EINVAL;
 
         ofld_req1.hdr.op_code = ISCSI_KWQE_OPCODE_OFFLOAD_CONN1;
         ofld_req1.hdr.flags =
@@ -840,7 +852,9 @@ static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba,
         num_kwqes += 1;
 
         if (hba->cnic && hba->cnic->submit_kwqes)
-                hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes);
+                rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes);
+
+        return rc;
 }
 
 /**
@@ -851,12 +865,16 @@ static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba,
  *
  * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE
  */
-void bnx2i_send_conn_ofld_req(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
+int bnx2i_send_conn_ofld_req(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 {
+        int rc;
+
         if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type))
-                bnx2i_5771x_send_conn_ofld_req(hba, ep);
+                rc = bnx2i_5771x_send_conn_ofld_req(hba, ep);
         else
-                bnx2i_570x_send_conn_ofld_req(hba, ep);
+                rc = bnx2i_570x_send_conn_ofld_req(hba, ep);
+
+        return rc;
 }
 
 
@@ -1513,7 +1531,7 @@ static void bnx2i_process_nopin_local_cmpl(struct iscsi_session *session,
         task = iscsi_itt_to_task(conn,
                                  nop_in->itt & ISCSI_NOP_IN_MSG_INDEX);
         if (task)
-                iscsi_put_task(task);
+                __iscsi_put_task(task);
         spin_unlock(&session->lock);
 }
 
@@ -1549,11 +1567,9 @@ static int bnx2i_process_nopin_mesg(struct iscsi_session *session,
         struct iscsi_task *task;
         struct bnx2i_nop_in_msg *nop_in;
         struct iscsi_nopin *hdr;
-        u32 itt;
         int tgt_async_nop = 0;
 
         nop_in = (struct bnx2i_nop_in_msg *)cqe;
-        itt = nop_in->itt & ISCSI_NOP_IN_MSG_INDEX;
 
         spin_lock(&session->lock);
         hdr = (struct iscsi_nopin *)&bnx2i_conn->gen_pdu.resp_hdr;
@@ -1563,7 +1579,7 @@ static int bnx2i_process_nopin_mesg(struct iscsi_session *session,
         hdr->exp_cmdsn = cpu_to_be32(nop_in->exp_cmd_sn);
         hdr->ttt = cpu_to_be32(nop_in->ttt);
 
-        if (itt == (u16) RESERVED_ITT) {
+        if (nop_in->itt == (u16) RESERVED_ITT) {
                 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
                 hdr->itt = RESERVED_ITT;
                 tgt_async_nop = 1;
@@ -1571,7 +1587,8 @@ static int bnx2i_process_nopin_mesg(struct iscsi_session *session,
         }
 
         /* this is a response to one of our nop-outs */
-        task = iscsi_itt_to_task(conn, itt);
+        task = iscsi_itt_to_task(conn,
+                         (itt_t) (nop_in->itt & ISCSI_NOP_IN_MSG_INDEX));
         if (task) {
                 hdr->flags = ISCSI_FLAG_CMD_FINAL;
                 hdr->itt = task->hdr->itt;
@@ -1721,9 +1738,18 @@ static void bnx2i_process_new_cqes(struct bnx2i_conn *bnx2i_conn)
                 if (nopin->cq_req_sn != qp->cqe_exp_seq_sn)
                         break;
 
-                if (unlikely(test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx)))
+                if (unlikely(test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx))) {
+                        if (nopin->op_code == ISCSI_OP_NOOP_IN &&
+                            nopin->itt == (u16) RESERVED_ITT) {
+                                printk(KERN_ALERT "bnx2i: Unsolicited "
+                                        "NOP-In detected for suspended "
+                                        "connection dev=%s!\n",
+                                        bnx2i_conn->hba->netdev->name);
+                                bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
+                                goto cqe_out;
+                        }
                         break;
-
+                }
                 tgt_async_msg = 0;
 
                 switch (nopin->op_code) {
@@ -1770,10 +1796,9 @@ static void bnx2i_process_new_cqes(struct bnx2i_conn *bnx2i_conn)
                         printk(KERN_ALERT "bnx2i: unknown opcode 0x%x\n",
                                           nopin->op_code);
                 }
-
                 if (!tgt_async_msg)
                         bnx2i_conn->ep->num_active_cmds--;
-
+cqe_out:
                 /* clear out in production version only, till beta keep opcode
                  * field intact, will be helpful in debugging (context dump)
                  * nopin->op_code = 0;
@@ -2154,11 +2179,24 @@ static void bnx2i_process_ofld_cmpl(struct bnx2i_hba *hba,
         }
 
         if (ofld_kcqe->completion_status) {
+                ep->state = EP_STATE_OFLD_FAILED;
                 if (ofld_kcqe->completion_status ==
                     ISCSI_KCQE_COMPLETION_STATUS_CTX_ALLOC_FAILURE)
-                        printk(KERN_ALERT "bnx2i: unable to allocate"
-                                          " iSCSI context resources\n");
-                ep->state = EP_STATE_OFLD_FAILED;
+                        printk(KERN_ALERT "bnx2i (%s): ofld1 cmpl - unable "
+                                "to allocate iSCSI context resources\n",
+                                hba->netdev->name);
+                else if (ofld_kcqe->completion_status ==
+                         ISCSI_KCQE_COMPLETION_STATUS_INVALID_OPCODE)
+                        printk(KERN_ALERT "bnx2i (%s): ofld1 cmpl - invalid "
+                                "opcode\n", hba->netdev->name);
+                else if (ofld_kcqe->completion_status ==
+                        ISCSI_KCQE_COMPLETION_STATUS_CID_BUSY)
+                        /* error status code valid only for 5771x chipset */
+                        ep->state = EP_STATE_OFLD_FAILED_CID_BUSY;
+                else
+                        printk(KERN_ALERT "bnx2i (%s): ofld1 cmpl - invalid "
+                                "error code %d\n", hba->netdev->name,
+                                ofld_kcqe->completion_status);
         } else {
                 ep->state = EP_STATE_OFLD_COMPL;
                 cid_addr = ofld_kcqe->iscsi_conn_context_id;
@@ -2339,10 +2377,14 @@ static void bnx2i_cm_remote_close(struct cnic_sock *cm_sk)
 static void bnx2i_cm_remote_abort(struct cnic_sock *cm_sk)
 {
         struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context;
+        u32 old_state = ep->state;
 
         ep->state = EP_STATE_TCP_RST_RCVD;
-        if (ep->conn)
-                bnx2i_recovery_que_add_conn(ep->hba, ep->conn);
+        if (old_state == EP_STATE_DISCONN_START)
+                wake_up_interruptible(&ep->ofld_wait);
+        else
+                if (ep->conn)
+                        bnx2i_recovery_que_add_conn(ep->hba, ep->conn);
 }
 
 
diff --git a/drivers/scsi/bnx2i/bnx2i_init.c b/drivers/scsi/bnx2i/bnx2i_init.c
index 50c2aa3b8eb1..72a7b2d4a439 100644
--- a/drivers/scsi/bnx2i/bnx2i_init.c
+++ b/drivers/scsi/bnx2i/bnx2i_init.c
@@ -1,6 +1,6 @@
 /* bnx2i.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2009 Broadcom Corporation
+ * Copyright (c) 2006 - 2010 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
@@ -9,6 +9,7 @@
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 
 #include "bnx2i.h"
@@ -17,8 +18,8 @@ static struct list_head adapter_list = LIST_HEAD_INIT(adapter_list);
 static u32 adapter_count;
 
 #define DRV_MODULE_NAME         "bnx2i"
-#define DRV_MODULE_VERSION      "2.1.3"
-#define DRV_MODULE_RELDATE      "Aug 10, 2010"
+#define DRV_MODULE_VERSION      "2.6.2.2"
+#define DRV_MODULE_RELDATE      "Nov 23, 2010"
 
 static char version[] __devinitdata =
                 "Broadcom NetXtreme II iSCSI Driver " DRV_MODULE_NAME \
@@ -65,8 +66,6 @@ MODULE_PARM_DESC(rq_size, "Configure RQ size");
 
 u64 iscsi_error_mask = 0x00;
 
-static void bnx2i_unreg_one_device(struct bnx2i_hba *hba) ;
-
 
 /**
  * bnx2i_identify_device - identifies NetXtreme II device type
@@ -211,13 +210,24 @@ void bnx2i_stop(void *handle)
 {
         struct bnx2i_hba *hba = handle;
         int conns_active;
+        int wait_delay = 1 * HZ;
 
         /* check if cleanup happened in GOING_DOWN context */
-        if (!test_and_clear_bit(ADAPTER_STATE_GOING_DOWN,
-                                &hba->adapter_state))
+        if (!test_and_set_bit(ADAPTER_STATE_GOING_DOWN,
+                              &hba->adapter_state)) {
                 iscsi_host_for_each_session(hba->shost,
                                             bnx2i_drop_session);
-
+                wait_delay = hba->hba_shutdown_tmo;
+        }
+        /* Wait for inflight offload connection tasks to complete before
+         * proceeding. Forcefully terminate all connection recovery in
+         * progress at the earliest, either in bind(), send_pdu(LOGIN),
+         * or conn_start()
+         */
+        wait_event_interruptible_timeout(hba->eh_wait,
+                                         (list_empty(&hba->ep_ofld_list) &&
+                                         list_empty(&hba->ep_destroy_list)),
+                                         10 * HZ);
         /* Wait for all endpoints to be torn down, Chip will be reset once
          *  control returns to network driver. So it is required to cleanup and
          * release all connection resources before returning from this routine.
@@ -226,7 +236,7 @@ void bnx2i_stop(void *handle)
                 conns_active = hba->ofld_conns_active;
                 wait_event_interruptible_timeout(hba->eh_wait,
                                 (hba->ofld_conns_active != conns_active),
-                                hba->hba_shutdown_tmo);
+                                wait_delay);
                 if (hba->ofld_conns_active == conns_active)
                         break;
         }
@@ -235,88 +245,10 @@ void bnx2i_stop(void *handle)
         /* This flag should be cleared last so that ep_disconnect() gracefully
          * cleans up connection context
          */
+        clear_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state);
         clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
 }
 
-/**
- * bnx2i_register_device - register bnx2i adapter instance with the cnic driver
- * @hba:        Adapter instance to register
- *
- * registers bnx2i adapter instance with the cnic driver while holding the
- *      adapter structure lock
- */
-void bnx2i_register_device(struct bnx2i_hba *hba)
-{
-        int rc;
-
-        if (test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state) ||
-            test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) {
-                return;
-        }
-
-        rc = hba->cnic->register_device(hba->cnic, CNIC_ULP_ISCSI, hba);
-
-        if (!rc)
-                set_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
-}
-
-
-/**
- * bnx2i_reg_dev_all - registers all adapter instances with the cnic driver
- *
- * registers all bnx2i adapter instances with the cnic driver while holding
- *      the global resource lock
- */
-void bnx2i_reg_dev_all(void)
-{
-        struct bnx2i_hba *hba, *temp;
-
-        mutex_lock(&bnx2i_dev_lock);
-        list_for_each_entry_safe(hba, temp, &adapter_list, link)
-                bnx2i_register_device(hba);
-        mutex_unlock(&bnx2i_dev_lock);
-}
-
-
-/**
- * bnx2i_unreg_one_device - unregister adapter instance with the cnic driver
- * @hba:        Adapter instance to unregister
- *
- * registers bnx2i adapter instance with the cnic driver while holding
- *      the adapter structure lock
- */
-static void bnx2i_unreg_one_device(struct bnx2i_hba *hba)
-{
-        if (hba->ofld_conns_active ||
-            !test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic) ||
-            test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state))
-                return;
-
-        hba->cnic->unregister_device(hba->cnic, CNIC_ULP_ISCSI);
-
-        /* ep_disconnect could come before NETDEV_DOWN, driver won't
-         * see NETDEV_DOWN as it already unregistered itself.
-         */
-        hba->adapter_state = 0;
-        clear_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic);
-}
-
-/**
- * bnx2i_unreg_dev_all - unregisters all bnx2i instances with the cnic driver
- *
- * unregisters all bnx2i adapter instances with the cnic driver while holding
- *      the global resource lock
- */
-void bnx2i_unreg_dev_all(void)
-{
-        struct bnx2i_hba *hba, *temp;
-
-        mutex_lock(&bnx2i_dev_lock);
-        list_for_each_entry_safe(hba, temp, &adapter_list, link)
-                bnx2i_unreg_one_device(hba);
-        mutex_unlock(&bnx2i_dev_lock);
-}
-
 
 /**
  * bnx2i_init_one - initialize an adapter instance and allocate memory resources
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index fb50efbce087..f0dce26593eb 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -1,7 +1,7 @@
 /*
  * bnx2i_iscsi.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2009 Broadcom Corporation
+ * Copyright (c) 2006 - 2010 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
@@ -10,6 +10,7 @@
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 
 #include <linux/slab.h>
@@ -411,7 +412,9 @@ static void bnx2i_free_ep(struct iscsi_endpoint *ep)
         bnx2i_ep->state = EP_STATE_IDLE;
         bnx2i_ep->hba->ofld_conns_active--;
 
-        bnx2i_free_iscsi_cid(bnx2i_ep->hba, bnx2i_ep->ep_iscsi_cid);
+        if (bnx2i_ep->ep_iscsi_cid != (u16) -1)
+                bnx2i_free_iscsi_cid(bnx2i_ep->hba, bnx2i_ep->ep_iscsi_cid);
+
         if (bnx2i_ep->conn) {
                 bnx2i_ep->conn->ep = NULL;
                 bnx2i_ep->conn = NULL;
@@ -1383,6 +1386,12 @@ static int bnx2i_conn_bind(struct iscsi_cls_session *cls_session,
         ep = iscsi_lookup_endpoint(transport_fd);
         if (!ep)
                 return -EINVAL;
+        /*
+         * Forcefully terminate all in progress connection recovery at the
+         * earliest, either in bind(), send_pdu(LOGIN), or conn_start()
+         */
+        if (bnx2i_adapter_ready(hba))
+                return -EIO;
 
         bnx2i_ep = ep->dd_data;
         if ((bnx2i_ep->state == EP_STATE_TCP_FIN_RCVD) ||
@@ -1404,7 +1413,6 @@ static int bnx2i_conn_bind(struct iscsi_cls_session *cls_session,
                                   hba->netdev->name);
                 return -EEXIST;
         }
-
         bnx2i_ep->conn = bnx2i_conn;
         bnx2i_conn->ep = bnx2i_ep;
         bnx2i_conn->iscsi_conn_cid = bnx2i_ep->ep_iscsi_cid;
@@ -1461,21 +1469,28 @@ static int bnx2i_conn_get_param(struct iscsi_cls_conn *cls_conn,
         struct bnx2i_conn *bnx2i_conn = conn->dd_data;
         int len = 0;
 
+        if (!(bnx2i_conn && bnx2i_conn->ep && bnx2i_conn->ep->hba))
+                goto out;
+
         switch (param) {
         case ISCSI_PARAM_CONN_PORT:
-                if (bnx2i_conn->ep)
+                mutex_lock(&bnx2i_conn->ep->hba->net_dev_lock);
+                if (bnx2i_conn->ep->cm_sk)
                         len = sprintf(buf, "%hu\n",
                                       bnx2i_conn->ep->cm_sk->dst_port);
+                mutex_unlock(&bnx2i_conn->ep->hba->net_dev_lock);
                 break;
         case ISCSI_PARAM_CONN_ADDRESS:
-                if (bnx2i_conn->ep)
+                mutex_lock(&bnx2i_conn->ep->hba->net_dev_lock);
+                if (bnx2i_conn->ep->cm_sk)
                         len = sprintf(buf, "%pI4\n",
                                       &bnx2i_conn->ep->cm_sk->dst_ip);
+                mutex_unlock(&bnx2i_conn->ep->hba->net_dev_lock);
                 break;
         default:
                 return iscsi_conn_get_param(cls_conn, param, buf);
         }
-
+out:
         return len;
 }
 
@@ -1599,8 +1614,6 @@ static struct bnx2i_hba *bnx2i_check_route(struct sockaddr *dst_addr)
         struct bnx2i_hba *hba;
         struct cnic_dev *cnic = NULL;
 
-        bnx2i_reg_dev_all();
-
         hba = get_adapter_list_head();
         if (hba && hba->cnic)
                 cnic = hba->cnic->cm_select_dev(desti, CNIC_ULP_ISCSI);
@@ -1640,18 +1653,26 @@ no_nx2_route:
 static int bnx2i_tear_down_conn(struct bnx2i_hba *hba,
                                  struct bnx2i_endpoint *ep)
 {
-        if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic))
+        if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic) && ep->cm_sk)
                 hba->cnic->cm_destroy(ep->cm_sk);
 
-        if (test_bit(ADAPTER_STATE_GOING_DOWN, &ep->hba->adapter_state))
-                ep->state = EP_STATE_DISCONN_COMPL;
-
         if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type) &&
             ep->state == EP_STATE_DISCONN_TIMEDOUT) {
-                printk(KERN_ALERT "bnx2i - ERROR - please submit GRC Dump,"
-                                  " NW/PCIe trace, driver msgs to developers"
-                                  " for analysis\n");
-                return 1;
+                if (ep->conn && ep->conn->cls_conn &&
+                    ep->conn->cls_conn->dd_data) {
+                        struct iscsi_conn *conn = ep->conn->cls_conn->dd_data;
+
+                        /* Must suspend all rx queue activity for this ep */
+                        set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
+                }
+                /* CONN_DISCONNECT timeout may or may not be an issue depending
+                 * on what transcribed in TCP layer, different targets behave
+                 * differently
+                 */
+                printk(KERN_ALERT "bnx2i (%s): - WARN - CONN_DISCON timed out, "
+                                  "please submit GRC Dump, NW/PCIe trace, "
+                                  "driver msgs to developers for analysis\n",
+                                  hba->netdev->name);
         }
 
         ep->state = EP_STATE_CLEANUP_START;
@@ -1664,7 +1685,9 @@ static int bnx2i_tear_down_conn(struct bnx2i_hba *hba,
         bnx2i_ep_destroy_list_add(hba, ep);
 
         /* destroy iSCSI context, wait for it to complete */
-        bnx2i_send_conn_destroy(hba, ep);
+        if (bnx2i_send_conn_destroy(hba, ep))
+                ep->state = EP_STATE_CLEANUP_CMPL;
+
         wait_event_interruptible(ep->ofld_wait,
                                  (ep->state != EP_STATE_CLEANUP_START));
 
@@ -1711,8 +1734,6 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
         if (shost) {
                 /* driver is given scsi host to work with */
                 hba = iscsi_host_priv(shost);
-                /* Register the device with cnic if not already done so */
-                bnx2i_register_device(hba);
         } else
                 /*
                  * check if the given destination can be reached through
@@ -1720,13 +1741,17 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
                  */
                 hba = bnx2i_check_route(dst_addr);
 
-        if (!hba || test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state)) {
+        if (!hba) {
                 rc = -EINVAL;
                 goto nohba;
         }
+        mutex_lock(&hba->net_dev_lock);
 
+        if (bnx2i_adapter_ready(hba) || !hba->cid_que.cid_free_cnt) {
+                rc = -EPERM;
+                goto check_busy;
+        }
         cnic = hba->cnic;
-        mutex_lock(&hba->net_dev_lock);
         ep = bnx2i_alloc_ep(hba);
         if (!ep) {
                 rc = -ENOMEM;
@@ -1734,23 +1759,21 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
         }
         bnx2i_ep = ep->dd_data;
 
-        if (bnx2i_adapter_ready(hba)) {
-                rc = -EPERM;
-                goto net_if_down;
-        }
-
         bnx2i_ep->num_active_cmds = 0;
         iscsi_cid = bnx2i_alloc_iscsi_cid(hba);
         if (iscsi_cid == -1) {
-                printk(KERN_ALERT "alloc_ep: unable to allocate iscsi cid\n");
+                printk(KERN_ALERT "bnx2i (%s): alloc_ep - unable to allocate "
+                        "iscsi cid\n", hba->netdev->name);
                 rc = -ENOMEM;
-                goto iscsi_cid_err;
+                bnx2i_free_ep(ep);
+                goto check_busy;
         }
         bnx2i_ep->hba_age = hba->age;
 
         rc = bnx2i_alloc_qp_resc(hba, bnx2i_ep);
         if (rc != 0) {
-                printk(KERN_ALERT "bnx2i: ep_conn, alloc QP resc error\n");
+                printk(KERN_ALERT "bnx2i (%s): ep_conn - alloc QP resc error"
+                        "\n", hba->netdev->name);
                 rc = -ENOMEM;
                 goto qp_resc_err;
         }
@@ -1765,7 +1788,18 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
         bnx2i_ep->ofld_timer.data = (unsigned long) bnx2i_ep;
         add_timer(&bnx2i_ep->ofld_timer);
 
-        bnx2i_send_conn_ofld_req(hba, bnx2i_ep);
+        if (bnx2i_send_conn_ofld_req(hba, bnx2i_ep)) {
+                if (bnx2i_ep->state == EP_STATE_OFLD_FAILED_CID_BUSY) {
+                        printk(KERN_ALERT "bnx2i (%s): iscsi cid %d is busy\n",
+                                hba->netdev->name, bnx2i_ep->ep_iscsi_cid);
+                        rc = -EBUSY;
+                } else
+                        rc = -ENOSPC;
+                printk(KERN_ALERT "bnx2i (%s): unable to send conn offld kwqe"
+                        "\n", hba->netdev->name);
+                bnx2i_ep_ofld_list_del(hba, bnx2i_ep);
+                goto conn_failed;
+        }
 
         /* Wait for CNIC hardware to setup conn context and return 'cid' */
         wait_event_interruptible(bnx2i_ep->ofld_wait,
@@ -1778,7 +1812,12 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
         bnx2i_ep_ofld_list_del(hba, bnx2i_ep);
 
         if (bnx2i_ep->state != EP_STATE_OFLD_COMPL) {
-                rc = -ENOSPC;
+                if (bnx2i_ep->state == EP_STATE_OFLD_FAILED_CID_BUSY) {
+                        printk(KERN_ALERT "bnx2i (%s): iscsi cid %d is busy\n",
+                                hba->netdev->name, bnx2i_ep->ep_iscsi_cid);
+                        rc = -EBUSY;
+                } else
+                        rc = -ENOSPC;
                 goto conn_failed;
         }
 
@@ -1786,7 +1825,8 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
                              iscsi_cid, &bnx2i_ep->cm_sk, bnx2i_ep);
         if (rc) {
                 rc = -EINVAL;
-                goto conn_failed;
+                /* Need to terminate and cleanup the connection */
+                goto release_ep;
         }
 
         bnx2i_ep->cm_sk->rcv_buf = 256 * 1024;
@@ -1830,15 +1870,12 @@ release_ep:
                 return ERR_PTR(rc);
         }
 conn_failed:
-net_if_down:
-iscsi_cid_err:
         bnx2i_free_qp_resc(hba, bnx2i_ep);
 qp_resc_err:
         bnx2i_free_ep(ep);
 check_busy:
         mutex_unlock(&hba->net_dev_lock);
 nohba:
-        bnx2i_unreg_dev_all();
         return ERR_PTR(rc);
 }
 
@@ -1898,12 +1935,13 @@ static int bnx2i_ep_tcp_conn_active(struct bnx2i_endpoint *bnx2i_ep)
                 cnic_dev_10g = 1;
 
         switch (bnx2i_ep->state) {
-        case EP_STATE_CONNECT_START:
+        case EP_STATE_CONNECT_FAILED:
         case EP_STATE_CLEANUP_FAILED:
         case EP_STATE_OFLD_FAILED:
         case EP_STATE_DISCONN_TIMEDOUT:
                 ret = 0;
                 break;
+        case EP_STATE_CONNECT_START:
         case EP_STATE_CONNECT_COMPL:
         case EP_STATE_ULP_UPDATE_START:
         case EP_STATE_ULP_UPDATE_COMPL:
@@ -1914,13 +1952,10 @@ static int bnx2i_ep_tcp_conn_active(struct bnx2i_endpoint *bnx2i_ep)
                 ret = 1;
                 break;
         case EP_STATE_TCP_RST_RCVD:
-                ret = 0;
-                break;
-        case EP_STATE_CONNECT_FAILED:
                 if (cnic_dev_10g)
-                        ret = 1;
-                else
                         ret = 0;
+                else
+                        ret = 1;
                 break;
         default:
                 ret = 0;
@@ -1953,7 +1988,8 @@ int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
         if (!cnic)
                 return 0;
 
-        if (bnx2i_ep->state == EP_STATE_IDLE)
+        if (bnx2i_ep->state == EP_STATE_IDLE ||
+            bnx2i_ep->state == EP_STATE_DISCONN_TIMEDOUT)
                 return 0;
 
         if (!bnx2i_ep_tcp_conn_active(bnx2i_ep))
@@ -1979,9 +2015,10 @@ int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
                         if (session->state == ISCSI_STATE_LOGGING_OUT) {
                                 if (bnx2i_ep->state == EP_STATE_LOGOUT_SENT) {
                                         /* Logout sent, but no resp */
-                                        printk(KERN_ALERT "bnx2i - WARNING "
-                                                "logout response was not "
-                                                "received!\n");
+                                        printk(KERN_ALERT "bnx2i (%s): WARNING"
+                                                " logout response was not "
+                                                "received!\n",
+                                                bnx2i_ep->hba->netdev->name);
                                 } else if (bnx2i_ep->state ==
                                            EP_STATE_LOGOUT_RESP_RCVD)
                                         close = 1;
@@ -1999,9 +2036,8 @@ int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
         else
                 close_ret = cnic->cm_abort(bnx2i_ep->cm_sk);
 
-        /* No longer allow CFC delete if cm_close/abort fails the request */
         if (close_ret)
-                printk(KERN_ALERT "bnx2i: %s close/abort(%d) returned %d\n",
+                printk(KERN_ALERT "bnx2i (%s): close/abort(%d) returned %d\n",
                         bnx2i_ep->hba->netdev->name, close, close_ret);
         else
                 /* wait for option-2 conn teardown */
@@ -2015,7 +2051,7 @@ int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
 destroy_conn:
         bnx2i_ep_active_list_del(hba, bnx2i_ep);
         if (bnx2i_tear_down_conn(hba, bnx2i_ep))
-                ret = -EINVAL;
+                return -EINVAL;
 out:
         bnx2i_ep->state = EP_STATE_IDLE;
         return ret;
@@ -2054,14 +2090,17 @@ static void bnx2i_ep_disconnect(struct iscsi_endpoint *ep)
 
         mutex_lock(&hba->net_dev_lock);
 
-        if (bnx2i_ep->state == EP_STATE_IDLE)
-                goto return_bnx2i_ep;
+        if (bnx2i_ep->state == EP_STATE_DISCONN_TIMEDOUT)
+                goto out;
 
-        if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state))
+        if (bnx2i_ep->state == EP_STATE_IDLE)
                 goto free_resc;
 
-        if (bnx2i_ep->hba_age != hba->age)
+        if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state) ||
+            (bnx2i_ep->hba_age != hba->age)) {
+                bnx2i_ep_active_list_del(hba, bnx2i_ep);
                 goto free_resc;
+        }
 
         /* Do all chip cleanup here */
         if (bnx2i_hw_ep_disconnect(bnx2i_ep)) {
@@ -2070,14 +2109,13 @@ static void bnx2i_ep_disconnect(struct iscsi_endpoint *ep)
         }
 free_resc:
         bnx2i_free_qp_resc(hba, bnx2i_ep);
-return_bnx2i_ep:
+
         if (bnx2i_conn)
                 bnx2i_conn->ep = NULL;
 
         bnx2i_free_ep(ep);
+out:
         mutex_unlock(&hba->net_dev_lock);
-        if (!hba->ofld_conns_active)
-                bnx2i_unreg_dev_all();
 
         wake_up_interruptible(&hba->eh_wait);
 }
diff --git a/drivers/scsi/bnx2i/bnx2i_sysfs.c b/drivers/scsi/bnx2i/bnx2i_sysfs.c
index 96426b751eb2..9174196d9033 100644
--- a/drivers/scsi/bnx2i/bnx2i_sysfs.c
+++ b/drivers/scsi/bnx2i/bnx2i_sysfs.c
@@ -1,12 +1,13 @@
 /* bnx2i_sysfs.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2004 - 2009 Broadcom Corporation
+ * Copyright (c) 2004 - 2010 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation.
  *
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
+ * Maintained by: Eddie Wai (eddie.wai@broadcom.com)
  */
 
 #include "bnx2i.h"
diff --git a/drivers/scsi/device_handler/scsi_dh.c b/drivers/scsi/device_handler/scsi_dh.c
index 6fae3d285ae7..b837c5b3c8f9 100644
--- a/drivers/scsi/device_handler/scsi_dh.c
+++ b/drivers/scsi/device_handler/scsi_dh.c
@@ -442,12 +442,19 @@ int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
         sdev = q->queuedata;
         if (sdev && sdev->scsi_dh_data)
                 scsi_dh = sdev->scsi_dh_data->scsi_dh;
-        if (!scsi_dh || !get_device(&sdev->sdev_gendev))
+        if (!scsi_dh || !get_device(&sdev->sdev_gendev) ||
+            sdev->sdev_state == SDEV_CANCEL ||
+            sdev->sdev_state == SDEV_DEL)
                 err = SCSI_DH_NOSYS;
+        if (sdev->sdev_state == SDEV_OFFLINE)
+                err = SCSI_DH_DEV_OFFLINED;
         spin_unlock_irqrestore(q->queue_lock, flags);
 
-        if (err)
+        if (err) {
+                if (fn)
+                        fn(data, err);
                 return err;
+        }
 
         if (scsi_dh->activate)
                 err = scsi_dh->activate(sdev, fn, data);
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index d23a538a9dfc..9f9600b67001 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -854,7 +854,6 @@ static void fcoe_if_destroy(struct fc_lport *lport)
 
         /* Cleanup the fc_lport */
         fc_lport_destroy(lport);
-        fc_fcp_destroy(lport);
 
         /* Stop the transmit retry timer */
         del_timer_sync(&port->timer);
@@ -876,6 +875,9 @@ static void fcoe_if_destroy(struct fc_lport *lport)
         fc_remove_host(lport->host);
         scsi_remove_host(lport->host);
 
+        /* Destroy lport scsi_priv */
+        fc_fcp_destroy(lport);
+
         /* There are no more rports or I/O, free the EM */
         fc_exch_mgr_free(lport);
 
diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index bc17c7123202..625c6be25396 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -54,6 +54,7 @@ MODULE_LICENSE("GPL v2");
 static void fcoe_ctlr_timeout(unsigned long);
 static void fcoe_ctlr_timer_work(struct work_struct *);
 static void fcoe_ctlr_recv_work(struct work_struct *);
+static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *);
 
 static void fcoe_ctlr_vn_start(struct fcoe_ctlr *);
 static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *, struct sk_buff *);
@@ -176,6 +177,7 @@ void fcoe_ctlr_init(struct fcoe_ctlr *fip, enum fip_state mode)
         fip->mode = mode;
         INIT_LIST_HEAD(&fip->fcfs);
         mutex_init(&fip->ctlr_mutex);
+        spin_lock_init(&fip->ctlr_lock);
         fip->flogi_oxid = FC_XID_UNKNOWN;
         setup_timer(&fip->timer, fcoe_ctlr_timeout, (unsigned long)fip);
         INIT_WORK(&fip->timer_work, fcoe_ctlr_timer_work);
@@ -231,6 +233,49 @@ void fcoe_ctlr_destroy(struct fcoe_ctlr *fip)
 EXPORT_SYMBOL(fcoe_ctlr_destroy);
 
 /**
+ * fcoe_ctlr_announce() - announce new FCF selection
+ * @fip: The FCoE controller
+ *
+ * Also sets the destination MAC for FCoE and control packets
+ *
+ * Called with neither ctlr_mutex nor ctlr_lock held.
+ */
+static void fcoe_ctlr_announce(struct fcoe_ctlr *fip)
+{
+        struct fcoe_fcf *sel;
+        struct fcoe_fcf *fcf;
+
+        mutex_lock(&fip->ctlr_mutex);
+        spin_lock_bh(&fip->ctlr_lock);
+
+        kfree_skb(fip->flogi_req);
+        fip->flogi_req = NULL;
+        list_for_each_entry(fcf, &fip->fcfs, list)
+                fcf->flogi_sent = 0;
+
+        spin_unlock_bh(&fip->ctlr_lock);
+        sel = fip->sel_fcf;
+
+        if (sel && !compare_ether_addr(sel->fcf_mac, fip->dest_addr))
+                goto unlock;
+        if (!is_zero_ether_addr(fip->dest_addr)) {
+                printk(KERN_NOTICE "libfcoe: host%d: "
+                       "FIP Fibre-Channel Forwarder MAC %pM deselected\n",
+                       fip->lp->host->host_no, fip->dest_addr);
+                memset(fip->dest_addr, 0, ETH_ALEN);
+        }
+        if (sel) {
+                printk(KERN_INFO "libfcoe: host%d: FIP selected "
+                       "Fibre-Channel Forwarder MAC %pM\n",
+                       fip->lp->host->host_no, sel->fcf_mac);
+                memcpy(fip->dest_addr, sel->fcf_mac, ETH_ALEN);
+                fip->map_dest = 0;
+        }
+unlock:
+        mutex_unlock(&fip->ctlr_mutex);
+}
+
+/**
  * fcoe_ctlr_fcoe_size() - Return the maximum FCoE size required for VN_Port
  * @fip: The FCoE controller to get the maximum FCoE size from
  *
@@ -564,6 +609,9 @@ static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip, struct fc_lport *lport,
  * The caller must check that the length is a multiple of 4.
  * The SKB must have enough headroom (28 bytes) and tailroom (8 bytes).
  * The the skb must also be an fc_frame.
+ *
+ * This is called from the lower-level driver with spinlocks held,
+ * so we must not take a mutex here.
  */
 int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct fc_lport *lport,
                        struct sk_buff *skb)
@@ -601,7 +649,15 @@ int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct fc_lport *lport,
         switch (op) {
         case ELS_FLOGI:
                 op = FIP_DT_FLOGI;
-                break;
+                if (fip->mode == FIP_MODE_VN2VN)
+                        break;
+                spin_lock_bh(&fip->ctlr_lock);
+                kfree_skb(fip->flogi_req);
+                fip->flogi_req = skb;
+                fip->flogi_req_send = 1;
+                spin_unlock_bh(&fip->ctlr_lock);
+                schedule_work(&fip->timer_work);
+                return -EINPROGRESS;
         case ELS_FDISC:
                 if (ntoh24(fh->fh_s_id))
                         return 0;
@@ -922,11 +978,9 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
         }
         mtu_valid = fcoe_ctlr_mtu_valid(fcf);
         fcf->time = jiffies;
-        if (!found) {
-                LIBFCOE_FIP_DBG(fip, "New FCF for fab %16.16llx "
-                                "map %x val %d\n",
-                                fcf->fabric_name, fcf->fc_map, mtu_valid);
-        }
+        if (!found)
+                LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",
+                                fcf->fabric_name, fcf->fcf_mac);
 
         /*
          * If this advertisement is not solicited and our max receive size
@@ -945,6 +999,17 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
                 fcoe_ctlr_solicit(fip, NULL);
 
         /*
+         * Put this FCF at the head of the list for priority among equals.
+         * This helps in the case of an NPV switch which insists we use
+         * the FCF that answers multicast solicitations, not the others that
+         * are sending periodic multicast advertisements.
+         */
+        if (mtu_valid) {
+                list_del(&fcf->list);
+                list_add(&fcf->list, &fip->fcfs);
+        }
+
+        /*
          * If this is the first validated FCF, note the time and
          * set a timer to trigger selection.
          */
@@ -1061,18 +1126,24 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
         els_op = *(u8 *)(fh + 1);
 
         if ((els_dtype == FIP_DT_FLOGI || els_dtype == FIP_DT_FDISC) &&
-            sub == FIP_SC_REP && els_op == ELS_LS_ACC &&
-            fip->mode != FIP_MODE_VN2VN) {
-                if (!is_valid_ether_addr(granted_mac)) {
-                        LIBFCOE_FIP_DBG(fip,
-                                "Invalid MAC address %pM in FIP ELS\n",
-                                granted_mac);
-                        goto drop;
-                }
-                memcpy(fr_cb(fp)->granted_mac, granted_mac, ETH_ALEN);
+            sub == FIP_SC_REP && fip->mode != FIP_MODE_VN2VN) {
+                if (els_op == ELS_LS_ACC) {
+                        if (!is_valid_ether_addr(granted_mac)) {
+                                LIBFCOE_FIP_DBG(fip,
+                                        "Invalid MAC address %pM in FIP ELS\n",
+                                        granted_mac);
+                                goto drop;
+                        }
+                        memcpy(fr_cb(fp)->granted_mac, granted_mac, ETH_ALEN);
 
-                if (fip->flogi_oxid == ntohs(fh->fh_ox_id))
-                        fip->flogi_oxid = FC_XID_UNKNOWN;
+                        if (fip->flogi_oxid == ntohs(fh->fh_ox_id)) {
+                                fip->flogi_oxid = FC_XID_UNKNOWN;
+                                if (els_dtype == FIP_DT_FLOGI)
+                                        fcoe_ctlr_announce(fip);
+                        }
+                } else if (els_dtype == FIP_DT_FLOGI &&
+                           !fcoe_ctlr_flogi_retry(fip))
+                        goto drop;      /* retrying FLOGI so drop reject */
         }
 
         if ((desc_cnt == 0) || ((els_op != ELS_LS_RJT) &&
@@ -1326,20 +1397,39 @@ drop:
  * fcoe_ctlr_select() - Select the best FCF (if possible)
  * @fip: The FCoE controller
  *
+ * Returns the selected FCF, or NULL if none are usable.
+ *
  * If there are conflicting advertisements, no FCF can be chosen.
  *
+ * If there is already a selected FCF, this will choose a better one or
+ * an equivalent one that hasn't already been sent a FLOGI.
+ *
  * Called with lock held.
  */
-static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
+static struct fcoe_fcf *fcoe_ctlr_select(struct fcoe_ctlr *fip)
 {
         struct fcoe_fcf *fcf;
-        struct fcoe_fcf *best = NULL;
+        struct fcoe_fcf *best = fip->sel_fcf;
+        struct fcoe_fcf *first;
+
+        first = list_first_entry(&fip->fcfs, struct fcoe_fcf, list);
 
         list_for_each_entry(fcf, &fip->fcfs, list) {
-                LIBFCOE_FIP_DBG(fip, "consider FCF for fab %16.16llx "
-                                "VFID %d map %x val %d\n",
-                                fcf->fabric_name, fcf->vfid,
-                                fcf->fc_map, fcoe_ctlr_mtu_valid(fcf));
+                LIBFCOE_FIP_DBG(fip, "consider FCF fab %16.16llx "
+                                "VFID %d mac %pM map %x val %d "
+                                "sent %u pri %u\n",
+                                fcf->fabric_name, fcf->vfid, fcf->fcf_mac,
+                                fcf->fc_map, fcoe_ctlr_mtu_valid(fcf),
+                                fcf->flogi_sent, fcf->pri);
+                if (fcf->fabric_name != first->fabric_name ||
+                    fcf->vfid != first->vfid ||
+                    fcf->fc_map != first->fc_map) {
+                        LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
+                                        "or FC-MAP\n");
+                        return NULL;
+                }
+                if (fcf->flogi_sent)
+                        continue;
                 if (!fcoe_ctlr_fcf_usable(fcf)) {
                         LIBFCOE_FIP_DBG(fip, "FCF for fab %16.16llx "
                                         "map %x %svalid %savailable\n",
@@ -1349,21 +1439,131 @@ static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
                                         "" : "un");
                         continue;
                 }
-                if (!best) {
-                        best = fcf;
-                        continue;
-                }
-                if (fcf->fabric_name != best->fabric_name ||
-                    fcf->vfid != best->vfid ||
-                    fcf->fc_map != best->fc_map) {
-                        LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
-                                        "or FC-MAP\n");
-                        return;
-                }
-                if (fcf->pri < best->pri)
+                if (!best || fcf->pri < best->pri || best->flogi_sent)
                         best = fcf;
         }
         fip->sel_fcf = best;
+        if (best) {
+                LIBFCOE_FIP_DBG(fip, "using FCF mac %pM\n", best->fcf_mac);
+                fip->port_ka_time = jiffies +
+                        msecs_to_jiffies(FIP_VN_KA_PERIOD);
+                fip->ctlr_ka_time = jiffies + best->fka_period;
+                if (time_before(fip->ctlr_ka_time, fip->timer.expires))
+                        mod_timer(&fip->timer, fip->ctlr_ka_time);
+        }
+        return best;
+}
+
+/**
+ * fcoe_ctlr_flogi_send_locked() - send FIP-encapsulated FLOGI to current FCF
+ * @fip: The FCoE controller
+ *
+ * Returns non-zero error if it could not be sent.
+ *
+ * Called with ctlr_mutex and ctlr_lock held.
+ * Caller must verify that fip->sel_fcf is not NULL.
+ */
+static int fcoe_ctlr_flogi_send_locked(struct fcoe_ctlr *fip)
+{
+        struct sk_buff *skb;
+        struct sk_buff *skb_orig;
+        struct fc_frame_header *fh;
+        int error;
+
+        skb_orig = fip->flogi_req;
+        if (!skb_orig)
+                return -EINVAL;
+
+        /*
+         * Clone and send the FLOGI request.  If clone fails, use original.
+         */
+        skb = skb_clone(skb_orig, GFP_ATOMIC);
+        if (!skb) {
+                skb = skb_orig;
+                fip->flogi_req = NULL;
+        }
+        fh = (struct fc_frame_header *)skb->data;
+        error = fcoe_ctlr_encaps(fip, fip->lp, FIP_DT_FLOGI, skb,
+                                 ntoh24(fh->fh_d_id));
+        if (error) {
+                kfree_skb(skb);
+                return error;
+        }
+        fip->send(fip, skb);
+        fip->sel_fcf->flogi_sent = 1;
+        return 0;
+}
+
+/**
+ * fcoe_ctlr_flogi_retry() - resend FLOGI request to a new FCF if possible
+ * @fip: The FCoE controller
+ *
+ * Returns non-zero error code if there's no FLOGI request to retry or
+ * no alternate FCF available.
+ */
+static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *fip)
+{
+        struct fcoe_fcf *fcf;
+        int error;
+
+        mutex_lock(&fip->ctlr_mutex);
+        spin_lock_bh(&fip->ctlr_lock);
+        LIBFCOE_FIP_DBG(fip, "re-sending FLOGI - reselect\n");
+        fcf = fcoe_ctlr_select(fip);
+        if (!fcf || fcf->flogi_sent) {
+                kfree_skb(fip->flogi_req);
+                fip->flogi_req = NULL;
+                error = -ENOENT;
+        } else {
+                fcoe_ctlr_solicit(fip, NULL);
+                error = fcoe_ctlr_flogi_send_locked(fip);
+        }
+        spin_unlock_bh(&fip->ctlr_lock);
+        mutex_unlock(&fip->ctlr_mutex);
+        return error;
+}
+
+
+/**
+ * fcoe_ctlr_flogi_send() - Handle sending of FIP FLOGI.
+ * @fip: The FCoE controller that timed out
+ *
+ * Done here because fcoe_ctlr_els_send() can't get mutex.
+ *
+ * Called with ctlr_mutex held.  The caller must not hold ctlr_lock.
+ */
+static void fcoe_ctlr_flogi_send(struct fcoe_ctlr *fip)
+{
+        struct fcoe_fcf *fcf;
+
+        spin_lock_bh(&fip->ctlr_lock);
+        fcf = fip->sel_fcf;
+        if (!fcf || !fip->flogi_req_send)
+                goto unlock;
+
+        LIBFCOE_FIP_DBG(fip, "sending FLOGI\n");
+
+        /*
+         * If this FLOGI is being sent due to a timeout retry
+         * to the same FCF as before, select a different FCF if possible.
+         */
+        if (fcf->flogi_sent) {
+                LIBFCOE_FIP_DBG(fip, "sending FLOGI - reselect\n");
+                fcf = fcoe_ctlr_select(fip);
+                if (!fcf || fcf->flogi_sent) {
+                        LIBFCOE_FIP_DBG(fip, "sending FLOGI - clearing\n");
+                        list_for_each_entry(fcf, &fip->fcfs, list)
+                                fcf->flogi_sent = 0;
+                        fcf = fcoe_ctlr_select(fip);
+                }
+        }
+        if (fcf) {
+                fcoe_ctlr_flogi_send_locked(fip);
+                fip->flogi_req_send = 0;
+        } else /* XXX */
+                LIBFCOE_FIP_DBG(fip, "No FCF selected - defer send\n");
+unlock:
+        spin_unlock_bh(&fip->ctlr_lock);
 }
 
 /**
@@ -1411,34 +1611,16 @@ static void fcoe_ctlr_timer_work(struct work_struct *work)
         sel = fip->sel_fcf;
         if (!sel && fip->sel_time) {
                 if (time_after_eq(jiffies, fip->sel_time)) {
-                        fcoe_ctlr_select(fip);
-                        sel = fip->sel_fcf;
+                        sel = fcoe_ctlr_select(fip);
                         fip->sel_time = 0;
                 } else if (time_after(next_timer, fip->sel_time))
                         next_timer = fip->sel_time;
         }
 
-        if (sel != fcf) {
-                fcf = sel;              /* the old FCF may have been freed */
-                if (sel) {
-                        printk(KERN_INFO "libfcoe: host%d: FIP selected "
-                               "Fibre-Channel Forwarder MAC %pM\n",
-                               fip->lp->host->host_no, sel->fcf_mac);
-                        memcpy(fip->dest_addr, sel->fcf_mac, ETH_ALEN);
-                        fip->map_dest = 0;
-                        fip->port_ka_time = jiffies +
-                                msecs_to_jiffies(FIP_VN_KA_PERIOD);
-                        fip->ctlr_ka_time = jiffies + sel->fka_period;
-                        if (time_after(next_timer, fip->ctlr_ka_time))
-                                next_timer = fip->ctlr_ka_time;
-                } else {
-                        printk(KERN_NOTICE "libfcoe: host%d: "
-                               "FIP Fibre-Channel Forwarder timed out.  "
-                               "Starting FCF discovery.\n",
-                               fip->lp->host->host_no);
-                        reset = 1;
-                }
-        }
+        if (sel && fip->flogi_req_send)
+                fcoe_ctlr_flogi_send(fip);
+        else if (!sel && fcf)
+                reset = 1;
 
         if (sel && !sel->fd_flags) {
                 if (time_after_eq(jiffies, fip->ctlr_ka_time)) {
@@ -2475,7 +2657,7 @@ static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *fip)
         case FIP_ST_LINK_WAIT:
                 goto unlock;
         default:
-                WARN(1, "unexpected state %d", fip->state);
+                WARN(1, "unexpected state %d\n", fip->state);
                 goto unlock;
         }
         mod_timer(&fip->timer, next_time);
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 76365700e2d5..3242bcabad97 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -4273,8 +4273,10 @@ static int ioc_general(void __user *arg, char *cmnd)
     }
 
     rval = __gdth_execute(ha->sdev, &gen.command, cmnd, gen.timeout, &gen.info);
-    if (rval < 0)
+    if (rval < 0) {
+        gdth_ioctl_free(ha, gen.data_len+gen.sense_len, buf, paddr);
         return rval;
+    }
     gen.status = rval;
 
     if (copy_to_user(arg + sizeof(gdth_ioctl_general), buf, 
diff --git a/drivers/scsi/gdth_proc.c b/drivers/scsi/gdth_proc.c
index 0572b9bf4bd6..652754319a4b 100644
--- a/drivers/scsi/gdth_proc.c
+++ b/drivers/scsi/gdth_proc.c
@@ -365,8 +365,10 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
                     len = 0;
                     begin = pos;
                 }
-                if (pos > offset + length)
+                if (pos > offset + length) {
+                    gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
                     goto stop_output;
+                }
             }
         }
         gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
@@ -450,8 +452,10 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
                     len = 0;
                     begin = pos;
                 }
-                if (pos > offset + length)
+                if (pos > offset + length) {
+                    gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
                     goto stop_output;
+                }
             } while (drv_no != -1);
              
             if (is_mirr) {
@@ -472,8 +476,10 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
                 len = 0;
                 begin = pos;
             }
-            if (pos > offset + length)
+            if (pos > offset + length) {
+                gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
                 goto stop_output;
+            }
         }       
         gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
         
@@ -542,8 +548,10 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
                     len = 0;
                     begin = pos;
                 }
-                if (pos > offset + length)
+                if (pos > offset + length) {
+                    gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
                     goto stop_output;
+                }
             }
         }
         gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index a6dea08664fc..12deffccb8da 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -641,11 +641,6 @@ static void fixup_botched_add(struct ctlr_info *h,
 static inline int device_is_the_same(struct hpsa_scsi_dev_t *dev1,
         struct hpsa_scsi_dev_t *dev2)
 {
-        if ((is_logical_dev_addr_mode(dev1->scsi3addr) ||
-                (dev1->lun != -1 && dev2->lun != -1)) &&
-                dev1->devtype != 0x0C)
-                return (memcmp(dev1, dev2, sizeof(*dev1)) == 0);
-
         /* we compare everything except lun and target as these
          * are not yet assigned.  Compare parts likely
          * to differ first
@@ -660,12 +655,8 @@ static inline int device_is_the_same(struct hpsa_scsi_dev_t *dev1,
                 return 0;
         if (memcmp(dev1->vendor, dev2->vendor, sizeof(dev1->vendor)) != 0)
                 return 0;
-        if (memcmp(dev1->revision, dev2->revision, sizeof(dev1->revision)) != 0)
-                return 0;
         if (dev1->devtype != dev2->devtype)
                 return 0;
-        if (dev1->raid_level != dev2->raid_level)
-                return 0;
         if (dev1->bus != dev2->bus)
                 return 0;
         return 1;
@@ -1477,8 +1468,6 @@ static int hpsa_update_device_info(struct ctlr_info *h,
                 sizeof(this_device->vendor));
         memcpy(this_device->model, &inq_buff[16],
                 sizeof(this_device->model));
-        memcpy(this_device->revision, &inq_buff[32],
-                sizeof(this_device->revision));
         memset(this_device->device_id, 0,
                 sizeof(this_device->device_id));
         hpsa_get_device_id(h, scsi3addr, this_device->device_id,
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index a203ef65cb50..19586e189f0f 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -45,7 +45,6 @@ struct hpsa_scsi_dev_t {
         unsigned char device_id[16];    /* from inquiry pg. 0x83 */
         unsigned char vendor[8];        /* bytes 8-15 of inquiry data */
         unsigned char model[16];        /* bytes 16-31 of inquiry data */
-        unsigned char revision[4];      /* bytes 32-35 of inquiry data */
         unsigned char raid_level;       /* from inquiry page 0xC1 */
 };
 
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index 57cad7e20caa..b7650613b8c2 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -2493,23 +2493,23 @@ static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
 }
 
 static const struct ibmvfc_async_desc ae_desc [] = {
-        { IBMVFC_AE_ELS_PLOGI,          "PLOGI",                IBMVFC_DEFAULT_LOG_LEVEL + 1 },
-        { IBMVFC_AE_ELS_LOGO,           "LOGO",         IBMVFC_DEFAULT_LOG_LEVEL + 1 },
-        { IBMVFC_AE_ELS_PRLO,           "PRLO",         IBMVFC_DEFAULT_LOG_LEVEL + 1 },
-        { IBMVFC_AE_SCN_NPORT,          "N-Port SCN",   IBMVFC_DEFAULT_LOG_LEVEL + 1 },
-        { IBMVFC_AE_SCN_GROUP,          "Group SCN",    IBMVFC_DEFAULT_LOG_LEVEL + 1 },
-        { IBMVFC_AE_SCN_DOMAIN,         "Domain SCN",   IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_SCN_FABRIC,         "Fabric SCN",   IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_LINK_UP,            "Link Up",              IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_LINK_DOWN,          "Link Down",    IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_LINK_DEAD,          "Link Dead",    IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_HALT,                       "Halt",         IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_RESUME,             "Resume",               IBMVFC_DEFAULT_LOG_LEVEL },
-        { IBMVFC_AE_ADAPTER_FAILED,     "Adapter Failed",       IBMVFC_DEFAULT_LOG_LEVEL },
+        { "PLOGI",      IBMVFC_AE_ELS_PLOGI,    IBMVFC_DEFAULT_LOG_LEVEL + 1 },
+        { "LOGO",       IBMVFC_AE_ELS_LOGO,     IBMVFC_DEFAULT_LOG_LEVEL + 1 },
+        { "PRLO",       IBMVFC_AE_ELS_PRLO,     IBMVFC_DEFAULT_LOG_LEVEL + 1 },
+        { "N-Port SCN", IBMVFC_AE_SCN_NPORT,    IBMVFC_DEFAULT_LOG_LEVEL + 1 },
+        { "Group SCN",  IBMVFC_AE_SCN_GROUP,    IBMVFC_DEFAULT_LOG_LEVEL + 1 },
+        { "Domain SCN", IBMVFC_AE_SCN_DOMAIN,   IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Fabric SCN", IBMVFC_AE_SCN_FABRIC,   IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Link Up",    IBMVFC_AE_LINK_UP,      IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Link Down",  IBMVFC_AE_LINK_DOWN,    IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Link Dead",  IBMVFC_AE_LINK_DEAD,    IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Halt",       IBMVFC_AE_HALT,         IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Resume",     IBMVFC_AE_RESUME,       IBMVFC_DEFAULT_LOG_LEVEL },
+        { "Adapter Failed", IBMVFC_AE_ADAPTER_FAILED, IBMVFC_DEFAULT_LOG_LEVEL },
 };
 
 static const struct ibmvfc_async_desc unknown_ae = {
-        0, "Unknown async", IBMVFC_DEFAULT_LOG_LEVEL
+        "Unknown async", 0, IBMVFC_DEFAULT_LOG_LEVEL
 };
 
 /**
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index ef663e7c9bbc..834c37fc7ce9 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -542,8 +542,8 @@ enum ibmvfc_async_event {
 };
 
 struct ibmvfc_async_desc {
-        enum ibmvfc_async_event ae;
         const char *desc;
+        enum ibmvfc_async_event ae;
         int log_level;
 };
 
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 5bbaee597e88..de2e09e49a3e 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -146,7 +146,7 @@ static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
                 }
         },
         { /* CRoC */
-                .mailbox = 0x00040,
+                .mailbox = 0x00044,
                 .cache_line_size = 0x20,
                 {
                         .set_interrupt_mask_reg = 0x00010,
@@ -1048,6 +1048,8 @@ static void ipr_init_res_entry(struct ipr_resource_entry *res,
                         sizeof(res->res_path));
 
                 res->bus = 0;
+                memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
+                        sizeof(res->dev_lun.scsi_lun));
                 res->lun = scsilun_to_int(&res->dev_lun);
 
                 if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
@@ -1063,9 +1065,6 @@ static void ipr_init_res_entry(struct ipr_resource_entry *res,
                                                                   ioa_cfg->max_devs_supported);
                                 set_bit(res->target, ioa_cfg->target_ids);
                         }
-
-                        memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
-                                sizeof(res->dev_lun.scsi_lun));
                 } else if (res->type == IPR_RES_TYPE_IOAFP) {
                         res->bus = IPR_IOAFP_VIRTUAL_BUS;
                         res->target = 0;
@@ -1116,7 +1115,7 @@ static int ipr_is_same_device(struct ipr_resource_entry *res,
         if (res->ioa_cfg->sis64) {
                 if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
                                         sizeof(cfgtew->u.cfgte64->dev_id)) &&
-                        !memcmp(&res->lun, &cfgtew->u.cfgte64->lun,
+                        !memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
                                         sizeof(cfgtew->u.cfgte64->lun))) {
                         return 1;
                 }
@@ -2901,6 +2900,12 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
                 return;
         }
 
+        if (ioa_cfg->sis64) {
+                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                ssleep(IPR_DUMP_DELAY_SECONDS);
+                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        }
+
         start_addr = readl(ioa_cfg->ioa_mailbox);
 
         if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
@@ -7473,6 +7478,29 @@ static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
 }
 
 /**
+ * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
+ * @ipr_cmd:    ipr command struct
+ *
+ * Description: This function will call to get the unit check buffer.
+ *
+ * Return value:
+ *      IPR_RC_JOB_RETURN
+ **/
+static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+
+        ENTER;
+        ioa_cfg->ioa_unit_checked = 0;
+        ipr_get_unit_check_buffer(ioa_cfg);
+        ipr_cmd->job_step = ipr_reset_alert;
+        ipr_reset_start_timer(ipr_cmd, 0);
+
+        LEAVE;
+        return IPR_RC_JOB_RETURN;
+}
+
+/**
  * ipr_reset_restore_cfg_space - Restore PCI config space.
  * @ipr_cmd:    ipr command struct
  *
@@ -7512,11 +7540,17 @@ static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
         }
 
         if (ioa_cfg->ioa_unit_checked) {
-                ioa_cfg->ioa_unit_checked = 0;
-                ipr_get_unit_check_buffer(ioa_cfg);
-                ipr_cmd->job_step = ipr_reset_alert;
-                ipr_reset_start_timer(ipr_cmd, 0);
-                return IPR_RC_JOB_RETURN;
+                if (ioa_cfg->sis64) {
+                        ipr_cmd->job_step = ipr_reset_get_unit_check_job;
+                        ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT);
+                        return IPR_RC_JOB_RETURN;
+                } else {
+                        ioa_cfg->ioa_unit_checked = 0;
+                        ipr_get_unit_check_buffer(ioa_cfg);
+                        ipr_cmd->job_step = ipr_reset_alert;
+                        ipr_reset_start_timer(ipr_cmd, 0);
+                        return IPR_RC_JOB_RETURN;
+                }
         }
 
         if (ioa_cfg->in_ioa_bringdown) {
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index b28a00f1082c..13f425fb8851 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -218,6 +218,8 @@
 #define IPR_WAIT_FOR_BIST_TIMEOUT               (2 * HZ)
 #define IPR_PCI_RESET_TIMEOUT                   (HZ / 2)
 #define IPR_DUMP_TIMEOUT                        (15 * HZ)
+#define IPR_DUMP_DELAY_SECONDS                  4
+#define IPR_DUMP_DELAY_TIMEOUT                  (IPR_DUMP_DELAY_SECONDS * HZ)
 
 /*
  * SCSI Literals
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index ec2a1aec2350..d21367d3305f 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -67,6 +67,11 @@ struct workqueue_struct *fc_exch_workqueue;
 struct fc_exch_pool {
         u16              next_index;
         u16              total_exches;
+
+        /* two cache of free slot in exch array */
+        u16              left;
+        u16              right;
+
         spinlock_t       lock;
         struct list_head ex_list;
 };
@@ -108,7 +113,6 @@ struct fc_exch_mgr {
                 atomic_t non_bls_resp;
         } stats;
 };
-#define fc_seq_exch(sp) container_of(sp, struct fc_exch, seq)
 
 /**
  * struct fc_exch_mgr_anchor - primary structure for list of EMs
@@ -397,13 +401,23 @@ static inline void fc_exch_ptr_set(struct fc_exch_pool *pool, u16 index,
 static void fc_exch_delete(struct fc_exch *ep)
 {
         struct fc_exch_pool *pool;
+        u16 index;
 
         pool = ep->pool;
         spin_lock_bh(&pool->lock);
         WARN_ON(pool->total_exches <= 0);
         pool->total_exches--;
-        fc_exch_ptr_set(pool, (ep->xid - ep->em->min_xid) >> fc_cpu_order,
-                        NULL);
+
+        /* update cache of free slot */
+        index = (ep->xid - ep->em->min_xid) >> fc_cpu_order;
+        if (pool->left == FC_XID_UNKNOWN)
+                pool->left = index;
+        else if (pool->right == FC_XID_UNKNOWN)
+                pool->right = index;
+        else
+                pool->next_index = index;
+
+        fc_exch_ptr_set(pool, index, NULL);
         list_del(&ep->ex_list);
         spin_unlock_bh(&pool->lock);
         fc_exch_release(ep);    /* drop hold for exch in mp */
@@ -636,10 +650,13 @@ static void fc_exch_timeout(struct work_struct *work)
                 if (e_stat & ESB_ST_ABNORMAL)
                         rc = fc_exch_done_locked(ep);
                 spin_unlock_bh(&ep->ex_lock);
-                if (!rc)
-                        fc_exch_delete(ep);
                 if (resp)
                         resp(sp, ERR_PTR(-FC_EX_TIMEOUT), arg);
+                if (!rc) {
+                        /* delete the exchange if it's already being aborted */
+                        fc_exch_delete(ep);
+                        return;
+                }
                 fc_seq_exch_abort(sp, 2 * ep->r_a_tov);
                 goto done;
         }
@@ -679,6 +696,19 @@ static struct fc_exch *fc_exch_em_alloc(struct fc_lport *lport,
         pool = per_cpu_ptr(mp->pool, cpu);
         spin_lock_bh(&pool->lock);
         put_cpu();
+
+        /* peek cache of free slot */
+        if (pool->left != FC_XID_UNKNOWN) {
+                index = pool->left;
+                pool->left = FC_XID_UNKNOWN;
+                goto hit;
+        }
+        if (pool->right != FC_XID_UNKNOWN) {
+                index = pool->right;
+                pool->right = FC_XID_UNKNOWN;
+                goto hit;
+        }
+
         index = pool->next_index;
         /* allocate new exch from pool */
         while (fc_exch_ptr_get(pool, index)) {
@@ -687,7 +717,7 @@ static struct fc_exch *fc_exch_em_alloc(struct fc_lport *lport,
                         goto err;
         }
         pool->next_index = index == mp->pool_max_index ? 0 : index + 1;
-
+hit:
         fc_exch_hold(ep);       /* hold for exch in mp */
         spin_lock_init(&ep->ex_lock);
         /*
@@ -1247,7 +1277,7 @@ static struct fc_seq *fc_seq_assign(struct fc_lport *lport, struct fc_frame *fp)
 
         list_for_each_entry(ema, &lport->ema_list, ema_list)
                 if ((!ema->match || ema->match(fp)) &&
-                    fc_seq_lookup_recip(lport, ema->mp, fp) != FC_RJT_NONE)
+                    fc_seq_lookup_recip(lport, ema->mp, fp) == FC_RJT_NONE)
                         break;
         return fr_seq(fp);
 }
@@ -1343,7 +1373,7 @@ static void fc_exch_recv_seq_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
         }
         if (ep->esb_stat & ESB_ST_COMPLETE) {
                 atomic_inc(&mp->stats.xid_not_found);
-                goto out;
+                goto rel;
         }
         if (ep->rxid == FC_XID_UNKNOWN)
                 ep->rxid = ntohs(fh->fh_rx_id);
@@ -2181,6 +2211,8 @@ struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lport,
                 goto free_mempool;
         for_each_possible_cpu(cpu) {
                 pool = per_cpu_ptr(mp->pool, cpu);
+                pool->left = FC_XID_UNKNOWN;
+                pool->right = FC_XID_UNKNOWN;
                 spin_lock_init(&pool->lock);
                 INIT_LIST_HEAD(&pool->ex_list);
         }
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 2924363d142b..cdc06cda76e5 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -57,6 +57,9 @@ struct kmem_cache *scsi_pkt_cachep;
 #define FC_SRB_READ             (1 << 1)
 #define FC_SRB_WRITE            (1 << 0)
 
+/* constant added to e_d_tov timeout to get rec_tov value */
+#define REC_TOV_CONST           1
+
 /*
  * The SCp.ptr should be tested and set under the scsi_pkt_queue lock
  */
@@ -96,7 +99,7 @@ static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
 static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
 static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
-static void fc_fcp_recovery(struct fc_fcp_pkt *);
+static void fc_fcp_recovery(struct fc_fcp_pkt *, u8 code);
 static void fc_fcp_timeout(unsigned long);
 static void fc_fcp_rec(struct fc_fcp_pkt *);
 static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
@@ -120,14 +123,13 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
 #define FC_DATA_UNDRUN          7
 #define FC_ERROR                8
 #define FC_HRD_ERROR            9
-#define FC_CMD_RECOVERY         10
+#define FC_CRC_ERROR            10
+#define FC_TIMED_OUT            11
 
 /*
  * Error recovery timeout values.
  */
-#define FC_SCSI_ER_TIMEOUT      (10 * HZ)
 #define FC_SCSI_TM_TOV          (10 * HZ)
-#define FC_SCSI_REC_TOV         (2 * HZ)
 #define FC_HOST_RESET_TIMEOUT   (30 * HZ)
 #define FC_CAN_QUEUE_PERIOD     (60 * HZ)
 
@@ -438,6 +440,7 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         void *buf;
         struct scatterlist *sg;
         u32 nents;
+        u8 host_bcode = FC_COMPLETE;
 
         fh = fc_frame_header_get(fp);
         offset = ntohl(fh->fh_parm_offset);
@@ -446,13 +449,16 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         buf = fc_frame_payload_get(fp, 0);
 
         /*
-         * if this I/O is ddped then clear it
-         * and initiate recovery since data
-         * frames are expected to be placed
-         * directly in that case.
+         * if this I/O is ddped then clear it and initiate recovery since data
+         * frames are expected to be placed directly in that case.
+         *
+         * Indicate error to scsi-ml because something went wrong with the
+         * ddp handling to get us here.
          */
         if (fsp->xfer_ddp != FC_XID_UNKNOWN) {
                 fc_fcp_ddp_done(fsp);
+                FC_FCP_DBG(fsp, "DDP I/O in fc_fcp_recv_data set ERROR\n");
+                host_bcode = FC_ERROR;
                 goto err;
         }
         if (offset + len > fsp->data_len) {
@@ -462,6 +468,9 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                         goto crc_err;
                 FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
                            "data_len %x\n", len, offset, fsp->data_len);
+
+                /* Data is corrupted indicate scsi-ml should retry */
+                host_bcode = FC_DATA_OVRRUN;
                 goto err;
         }
         if (offset != fsp->xfer_len)
@@ -498,8 +507,10 @@ crc_err:
                          * If so, we need to retry the entire operation.
                          * Otherwise, ignore it.
                          */
-                        if (fsp->state & FC_SRB_DISCONTIG)
+                        if (fsp->state & FC_SRB_DISCONTIG) {
+                                host_bcode = FC_CRC_ERROR;
                                 goto err;
+                        }
                         return;
                 }
         }
@@ -517,7 +528,7 @@ crc_err:
                 fc_fcp_complete_locked(fsp);
         return;
 err:
-        fc_fcp_recovery(fsp);
+        fc_fcp_recovery(fsp, host_bcode);
 }
 
 /**
@@ -962,7 +973,13 @@ static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
                 }
                 lport->tt.exch_done(seq);
         }
-        fc_io_compl(fsp);
+        /*
+         * Some resets driven by SCSI are not I/Os and do not have
+         * SCSI commands associated with the requests. We should not
+         * call I/O completion if we do not have a SCSI command.
+         */
+        if (fsp->cmd)
+                fc_io_compl(fsp);
 }
 
 /**
@@ -1073,6 +1090,21 @@ static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
 }
 
 /**
+ * get_fsp_rec_tov() - Helper function to get REC_TOV
+ * @fsp: the FCP packet
+ */
+static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
+{
+        struct fc_rport *rport;
+        struct fc_rport_libfc_priv *rpriv;
+
+        rport = fsp->rport;
+        rpriv = rport->dd_data;
+
+        return rpriv->e_d_tov + REC_TOV_CONST;
+}
+
+/**
  * fc_fcp_cmd_send() - Send a FCP command
  * @lport: The local port to send the command on
  * @fsp:   The FCP packet the command is on
@@ -1089,6 +1121,7 @@ static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
         struct fc_rport_libfc_priv *rpriv;
         const size_t len = sizeof(fsp->cdb_cmd);
         int rc = 0;
+        unsigned int rec_tov;
 
         if (fc_fcp_lock_pkt(fsp))
                 return 0;
@@ -1119,10 +1152,13 @@ static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
         fsp->seq_ptr = seq;
         fc_fcp_pkt_hold(fsp);   /* hold for fc_fcp_pkt_destroy */
 
+        rec_tov = get_fsp_rec_tov(fsp);
+
         setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
-        fc_fcp_timer_set(fsp,
-                         (fsp->tgt_flags & FC_RP_FLAGS_REC_SUPPORTED) ?
-                         FC_SCSI_REC_TOV : FC_SCSI_ER_TIMEOUT);
+
+        if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
+                fc_fcp_timer_set(fsp, rec_tov);
+
 unlock:
         fc_fcp_unlock_pkt(fsp);
         return rc;
@@ -1197,13 +1233,16 @@ static void fc_lun_reset_send(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
         struct fc_lport *lport = fsp->lp;
+        unsigned int rec_tov;
+
         if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
                 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
                         return;
                 if (fc_fcp_lock_pkt(fsp))
                         return;
+                rec_tov = get_fsp_rec_tov(fsp);
                 setup_timer(&fsp->timer, fc_lun_reset_send, (unsigned long)fsp);
-                fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
+                fc_fcp_timer_set(fsp, rec_tov);
                 fc_fcp_unlock_pkt(fsp);
         }
 }
@@ -1282,27 +1321,27 @@ static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                  *
                  * scsi-eh will escalate for when either happens.
                  */
-                return;
+                goto out;
         }
 
         if (fc_fcp_lock_pkt(fsp))
-                return;
+                goto out;
 
         /*
          * raced with eh timeout handler.
          */
-        if (!fsp->seq_ptr || !fsp->wait_for_comp) {
-                spin_unlock_bh(&fsp->scsi_pkt_lock);
-                return;
-        }
+        if (!fsp->seq_ptr || !fsp->wait_for_comp)
+                goto out_unlock;
 
         fh = fc_frame_header_get(fp);
         if (fh->fh_type != FC_TYPE_BLS)
                 fc_fcp_resp(fsp, fp);
         fsp->seq_ptr = NULL;
         fsp->lp->tt.exch_done(seq);
-        fc_frame_free(fp);
+out_unlock:
         fc_fcp_unlock_pkt(fsp);
+out:
+        fc_frame_free(fp);
 }
 
 /**
@@ -1341,13 +1380,10 @@ static void fc_fcp_timeout(unsigned long data)
 
         if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
                 fc_fcp_rec(fsp);
-        else if (time_after_eq(fsp->last_pkt_time + (FC_SCSI_ER_TIMEOUT / 2),
-                               jiffies))
-                fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
         else if (fsp->state & FC_SRB_RCV_STATUS)
                 fc_fcp_complete_locked(fsp);
         else
-                fc_fcp_recovery(fsp);
+                fc_fcp_recovery(fsp, FC_TIMED_OUT);
         fsp->state &= ~FC_SRB_FCP_PROCESSING_TMO;
 unlock:
         fc_fcp_unlock_pkt(fsp);
@@ -1373,6 +1409,7 @@ static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
                 fc_fcp_complete_locked(fsp);
                 return;
         }
+
         fp = fc_fcp_frame_alloc(lport, sizeof(struct fc_els_rec));
         if (!fp)
                 goto retry;
@@ -1383,15 +1420,15 @@ static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
                        FC_FCTL_REQ, 0);
         if (lport->tt.elsct_send(lport, rport->port_id, fp, ELS_REC,
                                  fc_fcp_rec_resp, fsp,
-                                 jiffies_to_msecs(FC_SCSI_REC_TOV))) {
+                                 2 * lport->r_a_tov)) {
                 fc_fcp_pkt_hold(fsp);           /* hold while REC outstanding */
                 return;
         }
 retry:
         if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
-                fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
         else
-                fc_fcp_recovery(fsp);
+                fc_fcp_recovery(fsp, FC_TIMED_OUT);
 }
 
 /**
@@ -1445,7 +1482,6 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                          * making progress.
                          */
                         rpriv->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
-                        fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
                         break;
                 case ELS_RJT_LOGIC:
                 case ELS_RJT_UNAB:
@@ -1460,7 +1496,7 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                                 fc_fcp_retry_cmd(fsp);
                                 break;
                         }
-                        fc_fcp_recovery(fsp);
+                        fc_fcp_recovery(fsp, FC_ERROR);
                         break;
                 }
         } else if (opcode == ELS_LS_ACC) {
@@ -1498,12 +1534,12 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                         }
                         fc_fcp_srr(fsp, r_ctl, offset);
                 } else if (e_stat & ESB_ST_SEQ_INIT) {
-
+                        unsigned int rec_tov = get_fsp_rec_tov(fsp);
                         /*
                          * The remote port has the initiative, so just
                          * keep waiting for it to complete.
                          */
-                        fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
+                        fc_fcp_timer_set(fsp, rec_tov);
                 } else {
 
                         /*
@@ -1575,7 +1611,7 @@ static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
                         fc_fcp_rec(fsp);
                 else
-                        fc_fcp_recovery(fsp);
+                        fc_fcp_recovery(fsp, FC_ERROR);
                 break;
         }
         fc_fcp_unlock_pkt(fsp);
@@ -1587,9 +1623,9 @@ out:
  * fc_fcp_recovery() - Handler for fcp_pkt recovery
  * @fsp: The FCP pkt that needs to be aborted
  */
-static void fc_fcp_recovery(struct fc_fcp_pkt *fsp)
+static void fc_fcp_recovery(struct fc_fcp_pkt *fsp, u8 code)
 {
-        fsp->status_code = FC_CMD_RECOVERY;
+        fsp->status_code = code;
         fsp->cdb_status = 0;
         fsp->io_status = 0;
         /*
@@ -1616,6 +1652,7 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
         struct fcp_srr *srr;
         struct fc_frame *fp;
         u8 cdb_op;
+        unsigned int rec_tov;
 
         rport = fsp->rport;
         rpriv = rport->dd_data;
@@ -1640,8 +1677,9 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
                        rpriv->local_port->port_id, FC_TYPE_FCP,
                        FC_FCTL_REQ, 0);
 
+        rec_tov = get_fsp_rec_tov(fsp);
         seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp, NULL,
-                                      fsp, jiffies_to_msecs(FC_SCSI_REC_TOV));
+                                      fsp, jiffies_to_msecs(rec_tov));
         if (!seq)
                 goto retry;
 
@@ -1665,6 +1703,7 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
         struct fc_fcp_pkt *fsp = arg;
         struct fc_frame_header *fh;
+        unsigned int rec_tov;
 
         if (IS_ERR(fp)) {
                 fc_fcp_srr_error(fsp, fp);
@@ -1691,11 +1730,12 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         switch (fc_frame_payload_op(fp)) {
         case ELS_LS_ACC:
                 fsp->recov_retry = 0;
-                fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
+                rec_tov = get_fsp_rec_tov(fsp);
+                fc_fcp_timer_set(fsp, rec_tov);
                 break;
         case ELS_LS_RJT:
         default:
-                fc_fcp_recovery(fsp);
+                fc_fcp_recovery(fsp, FC_ERROR);
                 break;
         }
         fc_fcp_unlock_pkt(fsp);
@@ -1721,7 +1761,7 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
                         fc_fcp_rec(fsp);
                 else
-                        fc_fcp_recovery(fsp);
+                        fc_fcp_recovery(fsp, FC_TIMED_OUT);
                 break;
         case -FC_EX_CLOSED:                     /* e.g., link failure */
                 /* fall through */
@@ -1820,19 +1860,17 @@ static int fc_queuecommand_lck(struct scsi_cmnd *sc_cmd, void (*done)(struct scs
         if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
                 fsp->req_flags = FC_SRB_READ;
                 stats->InputRequests++;
-                stats->InputMegabytes = fsp->data_len;
+                stats->InputBytes += fsp->data_len;
         } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
                 fsp->req_flags = FC_SRB_WRITE;
                 stats->OutputRequests++;
-                stats->OutputMegabytes = fsp->data_len;
+                stats->OutputBytes += fsp->data_len;
         } else {
                 fsp->req_flags = 0;
                 stats->ControlRequests++;
         }
         put_cpu();
 
-        fsp->tgt_flags = rpriv->flags;
-
         init_timer(&fsp->timer);
         fsp->timer.data = (unsigned long)fsp;
 
@@ -1946,18 +1984,29 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
                 break;
         case FC_CMD_ABORTED:
                 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
-                           "due to FC_CMD_ABORTED\n");
+                          "due to FC_CMD_ABORTED\n");
                 sc_cmd->result = (DID_ERROR << 16) | fsp->io_status;
                 break;
-        case FC_CMD_RECOVERY:
-                sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
-                break;
         case FC_CMD_RESET:
+                FC_FCP_DBG(fsp, "Returning DID_RESET to scsi-ml "
+                           "due to FC_CMD_RESET\n");
                 sc_cmd->result = (DID_RESET << 16);
                 break;
         case FC_HRD_ERROR:
+                FC_FCP_DBG(fsp, "Returning DID_NO_CONNECT to scsi-ml "
+                           "due to FC_HRD_ERROR\n");
                 sc_cmd->result = (DID_NO_CONNECT << 16);
                 break;
+        case FC_CRC_ERROR:
+                FC_FCP_DBG(fsp, "Returning DID_PARITY to scsi-ml "
+                           "due to FC_CRC_ERROR\n");
+                sc_cmd->result = (DID_PARITY << 16);
+                break;
+        case FC_TIMED_OUT:
+                FC_FCP_DBG(fsp, "Returning DID_BUS_BUSY to scsi-ml "
+                           "due to FC_TIMED_OUT\n");
+                sc_cmd->result = (DID_BUS_BUSY << 16) | fsp->io_status;
+                break;
         default:
                 FC_FCP_DBG(fsp, "Returning DID_ERROR to scsi-ml "
                            "due to unknown error\n");
@@ -2004,7 +2053,7 @@ int fc_eh_abort(struct scsi_cmnd *sc_cmd)
         fsp = CMD_SP(sc_cmd);
         if (!fsp) {
                 /* command completed while scsi eh was setting up */
-                spin_unlock_irqrestore(lport->host->host_lock, flags);
+                spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
                 return SUCCESS;
         }
         /* grab a ref so the fsp and sc_cmd cannot be relased from under us */
diff --git a/drivers/scsi/libfc/fc_libfc.h b/drivers/scsi/libfc/fc_libfc.h
index 16d2162dda1f..eea0c3541b71 100644
--- a/drivers/scsi/libfc/fc_libfc.h
+++ b/drivers/scsi/libfc/fc_libfc.h
@@ -66,9 +66,21 @@ extern unsigned int fc_debug_logging;
 
 #define FC_FCP_DBG(pkt, fmt, args...)                                   \
         FC_CHECK_LOGGING(FC_FCP_LOGGING,                                \
-                         printk(KERN_INFO "host%u: fcp: %6.6x: " fmt,   \
+        {                                                               \
+                if ((pkt)->seq_ptr) {                                   \
+                        struct fc_exch *_ep = NULL;                     \
+                        _ep = fc_seq_exch((pkt)->seq_ptr);              \
+                        printk(KERN_INFO "host%u: fcp: %6.6x: "         \
+                                "xid %04x-%04x: " fmt,                  \
                                 (pkt)->lp->host->host_no,               \
-                                pkt->rport->port_id, ##args))
+                                (pkt)->rport->port_id,                  \
+                                (_ep)->oxid, (_ep)->rxid, ##args);      \
+                } else {                                                \
+                        printk(KERN_INFO "host%u: fcp: %6.6x: " fmt,    \
+                                (pkt)->lp->host->host_no,               \
+                                (pkt)->rport->port_id, ##args);         \
+                }                                                       \
+        })
 
 #define FC_EXCH_DBG(exch, fmt, args...)                                 \
         FC_CHECK_LOGGING(FC_EXCH_LOGGING,                               \
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 9be63edbf8fb..c5a10f94f845 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -288,6 +288,8 @@ struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
         struct fc_lport *lport = shost_priv(shost);
         struct timespec v0, v1;
         unsigned int cpu;
+        u64 fcp_in_bytes = 0;
+        u64 fcp_out_bytes = 0;
 
         fcoe_stats = &lport->host_stats;
         memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
@@ -310,10 +312,12 @@ struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
                 fcoe_stats->fcp_input_requests += stats->InputRequests;
                 fcoe_stats->fcp_output_requests += stats->OutputRequests;
                 fcoe_stats->fcp_control_requests += stats->ControlRequests;
-                fcoe_stats->fcp_input_megabytes += stats->InputMegabytes;
-                fcoe_stats->fcp_output_megabytes += stats->OutputMegabytes;
+                fcp_in_bytes += stats->InputBytes;
+                fcp_out_bytes += stats->OutputBytes;
                 fcoe_stats->link_failure_count += stats->LinkFailureCount;
         }
+        fcoe_stats->fcp_input_megabytes = div_u64(fcp_in_bytes, 1000000);
+        fcoe_stats->fcp_output_megabytes = div_u64(fcp_out_bytes, 1000000);
         fcoe_stats->lip_count = -1;
         fcoe_stats->nos_count = -1;
         fcoe_stats->loss_of_sync_count = -1;
@@ -1703,8 +1707,10 @@ static int fc_lport_els_request(struct fc_bsg_job *job,
         info->sg = job->reply_payload.sg_list;
 
         if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
-                                     NULL, info, tov))
+                                     NULL, info, tov)) {
+                kfree(info);
                 return -ECOMM;
+        }
         return 0;
 }
 
@@ -1762,8 +1768,10 @@ static int fc_lport_ct_request(struct fc_bsg_job *job,
         info->sg = job->reply_payload.sg_list;
 
         if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
-                                     NULL, info, tov))
+                                     NULL, info, tov)) {
+                kfree(info);
                 return -ECOMM;
+        }
         return 0;
 }
 
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index a84ef13ed74a..a7175adab32d 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -652,7 +652,7 @@ void fc_rport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
         FC_RPORT_DBG(rdata, "Received a FLOGI %s\n", fc_els_resp_type(fp));
 
         if (fp == ERR_PTR(-FC_EX_CLOSED))
-                return;
+                goto put;
 
         mutex_lock(&rdata->rp_mutex);
 
@@ -689,6 +689,7 @@ out:
         fc_frame_free(fp);
 err:
         mutex_unlock(&rdata->rp_mutex);
+put:
         kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
         return;
 bad:
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index c15fde808c33..da8b61543ee4 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -505,6 +505,7 @@ static void iscsi_free_task(struct iscsi_task *task)
         struct iscsi_conn *conn = task->conn;
         struct iscsi_session *session = conn->session;
         struct scsi_cmnd *sc = task->sc;
+        int oldstate = task->state;
 
         ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n",
                           task->itt, task->state, task->sc);
@@ -525,10 +526,10 @@ static void iscsi_free_task(struct iscsi_task *task)
                 /* SCSI eh reuses commands to verify us */
                 sc->SCp.ptr = NULL;
                 /*
-                 * queue command may call this to free the task, but
-                 * not have setup the sc callback
+                 * queue command may call this to free the task, so
+                 * it will decide how to return sc to scsi-ml.
                  */
-                if (sc->scsi_done)
+                if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ)
                         sc->scsi_done(sc);
         }
 }
@@ -539,11 +540,12 @@ void __iscsi_get_task(struct iscsi_task *task)
 }
 EXPORT_SYMBOL_GPL(__iscsi_get_task);
 
-static void __iscsi_put_task(struct iscsi_task *task)
+void __iscsi_put_task(struct iscsi_task *task)
 {
         if (atomic_dec_and_test(&task->refcount))
                 iscsi_free_task(task);
 }
+EXPORT_SYMBOL_GPL(__iscsi_put_task);
 
 void iscsi_put_task(struct iscsi_task *task)
 {
@@ -571,7 +573,8 @@ static void iscsi_complete_task(struct iscsi_task *task, int state)
                           task->itt, task->state, task->sc);
         if (task->state == ISCSI_TASK_COMPLETED ||
             task->state == ISCSI_TASK_ABRT_TMF ||
-            task->state == ISCSI_TASK_ABRT_SESS_RECOV)
+            task->state == ISCSI_TASK_ABRT_SESS_RECOV ||
+            task->state == ISCSI_TASK_REQUEUE_SCSIQ)
                 return;
         WARN_ON_ONCE(task->state == ISCSI_TASK_FREE);
         task->state = state;
@@ -1335,17 +1338,16 @@ void iscsi_session_failure(struct iscsi_session *session,
 {
         struct iscsi_conn *conn;
         struct device *dev;
-        unsigned long flags;
 
-        spin_lock_irqsave(&session->lock, flags);
+        spin_lock_bh(&session->lock);
         conn = session->leadconn;
         if (session->state == ISCSI_STATE_TERMINATE || !conn) {
-                spin_unlock_irqrestore(&session->lock, flags);
+                spin_unlock_bh(&session->lock);
                 return;
         }
 
         dev = get_device(&conn->cls_conn->dev);
-        spin_unlock_irqrestore(&session->lock, flags);
+        spin_unlock_bh(&session->lock);
         if (!dev)
                 return;
         /*
@@ -1364,17 +1366,16 @@ EXPORT_SYMBOL_GPL(iscsi_session_failure);
 void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
 {
         struct iscsi_session *session = conn->session;
-        unsigned long flags;
 
-        spin_lock_irqsave(&session->lock, flags);
+        spin_lock_bh(&session->lock);
         if (session->state == ISCSI_STATE_FAILED) {
-                spin_unlock_irqrestore(&session->lock, flags);
+                spin_unlock_bh(&session->lock);
                 return;
         }
 
         if (conn->stop_stage == 0)
                 session->state = ISCSI_STATE_FAILED;
-        spin_unlock_irqrestore(&session->lock, flags);
+        spin_unlock_bh(&session->lock);
 
         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
@@ -1599,27 +1600,23 @@ enum {
         FAILURE_SESSION_NOT_READY,
 };
 
-static int iscsi_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
+int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
 {
         struct iscsi_cls_session *cls_session;
-        struct Scsi_Host *host;
         struct iscsi_host *ihost;
         int reason = 0;
         struct iscsi_session *session;
         struct iscsi_conn *conn;
         struct iscsi_task *task = NULL;
 
-        sc->scsi_done = done;
         sc->result = 0;
         sc->SCp.ptr = NULL;
 
-        host = sc->device->host;
         ihost = shost_priv(host);
-        spin_unlock(host->host_lock);
 
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
-        spin_lock(&session->lock);
+        spin_lock_bh(&session->lock);
 
         reason = iscsi_session_chkready(cls_session);
         if (reason) {
@@ -1705,25 +1702,21 @@ static int iscsi_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi
         }
 
         session->queued_cmdsn++;
-        spin_unlock(&session->lock);
-        spin_lock(host->host_lock);
+        spin_unlock_bh(&session->lock);
         return 0;
 
 prepd_reject:
-        sc->scsi_done = NULL;
-        iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
+        iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
 reject:
-        spin_unlock(&session->lock);
+        spin_unlock_bh(&session->lock);
         ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
                           sc->cmnd[0], reason);
-        spin_lock(host->host_lock);
         return SCSI_MLQUEUE_TARGET_BUSY;
 
 prepd_fault:
-        sc->scsi_done = NULL;
-        iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
+        iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
 fault:
-        spin_unlock(&session->lock);
+        spin_unlock_bh(&session->lock);
         ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
                           sc->cmnd[0], reason);
         if (!scsi_bidi_cmnd(sc))
@@ -1732,12 +1725,9 @@ fault:
                 scsi_out(sc)->resid = scsi_out(sc)->length;
                 scsi_in(sc)->resid = scsi_in(sc)->length;
         }
-        done(sc);
-        spin_lock(host->host_lock);
+        sc->scsi_done(sc);
         return 0;
 }
-
-DEF_SCSI_QCMD(iscsi_queuecommand)
 EXPORT_SYMBOL_GPL(iscsi_queuecommand);
 
 int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
@@ -1795,9 +1785,9 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
                                       NULL, 0);
         if (!task) {
                 spin_unlock_bh(&session->lock);
+                iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n");
                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
                 spin_lock_bh(&session->lock);
-                ISCSI_DBG_EH(session, "tmf exec failure\n");
                 return -EPERM;
         }
         conn->tmfcmd_pdus_cnt++;
@@ -2202,7 +2192,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
                 goto success_unlocked;
         case TMF_TIMEDOUT:
                 spin_unlock_bh(&session->lock);
-                iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+                iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
                 goto failed_unlocked;
         case TMF_NOT_FOUND:
                 if (!sc->SCp.ptr) {
@@ -2289,7 +2279,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
                 break;
         case TMF_TIMEDOUT:
                 spin_unlock_bh(&session->lock);
-                iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+                iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
                 goto done;
         default:
                 conn->tmf_state = TMF_INITIAL;
@@ -2370,7 +2360,7 @@ failed:
          * we drop the lock here but the leadconn cannot be destoyed while
          * we are in the scsi eh
          */
-        iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+        iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
 
         ISCSI_DBG_EH(session, "wait for relogin\n");
         wait_event_interruptible(conn->ehwait,
@@ -2452,7 +2442,7 @@ int iscsi_eh_target_reset(struct scsi_cmnd *sc)
                 break;
         case TMF_TIMEDOUT:
                 spin_unlock_bh(&session->lock);
-                iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+                iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
                 goto done;
         default:
                 conn->tmf_state = TMF_INITIAL;
diff --git a/drivers/scsi/libsas/sas_port.c b/drivers/scsi/libsas/sas_port.c
index fe8b74c706d2..5257fdfe699a 100644
--- a/drivers/scsi/libsas/sas_port.c
+++ b/drivers/scsi/libsas/sas_port.c
@@ -28,6 +28,17 @@
 #include <scsi/scsi_transport_sas.h>
 #include "../scsi_sas_internal.h"
 
+static bool phy_is_wideport_member(struct asd_sas_port *port, struct asd_sas_phy *phy)
+{
+        struct sas_ha_struct *sas_ha = phy->ha;
+
+        if (memcmp(port->attached_sas_addr, phy->attached_sas_addr,
+                   SAS_ADDR_SIZE) != 0 || (sas_ha->strict_wide_ports &&
+             memcmp(port->sas_addr, phy->sas_addr, SAS_ADDR_SIZE) != 0))
+                return false;
+        return true;
+}
+
 /**
  * sas_form_port -- add this phy to a port
  * @phy: the phy of interest
@@ -45,8 +56,7 @@ static void sas_form_port(struct asd_sas_phy *phy)
         unsigned long flags;
 
         if (port) {
-                if (memcmp(port->attached_sas_addr, phy->attached_sas_addr,
-                           SAS_ADDR_SIZE) != 0)
+                if (!phy_is_wideport_member(port, phy))
                         sas_deform_port(phy);
                 else {
                         SAS_DPRINTK("%s: phy%d belongs to port%d already(%d)!\n",
@@ -62,9 +72,7 @@ static void sas_form_port(struct asd_sas_phy *phy)
                 port = sas_ha->sas_port[i];
                 spin_lock(&port->phy_list_lock);
                 if (*(u64 *) port->sas_addr &&
-                    memcmp(port->attached_sas_addr,
-                           phy->attached_sas_addr, SAS_ADDR_SIZE) == 0 &&
-                    port->num_phys > 0) {
+                    phy_is_wideport_member(port, phy) && port->num_phys > 0) {
                         /* wide port */
                         SAS_DPRINTK("phy%d matched wide port%d\n", phy->id,
                                     port->id);
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 196de40b906c..746dd3d7a092 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -464,12 +464,29 @@ struct unsol_rcv_ct_ctx {
 #define UNSOL_VALID     0x00000001
 };
 
+#define LPFC_USER_LINK_SPEED_AUTO       0       /* auto select (default)*/
+#define LPFC_USER_LINK_SPEED_1G         1       /* 1 Gigabaud */
+#define LPFC_USER_LINK_SPEED_2G         2       /* 2 Gigabaud */
+#define LPFC_USER_LINK_SPEED_4G         4       /* 4 Gigabaud */
+#define LPFC_USER_LINK_SPEED_8G         8       /* 8 Gigabaud */
+#define LPFC_USER_LINK_SPEED_10G        10      /* 10 Gigabaud */
+#define LPFC_USER_LINK_SPEED_16G        16      /* 16 Gigabaud */
+#define LPFC_USER_LINK_SPEED_MAX        LPFC_USER_LINK_SPEED_16G
+#define LPFC_USER_LINK_SPEED_BITMAP ((1 << LPFC_USER_LINK_SPEED_16G) | \
+                                     (1 << LPFC_USER_LINK_SPEED_10G) | \
+                                     (1 << LPFC_USER_LINK_SPEED_8G) | \
+                                     (1 << LPFC_USER_LINK_SPEED_4G) | \
+                                     (1 << LPFC_USER_LINK_SPEED_2G) | \
+                                     (1 << LPFC_USER_LINK_SPEED_1G) | \
+                                     (1 << LPFC_USER_LINK_SPEED_AUTO))
+#define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8, 10, 16"
+
 struct lpfc_hba {
         /* SCSI interface function jump table entries */
         int (*lpfc_new_scsi_buf)
                 (struct lpfc_vport *, int);
         struct lpfc_scsi_buf * (*lpfc_get_scsi_buf)
-                (struct lpfc_hba *);
+                (struct lpfc_hba *, struct lpfc_nodelist *);
         int (*lpfc_scsi_prep_dma_buf)
                 (struct lpfc_hba *, struct lpfc_scsi_buf *);
         void (*lpfc_scsi_unprep_dma_buf)
@@ -545,7 +562,7 @@ struct lpfc_hba {
         uint32_t hba_flag;      /* hba generic flags */
 #define HBA_ERATT_HANDLED       0x1 /* This flag is set when eratt handled */
 #define DEFER_ERATT             0x2 /* Deferred error attention in progress */
-#define HBA_FCOE_SUPPORT        0x4 /* HBA function supports FCOE */
+#define HBA_FCOE_MODE           0x4 /* HBA function in FCoE Mode */
 #define HBA_SP_QUEUE_EVT        0x8 /* Slow-path qevt posted to worker thread*/
 #define HBA_POST_RECEIVE_BUFFER 0x10 /* Rcv buffers need to be posted */
 #define FCP_XRI_ABORT_EVENT     0x20
@@ -557,6 +574,7 @@ struct lpfc_hba {
 #define HBA_FIP_SUPPORT         0x800 /* FIP support in HBA */
 #define HBA_AER_ENABLED         0x1000 /* AER enabled with HBA */
 #define HBA_DEVLOSS_TMO         0x2000 /* HBA in devloss timeout */
+#define HBA_RRQ_ACTIVE          0x4000 /* process the rrq active list */
         uint32_t fcp_ring_in_use; /* When polling test if intr-hndlr active*/
         struct lpfc_dmabuf slim2p;
 
@@ -606,6 +624,7 @@ struct lpfc_hba {
         /* HBA Config Parameters */
         uint32_t cfg_ack0;
         uint32_t cfg_enable_npiv;
+        uint32_t cfg_enable_rrq;
         uint32_t cfg_topology;
         uint32_t cfg_link_speed;
         uint32_t cfg_cr_delay;
@@ -716,6 +735,7 @@ struct lpfc_hba {
         uint32_t total_scsi_bufs;
         struct list_head lpfc_iocb_list;
         uint32_t total_iocbq_bufs;
+        struct list_head active_rrq_list;
         spinlock_t hbalock;
 
         /* pci_mem_pools */
@@ -728,6 +748,7 @@ struct lpfc_hba {
 
         mempool_t *mbox_mem_pool;
         mempool_t *nlp_mem_pool;
+        mempool_t *rrq_pool;
 
         struct fc_host_statistics link_stats;
         enum intr_type_t intr_type;
@@ -784,6 +805,7 @@ struct lpfc_hba {
         unsigned long skipped_hb;
         struct timer_list hb_tmofunc;
         uint8_t hb_outstanding;
+        struct timer_list rrq_tmr;
         enum hba_temp_state over_temp_state;
         /* ndlp reference management */
         spinlock_t ndlp_lock;
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index c1cbec01345d..c06491b5862f 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -52,10 +52,6 @@
 #define LPFC_MIN_DEVLOSS_TMO 1
 #define LPFC_MAX_DEVLOSS_TMO 255
 
-#define LPFC_MAX_LINK_SPEED 8
-#define LPFC_LINK_SPEED_BITMAP 0x00000117
-#define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8"
-
 /**
  * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
  * @incr: integer to convert.
@@ -463,7 +459,7 @@ lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
                 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
                         len += snprintf(buf + len, PAGE_SIZE-len,
                                         "   Menlo Maint Mode\n");
-                else if (phba->fc_topology == TOPOLOGY_LOOP) {
+                else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                         if (vport->fc_flag & FC_PUBLIC_LOOP)
                                 len += snprintf(buf + len, PAGE_SIZE-len,
                                                 "   Public Loop\n");
@@ -1981,6 +1977,13 @@ lpfc_param_show(enable_npiv);
 lpfc_param_init(enable_npiv, 1, 0, 1);
 static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);
 
+int lpfc_enable_rrq;
+module_param(lpfc_enable_rrq, int, 0);
+MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
+lpfc_param_show(enable_rrq);
+lpfc_param_init(enable_rrq, 0, 0, 1);
+static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL);
+
 /*
 # lpfc_suppress_link_up:  Bring link up at initialization
 #            0x0  = bring link up (issue MBX_INIT_LINK)
@@ -2837,14 +2840,8 @@ static struct bin_attribute sysfs_drvr_stat_data_attr = {
 /*
 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
 # connection.
-#       0  = auto select (default)
-#       1  = 1 Gigabaud
-#       2  = 2 Gigabaud
-#       4  = 4 Gigabaud
-#       8  = 8 Gigabaud
-# Value range is [0,8]. Default value is 0.
+# Value range is [0,16]. Default value is 0.
 */
-
 /**
  * lpfc_link_speed_set - Set the adapters link speed
  * @phba: lpfc_hba pointer.
@@ -2869,7 +2866,7 @@ lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
-        int val = 0;
+        int val = LPFC_USER_LINK_SPEED_AUTO;
         int nolip = 0;
         const char *val_buf = buf;
         int err;
@@ -2885,15 +2882,20 @@ lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
         if (sscanf(val_buf, "%i", &val) != 1)
                 return -EINVAL;
 
-        if (((val == LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
-                ((val == LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
-                ((val == LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
-                ((val == LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
-                ((val == LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)))
+        if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
+            ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
+            ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
+            ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
+            ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
+            ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb))) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2879 lpfc_link_speed attribute cannot be set "
+                                "to %d. Speed is not supported by this port.\n",
+                                val);
                 return -EINVAL;
-
-        if ((val >= 0 && val <= 8)
-                && (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
+        }
+        if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
+            (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
                 prev_val = phba->cfg_link_speed;
                 phba->cfg_link_speed = val;
                 if (nolip)
@@ -2906,11 +2908,9 @@ lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
                 } else
                         return strlen(buf);
         }
-
         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                "%d:0469 lpfc_link_speed attribute cannot be set to %d, "
-                "allowed range is [0, 8]\n",
-                phba->brd_no, val);
+                "0469 lpfc_link_speed attribute cannot be set to %d, "
+                "allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val);
         return -EINVAL;
 }
 
@@ -2938,8 +2938,8 @@ lpfc_param_show(link_speed)
 static int
 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
 {
-        if ((val >= 0 && val <= LPFC_MAX_LINK_SPEED)
-                && (LPFC_LINK_SPEED_BITMAP & (1 << val))) {
+        if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
+            (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
                 phba->cfg_link_speed = val;
                 return 0;
         }
@@ -2947,12 +2947,12 @@ lpfc_link_speed_init(struct lpfc_hba *phba, int val)
                         "0405 lpfc_link_speed attribute cannot "
                         "be set to %d, allowed values are "
                         "["LPFC_LINK_SPEED_STRING"]\n", val);
-        phba->cfg_link_speed = 0;
+        phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
         return -EINVAL;
 }
 
 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
-                lpfc_link_speed_show, lpfc_link_speed_store);
+                   lpfc_link_speed_show, lpfc_link_speed_store);
 
 /*
 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
@@ -3305,12 +3305,12 @@ LPFC_ATTR_R(fcp_eq_count, LPFC_FP_EQN_DEF, LPFC_FP_EQN_MIN, LPFC_FP_EQN_MAX,
 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
 
 /*
-# lpfc_enable_hba_heartbeat: Enable HBA heartbeat timer..
+# lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
 #       0  = HBA Heartbeat disabled
 #       1  = HBA Heartbeat enabled (default)
 # Value range is [0,1]. Default value is 1.
 */
-LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
+LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
 
 /*
 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
@@ -3401,6 +3401,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_fdmi_on,
         &dev_attr_lpfc_max_luns,
         &dev_attr_lpfc_enable_npiv,
+        &dev_attr_lpfc_enable_rrq,
         &dev_attr_nport_evt_cnt,
         &dev_attr_board_mode,
         &dev_attr_max_vpi,
@@ -3798,8 +3799,7 @@ sysfs_mbox_read(struct file *filp, struct kobject *kobj,
                         }
                         break;
                 case MBX_READ_SPARM64:
-                case MBX_READ_LA:
-                case MBX_READ_LA64:
+                case MBX_READ_TOPOLOGY:
                 case MBX_REG_LOGIN:
                 case MBX_REG_LOGIN64:
                 case MBX_CONFIG_PORT:
@@ -3989,7 +3989,7 @@ lpfc_get_host_port_type(struct Scsi_Host *shost)
         if (vport->port_type == LPFC_NPIV_PORT) {
                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
         } else if (lpfc_is_link_up(phba)) {
-                if (phba->fc_topology == TOPOLOGY_LOOP) {
+                if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                         if (vport->fc_flag & FC_PUBLIC_LOOP)
                                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
                         else
@@ -4058,23 +4058,26 @@ lpfc_get_host_speed(struct Scsi_Host *shost)
 
         if (lpfc_is_link_up(phba)) {
                 switch(phba->fc_linkspeed) {
-                        case LA_1GHZ_LINK:
-                                fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
+                case LPFC_LINK_SPEED_1GHZ:
+                        fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
                         break;
-                        case LA_2GHZ_LINK:
-                                fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
+                case LPFC_LINK_SPEED_2GHZ:
+                        fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
                         break;
-                        case LA_4GHZ_LINK:
-                                fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
+                case LPFC_LINK_SPEED_4GHZ:
+                        fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
                         break;
-                        case LA_8GHZ_LINK:
-                                fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
+                case LPFC_LINK_SPEED_8GHZ:
+                        fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
                         break;
-                        case LA_10GHZ_LINK:
-                                fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
+                case LPFC_LINK_SPEED_10GHZ:
+                        fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
                         break;
-                        default:
-                                fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
+                case LPFC_LINK_SPEED_16GHZ:
+                        fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
+                        break;
+                default:
+                        fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                         break;
                 }
         } else
@@ -4097,7 +4100,7 @@ lpfc_get_host_fabric_name (struct Scsi_Host *shost)
         spin_lock_irq(shost->host_lock);
 
         if ((vport->fc_flag & FC_FABRIC) ||
-            ((phba->fc_topology == TOPOLOGY_LOOP) &&
+            ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
              (vport->fc_flag & FC_PUBLIC_LOOP)))
                 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
         else
@@ -4208,11 +4211,11 @@ lpfc_get_stats(struct Scsi_Host *shost)
         hs->invalid_crc_count -= lso->invalid_crc_count;
         hs->error_frames -= lso->error_frames;
 
-        if (phba->hba_flag & HBA_FCOE_SUPPORT) {
+        if (phba->hba_flag & HBA_FCOE_MODE) {
                 hs->lip_count = -1;
                 hs->nos_count = (phba->link_events >> 1);
                 hs->nos_count -= lso->link_events;
-        } else if (phba->fc_topology == TOPOLOGY_LOOP) {
+        } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                 hs->lip_count = (phba->fc_eventTag >> 1);
                 hs->lip_count -= lso->link_events;
                 hs->nos_count = -1;
@@ -4303,7 +4306,7 @@ lpfc_reset_stats(struct Scsi_Host *shost)
         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
         lso->error_frames = pmb->un.varRdLnk.crcCnt;
-        if (phba->hba_flag & HBA_FCOE_SUPPORT)
+        if (phba->hba_flag & HBA_FCOE_MODE)
                 lso->link_events = (phba->link_events >> 1);
         else
                 lso->link_events = (phba->fc_eventTag >> 1);
@@ -4615,6 +4618,7 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
         lpfc_link_speed_init(phba, lpfc_link_speed);
         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
+        lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
         lpfc_use_msi_init(phba, lpfc_use_msi);
         lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
         lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count);
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 7260c3af555a..0dd43bb91618 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -162,7 +162,6 @@ lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
                         struct lpfc_iocbq *cmdiocbq,
                         struct lpfc_iocbq *rspiocbq)
 {
-        unsigned long iflags;
         struct bsg_job_data *dd_data;
         struct fc_bsg_job *job;
         IOCB_t *rsp;
@@ -173,9 +172,10 @@ lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
         int rc = 0;
 
         spin_lock_irqsave(&phba->ct_ev_lock, flags);
-        dd_data = cmdiocbq->context1;
+        dd_data = cmdiocbq->context2;
         if (!dd_data) {
                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
                 return;
         }
 
@@ -183,17 +183,9 @@ lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
         job = iocb->set_job;
         job->dd_data = NULL; /* so timeout handler does not reply */
 
-        spin_lock_irqsave(&phba->hbalock, iflags);
-        cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
-        if (cmdiocbq->context2 && rspiocbq)
-                memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
-                       &rspiocbq->iocb, sizeof(IOCB_t));
-        spin_unlock_irqrestore(&phba->hbalock, iflags);
-
         bmp = iocb->bmp;
-        rspiocbq = iocb->rspiocbq;
         rsp = &rspiocbq->iocb;
-        ndlp = iocb->ndlp;
+        ndlp = cmdiocbq->context1;
 
         pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
                      job->request_payload.sg_cnt, DMA_TO_DEVICE);
@@ -220,7 +212,6 @@ lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
                         rsp->un.genreq64.bdl.bdeSize;
 
         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
-        lpfc_sli_release_iocbq(phba, rspiocbq);
         lpfc_sli_release_iocbq(phba, cmdiocbq);
         lpfc_nlp_put(ndlp);
         kfree(bmp);
@@ -247,9 +238,7 @@ lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
         struct ulp_bde64 *bpl = NULL;
         uint32_t timeout;
         struct lpfc_iocbq *cmdiocbq = NULL;
-        struct lpfc_iocbq *rspiocbq = NULL;
         IOCB_t *cmd;
-        IOCB_t *rsp;
         struct lpfc_dmabuf *bmp = NULL;
         int request_nseg;
         int reply_nseg;
@@ -296,17 +285,10 @@ lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
         }
 
         cmd = &cmdiocbq->iocb;
-        rspiocbq = lpfc_sli_get_iocbq(phba);
-        if (!rspiocbq) {
-                rc = -ENOMEM;
-                goto free_cmdiocbq;
-        }
-
-        rsp = &rspiocbq->iocb;
         bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
         if (!bmp->virt) {
                 rc = -ENOMEM;
-                goto free_rspiocbq;
+                goto free_cmdiocbq;
         }
 
         INIT_LIST_HEAD(&bmp->list);
@@ -358,14 +340,12 @@ lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
         cmd->ulpTimeout = timeout;
 
         cmdiocbq->iocb_cmpl = lpfc_bsg_send_mgmt_cmd_cmp;
-        cmdiocbq->context1 = dd_data;
-        cmdiocbq->context2 = rspiocbq;
+        cmdiocbq->context1 = ndlp;
+        cmdiocbq->context2 = dd_data;
         dd_data->type = TYPE_IOCB;
         dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
-        dd_data->context_un.iocb.rspiocbq = rspiocbq;
         dd_data->context_un.iocb.set_job = job;
         dd_data->context_un.iocb.bmp = bmp;
-        dd_data->context_un.iocb.ndlp = ndlp;
 
         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
                 creg_val = readl(phba->HCregaddr);
@@ -391,8 +371,6 @@ lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
 
         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
 
-free_rspiocbq:
-        lpfc_sli_release_iocbq(phba, rspiocbq);
 free_cmdiocbq:
         lpfc_sli_release_iocbq(phba, cmdiocbq);
 free_bmp:
@@ -1220,7 +1198,7 @@ lpfc_issue_ct_rsp_cmp(struct lpfc_hba *phba,
         int rc = 0;
 
         spin_lock_irqsave(&phba->ct_ev_lock, flags);
-        dd_data = cmdiocbq->context1;
+        dd_data = cmdiocbq->context2;
         /* normal completion and timeout crossed paths, already done */
         if (!dd_data) {
                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
@@ -1369,8 +1347,8 @@ lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
         ctiocb->context3 = bmp;
 
         ctiocb->iocb_cmpl = lpfc_issue_ct_rsp_cmp;
-        ctiocb->context1 = dd_data;
-        ctiocb->context2 = NULL;
+        ctiocb->context2 = dd_data;
+        ctiocb->context1 = ndlp;
         dd_data->type = TYPE_IOCB;
         dd_data->context_un.iocb.cmdiocbq = ctiocb;
         dd_data->context_un.iocb.rspiocbq = NULL;
@@ -1641,7 +1619,7 @@ job_error:
  * This function obtains a remote port login id so the diag loopback test
  * can send and receive its own unsolicited CT command.
  **/
-static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t * rpi)
+static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t *rpi)
 {
         LPFC_MBOXQ_t *mbox;
         struct lpfc_dmabuf *dmabuff;
@@ -1651,10 +1629,14 @@ static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t * rpi)
         if (!mbox)
                 return -ENOMEM;
 
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                *rpi = lpfc_sli4_alloc_rpi(phba);
         status = lpfc_reg_rpi(phba, 0, phba->pport->fc_myDID,
-                                (uint8_t *)&phba->pport->fc_sparam, mbox, 0);
+                              (uint8_t *)&phba->pport->fc_sparam, mbox, *rpi);
         if (status) {
                 mempool_free(mbox, phba->mbox_mem_pool);
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        lpfc_sli4_free_rpi(phba, *rpi);
                 return -ENOMEM;
         }
 
@@ -1668,6 +1650,8 @@ static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t * rpi)
                 kfree(dmabuff);
                 if (status != MBX_TIMEOUT)
                         mempool_free(mbox, phba->mbox_mem_pool);
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        lpfc_sli4_free_rpi(phba, *rpi);
                 return -ENODEV;
         }
 
@@ -1704,8 +1688,9 @@ static int lpfcdiag_loop_self_unreg(struct lpfc_hba *phba, uint16_t rpi)
                         mempool_free(mbox, phba->mbox_mem_pool);
                 return -EIO;
         }
-
         mempool_free(mbox, phba->mbox_mem_pool);
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                lpfc_sli4_free_rpi(phba, rpi);
         return 0;
 }
 
@@ -2102,7 +2087,7 @@ lpfc_bsg_diag_test(struct fc_bsg_job *job)
         uint32_t size;
         uint32_t full_size;
         size_t segment_len = 0, segment_offset = 0, current_offset = 0;
-        uint16_t rpi;
+        uint16_t rpi = 0;
         struct lpfc_iocbq *cmdiocbq, *rspiocbq;
         IOCB_t *cmd, *rsp;
         struct lpfc_sli_ct_request *ctreq;
@@ -2162,7 +2147,7 @@ lpfc_bsg_diag_test(struct fc_bsg_job *job)
                 goto loopback_test_exit;
         }
 
-        if (size >= BUF_SZ_4K) {
+        if (full_size >= BUF_SZ_4K) {
                 /*
                  * Allocate memory for ioctl data. If buffer is bigger than 64k,
                  * then we allocate 64k and re-use that buffer over and over to
@@ -2171,7 +2156,7 @@ lpfc_bsg_diag_test(struct fc_bsg_job *job)
                  * problem with GET_FCPTARGETMAPPING...
                  */
                 if (size <= (64 * 1024))
-                        total_mem = size;
+                        total_mem = full_size;
                 else
                         total_mem = 64 * 1024;
         } else
@@ -2189,7 +2174,6 @@ lpfc_bsg_diag_test(struct fc_bsg_job *job)
         sg_copy_to_buffer(job->request_payload.sg_list,
                                 job->request_payload.sg_cnt,
                                 ptr, size);
-
         rc = lpfcdiag_loop_self_reg(phba, &rpi);
         if (rc)
                 goto loopback_test_exit;
@@ -2601,12 +2585,11 @@ static int lpfc_bsg_check_cmd_access(struct lpfc_hba *phba,
                         phba->wait_4_mlo_maint_flg = 1;
                 } else if (mb->un.varWords[0] == SETVAR_MLORST) {
                         phba->link_flag &= ~LS_LOOPBACK_MODE;
-                        phba->fc_topology = TOPOLOGY_PT_PT;
+                        phba->fc_topology = LPFC_TOPOLOGY_PT_PT;
                 }
                 break;
         case MBX_READ_SPARM64:
-        case MBX_READ_LA:
-        case MBX_READ_LA64:
+        case MBX_READ_TOPOLOGY:
         case MBX_REG_LOGIN:
         case MBX_REG_LOGIN64:
         case MBX_CONFIG_PORT:
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index a5f5a093a8a4..17fde522c84a 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -31,7 +31,7 @@ void lpfc_read_nv(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_config_async(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t);
 
 void lpfc_heart_beat(struct lpfc_hba *, LPFC_MBOXQ_t *);
-int lpfc_read_la(struct lpfc_hba *, LPFC_MBOXQ_t *, struct lpfc_dmabuf *);
+int lpfc_read_topology(struct lpfc_hba *, LPFC_MBOXQ_t *, struct lpfc_dmabuf *);
 void lpfc_clear_la(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_issue_clear_la(struct lpfc_hba *, struct lpfc_vport *);
 void lpfc_config_link(struct lpfc_hba *, LPFC_MBOXQ_t *);
@@ -40,7 +40,7 @@ int lpfc_read_sparam(struct lpfc_hba *, LPFC_MBOXQ_t *, int);
 void lpfc_read_config(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_read_lnk_stat(struct lpfc_hba *, LPFC_MBOXQ_t *);
 int lpfc_reg_rpi(struct lpfc_hba *, uint16_t, uint32_t, uint8_t *,
-                 LPFC_MBOXQ_t *, uint32_t);
+                 LPFC_MBOXQ_t *, uint16_t);
 void lpfc_set_var(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t, uint32_t);
 void lpfc_unreg_login(struct lpfc_hba *, uint16_t, uint32_t, LPFC_MBOXQ_t *);
 void lpfc_unreg_did(struct lpfc_hba *, uint16_t, uint32_t, LPFC_MBOXQ_t *);
@@ -64,7 +64,7 @@ void lpfc_cleanup_pending_mbox(struct lpfc_vport *);
 int lpfc_linkdown(struct lpfc_hba *);
 void lpfc_linkdown_port(struct lpfc_vport *);
 void lpfc_port_link_failure(struct lpfc_vport *);
-void lpfc_mbx_cmpl_read_la(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_mbx_cmpl_read_topology(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_init_vpi_cmpl(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_cancel_all_vport_retry_delay_timer(struct lpfc_hba *);
 void lpfc_retry_pport_discovery(struct lpfc_hba *);
@@ -121,6 +121,7 @@ void lpfc_end_rscn(struct lpfc_vport *);
 int lpfc_els_chk_latt(struct lpfc_vport *);
 int lpfc_els_abort_flogi(struct lpfc_hba *);
 int lpfc_initial_flogi(struct lpfc_vport *);
+void lpfc_issue_init_vfi(struct lpfc_vport *);
 int lpfc_initial_fdisc(struct lpfc_vport *);
 int lpfc_issue_els_plogi(struct lpfc_vport *, uint32_t, uint8_t);
 int lpfc_issue_els_prli(struct lpfc_vport *, struct lpfc_nodelist *, uint8_t);
@@ -415,5 +416,13 @@ struct lpfc_iocbq *lpfc_sli_ringtx_get(struct lpfc_hba *,
 int __lpfc_sli_issue_iocb(struct lpfc_hba *, uint32_t,
         struct lpfc_iocbq *, uint32_t);
 uint32_t lpfc_drain_txq(struct lpfc_hba *);
-
-
+void lpfc_clr_rrq_active(struct lpfc_hba *, uint16_t, struct lpfc_node_rrq *);
+int lpfc_test_rrq_active(struct lpfc_hba *, struct lpfc_nodelist *, uint16_t);
+void lpfc_handle_rrq_active(struct lpfc_hba *);
+int lpfc_send_rrq(struct lpfc_hba *, struct lpfc_node_rrq *);
+int lpfc_set_rrq_active(struct lpfc_hba *, struct lpfc_nodelist *,
+        uint16_t, uint16_t, uint16_t);
+void lpfc_cleanup_wt_rrqs(struct lpfc_hba *);
+void lpfc_cleanup_vports_rrqs(struct lpfc_vport *);
+struct lpfc_node_rrq *lpfc_get_active_rrq(struct lpfc_vport *, uint16_t,
+        uint32_t);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 463b74902ac4..c004fa9a681e 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -48,14 +48,14 @@
 #include "lpfc_vport.h"
 #include "lpfc_debugfs.h"
 
-#define HBA_PORTSPEED_UNKNOWN               0   /* Unknown - transceiver
-                                                 * incapable of reporting */
-#define HBA_PORTSPEED_1GBIT                 1   /* 1 GBit/sec */
-#define HBA_PORTSPEED_2GBIT                 2   /* 2 GBit/sec */
-#define HBA_PORTSPEED_4GBIT                 8   /* 4 GBit/sec */
-#define HBA_PORTSPEED_8GBIT                16   /* 8 GBit/sec */
-#define HBA_PORTSPEED_10GBIT                4   /* 10 GBit/sec */
-#define HBA_PORTSPEED_NOT_NEGOTIATED        5   /* Speed not established */
+/* FDMI Port Speed definitions */
+#define HBA_PORTSPEED_1GBIT             0x0001  /* 1 GBit/sec */
+#define HBA_PORTSPEED_2GBIT             0x0002  /* 2 GBit/sec */
+#define HBA_PORTSPEED_4GBIT             0x0008  /* 4 GBit/sec */
+#define HBA_PORTSPEED_10GBIT            0x0004  /* 10 GBit/sec */
+#define HBA_PORTSPEED_8GBIT             0x0010  /* 8 GBit/sec */
+#define HBA_PORTSPEED_16GBIT            0x0020  /* 16 GBit/sec */
+#define HBA_PORTSPEED_UNKNOWN           0x0800  /* Unknown */
 
 #define FOURBYTES       4
 
@@ -1593,8 +1593,10 @@ lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, int cmdcode)
                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
 
                         ae->un.SupportSpeed = 0;
+                        if (phba->lmt & LMT_16Gb)
+                                ae->un.SupportSpeed |= HBA_PORTSPEED_16GBIT;
                         if (phba->lmt & LMT_10Gb)
-                                ae->un.SupportSpeed = HBA_PORTSPEED_10GBIT;
+                                ae->un.SupportSpeed |= HBA_PORTSPEED_10GBIT;
                         if (phba->lmt & LMT_8Gb)
                                 ae->un.SupportSpeed |= HBA_PORTSPEED_8GBIT;
                         if (phba->lmt & LMT_4Gb)
@@ -1612,24 +1614,26 @@ lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, int cmdcode)
                         ae->ad.bits.AttrType = be16_to_cpu(PORT_SPEED);
                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
                         switch(phba->fc_linkspeed) {
-                                case LA_1GHZ_LINK:
-                                        ae->un.PortSpeed = HBA_PORTSPEED_1GBIT;
+                        case LPFC_LINK_SPEED_1GHZ:
+                                ae->un.PortSpeed = HBA_PORTSPEED_1GBIT;
                                 break;
-                                case LA_2GHZ_LINK:
-                                        ae->un.PortSpeed = HBA_PORTSPEED_2GBIT;
+                        case LPFC_LINK_SPEED_2GHZ:
+                                ae->un.PortSpeed = HBA_PORTSPEED_2GBIT;
                                 break;
-                                case LA_4GHZ_LINK:
-                                        ae->un.PortSpeed = HBA_PORTSPEED_4GBIT;
+                        case LPFC_LINK_SPEED_4GHZ:
+                                ae->un.PortSpeed = HBA_PORTSPEED_4GBIT;
                                 break;
-                                case LA_8GHZ_LINK:
-                                        ae->un.PortSpeed = HBA_PORTSPEED_8GBIT;
+                        case LPFC_LINK_SPEED_8GHZ:
+                                ae->un.PortSpeed = HBA_PORTSPEED_8GBIT;
                                 break;
-                                case LA_10GHZ_LINK:
-                                        ae->un.PortSpeed = HBA_PORTSPEED_10GBIT;
+                        case LPFC_LINK_SPEED_10GHZ:
+                                ae->un.PortSpeed = HBA_PORTSPEED_10GBIT;
                                 break;
-                                default:
-                                        ae->un.PortSpeed =
-                                                HBA_PORTSPEED_UNKNOWN;
+                        case LPFC_LINK_SPEED_16GHZ:
+                                ae->un.PortSpeed = HBA_PORTSPEED_16GBIT;
+                                break;
+                        default:
+                                ae->un.PortSpeed = HBA_PORTSPEED_UNKNOWN;
                                 break;
                         }
                         pab->ab.EntryCnt++;
diff --git a/drivers/scsi/lpfc/lpfc_disc.h b/drivers/scsi/lpfc/lpfc_disc.h
index 7cae69de36f7..1d84b63fccad 100644
--- a/drivers/scsi/lpfc/lpfc_disc.h
+++ b/drivers/scsi/lpfc/lpfc_disc.h
@@ -68,6 +68,12 @@ struct lpfc_fast_path_event {
         } un;
 };
 
+#define LPFC_SLI4_MAX_XRI       1024    /* Used to make the ndlp's xri_bitmap */
+#define XRI_BITMAP_ULONGS (LPFC_SLI4_MAX_XRI / BITS_PER_LONG)
+struct lpfc_node_rrqs {
+        unsigned long xri_bitmap[XRI_BITMAP_ULONGS];
+};
+
 struct lpfc_nodelist {
         struct list_head nlp_listp;
         struct lpfc_name nlp_portname;
@@ -110,8 +116,19 @@ struct lpfc_nodelist {
         atomic_t cmd_pending;
         uint32_t cmd_qdepth;
         unsigned long last_change_time;
+        struct lpfc_node_rrqs active_rrqs;
         struct lpfc_scsicmd_bkt *lat_data;      /* Latency data */
 };
+struct lpfc_node_rrq {
+        struct list_head list;
+        uint16_t xritag;
+        uint16_t send_rrq;
+        uint16_t rxid;
+        uint32_t         nlp_DID;               /* FC D_ID of entry */
+        struct lpfc_vport *vport;
+        struct lpfc_nodelist *ndlp;
+        unsigned long rrq_stop_time;
+};
 
 /* Defines for nlp_flag (uint32) */
 #define NLP_IGNR_REG_CMPL  0x00000001 /* Rcvd rscn before we cmpl reg login */
@@ -136,7 +153,7 @@ struct lpfc_nodelist {
 #define NLP_NODEV_REMOVE   0x08000000   /* Defer removal till discovery ends */
 #define NLP_TARGET_REMOVE  0x10000000   /* Target remove in process */
 #define NLP_SC_REQ         0x20000000   /* Target requires authentication */
-#define NLP_RPI_VALID      0x80000000   /* nlp_rpi is valid */
+#define NLP_RPI_REGISTERED 0x80000000   /* nlp_rpi is valid */
 
 /* ndlp usage management macros */
 #define NLP_CHK_NODE_ACT(ndlp)          (((ndlp)->nlp_usg_map \
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 884f4d321799..c62d567cc845 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -375,7 +375,8 @@ lpfc_issue_fabric_reglogin(struct lpfc_vport *vport)
                 err = 4;
                 goto fail;
         }
-        rc = lpfc_reg_rpi(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox, 0);
+        rc = lpfc_reg_rpi(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox,
+                          ndlp->nlp_rpi);
         if (rc) {
                 err = 5;
                 goto fail_free_mbox;
@@ -523,7 +524,7 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         phba->fc_edtovResol = sp->cmn.edtovResolution;
         phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
 
-        if (phba->fc_topology == TOPOLOGY_LOOP) {
+        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                 spin_lock_irq(shost->host_lock);
                 vport->fc_flag |= FC_PUBLIC_LOOP;
                 spin_unlock_irq(shost->host_lock);
@@ -832,6 +833,12 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
                         goto out;
 
+                /* FLOGI failure */
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "0100 FLOGI failure Status:x%x/x%x TMO:x%x\n",
+                                 irsp->ulpStatus, irsp->un.ulpWord[4],
+                                 irsp->ulpTimeout);
+
                 /* FLOGI failed, so there is no fabric */
                 spin_lock_irq(shost->host_lock);
                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
@@ -843,13 +850,16 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                  */
                 if (phba->alpa_map[0] == 0) {
                         vport->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
+                        if ((phba->sli_rev == LPFC_SLI_REV4) &&
+                            (!(vport->fc_flag & FC_VFI_REGISTERED) ||
+                             (vport->fc_prevDID != vport->fc_myDID))) {
+                                if (vport->fc_flag & FC_VFI_REGISTERED)
+                                        lpfc_sli4_unreg_all_rpis(vport);
+                                lpfc_issue_reg_vfi(vport);
+                                lpfc_nlp_put(ndlp);
+                                goto out;
+                        }
                 }
-
-                /* FLOGI failure */
-                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
-                                 "0100 FLOGI failure Status:x%x/x%x TMO:x%x\n",
-                                 irsp->ulpStatus, irsp->un.ulpWord[4],
-                                 irsp->ulpTimeout);
                 goto flogifail;
         }
         spin_lock_irq(shost->host_lock);
@@ -879,7 +889,7 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                  */
                 if (sp->cmn.fPort)
                         rc = lpfc_cmpl_els_flogi_fabric(vport, ndlp, sp, irsp);
-                else if (!(phba->hba_flag & HBA_FCOE_SUPPORT))
+                else if (!(phba->hba_flag & HBA_FCOE_MODE))
                         rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
                 else {
                         lpfc_printf_vlog(vport, KERN_ERR,
@@ -1014,7 +1024,9 @@ lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         if (sp->cmn.fcphHigh < FC_PH3)
                 sp->cmn.fcphHigh = FC_PH3;
 
-        if  (phba->sli_rev == LPFC_SLI_REV4) {
+        if  ((phba->sli_rev == LPFC_SLI_REV4) &&
+             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+              LPFC_SLI_INTF_IF_TYPE_0)) {
                 elsiocb->iocb.ulpCt_h = ((SLI4_CT_FCFI >> 1) & 1);
                 elsiocb->iocb.ulpCt_l = (SLI4_CT_FCFI & 1);
                 /* FLOGI needs to be 3 for WQE FCFI */
@@ -1027,7 +1039,7 @@ lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 icmd->ulpCt_l = 0;
         }
 
-        if (phba->fc_topology != TOPOLOGY_LOOP) {
+        if (phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
                 icmd->un.elsreq64.myID = 0;
                 icmd->un.elsreq64.fl = 1;
         }
@@ -1281,6 +1293,7 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
         uint32_t rc, keepDID = 0;
         int  put_node;
         int  put_rport;
+        struct lpfc_node_rrqs rrq;
 
         /* Fabric nodes can have the same WWPN so we don't bother searching
          * by WWPN.  Just return the ndlp that was given to us.
@@ -1298,6 +1311,7 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
 
         if (new_ndlp == ndlp && NLP_CHK_NODE_ACT(new_ndlp))
                 return ndlp;
+        memset(&rrq.xri_bitmap, 0, sizeof(new_ndlp->active_rrqs.xri_bitmap));
 
         if (!new_ndlp) {
                 rc = memcmp(&ndlp->nlp_portname, name,
@@ -1318,12 +1332,25 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
                 if (!new_ndlp)
                         return ndlp;
                 keepDID = new_ndlp->nlp_DID;
-        } else
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        memcpy(&rrq.xri_bitmap,
+                                &new_ndlp->active_rrqs.xri_bitmap,
+                                sizeof(new_ndlp->active_rrqs.xri_bitmap));
+        } else {
                 keepDID = new_ndlp->nlp_DID;
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        memcpy(&rrq.xri_bitmap,
+                                &new_ndlp->active_rrqs.xri_bitmap,
+                                sizeof(new_ndlp->active_rrqs.xri_bitmap));
+        }
 
         lpfc_unreg_rpi(vport, new_ndlp);
         new_ndlp->nlp_DID = ndlp->nlp_DID;
         new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                memcpy(new_ndlp->active_rrqs.xri_bitmap,
+                        &ndlp->active_rrqs.xri_bitmap,
+                        sizeof(ndlp->active_rrqs.xri_bitmap));
 
         if (ndlp->nlp_flag & NLP_NPR_2B_DISC)
                 new_ndlp->nlp_flag |= NLP_NPR_2B_DISC;
@@ -1362,12 +1389,20 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
 
                 /* Two ndlps cannot have the same did on the nodelist */
                 ndlp->nlp_DID = keepDID;
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        memcpy(&ndlp->active_rrqs.xri_bitmap,
+                                &rrq.xri_bitmap,
+                                sizeof(ndlp->active_rrqs.xri_bitmap));
                 lpfc_drop_node(vport, ndlp);
         }
         else {
                 lpfc_unreg_rpi(vport, ndlp);
                 /* Two ndlps cannot have the same did */
                 ndlp->nlp_DID = keepDID;
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        memcpy(&ndlp->active_rrqs.xri_bitmap,
+                                &rrq.xri_bitmap,
+                                sizeof(ndlp->active_rrqs.xri_bitmap));
                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
                 /* Since we are swapping the ndlp passed in with the new one
                  * and the did has already been swapped, copy over the
@@ -1428,6 +1463,73 @@ lpfc_end_rscn(struct lpfc_vport *vport)
 }
 
 /**
+ * lpfc_cmpl_els_rrq - Completion handled for els RRQs.
+ * @phba: pointer to lpfc hba data structure.
+ * @cmdiocb: pointer to lpfc command iocb data structure.
+ * @rspiocb: pointer to lpfc response iocb data structure.
+ *
+ * This routine will call the clear rrq function to free the rrq and
+ * clear the xri's bit in the ndlp's xri_bitmap. If the ndlp does not
+ * exist then the clear_rrq is still called because the rrq needs to
+ * be freed.
+ **/
+
+static void
+lpfc_cmpl_els_rrq(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
+                    struct lpfc_iocbq *rspiocb)
+{
+        struct lpfc_vport *vport = cmdiocb->vport;
+        IOCB_t *irsp;
+        struct lpfc_nodelist *ndlp;
+        struct lpfc_node_rrq *rrq;
+
+        /* we pass cmdiocb to state machine which needs rspiocb as well */
+        rrq = cmdiocb->context_un.rrq;
+        cmdiocb->context_un.rsp_iocb = rspiocb;
+
+        irsp = &rspiocb->iocb;
+        lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
+                "RRQ cmpl:      status:x%x/x%x did:x%x",
+                irsp->ulpStatus, irsp->un.ulpWord[4],
+                irsp->un.elsreq64.remoteID);
+
+        ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
+        if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || ndlp != rrq->ndlp) {
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2882 RRQ completes to NPort x%x "
+                                 "with no ndlp. Data: x%x x%x x%x\n",
+                                 irsp->un.elsreq64.remoteID,
+                                 irsp->ulpStatus, irsp->un.ulpWord[4],
+                                 irsp->ulpIoTag);
+                goto out;
+        }
+
+        /* rrq completes to NPort <nlp_DID> */
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                         "2880 RRQ completes to NPort x%x "
+                         "Data: x%x x%x x%x x%x x%x\n",
+                         ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
+                         irsp->ulpTimeout, rrq->xritag, rrq->rxid);
+
+        if (irsp->ulpStatus) {
+                /* Check for retry */
+                /* RRQ failed Don't print the vport to vport rjts */
+                if (irsp->ulpStatus != IOSTAT_LS_RJT ||
+                        (((irsp->un.ulpWord[4]) >> 16 != LSRJT_INVALID_CMD) &&
+                        ((irsp->un.ulpWord[4]) >> 16 != LSRJT_UNABLE_TPC)) ||
+                        (phba)->pport->cfg_log_verbose & LOG_ELS)
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2881 RRQ failure DID:%06X Status:x%x/x%x\n",
+                                 ndlp->nlp_DID, irsp->ulpStatus,
+                                 irsp->un.ulpWord[4]);
+        }
+out:
+        if (rrq)
+                lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
+        lpfc_els_free_iocb(phba, cmdiocb);
+        return;
+}
+/**
  * lpfc_cmpl_els_plogi - Completion callback function for plogi
  * @phba: pointer to lpfc hba data structure.
  * @cmdiocb: pointer to lpfc command iocb data structure.
@@ -2722,7 +2824,7 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                         if (cmd == ELS_CMD_FLOGI) {
                                 if (PCI_DEVICE_ID_HORNET ==
                                         phba->pcidev->device) {
-                                        phba->fc_topology = TOPOLOGY_LOOP;
+                                        phba->fc_topology = LPFC_TOPOLOGY_LOOP;
                                         phba->pport->fc_myDID = 0;
                                         phba->alpa_map[0] = 0;
                                         phba->alpa_map[1] = 0;
@@ -2877,7 +2979,7 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 retry = 1;
 
         if (((cmd == ELS_CMD_FLOGI) || (cmd == ELS_CMD_FDISC)) &&
-            (phba->fc_topology != TOPOLOGY_LOOP) &&
+            (phba->fc_topology != LPFC_TOPOLOGY_LOOP) &&
             !lpfc_error_lost_link(irsp)) {
                 /* FLOGI retry policy */
                 retry = 1;
@@ -3219,14 +3321,6 @@ lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
 
-        /*
-         * This routine is used to register and unregister in previous SLI
-         * modes.
-         */
-        if ((pmb->u.mb.mbxCommand == MBX_UNREG_LOGIN) &&
-            (phba->sli_rev == LPFC_SLI_REV4))
-                lpfc_sli4_free_rpi(phba, pmb->u.mb.un.varUnregLogin.rpi);
-
         pmb->context1 = NULL;
         pmb->context2 = NULL;
 
@@ -3904,6 +3998,47 @@ lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
 }
 
 /**
+ * lpfc_els_clear_rrq - Clear the rq that this rrq describes.
+ * @vport: pointer to a virtual N_Port data structure.
+ * @iocb: pointer to the lpfc command iocb data structure.
+ * @ndlp: pointer to a node-list data structure.
+ *
+ * Return
+ **/
+static void
+lpfc_els_clear_rrq(struct lpfc_vport *vport,
+      struct lpfc_iocbq *iocb, struct lpfc_nodelist *ndlp)
+{
+        struct lpfc_hba  *phba = vport->phba;
+        uint8_t *pcmd;
+        struct RRQ *rrq;
+        uint16_t rxid;
+        struct lpfc_node_rrq *prrq;
+
+
+        pcmd = (uint8_t *) (((struct lpfc_dmabuf *) iocb->context2)->virt);
+        pcmd += sizeof(uint32_t);
+        rrq = (struct RRQ *)pcmd;
+        rxid = bf_get(rrq_oxid, rrq);
+
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                        "2883 Clear RRQ for SID:x%x OXID:x%x RXID:x%x"
+                        " x%x x%x\n",
+                        bf_get(rrq_did, rrq),
+                        bf_get(rrq_oxid, rrq),
+                        rxid,
+                        iocb->iotag, iocb->iocb.ulpContext);
+
+        lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
+                "Clear RRQ:  did:x%x flg:x%x exchg:x%.08x",
+                ndlp->nlp_DID, ndlp->nlp_flag, rrq->rrq_exchg);
+        prrq = lpfc_get_active_rrq(vport, rxid, ndlp->nlp_DID);
+        if (prrq)
+                lpfc_clr_rrq_active(phba, rxid, prrq);
+        return;
+}
+
+/**
  * lpfc_els_rsp_echo_acc - Issue echo acc response
  * @vport: pointer to a virtual N_Port data structure.
  * @data: pointer to echo data to return in the accept.
@@ -4597,7 +4732,7 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
 
         lpfc_set_disctmo(vport);
 
-        if (phba->fc_topology == TOPOLOGY_LOOP) {
+        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                 /* We should never receive a FLOGI in loop mode, ignore it */
                 did = icmd->un.elsreq64.remoteID;
 
@@ -4792,6 +4927,8 @@ lpfc_els_rcv_rrq(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
                  struct lpfc_nodelist *ndlp)
 {
         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
+        if (vport->phba->sli_rev == LPFC_SLI_REV4)
+                lpfc_els_clear_rrq(vport, cmdiocb, ndlp);
 }
 
 /**
@@ -4940,7 +5077,7 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         pcmd += sizeof(uint32_t); /* Skip past command */
         rps_rsp = (RPS_RSP *)pcmd;
 
-        if (phba->fc_topology != TOPOLOGY_LOOP)
+        if (phba->fc_topology != LPFC_TOPOLOGY_LOOP)
                 status = 0x10;
         else
                 status = 0x8;
@@ -5194,6 +5331,97 @@ reject_out:
         return 0;
 }
 
+/* lpfc_issue_els_rrq - Process an unsolicited rps iocb
+ * @vport: pointer to a host virtual N_Port data structure.
+ * @ndlp: pointer to a node-list data structure.
+ * @did: DID of the target.
+ * @rrq: Pointer to the rrq struct.
+ *
+ * Build a ELS RRQ command and send it to the target. If the issue_iocb is
+ * Successful the the completion handler will clear the RRQ.
+ *
+ * Return codes
+ *   0 - Successfully sent rrq els iocb.
+ *   1 - Failed to send rrq els iocb.
+ **/
+static int
+lpfc_issue_els_rrq(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
+                        uint32_t did, struct lpfc_node_rrq *rrq)
+{
+        struct lpfc_hba  *phba = vport->phba;
+        struct RRQ *els_rrq;
+        IOCB_t *icmd;
+        struct lpfc_iocbq *elsiocb;
+        uint8_t *pcmd;
+        uint16_t cmdsize;
+        int ret;
+
+
+        if (ndlp != rrq->ndlp)
+                ndlp = rrq->ndlp;
+        if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
+                return 1;
+
+        /* If ndlp is not NULL, we will bump the reference count on it */
+        cmdsize = (sizeof(uint32_t) + sizeof(struct RRQ));
+        elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp, did,
+                                     ELS_CMD_RRQ);
+        if (!elsiocb)
+                return 1;
+
+        icmd = &elsiocb->iocb;
+        pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
+
+        /* For RRQ request, remainder of payload is Exchange IDs */
+        *((uint32_t *) (pcmd)) = ELS_CMD_RRQ;
+        pcmd += sizeof(uint32_t);
+        els_rrq = (struct RRQ *) pcmd;
+
+        bf_set(rrq_oxid, els_rrq, rrq->xritag);
+        bf_set(rrq_rxid, els_rrq, rrq->rxid);
+        bf_set(rrq_did, els_rrq, vport->fc_myDID);
+        els_rrq->rrq = cpu_to_be32(els_rrq->rrq);
+        els_rrq->rrq_exchg = cpu_to_be32(els_rrq->rrq_exchg);
+
+
+        lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
+                "Issue RRQ:     did:x%x",
+                did, rrq->xritag, rrq->rxid);
+        elsiocb->context_un.rrq = rrq;
+        elsiocb->iocb_cmpl = lpfc_cmpl_els_rrq;
+        ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
+
+        if (ret == IOCB_ERROR) {
+                lpfc_els_free_iocb(phba, elsiocb);
+                return 1;
+        }
+        return 0;
+}
+
+/**
+ * lpfc_send_rrq - Sends ELS RRQ if needed.
+ * @phba: pointer to lpfc hba data structure.
+ * @rrq: pointer to the active rrq.
+ *
+ * This routine will call the lpfc_issue_els_rrq if the rrq is
+ * still active for the xri. If this function returns a failure then
+ * the caller needs to clean up the RRQ by calling lpfc_clr_active_rrq.
+ *
+ * Returns 0 Success.
+ *         1 Failure.
+ **/
+int
+lpfc_send_rrq(struct lpfc_hba *phba, struct lpfc_node_rrq *rrq)
+{
+        struct lpfc_nodelist *ndlp = lpfc_findnode_did(rrq->vport,
+                                                        rrq->nlp_DID);
+        if (lpfc_test_rrq_active(phba, ndlp, rrq->xritag))
+                return lpfc_issue_els_rrq(rrq->vport, ndlp,
+                                         rrq->nlp_DID, rrq);
+        else
+                return 1;
+}
+
 /**
  * lpfc_els_rsp_rpl_acc - Issue an accept rpl els command
  * @vport: pointer to a host virtual N_Port data structure.
@@ -5482,7 +5710,7 @@ lpfc_els_rcv_fan(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
                     (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
                             sizeof(struct lpfc_name)))) {
                         /* This port has switched fabrics. FLOGI is required */
-                        lpfc_initial_flogi(vport);
+                        lpfc_issue_init_vfi(vport);
                 } else {
                         /* FAN verified - skip FLOGI */
                         vport->fc_myDID = vport->fc_prevDID;
@@ -6201,7 +6429,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         cmd, did, vport->port_state);
 
                 /* Unsupported ELS command, reject */
-                rjt_err = LSRJT_INVALID_CMD;
+                rjt_err = LSRJT_CMD_UNSUPPORTED;
 
                 /* Unknown ELS command <elsCmd> received from NPORT <did> */
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
@@ -6373,7 +6601,7 @@ lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
         if (!ndlp) {
                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
                 if (!ndlp) {
-                        if (phba->fc_topology == TOPOLOGY_LOOP) {
+                        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                                 lpfc_disc_start(vport);
                                 return;
                         }
@@ -6386,7 +6614,7 @@ lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
         } else if (!NLP_CHK_NODE_ACT(ndlp)) {
                 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
                 if (!ndlp) {
-                        if (phba->fc_topology == TOPOLOGY_LOOP) {
+                        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                                 lpfc_disc_start(vport);
                                 return;
                         }
@@ -6408,18 +6636,31 @@ lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
         }
 
         if (vport->cfg_fdmi_on) {
-                ndlp_fdmi = mempool_alloc(phba->nlp_mem_pool,
-                                          GFP_KERNEL);
+                /* If this is the first time, allocate an ndlp and initialize
+                 * it. Otherwise, make sure the node is enabled and then do the
+                 * login.
+                 */
+                ndlp_fdmi = lpfc_findnode_did(vport, FDMI_DID);
+                if (!ndlp_fdmi) {
+                        ndlp_fdmi = mempool_alloc(phba->nlp_mem_pool,
+                                                  GFP_KERNEL);
+                        if (ndlp_fdmi) {
+                                lpfc_nlp_init(vport, ndlp_fdmi, FDMI_DID);
+                                ndlp_fdmi->nlp_type |= NLP_FABRIC;
+                        } else
+                                return;
+                }
+                if (!NLP_CHK_NODE_ACT(ndlp_fdmi))
+                        ndlp_fdmi = lpfc_enable_node(vport,
+                                                     ndlp_fdmi,
+                                                     NLP_STE_NPR_NODE);
+
                 if (ndlp_fdmi) {
-                        lpfc_nlp_init(vport, ndlp_fdmi, FDMI_DID);
-                        ndlp_fdmi->nlp_type |= NLP_FABRIC;
                         lpfc_nlp_set_state(vport, ndlp_fdmi,
-                                NLP_STE_PLOGI_ISSUE);
-                        lpfc_issue_els_plogi(vport, ndlp_fdmi->nlp_DID,
-                                             0);
+                                           NLP_STE_PLOGI_ISSUE);
+                        lpfc_issue_els_plogi(vport, ndlp_fdmi->nlp_DID, 0);
                 }
         }
-        return;
 }
 
 /**
@@ -6497,7 +6738,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                         spin_unlock_irq(shost->host_lock);
                         if (vport->port_type == LPFC_PHYSICAL_PORT
                                 && !(vport->fc_flag & FC_LOGO_RCVD_DID_CHNG))
-                                lpfc_initial_flogi(vport);
+                                lpfc_issue_init_vfi(vport);
                         else
                                 lpfc_initial_fdisc(vport);
                         break;
@@ -6734,7 +6975,7 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         vport->fc_flag &= ~FC_VPORT_CVL_RCVD;
         vport->fc_flag &= ~FC_VPORT_LOGO_RCVD;
         vport->fc_flag |= FC_FABRIC;
-        if (vport->phba->fc_topology == TOPOLOGY_LOOP)
+        if (vport->phba->fc_topology == LPFC_TOPOLOGY_LOOP)
                 vport->fc_flag |=  FC_PUBLIC_LOOP;
         spin_unlock_irq(shost->host_lock);
 
@@ -6844,7 +7085,9 @@ lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         icmd->un.elsreq64.myID = 0;
         icmd->un.elsreq64.fl = 1;
 
-        if  (phba->sli_rev == LPFC_SLI_REV4) {
+        if  ((phba->sli_rev == LPFC_SLI_REV4) &&
+             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+              LPFC_SLI_INTF_IF_TYPE_0)) {
                 /* FDISC needs to be 1 for WQE VPI */
                 elsiocb->iocb.ulpCt_h = (SLI4_CT_VPI >> 1) & 1;
                 elsiocb->iocb.ulpCt_l = SLI4_CT_VPI & 1 ;
@@ -7351,8 +7594,11 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
                           struct sli4_wcqe_xri_aborted *axri)
 {
         uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
+        uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
+
         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
         unsigned long iflag = 0;
+        struct lpfc_nodelist *ndlp;
         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
 
         spin_lock_irqsave(&phba->hbalock, iflag);
@@ -7361,11 +7607,14 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
                         &phba->sli4_hba.lpfc_abts_els_sgl_list, list) {
                 if (sglq_entry->sli4_xritag == xri) {
                         list_del(&sglq_entry->list);
+                        ndlp = sglq_entry->ndlp;
+                        sglq_entry->ndlp = NULL;
                         list_add_tail(&sglq_entry->list,
                                 &phba->sli4_hba.lpfc_sgl_list);
                         sglq_entry->state = SGL_FREED;
                         spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
                         spin_unlock_irqrestore(&phba->hbalock, iflag);
+                        lpfc_set_rrq_active(phba, ndlp, xri, rxid, 1);
 
                         /* Check if TXQ queue needs to be serviced */
                         if (pring->txq_cnt)
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index a5d1695dac3d..f9f160ab2ee9 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -607,6 +607,8 @@ lpfc_work_done(struct lpfc_hba *phba)
 
         /* Process SLI4 events */
         if (phba->pci_dev_grp == LPFC_PCI_DEV_OC) {
+                if (phba->hba_flag & HBA_RRQ_ACTIVE)
+                        lpfc_handle_rrq_active(phba);
                 if (phba->hba_flag & FCP_XRI_ABORT_EVENT)
                         lpfc_sli4_fcp_xri_abort_event_proc(phba);
                 if (phba->hba_flag & ELS_XRI_ABORT_EVENT)
@@ -966,6 +968,7 @@ lpfc_linkup(struct lpfc_hba *phba)
         struct lpfc_vport **vports;
         int i;
 
+        lpfc_cleanup_wt_rrqs(phba);
         phba->link_state = LPFC_LINK_UP;
 
         /* Unblock fabric iocbs if they are blocked */
@@ -1064,7 +1067,7 @@ lpfc_mbx_cmpl_local_config_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 
         mempool_free(pmb, phba->mbox_mem_pool);
 
-        if (phba->fc_topology == TOPOLOGY_LOOP &&
+        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP &&
             vport->fc_flag & FC_PUBLIC_LOOP &&
             !(vport->fc_flag & FC_LBIT)) {
                         /* Need to wait for FAN - use discovery timer
@@ -1078,9 +1081,8 @@ lpfc_mbx_cmpl_local_config_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         /* Start discovery by sending a FLOGI. port_state is identically
          * LPFC_FLOGI while waiting for FLOGI cmpl
          */
-        if (vport->port_state != LPFC_FLOGI) {
+        if (vport->port_state != LPFC_FLOGI)
                 lpfc_initial_flogi(vport);
-        }
         return;
 
 out:
@@ -1131,7 +1133,7 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         if (vport->port_state != LPFC_FLOGI) {
                 phba->hba_flag |= FCF_RR_INPROG;
                 spin_unlock_irq(&phba->hbalock);
-                lpfc_initial_flogi(vport);
+                lpfc_issue_init_vfi(vport);
                 goto out;
         }
         spin_unlock_irq(&phba->hbalock);
@@ -1353,7 +1355,7 @@ lpfc_register_fcf(struct lpfc_hba *phba)
                 if (phba->pport->port_state != LPFC_FLOGI) {
                         phba->hba_flag |= FCF_RR_INPROG;
                         spin_unlock_irq(&phba->hbalock);
-                        lpfc_initial_flogi(phba->pport);
+                        lpfc_issue_init_vfi(phba->pport);
                         return;
                 }
                 spin_unlock_irq(&phba->hbalock);
@@ -2331,7 +2333,7 @@ lpfc_mbx_cmpl_fcf_rr_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                                 phba->fcf.current_rec.fcf_indx, fcf_index);
                 /* Wait 500 ms before retrying FLOGI to current FCF */
                 msleep(500);
-                lpfc_initial_flogi(phba->pport);
+                lpfc_issue_init_vfi(phba->pport);
                 goto out;
         }
 
@@ -2422,6 +2424,63 @@ out:
 }
 
 /**
+ * lpfc_init_vfi_cmpl - Completion handler for init_vfi mbox command.
+ * @phba: pointer to lpfc hba data structure.
+ * @mboxq: pointer to mailbox data structure.
+ *
+ * This function handles completion of init vfi mailbox command.
+ */
+void
+lpfc_init_vfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+{
+        struct lpfc_vport *vport = mboxq->vport;
+
+        if (mboxq->u.mb.mbxStatus && (mboxq->u.mb.mbxStatus != 0x4002)) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                                LOG_MBOX,
+                                "2891 Init VFI mailbox failed 0x%x\n",
+                                mboxq->u.mb.mbxStatus);
+                mempool_free(mboxq, phba->mbox_mem_pool);
+                lpfc_vport_set_state(vport, FC_VPORT_FAILED);
+                return;
+        }
+        lpfc_initial_flogi(vport);
+        mempool_free(mboxq, phba->mbox_mem_pool);
+        return;
+}
+
+/**
+ * lpfc_issue_init_vfi - Issue init_vfi mailbox command.
+ * @vport: pointer to lpfc_vport data structure.
+ *
+ * This function issue a init_vfi mailbox command to initialize the VFI and
+ * VPI for the physical port.
+ */
+void
+lpfc_issue_init_vfi(struct lpfc_vport *vport)
+{
+        LPFC_MBOXQ_t *mboxq;
+        int rc;
+        struct lpfc_hba *phba = vport->phba;
+
+        mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                        LOG_MBOX, "2892 Failed to allocate "
+                        "init_vfi mailbox\n");
+                return;
+        }
+        lpfc_init_vfi(mboxq, vport);
+        mboxq->mbox_cmpl = lpfc_init_vfi_cmpl;
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                        LOG_MBOX, "2893 Failed to issue init_vfi mailbox\n");
+                mempool_free(mboxq, vport->phba->mbox_mem_pool);
+        }
+}
+
+/**
  * lpfc_init_vpi_cmpl - Completion handler for init_vpi mbox command.
  * @phba: pointer to lpfc hba data structure.
  * @mboxq: pointer to mailbox data structure.
@@ -2528,7 +2587,7 @@ lpfc_start_fdiscs(struct lpfc_hba *phba)
                                                      FC_VPORT_FAILED);
                                 continue;
                         }
-                        if (phba->fc_topology == TOPOLOGY_LOOP) {
+                        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                                 lpfc_vport_set_state(vports[i],
                                                      FC_VPORT_LINKDOWN);
                                 continue;
@@ -2564,7 +2623,7 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                          "2018 REG_VFI mbxStatus error x%x "
                          "HBA state x%x\n",
                          mboxq->u.mb.mbxStatus, vport->port_state);
-                if (phba->fc_topology == TOPOLOGY_LOOP) {
+                if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                         /* FLOGI failed, use loop map to make discovery list */
                         lpfc_disc_list_loopmap(vport);
                         /* Start discovery */
@@ -2582,8 +2641,18 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         spin_unlock_irq(shost->host_lock);
 
         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
-                lpfc_start_fdiscs(phba);
-                lpfc_do_scr_ns_plogi(phba, vport);
+                /* For private loop just start discovery and we are done. */
+                if ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
+                    (phba->alpa_map[0] == 0) &&
+                    !(vport->fc_flag & FC_PUBLIC_LOOP)) {
+                        /* Use loop map to make discovery list */
+                        lpfc_disc_list_loopmap(vport);
+                        /* Start discovery */
+                        lpfc_disc_start(vport);
+                } else {
+                        lpfc_start_fdiscs(phba);
+                        lpfc_do_scr_ns_plogi(phba, vport);
+                }
         }
 
 fail_free_mem:
@@ -2644,7 +2713,7 @@ out:
 }
 
 static void
-lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
+lpfc_mbx_process_link_up(struct lpfc_hba *phba, struct lpfc_mbx_read_top *la)
 {
         struct lpfc_vport *vport = phba->pport;
         LPFC_MBOXQ_t *sparam_mbox, *cfglink_mbox = NULL;
@@ -2654,31 +2723,24 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
         struct fcf_record *fcf_record;
 
         spin_lock_irq(&phba->hbalock);
-        switch (la->UlnkSpeed) {
-        case LA_1GHZ_LINK:
-                phba->fc_linkspeed = LA_1GHZ_LINK;
-                break;
-        case LA_2GHZ_LINK:
-                phba->fc_linkspeed = LA_2GHZ_LINK;
-                break;
-        case LA_4GHZ_LINK:
-                phba->fc_linkspeed = LA_4GHZ_LINK;
-                break;
-        case LA_8GHZ_LINK:
-                phba->fc_linkspeed = LA_8GHZ_LINK;
-                break;
-        case LA_10GHZ_LINK:
-                phba->fc_linkspeed = LA_10GHZ_LINK;
+        switch (bf_get(lpfc_mbx_read_top_link_spd, la)) {
+        case LPFC_LINK_SPEED_1GHZ:
+        case LPFC_LINK_SPEED_2GHZ:
+        case LPFC_LINK_SPEED_4GHZ:
+        case LPFC_LINK_SPEED_8GHZ:
+        case LPFC_LINK_SPEED_10GHZ:
+        case LPFC_LINK_SPEED_16GHZ:
+                phba->fc_linkspeed = bf_get(lpfc_mbx_read_top_link_spd, la);
                 break;
         default:
-                phba->fc_linkspeed = LA_UNKNW_LINK;
+                phba->fc_linkspeed = LPFC_LINK_SPEED_UNKNOWN;
                 break;
         }
 
-        phba->fc_topology = la->topology;
+        phba->fc_topology = bf_get(lpfc_mbx_read_top_topology, la);
         phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
 
-        if (phba->fc_topology == TOPOLOGY_LOOP) {
+        if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED;
 
                 /* if npiv is enabled and this adapter supports npiv log
@@ -2689,11 +2751,11 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                                 "1309 Link Up Event npiv not supported in loop "
                                 "topology\n");
                                 /* Get Loop Map information */
-                if (la->il)
+                if (bf_get(lpfc_mbx_read_top_il, la))
                         vport->fc_flag |= FC_LBIT;
 
-                vport->fc_myDID = la->granted_AL_PA;
-                i = la->un.lilpBde64.tus.f.bdeSize;
+                vport->fc_myDID = bf_get(lpfc_mbx_read_top_alpa_granted, la);
+                i = la->lilpBde64.tus.f.bdeSize;
 
                 if (i == 0) {
                         phba->alpa_map[0] = 0;
@@ -2764,7 +2826,7 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                 goto out;
         }
 
-        if (!(phba->hba_flag & HBA_FCOE_SUPPORT)) {
+        if (!(phba->hba_flag & HBA_FCOE_MODE)) {
                 cfglink_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
                 if (!cfglink_mbox)
                         goto out;
@@ -2874,17 +2936,17 @@ lpfc_mbx_issue_link_down(struct lpfc_hba *phba)
 
 
 /*
- * This routine handles processing a READ_LA mailbox
+ * This routine handles processing a READ_TOPOLOGY mailbox
  * command upon completion. It is setup in the LPFC_MBOXQ
  * as the completion routine when the command is
  * handed off to the SLI layer.
  */
 void
-lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
+lpfc_mbx_cmpl_read_topology(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 {
         struct lpfc_vport *vport = pmb->vport;
         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
-        READ_LA_VAR *la;
+        struct lpfc_mbx_read_top *la;
         MAILBOX_t *mb = &pmb->u.mb;
         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
 
@@ -2897,15 +2959,15 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                                 mb->mbxStatus, vport->port_state);
                 lpfc_mbx_issue_link_down(phba);
                 phba->link_state = LPFC_HBA_ERROR;
-                goto lpfc_mbx_cmpl_read_la_free_mbuf;
+                goto lpfc_mbx_cmpl_read_topology_free_mbuf;
         }
 
-        la = (READ_LA_VAR *) &pmb->u.mb.un.varReadLA;
+        la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop;
 
         memcpy(&phba->alpa_map[0], mp->virt, 128);
 
         spin_lock_irq(shost->host_lock);
-        if (la->pb)
+        if (bf_get(lpfc_mbx_read_top_pb, la))
                 vport->fc_flag |= FC_BYPASSED_MODE;
         else
                 vport->fc_flag &= ~FC_BYPASSED_MODE;
@@ -2914,41 +2976,48 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         if ((phba->fc_eventTag  < la->eventTag) ||
             (phba->fc_eventTag == la->eventTag)) {
                 phba->fc_stat.LinkMultiEvent++;
-                if (la->attType == AT_LINK_UP)
+                if (bf_get(lpfc_mbx_read_top_att_type, la) == LPFC_ATT_LINK_UP)
                         if (phba->fc_eventTag != 0)
                                 lpfc_linkdown(phba);
         }
 
         phba->fc_eventTag = la->eventTag;
         spin_lock_irq(&phba->hbalock);
-        if (la->mm)
+        if (bf_get(lpfc_mbx_read_top_mm, la))
                 phba->sli.sli_flag |= LPFC_MENLO_MAINT;
         else
                 phba->sli.sli_flag &= ~LPFC_MENLO_MAINT;
         spin_unlock_irq(&phba->hbalock);
 
         phba->link_events++;
-        if (la->attType == AT_LINK_UP && (!la->mm)) {
+        if ((bf_get(lpfc_mbx_read_top_att_type, la) == LPFC_ATT_LINK_UP) &&
+            (!bf_get(lpfc_mbx_read_top_mm, la))) {
                 phba->fc_stat.LinkUp++;
                 if (phba->link_flag & LS_LOOPBACK_MODE) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
                                         "1306 Link Up Event in loop back mode "
                                         "x%x received Data: x%x x%x x%x x%x\n",
                                         la->eventTag, phba->fc_eventTag,
-                                        la->granted_AL_PA, la->UlnkSpeed,
+                                        bf_get(lpfc_mbx_read_top_alpa_granted,
+                                               la),
+                                        bf_get(lpfc_mbx_read_top_link_spd, la),
                                         phba->alpa_map[0]);
                 } else {
                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
                                         "1303 Link Up Event x%x received "
                                         "Data: x%x x%x x%x x%x x%x x%x %d\n",
                                         la->eventTag, phba->fc_eventTag,
-                                        la->granted_AL_PA, la->UlnkSpeed,
+                                        bf_get(lpfc_mbx_read_top_alpa_granted,
+                                               la),
+                                        bf_get(lpfc_mbx_read_top_link_spd, la),
                                         phba->alpa_map[0],
-                                        la->mm, la->fa,
+                                        bf_get(lpfc_mbx_read_top_mm, la),
+                                        bf_get(lpfc_mbx_read_top_fa, la),
                                         phba->wait_4_mlo_maint_flg);
                 }
                 lpfc_mbx_process_link_up(phba, la);
-        } else if (la->attType == AT_LINK_DOWN) {
+        } else if (bf_get(lpfc_mbx_read_top_att_type, la) ==
+                   LPFC_ATT_LINK_DOWN) {
                 phba->fc_stat.LinkDown++;
                 if (phba->link_flag & LS_LOOPBACK_MODE) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
@@ -2964,11 +3033,13 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                                 "Data: x%x x%x x%x x%x x%x\n",
                                 la->eventTag, phba->fc_eventTag,
                                 phba->pport->port_state, vport->fc_flag,
-                                la->mm, la->fa);
+                                bf_get(lpfc_mbx_read_top_mm, la),
+                                bf_get(lpfc_mbx_read_top_fa, la));
                 }
                 lpfc_mbx_issue_link_down(phba);
         }
-        if (la->mm && la->attType == AT_LINK_UP) {
+        if ((bf_get(lpfc_mbx_read_top_mm, la)) &&
+            (bf_get(lpfc_mbx_read_top_att_type, la) == LPFC_ATT_LINK_UP)) {
                 if (phba->link_state != LPFC_LINK_DOWN) {
                         phba->fc_stat.LinkDown++;
                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
@@ -2996,14 +3067,15 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 }
         }
 
-        if (la->fa) {
-                if (la->mm)
+        if (bf_get(lpfc_mbx_read_top_fa, la)) {
+                if (bf_get(lpfc_mbx_read_top_mm, la))
                         lpfc_issue_clear_la(phba, vport);
                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
-                                "1311 fa %d\n", la->fa);
+                                "1311 fa %d\n",
+                                bf_get(lpfc_mbx_read_top_fa, la));
         }
 
-lpfc_mbx_cmpl_read_la_free_mbuf:
+lpfc_mbx_cmpl_read_topology_free_mbuf:
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
         mempool_free(pmb, phba->mbox_mem_pool);
@@ -3030,8 +3102,8 @@ lpfc_mbx_cmpl_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         if (ndlp->nlp_flag & NLP_REG_LOGIN_SEND)
                 ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;
 
-        if (ndlp->nlp_flag &  NLP_IGNR_REG_CMPL ||
-                ndlp->nlp_state != NLP_STE_REG_LOGIN_ISSUE) {
+        if (ndlp->nlp_flag & NLP_IGNR_REG_CMPL ||
+            ndlp->nlp_state != NLP_STE_REG_LOGIN_ISSUE) {
                 /* We rcvd a rscn after issuing this
                  * mbox reg login, we may have cycled
                  * back through the state and be
@@ -3043,10 +3115,6 @@ lpfc_mbx_cmpl_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag &= ~NLP_IGNR_REG_CMPL;
                 spin_unlock_irq(shost->host_lock);
-                if (phba->sli_rev == LPFC_SLI_REV4)
-                        lpfc_sli4_free_rpi(phba,
-                                pmb->u.mb.un.varRegLogin.rpi);
-
         } else
                 /* Good status, call state machine */
                 lpfc_disc_state_machine(vport, ndlp, pmb,
@@ -3092,6 +3160,7 @@ lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         spin_unlock_irq(shost->host_lock);
         vport->unreg_vpi_cmpl = VPORT_OK;
         mempool_free(pmb, phba->mbox_mem_pool);
+        lpfc_cleanup_vports_rrqs(vport);
         /*
          * This shost reference might have been taken at the beginning of
          * lpfc_vport_delete()
@@ -3333,7 +3402,7 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 kfree(mp);
                 mempool_free(pmb, phba->mbox_mem_pool);
 
-                if (phba->fc_topology == TOPOLOGY_LOOP) {
+                if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                         /* FLOGI failed, use loop map to make discovery list */
                         lpfc_disc_list_loopmap(vport);
 
@@ -3355,7 +3424,7 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         }
 
         ndlp->nlp_rpi = mb->un.varWords[0];
-        ndlp->nlp_flag |= NLP_RPI_VALID;
+        ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         ndlp->nlp_type |= NLP_FABRIC;
         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
 
@@ -3413,7 +3482,7 @@ out:
                 /* If no other thread is using the ndlp, free it */
                 lpfc_nlp_not_used(ndlp);
 
-                if (phba->fc_topology == TOPOLOGY_LOOP) {
+                if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
                         /*
                          * RegLogin failed, use loop map to make discovery
                          * list
@@ -3429,7 +3498,7 @@ out:
         }
 
         ndlp->nlp_rpi = mb->un.varWords[0];
-        ndlp->nlp_flag |= NLP_RPI_VALID;
+        ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         ndlp->nlp_type |= NLP_FABRIC;
         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
 
@@ -3762,6 +3831,8 @@ lpfc_initialize_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         NLP_INT_NODE_ACT(ndlp);
         atomic_set(&ndlp->cmd_pending, 0);
         ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
+        if (vport->phba->sli_rev == LPFC_SLI_REV4)
+                ndlp->nlp_rpi = lpfc_sli4_alloc_rpi(vport->phba);
 }
 
 struct lpfc_nodelist *
@@ -3975,7 +4046,7 @@ lpfc_no_rpi(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
          * by firmware with a no rpi error.
          */
         psli = &phba->sli;
-        if (ndlp->nlp_flag & NLP_RPI_VALID) {
+        if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
                 /* Now process each ring */
                 for (i = 0; i < psli->num_rings; i++) {
                         pring = &psli->ring[i];
@@ -4023,7 +4094,7 @@ lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
         LPFC_MBOXQ_t    *mbox;
         int rc;
 
-        if (ndlp->nlp_flag & NLP_RPI_VALID) {
+        if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
                 if (mbox) {
                         lpfc_unreg_login(phba, vport->vpi, ndlp->nlp_rpi, mbox);
@@ -4035,8 +4106,9 @@ lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
                 }
                 lpfc_no_rpi(phba, ndlp);
 
-                ndlp->nlp_rpi = 0;
-                ndlp->nlp_flag &= ~NLP_RPI_VALID;
+                if (phba->sli_rev != LPFC_SLI_REV4)
+                        ndlp->nlp_rpi = 0;
+                ndlp->nlp_flag &= ~NLP_RPI_REGISTERED;
                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
                 return 1;
         }
@@ -4059,11 +4131,16 @@ lpfc_unreg_hba_rpis(struct lpfc_hba *phba)
         int i;
 
         vports = lpfc_create_vport_work_array(phba);
+        if (!vports) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                        "2884 Vport array allocation failed \n");
+                return;
+        }
         for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
                 shost = lpfc_shost_from_vport(vports[i]);
                 spin_lock_irq(shost->host_lock);
                 list_for_each_entry(ndlp, &vports[i]->fc_nodes, nlp_listp) {
-                        if (ndlp->nlp_flag & NLP_RPI_VALID) {
+                        if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
                                 /* The mempool_alloc might sleep */
                                 spin_unlock_irq(shost->host_lock);
                                 lpfc_unreg_rpi(vports[i], ndlp);
@@ -4192,9 +4269,6 @@ lpfc_cleanup_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
                                 kfree(mp);
                         }
                         list_del(&mb->list);
-                        if (phba->sli_rev == LPFC_SLI_REV4)
-                                lpfc_sli4_free_rpi(phba,
-                                         mb->u.mb.un.varRegLogin.rpi);
                         mempool_free(mb, phba->mbox_mem_pool);
                         /* We shall not invoke the lpfc_nlp_put to decrement
                          * the ndlp reference count as we are in the process
@@ -4236,15 +4310,15 @@ lpfc_nlp_remove(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
 
         lpfc_cancel_retry_delay_tmo(vport, ndlp);
         if ((ndlp->nlp_flag & NLP_DEFER_RM) &&
-                !(ndlp->nlp_flag & NLP_REG_LOGIN_SEND) &&
-            !(ndlp->nlp_flag & NLP_RPI_VALID)) {
+            !(ndlp->nlp_flag & NLP_REG_LOGIN_SEND) &&
+            !(ndlp->nlp_flag & NLP_RPI_REGISTERED)) {
                 /* For this case we need to cleanup the default rpi
                  * allocated by the firmware.
                  */
                 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))
                         != NULL) {
                         rc = lpfc_reg_rpi(phba, vport->vpi, ndlp->nlp_DID,
-                            (uint8_t *) &vport->fc_sparam, mbox, 0);
+                            (uint8_t *) &vport->fc_sparam, mbox, ndlp->nlp_rpi);
                         if (rc) {
                                 mempool_free(mbox, phba->mbox_mem_pool);
                         }
@@ -4436,7 +4510,7 @@ lpfc_disc_list_loopmap(struct lpfc_vport *vport)
         if (!lpfc_is_link_up(phba))
                 return;
 
-        if (phba->fc_topology != TOPOLOGY_LOOP)
+        if (phba->fc_topology != LPFC_TOPOLOGY_LOOP)
                 return;
 
         /* Check for loop map present or not */
@@ -4788,7 +4862,10 @@ lpfc_disc_timeout_handler(struct lpfc_vport *vport)
                         }
                 }
                 if (vport->port_state != LPFC_FLOGI) {
-                        lpfc_initial_flogi(vport);
+                        if (phba->sli_rev <= LPFC_SLI_REV3)
+                                lpfc_initial_flogi(vport);
+                        else
+                                lpfc_issue_init_vfi(vport);
                         return;
                 }
                 break;
@@ -4979,7 +5056,7 @@ lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         pmb->context2 = NULL;
 
         ndlp->nlp_rpi = mb->un.varWords[0];
-        ndlp->nlp_flag |= NLP_RPI_VALID;
+        ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         ndlp->nlp_type |= NLP_FABRIC;
         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
 
@@ -5103,6 +5180,8 @@ lpfc_nlp_release(struct kref *kref)
         spin_lock_irqsave(&phba->ndlp_lock, flags);
         NLP_CLR_NODE_ACT(ndlp);
         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                lpfc_sli4_free_rpi(phba, ndlp->nlp_rpi);
 
         /* free ndlp memory for final ndlp release */
         if (NLP_CHK_FREE_REQ(ndlp)) {
@@ -5254,6 +5333,10 @@ lpfc_fcf_inuse(struct lpfc_hba *phba)
 
         vports = lpfc_create_vport_work_array(phba);
 
+        /* If driver cannot allocate memory, indicate fcf is in use */
+        if (!vports)
+                return 1;
+
         for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
                 shost = lpfc_shost_from_vport(vports[i]);
                 spin_lock_irq(shost->host_lock);
@@ -5269,7 +5352,7 @@ lpfc_fcf_inuse(struct lpfc_hba *phba)
                                         "logged in\n",
                                         ndlp->nlp_rpi, ndlp->nlp_DID,
                                         ndlp->nlp_flag);
-                                if (ndlp->nlp_flag & NLP_RPI_VALID)
+                                if (ndlp->nlp_flag & NLP_RPI_REGISTERED)
                                         ret = 1;
                         }
                 }
@@ -5550,7 +5633,7 @@ lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
          * registered, do nothing.
          */
         spin_lock_irq(&phba->hbalock);
-        if (!(phba->hba_flag & HBA_FCOE_SUPPORT) ||
+        if (!(phba->hba_flag & HBA_FCOE_MODE) ||
             !(phba->fcf.fcf_flag & FCF_REGISTERED) ||
             !(phba->hba_flag & HBA_FIP_SUPPORT) ||
             (phba->fcf.fcf_flag & FCF_DISCOVERY) ||
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index 9b8333456465..96ed3ba6ba95 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -880,6 +880,24 @@ struct  RLS_RSP {		/* Structure is in Big Endian format */
         uint32_t crcCnt;
 };
 
+struct RRQ {                    /* Structure is in Big Endian format */
+        uint32_t rrq;
+#define rrq_rsvd_SHIFT          24
+#define rrq_rsvd_MASK           0x000000ff
+#define rrq_rsvd_WORD           rrq
+#define rrq_did_SHIFT           0
+#define rrq_did_MASK            0x00ffffff
+#define rrq_did_WORD            rrq
+        uint32_t rrq_exchg;
+#define rrq_oxid_SHIFT          16
+#define rrq_oxid_MASK           0xffff
+#define rrq_oxid_WORD           rrq_exchg
+#define rrq_rxid_SHIFT          0
+#define rrq_rxid_MASK           0xffff
+#define rrq_rxid_WORD           rrq_exchg
+};
+
+
 struct RTV_RSP {                /* Structure is in Big Endian format */
         uint32_t ratov;
         uint32_t edtov;
@@ -1172,7 +1190,10 @@ typedef struct {
 #define PCI_VENDOR_ID_EMULEX        0x10df
 #define PCI_DEVICE_ID_FIREFLY       0x1ae5
 #define PCI_DEVICE_ID_PROTEUS_VF    0xe100
+#define PCI_DEVICE_ID_BALIUS        0xe131
 #define PCI_DEVICE_ID_PROTEUS_PF    0xe180
+#define PCI_DEVICE_ID_LANCER_FC     0xe200
+#define PCI_DEVICE_ID_LANCER_FCOE   0xe260
 #define PCI_DEVICE_ID_SAT_SMB       0xf011
 #define PCI_DEVICE_ID_SAT_MID       0xf015
 #define PCI_DEVICE_ID_RFLY          0xf095
@@ -1189,6 +1210,7 @@ typedef struct {
 #define PCI_DEVICE_ID_SAT           0xf100
 #define PCI_DEVICE_ID_SAT_SCSP      0xf111
 #define PCI_DEVICE_ID_SAT_DCSP      0xf112
+#define PCI_DEVICE_ID_FALCON        0xf180
 #define PCI_DEVICE_ID_SUPERFLY      0xf700
 #define PCI_DEVICE_ID_DRAGONFLY     0xf800
 #define PCI_DEVICE_ID_CENTAUR       0xf900
@@ -1210,8 +1232,6 @@ typedef struct {
 #define PCI_VENDOR_ID_SERVERENGINE  0x19a2
 #define PCI_DEVICE_ID_TIGERSHARK    0x0704
 #define PCI_DEVICE_ID_TOMCAT        0x0714
-#define PCI_DEVICE_ID_FALCON        0xf180
-#define PCI_DEVICE_ID_BALIUS        0xe131
 
 #define JEDEC_ID_ADDRESS            0x0080001c
 #define FIREFLY_JEDEC_ID            0x1ACC
@@ -1368,7 +1388,6 @@ typedef struct {		/* FireFly BIU registers */
 #define MBX_READ_LNK_STAT   0x12
 #define MBX_REG_LOGIN       0x13
 #define MBX_UNREG_LOGIN     0x14
-#define MBX_READ_LA         0x15
 #define MBX_CLEAR_LA        0x16
 #define MBX_DUMP_MEMORY     0x17
 #define MBX_DUMP_CONTEXT    0x18
@@ -1402,7 +1421,7 @@ typedef struct {		/* FireFly BIU registers */
 #define MBX_READ_SPARM64    0x8D
 #define MBX_READ_RPI64      0x8F
 #define MBX_REG_LOGIN64     0x93
-#define MBX_READ_LA64       0x95
+#define MBX_READ_TOPOLOGY   0x95
 #define MBX_REG_VPI         0x96
 #define MBX_UNREG_VPI       0x97
 
@@ -1823,12 +1842,13 @@ typedef struct {
 #define FLAGS_IMED_ABORT             0x04000    /* Bit 14 */
 
         uint32_t link_speed;
-#define LINK_SPEED_AUTO 0       /* Auto selection */
-#define LINK_SPEED_1G   1       /* 1 Gigabaud */
-#define LINK_SPEED_2G   2       /* 2 Gigabaud */
-#define LINK_SPEED_4G   4       /* 4 Gigabaud */
-#define LINK_SPEED_8G   8       /* 8 Gigabaud */
-#define LINK_SPEED_10G   16      /* 10 Gigabaud */
+#define LINK_SPEED_AUTO 0x0     /* Auto selection */
+#define LINK_SPEED_1G   0x1     /* 1 Gigabaud */
+#define LINK_SPEED_2G   0x2     /* 2 Gigabaud */
+#define LINK_SPEED_4G   0x4     /* 4 Gigabaud */
+#define LINK_SPEED_8G   0x8     /* 8 Gigabaud */
+#define LINK_SPEED_10G  0x10    /* 10 Gigabaud */
+#define LINK_SPEED_16G  0x11    /* 16 Gigabaud */
 
 } INIT_LINK_VAR;
 
@@ -1999,6 +2019,7 @@ typedef struct {
 #define LMT_4Gb       0x040
 #define LMT_8Gb       0x080
 #define LMT_10Gb      0x100
+#define LMT_16Gb      0x200
         uint32_t rsvd2;
         uint32_t rsvd3;
         uint32_t max_xri;
@@ -2394,100 +2415,93 @@ typedef struct {
 #endif
 } UNREG_D_ID_VAR;
 
-/* Structure for MB Command READ_LA (21) */
-/* Structure for MB Command READ_LA64 (0x95) */
-
-typedef struct {
+/* Structure for MB Command READ_TOPOLOGY (0x95) */
+struct lpfc_mbx_read_top {
         uint32_t eventTag;      /* Event tag */
-#ifdef __BIG_ENDIAN_BITFIELD
-        uint32_t rsvd1:19;
-        uint32_t fa:1;
-        uint32_t mm:1;          /* Menlo Maintenance mode enabled */
-        uint32_t rx:1;
-        uint32_t pb:1;
-        uint32_t il:1;
-        uint32_t attType:8;
-#else   /*  __LITTLE_ENDIAN_BITFIELD */
-        uint32_t attType:8;
-        uint32_t il:1;
-        uint32_t pb:1;
-        uint32_t rx:1;
-        uint32_t mm:1;
-        uint32_t fa:1;
-        uint32_t rsvd1:19;
-#endif
-
-#define AT_RESERVED    0x00     /* Reserved - attType */
-#define AT_LINK_UP     0x01     /* Link is up */
-#define AT_LINK_DOWN   0x02     /* Link is down */
-
-#ifdef __BIG_ENDIAN_BITFIELD
-        uint8_t granted_AL_PA;
-        uint8_t lipAlPs;
-        uint8_t lipType;
-        uint8_t topology;
-#else   /*  __LITTLE_ENDIAN_BITFIELD */
-        uint8_t topology;
-        uint8_t lipType;
-        uint8_t lipAlPs;
-        uint8_t granted_AL_PA;
-#endif
-
-#define TOPOLOGY_PT_PT 0x01     /* Topology is pt-pt / pt-fabric */
-#define TOPOLOGY_LOOP  0x02     /* Topology is FC-AL */
-#define TOPOLOGY_LNK_MENLO_MAINTENANCE 0x05 /* maint mode zephtr to menlo */
-
-        union {
-                struct ulp_bde lilpBde; /* This BDE points to a 128 byte buffer
-                                           to */
-                /* store the LILP AL_PA position map into */
-                struct ulp_bde64 lilpBde64;
-        } un;
-
-#ifdef __BIG_ENDIAN_BITFIELD
-        uint32_t Dlu:1;
-        uint32_t Dtf:1;
-        uint32_t Drsvd2:14;
-        uint32_t DlnkSpeed:8;
-        uint32_t DnlPort:4;
-        uint32_t Dtx:2;
-        uint32_t Drx:2;
-#else   /*  __LITTLE_ENDIAN_BITFIELD */
-        uint32_t Drx:2;
-        uint32_t Dtx:2;
-        uint32_t DnlPort:4;
-        uint32_t DlnkSpeed:8;
-        uint32_t Drsvd2:14;
-        uint32_t Dtf:1;
-        uint32_t Dlu:1;
-#endif
-
-#ifdef __BIG_ENDIAN_BITFIELD
-        uint32_t Ulu:1;
-        uint32_t Utf:1;
-        uint32_t Ursvd2:14;
-        uint32_t UlnkSpeed:8;
-        uint32_t UnlPort:4;
-        uint32_t Utx:2;
-        uint32_t Urx:2;
-#else   /*  __LITTLE_ENDIAN_BITFIELD */
-        uint32_t Urx:2;
-        uint32_t Utx:2;
-        uint32_t UnlPort:4;
-        uint32_t UlnkSpeed:8;
-        uint32_t Ursvd2:14;
-        uint32_t Utf:1;
-        uint32_t Ulu:1;
-#endif
-
-#define LA_UNKNW_LINK  0x0    /* lnkSpeed */
-#define LA_1GHZ_LINK   0x04   /* lnkSpeed */
-#define LA_2GHZ_LINK   0x08   /* lnkSpeed */
-#define LA_4GHZ_LINK   0x10   /* lnkSpeed */
-#define LA_8GHZ_LINK   0x20   /* lnkSpeed */
-#define LA_10GHZ_LINK  0x40   /* lnkSpeed */
-
-} READ_LA_VAR;
+        uint32_t word2;
+#define lpfc_mbx_read_top_fa_SHIFT              12
+#define lpfc_mbx_read_top_fa_MASK               0x00000001
+#define lpfc_mbx_read_top_fa_WORD               word2
+#define lpfc_mbx_read_top_mm_SHIFT              11
+#define lpfc_mbx_read_top_mm_MASK               0x00000001
+#define lpfc_mbx_read_top_mm_WORD               word2
+#define lpfc_mbx_read_top_pb_SHIFT              9
+#define lpfc_mbx_read_top_pb_MASK               0X00000001
+#define lpfc_mbx_read_top_pb_WORD               word2
+#define lpfc_mbx_read_top_il_SHIFT              8
+#define lpfc_mbx_read_top_il_MASK               0x00000001
+#define lpfc_mbx_read_top_il_WORD               word2
+#define lpfc_mbx_read_top_att_type_SHIFT        0
+#define lpfc_mbx_read_top_att_type_MASK         0x000000FF
+#define lpfc_mbx_read_top_att_type_WORD         word2
+#define LPFC_ATT_RESERVED    0x00       /* Reserved - attType */
+#define LPFC_ATT_LINK_UP     0x01       /* Link is up */
+#define LPFC_ATT_LINK_DOWN   0x02       /* Link is down */
+        uint32_t word3;
+#define lpfc_mbx_read_top_alpa_granted_SHIFT    24
+#define lpfc_mbx_read_top_alpa_granted_MASK     0x000000FF
+#define lpfc_mbx_read_top_alpa_granted_WORD     word3
+#define lpfc_mbx_read_top_lip_alps_SHIFT        16
+#define lpfc_mbx_read_top_lip_alps_MASK         0x000000FF
+#define lpfc_mbx_read_top_lip_alps_WORD         word3
+#define lpfc_mbx_read_top_lip_type_SHIFT        8
+#define lpfc_mbx_read_top_lip_type_MASK         0x000000FF
+#define lpfc_mbx_read_top_lip_type_WORD         word3
+#define lpfc_mbx_read_top_topology_SHIFT        0
+#define lpfc_mbx_read_top_topology_MASK         0x000000FF
+#define lpfc_mbx_read_top_topology_WORD         word3
+#define LPFC_TOPOLOGY_PT_PT 0x01        /* Topology is pt-pt / pt-fabric */
+#define LPFC_TOPOLOGY_LOOP  0x02        /* Topology is FC-AL */
+#define LPFC_TOPOLOGY_MM    0x05        /* maint mode zephtr to menlo */
+        /* store the LILP AL_PA position map into */
+        struct ulp_bde64 lilpBde64;
+#define LPFC_ALPA_MAP_SIZE      128
+        uint32_t word7;
+#define lpfc_mbx_read_top_ld_lu_SHIFT           31
+#define lpfc_mbx_read_top_ld_lu_MASK            0x00000001
+#define lpfc_mbx_read_top_ld_lu_WORD            word7
+#define lpfc_mbx_read_top_ld_tf_SHIFT           30
+#define lpfc_mbx_read_top_ld_tf_MASK            0x00000001
+#define lpfc_mbx_read_top_ld_tf_WORD            word7
+#define lpfc_mbx_read_top_ld_link_spd_SHIFT     8
+#define lpfc_mbx_read_top_ld_link_spd_MASK      0x000000FF
+#define lpfc_mbx_read_top_ld_link_spd_WORD      word7
+#define lpfc_mbx_read_top_ld_nl_port_SHIFT      4
+#define lpfc_mbx_read_top_ld_nl_port_MASK       0x0000000F
+#define lpfc_mbx_read_top_ld_nl_port_WORD       word7
+#define lpfc_mbx_read_top_ld_tx_SHIFT           2
+#define lpfc_mbx_read_top_ld_tx_MASK            0x00000003
+#define lpfc_mbx_read_top_ld_tx_WORD            word7
+#define lpfc_mbx_read_top_ld_rx_SHIFT           0
+#define lpfc_mbx_read_top_ld_rx_MASK            0x00000003
+#define lpfc_mbx_read_top_ld_rx_WORD            word7
+        uint32_t word8;
+#define lpfc_mbx_read_top_lu_SHIFT              31
+#define lpfc_mbx_read_top_lu_MASK               0x00000001
+#define lpfc_mbx_read_top_lu_WORD               word8
+#define lpfc_mbx_read_top_tf_SHIFT              30
+#define lpfc_mbx_read_top_tf_MASK               0x00000001
+#define lpfc_mbx_read_top_tf_WORD               word8
+#define lpfc_mbx_read_top_link_spd_SHIFT        8
+#define lpfc_mbx_read_top_link_spd_MASK         0x000000FF
+#define lpfc_mbx_read_top_link_spd_WORD         word8
+#define lpfc_mbx_read_top_nl_port_SHIFT         4
+#define lpfc_mbx_read_top_nl_port_MASK          0x0000000F
+#define lpfc_mbx_read_top_nl_port_WORD          word8
+#define lpfc_mbx_read_top_tx_SHIFT              2
+#define lpfc_mbx_read_top_tx_MASK               0x00000003
+#define lpfc_mbx_read_top_tx_WORD               word8
+#define lpfc_mbx_read_top_rx_SHIFT              0
+#define lpfc_mbx_read_top_rx_MASK               0x00000003
+#define lpfc_mbx_read_top_rx_WORD               word8
+#define LPFC_LINK_SPEED_UNKNOWN 0x0
+#define LPFC_LINK_SPEED_1GHZ    0x04
+#define LPFC_LINK_SPEED_2GHZ    0x08
+#define LPFC_LINK_SPEED_4GHZ    0x10
+#define LPFC_LINK_SPEED_8GHZ    0x20
+#define LPFC_LINK_SPEED_10GHZ   0x40
+#define LPFC_LINK_SPEED_16GHZ   0x80
+};
 
 /* Structure for MB Command CLEAR_LA (22) */
 
@@ -3016,7 +3030,6 @@ typedef union {
         READ_LNK_VAR varRdLnk;          /* cmd = 18 (READ_LNK_STAT)  */
         REG_LOGIN_VAR varRegLogin;      /* cmd = 19 (REG_LOGIN(64))  */
         UNREG_LOGIN_VAR varUnregLogin;  /* cmd = 20 (UNREG_LOGIN)    */
-        READ_LA_VAR varReadLA;          /* cmd = 21 (READ_LA(64))    */
         CLEAR_LA_VAR varClearLA;        /* cmd = 22 (CLEAR_LA)       */
         DUMP_VAR varDmp;                /* Warm Start DUMP mbx cmd   */
         UNREG_D_ID_VAR varUnregDID;     /* cmd = 0x23 (UNREG_D_ID)   */
@@ -3026,6 +3039,7 @@ typedef union {
         struct config_hbq_var varCfgHbq;/* cmd = 0x7c (CONFIG_HBQ)  */
         struct update_cfg_var varUpdateCfg; /* cmd = 0x1B (UPDATE_CFG)*/
         CONFIG_PORT_VAR varCfgPort;     /* cmd = 0x88 (CONFIG_PORT)  */
+        struct lpfc_mbx_read_top varReadTop; /* cmd = 0x95 (READ_TOPOLOGY) */
         REG_VPI_VAR varRegVpi;          /* cmd = 0x96 (REG_VPI) */
         UNREG_VPI_VAR varUnregVpi;      /* cmd = 0x97 (UNREG_VPI) */
         ASYNCEVT_ENABLE_VAR varCfgAsyncEvent; /*cmd = x33 (CONFIG_ASYNC) */
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 6e4bc34e1d0d..94c1aa1136de 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -64,29 +64,39 @@ struct lpfc_sli_intf {
 #define lpfc_sli_intf_valid_MASK                0x00000007
 #define lpfc_sli_intf_valid_WORD                word0
 #define LPFC_SLI_INTF_VALID             6
-#define lpfc_sli_intf_featurelevel2_SHIFT       24
-#define lpfc_sli_intf_featurelevel2_MASK        0x0000001F
-#define lpfc_sli_intf_featurelevel2_WORD        word0
-#define lpfc_sli_intf_featurelevel1_SHIFT       16
-#define lpfc_sli_intf_featurelevel1_MASK        0x000000FF
-#define lpfc_sli_intf_featurelevel1_WORD        word0
-#define LPFC_SLI_INTF_FEATURELEVEL1_1   1
-#define LPFC_SLI_INTF_FEATURELEVEL1_2   2
+#define lpfc_sli_intf_sli_hint2_SHIFT           24
+#define lpfc_sli_intf_sli_hint2_MASK            0x0000001F
+#define lpfc_sli_intf_sli_hint2_WORD            word0
+#define LPFC_SLI_INTF_SLI_HINT2_NONE    0
+#define lpfc_sli_intf_sli_hint1_SHIFT           16
+#define lpfc_sli_intf_sli_hint1_MASK            0x000000FF
+#define lpfc_sli_intf_sli_hint1_WORD            word0
+#define LPFC_SLI_INTF_SLI_HINT1_NONE    0
+#define LPFC_SLI_INTF_SLI_HINT1_1       1
+#define LPFC_SLI_INTF_SLI_HINT1_2       2
+#define lpfc_sli_intf_if_type_SHIFT             12
+#define lpfc_sli_intf_if_type_MASK              0x0000000F
+#define lpfc_sli_intf_if_type_WORD              word0
+#define LPFC_SLI_INTF_IF_TYPE_0         0
+#define LPFC_SLI_INTF_IF_TYPE_1         1
+#define LPFC_SLI_INTF_IF_TYPE_2         2
 #define lpfc_sli_intf_sli_family_SHIFT          8
-#define lpfc_sli_intf_sli_family_MASK           0x000000FF
+#define lpfc_sli_intf_sli_family_MASK           0x0000000F
 #define lpfc_sli_intf_sli_family_WORD           word0
-#define LPFC_SLI_INTF_FAMILY_BE2        0
-#define LPFC_SLI_INTF_FAMILY_BE3        1
+#define LPFC_SLI_INTF_FAMILY_BE2        0x0
+#define LPFC_SLI_INTF_FAMILY_BE3        0x1
+#define LPFC_SLI_INTF_FAMILY_LNCR_A0    0xa
+#define LPFC_SLI_INTF_FAMILY_LNCR_B0    0xb
 #define lpfc_sli_intf_slirev_SHIFT              4
 #define lpfc_sli_intf_slirev_MASK               0x0000000F
 #define lpfc_sli_intf_slirev_WORD               word0
 #define LPFC_SLI_INTF_REV_SLI3          3
 #define LPFC_SLI_INTF_REV_SLI4          4
-#define lpfc_sli_intf_if_type_SHIFT             0
-#define lpfc_sli_intf_if_type_MASK              0x00000007
-#define lpfc_sli_intf_if_type_WORD              word0
-#define LPFC_SLI_INTF_IF_TYPE_0         0
-#define LPFC_SLI_INTF_IF_TYPE_1         1
+#define lpfc_sli_intf_func_type_SHIFT           0
+#define lpfc_sli_intf_func_type_MASK            0x00000001
+#define lpfc_sli_intf_func_type_WORD            word0
+#define LPFC_SLI_INTF_IF_TYPE_PHYS      0
+#define LPFC_SLI_INTF_IF_TYPE_VIRT      1
 };
 
 #define LPFC_SLI4_MBX_EMBED     true
@@ -450,35 +460,40 @@ struct lpfc_register {
         uint32_t word0;
 };
 
+/* The following BAR0 Registers apply to SLI4 if_type 0 UCNAs. */
 #define LPFC_UERR_STATUS_HI             0x00A4
 #define LPFC_UERR_STATUS_LO             0x00A0
 #define LPFC_UE_MASK_HI                 0x00AC
 #define LPFC_UE_MASK_LO                 0x00A8
+
+/* The following BAR0 register sets are defined for if_type 0 and 2 UCNAs. */
 #define LPFC_SLI_INTF                   0x0058
 
-/* BAR0 Registers */
-#define LPFC_HST_STATE                  0x00AC
-#define lpfc_hst_state_perr_SHIFT       31
-#define lpfc_hst_state_perr_MASK        0x1
-#define lpfc_hst_state_perr_WORD        word0
-#define lpfc_hst_state_sfi_SHIFT        30
-#define lpfc_hst_state_sfi_MASK         0x1
-#define lpfc_hst_state_sfi_WORD         word0
-#define lpfc_hst_state_nip_SHIFT        29
-#define lpfc_hst_state_nip_MASK         0x1
-#define lpfc_hst_state_nip_WORD         word0
-#define lpfc_hst_state_ipc_SHIFT        28
-#define lpfc_hst_state_ipc_MASK         0x1
-#define lpfc_hst_state_ipc_WORD         word0
-#define lpfc_hst_state_xrom_SHIFT       27
-#define lpfc_hst_state_xrom_MASK        0x1
-#define lpfc_hst_state_xrom_WORD        word0
-#define lpfc_hst_state_dl_SHIFT         26
-#define lpfc_hst_state_dl_MASK          0x1
-#define lpfc_hst_state_dl_WORD          word0
-#define lpfc_hst_state_port_status_SHIFT        0
-#define lpfc_hst_state_port_status_MASK         0xFFFF
-#define lpfc_hst_state_port_status_WORD         word0
+#define LPFC_SLIPORT_IF2_SMPHR          0x0400
+#define lpfc_port_smphr_perr_SHIFT      31
+#define lpfc_port_smphr_perr_MASK       0x1
+#define lpfc_port_smphr_perr_WORD       word0
+#define lpfc_port_smphr_sfi_SHIFT       30
+#define lpfc_port_smphr_sfi_MASK        0x1
+#define lpfc_port_smphr_sfi_WORD        word0
+#define lpfc_port_smphr_nip_SHIFT       29
+#define lpfc_port_smphr_nip_MASK        0x1
+#define lpfc_port_smphr_nip_WORD        word0
+#define lpfc_port_smphr_ipc_SHIFT       28
+#define lpfc_port_smphr_ipc_MASK        0x1
+#define lpfc_port_smphr_ipc_WORD        word0
+#define lpfc_port_smphr_scr1_SHIFT      27
+#define lpfc_port_smphr_scr1_MASK       0x1
+#define lpfc_port_smphr_scr1_WORD       word0
+#define lpfc_port_smphr_scr2_SHIFT      26
+#define lpfc_port_smphr_scr2_MASK       0x1
+#define lpfc_port_smphr_scr2_WORD       word0
+#define lpfc_port_smphr_host_scratch_SHIFT      16
+#define lpfc_port_smphr_host_scratch_MASK       0xFF
+#define lpfc_port_smphr_host_scratch_WORD       word0
+#define lpfc_port_smphr_port_status_SHIFT       0
+#define lpfc_port_smphr_port_status_MASK        0xFFFF
+#define lpfc_port_smphr_port_status_WORD        word0
 
 #define LPFC_POST_STAGE_POWER_ON_RESET                  0x0000
 #define LPFC_POST_STAGE_AWAITING_HOST_RDY               0x0001
@@ -511,10 +526,46 @@ struct lpfc_register {
 #define LPFC_POST_STAGE_RC_DONE                         0x0B07
 #define LPFC_POST_STAGE_REBOOT_SYSTEM                   0x0B08
 #define LPFC_POST_STAGE_MAC_ADDRESS                     0x0C00
-#define LPFC_POST_STAGE_ARMFW_READY                     0xC000
-#define LPFC_POST_STAGE_ARMFW_UE                        0xF000
+#define LPFC_POST_STAGE_PORT_READY                      0xC000
+#define LPFC_POST_STAGE_PORT_UE                         0xF000
+
+#define LPFC_SLIPORT_STATUS             0x0404
+#define lpfc_sliport_status_err_SHIFT   31
+#define lpfc_sliport_status_err_MASK    0x1
+#define lpfc_sliport_status_err_WORD    word0
+#define lpfc_sliport_status_end_SHIFT   30
+#define lpfc_sliport_status_end_MASK    0x1
+#define lpfc_sliport_status_end_WORD    word0
+#define lpfc_sliport_status_oti_SHIFT   29
+#define lpfc_sliport_status_oti_MASK    0x1
+#define lpfc_sliport_status_oti_WORD    word0
+#define lpfc_sliport_status_rn_SHIFT    24
+#define lpfc_sliport_status_rn_MASK     0x1
+#define lpfc_sliport_status_rn_WORD     word0
+#define lpfc_sliport_status_rdy_SHIFT   23
+#define lpfc_sliport_status_rdy_MASK    0x1
+#define lpfc_sliport_status_rdy_WORD    word0
+#define MAX_IF_TYPE_2_RESETS    1000
+
+#define LPFC_SLIPORT_CNTRL              0x0408
+#define lpfc_sliport_ctrl_end_SHIFT     30
+#define lpfc_sliport_ctrl_end_MASK      0x1
+#define lpfc_sliport_ctrl_end_WORD      word0
+#define LPFC_SLIPORT_LITTLE_ENDIAN 0
+#define LPFC_SLIPORT_BIG_ENDIAN    1
+#define lpfc_sliport_ctrl_ip_SHIFT      27
+#define lpfc_sliport_ctrl_ip_MASK       0x1
+#define lpfc_sliport_ctrl_ip_WORD       word0
+#define LPFC_SLIPORT_INIT_PORT  1
+
+#define LPFC_SLIPORT_ERR_1              0x040C
+#define LPFC_SLIPORT_ERR_2              0x0410
+
+/* The following Registers apply to SLI4 if_type 0 UCNAs. They typically
+ * reside in BAR 2.
+ */
+#define LPFC_SLIPORT_IF0_SMPHR  0x00AC
 
-/* BAR1 Registers */
 #define LPFC_IMR_MASK_ALL       0xFFFFFFFF
 #define LPFC_ISCR_CLEAR_ALL     0xFFFFFFFF
 
@@ -569,14 +620,21 @@ struct lpfc_register {
 #define LPFC_SLI4_INTR30                BIT30
 #define LPFC_SLI4_INTR31                BIT31
 
-/* BAR2 Registers */
+/*
+ * The Doorbell registers defined here exist in different BAR
+ * register sets depending on the UCNA Port's reported if_type
+ * value.  For UCNA ports running SLI4 and if_type 0, they reside in
+ * BAR4.  For UCNA ports running SLI4 and if_type 2, they reside in
+ * BAR0.  The offsets are the same so the driver must account for
+ * any base address difference.
+ */
 #define LPFC_RQ_DOORBELL                0x00A0
 #define lpfc_rq_doorbell_num_posted_SHIFT       16
 #define lpfc_rq_doorbell_num_posted_MASK        0x3FFF
 #define lpfc_rq_doorbell_num_posted_WORD        word0
 #define LPFC_RQ_POST_BATCH              8       /* RQEs to post at one time */
 #define lpfc_rq_doorbell_id_SHIFT               0
-#define lpfc_rq_doorbell_id_MASK                0x03FF
+#define lpfc_rq_doorbell_id_MASK                0xFFFF
 #define lpfc_rq_doorbell_id_WORD                word0
 
 #define LPFC_WQ_DOORBELL                0x0040
@@ -591,6 +649,11 @@ struct lpfc_register {
 #define lpfc_wq_doorbell_id_WORD                word0
 
 #define LPFC_EQCQ_DOORBELL              0x0120
+#define lpfc_eqcq_doorbell_se_SHIFT             31
+#define lpfc_eqcq_doorbell_se_MASK              0x0001
+#define lpfc_eqcq_doorbell_se_WORD              word0
+#define LPFC_EQCQ_SOLICIT_ENABLE_OFF    0
+#define LPFC_EQCQ_SOLICIT_ENABLE_ON     1
 #define lpfc_eqcq_doorbell_arm_SHIFT            29
 #define lpfc_eqcq_doorbell_arm_MASK             0x0001
 #define lpfc_eqcq_doorbell_arm_WORD             word0
@@ -628,7 +691,7 @@ struct lpfc_register {
 #define lpfc_mq_doorbell_num_posted_MASK        0x3FFF
 #define lpfc_mq_doorbell_num_posted_WORD        word0
 #define lpfc_mq_doorbell_id_SHIFT               0
-#define lpfc_mq_doorbell_id_MASK                0x03FF
+#define lpfc_mq_doorbell_id_MASK                0xFFFF
 #define lpfc_mq_doorbell_id_WORD                word0
 
 struct lpfc_sli4_cfg_mhdr {
@@ -1048,12 +1111,18 @@ struct lpfc_mbx_mq_create_ext {
 #define lpfc_mbx_mq_create_ext_async_evt_link_SHIFT     LPFC_TRAILER_CODE_LINK
 #define lpfc_mbx_mq_create_ext_async_evt_link_MASK      0x00000001
 #define lpfc_mbx_mq_create_ext_async_evt_link_WORD      async_evt_bmap
-#define lpfc_mbx_mq_create_ext_async_evt_fcfste_SHIFT   LPFC_TRAILER_CODE_FCOE
-#define lpfc_mbx_mq_create_ext_async_evt_fcfste_MASK    0x00000001
-#define lpfc_mbx_mq_create_ext_async_evt_fcfste_WORD    async_evt_bmap
+#define lpfc_mbx_mq_create_ext_async_evt_fip_SHIFT      LPFC_TRAILER_CODE_FCOE
+#define lpfc_mbx_mq_create_ext_async_evt_fip_MASK       0x00000001
+#define lpfc_mbx_mq_create_ext_async_evt_fip_WORD       async_evt_bmap
 #define lpfc_mbx_mq_create_ext_async_evt_group5_SHIFT   LPFC_TRAILER_CODE_GRP5
 #define lpfc_mbx_mq_create_ext_async_evt_group5_MASK    0x00000001
 #define lpfc_mbx_mq_create_ext_async_evt_group5_WORD    async_evt_bmap
+#define lpfc_mbx_mq_create_ext_async_evt_fc_SHIFT       LPFC_TRAILER_CODE_FC
+#define lpfc_mbx_mq_create_ext_async_evt_fc_MASK        0x00000001
+#define lpfc_mbx_mq_create_ext_async_evt_fc_WORD        async_evt_bmap
+#define lpfc_mbx_mq_create_ext_async_evt_sli_SHIFT      LPFC_TRAILER_CODE_SLI
+#define lpfc_mbx_mq_create_ext_async_evt_sli_MASK       0x00000001
+#define lpfc_mbx_mq_create_ext_async_evt_sli_WORD       async_evt_bmap
                         struct mq_context context;
                         struct dma_address page[LPFC_MAX_MQ_PAGE];
                 } request;
@@ -1307,7 +1376,7 @@ struct lpfc_mbx_query_fw_cfg {
 #define lpfc_function_mode_dal_WORD             function_mode
 #define lpfc_function_mode_lro_SHIFT            9
 #define lpfc_function_mode_lro_MASK             0x00000001
-#define lpfc_function_mode_lro_WORD             function_mode9
+#define lpfc_function_mode_lro_WORD             function_mode
 #define lpfc_function_mode_flex10_SHIFT         10
 #define lpfc_function_mode_flex10_MASK          0x00000001
 #define lpfc_function_mode_flex10_WORD          function_mode
@@ -1358,10 +1427,16 @@ struct lpfc_mbx_init_vfi {
 #define lpfc_init_vfi_vf_SHIFT          29
 #define lpfc_init_vfi_vf_MASK           0x00000001
 #define lpfc_init_vfi_vf_WORD           word1
+#define lpfc_init_vfi_vp_SHIFT          28
+#define lpfc_init_vfi_vp_MASK           0x00000001
+#define lpfc_init_vfi_vp_WORD           word1
 #define lpfc_init_vfi_vfi_SHIFT         0
 #define lpfc_init_vfi_vfi_MASK          0x0000FFFF
 #define lpfc_init_vfi_vfi_WORD          word1
         uint32_t word2;
+#define lpfc_init_vfi_vpi_SHIFT         16
+#define lpfc_init_vfi_vpi_MASK          0x0000FFFF
+#define lpfc_init_vfi_vpi_WORD          word2
 #define lpfc_init_vfi_fcfi_SHIFT        0
 #define lpfc_init_vfi_fcfi_MASK         0x0000FFFF
 #define lpfc_init_vfi_fcfi_WORD         word2
@@ -2069,6 +2144,8 @@ struct lpfc_mcqe {
 #define LPFC_TRAILER_CODE_FCOE  0x2
 #define LPFC_TRAILER_CODE_DCBX  0x3
 #define LPFC_TRAILER_CODE_GRP5  0x5
+#define LPFC_TRAILER_CODE_FC    0x10
+#define LPFC_TRAILER_CODE_SLI   0x11
 };
 
 struct lpfc_acqe_link {
@@ -2094,11 +2171,12 @@ struct lpfc_acqe_link {
 #define LPFC_ASYNC_LINK_STATUS_UP               0x1
 #define LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN     0x2
 #define LPFC_ASYNC_LINK_STATUS_LOGICAL_UP       0x3
-#define lpfc_acqe_link_physical_SHIFT           0
-#define lpfc_acqe_link_physical_MASK            0x000000FF
-#define lpfc_acqe_link_physical_WORD            word0
-#define LPFC_ASYNC_LINK_PORT_A                  0x0
-#define LPFC_ASYNC_LINK_PORT_B                  0x1
+#define lpfc_acqe_link_type_SHIFT               6
+#define lpfc_acqe_link_type_MASK                0x00000003
+#define lpfc_acqe_link_type_WORD                word0
+#define lpfc_acqe_link_number_SHIFT             0
+#define lpfc_acqe_link_number_MASK              0x0000003F
+#define lpfc_acqe_link_number_WORD              word0
         uint32_t word1;
 #define lpfc_acqe_link_fault_SHIFT      0
 #define lpfc_acqe_link_fault_MASK       0x000000FF
@@ -2106,29 +2184,31 @@ struct lpfc_acqe_link {
 #define LPFC_ASYNC_LINK_FAULT_NONE      0x0
 #define LPFC_ASYNC_LINK_FAULT_LOCAL     0x1
 #define LPFC_ASYNC_LINK_FAULT_REMOTE    0x2
-#define lpfc_acqe_qos_link_speed_SHIFT  16
-#define lpfc_acqe_qos_link_speed_MASK   0x0000FFFF
-#define lpfc_acqe_qos_link_speed_WORD   word1
+#define lpfc_acqe_logical_link_speed_SHIFT      16
+#define lpfc_acqe_logical_link_speed_MASK       0x0000FFFF
+#define lpfc_acqe_logical_link_speed_WORD       word1
         uint32_t event_tag;
         uint32_t trailer;
+#define LPFC_LINK_EVENT_TYPE_PHYSICAL   0x0
+#define LPFC_LINK_EVENT_TYPE_VIRTUAL    0x1
 };
 
-struct lpfc_acqe_fcoe {
+struct lpfc_acqe_fip {
         uint32_t index;
         uint32_t word1;
-#define lpfc_acqe_fcoe_fcf_count_SHIFT          0
-#define lpfc_acqe_fcoe_fcf_count_MASK           0x0000FFFF
-#define lpfc_acqe_fcoe_fcf_count_WORD           word1
-#define lpfc_acqe_fcoe_event_type_SHIFT         16
-#define lpfc_acqe_fcoe_event_type_MASK          0x0000FFFF
-#define lpfc_acqe_fcoe_event_type_WORD          word1
-#define LPFC_FCOE_EVENT_TYPE_NEW_FCF            0x1
-#define LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL     0x2
-#define LPFC_FCOE_EVENT_TYPE_FCF_DEAD           0x3
-#define LPFC_FCOE_EVENT_TYPE_CVL                0x4
-#define LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD      0x5
+#define lpfc_acqe_fip_fcf_count_SHIFT           0
+#define lpfc_acqe_fip_fcf_count_MASK            0x0000FFFF
+#define lpfc_acqe_fip_fcf_count_WORD            word1
+#define lpfc_acqe_fip_event_type_SHIFT          16
+#define lpfc_acqe_fip_event_type_MASK           0x0000FFFF
+#define lpfc_acqe_fip_event_type_WORD           word1
         uint32_t event_tag;
         uint32_t trailer;
+#define LPFC_FIP_EVENT_TYPE_NEW_FCF             0x1
+#define LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL      0x2
+#define LPFC_FIP_EVENT_TYPE_FCF_DEAD            0x3
+#define LPFC_FIP_EVENT_TYPE_CVL                 0x4
+#define LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD       0x5
 };
 
 struct lpfc_acqe_dcbx {
@@ -2140,9 +2220,12 @@ struct lpfc_acqe_dcbx {
 
 struct lpfc_acqe_grp5 {
         uint32_t word0;
-#define lpfc_acqe_grp5_pport_SHIFT      0
-#define lpfc_acqe_grp5_pport_MASK       0x000000FF
-#define lpfc_acqe_grp5_pport_WORD       word0
+#define lpfc_acqe_grp5_type_SHIFT               6
+#define lpfc_acqe_grp5_type_MASK                0x00000003
+#define lpfc_acqe_grp5_type_WORD                word0
+#define lpfc_acqe_grp5_number_SHIFT             0
+#define lpfc_acqe_grp5_number_MASK              0x0000003F
+#define lpfc_acqe_grp5_number_WORD              word0
         uint32_t word1;
 #define lpfc_acqe_grp5_llink_spd_SHIFT  16
 #define lpfc_acqe_grp5_llink_spd_MASK   0x0000FFFF
@@ -2151,6 +2234,68 @@ struct lpfc_acqe_grp5 {
         uint32_t trailer;
 };
 
+struct lpfc_acqe_fc_la {
+        uint32_t word0;
+#define lpfc_acqe_fc_la_speed_SHIFT             24
+#define lpfc_acqe_fc_la_speed_MASK              0x000000FF
+#define lpfc_acqe_fc_la_speed_WORD              word0
+#define LPFC_FC_LA_SPEED_UNKOWN         0x0
+#define LPFC_FC_LA_SPEED_1G             0x1
+#define LPFC_FC_LA_SPEED_2G             0x2
+#define LPFC_FC_LA_SPEED_4G             0x4
+#define LPFC_FC_LA_SPEED_8G             0x8
+#define LPFC_FC_LA_SPEED_10G            0xA
+#define LPFC_FC_LA_SPEED_16G            0x10
+#define lpfc_acqe_fc_la_topology_SHIFT          16
+#define lpfc_acqe_fc_la_topology_MASK           0x000000FF
+#define lpfc_acqe_fc_la_topology_WORD           word0
+#define LPFC_FC_LA_TOP_UNKOWN           0x0
+#define LPFC_FC_LA_TOP_P2P              0x1
+#define LPFC_FC_LA_TOP_FCAL             0x2
+#define LPFC_FC_LA_TOP_INTERNAL_LOOP    0x3
+#define LPFC_FC_LA_TOP_SERDES_LOOP      0x4
+#define lpfc_acqe_fc_la_att_type_SHIFT          8
+#define lpfc_acqe_fc_la_att_type_MASK           0x000000FF
+#define lpfc_acqe_fc_la_att_type_WORD           word0
+#define LPFC_FC_LA_TYPE_LINK_UP         0x1
+#define LPFC_FC_LA_TYPE_LINK_DOWN       0x2
+#define LPFC_FC_LA_TYPE_NO_HARD_ALPA    0x3
+#define lpfc_acqe_fc_la_port_type_SHIFT         6
+#define lpfc_acqe_fc_la_port_type_MASK          0x00000003
+#define lpfc_acqe_fc_la_port_type_WORD          word0
+#define LPFC_LINK_TYPE_ETHERNET         0x0
+#define LPFC_LINK_TYPE_FC               0x1
+#define lpfc_acqe_fc_la_port_number_SHIFT       0
+#define lpfc_acqe_fc_la_port_number_MASK        0x0000003F
+#define lpfc_acqe_fc_la_port_number_WORD        word0
+        uint32_t word1;
+#define lpfc_acqe_fc_la_llink_spd_SHIFT         16
+#define lpfc_acqe_fc_la_llink_spd_MASK          0x0000FFFF
+#define lpfc_acqe_fc_la_llink_spd_WORD          word1
+#define lpfc_acqe_fc_la_fault_SHIFT             0
+#define lpfc_acqe_fc_la_fault_MASK              0x000000FF
+#define lpfc_acqe_fc_la_fault_WORD              word1
+#define LPFC_FC_LA_FAULT_NONE           0x0
+#define LPFC_FC_LA_FAULT_LOCAL          0x1
+#define LPFC_FC_LA_FAULT_REMOTE         0x2
+        uint32_t event_tag;
+        uint32_t trailer;
+#define LPFC_FC_LA_EVENT_TYPE_FC_LINK           0x1
+#define LPFC_FC_LA_EVENT_TYPE_SHARED_LINK       0x2
+};
+
+struct lpfc_acqe_sli {
+        uint32_t event_data1;
+        uint32_t event_data2;
+        uint32_t reserved;
+        uint32_t trailer;
+#define LPFC_SLI_EVENT_TYPE_PORT_ERROR          0x1
+#define LPFC_SLI_EVENT_TYPE_OVER_TEMP           0x2
+#define LPFC_SLI_EVENT_TYPE_NORM_TEMP           0x3
+#define LPFC_SLI_EVENT_TYPE_NVLOG_POST          0x4
+#define LPFC_SLI_EVENT_TYPE_DIAG_DUMP           0x5
+};
+
 /*
  * Define the bootstrap mailbox (bmbx) region used to communicate
  * mailbox command between the host and port. The mailbox consists
@@ -2210,7 +2355,7 @@ struct wqe_common {
 #define wqe_rcvoxid_WORD      word9
         uint32_t word10;
 #define wqe_ebde_cnt_SHIFT    0
-#define wqe_ebde_cnt_MASK     0x00000007
+#define wqe_ebde_cnt_MASK     0x0000000f
 #define wqe_ebde_cnt_WORD     word10
 #define wqe_lenloc_SHIFT      7
 #define wqe_lenloc_MASK       0x00000003
@@ -2402,7 +2547,6 @@ struct xmit_seq64_wqe {
         uint32_t relative_offset;
         struct wqe_rctl_dfctl wge_ctl;
         struct wqe_common wqe_com; /* words 6-11 */
-        /* Note: word10 different REVISIT */
         uint32_t xmit_len;
         uint32_t rsvd_12_15[3];
 };
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index b3065791f303..462242dcdd0a 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -446,23 +446,25 @@ lpfc_config_port_post(struct lpfc_hba *phba)
         /* Get the default values for Model Name and Description */
         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
 
-        if ((phba->cfg_link_speed > LINK_SPEED_10G)
-            || ((phba->cfg_link_speed == LINK_SPEED_1G)
+        if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_16G)
+            || ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G)
                 && !(phba->lmt & LMT_1Gb))
-            || ((phba->cfg_link_speed == LINK_SPEED_2G)
+            || ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G)
                 && !(phba->lmt & LMT_2Gb))
-            || ((phba->cfg_link_speed == LINK_SPEED_4G)
+            || ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G)
                 && !(phba->lmt & LMT_4Gb))
-            || ((phba->cfg_link_speed == LINK_SPEED_8G)
+            || ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G)
                 && !(phba->lmt & LMT_8Gb))
-            || ((phba->cfg_link_speed == LINK_SPEED_10G)
-                && !(phba->lmt & LMT_10Gb))) {
+            || ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G)
+                && !(phba->lmt & LMT_10Gb))
+            || ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G)
+                && !(phba->lmt & LMT_16Gb))) {
                 /* Reset link speed to auto */
                 lpfc_printf_log(phba, KERN_WARNING, LOG_LINK_EVENT,
                         "1302 Invalid speed for this board: "
                         "Reset link speed to auto: x%x\n",
                         phba->cfg_link_speed);
-                        phba->cfg_link_speed = LINK_SPEED_AUTO;
+                        phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
         }
 
         phba->link_state = LPFC_LINK_DOWN;
@@ -648,22 +650,23 @@ lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag)
         mb = &pmb->u.mb;
         pmb->vport = vport;
 
-        lpfc_init_link(phba, pmb, phba->cfg_topology,
-                phba->cfg_link_speed);
+        lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
         lpfc_set_loopback_flag(phba);
         rc = lpfc_sli_issue_mbox(phba, pmb, flag);
-        if (rc != MBX_SUCCESS) {
+        if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                         "0498 Adapter failed to init, mbxCmd x%x "
                         "INIT_LINK, mbxStatus x%x\n",
                         mb->mbxCommand, mb->mbxStatus);
-                /* Clear all interrupt enable conditions */
-                writel(0, phba->HCregaddr);
-                readl(phba->HCregaddr); /* flush */
-                /* Clear all pending interrupts */
-                writel(0xffffffff, phba->HAregaddr);
-                readl(phba->HAregaddr); /* flush */
+                if (phba->sli_rev <= LPFC_SLI_REV3) {
+                        /* Clear all interrupt enable conditions */
+                        writel(0, phba->HCregaddr);
+                        readl(phba->HCregaddr); /* flush */
+                        /* Clear all pending interrupts */
+                        writel(0xffffffff, phba->HAregaddr);
+                        readl(phba->HAregaddr); /* flush */
+                }
                 phba->link_state = LPFC_HBA_ERROR;
                 if (rc != MBX_BUSY || flag == MBX_POLL)
                         mempool_free(pmb, phba->mbox_mem_pool);
@@ -927,6 +930,35 @@ lpfc_hb_timeout(unsigned long ptr)
 }
 
 /**
+ * lpfc_rrq_timeout - The RRQ-timer timeout handler
+ * @ptr: unsigned long holds the pointer to lpfc hba data structure.
+ *
+ * This is the RRQ-timer timeout handler registered to the lpfc driver. When
+ * this timer fires, a RRQ timeout event shall be posted to the lpfc driver
+ * work-port-events bitmap and the worker thread is notified. This timeout
+ * event will be used by the worker thread to invoke the actual timeout
+ * handler routine, lpfc_rrq_handler. Any periodical operations will
+ * be performed in the timeout handler and the RRQ timeout event bit shall
+ * be cleared by the worker thread after it has taken the event bitmap out.
+ **/
+static void
+lpfc_rrq_timeout(unsigned long ptr)
+{
+        struct lpfc_hba *phba;
+        uint32_t tmo_posted;
+        unsigned long iflag;
+
+        phba = (struct lpfc_hba *)ptr;
+        spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
+        tmo_posted = phba->hba_flag & HBA_RRQ_ACTIVE;
+        if (!tmo_posted)
+                phba->hba_flag |= HBA_RRQ_ACTIVE;
+        spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
+        if (!tmo_posted)
+                lpfc_worker_wake_up(phba);
+}
+
+/**
  * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
  * @phba: pointer to lpfc hba data structure.
  * @pmboxq: pointer to the driver internal queue element for mailbox command.
@@ -1374,6 +1406,8 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba)
         struct lpfc_vport *vport = phba->pport;
         uint32_t event_data;
         struct Scsi_Host *shost;
+        uint32_t if_type;
+        struct lpfc_register portstat_reg;
 
         /* If the pci channel is offline, ignore possible errors, since
          * we cannot communicate with the pci card anyway.
@@ -1390,17 +1424,49 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba)
         /* For now, the actual action for SLI4 device handling is not
          * specified yet, just treated it as adaptor hardware failure
          */
-        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                        "0143 SLI4 Adapter Hardware Error Data: x%x x%x\n",
-                        phba->work_status[0], phba->work_status[1]);
-
         event_data = FC_REG_DUMP_EVENT;
         shost = lpfc_shost_from_vport(vport);
         fc_host_post_vendor_event(shost, fc_get_event_number(),
                                   sizeof(event_data), (char *) &event_data,
                                   SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
 
-        lpfc_sli4_offline_eratt(phba);
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        switch (if_type) {
+        case LPFC_SLI_INTF_IF_TYPE_0:
+                lpfc_sli4_offline_eratt(phba);
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_2:
+                portstat_reg.word0 =
+                        readl(phba->sli4_hba.u.if_type2.STATUSregaddr);
+
+                if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) {
+                        /* TODO: Register for Overtemp async events. */
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2889 Port Overtemperature event, "
+                                "taking port\n");
+                        spin_lock_irq(&phba->hbalock);
+                        phba->over_temp_state = HBA_OVER_TEMP;
+                        spin_unlock_irq(&phba->hbalock);
+                        lpfc_sli4_offline_eratt(phba);
+                        return;
+                }
+                if (bf_get(lpfc_sliport_status_rn, &portstat_reg)) {
+                        /*
+                         * TODO: Attempt port recovery via a port reset.
+                         * When fully implemented, the driver should
+                         * attempt to recover the port here and return.
+                         * For now, log an error and take the port offline.
+                         */
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2887 Port Error: Attempting "
+                                        "Port Recovery\n");
+                }
+                lpfc_sli4_offline_eratt(phba);
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_1:
+        default:
+                break;
+        }
 }
 
 /**
@@ -1459,8 +1525,8 @@ lpfc_handle_latt(struct lpfc_hba *phba)
         lpfc_els_flush_all_cmd(phba);
 
         psli->slistat.link_event++;
-        lpfc_read_la(phba, pmb, mp);
-        pmb->mbox_cmpl = lpfc_mbx_cmpl_read_la;
+        lpfc_read_topology(phba, pmb, mp);
+        pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
         pmb->vport = vport;
         /* Block ELS IOCBs until we have processed this mbox command */
         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
@@ -1853,6 +1919,14 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
                 m = (typeof(m)){"LPVe12002", "PCIe Shared I/O",
                                 "Fibre Channel Adapter"};
                 break;
+        case PCI_DEVICE_ID_LANCER_FC:
+                oneConnect = 1;
+                m = (typeof(m)){"Undefined", "PCIe", "Fibre Channel Adapter"};
+                break;
+        case PCI_DEVICE_ID_LANCER_FCOE:
+                oneConnect = 1;
+                m = (typeof(m)){"Undefined", "PCIe", "FCoE"};
+                break;
         default:
                 m = (typeof(m)){"Unknown", "", ""};
                 break;
@@ -2943,63 +3017,6 @@ lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
 }
 
 /**
- * lpfc_sli4_fw_cfg_check - Read the firmware config and verify FCoE support
- * @phba: pointer to lpfc hba data structure.
- *
- * This function uses the QUERY_FW_CFG mailbox command to determine if the
- * firmware loaded supports FCoE. A return of zero indicates that the mailbox
- * was successful and the firmware supports FCoE. Any other return indicates
- * a error. It is assumed that this function will be called before interrupts
- * are enabled.
- **/
-static int
-lpfc_sli4_fw_cfg_check(struct lpfc_hba *phba)
-{
-        int rc = 0;
-        LPFC_MBOXQ_t *mboxq;
-        struct lpfc_mbx_query_fw_cfg *query_fw_cfg;
-        uint32_t length;
-        uint32_t shdr_status, shdr_add_status;
-
-        mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-        if (!mboxq) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "2621 Failed to allocate mbox for "
-                                "query firmware config cmd\n");
-                return -ENOMEM;
-        }
-        query_fw_cfg = &mboxq->u.mqe.un.query_fw_cfg;
-        length = (sizeof(struct lpfc_mbx_query_fw_cfg) -
-                  sizeof(struct lpfc_sli4_cfg_mhdr));
-        lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
-                         LPFC_MBOX_OPCODE_QUERY_FW_CFG,
-                         length, LPFC_SLI4_MBX_EMBED);
-        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
-        /* The IOCTL status is embedded in the mailbox subheader. */
-        shdr_status = bf_get(lpfc_mbox_hdr_status,
-                             &query_fw_cfg->header.cfg_shdr.response);
-        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
-                                 &query_fw_cfg->header.cfg_shdr.response);
-        if (shdr_status || shdr_add_status || rc != MBX_SUCCESS) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "2622 Query Firmware Config failed "
-                                "mbx status x%x, status x%x add_status x%x\n",
-                                rc, shdr_status, shdr_add_status);
-                return -EINVAL;
-        }
-        if (!bf_get(lpfc_function_mode_fcoe_i, query_fw_cfg)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "2623 FCoE Function not supported by firmware. "
-                                "Function mode = %08x\n",
-                                query_fw_cfg->function_mode);
-                return -EINVAL;
-        }
-        if (rc != MBX_TIMEOUT)
-                mempool_free(mboxq, phba->mbox_mem_pool);
-        return 0;
-}
-
-/**
  * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
  * @phba: pointer to lpfc hba data structure.
  * @acqe_link: pointer to the async link completion queue entry.
@@ -3051,20 +3068,20 @@ lpfc_sli4_parse_latt_type(struct lpfc_hba *phba,
         switch (bf_get(lpfc_acqe_link_status, acqe_link)) {
         case LPFC_ASYNC_LINK_STATUS_DOWN:
         case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN:
-                att_type = AT_LINK_DOWN;
+                att_type = LPFC_ATT_LINK_DOWN;
                 break;
         case LPFC_ASYNC_LINK_STATUS_UP:
                 /* Ignore physical link up events - wait for logical link up */
-                att_type = AT_RESERVED;
+                att_type = LPFC_ATT_RESERVED;
                 break;
         case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP:
-                att_type = AT_LINK_UP;
+                att_type = LPFC_ATT_LINK_UP;
                 break;
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "0399 Invalid link attention type: x%x\n",
                                 bf_get(lpfc_acqe_link_status, acqe_link));
-                att_type = AT_RESERVED;
+                att_type = LPFC_ATT_RESERVED;
                 break;
         }
         return att_type;
@@ -3088,36 +3105,32 @@ lpfc_sli4_parse_latt_link_speed(struct lpfc_hba *phba,
 
         switch (bf_get(lpfc_acqe_link_speed, acqe_link)) {
         case LPFC_ASYNC_LINK_SPEED_ZERO:
-                link_speed = LA_UNKNW_LINK;
-                break;
         case LPFC_ASYNC_LINK_SPEED_10MBPS:
-                link_speed = LA_UNKNW_LINK;
-                break;
         case LPFC_ASYNC_LINK_SPEED_100MBPS:
-                link_speed = LA_UNKNW_LINK;
+                link_speed = LPFC_LINK_SPEED_UNKNOWN;
                 break;
         case LPFC_ASYNC_LINK_SPEED_1GBPS:
-                link_speed = LA_1GHZ_LINK;
+                link_speed = LPFC_LINK_SPEED_1GHZ;
                 break;
         case LPFC_ASYNC_LINK_SPEED_10GBPS:
-                link_speed = LA_10GHZ_LINK;
+                link_speed = LPFC_LINK_SPEED_10GHZ;
                 break;
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "0483 Invalid link-attention link speed: x%x\n",
                                 bf_get(lpfc_acqe_link_speed, acqe_link));
-                link_speed = LA_UNKNW_LINK;
+                link_speed = LPFC_LINK_SPEED_UNKNOWN;
                 break;
         }
         return link_speed;
 }
 
 /**
- * lpfc_sli4_async_link_evt - Process the asynchronous link event
+ * lpfc_sli4_async_link_evt - Process the asynchronous FCoE link event
  * @phba: pointer to lpfc hba data structure.
  * @acqe_link: pointer to the async link completion queue entry.
  *
- * This routine is to handle the SLI4 asynchronous link event.
+ * This routine is to handle the SLI4 asynchronous FCoE link event.
  **/
 static void
 lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
@@ -3126,11 +3139,12 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
         struct lpfc_dmabuf *mp;
         LPFC_MBOXQ_t *pmb;
         MAILBOX_t *mb;
-        READ_LA_VAR *la;
+        struct lpfc_mbx_read_top *la;
         uint8_t att_type;
+        int rc;
 
         att_type = lpfc_sli4_parse_latt_type(phba, acqe_link);
-        if (att_type != AT_LINK_DOWN && att_type != AT_LINK_UP)
+        if (att_type != LPFC_ATT_LINK_DOWN && att_type != LPFC_ATT_LINK_UP)
                 return;
         phba->fcoe_eventtag = acqe_link->event_tag;
         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
@@ -3161,45 +3175,168 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
         /* Update link event statistics */
         phba->sli.slistat.link_event++;
 
-        /* Create pseudo lpfc_handle_latt mailbox command from link ACQE */
-        lpfc_read_la(phba, pmb, mp);
+        /* Create lpfc_handle_latt mailbox command from link ACQE */
+        lpfc_read_topology(phba, pmb, mp);
+        pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
         pmb->vport = phba->pport;
 
+        /* Keep the link status for extra SLI4 state machine reference */
+        phba->sli4_hba.link_state.speed =
+                                bf_get(lpfc_acqe_link_speed, acqe_link);
+        phba->sli4_hba.link_state.duplex =
+                                bf_get(lpfc_acqe_link_duplex, acqe_link);
+        phba->sli4_hba.link_state.status =
+                                bf_get(lpfc_acqe_link_status, acqe_link);
+        phba->sli4_hba.link_state.type =
+                                bf_get(lpfc_acqe_link_type, acqe_link);
+        phba->sli4_hba.link_state.number =
+                                bf_get(lpfc_acqe_link_number, acqe_link);
+        phba->sli4_hba.link_state.fault =
+                                bf_get(lpfc_acqe_link_fault, acqe_link);
+        phba->sli4_hba.link_state.logical_speed =
+                        bf_get(lpfc_acqe_logical_link_speed, acqe_link);
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "2900 Async FCoE Link event - Speed:%dGBit duplex:x%x "
+                        "LA Type:x%x Port Type:%d Port Number:%d Logical "
+                        "speed:%dMbps Fault:%d\n",
+                        phba->sli4_hba.link_state.speed,
+                        phba->sli4_hba.link_state.topology,
+                        phba->sli4_hba.link_state.status,
+                        phba->sli4_hba.link_state.type,
+                        phba->sli4_hba.link_state.number,
+                        phba->sli4_hba.link_state.logical_speed * 10,
+                        phba->sli4_hba.link_state.fault);
+        /*
+         * For FC Mode: issue the READ_TOPOLOGY mailbox command to fetch
+         * topology info. Note: Optional for non FC-AL ports.
+         */
+        if (!(phba->hba_flag & HBA_FCOE_MODE)) {
+                rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+                if (rc == MBX_NOT_FINISHED)
+                        goto out_free_dmabuf;
+                return;
+        }
+        /*
+         * For FCoE Mode: fill in all the topology information we need and call
+         * the READ_TOPOLOGY completion routine to continue without actually
+         * sending the READ_TOPOLOGY mailbox command to the port.
+         */
         /* Parse and translate status field */
         mb = &pmb->u.mb;
         mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link);
 
         /* Parse and translate link attention fields */
-        la = (READ_LA_VAR *) &pmb->u.mb.un.varReadLA;
+        la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop;
         la->eventTag = acqe_link->event_tag;
-        la->attType = att_type;
-        la->UlnkSpeed = lpfc_sli4_parse_latt_link_speed(phba, acqe_link);
+        bf_set(lpfc_mbx_read_top_att_type, la, att_type);
+        bf_set(lpfc_mbx_read_top_link_spd, la,
+               lpfc_sli4_parse_latt_link_speed(phba, acqe_link));
 
         /* Fake the the following irrelvant fields */
-        la->topology = TOPOLOGY_PT_PT;
-        la->granted_AL_PA = 0;
-        la->il = 0;
-        la->pb = 0;
-        la->fa = 0;
-        la->mm = 0;
+        bf_set(lpfc_mbx_read_top_topology, la, LPFC_TOPOLOGY_PT_PT);
+        bf_set(lpfc_mbx_read_top_alpa_granted, la, 0);
+        bf_set(lpfc_mbx_read_top_il, la, 0);
+        bf_set(lpfc_mbx_read_top_pb, la, 0);
+        bf_set(lpfc_mbx_read_top_fa, la, 0);
+        bf_set(lpfc_mbx_read_top_mm, la, 0);
+
+        /* Invoke the lpfc_handle_latt mailbox command callback function */
+        lpfc_mbx_cmpl_read_topology(phba, pmb);
+
+        return;
 
+out_free_dmabuf:
+        kfree(mp);
+out_free_pmb:
+        mempool_free(pmb, phba->mbox_mem_pool);
+}
+
+/**
+ * lpfc_sli4_async_fc_evt - Process the asynchronous FC link event
+ * @phba: pointer to lpfc hba data structure.
+ * @acqe_fc: pointer to the async fc completion queue entry.
+ *
+ * This routine is to handle the SLI4 asynchronous FC event. It will simply log
+ * that the event was received and then issue a read_topology mailbox command so
+ * that the rest of the driver will treat it the same as SLI3.
+ **/
+static void
+lpfc_sli4_async_fc_evt(struct lpfc_hba *phba, struct lpfc_acqe_fc_la *acqe_fc)
+{
+        struct lpfc_dmabuf *mp;
+        LPFC_MBOXQ_t *pmb;
+        int rc;
+
+        if (bf_get(lpfc_trailer_type, acqe_fc) !=
+            LPFC_FC_LA_EVENT_TYPE_FC_LINK) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2895 Non FC link Event detected.(%d)\n",
+                                bf_get(lpfc_trailer_type, acqe_fc));
+                return;
+        }
         /* Keep the link status for extra SLI4 state machine reference */
         phba->sli4_hba.link_state.speed =
-                                bf_get(lpfc_acqe_link_speed, acqe_link);
-        phba->sli4_hba.link_state.duplex =
-                                bf_get(lpfc_acqe_link_duplex, acqe_link);
+                                bf_get(lpfc_acqe_fc_la_speed, acqe_fc);
+        phba->sli4_hba.link_state.duplex = LPFC_ASYNC_LINK_DUPLEX_FULL;
+        phba->sli4_hba.link_state.topology =
+                                bf_get(lpfc_acqe_fc_la_topology, acqe_fc);
         phba->sli4_hba.link_state.status =
-                                bf_get(lpfc_acqe_link_status, acqe_link);
-        phba->sli4_hba.link_state.physical =
-                                bf_get(lpfc_acqe_link_physical, acqe_link);
+                                bf_get(lpfc_acqe_fc_la_att_type, acqe_fc);
+        phba->sli4_hba.link_state.type =
+                                bf_get(lpfc_acqe_fc_la_port_type, acqe_fc);
+        phba->sli4_hba.link_state.number =
+                                bf_get(lpfc_acqe_fc_la_port_number, acqe_fc);
         phba->sli4_hba.link_state.fault =
-                                bf_get(lpfc_acqe_link_fault, acqe_link);
+                                bf_get(lpfc_acqe_link_fault, acqe_fc);
         phba->sli4_hba.link_state.logical_speed =
-                                bf_get(lpfc_acqe_qos_link_speed, acqe_link);
+                                bf_get(lpfc_acqe_fc_la_llink_spd, acqe_fc);
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "2896 Async FC event - Speed:%dGBaud Topology:x%x "
+                        "LA Type:x%x Port Type:%d Port Number:%d Logical speed:"
+                        "%dMbps Fault:%d\n",
+                        phba->sli4_hba.link_state.speed,
+                        phba->sli4_hba.link_state.topology,
+                        phba->sli4_hba.link_state.status,
+                        phba->sli4_hba.link_state.type,
+                        phba->sli4_hba.link_state.number,
+                        phba->sli4_hba.link_state.logical_speed * 10,
+                        phba->sli4_hba.link_state.fault);
+        pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2897 The mboxq allocation failed\n");
+                return;
+        }
+        mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!mp) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2898 The lpfc_dmabuf allocation failed\n");
+                goto out_free_pmb;
+        }
+        mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
+        if (!mp->virt) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2899 The mbuf allocation failed\n");
+                goto out_free_dmabuf;
+        }
 
-        /* Invoke the lpfc_handle_latt mailbox command callback function */
-        lpfc_mbx_cmpl_read_la(phba, pmb);
+        /* Cleanup any outstanding ELS commands */
+        lpfc_els_flush_all_cmd(phba);
+
+        /* Block ELS IOCBs until we have done process link event */
+        phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
+
+        /* Update link event statistics */
+        phba->sli.slistat.link_event++;
+
+        /* Create lpfc_handle_latt mailbox command from link ACQE */
+        lpfc_read_topology(phba, pmb, mp);
+        pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
+        pmb->vport = phba->pport;
 
+        rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED)
+                goto out_free_dmabuf;
         return;
 
 out_free_dmabuf:
@@ -3209,6 +3346,24 @@ out_free_pmb:
 }
 
 /**
+ * lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event
+ * @phba: pointer to lpfc hba data structure.
+ * @acqe_fc: pointer to the async SLI completion queue entry.
+ *
+ * This routine is to handle the SLI4 asynchronous SLI events.
+ **/
+static void
+lpfc_sli4_async_sli_evt(struct lpfc_hba *phba, struct lpfc_acqe_sli *acqe_sli)
+{
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "2901 Async SLI event - Event Data1:x%08x Event Data2:"
+                        "x%08x SLI Event Type:%d",
+                        acqe_sli->event_data1, acqe_sli->event_data2,
+                        bf_get(lpfc_trailer_type, acqe_sli));
+        return;
+}
+
+/**
  * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
  * @vport: pointer to vport data structure.
  *
@@ -3247,10 +3402,12 @@ lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
                 if (!ndlp)
                         return 0;
         }
-        if (phba->pport->port_state < LPFC_FLOGI)
+        if ((phba->pport->port_state < LPFC_FLOGI) &&
+                (phba->pport->port_state != LPFC_VPORT_FAILED))
                 return NULL;
         /* If virtual link is not yet instantiated ignore CVL */
-        if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC))
+        if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC)
+                && (vport->port_state != LPFC_VPORT_FAILED))
                 return NULL;
         shost = lpfc_shost_from_vport(vport);
         if (!shost)
@@ -3285,17 +3442,17 @@ lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba)
 }
 
 /**
- * lpfc_sli4_async_fcoe_evt - Process the asynchronous fcoe event
+ * lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event
  * @phba: pointer to lpfc hba data structure.
  * @acqe_link: pointer to the async fcoe completion queue entry.
  *
  * This routine is to handle the SLI4 asynchronous fcoe event.
  **/
 static void
-lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
-                         struct lpfc_acqe_fcoe *acqe_fcoe)
+lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
+                        struct lpfc_acqe_fip *acqe_fip)
 {
-        uint8_t event_type = bf_get(lpfc_acqe_fcoe_event_type, acqe_fcoe);
+        uint8_t event_type = bf_get(lpfc_trailer_type, acqe_fip);
         int rc;
         struct lpfc_vport *vport;
         struct lpfc_nodelist *ndlp;
@@ -3304,25 +3461,25 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
         struct lpfc_vport **vports;
         int i;
 
-        phba->fc_eventTag = acqe_fcoe->event_tag;
-        phba->fcoe_eventtag = acqe_fcoe->event_tag;
+        phba->fc_eventTag = acqe_fip->event_tag;
+        phba->fcoe_eventtag = acqe_fip->event_tag;
         switch (event_type) {
-        case LPFC_FCOE_EVENT_TYPE_NEW_FCF:
-        case LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD:
-                if (event_type == LPFC_FCOE_EVENT_TYPE_NEW_FCF)
+        case LPFC_FIP_EVENT_TYPE_NEW_FCF:
+        case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD:
+                if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF)
                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
                                         LOG_DISCOVERY,
                                         "2546 New FCF event, evt_tag:x%x, "
                                         "index:x%x\n",
-                                        acqe_fcoe->event_tag,
-                                        acqe_fcoe->index);
+                                        acqe_fip->event_tag,
+                                        acqe_fip->index);
                 else
                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP |
                                         LOG_DISCOVERY,
                                         "2788 FCF param modified event, "
                                         "evt_tag:x%x, index:x%x\n",
-                                        acqe_fcoe->event_tag,
-                                        acqe_fcoe->index);
+                                        acqe_fip->event_tag,
+                                        acqe_fip->index);
                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
                         /*
                          * During period of FCF discovery, read the FCF
@@ -3333,8 +3490,8 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                                         LOG_DISCOVERY,
                                         "2779 Read FCF (x%x) for updating "
                                         "roundrobin FCF failover bmask\n",
-                                        acqe_fcoe->index);
-                        rc = lpfc_sli4_read_fcf_rec(phba, acqe_fcoe->index);
+                                        acqe_fip->index);
+                        rc = lpfc_sli4_read_fcf_rec(phba, acqe_fip->index);
                 }
 
                 /* If the FCF discovery is in progress, do nothing. */
@@ -3360,7 +3517,7 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
                                 "2770 Start FCF table scan per async FCF "
                                 "event, evt_tag:x%x, index:x%x\n",
-                                acqe_fcoe->event_tag, acqe_fcoe->index);
+                                acqe_fip->event_tag, acqe_fip->index);
                 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
                                                      LPFC_FCOE_FCF_GET_FIRST);
                 if (rc)
@@ -3369,17 +3526,17 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                                         "command failed (x%x)\n", rc);
                 break;
 
-        case LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL:
+        case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                         "2548 FCF Table full count 0x%x tag 0x%x\n",
-                        bf_get(lpfc_acqe_fcoe_fcf_count, acqe_fcoe),
-                        acqe_fcoe->event_tag);
+                        bf_get(lpfc_acqe_fip_fcf_count, acqe_fip),
+                        acqe_fip->event_tag);
                 break;
 
-        case LPFC_FCOE_EVENT_TYPE_FCF_DEAD:
+        case LPFC_FIP_EVENT_TYPE_FCF_DEAD:
                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
                         "2549 FCF (x%x) disconnected from network, "
-                        "tag:x%x\n", acqe_fcoe->index, acqe_fcoe->event_tag);
+                        "tag:x%x\n", acqe_fip->index, acqe_fip->event_tag);
                 /*
                  * If we are in the middle of FCF failover process, clear
                  * the corresponding FCF bit in the roundrobin bitmap.
@@ -3388,13 +3545,13 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
                         spin_unlock_irq(&phba->hbalock);
                         /* Update FLOGI FCF failover eligible FCF bmask */
-                        lpfc_sli4_fcf_rr_index_clear(phba, acqe_fcoe->index);
+                        lpfc_sli4_fcf_rr_index_clear(phba, acqe_fip->index);
                         break;
                 }
                 spin_unlock_irq(&phba->hbalock);
 
                 /* If the event is not for currently used fcf do nothing */
-                if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
+                if (phba->fcf.current_rec.fcf_indx != acqe_fip->index)
                         break;
 
                 /*
@@ -3411,7 +3568,7 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
                                 "2771 Start FCF fast failover process due to "
                                 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
-                                "\n", acqe_fcoe->event_tag, acqe_fcoe->index);
+                                "\n", acqe_fip->event_tag, acqe_fip->index);
                 rc = lpfc_sli4_redisc_fcf_table(phba);
                 if (rc) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
@@ -3438,12 +3595,12 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                         lpfc_sli4_perform_all_vport_cvl(phba);
                 }
                 break;
-        case LPFC_FCOE_EVENT_TYPE_CVL:
+        case LPFC_FIP_EVENT_TYPE_CVL:
                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
                         "2718 Clear Virtual Link Received for VPI 0x%x"
-                        " tag 0x%x\n", acqe_fcoe->index, acqe_fcoe->event_tag);
+                        " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
                 vport = lpfc_find_vport_by_vpid(phba,
-                                acqe_fcoe->index - phba->vpi_base);
+                                acqe_fip->index - phba->vpi_base);
                 ndlp = lpfc_sli4_perform_vport_cvl(vport);
                 if (!ndlp)
                         break;
@@ -3494,7 +3651,7 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
                                         LOG_DISCOVERY,
                                         "2773 Start FCF failover per CVL, "
-                                        "evt_tag:x%x\n", acqe_fcoe->event_tag);
+                                        "evt_tag:x%x\n", acqe_fip->event_tag);
                         rc = lpfc_sli4_redisc_fcf_table(phba);
                         if (rc) {
                                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
@@ -3522,7 +3679,7 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                         "0288 Unknown FCoE event type 0x%x event tag "
-                        "0x%x\n", event_type, acqe_fcoe->event_tag);
+                        "0x%x\n", event_type, acqe_fip->event_tag);
                 break;
         }
 }
@@ -3599,8 +3756,7 @@ void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
                                                  &cq_event->cqe.acqe_link);
                         break;
                 case LPFC_TRAILER_CODE_FCOE:
-                        lpfc_sli4_async_fcoe_evt(phba,
-                                                 &cq_event->cqe.acqe_fcoe);
+                        lpfc_sli4_async_fip_evt(phba, &cq_event->cqe.acqe_fip);
                         break;
                 case LPFC_TRAILER_CODE_DCBX:
                         lpfc_sli4_async_dcbx_evt(phba,
@@ -3610,6 +3766,12 @@ void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
                         lpfc_sli4_async_grp5_evt(phba,
                                                  &cq_event->cqe.acqe_grp5);
                         break;
+                case LPFC_TRAILER_CODE_FC:
+                        lpfc_sli4_async_fc_evt(phba, &cq_event->cqe.acqe_fc);
+                        break;
+                case LPFC_TRAILER_CODE_SLI:
+                        lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli);
+                        break;
                 default:
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "1804 Invalid asynchrous event code: "
@@ -3948,7 +4110,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size;
         uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
         struct lpfc_mqe *mqe;
-        int longs;
+        int longs, sli_family;
 
         /* Before proceed, wait for POST done and device ready */
         rc = lpfc_sli4_post_status_check(phba);
@@ -3963,6 +4125,9 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         init_timer(&phba->hb_tmofunc);
         phba->hb_tmofunc.function = lpfc_hb_timeout;
         phba->hb_tmofunc.data = (unsigned long)phba;
+        init_timer(&phba->rrq_tmr);
+        phba->rrq_tmr.function = lpfc_rrq_timeout;
+        phba->rrq_tmr.data = (unsigned long)phba;
 
         psli = &phba->sli;
         /* MBOX heartbeat timer */
@@ -4010,12 +4175,22 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
          */
         buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) +
                     ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge)));
-        /* Feature Level 1 hardware is limited to 2 pages */
-        if ((bf_get(lpfc_sli_intf_featurelevel1, &phba->sli4_hba.sli_intf) ==
-             LPFC_SLI_INTF_FEATURELEVEL1_1))
-                max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
-        else
-                max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
+
+        sli_family = bf_get(lpfc_sli_intf_sli_family, &phba->sli4_hba.sli_intf);
+        max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
+        switch (sli_family) {
+        case LPFC_SLI_INTF_FAMILY_BE2:
+        case LPFC_SLI_INTF_FAMILY_BE3:
+                /* There is a single hint for BE - 2 pages per BPL. */
+                if (bf_get(lpfc_sli_intf_sli_hint1, &phba->sli4_hba.sli_intf) ==
+                    LPFC_SLI_INTF_SLI_HINT1_1)
+                        max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
+                break;
+        case LPFC_SLI_INTF_FAMILY_LNCR_A0:
+        case LPFC_SLI_INTF_FAMILY_LNCR_B0:
+        default:
+                break;
+        }
         for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE;
              dma_buf_size < max_buf_size && buf_size > dma_buf_size;
              dma_buf_size = dma_buf_size << 1)
@@ -4070,6 +4245,14 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         if (rc)
                 return -ENOMEM;
 
+        /* IF Type 2 ports get initialized now. */
+        if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+            LPFC_SLI_INTF_IF_TYPE_2) {
+                rc = lpfc_pci_function_reset(phba);
+                if (unlikely(rc))
+                        return -ENODEV;
+        }
+
         /* Create the bootstrap mailbox command */
         rc = lpfc_create_bootstrap_mbox(phba);
         if (unlikely(rc))
@@ -4080,19 +4263,18 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         if (unlikely(rc))
                 goto out_free_bsmbx;
 
-        rc = lpfc_sli4_fw_cfg_check(phba);
-        if (unlikely(rc))
-                goto out_free_bsmbx;
-
         /* Set up the hba's configuration parameters. */
         rc = lpfc_sli4_read_config(phba);
         if (unlikely(rc))
                 goto out_free_bsmbx;
 
-        /* Perform a function reset */
-        rc = lpfc_pci_function_reset(phba);
-        if (unlikely(rc))
-                goto out_free_bsmbx;
+        /* IF Type 0 ports get initialized now. */
+        if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+            LPFC_SLI_INTF_IF_TYPE_0) {
+                rc = lpfc_pci_function_reset(phba);
+                if (unlikely(rc))
+                        goto out_free_bsmbx;
+        }
 
         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
                                                        GFP_KERNEL);
@@ -5190,97 +5372,183 @@ lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
 int
 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
 {
-        struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg;
-        int i, port_error = -ENODEV;
+        struct lpfc_register portsmphr_reg, uerrlo_reg, uerrhi_reg;
+        struct lpfc_register reg_data;
+        int i, port_error = 0;
+        uint32_t if_type;
 
-        if (!phba->sli4_hba.STAregaddr)
+        if (!phba->sli4_hba.PSMPHRregaddr)
                 return -ENODEV;
 
         /* Wait up to 30 seconds for the SLI Port POST done and ready */
         for (i = 0; i < 3000; i++) {
-                sta_reg.word0 = readl(phba->sli4_hba.STAregaddr);
-                /* Encounter fatal POST error, break out */
-                if (bf_get(lpfc_hst_state_perr, &sta_reg)) {
+                portsmphr_reg.word0 = readl(phba->sli4_hba.PSMPHRregaddr);
+                if (bf_get(lpfc_port_smphr_perr, &portsmphr_reg)) {
+                        /* Port has a fatal POST error, break out */
                         port_error = -ENODEV;
                         break;
                 }
-                if (LPFC_POST_STAGE_ARMFW_READY ==
-                    bf_get(lpfc_hst_state_port_status, &sta_reg)) {
-                        port_error = 0;
+                if (LPFC_POST_STAGE_PORT_READY ==
+                    bf_get(lpfc_port_smphr_port_status, &portsmphr_reg))
                         break;
-                }
                 msleep(10);
         }
 
-        if (port_error)
+        /*
+         * If there was a port error during POST, then don't proceed with
+         * other register reads as the data may not be valid.  Just exit.
+         */
+        if (port_error) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                        "1408 Failure HBA POST Status: sta_reg=0x%x, "
-                        "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, xrom=x%x, "
-                        "dl=x%x, pstatus=x%x\n", sta_reg.word0,
-                        bf_get(lpfc_hst_state_perr, &sta_reg),
-                        bf_get(lpfc_hst_state_sfi, &sta_reg),
-                        bf_get(lpfc_hst_state_nip, &sta_reg),
-                        bf_get(lpfc_hst_state_ipc, &sta_reg),
-                        bf_get(lpfc_hst_state_xrom, &sta_reg),
-                        bf_get(lpfc_hst_state_dl, &sta_reg),
-                        bf_get(lpfc_hst_state_port_status, &sta_reg));
-
-        /* Log device information */
-        phba->sli4_hba.sli_intf.word0 = readl(phba->sli4_hba.SLIINTFregaddr);
-        if (bf_get(lpfc_sli_intf_valid,
-                   &phba->sli4_hba.sli_intf) == LPFC_SLI_INTF_VALID) {
+                        "1408 Port Failed POST - portsmphr=0x%x, "
+                        "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "
+                        "scr2=x%x, hscratch=x%x, pstatus=x%x\n",
+                        portsmphr_reg.word0,
+                        bf_get(lpfc_port_smphr_perr, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_sfi, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_nip, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_ipc, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_scr1, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_scr2, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_host_scratch, &portsmphr_reg),
+                        bf_get(lpfc_port_smphr_port_status, &portsmphr_reg));
+        } else {
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                                "2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
-                                "FeatureL1=0x%x, FeatureL2=0x%x\n",
+                                "2534 Device Info: SLIFamily=0x%x, "
+                                "SLIRev=0x%x, IFType=0x%x, SLIHint_1=0x%x, "
+                                "SLIHint_2=0x%x, FT=0x%x\n",
                                 bf_get(lpfc_sli_intf_sli_family,
                                        &phba->sli4_hba.sli_intf),
                                 bf_get(lpfc_sli_intf_slirev,
                                        &phba->sli4_hba.sli_intf),
-                                bf_get(lpfc_sli_intf_featurelevel1,
+                                bf_get(lpfc_sli_intf_if_type,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_sli_hint1,
                                        &phba->sli4_hba.sli_intf),
-                                bf_get(lpfc_sli_intf_featurelevel2,
+                                bf_get(lpfc_sli_intf_sli_hint2,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_func_type,
                                        &phba->sli4_hba.sli_intf));
+                /*
+                 * Check for other Port errors during the initialization
+                 * process.  Fail the load if the port did not come up
+                 * correctly.
+                 */
+                if_type = bf_get(lpfc_sli_intf_if_type,
+                                 &phba->sli4_hba.sli_intf);
+                switch (if_type) {
+                case LPFC_SLI_INTF_IF_TYPE_0:
+                        phba->sli4_hba.ue_mask_lo =
+                              readl(phba->sli4_hba.u.if_type0.UEMASKLOregaddr);
+                        phba->sli4_hba.ue_mask_hi =
+                              readl(phba->sli4_hba.u.if_type0.UEMASKHIregaddr);
+                        uerrlo_reg.word0 =
+                              readl(phba->sli4_hba.u.if_type0.UERRLOregaddr);
+                        uerrhi_reg.word0 =
+                                readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
+                        if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
+                            (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
+                                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                                "1422 Unrecoverable Error "
+                                                "Detected during POST "
+                                                "uerr_lo_reg=0x%x, "
+                                                "uerr_hi_reg=0x%x, "
+                                                "ue_mask_lo_reg=0x%x, "
+                                                "ue_mask_hi_reg=0x%x\n",
+                                                uerrlo_reg.word0,
+                                                uerrhi_reg.word0,
+                                                phba->sli4_hba.ue_mask_lo,
+                                                phba->sli4_hba.ue_mask_hi);
+                                port_error = -ENODEV;
+                        }
+                        break;
+                case LPFC_SLI_INTF_IF_TYPE_2:
+                        /* Final checks.  The port status should be clean. */
+                        reg_data.word0 =
+                                readl(phba->sli4_hba.u.if_type2.STATUSregaddr);
+                        if (bf_get(lpfc_sliport_status_err, &reg_data)) {
+                                phba->work_status[0] =
+                                        readl(phba->sli4_hba.u.if_type2.
+                                              ERR1regaddr);
+                                phba->work_status[1] =
+                                        readl(phba->sli4_hba.u.if_type2.
+                                              ERR2regaddr);
+                                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2888 Port Error Detected "
+                                        "during POST: "
+                                        "port status reg 0x%x, "
+                                        "port_smphr reg 0x%x, "
+                                        "error 1=0x%x, error 2=0x%x\n",
+                                        reg_data.word0,
+                                        portsmphr_reg.word0,
+                                        phba->work_status[0],
+                                        phba->work_status[1]);
+                                port_error = -ENODEV;
+                        }
+                        break;
+                case LPFC_SLI_INTF_IF_TYPE_1:
+                default:
+                        break;
+                }
         }
-        phba->sli4_hba.ue_mask_lo = readl(phba->sli4_hba.UEMASKLOregaddr);
-        phba->sli4_hba.ue_mask_hi = readl(phba->sli4_hba.UEMASKHIregaddr);
-        /* With uncoverable error, log the error message and return error */
-        uerrlo_reg.word0 = readl(phba->sli4_hba.UERRLOregaddr);
-        uerrhi_reg.word0 = readl(phba->sli4_hba.UERRHIregaddr);
-        if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
-            (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "1422 HBA Unrecoverable error: "
-                                "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
-                                "ue_mask_lo_reg=0x%x, ue_mask_hi_reg=0x%x\n",
-                                uerrlo_reg.word0, uerrhi_reg.word0,
-                                phba->sli4_hba.ue_mask_lo,
-                                phba->sli4_hba.ue_mask_hi);
-                return -ENODEV;
-        }
-
         return port_error;
 }
 
 /**
  * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
  * @phba: pointer to lpfc hba data structure.
+ * @if_type:  The SLI4 interface type getting configured.
  *
  * This routine is invoked to set up SLI4 BAR0 PCI config space register
  * memory map.
  **/
 static void
-lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba)
-{
-        phba->sli4_hba.UERRLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_UERR_STATUS_LO;
-        phba->sli4_hba.UERRHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_UERR_STATUS_HI;
-        phba->sli4_hba.UEMASKLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_UE_MASK_LO;
-        phba->sli4_hba.UEMASKHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_UE_MASK_HI;
-        phba->sli4_hba.SLIINTFregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_SLI_INTF;
+lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type)
+{
+        switch (if_type) {
+        case LPFC_SLI_INTF_IF_TYPE_0:
+                phba->sli4_hba.u.if_type0.UERRLOregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_LO;
+                phba->sli4_hba.u.if_type0.UERRHIregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_HI;
+                phba->sli4_hba.u.if_type0.UEMASKLOregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_LO;
+                phba->sli4_hba.u.if_type0.UEMASKHIregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_HI;
+                phba->sli4_hba.SLIINTFregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_2:
+                phba->sli4_hba.u.if_type2.ERR1regaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_ERR_1;
+                phba->sli4_hba.u.if_type2.ERR2regaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_ERR_2;
+                phba->sli4_hba.u.if_type2.CTRLregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_CNTRL;
+                phba->sli4_hba.u.if_type2.STATUSregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_STATUS;
+                phba->sli4_hba.SLIINTFregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
+                phba->sli4_hba.PSMPHRregaddr =
+                     phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_IF2_SMPHR;
+                phba->sli4_hba.RQDBregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_RQ_DOORBELL;
+                phba->sli4_hba.WQDBregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_WQ_DOORBELL;
+                phba->sli4_hba.EQCQDBregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_EQCQ_DOORBELL;
+                phba->sli4_hba.MQDBregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_MQ_DOORBELL;
+                phba->sli4_hba.BMBXregaddr =
+                        phba->sli4_hba.conf_regs_memmap_p + LPFC_BMBX;
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_1:
+        default:
+                dev_printk(KERN_ERR, &phba->pcidev->dev,
+                           "FATAL - unsupported SLI4 interface type - %d\n",
+                           if_type);
+                break;
+        }
 }
 
 /**
@@ -5293,16 +5561,14 @@ lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba)
 static void
 lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba)
 {
-
-        phba->sli4_hba.STAregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
-                                    LPFC_HST_STATE;
+        phba->sli4_hba.PSMPHRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
+                LPFC_SLIPORT_IF0_SMPHR;
         phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
-                                    LPFC_HST_ISR0;
+                LPFC_HST_ISR0;
         phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
-                                    LPFC_HST_IMR0;
+                LPFC_HST_IMR0;
         phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
-                                     LPFC_HST_ISCR0;
-        return;
+                LPFC_HST_ISCR0;
 }
 
 /**
@@ -5542,11 +5808,12 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
 }
 
 /**
- * lpfc_dev_endian_order_setup - Notify the port of the host's endian order.
+ * lpfc_setup_endian_order - Write endian order to an SLI4 if_type 0 port.
  * @phba: pointer to lpfc hba data structure.
  *
- * This routine is invoked to setup the host-side endian order to the
- * HBA consistent with the SLI-4 interface spec.
+ * This routine is invoked to setup the port-side endian order when
+ * the port if_type is 0.  This routine has no function for other
+ * if_types.
  *
  * Return codes
  *      0 - successful
@@ -5557,34 +5824,44 @@ static int
 lpfc_setup_endian_order(struct lpfc_hba *phba)
 {
         LPFC_MBOXQ_t *mboxq;
-        uint32_t rc = 0;
+        uint32_t if_type, rc = 0;
         uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0,
                                       HOST_ENDIAN_HIGH_WORD1};
 
-        mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-        if (!mboxq) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0492 Unable to allocate memory for issuing "
-                                "SLI_CONFIG_SPECIAL mailbox command\n");
-                return -ENOMEM;
-        }
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        switch (if_type) {
+        case LPFC_SLI_INTF_IF_TYPE_0:
+                mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
+                                                       GFP_KERNEL);
+                if (!mboxq) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "0492 Unable to allocate memory for "
+                                        "issuing SLI_CONFIG_SPECIAL mailbox "
+                                        "command\n");
+                        return -ENOMEM;
+                }
 
-        /*
-         * The SLI4_CONFIG_SPECIAL mailbox command requires the first two
-         * words to contain special data values and no other data.
-         */
-        memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
-        memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
-        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
-        if (rc != MBX_SUCCESS) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0493 SLI_CONFIG_SPECIAL mailbox failed with "
-                                "status x%x\n",
-                                rc);
-                rc = -EIO;
+                /*
+                 * The SLI4_CONFIG_SPECIAL mailbox command requires the first
+                 * two words to contain special data values and no other data.
+                 */
+                memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
+                memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
+                rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+                if (rc != MBX_SUCCESS) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "0493 SLI_CONFIG_SPECIAL mailbox "
+                                        "failed with status x%x\n",
+                                        rc);
+                        rc = -EIO;
+                }
+                mempool_free(mboxq, phba->mbox_mem_pool);
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_2:
+        case LPFC_SLI_INTF_IF_TYPE_1:
+        default:
+                break;
         }
-
-        mempool_free(mboxq, phba->mbox_mem_pool);
         return rc;
 }
 
@@ -6416,36 +6693,124 @@ int
 lpfc_pci_function_reset(struct lpfc_hba *phba)
 {
         LPFC_MBOXQ_t *mboxq;
-        uint32_t rc = 0;
+        uint32_t rc = 0, if_type;
         uint32_t shdr_status, shdr_add_status;
+        uint32_t rdy_chk, num_resets = 0, reset_again = 0;
         union lpfc_sli4_cfg_shdr *shdr;
+        struct lpfc_register reg_data;
 
-        mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-        if (!mboxq) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0494 Unable to allocate memory for issuing "
-                                "SLI_FUNCTION_RESET mailbox command\n");
-                return -ENOMEM;
-        }
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        switch (if_type) {
+        case LPFC_SLI_INTF_IF_TYPE_0:
+                mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
+                                                       GFP_KERNEL);
+                if (!mboxq) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "0494 Unable to allocate memory for "
+                                        "issuing SLI_FUNCTION_RESET mailbox "
+                                        "command\n");
+                        return -ENOMEM;
+                }
 
-        /* Set up PCI function reset SLI4_CONFIG mailbox-ioctl command */
-        lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
-                         LPFC_MBOX_OPCODE_FUNCTION_RESET, 0,
-                         LPFC_SLI4_MBX_EMBED);
-        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
-        shdr = (union lpfc_sli4_cfg_shdr *)
-                &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
-        shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
-        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
-        if (rc != MBX_TIMEOUT)
-                mempool_free(mboxq, phba->mbox_mem_pool);
-        if (shdr_status || shdr_add_status || rc) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0495 SLI_FUNCTION_RESET mailbox failed with "
-                                "status x%x add_status x%x, mbx status x%x\n",
-                                shdr_status, shdr_add_status, rc);
-                rc = -ENXIO;
+                /* Setup PCI function reset mailbox-ioctl command */
+                lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
+                                 LPFC_MBOX_OPCODE_FUNCTION_RESET, 0,
+                                 LPFC_SLI4_MBX_EMBED);
+                rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+                shdr = (union lpfc_sli4_cfg_shdr *)
+                        &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
+                shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                                         &shdr->response);
+                if (rc != MBX_TIMEOUT)
+                        mempool_free(mboxq, phba->mbox_mem_pool);
+                if (shdr_status || shdr_add_status || rc) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "0495 SLI_FUNCTION_RESET mailbox "
+                                        "failed with status x%x add_status x%x,"
+                                        " mbx status x%x\n",
+                                        shdr_status, shdr_add_status, rc);
+                        rc = -ENXIO;
+                }
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_2:
+                for (num_resets = 0;
+                     num_resets < MAX_IF_TYPE_2_RESETS;
+                     num_resets++) {
+                        reg_data.word0 = 0;
+                        bf_set(lpfc_sliport_ctrl_end, &reg_data,
+                               LPFC_SLIPORT_LITTLE_ENDIAN);
+                        bf_set(lpfc_sliport_ctrl_ip, &reg_data,
+                               LPFC_SLIPORT_INIT_PORT);
+                        writel(reg_data.word0, phba->sli4_hba.u.if_type2.
+                               CTRLregaddr);
+
+                        /*
+                         * Poll the Port Status Register and wait for RDY for
+                         * up to 10 seconds.  If the port doesn't respond, treat
+                         * it as an error.  If the port responds with RN, start
+                         * the loop again.
+                         */
+                        for (rdy_chk = 0; rdy_chk < 1000; rdy_chk++) {
+                                reg_data.word0 =
+                                        readl(phba->sli4_hba.u.if_type2.
+                                              STATUSregaddr);
+                                if (bf_get(lpfc_sliport_status_rdy, &reg_data))
+                                        break;
+                                if (bf_get(lpfc_sliport_status_rn, &reg_data)) {
+                                        reset_again++;
+                                        break;
+                                }
+                                msleep(10);
+                        }
+
+                        /*
+                         * If the port responds to the init request with
+                         * reset needed, delay for a bit and restart the loop.
+                         */
+                        if (reset_again) {
+                                msleep(10);
+                                reset_again = 0;
+                                continue;
+                        }
+
+                        /* Detect any port errors. */
+                        reg_data.word0 = readl(phba->sli4_hba.u.if_type2.
+                                               STATUSregaddr);
+                        if ((bf_get(lpfc_sliport_status_err, &reg_data)) ||
+                            (rdy_chk >= 1000)) {
+                                phba->work_status[0] = readl(
+                                        phba->sli4_hba.u.if_type2.ERR1regaddr);
+                                phba->work_status[1] = readl(
+                                        phba->sli4_hba.u.if_type2.ERR2regaddr);
+                                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2890 Port Error Detected "
+                                        "during Port Reset: "
+                                        "port status reg 0x%x, "
+                                        "error 1=0x%x, error 2=0x%x\n",
+                                        reg_data.word0,
+                                        phba->work_status[0],
+                                        phba->work_status[1]);
+                                rc = -ENODEV;
+                        }
+
+                        /*
+                         * Terminate the outer loop provided the Port indicated
+                         * ready within 10 seconds.
+                         */
+                        if (rdy_chk < 1000)
+                                break;
+                }
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_1:
+        default:
+                break;
         }
+
+        /* Catch the not-ready port failure after a port reset. */
+        if (num_resets >= MAX_IF_TYPE_2_RESETS)
+                rc = -ENODEV;
+
         return rc;
 }
 
@@ -6536,6 +6901,7 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
         struct pci_dev *pdev;
         unsigned long bar0map_len, bar1map_len, bar2map_len;
         int error = -ENODEV;
+        uint32_t if_type;
 
         /* Obtain PCI device reference */
         if (!phba->pcidev)
@@ -6552,61 +6918,105 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
                 }
         }
 
-        /* Get the bus address of SLI4 device Bar0, Bar1, and Bar2 and the
-         * number of bytes required by each mapping. They are actually
-         * mapping to the PCI BAR regions 0 or 1, 2, and 4 by the SLI4 device.
+        /*
+         * The BARs and register set definitions and offset locations are
+         * dependent on the if_type.
+         */
+        if (pci_read_config_dword(pdev, LPFC_SLI_INTF,
+                                  &phba->sli4_hba.sli_intf.word0)) {
+                return error;
+        }
+
+        /* There is no SLI3 failback for SLI4 devices. */
+        if (bf_get(lpfc_sli_intf_valid, &phba->sli4_hba.sli_intf) !=
+            LPFC_SLI_INTF_VALID) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2894 SLI_INTF reg contents invalid "
+                                "sli_intf reg 0x%x\n",
+                                phba->sli4_hba.sli_intf.word0);
+                return error;
+        }
+
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        /*
+         * Get the bus address of SLI4 device Bar regions and the
+         * number of bytes required by each mapping. The mapping of the
+         * particular PCI BARs regions is dependent on the type of
+         * SLI4 device.
          */
         if (pci_resource_start(pdev, 0)) {
                 phba->pci_bar0_map = pci_resource_start(pdev, 0);
                 bar0map_len = pci_resource_len(pdev, 0);
+
+                /*
+                 * Map SLI4 PCI Config Space Register base to a kernel virtual
+                 * addr
+                 */
+                phba->sli4_hba.conf_regs_memmap_p =
+                        ioremap(phba->pci_bar0_map, bar0map_len);
+                if (!phba->sli4_hba.conf_regs_memmap_p) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                   "ioremap failed for SLI4 PCI config "
+                                   "registers.\n");
+                        goto out;
+                }
+                /* Set up BAR0 PCI config space register memory map */
+                lpfc_sli4_bar0_register_memmap(phba, if_type);
         } else {
                 phba->pci_bar0_map = pci_resource_start(pdev, 1);
                 bar0map_len = pci_resource_len(pdev, 1);
-        }
-        phba->pci_bar1_map = pci_resource_start(pdev, 2);
-        bar1map_len = pci_resource_len(pdev, 2);
-
-        phba->pci_bar2_map = pci_resource_start(pdev, 4);
-        bar2map_len = pci_resource_len(pdev, 4);
-
-        /* Map SLI4 PCI Config Space Register base to a kernel virtual addr */
-        phba->sli4_hba.conf_regs_memmap_p =
+                if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                           "FATAL - No BAR0 mapping for SLI4, if_type 2\n");
+                        goto out;
+                }
+                phba->sli4_hba.conf_regs_memmap_p =
                                 ioremap(phba->pci_bar0_map, bar0map_len);
-        if (!phba->sli4_hba.conf_regs_memmap_p) {
-                dev_printk(KERN_ERR, &pdev->dev,
-                           "ioremap failed for SLI4 PCI config registers.\n");
-                goto out;
+                if (!phba->sli4_hba.conf_regs_memmap_p) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "ioremap failed for SLI4 PCI config "
+                                "registers.\n");
+                                goto out;
+                }
+                lpfc_sli4_bar0_register_memmap(phba, if_type);
         }
 
-        /* Map SLI4 HBA Control Register base to a kernel virtual address. */
-        phba->sli4_hba.ctrl_regs_memmap_p =
+        if (pci_resource_start(pdev, 2)) {
+                /*
+                 * Map SLI4 if type 0 HBA Control Register base to a kernel
+                 * virtual address and setup the registers.
+                 */
+                phba->pci_bar1_map = pci_resource_start(pdev, 2);
+                bar1map_len = pci_resource_len(pdev, 2);
+                phba->sli4_hba.ctrl_regs_memmap_p =
                                 ioremap(phba->pci_bar1_map, bar1map_len);
-        if (!phba->sli4_hba.ctrl_regs_memmap_p) {
-                dev_printk(KERN_ERR, &pdev->dev,
+                if (!phba->sli4_hba.ctrl_regs_memmap_p) {
+                        dev_printk(KERN_ERR, &pdev->dev,
                            "ioremap failed for SLI4 HBA control registers.\n");
-                goto out_iounmap_conf;
+                        goto out_iounmap_conf;
+                }
+                lpfc_sli4_bar1_register_memmap(phba);
         }
 
-        /* Map SLI4 HBA Doorbell Register base to a kernel virtual address. */
-        phba->sli4_hba.drbl_regs_memmap_p =
+        if (pci_resource_start(pdev, 4)) {
+                /*
+                 * Map SLI4 if type 0 HBA Doorbell Register base to a kernel
+                 * virtual address and setup the registers.
+                 */
+                phba->pci_bar2_map = pci_resource_start(pdev, 4);
+                bar2map_len = pci_resource_len(pdev, 4);
+                phba->sli4_hba.drbl_regs_memmap_p =
                                 ioremap(phba->pci_bar2_map, bar2map_len);
-        if (!phba->sli4_hba.drbl_regs_memmap_p) {
-                dev_printk(KERN_ERR, &pdev->dev,
+                if (!phba->sli4_hba.drbl_regs_memmap_p) {
+                        dev_printk(KERN_ERR, &pdev->dev,
                            "ioremap failed for SLI4 HBA doorbell registers.\n");
-                goto out_iounmap_ctrl;
+                        goto out_iounmap_ctrl;
+                }
+                error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0);
+                if (error)
+                        goto out_iounmap_all;
         }
 
-        /* Set up BAR0 PCI config space register memory map */
-        lpfc_sli4_bar0_register_memmap(phba);
-
-        /* Set up BAR1 register memory map */
-        lpfc_sli4_bar1_register_memmap(phba);
-
-        /* Set up BAR2 register memory map */
-        error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0);
-        if (error)
-                goto out_iounmap_all;
-
         return 0;
 
 out_iounmap_all:
@@ -8149,6 +8559,8 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
                 goto out_unset_driver_resource_s4;
         }
 
+        INIT_LIST_HEAD(&phba->active_rrq_list);
+
         /* Set up common device driver resources */
         error = lpfc_setup_driver_resource_phase2(phba);
         if (error) {
@@ -8218,7 +8630,11 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
                                 "0451 Configure interrupt mode (%d) "
                                 "failed active interrupt test.\n",
                                 intr_mode);
-                /* Unset the preivous SLI-4 HBA setup */
+                /* Unset the previous SLI-4 HBA setup. */
+                /*
+                 * TODO:  Is this operation compatible with IF TYPE 2
+                 * devices?  All port state is deleted and cleared.
+                 */
                 lpfc_sli4_unset_hba(phba);
                 /* Try next level of interrupt mode */
                 cfg_mode = --intr_mode;
@@ -8990,6 +9406,10 @@ static struct pci_device_id lpfc_id_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID, },
         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BALIUS,
                 PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FC,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FCOE,
+                PCI_ANY_ID, PCI_ANY_ID, },
         { 0 }
 };
 
diff --git a/drivers/scsi/lpfc/lpfc_logmsg.h b/drivers/scsi/lpfc/lpfc_logmsg.h
index bb59e9273126..e3b790e59156 100644
--- a/drivers/scsi/lpfc/lpfc_logmsg.h
+++ b/drivers/scsi/lpfc/lpfc_logmsg.h
@@ -33,7 +33,7 @@
 #define LOG_FCP_ERROR   0x00001000      /* log errors, not underruns */
 #define LOG_LIBDFC      0x00002000      /* Libdfc events */
 #define LOG_VPORT       0x00004000      /* NPIV events */
-#define LOF_SECURITY    0x00008000      /* Security events */
+#define LOG_SECURITY    0x00008000      /* Security events */
 #define LOG_EVENT       0x00010000      /* CT,TEMP,DUMP, logging */
 #define LOG_FIP         0x00020000      /* FIP events */
 #define LOG_ALL_MSG     0xffffffff      /* LOG all messages */
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index 62d0957e1d4c..23403c650207 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -263,18 +263,19 @@ lpfc_heart_beat(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
 }
 
 /**
- * lpfc_read_la - Prepare a mailbox command for reading HBA link attention
+ * lpfc_read_topology - Prepare a mailbox command for reading HBA topology
  * @phba: pointer to lpfc hba data structure.
  * @pmb: pointer to the driver internal queue element for mailbox command.
  * @mp: DMA buffer memory for reading the link attention information into.
  *
- * The read link attention mailbox command is issued to read the Link Event
- * Attention information indicated by the HBA port when the Link Event bit
- * of the Host Attention (HSTATT) register is set to 1. A Link Event
+ * The read topology mailbox command is issued to read the link topology
+ * information indicated by the HBA port when the Link Event bit of the Host
+ * Attention (HSTATT) register is set to 1 (For SLI-3) or when an FC Link
+ * Attention ACQE is received from the port (For SLI-4). A Link Event
  * Attention occurs based on an exception detected at the Fibre Channel link
  * interface.
  *
- * This routine prepares the mailbox command for reading HBA link attention
+ * This routine prepares the mailbox command for reading HBA link topology
  * information. A DMA memory has been set aside and address passed to the
  * HBA through @mp for the HBA to DMA link attention information into the
  * memory as part of the execution of the mailbox command.
@@ -283,7 +284,8 @@ lpfc_heart_beat(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
  *    0 - Success (currently always return 0)
  **/
 int
-lpfc_read_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb, struct lpfc_dmabuf *mp)
+lpfc_read_topology(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb,
+                   struct lpfc_dmabuf *mp)
 {
         MAILBOX_t *mb;
         struct lpfc_sli *psli;
@@ -293,15 +295,15 @@ lpfc_read_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb, struct lpfc_dmabuf *mp)
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 
         INIT_LIST_HEAD(&mp->list);
-        mb->mbxCommand = MBX_READ_LA64;
-        mb->un.varReadLA.un.lilpBde64.tus.f.bdeSize = 128;
-        mb->un.varReadLA.un.lilpBde64.addrHigh = putPaddrHigh(mp->phys);
-        mb->un.varReadLA.un.lilpBde64.addrLow = putPaddrLow(mp->phys);
+        mb->mbxCommand = MBX_READ_TOPOLOGY;
+        mb->un.varReadTop.lilpBde64.tus.f.bdeSize = LPFC_ALPA_MAP_SIZE;
+        mb->un.varReadTop.lilpBde64.addrHigh = putPaddrHigh(mp->phys);
+        mb->un.varReadTop.lilpBde64.addrLow = putPaddrLow(mp->phys);
 
         /* Save address for later completion and set the owner to host so that
          * the FW knows this mailbox is available for processing.
          */
-        pmb->context1 = (uint8_t *) mp;
+        pmb->context1 = (uint8_t *)mp;
         mb->mbxOwner = OWN_HOST;
         return (0);
 }
@@ -516,18 +518,33 @@ lpfc_init_link(struct lpfc_hba * phba,
         vpd = &phba->vpd;
         if (vpd->rev.feaLevelHigh >= 0x02){
                 switch(linkspeed){
-                        case LINK_SPEED_1G:
-                        case LINK_SPEED_2G:
-                        case LINK_SPEED_4G:
-                        case LINK_SPEED_8G:
-                                mb->un.varInitLnk.link_flags |=
-                                                        FLAGS_LINK_SPEED;
-                                mb->un.varInitLnk.link_speed = linkspeed;
+                case LPFC_USER_LINK_SPEED_1G:
+                        mb->un.varInitLnk.link_flags |= FLAGS_LINK_SPEED;
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_1G;
+                        break;
+                case LPFC_USER_LINK_SPEED_2G:
+                        mb->un.varInitLnk.link_flags |= FLAGS_LINK_SPEED;
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_2G;
+                        break;
+                case LPFC_USER_LINK_SPEED_4G:
+                        mb->un.varInitLnk.link_flags |= FLAGS_LINK_SPEED;
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_4G;
+                        break;
+                case LPFC_USER_LINK_SPEED_8G:
+                        mb->un.varInitLnk.link_flags |= FLAGS_LINK_SPEED;
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_8G;
+                        break;
+                case LPFC_USER_LINK_SPEED_10G:
+                        mb->un.varInitLnk.link_flags |= FLAGS_LINK_SPEED;
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_10G;
                         break;
-                        case LINK_SPEED_AUTO:
-                        default:
-                                mb->un.varInitLnk.link_speed =
-                                                        LINK_SPEED_AUTO;
+                case LPFC_USER_LINK_SPEED_16G:
+                        mb->un.varInitLnk.link_flags |= FLAGS_LINK_SPEED;
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_16G;
+                        break;
+                case LPFC_USER_LINK_SPEED_AUTO:
+                default:
+                        mb->un.varInitLnk.link_speed = LINK_SPEED_AUTO;
                         break;
                 }
 
@@ -693,7 +710,7 @@ lpfc_read_lnk_stat(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
  * @did: remote port identifier.
  * @param: pointer to memory holding the server parameters.
  * @pmb: pointer to the driver internal queue element for mailbox command.
- * @flag: action flag to be passed back for the complete function.
+ * @rpi: the rpi to use in the registration (usually only used for SLI4.
  *
  * The registration login mailbox command is used to register an N_Port or
  * F_Port login. This registration allows the HBA to cache the remote N_Port
@@ -712,7 +729,7 @@ lpfc_read_lnk_stat(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
  **/
 int
 lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
-               uint8_t *param, LPFC_MBOXQ_t *pmb, uint32_t flag)
+             uint8_t *param, LPFC_MBOXQ_t *pmb, uint16_t rpi)
 {
         MAILBOX_t *mb = &pmb->u.mb;
         uint8_t *sparam;
@@ -722,17 +739,13 @@ lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
 
         mb->un.varRegLogin.rpi = 0;
         if (phba->sli_rev == LPFC_SLI_REV4) {
-                mb->un.varRegLogin.rpi = lpfc_sli4_alloc_rpi(phba);
+                mb->un.varRegLogin.rpi = rpi;
                 if (mb->un.varRegLogin.rpi == LPFC_RPI_ALLOC_ERROR)
                         return 1;
         }
-
         mb->un.varRegLogin.vpi = vpi + phba->vpi_base;
         mb->un.varRegLogin.did = did;
-        mb->un.varWords[30] = flag;     /* Set flag to issue action on cmpl */
-
         mb->mbxOwner = OWN_HOST;
-
         /* Get a buffer to hold NPorts Service Parameters */
         mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
         if (mp)
@@ -743,7 +756,7 @@ lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
                 /* REG_LOGIN: no buffers */
                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
                                 "0302 REG_LOGIN: no buffers, VPI:%d DID:x%x, "
-                                "flag x%x\n", vpi, did, flag);
+                                "rpi x%x\n", vpi, did, rpi);
                 return (1);
         }
         INIT_LIST_HEAD(&mp->list);
@@ -1918,11 +1931,14 @@ lpfc_init_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport)
         struct lpfc_mbx_init_vfi *init_vfi;
 
         memset(mbox, 0, sizeof(*mbox));
+        mbox->vport = vport;
         init_vfi = &mbox->u.mqe.un.init_vfi;
         bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_INIT_VFI);
         bf_set(lpfc_init_vfi_vr, init_vfi, 1);
         bf_set(lpfc_init_vfi_vt, init_vfi, 1);
+        bf_set(lpfc_init_vfi_vp, init_vfi, 1);
         bf_set(lpfc_init_vfi_vfi, init_vfi, vport->vfi + vport->phba->vfi_base);
+        bf_set(lpfc_init_vpi_vpi, init_vfi, vport->vpi + vport->phba->vpi_base);
         bf_set(lpfc_init_vfi_fcfi, init_vfi, vport->phba->fcf.fcfi);
 }
 
diff --git a/drivers/scsi/lpfc/lpfc_mem.c b/drivers/scsi/lpfc/lpfc_mem.c
index 8f879e477e9d..cbb48ee8b0bb 100644
--- a/drivers/scsi/lpfc/lpfc_mem.c
+++ b/drivers/scsi/lpfc/lpfc_mem.c
@@ -113,11 +113,16 @@ lpfc_mem_alloc(struct lpfc_hba *phba, int align)
                 goto fail_free_mbox_pool;
 
         if (phba->sli_rev == LPFC_SLI_REV4) {
+                phba->rrq_pool =
+                        mempool_create_kmalloc_pool(LPFC_MEM_POOL_SIZE,
+                                                sizeof(struct lpfc_node_rrq));
+                if (!phba->rrq_pool)
+                        goto fail_free_nlp_mem_pool;
                 phba->lpfc_hrb_pool = pci_pool_create("lpfc_hrb_pool",
                                               phba->pcidev,
                                               LPFC_HDR_BUF_SIZE, align, 0);
                 if (!phba->lpfc_hrb_pool)
-                        goto fail_free_nlp_mem_pool;
+                        goto fail_free_rrq_mem_pool;
 
                 phba->lpfc_drb_pool = pci_pool_create("lpfc_drb_pool",
                                               phba->pcidev,
@@ -147,6 +152,9 @@ lpfc_mem_alloc(struct lpfc_hba *phba, int align)
  fail_free_hrb_pool:
         pci_pool_destroy(phba->lpfc_hrb_pool);
         phba->lpfc_hrb_pool = NULL;
+ fail_free_rrq_mem_pool:
+        mempool_destroy(phba->rrq_pool);
+        phba->rrq_pool = NULL;
  fail_free_nlp_mem_pool:
         mempool_destroy(phba->nlp_mem_pool);
         phba->nlp_mem_pool = NULL;
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index bccc9c66fa37..d85a7423a694 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -386,7 +386,7 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 goto out;
 
         rc = lpfc_reg_rpi(phba, vport->vpi, icmd->un.rcvels.remoteID,
-                            (uint8_t *) sp, mbox, 0);
+                            (uint8_t *) sp, mbox, ndlp->nlp_rpi);
         if (rc) {
                 mempool_free(mbox, phba->mbox_mem_pool);
                 goto out;
@@ -632,7 +632,7 @@ lpfc_disc_set_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
 {
         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
-        if (!(ndlp->nlp_flag & NLP_RPI_VALID)) {
+        if (!(ndlp->nlp_flag & NLP_RPI_REGISTERED)) {
                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
                 return 0;
         }
@@ -968,7 +968,7 @@ lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport *vport,
         lpfc_unreg_rpi(vport, ndlp);
 
         if (lpfc_reg_rpi(phba, vport->vpi, irsp->un.elsreq64.remoteID,
-                           (uint8_t *) sp, mbox, 0) == 0) {
+                         (uint8_t *) sp, mbox, ndlp->nlp_rpi) == 0) {
                 switch (ndlp->nlp_DID) {
                 case NameServer_DID:
                         mbox->mbox_cmpl = lpfc_mbx_cmpl_ns_reg_login;
@@ -1338,12 +1338,6 @@ lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport,
         list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
                 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
                    (ndlp == (struct lpfc_nodelist *) mb->context2)) {
-                        if (phba->sli_rev == LPFC_SLI_REV4) {
-                                spin_unlock_irq(&phba->hbalock);
-                                lpfc_sli4_free_rpi(phba,
-                                        mb->u.mb.un.varRegLogin.rpi);
-                                spin_lock_irq(&phba->hbalock);
-                        }
                         mp = (struct lpfc_dmabuf *) (mb->context1);
                         if (mp) {
                                 __lpfc_mbuf_free(phba, mp->virt, mp->phys);
@@ -1426,7 +1420,7 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport,
         }
 
         ndlp->nlp_rpi = mb->un.varWords[0];
-        ndlp->nlp_flag |= NLP_RPI_VALID;
+        ndlp->nlp_flag |= NLP_RPI_REGISTERED;
 
         /* Only if we are not a fabric nport do we issue PRLI */
         if (!(ndlp->nlp_type & NLP_FABRIC)) {
@@ -2027,7 +2021,7 @@ lpfc_cmpl_reglogin_npr_node(struct lpfc_vport *vport,
 
         if (!mb->mbxStatus) {
                 ndlp->nlp_rpi = mb->un.varWords[0];
-                ndlp->nlp_flag |= NLP_RPI_VALID;
+                ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         } else {
                 if (ndlp->nlp_flag & NLP_NODEV_REMOVE) {
                         lpfc_drop_node(vport, ndlp);
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 581837b3c71a..c97751c95d77 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -621,10 +621,13 @@ lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
                           struct sli4_wcqe_xri_aborted *axri)
 {
         uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
+        uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
         struct lpfc_scsi_buf *psb, *next_psb;
         unsigned long iflag = 0;
         struct lpfc_iocbq *iocbq;
         int i;
+        struct lpfc_nodelist *ndlp;
+        int rrq_empty = 0;
         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
 
         spin_lock_irqsave(&phba->hbalock, iflag);
@@ -637,8 +640,14 @@ lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
                         psb->status = IOSTAT_SUCCESS;
                         spin_unlock(
                                 &phba->sli4_hba.abts_scsi_buf_list_lock);
+                        ndlp = psb->rdata->pnode;
+                        rrq_empty = list_empty(&phba->active_rrq_list);
                         spin_unlock_irqrestore(&phba->hbalock, iflag);
+                        if (ndlp)
+                                lpfc_set_rrq_active(phba, ndlp, xri, rxid, 1);
                         lpfc_release_scsi_buf_s4(phba, psb);
+                        if (rrq_empty)
+                                lpfc_worker_wake_up(phba);
                         return;
                 }
         }
@@ -914,7 +923,7 @@ lpfc_new_scsi_buf(struct lpfc_vport *vport, int num_to_alloc)
 }
 
 /**
- * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
+ * lpfc_get_scsi_buf_s3 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
  * @phba: The HBA for which this call is being executed.
  *
  * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
@@ -925,7 +934,7 @@ lpfc_new_scsi_buf(struct lpfc_vport *vport, int num_to_alloc)
  *   Pointer to lpfc_scsi_buf - Success
  **/
 static struct lpfc_scsi_buf*
-lpfc_get_scsi_buf(struct lpfc_hba * phba)
+lpfc_get_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
         struct  lpfc_scsi_buf * lpfc_cmd = NULL;
         struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
@@ -941,6 +950,67 @@ lpfc_get_scsi_buf(struct lpfc_hba * phba)
         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
         return  lpfc_cmd;
 }
+/**
+ * lpfc_get_scsi_buf_s4 - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
+ * @phba: The HBA for which this call is being executed.
+ *
+ * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
+ * and returns to caller.
+ *
+ * Return codes:
+ *   NULL - Error
+ *   Pointer to lpfc_scsi_buf - Success
+ **/
+static struct lpfc_scsi_buf*
+lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
+{
+        struct  lpfc_scsi_buf *lpfc_cmd = NULL;
+        struct  lpfc_scsi_buf *start_lpfc_cmd = NULL;
+        struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
+        unsigned long iflag = 0;
+        int found = 0;
+
+        spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
+        list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
+        spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
+        while (!found && lpfc_cmd) {
+                if (lpfc_test_rrq_active(phba, ndlp,
+                                         lpfc_cmd->cur_iocbq.sli4_xritag)) {
+                        lpfc_release_scsi_buf_s4(phba, lpfc_cmd);
+                        spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
+                        list_remove_head(scsi_buf_list, lpfc_cmd,
+                                         struct lpfc_scsi_buf, list);
+                        spin_unlock_irqrestore(&phba->scsi_buf_list_lock,
+                                                 iflag);
+                        if (lpfc_cmd == start_lpfc_cmd) {
+                                lpfc_cmd = NULL;
+                                break;
+                        } else
+                                continue;
+                }
+                found = 1;
+                lpfc_cmd->seg_cnt = 0;
+                lpfc_cmd->nonsg_phys = 0;
+                lpfc_cmd->prot_seg_cnt = 0;
+        }
+        return  lpfc_cmd;
+}
+/**
+ * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
+ * @phba: The HBA for which this call is being executed.
+ *
+ * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
+ * and returns to caller.
+ *
+ * Return codes:
+ *   NULL - Error
+ *   Pointer to lpfc_scsi_buf - Success
+ **/
+static struct lpfc_scsi_buf*
+lpfc_get_scsi_buf(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
+{
+        return  phba->lpfc_get_scsi_buf(phba, ndlp);
+}
 
 /**
  * lpfc_release_scsi_buf - Return a scsi buffer back to hba scsi buf list
@@ -2744,18 +2814,19 @@ lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
 
         phba->lpfc_scsi_unprep_dma_buf = lpfc_scsi_unprep_dma_buf;
         phba->lpfc_scsi_prep_cmnd = lpfc_scsi_prep_cmnd;
-        phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf;
 
         switch (dev_grp) {
         case LPFC_PCI_DEV_LP:
                 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s3;
                 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s3;
                 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s3;
+                phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s3;
                 break;
         case LPFC_PCI_DEV_OC:
                 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s4;
                 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s4;
                 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s4;
+                phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf_s4;
                 break;
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -2764,7 +2835,6 @@ lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
                 return -ENODEV;
                 break;
         }
-        phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf;
         phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
         phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
         return 0;
@@ -2940,7 +3010,7 @@ lpfc_queuecommand_lck(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
         if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth)
                 goto out_host_busy;
 
-        lpfc_cmd = lpfc_get_scsi_buf(phba);
+        lpfc_cmd = lpfc_get_scsi_buf(phba, ndlp);
         if (lpfc_cmd == NULL) {
                 lpfc_rampdown_queue_depth(phba);
 
@@ -3239,7 +3309,7 @@ lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
         if (!pnode || !NLP_CHK_NODE_ACT(pnode))
                 return FAILED;
 
-        lpfc_cmd = lpfc_get_scsi_buf(phba);
+        lpfc_cmd = lpfc_get_scsi_buf(phba, rdata->pnode);
         if (lpfc_cmd == NULL)
                 return FAILED;
         lpfc_cmd->timeout = 60;
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 554efa6623f4..634b2fea9c4d 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -513,8 +513,344 @@ __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
 }
 
 /**
+ * __lpfc_set_rrq_active - set RRQ active bit in the ndlp's xri_bitmap.
+ * @phba: Pointer to HBA context object.
+ * @ndlp: nodelist pointer for this target.
+ * @xritag: xri used in this exchange.
+ * @rxid: Remote Exchange ID.
+ * @send_rrq: Flag used to determine if we should send rrq els cmd.
+ *
+ * This function is called with hbalock held.
+ * The active bit is set in the ndlp's active rrq xri_bitmap. Allocates an
+ * rrq struct and adds it to the active_rrq_list.
+ *
+ * returns  0 for rrq slot for this xri
+ *         < 0  Were not able to get rrq mem or invalid parameter.
+ **/
+static int
+__lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
+                uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
+{
+        uint16_t adj_xri;
+        struct lpfc_node_rrq *rrq;
+        int empty;
+
+        /*
+         * set the active bit even if there is no mem available.
+         */
+        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
+        if (!ndlp)
+                return -EINVAL;
+        if (test_and_set_bit(adj_xri, ndlp->active_rrqs.xri_bitmap))
+                return -EINVAL;
+        rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
+        if (rrq) {
+                rrq->send_rrq = send_rrq;
+                rrq->xritag = xritag;
+                rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
+                rrq->ndlp = ndlp;
+                rrq->nlp_DID = ndlp->nlp_DID;
+                rrq->vport = ndlp->vport;
+                rrq->rxid = rxid;
+                empty = list_empty(&phba->active_rrq_list);
+                if (phba->cfg_enable_rrq && send_rrq)
+                        /*
+                         * We need the xri before we can add this to the
+                         * phba active rrq list.
+                         */
+                        rrq->send_rrq = send_rrq;
+                else
+                        rrq->send_rrq = 0;
+                list_add_tail(&rrq->list, &phba->active_rrq_list);
+                if (!(phba->hba_flag & HBA_RRQ_ACTIVE)) {
+                        phba->hba_flag |= HBA_RRQ_ACTIVE;
+                        if (empty)
+                                lpfc_worker_wake_up(phba);
+                }
+                return 0;
+        }
+        return -ENOMEM;
+}
+
+/**
+ * __lpfc_clr_rrq_active - Clears RRQ active bit in xri_bitmap.
+ * @phba: Pointer to HBA context object.
+ * @xritag: xri used in this exchange.
+ * @rrq: The RRQ to be cleared.
+ *
+ * This function is called with hbalock held. This function
+ **/
+static void
+__lpfc_clr_rrq_active(struct lpfc_hba *phba,
+                        uint16_t xritag,
+                        struct lpfc_node_rrq *rrq)
+{
+        uint16_t adj_xri;
+        struct lpfc_nodelist *ndlp;
+
+        ndlp = lpfc_findnode_did(rrq->vport, rrq->nlp_DID);
+
+        /* The target DID could have been swapped (cable swap)
+         * we should use the ndlp from the findnode if it is
+         * available.
+         */
+        if (!ndlp)
+                ndlp = rrq->ndlp;
+
+        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
+        if (test_and_clear_bit(adj_xri, ndlp->active_rrqs.xri_bitmap)) {
+                rrq->send_rrq = 0;
+                rrq->xritag = 0;
+                rrq->rrq_stop_time = 0;
+        }
+        mempool_free(rrq, phba->rrq_pool);
+}
+
+/**
+ * lpfc_handle_rrq_active - Checks if RRQ has waithed RATOV.
+ * @phba: Pointer to HBA context object.
+ *
+ * This function is called with hbalock held. This function
+ * Checks if stop_time (ratov from setting rrq active) has
+ * been reached, if it has and the send_rrq flag is set then
+ * it will call lpfc_send_rrq. If the send_rrq flag is not set
+ * then it will just call the routine to clear the rrq and
+ * free the rrq resource.
+ * The timer is set to the next rrq that is going to expire before
+ * leaving the routine.
+ *
+ **/
+void
+lpfc_handle_rrq_active(struct lpfc_hba *phba)
+{
+        struct lpfc_node_rrq *rrq;
+        struct lpfc_node_rrq *nextrrq;
+        unsigned long next_time;
+        unsigned long iflags;
+
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        phba->hba_flag &= ~HBA_RRQ_ACTIVE;
+        next_time = jiffies + HZ * (phba->fc_ratov + 1);
+        list_for_each_entry_safe(rrq, nextrrq,
+                        &phba->active_rrq_list, list) {
+                if (time_after(jiffies, rrq->rrq_stop_time)) {
+                        list_del(&rrq->list);
+                        if (!rrq->send_rrq)
+                                /* this call will free the rrq */
+                                __lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
+                        else {
+                        /* if we send the rrq then the completion handler
+                         *  will clear the bit in the xribitmap.
+                         */
+                                spin_unlock_irqrestore(&phba->hbalock, iflags);
+                                if (lpfc_send_rrq(phba, rrq)) {
+                                        lpfc_clr_rrq_active(phba, rrq->xritag,
+                                                                 rrq);
+                                }
+                                spin_lock_irqsave(&phba->hbalock, iflags);
+                        }
+                } else if  (time_before(rrq->rrq_stop_time, next_time))
+                        next_time = rrq->rrq_stop_time;
+        }
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        if (!list_empty(&phba->active_rrq_list))
+                mod_timer(&phba->rrq_tmr, next_time);
+}
+
+/**
+ * lpfc_get_active_rrq - Get the active RRQ for this exchange.
+ * @vport: Pointer to vport context object.
+ * @xri: The xri used in the exchange.
+ * @did: The targets DID for this exchange.
+ *
+ * returns NULL = rrq not found in the phba->active_rrq_list.
+ *         rrq = rrq for this xri and target.
+ **/
+struct lpfc_node_rrq *
+lpfc_get_active_rrq(struct lpfc_vport *vport, uint16_t xri, uint32_t did)
+{
+        struct lpfc_hba *phba = vport->phba;
+        struct lpfc_node_rrq *rrq;
+        struct lpfc_node_rrq *nextrrq;
+        unsigned long iflags;
+
+        if (phba->sli_rev != LPFC_SLI_REV4)
+                return NULL;
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list) {
+                if (rrq->vport == vport && rrq->xritag == xri &&
+                                rrq->nlp_DID == did){
+                        list_del(&rrq->list);
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
+                        return rrq;
+                }
+        }
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        return NULL;
+}
+
+/**
+ * lpfc_cleanup_vports_rrqs - Remove and clear the active RRQ for this vport.
+ * @vport: Pointer to vport context object.
+ *
+ * Remove all active RRQs for this vport from the phba->active_rrq_list and
+ * clear the rrq.
+ **/
+void
+lpfc_cleanup_vports_rrqs(struct lpfc_vport *vport)
+
+{
+        struct lpfc_hba *phba = vport->phba;
+        struct lpfc_node_rrq *rrq;
+        struct lpfc_node_rrq *nextrrq;
+        unsigned long iflags;
+
+        if (phba->sli_rev != LPFC_SLI_REV4)
+                return;
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list) {
+                if (rrq->vport == vport) {
+                        list_del(&rrq->list);
+                        __lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
+                }
+        }
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+}
+
+/**
+ * lpfc_cleanup_wt_rrqs - Remove all rrq's from the active list.
+ * @phba: Pointer to HBA context object.
+ *
+ * Remove all rrqs from the phba->active_rrq_list and free them by
+ * calling __lpfc_clr_active_rrq
+ *
+ **/
+void
+lpfc_cleanup_wt_rrqs(struct lpfc_hba *phba)
+{
+        struct lpfc_node_rrq *rrq;
+        struct lpfc_node_rrq *nextrrq;
+        unsigned long next_time;
+        unsigned long iflags;
+
+        if (phba->sli_rev != LPFC_SLI_REV4)
+                return;
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        phba->hba_flag &= ~HBA_RRQ_ACTIVE;
+        next_time = jiffies + HZ * (phba->fc_ratov * 2);
+        list_for_each_entry_safe(rrq, nextrrq, &phba->active_rrq_list, list) {
+                list_del(&rrq->list);
+                __lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
+        }
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        if (!list_empty(&phba->active_rrq_list))
+                mod_timer(&phba->rrq_tmr, next_time);
+}
+
+
+/**
+ * __lpfc_test_rrq_active - Test RRQ bit in xri_bitmap.
+ * @phba: Pointer to HBA context object.
+ * @ndlp: Targets nodelist pointer for this exchange.
+ * @xritag the xri in the bitmap to test.
+ *
+ * This function is called with hbalock held. This function
+ * returns 0 = rrq not active for this xri
+ *         1 = rrq is valid for this xri.
+ **/
+static int
+__lpfc_test_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
+                        uint16_t  xritag)
+{
+        uint16_t adj_xri;
+
+        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
+        if (!ndlp)
+                return 0;
+        if (test_bit(adj_xri, ndlp->active_rrqs.xri_bitmap))
+                        return 1;
+        else
+                return 0;
+}
+
+/**
+ * lpfc_set_rrq_active - set RRQ active bit in xri_bitmap.
+ * @phba: Pointer to HBA context object.
+ * @ndlp: nodelist pointer for this target.
+ * @xritag: xri used in this exchange.
+ * @rxid: Remote Exchange ID.
+ * @send_rrq: Flag used to determine if we should send rrq els cmd.
+ *
+ * This function takes the hbalock.
+ * The active bit is always set in the active rrq xri_bitmap even
+ * if there is no slot avaiable for the other rrq information.
+ *
+ * returns 0 rrq actived for this xri
+ *         < 0 No memory or invalid ndlp.
+ **/
+int
+lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
+                        uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
+{
+        int ret;
+        unsigned long iflags;
+
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        ret = __lpfc_set_rrq_active(phba, ndlp, xritag, rxid, send_rrq);
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        return ret;
+}
+
+/**
+ * lpfc_clr_rrq_active - Clears RRQ active bit in xri_bitmap.
+ * @phba: Pointer to HBA context object.
+ * @xritag: xri used in this exchange.
+ * @rrq: The RRQ to be cleared.
+ *
+ * This function is takes the hbalock.
+ **/
+void
+lpfc_clr_rrq_active(struct lpfc_hba *phba,
+                        uint16_t xritag,
+                        struct lpfc_node_rrq *rrq)
+{
+        unsigned long iflags;
+
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        __lpfc_clr_rrq_active(phba, xritag, rrq);
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        return;
+}
+
+
+
+/**
+ * lpfc_test_rrq_active - Test RRQ bit in xri_bitmap.
+ * @phba: Pointer to HBA context object.
+ * @ndlp: Targets nodelist pointer for this exchange.
+ * @xritag the xri in the bitmap to test.
+ *
+ * This function takes the hbalock.
+ * returns 0 = rrq not active for this xri
+ *         1 = rrq is valid for this xri.
+ **/
+int
+lpfc_test_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
+                        uint16_t  xritag)
+{
+        int ret;
+        unsigned long iflags;
+
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        ret = __lpfc_test_rrq_active(phba, ndlp, xritag);
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        return ret;
+}
+
+/**
  * __lpfc_sli_get_sglq - Allocates an iocb object from sgl pool
  * @phba: Pointer to HBA context object.
+ * @piocb: Pointer to the iocbq.
  *
  * This function is called with hbalock held. This function
  * Gets a new driver sglq object from the sglq list. If the
@@ -522,17 +858,51 @@ __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
  * allocated sglq object else it returns NULL.
  **/
 static struct lpfc_sglq *
-__lpfc_sli_get_sglq(struct lpfc_hba *phba)
+__lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
 {
         struct list_head *lpfc_sgl_list = &phba->sli4_hba.lpfc_sgl_list;
         struct lpfc_sglq *sglq = NULL;
+        struct lpfc_sglq *start_sglq = NULL;
         uint16_t adj_xri;
+        struct lpfc_scsi_buf *lpfc_cmd;
+        struct lpfc_nodelist *ndlp;
+        int found = 0;
+
+        if (piocbq->iocb_flag &  LPFC_IO_FCP) {
+                lpfc_cmd = (struct lpfc_scsi_buf *) piocbq->context1;
+                ndlp = lpfc_cmd->rdata->pnode;
+        } else  if ((piocbq->iocb.ulpCommand == CMD_GEN_REQUEST64_CR) &&
+                        !(piocbq->iocb_flag & LPFC_IO_LIBDFC))
+                ndlp = piocbq->context_un.ndlp;
+        else
+                ndlp = piocbq->context1;
+
         list_remove_head(lpfc_sgl_list, sglq, struct lpfc_sglq, list);
-        if (!sglq)
-                return NULL;
-        adj_xri = sglq->sli4_xritag - phba->sli4_hba.max_cfg_param.xri_base;
-        phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = sglq;
-        sglq->state = SGL_ALLOCATED;
+        start_sglq = sglq;
+        while (!found) {
+                if (!sglq)
+                        return NULL;
+                adj_xri = sglq->sli4_xritag -
+                                phba->sli4_hba.max_cfg_param.xri_base;
+                if (__lpfc_test_rrq_active(phba, ndlp, sglq->sli4_xritag)) {
+                        /* This xri has an rrq outstanding for this DID.
+                         * put it back in the list and get another xri.
+                         */
+                        list_add_tail(&sglq->list, lpfc_sgl_list);
+                        sglq = NULL;
+                        list_remove_head(lpfc_sgl_list, sglq,
+                                                struct lpfc_sglq, list);
+                        if (sglq == start_sglq) {
+                                sglq = NULL;
+                                break;
+                        } else
+                                continue;
+                }
+                sglq->ndlp = ndlp;
+                found = 1;
+                phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = sglq;
+                sglq->state = SGL_ALLOCATED;
+        }
         return sglq;
 }
 
@@ -598,6 +968,7 @@ __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
                                 &phba->sli4_hba.abts_sgl_list_lock, iflag);
                 } else {
                         sglq->state = SGL_FREED;
+                        sglq->ndlp = NULL;
                         list_add(&sglq->list, &phba->sli4_hba.lpfc_sgl_list);
 
                         /* Check if TXQ queue needs to be serviced */
@@ -1634,7 +2005,6 @@ lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
         case MBX_READ_LNK_STAT:
         case MBX_REG_LOGIN:
         case MBX_UNREG_LOGIN:
-        case MBX_READ_LA:
         case MBX_CLEAR_LA:
         case MBX_DUMP_MEMORY:
         case MBX_DUMP_CONTEXT:
@@ -1656,7 +2026,7 @@ lpfc_sli_chk_mbx_command(uint8_t mbxCommand)
         case MBX_READ_SPARM64:
         case MBX_READ_RPI64:
         case MBX_REG_LOGIN64:
-        case MBX_READ_LA64:
+        case MBX_READ_TOPOLOGY:
         case MBX_WRITE_WWN:
         case MBX_SET_DEBUG:
         case MBX_LOAD_EXP_ROM:
@@ -1746,11 +2116,6 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 kfree(mp);
         }
 
-        if ((pmb->u.mb.mbxCommand == MBX_UNREG_LOGIN) &&
-            (phba->sli_rev == LPFC_SLI_REV4) &&
-            (pmb->u.mb.un.varUnregLogin.rsvd1 == 0x0))
-                lpfc_sli4_free_rpi(phba, pmb->u.mb.un.varUnregLogin.rpi);
-
         /*
          * If a REG_LOGIN succeeded  after node is destroyed or node
          * is in re-discovery driver need to cleanup the RPI.
@@ -3483,12 +3848,6 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
         phba->pport->fc_myDID = 0;
         phba->pport->fc_prevDID = 0;
 
-        /* Turn off parity checking and serr during the physical reset */
-        pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
-        pci_write_config_word(phba->pcidev, PCI_COMMAND,
-                              (cfg_value &
-                              ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
-
         spin_lock_irq(&phba->hbalock);
         psli->sli_flag &= ~(LPFC_PROCESS_LA);
         phba->fcf.fcf_flag = 0;
@@ -3508,9 +3867,18 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
         /* Now physically reset the device */
         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
                         "0389 Performing PCI function reset!\n");
+
+        /* Turn off parity checking and serr during the physical reset */
+        pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
+        pci_write_config_word(phba->pcidev, PCI_COMMAND, (cfg_value &
+                              ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
+
         /* Perform FCoE PCI function reset */
         lpfc_pci_function_reset(phba);
 
+        /* Restore PCI cmd register */
+        pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
+
         return 0;
 }
 
@@ -4317,6 +4685,10 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         struct lpfc_vport *vport = phba->pport;
         struct lpfc_dmabuf *mp;
 
+        /*
+         * TODO:  Why does this routine execute these task in a different
+         * order from probe?
+         */
         /* Perform a PCI function reset to start from clean */
         rc = lpfc_pci_function_reset(phba);
         if (unlikely(rc))
@@ -4357,13 +4729,16 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         }
 
         rc = lpfc_sli4_read_rev(phba, mboxq, vpd, &vpd_size);
-        if (unlikely(rc))
-                goto out_free_vpd;
-
+        if (unlikely(rc)) {
+                kfree(vpd);
+                goto out_free_mbox;
+        }
         mqe = &mboxq->u.mqe;
         phba->sli_rev = bf_get(lpfc_mbx_rd_rev_sli_lvl, &mqe->un.read_rev);
         if (bf_get(lpfc_mbx_rd_rev_fcoe, &mqe->un.read_rev))
-                phba->hba_flag |= HBA_FCOE_SUPPORT;
+                phba->hba_flag |= HBA_FCOE_MODE;
+        else
+                phba->hba_flag &= ~HBA_FCOE_MODE;
 
         if (bf_get(lpfc_mbx_rd_rev_cee_ver, &mqe->un.read_rev) ==
                 LPFC_DCBX_CEE_MODE)
@@ -4372,13 +4747,14 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 phba->hba_flag &= ~HBA_FIP_SUPPORT;
 
         if (phba->sli_rev != LPFC_SLI_REV4 ||
-            !(phba->hba_flag & HBA_FCOE_SUPPORT)) {
+            !(phba->hba_flag & HBA_FCOE_MODE)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                         "0376 READ_REV Error. SLI Level %d "
                         "FCoE enabled %d\n",
-                        phba->sli_rev, phba->hba_flag & HBA_FCOE_SUPPORT);
+                        phba->sli_rev, phba->hba_flag & HBA_FCOE_MODE);
                 rc = -EIO;
-                goto out_free_vpd;
+                kfree(vpd);
+                goto out_free_mbox;
         }
         /*
          * Evaluate the read rev and vpd data. Populate the driver
@@ -4392,6 +4768,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                                 "Using defaults.\n", rc);
                 rc = 0;
         }
+        kfree(vpd);
 
         /* Save information as VPD data */
         phba->vpd.rev.biuRev = mqe->un.read_rev.first_hw_rev;
@@ -4428,7 +4805,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
         if (unlikely(rc)) {
                 rc = -EIO;
-                goto out_free_vpd;
+                goto out_free_mbox;
         }
 
         /*
@@ -4476,7 +4853,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         if (rc) {
                 phba->link_state = LPFC_HBA_ERROR;
                 rc = -ENOMEM;
-                goto out_free_vpd;
+                goto out_free_mbox;
         }
 
         mboxq->vport = vport;
@@ -4501,7 +4878,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                                 rc, bf_get(lpfc_mqe_status, mqe));
                 phba->link_state = LPFC_HBA_ERROR;
                 rc = -EIO;
-                goto out_free_vpd;
+                goto out_free_mbox;
         }
 
         if (phba->cfg_soft_wwnn)
@@ -4526,7 +4903,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                                 "0582 Error %d during sgl post operation\n",
                                         rc);
                 rc = -ENODEV;
-                goto out_free_vpd;
+                goto out_free_mbox;
         }
 
         /* Register SCSI SGL pool to the device */
@@ -4538,7 +4915,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 /* Some Scsi buffers were moved to the abort scsi list */
                 /* A pci function reset will repost them */
                 rc = -ENODEV;
-                goto out_free_vpd;
+                goto out_free_mbox;
         }
 
         /* Post the rpi header region to the device. */
@@ -4548,7 +4925,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                                 "0393 Error %d during rpi post operation\n",
                                 rc);
                 rc = -ENODEV;
-                goto out_free_vpd;
+                goto out_free_mbox;
         }
 
         /* Set up all the queues to the device */
@@ -4608,33 +4985,33 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 }
         }
 
+        if (!(phba->hba_flag & HBA_FCOE_MODE)) {
+                /*
+                 * The FC Port needs to register FCFI (index 0)
+                 */
+                lpfc_reg_fcfi(phba, mboxq);
+                mboxq->vport = phba->pport;
+                rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+                if (rc == MBX_SUCCESS)
+                        rc = 0;
+                else
+                        goto out_unset_queue;
+        }
         /*
          * The port is ready, set the host's link state to LINK_DOWN
          * in preparation for link interrupts.
          */
-        lpfc_init_link(phba, mboxq, phba->cfg_topology, phba->cfg_link_speed);
-        mboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
-        lpfc_set_loopback_flag(phba);
-        /* Change driver state to LPFC_LINK_DOWN right before init link */
         spin_lock_irq(&phba->hbalock);
         phba->link_state = LPFC_LINK_DOWN;
         spin_unlock_irq(&phba->hbalock);
-        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
-        if (unlikely(rc != MBX_NOT_FINISHED)) {
-                kfree(vpd);
-                return 0;
-        } else
-                rc = -EIO;
-
+        rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
+out_unset_queue:
         /* Unset all the queues set up in this routine when error out */
         if (rc)
                 lpfc_sli4_queue_unset(phba);
-
 out_stop_timers:
         if (rc)
                 lpfc_stop_hba_timers(phba);
-out_free_vpd:
-        kfree(vpd);
 out_free_mbox:
         mempool_free(mboxq, phba->mbox_mem_pool);
         return rc;
@@ -5863,6 +6240,8 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
         IOCB_t *icmd;
         int numBdes = 0;
         int i = 0;
+        uint32_t offset = 0; /* accumulated offset in the sg request list */
+        int inbound = 0; /* number of sg reply entries inbound from firmware */
 
         if (!piocbq || !sglq)
                 return xritag;
@@ -5897,6 +6276,20 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
                          */
                         bde.tus.w = le32_to_cpu(bpl->tus.w);
                         sgl->sge_len = cpu_to_le32(bde.tus.f.bdeSize);
+                        /* The offsets in the sgl need to be accumulated
+                         * separately for the request and reply lists.
+                         * The request is always first, the reply follows.
+                         */
+                        if (piocbq->iocb.ulpCommand == CMD_GEN_REQUEST64_CR) {
+                                /* add up the reply sg entries */
+                                if (bpl->tus.f.bdeFlags == BUFF_TYPE_BDE_64I)
+                                        inbound++;
+                                /* first inbound? reset the offset */
+                                if (inbound == 1)
+                                        offset = 0;
+                                bf_set(lpfc_sli4_sge_offset, sgl, offset);
+                                offset += bde.tus.f.bdeSize;
+                        }
                         bpl++;
                         sgl++;
                 }
@@ -6028,11 +6421,6 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(els_req64_vf, &wqe->els_req, 0);
                 /* And a VFID for word 12 */
                 bf_set(els_req64_vfid, &wqe->els_req, 0);
-                /*
-                 * Set ct field to 3, indicates that the context_tag field
-                 * contains the FCFI and remote N_Port_ID is
-                 * in word 5.
-                 */
                 ct = ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l);
                 bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
                        iocbq->iocb.ulpContext);
@@ -6140,6 +6528,18 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_ebde_cnt, &wqe->fcp_icmd.wqe_com, 0);
         break;
         case CMD_GEN_REQUEST64_CR:
+                /* For this command calculate the xmit length of the
+                 * request bde.
+                 */
+                xmit_len = 0;
+                numBdes = iocbq->iocb.un.genreq64.bdl.bdeSize /
+                        sizeof(struct ulp_bde64);
+                for (i = 0; i < numBdes; i++) {
+                        if (bpl[i].tus.f.bdeFlags != BUFF_TYPE_BDE_64)
+                                break;
+                        bde.tus.w = le32_to_cpu(bpl[i].tus.w);
+                        xmit_len += bde.tus.f.bdeSize;
+                }
                 /* word3 iocb=IO_TAG wqe=request_payload_len */
                 wqe->gen_req.request_payload_len = xmit_len;
                 /* word4 iocb=parameter wqe=relative_offset memcpy */
@@ -6320,7 +6720,7 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
                                         return IOCB_BUSY;
                                 }
                         } else {
-                        sglq = __lpfc_sli_get_sglq(phba);
+                        sglq = __lpfc_sli_get_sglq(phba, piocb);
                                 if (!sglq) {
                                         if (!(flag & SLI_IOCB_RET_IOCB)) {
                                                 __lpfc_sli_ringtx_put(phba,
@@ -8033,29 +8433,66 @@ static int
 lpfc_sli4_eratt_read(struct lpfc_hba *phba)
 {
         uint32_t uerr_sta_hi, uerr_sta_lo;
+        uint32_t if_type, portsmphr;
+        struct lpfc_register portstat_reg;
 
-        /* For now, use the SLI4 device internal unrecoverable error
+        /*
+         * For now, use the SLI4 device internal unrecoverable error
          * registers for error attention. This can be changed later.
          */
-        uerr_sta_lo = readl(phba->sli4_hba.UERRLOregaddr);
-        uerr_sta_hi = readl(phba->sli4_hba.UERRHIregaddr);
-        if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||
-            (~phba->sli4_hba.ue_mask_hi & uerr_sta_hi)) {
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        switch (if_type) {
+        case LPFC_SLI_INTF_IF_TYPE_0:
+                uerr_sta_lo = readl(phba->sli4_hba.u.if_type0.UERRLOregaddr);
+                uerr_sta_hi = readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
+                if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||
+                    (~phba->sli4_hba.ue_mask_hi & uerr_sta_hi)) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "1423 HBA Unrecoverable error: "
+                                        "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
+                                        "ue_mask_lo_reg=0x%x, "
+                                        "ue_mask_hi_reg=0x%x\n",
+                                        uerr_sta_lo, uerr_sta_hi,
+                                        phba->sli4_hba.ue_mask_lo,
+                                        phba->sli4_hba.ue_mask_hi);
+                        phba->work_status[0] = uerr_sta_lo;
+                        phba->work_status[1] = uerr_sta_hi;
+                        phba->work_ha |= HA_ERATT;
+                        phba->hba_flag |= HBA_ERATT_HANDLED;
+                        return 1;
+                }
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_2:
+                portstat_reg.word0 =
+                        readl(phba->sli4_hba.u.if_type2.STATUSregaddr);
+                portsmphr = readl(phba->sli4_hba.PSMPHRregaddr);
+                if (bf_get(lpfc_sliport_status_err, &portstat_reg)) {
+                        phba->work_status[0] =
+                                readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
+                        phba->work_status[1] =
+                                readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2885 Port Error Detected: "
+                                        "port status reg 0x%x, "
+                                        "port smphr reg 0x%x, "
+                                        "error 1=0x%x, error 2=0x%x\n",
+                                        portstat_reg.word0,
+                                        portsmphr,
+                                        phba->work_status[0],
+                                        phba->work_status[1]);
+                        phba->work_ha |= HA_ERATT;
+                        phba->hba_flag |= HBA_ERATT_HANDLED;
+                        return 1;
+                }
+                break;
+        case LPFC_SLI_INTF_IF_TYPE_1:
+        default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "1423 HBA Unrecoverable error: "
-                                "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
-                                "ue_mask_lo_reg=0x%x, ue_mask_hi_reg=0x%x\n",
-                                uerr_sta_lo, uerr_sta_hi,
-                                phba->sli4_hba.ue_mask_lo,
-                                phba->sli4_hba.ue_mask_hi);
-                phba->work_status[0] = uerr_sta_lo;
-                phba->work_status[1] = uerr_sta_hi;
-                /* Set the driver HA work bitmap */
-                phba->work_ha |= HA_ERATT;
-                /* Indicate polling handles this ERATT */
-                phba->hba_flag |= HBA_ERATT_HANDLED;
+                                "2886 HBA Error Attention on unsupported "
+                                "if type %d.", if_type);
                 return 1;
         }
+
         return 0;
 }
 
@@ -8110,7 +8547,7 @@ lpfc_sli_check_eratt(struct lpfc_hba *phba)
                 ha_copy = lpfc_sli_eratt_read(phba);
                 break;
         case LPFC_SLI_REV4:
-                /* Read devcie Uncoverable Error (UERR) registers */
+                /* Read device Uncoverable Error (UERR) registers */
                 ha_copy = lpfc_sli4_eratt_read(phba);
                 break;
         default:
@@ -10155,16 +10592,20 @@ lpfc_mq_create(struct lpfc_hba *phba, struct lpfc_queue *mq,
                          length, LPFC_SLI4_MBX_EMBED);
 
         mq_create_ext = &mbox->u.mqe.un.mq_create_ext;
-        bf_set(lpfc_mbx_mq_create_ext_num_pages, &mq_create_ext->u.request,
-                    mq->page_count);
-        bf_set(lpfc_mbx_mq_create_ext_async_evt_link, &mq_create_ext->u.request,
-               1);
-        bf_set(lpfc_mbx_mq_create_ext_async_evt_fcfste,
+        bf_set(lpfc_mbx_mq_create_ext_num_pages,
+               &mq_create_ext->u.request, mq->page_count);
+        bf_set(lpfc_mbx_mq_create_ext_async_evt_link,
+               &mq_create_ext->u.request, 1);
+        bf_set(lpfc_mbx_mq_create_ext_async_evt_fip,
                &mq_create_ext->u.request, 1);
         bf_set(lpfc_mbx_mq_create_ext_async_evt_group5,
                &mq_create_ext->u.request, 1);
-        bf_set(lpfc_mq_context_cq_id, &mq_create_ext->u.request.context,
-               cq->queue_id);
+        bf_set(lpfc_mbx_mq_create_ext_async_evt_fc,
+               &mq_create_ext->u.request, 1);
+        bf_set(lpfc_mbx_mq_create_ext_async_evt_sli,
+               &mq_create_ext->u.request, 1);
+        bf_set(lpfc_mq_context_cq_id,
+               &mq_create_ext->u.request.context, cq->queue_id);
         bf_set(lpfc_mq_context_valid, &mq_create_ext->u.request.context, 1);
         switch (mq->entry_count) {
         default:
@@ -11137,7 +11578,8 @@ lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
 static int
 lpfc_fc_frame_check(struct lpfc_hba *phba, struct fc_frame_header *fc_hdr)
 {
-        char *rctl_names[] = FC_RCTL_NAMES_INIT;
+        /*  make rctl_names static to save stack space */
+        static char *rctl_names[] = FC_RCTL_NAMES_INIT;
         char *type_names[] = FC_TYPE_NAMES_INIT;
         struct fc_vft_header *fc_vft_hdr;
 
@@ -11538,6 +11980,10 @@ lpfc_sli4_seq_abort_acc(struct lpfc_hba *phba,
                                 "SID:x%x\n", oxid, sid);
                 return;
         }
+        if (rxid >= phba->sli4_hba.max_cfg_param.xri_base
+                && rxid <= (phba->sli4_hba.max_cfg_param.max_xri
+                + phba->sli4_hba.max_cfg_param.xri_base))
+                lpfc_set_rrq_active(phba, ndlp, rxid, oxid, 0);
 
         /* Allocate buffer for acc iocb */
         ctiocb = lpfc_sli_get_iocbq(phba);
@@ -11560,6 +12006,7 @@ lpfc_sli4_seq_abort_acc(struct lpfc_hba *phba,
         icmd->ulpLe = 1;
         icmd->ulpClass = CLASS3;
         icmd->ulpContext = ndlp->nlp_rpi;
+        ctiocb->context1 = ndlp;
 
         ctiocb->iocb_cmpl = NULL;
         ctiocb->vport = phba->pport;
@@ -12129,42 +12576,37 @@ lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp)
 
 /**
  * lpfc_sli4_init_vpi - Initialize a vpi with the port
- * @phba: pointer to lpfc hba data structure.
- * @vpi: vpi value to activate with the port.
+ * @vport: Pointer to the vport for which the vpi is being initialized
  *
- * This routine is invoked to activate a vpi with the
- * port when the host intends to use vports with a
- * nonzero vpi.
+ * This routine is invoked to activate a vpi with the port.
  *
  * Returns:
  *    0 success
  *    -Evalue otherwise
  **/
 int
-lpfc_sli4_init_vpi(struct lpfc_hba *phba, uint16_t vpi)
+lpfc_sli4_init_vpi(struct lpfc_vport *vport)
 {
         LPFC_MBOXQ_t *mboxq;
         int rc = 0;
         int retval = MBX_SUCCESS;
         uint32_t mbox_tmo;
-
-        if (vpi == 0)
-                return -EINVAL;
+        struct lpfc_hba *phba = vport->phba;
         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mboxq)
                 return -ENOMEM;
-        lpfc_init_vpi(phba, mboxq, vpi);
+        lpfc_init_vpi(phba, mboxq, vport->vpi);
         mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_INIT_VPI);
         rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
         if (rc != MBX_SUCCESS) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_SLI,
                                 "2022 INIT VPI Mailbox failed "
                                 "status %d, mbxStatus x%x\n", rc,
                                 bf_get(lpfc_mqe_status, &mboxq->u.mqe));
                 retval = -EIO;
         }
         if (rc != MBX_TIMEOUT)
-                mempool_free(mboxq, phba->mbox_mem_pool);
+                mempool_free(mboxq, vport->phba->mbox_mem_pool);
 
         return retval;
 }
@@ -12854,6 +13296,7 @@ lpfc_cleanup_pending_mbox(struct lpfc_vport *vport)
         struct lpfc_nodelist *act_mbx_ndlp = NULL;
         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
         LIST_HEAD(mbox_cmd_list);
+        uint8_t restart_loop;
 
         /* Clean up internally queued mailbox commands with the vport */
         spin_lock_irq(&phba->hbalock);
@@ -12882,15 +13325,44 @@ lpfc_cleanup_pending_mbox(struct lpfc_vport *vport)
                         mb->mbox_flag |= LPFC_MBX_IMED_UNREG;
                 }
         }
+        /* Cleanup any mailbox completions which are not yet processed */
+        do {
+                restart_loop = 0;
+                list_for_each_entry(mb, &phba->sli.mboxq_cmpl, list) {
+                        /*
+                         * If this mailox is already processed or it is
+                         * for another vport ignore it.
+                         */
+                        if ((mb->vport != vport) ||
+                                (mb->mbox_flag & LPFC_MBX_IMED_UNREG))
+                                continue;
+
+                        if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) &&
+                                (mb->u.mb.mbxCommand != MBX_REG_VPI))
+                                continue;
+
+                        mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+                        if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
+                                ndlp = (struct lpfc_nodelist *)mb->context2;
+                                /* Unregister the RPI when mailbox complete */
+                                mb->mbox_flag |= LPFC_MBX_IMED_UNREG;
+                                restart_loop = 1;
+                                spin_unlock_irq(&phba->hbalock);
+                                spin_lock(shost->host_lock);
+                                ndlp->nlp_flag &= ~NLP_IGNR_REG_CMPL;
+                                spin_unlock(shost->host_lock);
+                                spin_lock_irq(&phba->hbalock);
+                                break;
+                        }
+                }
+        } while (restart_loop);
+
         spin_unlock_irq(&phba->hbalock);
 
         /* Release the cleaned-up mailbox commands */
         while (!list_empty(&mbox_cmd_list)) {
                 list_remove_head(&mbox_cmd_list, mb, LPFC_MBOXQ_t, list);
                 if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
-                        if (phba->sli_rev == LPFC_SLI_REV4)
-                                __lpfc_sli4_free_rpi(phba,
-                                                mb->u.mb.un.varRegLogin.rpi);
                         mp = (struct lpfc_dmabuf *) (mb->context1);
                         if (mp) {
                                 __lpfc_mbuf_free(phba, mp->virt, mp->phys);
@@ -12948,12 +13420,13 @@ lpfc_drain_txq(struct lpfc_hba *phba)
         while (pring->txq_cnt) {
                 spin_lock_irqsave(&phba->hbalock, iflags);
 
-                sglq = __lpfc_sli_get_sglq(phba);
+                piocbq = lpfc_sli_ringtx_get(phba, pring);
+                sglq = __lpfc_sli_get_sglq(phba, piocbq);
                 if (!sglq) {
+                        __lpfc_sli_ringtx_put(phba, pring, piocbq);
                         spin_unlock_irqrestore(&phba->hbalock, iflags);
                         break;
                 } else {
-                        piocbq = lpfc_sli_ringtx_get(phba, pring);
                         if (!piocbq) {
                                 /* The txq_cnt out of sync. This should
                                  * never happen
diff --git a/drivers/scsi/lpfc/lpfc_sli.h b/drivers/scsi/lpfc/lpfc_sli.h
index cd56d6cce6c3..453577c21c14 100644
--- a/drivers/scsi/lpfc/lpfc_sli.h
+++ b/drivers/scsi/lpfc/lpfc_sli.h
@@ -34,9 +34,11 @@ struct lpfc_cq_event {
         union {
                 struct lpfc_mcqe                mcqe_cmpl;
                 struct lpfc_acqe_link           acqe_link;
-                struct lpfc_acqe_fcoe           acqe_fcoe;
+                struct lpfc_acqe_fip            acqe_fip;
                 struct lpfc_acqe_dcbx           acqe_dcbx;
                 struct lpfc_acqe_grp5           acqe_grp5;
+                struct lpfc_acqe_fc_la          acqe_fc;
+                struct lpfc_acqe_sli            acqe_sli;
                 struct lpfc_rcqe                rcqe_cmpl;
                 struct sli4_wcqe_xri_aborted    wcqe_axri;
                 struct lpfc_wcqe_complete       wcqe_cmpl;
@@ -82,6 +84,7 @@ struct lpfc_iocbq {
                 struct lpfc_iocbq    *rsp_iocb;
                 struct lpfcMboxq     *mbox;
                 struct lpfc_nodelist *ndlp;
+                struct lpfc_node_rrq *rrq;
         } context_un;
 
         void (*fabric_iocb_cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index c4483feb8b71..c7217d579e0f 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -137,9 +137,11 @@ struct lpfc_sli4_link {
         uint8_t speed;
         uint8_t duplex;
         uint8_t status;
-        uint8_t physical;
+        uint8_t type;
+        uint8_t number;
         uint8_t fault;
         uint16_t logical_speed;
+        uint16_t topology;
 };
 
 struct lpfc_fcf_rec {
@@ -367,23 +369,39 @@ struct lpfc_sli4_hba {
                                              PCI BAR1, control registers */
         void __iomem *drbl_regs_memmap_p; /* Kernel memory mapped address for
                                              PCI BAR2, doorbell registers */
-        /* BAR0 PCI config space register memory map */
-        void __iomem *UERRLOregaddr; /* Address to UERR_STATUS_LO register */
-        void __iomem *UERRHIregaddr; /* Address to UERR_STATUS_HI register */
-        void __iomem *UEMASKLOregaddr; /* Address to UE_MASK_LO register */
-        void __iomem *UEMASKHIregaddr; /* Address to UE_MASK_HI register */
-        void __iomem *SLIINTFregaddr; /* Address to SLI_INTF register */
-        /* BAR1 FCoE function CSR register memory map */
-        void __iomem *STAregaddr;    /* Address to HST_STATE register */
-        void __iomem *ISRregaddr;    /* Address to HST_ISR register */
-        void __iomem *IMRregaddr;    /* Address to HST_IMR register */
-        void __iomem *ISCRregaddr;   /* Address to HST_ISCR register */
-        /* BAR2 VF-0 doorbell register memory map */
-        void __iomem *RQDBregaddr;   /* Address to RQ_DOORBELL register */
-        void __iomem *WQDBregaddr;   /* Address to WQ_DOORBELL register */
-        void __iomem *EQCQDBregaddr; /* Address to EQCQ_DOORBELL register */
-        void __iomem *MQDBregaddr;   /* Address to MQ_DOORBELL register */
-        void __iomem *BMBXregaddr;   /* Address to BootStrap MBX register */
+        union {
+                struct {
+                        /* IF Type 0, BAR 0 PCI cfg space reg mem map */
+                        void __iomem *UERRLOregaddr;
+                        void __iomem *UERRHIregaddr;
+                        void __iomem *UEMASKLOregaddr;
+                        void __iomem *UEMASKHIregaddr;
+                } if_type0;
+                struct {
+                        /* IF Type 2, BAR 0 PCI cfg space reg mem map. */
+                        void __iomem *STATUSregaddr;
+                        void __iomem *CTRLregaddr;
+                        void __iomem *ERR1regaddr;
+                        void __iomem *ERR2regaddr;
+                } if_type2;
+        } u;
+
+        /* IF type 0, BAR1 and if type 2, Bar 0 CSR register memory map */
+        void __iomem *PSMPHRregaddr;
+
+        /* Well-known SLI INTF register memory map. */
+        void __iomem *SLIINTFregaddr;
+
+        /* IF type 0, BAR 1 function CSR register memory map */
+        void __iomem *ISRregaddr;       /* HST_ISR register */
+        void __iomem *IMRregaddr;       /* HST_IMR register */
+        void __iomem *ISCRregaddr;      /* HST_ISCR register */
+        /* IF type 0, BAR 0 and if type 2, BAR 0 doorbell register memory map */
+        void __iomem *RQDBregaddr;      /* RQ_DOORBELL register */
+        void __iomem *WQDBregaddr;      /* WQ_DOORBELL register */
+        void __iomem *EQCQDBregaddr;    /* EQCQ_DOORBELL register */
+        void __iomem *MQDBregaddr;      /* MQ_DOORBELL register */
+        void __iomem *BMBXregaddr;      /* BootStrap MBX register */
 
         uint32_t ue_mask_lo;
         uint32_t ue_mask_hi;
@@ -466,6 +484,7 @@ struct lpfc_sglq {
         struct list_head clist;
         enum lpfc_sge_type buff_type; /* is this a scsi sgl */
         enum lpfc_sgl_state state;
+        struct lpfc_nodelist *ndlp; /* ndlp associated with IO */
         uint16_t iotag;         /* pre-assigned IO tag */
         uint16_t sli4_xritag;   /* pre-assigned XRI, (OXID) tag. */
         struct sli4_sge *sgl;   /* pre-assigned SGL */
@@ -532,7 +551,6 @@ int lpfc_sli4_post_all_rpi_hdrs(struct lpfc_hba *);
 struct lpfc_rpi_hdr *lpfc_sli4_create_rpi_hdr(struct lpfc_hba *);
 void lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *);
 int lpfc_sli4_alloc_rpi(struct lpfc_hba *);
-void __lpfc_sli4_free_rpi(struct lpfc_hba *, int);
 void lpfc_sli4_free_rpi(struct lpfc_hba *, int);
 void lpfc_sli4_remove_rpis(struct lpfc_hba *);
 void lpfc_sli4_async_event_proc(struct lpfc_hba *);
@@ -548,7 +566,7 @@ int lpfc_sli4_brdreset(struct lpfc_hba *);
 int lpfc_sli4_add_fcf_record(struct lpfc_hba *, struct fcf_record *);
 void lpfc_sli_remove_dflt_fcf(struct lpfc_hba *);
 int lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *);
-int lpfc_sli4_init_vpi(struct lpfc_hba *, uint16_t);
+int lpfc_sli4_init_vpi(struct lpfc_vport *);
 uint32_t lpfc_sli4_cq_release(struct lpfc_queue *, bool);
 uint32_t lpfc_sli4_eq_release(struct lpfc_queue *, bool);
 void lpfc_sli4_fcfi_unreg(struct lpfc_hba *, uint16_t);
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 7a1b5b112a0b..386cf92de492 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -18,7 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.18"
+#define LPFC_DRIVER_VERSION "8.3.20"
 #define LPFC_DRIVER_NAME                "lpfc"
 #define LPFC_SP_DRIVER_HANDLER_NAME     "lpfc:sp"
 #define LPFC_FP_DRIVER_HANDLER_NAME     "lpfc:fp"
diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
index a5281ce893d0..6b8d2952e32f 100644
--- a/drivers/scsi/lpfc/lpfc_vport.c
+++ b/drivers/scsi/lpfc/lpfc_vport.c
@@ -395,8 +395,8 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
          * by the port.
          */
         if ((phba->sli_rev == LPFC_SLI_REV4) &&
-                (pport->fc_flag & FC_VFI_REGISTERED)) {
-                rc = lpfc_sli4_init_vpi(phba, vpi);
+            (pport->fc_flag & FC_VFI_REGISTERED)) {
+                rc = lpfc_sli4_init_vpi(vport);
                 if (rc) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
                                         "1838 Failed to INIT_VPI on vpi %d "
@@ -418,7 +418,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
 
         if ((phba->link_state < LPFC_LINK_UP) ||
             (pport->port_state < LPFC_FABRIC_CFG_LINK) ||
-            (phba->fc_topology == TOPOLOGY_LOOP)) {
+            (phba->fc_topology == LPFC_TOPOLOGY_LOOP)) {
                 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
                 rc = VPORT_OK;
                 goto out;
@@ -514,7 +514,7 @@ enable_vport(struct fc_vport *fc_vport)
         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
         if ((phba->link_state < LPFC_LINK_UP) ||
-            (phba->fc_topology == TOPOLOGY_LOOP)) {
+            (phba->fc_topology == LPFC_TOPOLOGY_LOOP)) {
                 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
                 return VPORT_OK;
         }
@@ -665,7 +665,7 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
         if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
             ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
             phba->link_state >= LPFC_LINK_UP &&
-            phba->fc_topology != TOPOLOGY_LOOP) {
+            phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
                 if (vport->cfg_enable_da_id) {
                         timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
                         if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0))
diff --git a/drivers/scsi/megaraid/Makefile b/drivers/scsi/megaraid/Makefile
index f469915b97c3..5826ed509e3e 100644
--- a/drivers/scsi/megaraid/Makefile
+++ b/drivers/scsi/megaraid/Makefile
@@ -1,3 +1,5 @@
 obj-$(CONFIG_MEGARAID_MM)       += megaraid_mm.o
 obj-$(CONFIG_MEGARAID_MAILBOX)  += megaraid_mbox.o
 obj-$(CONFIG_MEGARAID_SAS)      += megaraid_sas.o
+megaraid_sas-objs := megaraid_sas_base.o megaraid_sas_fusion.o \
+        megaraid_sas_fp.o
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index ad16f5e60046..1b5e375732c0 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -1,15 +1,30 @@
 /*
+ *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *              Linux MegaRAID driver for SAS based RAID controllers
+ *  Copyright (c) 2009-2011  LSI Corporation.
  *
- * Copyright (c) 2003-2005  LSI Corporation.
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
  *
- *              This program is free software; you can redistribute it and/or
- *              modify it under the terms of the GNU General Public License
- *              as published by the Free Software Foundation; either version
- *              2 of the License, or (at your option) any later version.
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
  *
- * FILE         : megaraid_sas.h
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *  FILE: megaraid_sas.h
+ *
+ *  Authors: LSI Corporation
+ *
+ *  Send feedback to: <megaraidlinux@lsi.com>
+ *
+ *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
+ *     ATTN: Linuxraid
  */
 
 #ifndef LSI_MEGARAID_SAS_H
@@ -18,9 +33,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                 "00.00.04.31-rc1"
-#define MEGASAS_RELDATE                 "May 3, 2010"
-#define MEGASAS_EXT_VERSION             "Mon. May 3, 11:41:51 PST 2010"
+#define MEGASAS_VERSION                         "00.00.05.29-rc1"
+#define MEGASAS_RELDATE                         "Dec. 7, 2010"
+#define MEGASAS_EXT_VERSION                     "Tue. Dec. 7 17:00:00 PDT 2010"
 
 /*
  * Device IDs
@@ -32,6 +47,7 @@
 #define PCI_DEVICE_ID_LSI_SAS0079GEN2           0x0079
 #define PCI_DEVICE_ID_LSI_SAS0073SKINNY         0x0073
 #define PCI_DEVICE_ID_LSI_SAS0071SKINNY         0x0071
+#define PCI_DEVICE_ID_LSI_FUSION                0x005b
 
 /*
  * =====================================
@@ -421,7 +437,6 @@ struct megasas_ctrl_prop {
         * Add properties that can be controlled by
         * a bit in the following structure.
         */
-
         struct {
                 u32     copyBackDisabled            : 1;
                 u32     SMARTerEnabled              : 1;
@@ -701,6 +716,7 @@ struct megasas_ctrl_info {
 #define MEGASAS_DEFAULT_INIT_ID                 -1
 #define MEGASAS_MAX_LUN                         8
 #define MEGASAS_MAX_LD                          64
+#define MEGASAS_DEFAULT_CMD_PER_LUN             128
 #define MEGASAS_MAX_PD                          (MEGASAS_MAX_PD_CHANNELS * \
                                                 MEGASAS_MAX_DEV_PER_CHANNEL)
 #define MEGASAS_MAX_LD_IDS                      (MEGASAS_MAX_LD_CHANNELS * \
@@ -769,7 +785,10 @@ struct megasas_ctrl_info {
 */
  
 struct megasas_register_set {
-        u32     reserved_0[4];                  /*0000h*/
+        u32     doorbell;                       /*0000h*/
+        u32     fusion_seq_offset;              /*0004h*/
+        u32     fusion_host_diag;               /*0008h*/
+        u32     reserved_01;                    /*000Ch*/
 
         u32     inbound_msg_0;                  /*0010h*/
         u32     inbound_msg_1;                  /*0014h*/
@@ -789,15 +808,18 @@ struct megasas_register_set {
         u32     inbound_queue_port;             /*0040h*/
         u32     outbound_queue_port;            /*0044h*/
 
-        u32     reserved_2[22];                 /*0048h*/
+        u32     reserved_2[9];                  /*0048h*/
+        u32     reply_post_host_index;          /*006Ch*/
+        u32     reserved_2_2[12];               /*0070h*/
 
         u32     outbound_doorbell_clear;        /*00A0h*/
 
         u32     reserved_3[3];                  /*00A4h*/
 
         u32     outbound_scratch_pad ;          /*00B0h*/
+        u32     outbound_scratch_pad_2;         /*00B4h*/
 
-        u32     reserved_4[3];                  /*00B4h*/
+        u32     reserved_4[2];                  /*00B8h*/
 
         u32     inbound_low_queue_port ;        /*00C0h*/
 
@@ -1272,6 +1294,9 @@ struct megasas_instance {
 
         u16 max_num_sge;
         u16 max_fw_cmds;
+        /* For Fusion its num IOCTL cmds, for others MFI based its
+           max_fw_cmds */
+        u16 max_mfi_cmds;
         u32 max_sectors_per_req;
         struct megasas_aen_event *ev;
 
@@ -1320,6 +1345,16 @@ struct megasas_instance {
 
         struct timer_list io_completion_timer;
         struct list_head internal_reset_pending_q;
+
+        /* Ptr to hba specfic information */
+        void *ctrl_context;
+        u8      msi_flag;
+        struct msix_entry msixentry;
+        u64 map_id;
+        struct megasas_cmd *map_update_cmd;
+        unsigned long bar;
+        long reset_flags;
+        struct mutex reset_mutex;
 };
 
 enum {
@@ -1345,6 +1380,13 @@ struct megasas_instance_template {
                 struct megasas_register_set __iomem *);
         int (*check_reset)(struct megasas_instance *, \
                 struct megasas_register_set __iomem *);
+        irqreturn_t (*service_isr)(int irq, void *devp);
+        void (*tasklet)(unsigned long);
+        u32 (*init_adapter)(struct megasas_instance *);
+        u32 (*build_and_issue_cmd) (struct megasas_instance *,
+                                    struct scsi_cmnd *);
+        void (*issue_dcmd) (struct megasas_instance *instance,
+                            struct megasas_cmd *cmd);
 };
 
 #define MEGASAS_IS_LOGICAL(scp)                                         \
@@ -1371,7 +1413,13 @@ struct megasas_cmd {
         struct list_head list;
         struct scsi_cmnd *scmd;
         struct megasas_instance *instance;
-        u32 frame_count;
+        union {
+                struct {
+                        u16 smid;
+                        u16 resvd;
+                } context;
+                u32 frame_count;
+        };
 };
 
 #define MAX_MGMT_ADAPTERS               1024
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 7451bc096a01..5d6d07bd1cd0 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -1,27 +1,34 @@
 /*
+ *  Linux MegaRAID driver for SAS based RAID controllers
  *
- *              Linux MegaRAID driver for SAS based RAID controllers
+ *  Copyright (c) 2009-2011  LSI Corporation.
  *
- * Copyright (c) 2003-2005  LSI Corporation.
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
  *
- *         This program is free software; you can redistribute it and/or
- *         modify it under the terms of the GNU General Public License
- *         as published by the Free Software Foundation; either version
- *         2 of the License, or (at your option) any later version.
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
  *
- * FILE         : megaraid_sas.c
- * Version     : v00.00.04.31-rc1
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
- * Authors:
- *      (email-id : megaraidlinux@lsi.com)
- *      Sreenivas Bagalkote
- *      Sumant Patro
- *      Bo Yang
+ *  FILE: megaraid_sas_base.c
+ *  Version : v00.00.05.29-rc1
  *
- * List of supported controllers
+ *  Authors: LSI Corporation
+ *           Sreenivas Bagalkote
+ *           Sumant Patro
+ *           Bo Yang
  *
- * OEM  Product Name                    VID     DID     SSVID   SSID
- * ---  ------------                    ---     ---     ----    ----
+ *  Send feedback to: <megaraidlinux@lsi.com>
+ *
+ *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
+ *     ATTN: Linuxraid
  */
 
 #include <linux/kernel.h>
@@ -46,6 +53,7 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
+#include "megaraid_sas_fusion.h"
 #include "megaraid_sas.h"
 
 /*
@@ -65,12 +73,16 @@ module_param_named(max_sectors, max_sectors, int, 0);
 MODULE_PARM_DESC(max_sectors,
         "Maximum number of sectors per IO command");
 
+static int msix_disable;
+module_param(msix_disable, int, S_IRUGO);
+MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
+
 MODULE_LICENSE("GPL");
 MODULE_VERSION(MEGASAS_VERSION);
 MODULE_AUTHOR("megaraidlinux@lsi.com");
 MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
 
-static int megasas_transition_to_ready(struct megasas_instance *instance);
+int megasas_transition_to_ready(struct megasas_instance *instance);
 static int megasas_get_pd_list(struct megasas_instance *instance);
 static int megasas_issue_init_mfi(struct megasas_instance *instance);
 static int megasas_register_aen(struct megasas_instance *instance,
@@ -98,6 +110,8 @@ static struct pci_device_id megasas_pci_table[] = {
         /* xscale IOP, vega */
         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
         /* xscale IOP */
+        {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
+        /* Fusion */
         {}
 };
 
@@ -111,23 +125,55 @@ static DEFINE_MUTEX(megasas_async_queue_mutex);
 static int megasas_poll_wait_aen;
 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
 static u32 support_poll_for_event;
-static u32 megasas_dbg_lvl;
+u32 megasas_dbg_lvl;
 static u32 support_device_change;
 
 /* define lock for aen poll */
 spinlock_t poll_aen_lock;
 
-static void
+void
 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
                      u8 alt_status);
 
+static irqreturn_t megasas_isr(int irq, void *devp);
+static u32
+megasas_init_adapter_mfi(struct megasas_instance *instance);
+u32
+megasas_build_and_issue_cmd(struct megasas_instance *instance,
+                            struct scsi_cmnd *scmd);
+static void megasas_complete_cmd_dpc(unsigned long instance_addr);
+void
+megasas_release_fusion(struct megasas_instance *instance);
+int
+megasas_ioc_init_fusion(struct megasas_instance *instance);
+void
+megasas_free_cmds_fusion(struct megasas_instance *instance);
+u8
+megasas_get_map_info(struct megasas_instance *instance);
+int
+megasas_sync_map_info(struct megasas_instance *instance);
+int
+wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);
+void megasas_reset_reply_desc(struct megasas_instance *instance);
+u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
+                      struct LD_LOAD_BALANCE_INFO *lbInfo);
+int megasas_reset_fusion(struct Scsi_Host *shost);
+void megasas_fusion_ocr_wq(struct work_struct *work);
+
+void
+megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
+{
+        instance->instancet->fire_cmd(instance,
+                cmd->frame_phys_addr, 0, instance->reg_set);
+}
+
 /**
  * megasas_get_cmd -    Get a command from the free pool
  * @instance:           Adapter soft state
  *
  * Returns a free command from the pool
  */
-static struct megasas_cmd *megasas_get_cmd(struct megasas_instance
+struct megasas_cmd *megasas_get_cmd(struct megasas_instance
                                                   *instance)
 {
         unsigned long flags;
@@ -152,7 +198,7 @@ static struct megasas_cmd *megasas_get_cmd(struct megasas_instance
  * @instance:           Adapter soft state
  * @cmd:                Command packet to be returned to free command pool
  */
-static inline void
+inline void
 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 {
         unsigned long flags;
@@ -160,6 +206,7 @@ megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
 
         cmd->scmd = NULL;
+        cmd->frame_count = 0;
         list_add_tail(&cmd->list, &instance->cmd_pool);
 
         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
@@ -167,7 +214,7 @@ megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 
 
 /**
-*       The following functions are defined for xscale 
+*       The following functions are defined for xscale
 *       (deviceid : 1064R, PERC5) controllers
 */
 
@@ -210,7 +257,7 @@ megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
  * megasas_clear_interrupt_xscale -     Check & clear interrupt
  * @regs:                               MFI register set
  */
-static int 
+static int
 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
 {
         u32 status;
@@ -243,7 +290,7 @@ megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
  * @frame_count :               Number of frames for the command
  * @regs :                      MFI register set
  */
-static inline void 
+static inline void
 megasas_fire_cmd_xscale(struct megasas_instance *instance,
                 dma_addr_t frame_phys_addr,
                 u32 frame_count,
@@ -323,15 +370,20 @@ static struct megasas_instance_template megasas_instance_template_xscale = {
         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
         .adp_reset = megasas_adp_reset_xscale,
         .check_reset = megasas_check_reset_xscale,
+        .service_isr = megasas_isr,
+        .tasklet = megasas_complete_cmd_dpc,
+        .init_adapter = megasas_init_adapter_mfi,
+        .build_and_issue_cmd = megasas_build_and_issue_cmd,
+        .issue_dcmd = megasas_issue_dcmd,
 };
 
 /**
-*       This is the end of set of functions & definitions specific 
+*       This is the end of set of functions & definitions specific
 *       to xscale (deviceid : 1064R, PERC5) controllers
 */
 
 /**
-*       The following functions are defined for ppc (deviceid : 0x60) 
+*       The following functions are defined for ppc (deviceid : 0x60)
 *       controllers
 */
 
@@ -343,7 +395,7 @@ static inline void
 megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs)
 {
         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
-    
+
         writel(~0x80000000, &(regs)->outbound_intr_mask);
 
         /* Dummy readl to force pci flush */
@@ -377,7 +429,7 @@ megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
  * megasas_clear_interrupt_ppc -        Check & clear interrupt
  * @regs:                               MFI register set
  */
-static int 
+static int
 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
 {
         u32 status;
@@ -406,7 +458,7 @@ megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
  * @frame_count :               Number of frames for the command
  * @regs :                      MFI register set
  */
-static inline void 
+static inline void
 megasas_fire_cmd_ppc(struct megasas_instance *instance,
                 dma_addr_t frame_phys_addr,
                 u32 frame_count,
@@ -414,7 +466,7 @@ megasas_fire_cmd_ppc(struct megasas_instance *instance,
 {
         unsigned long flags;
         spin_lock_irqsave(&instance->hba_lock, flags);
-        writel((frame_phys_addr | (frame_count<<1))|1, 
+        writel((frame_phys_addr | (frame_count<<1))|1,
                         &(regs)->inbound_queue_port);
         spin_unlock_irqrestore(&instance->hba_lock, flags);
 }
@@ -441,7 +493,7 @@ megasas_check_reset_ppc(struct megasas_instance *instance,
         return 0;
 }
 static struct megasas_instance_template megasas_instance_template_ppc = {
-        
+
         .fire_cmd = megasas_fire_cmd_ppc,
         .enable_intr = megasas_enable_intr_ppc,
         .disable_intr = megasas_disable_intr_ppc,
@@ -449,6 +501,11 @@ static struct megasas_instance_template megasas_instance_template_ppc = {
         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
         .adp_reset = megasas_adp_reset_ppc,
         .check_reset = megasas_check_reset_ppc,
+        .service_isr = megasas_isr,
+        .tasklet = megasas_complete_cmd_dpc,
+        .init_adapter = megasas_init_adapter_mfi,
+        .build_and_issue_cmd = megasas_build_and_issue_cmd,
+        .issue_dcmd = megasas_issue_dcmd,
 };
 
 /**
@@ -570,6 +627,11 @@ static struct megasas_instance_template megasas_instance_template_skinny = {
         .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
         .adp_reset = megasas_adp_reset_skinny,
         .check_reset = megasas_check_reset_skinny,
+        .service_isr = megasas_isr,
+        .tasklet = megasas_complete_cmd_dpc,
+        .init_adapter = megasas_init_adapter_mfi,
+        .build_and_issue_cmd = megasas_build_and_issue_cmd,
+        .issue_dcmd = megasas_issue_dcmd,
 };
 
 
@@ -744,6 +806,11 @@ static struct megasas_instance_template megasas_instance_template_gen2 = {
         .read_fw_status_reg = megasas_read_fw_status_reg_gen2,
         .adp_reset = megasas_adp_reset_gen2,
         .check_reset = megasas_check_reset_gen2,
+        .service_isr = megasas_isr,
+        .tasklet = megasas_complete_cmd_dpc,
+        .init_adapter = megasas_init_adapter_mfi,
+        .build_and_issue_cmd = megasas_build_and_issue_cmd,
+        .issue_dcmd = megasas_issue_dcmd,
 };
 
 /**
@@ -751,18 +818,21 @@ static struct megasas_instance_template megasas_instance_template_gen2 = {
 *       specific to gen2 (deviceid : 0x78, 0x79) controllers
 */
 
+/*
+ * Template added for TB (Fusion)
+ */
+extern struct megasas_instance_template megasas_instance_template_fusion;
+
 /**
  * megasas_issue_polled -       Issues a polling command
  * @instance:                   Adapter soft state
- * @cmd:                        Command packet to be issued 
+ * @cmd:                        Command packet to be issued
  *
  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
  */
-static int
+int
 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
 {
-        int i;
-        u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000;
 
         struct megasas_header *frame_hdr = &cmd->frame->hdr;
 
@@ -772,21 +842,12 @@ megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
         /*
          * Issue the frame using inbound queue port
          */
-        instance->instancet->fire_cmd(instance,
-                        cmd->frame_phys_addr, 0, instance->reg_set);
+        instance->instancet->issue_dcmd(instance, cmd);
 
         /*
          * Wait for cmd_status to change
          */
-        for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i++) {
-                rmb();
-                msleep(1);
-        }
-
-        if (frame_hdr->cmd_status == 0xff)
-                return -ETIME;
-
-        return 0;
+        return wait_and_poll(instance, cmd);
 }
 
 /**
@@ -804,8 +865,7 @@ megasas_issue_blocked_cmd(struct megasas_instance *instance,
 {
         cmd->cmd_status = ENODATA;
 
-        instance->instancet->fire_cmd(instance,
-                        cmd->frame_phys_addr, 0, instance->reg_set);
+        instance->instancet->issue_dcmd(instance, cmd);
 
         wait_event(instance->int_cmd_wait_q, cmd->cmd_status != ENODATA);
 
@@ -849,8 +909,7 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
         cmd->sync_cmd = 1;
         cmd->cmd_status = 0xFF;
 
-        instance->instancet->fire_cmd(instance,
-                        cmd->frame_phys_addr, 0, instance->reg_set);
+        instance->instancet->issue_dcmd(instance, cmd);
 
         /*
          * Wait for this cmd to complete
@@ -1242,11 +1301,11 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
 /**
  * megasas_is_ldio -            Checks if the cmd is for logical drive
  * @scmd:                       SCSI command
- *      
+ *
  * Called by megasas_queue_command to find out if the command to be queued
- * is a logical drive command   
+ * is a logical drive command
  */
-static inline int megasas_is_ldio(struct scsi_cmnd *cmd)
+inline int megasas_is_ldio(struct scsi_cmnd *cmd)
 {
         if (!MEGASAS_IS_LOGICAL(cmd))
                 return 0;
@@ -1328,6 +1387,51 @@ megasas_dump_pending_frames(struct megasas_instance *instance)
         printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
 }
 
+u32
+megasas_build_and_issue_cmd(struct megasas_instance *instance,
+                            struct scsi_cmnd *scmd)
+{
+        struct megasas_cmd *cmd;
+        u32 frame_count;
+
+        cmd = megasas_get_cmd(instance);
+        if (!cmd)
+                return SCSI_MLQUEUE_HOST_BUSY;
+
+        /*
+         * Logical drive command
+         */
+        if (megasas_is_ldio(scmd))
+                frame_count = megasas_build_ldio(instance, scmd, cmd);
+        else
+                frame_count = megasas_build_dcdb(instance, scmd, cmd);
+
+        if (!frame_count)
+                goto out_return_cmd;
+
+        cmd->scmd = scmd;
+        scmd->SCp.ptr = (char *)cmd;
+
+        /*
+         * Issue the command to the FW
+         */
+        atomic_inc(&instance->fw_outstanding);
+
+        instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
+                                cmd->frame_count-1, instance->reg_set);
+        /*
+         * Check if we have pend cmds to be completed
+         */
+        if (poll_mode_io && atomic_read(&instance->fw_outstanding))
+                tasklet_schedule(&instance->isr_tasklet);
+
+        return 0;
+out_return_cmd:
+        megasas_return_cmd(instance, cmd);
+        return 1;
+}
+
+
 /**
  * megasas_queue_command -      Queue entry point
  * @scmd:                       SCSI command to be queued
@@ -1336,8 +1440,6 @@ megasas_dump_pending_frames(struct megasas_instance *instance)
 static int
 megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
 {
-        u32 frame_count;
-        struct megasas_cmd *cmd;
         struct megasas_instance *instance;
         unsigned long flags;
 
@@ -1376,42 +1478,13 @@ megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd
                 break;
         }
 
-        cmd = megasas_get_cmd(instance);
-        if (!cmd)
+        if (instance->instancet->build_and_issue_cmd(instance, scmd)) {
+                printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n");
                 return SCSI_MLQUEUE_HOST_BUSY;
-
-        /*
-         * Logical drive command
-         */
-        if (megasas_is_ldio(scmd))
-                frame_count = megasas_build_ldio(instance, scmd, cmd);
-        else
-                frame_count = megasas_build_dcdb(instance, scmd, cmd);
-
-        if (!frame_count)
-                goto out_return_cmd;
-
-        cmd->scmd = scmd;
-        scmd->SCp.ptr = (char *)cmd;
-
-        /*
-         * Issue the command to the FW
-         */
-        atomic_inc(&instance->fw_outstanding);
-
-        instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
-                                cmd->frame_count-1, instance->reg_set);
-        /*
-         * Check if we have pend cmds to be completed
-         */
-        if (poll_mode_io && atomic_read(&instance->fw_outstanding))
-                tasklet_schedule(&instance->isr_tasklet);
-
+        }
 
         return 0;
 
- out_return_cmd:
-        megasas_return_cmd(instance, cmd);
  out_done:
         done(scmd);
         return 0;
@@ -1492,15 +1565,44 @@ static int megasas_slave_alloc(struct scsi_device *sdev)
         return 0;
 }
 
-static void megaraid_sas_kill_hba(struct megasas_instance *instance)
+void megaraid_sas_kill_hba(struct megasas_instance *instance)
 {
         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
-                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
-                writel(MFI_STOP_ADP,
-                        &instance->reg_set->reserved_0[0]);
+            (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
+            (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)) {
+                writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
         } else {
-                writel(MFI_STOP_ADP,
-                        &instance->reg_set->inbound_doorbell);
+                writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);
+        }
+}
+
+ /**
+  * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
+  *                                     restored to max value
+  * @instance:                  Adapter soft state
+  *
+  */
+void
+megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
+{
+        unsigned long flags;
+        if (instance->flag & MEGASAS_FW_BUSY
+                && time_after(jiffies, instance->last_time + 5 * HZ)
+                && atomic_read(&instance->fw_outstanding) < 17) {
+
+                spin_lock_irqsave(instance->host->host_lock, flags);
+                instance->flag &= ~MEGASAS_FW_BUSY;
+                if ((instance->pdev->device ==
+                        PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                        (instance->pdev->device ==
+                        PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                        instance->host->can_queue =
+                                instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
+                } else
+                        instance->host->can_queue =
+                                instance->max_fw_cmds - MEGASAS_INT_CMDS;
+
+                spin_unlock_irqrestore(instance->host->host_lock, flags);
         }
 }
 
@@ -1554,24 +1656,7 @@ static void megasas_complete_cmd_dpc(unsigned long instance_addr)
         /*
          * Check if we can restore can_queue
          */
-        if (instance->flag & MEGASAS_FW_BUSY
-                && time_after(jiffies, instance->last_time + 5 * HZ)
-                && atomic_read(&instance->fw_outstanding) < 17) {
-
-                spin_lock_irqsave(instance->host->host_lock, flags);
-                instance->flag &= ~MEGASAS_FW_BUSY;
-                if ((instance->pdev->device ==
-                        PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
-                        (instance->pdev->device ==
-                        PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
-                        instance->host->can_queue =
-                                instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
-                } else
-                        instance->host->can_queue =
-                                instance->max_fw_cmds - MEGASAS_INT_CMDS;
-
-                spin_unlock_irqrestore(instance->host->host_lock, flags);
-        }
+        megasas_check_and_restore_queue_depth(instance);
 }
 
 static void
@@ -1749,7 +1834,7 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
                         (instance->pdev->device ==
                         PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
                         writel(MFI_STOP_ADP,
-                                &instance->reg_set->reserved_0[0]);
+                                &instance->reg_set->doorbell);
                 } else {
                         writel(MFI_STOP_ADP,
                                 &instance->reg_set->inbound_doorbell);
@@ -1853,11 +1938,16 @@ static int megasas_reset_device(struct scsi_cmnd *scmd)
 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
 {
         int ret;
+        struct megasas_instance *instance;
+        instance = (struct megasas_instance *)scmd->device->host->hostdata;
 
         /*
          * First wait for all commands to complete
          */
-        ret = megasas_generic_reset(scmd);
+        if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)
+                ret = megasas_reset_fusion(scmd->device->host);
+        else
+                ret = megasas_generic_reset(scmd);
 
         return ret;
 }
@@ -2000,8 +2090,8 @@ megasas_complete_int_cmd(struct megasas_instance *instance,
  * @instance:                   Adapter soft state
  * @cmd:                        Cmd that was issued to abort another cmd
  *
- * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q 
- * after it issues an abort on a previously issued command. This function 
+ * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
+ * after it issues an abort on a previously issued command. This function
  * wakes up all functions waiting on the same wait queue.
  */
 static void
@@ -2021,19 +2111,20 @@ megasas_complete_abort(struct megasas_instance *instance,
  * megasas_complete_cmd -       Completes a command
  * @instance:                   Adapter soft state
  * @cmd:                        Command to be completed
- * @alt_status:                 If non-zero, use this value as status to 
+ * @alt_status:                 If non-zero, use this value as status to
  *                              SCSI mid-layer instead of the value returned
  *                              by the FW. This should be used if caller wants
  *                              an alternate status (as in the case of aborted
  *                              commands)
  */
-static void
+void
 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
                      u8 alt_status)
 {
         int exception = 0;
         struct megasas_header *hdr = &cmd->frame->hdr;
         unsigned long flags;
+        struct fusion_context *fusion = instance->ctrl_context;
 
         /* flag for the retry reset */
         cmd->retry_for_fw_reset = 0;
@@ -2126,6 +2217,37 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
         case MFI_CMD_SMP:
         case MFI_CMD_STP:
         case MFI_CMD_DCMD:
+                /* Check for LD map update */
+                if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) &&
+                    (cmd->frame->dcmd.mbox.b[1] == 1)) {
+                        spin_lock_irqsave(instance->host->host_lock, flags);
+                        if (cmd->frame->hdr.cmd_status != 0) {
+                                if (cmd->frame->hdr.cmd_status !=
+                                    MFI_STAT_NOT_FOUND)
+                                        printk(KERN_WARNING "megasas: map sync"
+                                               "failed, status = 0x%x.\n",
+                                               cmd->frame->hdr.cmd_status);
+                                else {
+                                        megasas_return_cmd(instance, cmd);
+                                        spin_unlock_irqrestore(
+                                                instance->host->host_lock,
+                                                flags);
+                                        break;
+                                }
+                        } else
+                                instance->map_id++;
+                        megasas_return_cmd(instance, cmd);
+                        if (MR_ValidateMapInfo(
+                                    fusion->ld_map[(instance->map_id & 1)],
+                                    fusion->load_balance_info))
+                                fusion->fast_path_io = 1;
+                        else
+                                fusion->fast_path_io = 0;
+                        megasas_sync_map_info(instance);
+                        spin_unlock_irqrestore(instance->host->host_lock,
+                                               flags);
+                        break;
+                }
                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
                         cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {
                         spin_lock_irqsave(&poll_aen_lock, flags);
@@ -2464,7 +2586,7 @@ static irqreturn_t megasas_isr(int irq, void *devp)
  * states, driver must take steps to bring it to ready state. Otherwise, it
  * has to wait for the ready state.
  */
-static int
+int
 megasas_transition_to_ready(struct megasas_instance* instance)
 {
         int i;
@@ -2476,8 +2598,8 @@ megasas_transition_to_ready(struct megasas_instance* instance)
         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
 
         if (fw_state != MFI_STATE_READY)
-                printk(KERN_INFO "megasas: Waiting for FW to come to ready"
-                       " state\n");
+                printk(KERN_INFO "megasas: Waiting for FW to come to ready"
+                       " state\n");
 
         while (fw_state != MFI_STATE_READY) {
 
@@ -2498,11 +2620,12 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                         if ((instance->pdev->device ==
                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
                                 (instance->pdev->device ==
-                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
-
+                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
+                                (instance->pdev->device ==
+                                 PCI_DEVICE_ID_LSI_FUSION)) {
                                 writel(
                                   MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
-                                  &instance->reg_set->reserved_0[0]);
+                                  &instance->reg_set->doorbell);
                         } else {
                                 writel(
                                     MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
@@ -2515,11 +2638,13 @@ megasas_transition_to_ready(struct megasas_instance* instance)
 
                 case MFI_STATE_BOOT_MESSAGE_PENDING:
                         if ((instance->pdev->device ==
-                                PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
-                        (instance->pdev->device ==
-                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                             PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                                (instance->pdev->device ==
+                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
+                            (instance->pdev->device ==
+                             PCI_DEVICE_ID_LSI_FUSION)) {
                                 writel(MFI_INIT_HOTPLUG,
-                                &instance->reg_set->reserved_0[0]);
+                                       &instance->reg_set->doorbell);
                         } else
                                 writel(MFI_INIT_HOTPLUG,
                                         &instance->reg_set->inbound_doorbell);
@@ -2536,9 +2661,23 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                         if ((instance->pdev->device ==
                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
                                 (instance->pdev->device ==
-                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
+                                (instance->pdev->device
+                                        == PCI_DEVICE_ID_LSI_FUSION)) {
                                 writel(MFI_RESET_FLAGS,
-                                        &instance->reg_set->reserved_0[0]);
+                                        &instance->reg_set->doorbell);
+                                if (instance->pdev->device ==
+                                    PCI_DEVICE_ID_LSI_FUSION) {
+                                        for (i = 0; i < (10 * 1000); i += 20) {
+                                                if (readl(
+                                                            &instance->
+                                                            reg_set->
+                                                            doorbell) & 1)
+                                                        msleep(20);
+                                                else
+                                                        break;
+                                        }
+                                }
                         } else
                                 writel(MFI_RESET_FLAGS,
                                         &instance->reg_set->inbound_doorbell);
@@ -2590,7 +2729,7 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                  * The cur_state should not last for more than max_wait secs
                  */
                 for (i = 0; i < (max_wait * 1000); i++) {
-                        fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &  
+                        fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &
                                         MFI_STATE_MASK ;
                 curr_abs_state =
                 instance->instancet->read_fw_status_reg(instance->reg_set);
@@ -2610,7 +2749,7 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                         return -ENODEV;
                 }
         }
-        printk(KERN_INFO "megasas: FW now in Ready state\n");
+        printk(KERN_INFO "megasas: FW now in Ready state\n");
 
         return 0;
 }
@@ -2622,7 +2761,7 @@ megasas_transition_to_ready(struct megasas_instance* instance)
 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
 {
         int i;
-        u32 max_cmd = instance->max_fw_cmds;
+        u32 max_cmd = instance->max_mfi_cmds;
         struct megasas_cmd *cmd;
 
         if (!instance->frame_dma_pool)
@@ -2673,7 +2812,7 @@ static int megasas_create_frame_pool(struct megasas_instance *instance)
         u32 frame_count;
         struct megasas_cmd *cmd;
 
-        max_cmd = instance->max_fw_cmds;
+        max_cmd = instance->max_mfi_cmds;
 
         /*
          * Size of our frame is 64 bytes for MFI frame, followed by max SG
@@ -2760,14 +2899,15 @@ static int megasas_create_frame_pool(struct megasas_instance *instance)
  * megasas_free_cmds -  Free all the cmds in the free cmd pool
  * @instance:           Adapter soft state
  */
-static void megasas_free_cmds(struct megasas_instance *instance)
+void megasas_free_cmds(struct megasas_instance *instance)
 {
         int i;
         /* First free the MFI frame pool */
         megasas_teardown_frame_pool(instance);
 
         /* Free all the commands in the cmd_list */
-        for (i = 0; i < instance->max_fw_cmds; i++)
+        for (i = 0; i < instance->max_mfi_cmds; i++)
+
                 kfree(instance->cmd_list[i]);
 
         /* Free the cmd_list buffer itself */
@@ -2795,14 +2935,14 @@ static void megasas_free_cmds(struct megasas_instance *instance)
  * This array is used only to look up the megasas_cmd given the context. The
  * free commands themselves are maintained in a linked list called cmd_pool.
  */
-static int megasas_alloc_cmds(struct megasas_instance *instance)
+int megasas_alloc_cmds(struct megasas_instance *instance)
 {
         int i;
         int j;
         u32 max_cmd;
         struct megasas_cmd *cmd;
 
-        max_cmd = instance->max_fw_cmds;
+        max_cmd = instance->max_mfi_cmds;
 
         /*
          * instance->cmd_list is an array of struct megasas_cmd pointers.
@@ -2816,6 +2956,7 @@ static int megasas_alloc_cmds(struct megasas_instance *instance)
                 return -ENOMEM;
         }
 
+        memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
 
         for (i = 0; i < max_cmd; i++) {
                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
@@ -3210,76 +3351,15 @@ megasas_io_completion_timer(unsigned long instance_addr)
                         jiffies + MEGASAS_COMPLETION_TIMER_INTERVAL);
 }
 
-/**
- * megasas_init_mfi -   Initializes the FW
- * @instance:           Adapter soft state
- *
- * This is the main function for initializing MFI firmware.
- */
-static int megasas_init_mfi(struct megasas_instance *instance)
+static u32
+megasas_init_adapter_mfi(struct megasas_instance *instance)
 {
+        struct megasas_register_set __iomem *reg_set;
         u32 context_sz;
         u32 reply_q_sz;
-        u32 max_sectors_1;
-        u32 max_sectors_2;
-        u32 tmp_sectors;
-        struct megasas_register_set __iomem *reg_set;
-        struct megasas_ctrl_info *ctrl_info;
-        /*
-         * Map the message registers
-         */
-        if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
-                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
-                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
-                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0079GEN2)) {
-                instance->base_addr = pci_resource_start(instance->pdev, 1);
-        } else {
-                instance->base_addr = pci_resource_start(instance->pdev, 0);
-        }
-
-        if (pci_request_selected_regions(instance->pdev,
-                pci_select_bars(instance->pdev, IORESOURCE_MEM),
-                "megasas: LSI")) {
-                printk(KERN_DEBUG "megasas: IO memory region busy!\n");
-                return -EBUSY;
-        }
-
-        instance->reg_set = ioremap_nocache(instance->base_addr, 8192);
-
-        if (!instance->reg_set) {
-                printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
-                goto fail_ioremap;
-        }
 
         reg_set = instance->reg_set;
 
-        switch(instance->pdev->device)
-        {
-                case PCI_DEVICE_ID_LSI_SAS1078R:
-                case PCI_DEVICE_ID_LSI_SAS1078DE:
-                        instance->instancet = &megasas_instance_template_ppc;
-                        break;
-                case PCI_DEVICE_ID_LSI_SAS1078GEN2:
-                case PCI_DEVICE_ID_LSI_SAS0079GEN2:
-                        instance->instancet = &megasas_instance_template_gen2;
-                        break;
-                case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
-                case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
-                        instance->instancet = &megasas_instance_template_skinny;
-                        break;
-                case PCI_DEVICE_ID_LSI_SAS1064R:
-                case PCI_DEVICE_ID_DELL_PERC5:
-                default:
-                        instance->instancet = &megasas_instance_template_xscale;
-                        break;
-        }
-
-        /*
-         * We expect the FW state to be READY
-         */
-        if (megasas_transition_to_ready(instance))
-                goto fail_ready_state;
-
         /*
          * Get various operational parameters from status register
          */
@@ -3290,7 +3370,8 @@ static int megasas_init_mfi(struct megasas_instance *instance)
          * does not exceed max cmds that the FW can support
          */
         instance->max_fw_cmds = instance->max_fw_cmds-1;
-        instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >> 
+        instance->max_mfi_cmds = instance->max_fw_cmds;
+        instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>
                                         0x10;
         /*
          * Create a pool of commands
@@ -3333,6 +3414,90 @@ static int megasas_init_mfi(struct megasas_instance *instance)
         if (instance->fw_support_ieee)
                 instance->flag_ieee = 1;
 
+        return 0;
+
+fail_fw_init:
+
+        pci_free_consistent(instance->pdev, reply_q_sz,
+                            instance->reply_queue, instance->reply_queue_h);
+fail_reply_queue:
+        megasas_free_cmds(instance);
+
+fail_alloc_cmds:
+        iounmap(instance->reg_set);
+        return 1;
+}
+
+/**
+ * megasas_init_fw -    Initializes the FW
+ * @instance:           Adapter soft state
+ *
+ * This is the main function for initializing firmware
+ */
+
+static int megasas_init_fw(struct megasas_instance *instance)
+{
+        u32 max_sectors_1;
+        u32 max_sectors_2;
+        u32 tmp_sectors;
+        struct megasas_register_set __iomem *reg_set;
+        struct megasas_ctrl_info *ctrl_info;
+        unsigned long bar_list;
+
+        /* Find first memory bar */
+        bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
+        instance->bar = find_first_bit(&bar_list, sizeof(unsigned long));
+        instance->base_addr = pci_resource_start(instance->pdev, instance->bar);
+        if (pci_request_selected_regions(instance->pdev, instance->bar,
+                                         "megasas: LSI")) {
+                printk(KERN_DEBUG "megasas: IO memory region busy!\n");
+                return -EBUSY;
+        }
+
+        instance->reg_set = ioremap_nocache(instance->base_addr, 8192);
+
+        if (!instance->reg_set) {
+                printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
+                goto fail_ioremap;
+        }
+
+        reg_set = instance->reg_set;
+
+        switch (instance->pdev->device) {
+        case PCI_DEVICE_ID_LSI_FUSION:
+                instance->instancet = &megasas_instance_template_fusion;
+                break;
+        case PCI_DEVICE_ID_LSI_SAS1078R:
+        case PCI_DEVICE_ID_LSI_SAS1078DE:
+                instance->instancet = &megasas_instance_template_ppc;
+                break;
+        case PCI_DEVICE_ID_LSI_SAS1078GEN2:
+        case PCI_DEVICE_ID_LSI_SAS0079GEN2:
+                instance->instancet = &megasas_instance_template_gen2;
+                break;
+        case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
+        case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
+                instance->instancet = &megasas_instance_template_skinny;
+                break;
+        case PCI_DEVICE_ID_LSI_SAS1064R:
+        case PCI_DEVICE_ID_DELL_PERC5:
+        default:
+                instance->instancet = &megasas_instance_template_xscale;
+                break;
+        }
+
+        /*
+         * We expect the FW state to be READY
+         */
+        if (megasas_transition_to_ready(instance))
+                goto fail_ready_state;
+
+        /* Get operational params, sge flags, send init cmd to controller */
+        if (instance->instancet->init_adapter(instance))
+                return -ENODEV;
+
+        printk(KERN_ERR "megasas: INIT adapter done\n");
+
         /** for passthrough
         * the following function will get the PD LIST.
         */
@@ -3388,20 +3553,11 @@ static int megasas_init_mfi(struct megasas_instance *instance)
                                 MEGASAS_COMPLETION_TIMER_INTERVAL);
         return 0;
 
-      fail_fw_init:
-
-        pci_free_consistent(instance->pdev, reply_q_sz,
-                            instance->reply_queue, instance->reply_queue_h);
-      fail_reply_queue:
-        megasas_free_cmds(instance);
-
-      fail_alloc_cmds:
-      fail_ready_state:
+fail_ready_state:
         iounmap(instance->reg_set);
 
       fail_ioremap:
-        pci_release_selected_regions(instance->pdev,
-                pci_select_bars(instance->pdev, IORESOURCE_MEM));
+        pci_release_selected_regions(instance->pdev, instance->bar);
 
         return -EINVAL;
 }
@@ -3412,17 +3568,17 @@ static int megasas_init_mfi(struct megasas_instance *instance)
  */
 static void megasas_release_mfi(struct megasas_instance *instance)
 {
-        u32 reply_q_sz = sizeof(u32) * (instance->max_fw_cmds + 1);
+        u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
 
-        pci_free_consistent(instance->pdev, reply_q_sz,
+        if (instance->reply_queue)
+                pci_free_consistent(instance->pdev, reply_q_sz,
                             instance->reply_queue, instance->reply_queue_h);
 
         megasas_free_cmds(instance);
 
         iounmap(instance->reg_set);
 
-        pci_release_selected_regions(instance->pdev,
-                pci_select_bars(instance->pdev, IORESOURCE_MEM));
+        pci_release_selected_regions(instance->pdev, instance->bar);
 }
 
 /**
@@ -3609,8 +3765,7 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
         /*
          * Issue the aen registration frame
          */
-        instance->instancet->fire_cmd(instance,
-                        cmd->frame_phys_addr, 0, instance->reg_set);
+        instance->instancet->issue_dcmd(instance, cmd);
 
         return 0;
 }
@@ -3687,12 +3842,18 @@ static int megasas_io_attach(struct megasas_instance *instance)
         }
 
         host->max_sectors = instance->max_sectors_per_req;
-        host->cmd_per_lun = 128;
+        host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
         host->max_channel = MEGASAS_MAX_CHANNELS - 1;
         host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
         host->max_lun = MEGASAS_MAX_LUN;
         host->max_cmd_len = 16;
 
+        /* Fusion only supports host reset */
+        if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) {
+                host->hostt->eh_device_reset_handler = NULL;
+                host->hostt->eh_bus_reset_handler = NULL;
+        }
+
         /*
          * Notify the mid-layer about the new controller
          */
@@ -3733,7 +3894,7 @@ fail_set_dma_mask:
 /**
  * megasas_probe_one -  PCI hotplug entry point
  * @pdev:               PCI device structure
- * @id:                 PCI ids of supported hotplugged adapter 
+ * @id:                 PCI ids of supported hotplugged adapter
  */
 static int __devinit
 megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
@@ -3777,20 +3938,45 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         instance = (struct megasas_instance *)host->hostdata;
         memset(instance, 0, sizeof(*instance));
         atomic_set( &instance->fw_reset_no_pci_access, 0 );
+        instance->pdev = pdev;
 
-        instance->producer = pci_alloc_consistent(pdev, sizeof(u32),
-                                                  &instance->producer_h);
-        instance->consumer = pci_alloc_consistent(pdev, sizeof(u32),
-                                                  &instance->consumer_h);
+        switch (instance->pdev->device) {
+        case PCI_DEVICE_ID_LSI_FUSION:
+        {
+                struct fusion_context *fusion;
+
+                instance->ctrl_context =
+                        kzalloc(sizeof(struct fusion_context), GFP_KERNEL);
+                if (!instance->ctrl_context) {
+                        printk(KERN_DEBUG "megasas: Failed to allocate "
+                               "memory for Fusion context info\n");
+                        goto fail_alloc_dma_buf;
+                }
+                fusion = instance->ctrl_context;
+                INIT_LIST_HEAD(&fusion->cmd_pool);
+                spin_lock_init(&fusion->cmd_pool_lock);
+        }
+        break;
+        default: /* For all other supported controllers */
+
+                instance->producer =
+                        pci_alloc_consistent(pdev, sizeof(u32),
+                                             &instance->producer_h);
+                instance->consumer =
+                        pci_alloc_consistent(pdev, sizeof(u32),
+                                             &instance->consumer_h);
+
+                if (!instance->producer || !instance->consumer) {
+                        printk(KERN_DEBUG "megasas: Failed to allocate"
+                               "memory for producer, consumer\n");
+                        goto fail_alloc_dma_buf;
+                }
 
-        if (!instance->producer || !instance->consumer) {
-                printk(KERN_DEBUG "megasas: Failed to allocate memory for "
-                       "producer, consumer\n");
-                goto fail_alloc_dma_buf;
+                *instance->producer = 0;
+                *instance->consumer = 0;
+                break;
         }
 
-        *instance->producer = 0;
-        *instance->consumer = 0;
         megasas_poll_wait_aen = 0;
         instance->flag_ieee = 0;
         instance->ev = NULL;
@@ -3826,11 +4012,11 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         spin_lock_init(&poll_aen_lock);
 
         mutex_init(&instance->aen_mutex);
+        mutex_init(&instance->reset_mutex);
 
         /*
          * Initialize PCI related and misc parameters
          */
-        instance->pdev = pdev;
         instance->host = host;
         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
@@ -3848,18 +4034,31 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         instance->last_time = 0;
         instance->disableOnlineCtrlReset = 1;
 
-        INIT_WORK(&instance->work_init, process_fw_state_change_wq);
+        if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)
+                INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
+        else
+                INIT_WORK(&instance->work_init, process_fw_state_change_wq);
 
         /*
          * Initialize MFI Firmware
          */
-        if (megasas_init_mfi(instance))
+        if (megasas_init_fw(instance))
                 goto fail_init_mfi;
 
+        /* Try to enable MSI-X */
+        if ((instance->pdev->device != PCI_DEVICE_ID_LSI_SAS1078R) &&
+            (instance->pdev->device != PCI_DEVICE_ID_LSI_SAS1078DE) &&
+            (instance->pdev->device != PCI_DEVICE_ID_LSI_VERDE_ZCR) &&
+            !msix_disable && !pci_enable_msix(instance->pdev,
+                                              &instance->msixentry, 1))
+                instance->msi_flag = 1;
+
         /*
          * Register IRQ
          */
-        if (request_irq(pdev->irq, megasas_isr, IRQF_SHARED, "megasas", instance)) {
+        if (request_irq(instance->msi_flag ? instance->msixentry.vector :
+                        pdev->irq, instance->instancet->service_isr,
+                        IRQF_SHARED, "megasas", instance)) {
                 printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
                 goto fail_irq;
         }
@@ -3904,9 +4103,10 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         pci_set_drvdata(pdev, NULL);
         instance->instancet->disable_intr(instance->reg_set);
-        free_irq(instance->pdev->irq, instance);
-
-        megasas_release_mfi(instance);
+        free_irq(instance->msi_flag ? instance->msixentry.vector :
+                 instance->pdev->irq, instance);
+        if (instance->msi_flag)
+                pci_disable_msix(instance->pdev);
 
       fail_irq:
       fail_init_mfi:
@@ -3916,9 +4116,13 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                                     instance->evt_detail,
                                     instance->evt_detail_h);
 
-        if (instance->producer)
+        if (instance->producer) {
                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
                                     instance->producer_h);
+                megasas_release_mfi(instance);
+        } else {
+                megasas_release_fusion(instance);
+        }
         if (instance->consumer)
                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
                                     instance->consumer_h);
@@ -3990,7 +4194,9 @@ static void megasas_shutdown_controller(struct megasas_instance *instance,
 
         if (instance->aen_cmd)
                 megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd);
-
+        if (instance->map_update_cmd)
+                megasas_issue_blocked_abort_cmd(instance,
+                                                instance->map_update_cmd);
         dcmd = &cmd->frame->dcmd;
 
         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
@@ -4046,7 +4252,10 @@ megasas_suspend(struct pci_dev *pdev, pm_message_t state)
 
         pci_set_drvdata(instance->pdev, instance);
         instance->instancet->disable_intr(instance->reg_set);
-        free_irq(instance->pdev->irq, instance);
+        free_irq(instance->msi_flag ? instance->msixentry.vector :
+                 instance->pdev->irq, instance);
+        if (instance->msi_flag)
+                pci_disable_msix(instance->pdev);
 
         pci_save_state(pdev);
         pci_disable_device(pdev);
@@ -4092,9 +4301,6 @@ megasas_resume(struct pci_dev *pdev)
          * Initialize MFI Firmware
          */
 
-        *instance->producer = 0;
-        *instance->consumer = 0;
-
         atomic_set(&instance->fw_outstanding, 0);
 
         /*
@@ -4103,17 +4309,40 @@ megasas_resume(struct pci_dev *pdev)
         if (megasas_transition_to_ready(instance))
                 goto fail_ready_state;
 
-        if (megasas_issue_init_mfi(instance))
-                goto fail_init_mfi;
+        switch (instance->pdev->device) {
+        case PCI_DEVICE_ID_LSI_FUSION:
+        {
+                megasas_reset_reply_desc(instance);
+                if (megasas_ioc_init_fusion(instance)) {
+                        megasas_free_cmds(instance);
+                        megasas_free_cmds_fusion(instance);
+                        goto fail_init_mfi;
+                }
+                if (!megasas_get_map_info(instance))
+                        megasas_sync_map_info(instance);
+        }
+        break;
+        default:
+                *instance->producer = 0;
+                *instance->consumer = 0;
+                if (megasas_issue_init_mfi(instance))
+                        goto fail_init_mfi;
+                break;
+        }
 
-        tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc,
-                        (unsigned long)instance);
+        tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
+                     (unsigned long)instance);
+
+        /* Now re-enable MSI-X */
+        if (instance->msi_flag)
+                pci_enable_msix(instance->pdev, &instance->msixentry, 1);
 
         /*
          * Register IRQ
          */
-        if (request_irq(pdev->irq, megasas_isr, IRQF_SHARED,
-                "megasas", instance)) {
+        if (request_irq(instance->msi_flag ? instance->msixentry.vector :
+                        pdev->irq, instance->instancet->service_isr,
+                        IRQF_SHARED, "megasas", instance)) {
                 printk(KERN_ERR "megasas: Failed to register IRQ\n");
                 goto fail_irq;
         }
@@ -4171,10 +4400,12 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev)
         int i;
         struct Scsi_Host *host;
         struct megasas_instance *instance;
+        struct fusion_context *fusion;
 
         instance = pci_get_drvdata(pdev);
         instance->unload = 1;
         host = instance->host;
+        fusion = instance->ctrl_context;
 
         if (poll_mode_io)
                 del_timer_sync(&instance->io_completion_timer);
@@ -4211,18 +4442,37 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev)
 
         instance->instancet->disable_intr(instance->reg_set);
 
-        free_irq(instance->pdev->irq, instance);
-
-        megasas_release_mfi(instance);
-
-        pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
-                            instance->evt_detail, instance->evt_detail_h);
-
-        pci_free_consistent(pdev, sizeof(u32), instance->producer,
-                            instance->producer_h);
-
-        pci_free_consistent(pdev, sizeof(u32), instance->consumer,
-                            instance->consumer_h);
+        free_irq(instance->msi_flag ? instance->msixentry.vector :
+                 instance->pdev->irq, instance);
+        if (instance->msi_flag)
+                pci_disable_msix(instance->pdev);
+
+        switch (instance->pdev->device) {
+        case PCI_DEVICE_ID_LSI_FUSION:
+                megasas_release_fusion(instance);
+                for (i = 0; i < 2 ; i++)
+                        if (fusion->ld_map[i])
+                                dma_free_coherent(&instance->pdev->dev,
+                                                  fusion->map_sz,
+                                                  fusion->ld_map[i],
+                                                  fusion->
+                                                  ld_map_phys[i]);
+                kfree(instance->ctrl_context);
+                break;
+        default:
+                megasas_release_mfi(instance);
+                pci_free_consistent(pdev,
+                                    sizeof(struct megasas_evt_detail),
+                                    instance->evt_detail,
+                                    instance->evt_detail_h);
+                pci_free_consistent(pdev, sizeof(u32),
+                                    instance->producer,
+                                    instance->producer_h);
+                pci_free_consistent(pdev, sizeof(u32),
+                                    instance->consumer,
+                                    instance->consumer_h);
+                break;
+        }
 
         scsi_host_put(host);
 
@@ -4986,6 +5236,7 @@ megasas_aen_polling(struct work_struct *work)
                         break;
                 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
                 case MR_EVT_FOREIGN_CFG_IMPORTED:
+                case MR_EVT_LD_STATE_CHANGE:
                         doscan = 1;
                         break;
                 default:
@@ -5165,7 +5416,7 @@ err_dcf_attr_ver:
         pci_unregister_driver(&megasas_pci_driver);
 err_pcidrv:
         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
-        return rval;
+        return rval;
 }
 
 /**
diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
new file mode 100644
index 000000000000..53fa96ae2b3e
--- /dev/null
+++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
@@ -0,0 +1,516 @@
+/*
+ *  Linux MegaRAID driver for SAS based RAID controllers
+ *
+ *  Copyright (c) 2009-2011  LSI Corporation.
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *  FILE: megaraid_sas_fp.c
+ *
+ *  Authors: LSI Corporation
+ *           Sumant Patro
+ *           Varad Talamacki
+ *           Manoj Jose
+ *
+ *  Send feedback to: <megaraidlinux@lsi.com>
+ *
+ *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
+ *     ATTN: Linuxraid
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/list.h>
+#include <linux/moduleparam.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/smp_lock.h>
+#include <linux/uio.h>
+#include <linux/uaccess.h>
+#include <linux/fs.h>
+#include <linux/compat.h>
+#include <linux/blkdev.h>
+#include <linux/poll.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+
+#include "megaraid_sas_fusion.h"
+#include <asm/div64.h>
+
+#define ABS_DIFF(a, b)   (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
+#define MR_LD_STATE_OPTIMAL 3
+#define FALSE 0
+#define TRUE 1
+
+/* Prototypes */
+void
+mr_update_load_balance_params(struct MR_FW_RAID_MAP_ALL *map,
+                              struct LD_LOAD_BALANCE_INFO *lbInfo);
+
+u32 mega_mod64(u64 dividend, u32 divisor)
+{
+        u64 d;
+        u32 remainder;
+
+        if (!divisor)
+                printk(KERN_ERR "megasas : DIVISOR is zero, in div fn\n");
+        d = dividend;
+        remainder = do_div(d, divisor);
+        return remainder;
+}
+
+/**
+ * @param dividend    : Dividend
+ * @param divisor    : Divisor
+ *
+ * @return quotient
+ **/
+u64 mega_div64_32(uint64_t dividend, uint32_t divisor)
+{
+        u32 remainder;
+        u64 d;
+
+        if (!divisor)
+                printk(KERN_ERR "megasas : DIVISOR is zero in mod fn\n");
+
+        d = dividend;
+        remainder = do_div(d, divisor);
+
+        return d;
+}
+
+struct MR_LD_RAID *MR_LdRaidGet(u32 ld, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return &map->raidMap.ldSpanMap[ld].ldRaid;
+}
+
+static struct MR_SPAN_BLOCK_INFO *MR_LdSpanInfoGet(u32 ld,
+                                                   struct MR_FW_RAID_MAP_ALL
+                                                   *map)
+{
+        return &map->raidMap.ldSpanMap[ld].spanBlock[0];
+}
+
+static u8 MR_LdDataArmGet(u32 ld, u32 armIdx, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return map->raidMap.ldSpanMap[ld].dataArmMap[armIdx];
+}
+
+static u16 MR_ArPdGet(u32 ar, u32 arm, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return map->raidMap.arMapInfo[ar].pd[arm];
+}
+
+static u16 MR_LdSpanArrayGet(u32 ld, u32 span, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return map->raidMap.ldSpanMap[ld].spanBlock[span].span.arrayRef;
+}
+
+static u16 MR_PdDevHandleGet(u32 pd, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return map->raidMap.devHndlInfo[pd].curDevHdl;
+}
+
+u16 MR_GetLDTgtId(u32 ld, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return map->raidMap.ldSpanMap[ld].ldRaid.targetId;
+}
+
+u16 MR_TargetIdToLdGet(u32 ldTgtId, struct MR_FW_RAID_MAP_ALL *map)
+{
+        return map->raidMap.ldTgtIdToLd[ldTgtId];
+}
+
+static struct MR_LD_SPAN *MR_LdSpanPtrGet(u32 ld, u32 span,
+                                          struct MR_FW_RAID_MAP_ALL *map)
+{
+        return &map->raidMap.ldSpanMap[ld].spanBlock[span].span;
+}
+
+/*
+ * This function will validate Map info data provided by FW
+ */
+u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
+                      struct LD_LOAD_BALANCE_INFO *lbInfo)
+{
+        struct MR_FW_RAID_MAP *pFwRaidMap = &map->raidMap;
+
+        if (pFwRaidMap->totalSize !=
+            (sizeof(struct MR_FW_RAID_MAP) -sizeof(struct MR_LD_SPAN_MAP) +
+             (sizeof(struct MR_LD_SPAN_MAP) *pFwRaidMap->ldCount))) {
+                printk(KERN_ERR "megasas: map info structure size 0x%x is not matching with ld count\n",
+                       (unsigned int)((sizeof(struct MR_FW_RAID_MAP) -
+                                       sizeof(struct MR_LD_SPAN_MAP)) +
+                                      (sizeof(struct MR_LD_SPAN_MAP) *
+                                       pFwRaidMap->ldCount)));
+                printk(KERN_ERR "megasas: span map %x, pFwRaidMap->totalSize "
+                       ": %x\n", (unsigned int)sizeof(struct MR_LD_SPAN_MAP),
+                       pFwRaidMap->totalSize);
+                return 0;
+        }
+
+        mr_update_load_balance_params(map, lbInfo);
+
+        return 1;
+}
+
+u32 MR_GetSpanBlock(u32 ld, u64 row, u64 *span_blk,
+                    struct MR_FW_RAID_MAP_ALL *map, int *div_error)
+{
+        struct MR_SPAN_BLOCK_INFO *pSpanBlock = MR_LdSpanInfoGet(ld, map);
+        struct MR_QUAD_ELEMENT    *quad;
+        struct MR_LD_RAID         *raid = MR_LdRaidGet(ld, map);
+        u32                span, j;
+
+        for (span = 0; span < raid->spanDepth; span++, pSpanBlock++) {
+
+                for (j = 0; j < pSpanBlock->block_span_info.noElements; j++) {
+                        quad = &pSpanBlock->block_span_info.quad[j];
+
+                        if (quad->diff == 0) {
+                                *div_error = 1;
+                                return span;
+                        }
+                        if (quad->logStart <= row  &&  row <= quad->logEnd  &&
+                            (mega_mod64(row-quad->logStart, quad->diff)) == 0) {
+                                if (span_blk != NULL) {
+                                        u64  blk, debugBlk;
+                                        blk =
+                                                mega_div64_32(
+                                                        (row-quad->logStart),
+                                                        quad->diff);
+                                        debugBlk = blk;
+
+                                        blk = (blk + quad->offsetInSpan) <<
+                                                raid->stripeShift;
+                                        *span_blk = blk;
+                                }
+                                return span;
+                        }
+                }
+        }
+        return span;
+}
+
+/*
+******************************************************************************
+*
+* This routine calculates the arm, span and block for the specified stripe and
+* reference in stripe.
+*
+* Inputs :
+*
+*    ld   - Logical drive number
+*    stripRow        - Stripe number
+*    stripRef    - Reference in stripe
+*
+* Outputs :
+*
+*    span          - Span number
+*    block         - Absolute Block number in the physical disk
+*/
+u8 MR_GetPhyParams(u32 ld, u64 stripRow, u16 stripRef, u64 *pdBlock,
+                   u16 *pDevHandle, struct RAID_CONTEXT *pRAID_Context,
+                   struct MR_FW_RAID_MAP_ALL *map)
+{
+        struct MR_LD_RAID  *raid = MR_LdRaidGet(ld, map);
+        u32         pd, arRef;
+        u8          physArm, span;
+        u64         row;
+        u8          retval = TRUE;
+        int         error_code = 0;
+
+        row =  mega_div64_32(stripRow, raid->rowDataSize);
+
+        if (raid->level == 6) {
+                /* logical arm within row */
+                u32 logArm =  mega_mod64(stripRow, raid->rowDataSize);
+                u32 rowMod, armQ, arm;
+
+                if (raid->rowSize == 0)
+                        return FALSE;
+                /* get logical row mod */
+                rowMod = mega_mod64(row, raid->rowSize);
+                armQ = raid->rowSize-1-rowMod; /* index of Q drive */
+                arm = armQ+1+logArm; /* data always logically follows Q */
+                if (arm >= raid->rowSize) /* handle wrap condition */
+                        arm -= raid->rowSize;
+                physArm = (u8)arm;
+        } else  {
+                if (raid->modFactor == 0)
+                        return FALSE;
+                physArm = MR_LdDataArmGet(ld,  mega_mod64(stripRow,
+                                                          raid->modFactor),
+                                          map);
+        }
+
+        if (raid->spanDepth == 1) {
+                span = 0;
+                *pdBlock = row << raid->stripeShift;
+        } else {
+                span = (u8)MR_GetSpanBlock(ld, row, pdBlock, map, &error_code);
+                if (error_code == 1)
+                        return FALSE;
+        }
+
+        /* Get the array on which this span is present */
+        arRef       = MR_LdSpanArrayGet(ld, span, map);
+        pd          = MR_ArPdGet(arRef, physArm, map); /* Get the pd */
+
+        if (pd != MR_PD_INVALID)
+                /* Get dev handle from Pd. */
+                *pDevHandle = MR_PdDevHandleGet(pd, map);
+        else {
+                *pDevHandle = MR_PD_INVALID; /* set dev handle as invalid. */
+                if (raid->level >= 5)
+                        pRAID_Context->regLockFlags = REGION_TYPE_EXCLUSIVE;
+                else if (raid->level == 1) {
+                        /* Get alternate Pd. */
+                        pd = MR_ArPdGet(arRef, physArm + 1, map);
+                        if (pd != MR_PD_INVALID)
+                                /* Get dev handle from Pd */
+                                *pDevHandle = MR_PdDevHandleGet(pd, map);
+                }
+                retval = FALSE;
+        }
+
+        *pdBlock += stripRef + MR_LdSpanPtrGet(ld, span, map)->startBlk;
+        pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) |
+                physArm;
+        return retval;
+}
+
+/*
+******************************************************************************
+*
+* MR_BuildRaidContext function
+*
+* This function will initiate command processing.  The start/end row and strip
+* information is calculated then the lock is acquired.
+* This function will return 0 if region lock was acquired OR return num strips
+*/
+u8
+MR_BuildRaidContext(struct IO_REQUEST_INFO *io_info,
+                    struct RAID_CONTEXT *pRAID_Context,
+                    struct MR_FW_RAID_MAP_ALL *map)
+{
+        struct MR_LD_RAID  *raid;
+        u32         ld, stripSize, stripe_mask;
+        u64         endLba, endStrip, endRow, start_row, start_strip;
+        u64         regStart;
+        u32         regSize;
+        u8          num_strips, numRows;
+        u16         ref_in_start_stripe, ref_in_end_stripe;
+        u64         ldStartBlock;
+        u32         numBlocks, ldTgtId;
+        u8          isRead;
+        u8          retval = 0;
+
+        ldStartBlock = io_info->ldStartBlock;
+        numBlocks = io_info->numBlocks;
+        ldTgtId = io_info->ldTgtId;
+        isRead = io_info->isRead;
+
+        ld = MR_TargetIdToLdGet(ldTgtId, map);
+        raid = MR_LdRaidGet(ld, map);
+
+        stripSize = 1 << raid->stripeShift;
+        stripe_mask = stripSize-1;
+        /*
+         * calculate starting row and stripe, and number of strips and rows
+         */
+        start_strip         = ldStartBlock >> raid->stripeShift;
+        ref_in_start_stripe = (u16)(ldStartBlock & stripe_mask);
+        endLba              = ldStartBlock + numBlocks - 1;
+        ref_in_end_stripe   = (u16)(endLba & stripe_mask);
+        endStrip            = endLba >> raid->stripeShift;
+        num_strips          = (u8)(endStrip - start_strip + 1); /* End strip */
+        if (raid->rowDataSize == 0)
+                return FALSE;
+        start_row           =  mega_div64_32(start_strip, raid->rowDataSize);
+        endRow              =  mega_div64_32(endStrip, raid->rowDataSize);
+        numRows             = (u8)(endRow - start_row + 1);
+
+        /*
+         * calculate region info.
+         */
+
+        /* assume region is at the start of the first row */
+        regStart            = start_row << raid->stripeShift;
+        /* assume this IO needs the full row - we'll adjust if not true */
+        regSize             = stripSize;
+
+        /* If IO spans more than 1 strip, fp is not possible
+           FP is not possible for writes on non-0 raid levels
+           FP is not possible if LD is not capable */
+        if (num_strips > 1 || (!isRead && raid->level != 0) ||
+            !raid->capability.fpCapable) {
+                io_info->fpOkForIo = FALSE;
+        } else {
+                io_info->fpOkForIo = TRUE;
+        }
+
+        if (numRows == 1) {
+                /* single-strip IOs can always lock only the data needed */
+                if (num_strips == 1) {
+                        regStart += ref_in_start_stripe;
+                        regSize = numBlocks;
+                }
+                /* multi-strip IOs always need to full stripe locked */
+        } else {
+                if (start_strip == (start_row + 1) * raid->rowDataSize - 1) {
+                        /* If the start strip is the last in the start row */
+                        regStart += ref_in_start_stripe;
+                        regSize = stripSize - ref_in_start_stripe;
+                        /* initialize count to sectors from startref to end
+                           of strip */
+                }
+
+                if (numRows > 2)
+                        /* Add complete rows in the middle of the transfer */
+                        regSize += (numRows-2) << raid->stripeShift;
+
+                /* if IO ends within first strip of last row */
+                if (endStrip == endRow*raid->rowDataSize)
+                        regSize += ref_in_end_stripe+1;
+                else
+                        regSize += stripSize;
+        }
+
+        pRAID_Context->timeoutValue     = map->raidMap.fpPdIoTimeoutSec;
+        pRAID_Context->regLockFlags     = (isRead) ? REGION_TYPE_SHARED_READ :
+                raid->regTypeReqOnWrite;
+        pRAID_Context->VirtualDiskTgtId = raid->targetId;
+        pRAID_Context->regLockRowLBA    = regStart;
+        pRAID_Context->regLockLength    = regSize;
+        pRAID_Context->configSeqNum     = raid->seqNum;
+
+        /*Get Phy Params only if FP capable, or else leave it to MR firmware
+          to do the calculation.*/
+        if (io_info->fpOkForIo) {
+                retval = MR_GetPhyParams(ld, start_strip, ref_in_start_stripe,
+                                         &io_info->pdBlock,
+                                         &io_info->devHandle, pRAID_Context,
+                                         map);
+                /* If IO on an invalid Pd, then FP i snot possible */
+                if (io_info->devHandle == MR_PD_INVALID)
+                        io_info->fpOkForIo = FALSE;
+                return retval;
+        } else if (isRead) {
+                uint stripIdx;
+                for (stripIdx = 0; stripIdx < num_strips; stripIdx++) {
+                        if (!MR_GetPhyParams(ld, start_strip + stripIdx,
+                                             ref_in_start_stripe,
+                                             &io_info->pdBlock,
+                                             &io_info->devHandle,
+                                             pRAID_Context, map))
+                                return TRUE;
+                }
+        }
+        return TRUE;
+}
+
+void
+mr_update_load_balance_params(struct MR_FW_RAID_MAP_ALL *map,
+                              struct LD_LOAD_BALANCE_INFO *lbInfo)
+{
+        int ldCount;
+        u16 ld;
+        struct MR_LD_RAID *raid;
+
+        for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES; ldCount++) {
+                ld = MR_TargetIdToLdGet(ldCount, map);
+                if (ld >= MAX_LOGICAL_DRIVES) {
+                        lbInfo[ldCount].loadBalanceFlag = 0;
+                        continue;
+                }
+
+                raid = MR_LdRaidGet(ld, map);
+
+                /* Two drive Optimal RAID 1 */
+                if ((raid->level == 1)  &&  (raid->rowSize == 2) &&
+                    (raid->spanDepth == 1) && raid->ldState ==
+                    MR_LD_STATE_OPTIMAL) {
+                        u32 pd, arRef;
+
+                        lbInfo[ldCount].loadBalanceFlag = 1;
+
+                        /* Get the array on which this span is present */
+                        arRef = MR_LdSpanArrayGet(ld, 0, map);
+
+                        /* Get the Pd */
+                        pd = MR_ArPdGet(arRef, 0, map);
+                        /* Get dev handle from Pd */
+                        lbInfo[ldCount].raid1DevHandle[0] =
+                                MR_PdDevHandleGet(pd, map);
+                        /* Get the Pd */
+                        pd = MR_ArPdGet(arRef, 1, map);
+
+                        /* Get the dev handle from Pd */
+                        lbInfo[ldCount].raid1DevHandle[1] =
+                                MR_PdDevHandleGet(pd, map);
+                } else
+                        lbInfo[ldCount].loadBalanceFlag = 0;
+        }
+}
+
+u8 megasas_get_best_arm(struct LD_LOAD_BALANCE_INFO *lbInfo, u8 arm, u64 block,
+                        u32 count)
+{
+        u16     pend0, pend1;
+        u64     diff0, diff1;
+        u8      bestArm;
+
+        /* get the pending cmds for the data and mirror arms */
+        pend0 = atomic_read(&lbInfo->scsi_pending_cmds[0]);
+        pend1 = atomic_read(&lbInfo->scsi_pending_cmds[1]);
+
+        /* Determine the disk whose head is nearer to the req. block */
+        diff0 = ABS_DIFF(block, lbInfo->last_accessed_block[0]);
+        diff1 = ABS_DIFF(block, lbInfo->last_accessed_block[1]);
+        bestArm = (diff0 <= diff1 ? 0 : 1);
+
+        if ((bestArm == arm && pend0 > pend1 + 16)  ||
+            (bestArm != arm && pend1 > pend0 + 16))
+                bestArm ^= 1;
+
+        /* Update the last accessed block on the correct pd */
+        lbInfo->last_accessed_block[bestArm] = block + count - 1;
+
+        return bestArm;
+}
+
+u16 get_updated_dev_handle(struct LD_LOAD_BALANCE_INFO *lbInfo,
+                           struct IO_REQUEST_INFO *io_info)
+{
+        u8 arm, old_arm;
+        u16 devHandle;
+
+        old_arm = lbInfo->raid1DevHandle[0] == io_info->devHandle ? 0 : 1;
+
+        /* get best new arm */
+        arm  = megasas_get_best_arm(lbInfo, old_arm, io_info->ldStartBlock,
+                                    io_info->numBlocks);
+        devHandle = lbInfo->raid1DevHandle[arm];
+        atomic_inc(&lbInfo->scsi_pending_cmds[arm]);
+
+        return devHandle;
+}
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
new file mode 100644
index 000000000000..c1e09d5a6196
--- /dev/null
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -0,0 +1,2248 @@
+/*
+ *  Linux MegaRAID driver for SAS based RAID controllers
+ *
+ *  Copyright (c) 2009-2011  LSI Corporation.
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *  FILE: megaraid_sas_fusion.c
+ *
+ *  Authors: LSI Corporation
+ *           Sumant Patro
+ *           Adam Radford <linuxraid@lsi.com>
+ *
+ *  Send feedback to: <megaraidlinux@lsi.com>
+ *
+ *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
+ *     ATTN: Linuxraid
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/list.h>
+#include <linux/moduleparam.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/smp_lock.h>
+#include <linux/uio.h>
+#include <linux/uaccess.h>
+#include <linux/fs.h>
+#include <linux/compat.h>
+#include <linux/blkdev.h>
+#include <linux/mutex.h>
+#include <linux/poll.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+
+#include "megaraid_sas_fusion.h"
+#include "megaraid_sas.h"
+
+extern void megasas_free_cmds(struct megasas_instance *instance);
+extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
+                                           *instance);
+extern void
+megasas_complete_cmd(struct megasas_instance *instance,
+                     struct megasas_cmd *cmd, u8 alt_status);
+int megasas_is_ldio(struct scsi_cmnd *cmd);
+int
+wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);
+
+void
+megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd);
+int megasas_alloc_cmds(struct megasas_instance *instance);
+int
+megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs);
+int
+megasas_issue_polled(struct megasas_instance *instance,
+                     struct megasas_cmd *cmd);
+
+u8
+MR_BuildRaidContext(struct IO_REQUEST_INFO *io_info,
+                    struct RAID_CONTEXT *pRAID_Context,
+                    struct MR_FW_RAID_MAP_ALL *map);
+u16 MR_TargetIdToLdGet(u32 ldTgtId, struct MR_FW_RAID_MAP_ALL *map);
+struct MR_LD_RAID *MR_LdRaidGet(u32 ld, struct MR_FW_RAID_MAP_ALL *map);
+
+u16 MR_GetLDTgtId(u32 ld, struct MR_FW_RAID_MAP_ALL *map);
+u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
+                      struct LD_LOAD_BALANCE_INFO *lbInfo);
+u16 get_updated_dev_handle(struct LD_LOAD_BALANCE_INFO *lbInfo,
+                           struct IO_REQUEST_INFO *in_info);
+int megasas_transition_to_ready(struct megasas_instance *instance);
+void megaraid_sas_kill_hba(struct megasas_instance *instance);
+
+extern u32 megasas_dbg_lvl;
+
+/**
+ * megasas_enable_intr_fusion - Enables interrupts
+ * @regs:                       MFI register set
+ */
+void
+megasas_enable_intr_fusion(struct megasas_register_set __iomem *regs)
+{
+        writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
+
+        /* Dummy readl to force pci flush */
+        readl(&regs->outbound_intr_mask);
+}
+
+/**
+ * megasas_disable_intr_fusion - Disables interrupt
+ * @regs:                        MFI register set
+ */
+void
+megasas_disable_intr_fusion(struct megasas_register_set __iomem *regs)
+{
+        u32 mask = 0xFFFFFFFF;
+        u32 status;
+
+        writel(mask, &regs->outbound_intr_mask);
+        /* Dummy readl to force pci flush */
+        status = readl(&regs->outbound_intr_mask);
+}
+
+int
+megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs)
+{
+        u32 status;
+        /*
+         * Check if it is our interrupt
+         */
+        status = readl(&regs->outbound_intr_status);
+
+        if (status & 1) {
+                writel(status, &regs->outbound_intr_status);
+                readl(&regs->outbound_intr_status);
+                return 1;
+        }
+        if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
+                return 0;
+
+        /*
+         * dummy read to flush PCI
+         */
+        readl(&regs->outbound_intr_status);
+
+        return 1;
+}
+
+/**
+ * megasas_get_cmd_fusion -     Get a command from the free pool
+ * @instance:           Adapter soft state
+ *
+ * Returns a free command from the pool
+ */
+struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance
+                                                  *instance)
+{
+        unsigned long flags;
+        struct fusion_context *fusion =
+                (struct fusion_context *)instance->ctrl_context;
+        struct megasas_cmd_fusion *cmd = NULL;
+
+        spin_lock_irqsave(&fusion->cmd_pool_lock, flags);
+
+        if (!list_empty(&fusion->cmd_pool)) {
+                cmd = list_entry((&fusion->cmd_pool)->next,
+                                 struct megasas_cmd_fusion, list);
+                list_del_init(&cmd->list);
+        } else {
+                printk(KERN_ERR "megasas: Command pool (fusion) empty!\n");
+        }
+
+        spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags);
+        return cmd;
+}
+
+/**
+ * megasas_return_cmd_fusion -  Return a cmd to free command pool
+ * @instance:           Adapter soft state
+ * @cmd:                Command packet to be returned to free command pool
+ */
+static inline void
+megasas_return_cmd_fusion(struct megasas_instance *instance,
+                          struct megasas_cmd_fusion *cmd)
+{
+        unsigned long flags;
+        struct fusion_context *fusion =
+                (struct fusion_context *)instance->ctrl_context;
+
+        spin_lock_irqsave(&fusion->cmd_pool_lock, flags);
+
+        cmd->scmd = NULL;
+        cmd->sync_cmd_idx = (u32)ULONG_MAX;
+        list_add_tail(&cmd->list, &fusion->cmd_pool);
+
+        spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags);
+}
+
+/**
+ * megasas_teardown_frame_pool_fusion - Destroy the cmd frame DMA pool
+ * @instance:                           Adapter soft state
+ */
+static void megasas_teardown_frame_pool_fusion(
+        struct megasas_instance *instance)
+{
+        int i;
+        struct fusion_context *fusion = instance->ctrl_context;
+
+        u16 max_cmd = instance->max_fw_cmds;
+
+        struct megasas_cmd_fusion *cmd;
+
+        if (!fusion->sg_dma_pool || !fusion->sense_dma_pool) {
+                printk(KERN_ERR "megasas: dma pool is null. SG Pool %p, "
+                       "sense pool : %p\n", fusion->sg_dma_pool,
+                       fusion->sense_dma_pool);
+                return;
+        }
+
+        /*
+         * Return all frames to pool
+         */
+        for (i = 0; i < max_cmd; i++) {
+
+                cmd = fusion->cmd_list[i];
+
+                if (cmd->sg_frame)
+                        pci_pool_free(fusion->sg_dma_pool, cmd->sg_frame,
+                                      cmd->sg_frame_phys_addr);
+
+                if (cmd->sense)
+                        pci_pool_free(fusion->sense_dma_pool, cmd->sense,
+                                      cmd->sense_phys_addr);
+        }
+
+        /*
+         * Now destroy the pool itself
+         */
+        pci_pool_destroy(fusion->sg_dma_pool);
+        pci_pool_destroy(fusion->sense_dma_pool);
+
+        fusion->sg_dma_pool = NULL;
+        fusion->sense_dma_pool = NULL;
+}
+
+/**
+ * megasas_free_cmds_fusion -   Free all the cmds in the free cmd pool
+ * @instance:           Adapter soft state
+ */
+void
+megasas_free_cmds_fusion(struct megasas_instance *instance)
+{
+        int i;
+        struct fusion_context *fusion = instance->ctrl_context;
+
+        u32 max_cmds, req_sz, reply_sz, io_frames_sz;
+
+
+        req_sz = fusion->request_alloc_sz;
+        reply_sz = fusion->reply_alloc_sz;
+        io_frames_sz = fusion->io_frames_alloc_sz;
+
+        max_cmds = instance->max_fw_cmds;
+
+        /* Free descriptors and request Frames memory */
+        if (fusion->req_frames_desc)
+                dma_free_coherent(&instance->pdev->dev, req_sz,
+                                  fusion->req_frames_desc,
+                                  fusion->req_frames_desc_phys);
+
+        if (fusion->reply_frames_desc) {
+                pci_pool_free(fusion->reply_frames_desc_pool,
+                              fusion->reply_frames_desc,
+                              fusion->reply_frames_desc_phys);
+                pci_pool_destroy(fusion->reply_frames_desc_pool);
+        }
+
+        if (fusion->io_request_frames) {
+                pci_pool_free(fusion->io_request_frames_pool,
+                              fusion->io_request_frames,
+                              fusion->io_request_frames_phys);
+                pci_pool_destroy(fusion->io_request_frames_pool);
+        }
+
+        /* Free the Fusion frame pool */
+        megasas_teardown_frame_pool_fusion(instance);
+
+        /* Free all the commands in the cmd_list */
+        for (i = 0; i < max_cmds; i++)
+                kfree(fusion->cmd_list[i]);
+
+        /* Free the cmd_list buffer itself */
+        kfree(fusion->cmd_list);
+        fusion->cmd_list = NULL;
+
+        INIT_LIST_HEAD(&fusion->cmd_pool);
+}
+
+/**
+ * megasas_create_frame_pool_fusion -   Creates DMA pool for cmd frames
+ * @instance:                   Adapter soft state
+ *
+ */
+static int megasas_create_frame_pool_fusion(struct megasas_instance *instance)
+{
+        int i;
+        u32 max_cmd;
+        struct fusion_context *fusion;
+        struct megasas_cmd_fusion *cmd;
+        u32 total_sz_chain_frame;
+
+        fusion = instance->ctrl_context;
+        max_cmd = instance->max_fw_cmds;
+
+        total_sz_chain_frame = MEGASAS_MAX_SZ_CHAIN_FRAME;
+
+        /*
+         * Use DMA pool facility provided by PCI layer
+         */
+
+        fusion->sg_dma_pool = pci_pool_create("megasas sg pool fusion",
+                                              instance->pdev,
+                                              total_sz_chain_frame, 4,
+                                              0);
+        if (!fusion->sg_dma_pool) {
+                printk(KERN_DEBUG "megasas: failed to setup request pool "
+                       "fusion\n");
+                return -ENOMEM;
+        }
+        fusion->sense_dma_pool = pci_pool_create("megasas sense pool fusion",
+                                                 instance->pdev,
+                                                 SCSI_SENSE_BUFFERSIZE, 64, 0);
+
+        if (!fusion->sense_dma_pool) {
+                printk(KERN_DEBUG "megasas: failed to setup sense pool "
+                       "fusion\n");
+                pci_pool_destroy(fusion->sg_dma_pool);
+                fusion->sg_dma_pool = NULL;
+                return -ENOMEM;
+        }
+
+        /*
+         * Allocate and attach a frame to each of the commands in cmd_list
+         */
+        for (i = 0; i < max_cmd; i++) {
+
+                cmd = fusion->cmd_list[i];
+
+                cmd->sg_frame = pci_pool_alloc(fusion->sg_dma_pool,
+                                               GFP_KERNEL,
+                                               &cmd->sg_frame_phys_addr);
+
+                cmd->sense = pci_pool_alloc(fusion->sense_dma_pool,
+                                            GFP_KERNEL, &cmd->sense_phys_addr);
+                /*
+                 * megasas_teardown_frame_pool_fusion() takes care of freeing
+                 * whatever has been allocated
+                 */
+                if (!cmd->sg_frame || !cmd->sense) {
+                        printk(KERN_DEBUG "megasas: pci_pool_alloc failed\n");
+                        megasas_teardown_frame_pool_fusion(instance);
+                        return -ENOMEM;
+                }
+        }
+        return 0;
+}
+
+/**
+ * megasas_alloc_cmds_fusion -  Allocates the command packets
+ * @instance:           Adapter soft state
+ *
+ *
+ * Each frame has a 32-bit field called context. This context is used to get
+ * back the megasas_cmd_fusion from the frame when a frame gets completed
+ * In this driver, the 32 bit values are the indices into an array cmd_list.
+ * This array is used only to look up the megasas_cmd_fusion given the context.
+ * The free commands themselves are maintained in a linked list called cmd_pool.
+ *
+ * cmds are formed in the io_request and sg_frame members of the
+ * megasas_cmd_fusion. The context field is used to get a request descriptor
+ * and is used as SMID of the cmd.
+ * SMID value range is from 1 to max_fw_cmds.
+ */
+int
+megasas_alloc_cmds_fusion(struct megasas_instance *instance)
+{
+        int i, j;
+        u32 max_cmd, io_frames_sz;
+        struct fusion_context *fusion;
+        struct megasas_cmd_fusion *cmd;
+        union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
+        u32 offset;
+        dma_addr_t io_req_base_phys;
+        u8 *io_req_base;
+
+        fusion = instance->ctrl_context;
+
+        max_cmd = instance->max_fw_cmds;
+
+        fusion->req_frames_desc =
+                dma_alloc_coherent(&instance->pdev->dev,
+                                   fusion->request_alloc_sz,
+                                   &fusion->req_frames_desc_phys, GFP_KERNEL);
+
+        if (!fusion->req_frames_desc) {
+                printk(KERN_ERR "megasas; Could not allocate memory for "
+                       "request_frames\n");
+                goto fail_req_desc;
+        }
+
+        fusion->reply_frames_desc_pool =
+                pci_pool_create("reply_frames pool", instance->pdev,
+                                fusion->reply_alloc_sz, 16, 0);
+
+        if (!fusion->reply_frames_desc_pool) {
+                printk(KERN_ERR "megasas; Could not allocate memory for "
+                       "reply_frame pool\n");
+                goto fail_reply_desc;
+        }
+
+        fusion->reply_frames_desc =
+                pci_pool_alloc(fusion->reply_frames_desc_pool, GFP_KERNEL,
+                               &fusion->reply_frames_desc_phys);
+        if (!fusion->reply_frames_desc) {
+                printk(KERN_ERR "megasas; Could not allocate memory for "
+                       "reply_frame pool\n");
+                pci_pool_destroy(fusion->reply_frames_desc_pool);
+                goto fail_reply_desc;
+        }
+
+        reply_desc = fusion->reply_frames_desc;
+        for (i = 0; i < fusion->reply_q_depth; i++, reply_desc++)
+                reply_desc->Words = ULLONG_MAX;
+
+        io_frames_sz = fusion->io_frames_alloc_sz;
+
+        fusion->io_request_frames_pool =
+                pci_pool_create("io_request_frames pool", instance->pdev,
+                                fusion->io_frames_alloc_sz, 16, 0);
+
+        if (!fusion->io_request_frames_pool) {
+                printk(KERN_ERR "megasas: Could not allocate memory for "
+                       "io_request_frame pool\n");
+                goto fail_io_frames;
+        }
+
+        fusion->io_request_frames =
+                pci_pool_alloc(fusion->io_request_frames_pool, GFP_KERNEL,
+                               &fusion->io_request_frames_phys);
+        if (!fusion->io_request_frames) {
+                printk(KERN_ERR "megasas: Could not allocate memory for "
+                       "io_request_frames frames\n");
+                pci_pool_destroy(fusion->io_request_frames_pool);
+                goto fail_io_frames;
+        }
+
+        /*
+         * fusion->cmd_list is an array of struct megasas_cmd_fusion pointers.
+         * Allocate the dynamic array first and then allocate individual
+         * commands.
+         */
+        fusion->cmd_list = kmalloc(sizeof(struct megasas_cmd_fusion *)
+                                   *max_cmd, GFP_KERNEL);
+
+        if (!fusion->cmd_list) {
+                printk(KERN_DEBUG "megasas: out of memory. Could not alloc "
+                       "memory for cmd_list_fusion\n");
+                goto fail_cmd_list;
+        }
+
+        memset(fusion->cmd_list, 0, sizeof(struct megasas_cmd_fusion *)
+               *max_cmd);
+
+        max_cmd = instance->max_fw_cmds;
+        for (i = 0; i < max_cmd; i++) {
+                fusion->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd_fusion),
+                                              GFP_KERNEL);
+                if (!fusion->cmd_list[i]) {
+                        printk(KERN_ERR "Could not alloc cmd list fusion\n");
+
+                        for (j = 0; j < i; j++)
+                                kfree(fusion->cmd_list[j]);
+
+                        kfree(fusion->cmd_list);
+                        fusion->cmd_list = NULL;
+                        goto fail_cmd_list;
+                }
+        }
+
+        /* The first 256 bytes (SMID 0) is not used. Don't add to cmd list */
+        io_req_base = fusion->io_request_frames +
+                MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
+        io_req_base_phys = fusion->io_request_frames_phys +
+                MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
+
+        /*
+         * Add all the commands to command pool (fusion->cmd_pool)
+         */
+
+        /* SMID 0 is reserved. Set SMID/index from 1 */
+        for (i = 0; i < max_cmd; i++) {
+                cmd = fusion->cmd_list[i];
+                offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i;
+                memset(cmd, 0, sizeof(struct megasas_cmd_fusion));
+                cmd->index = i + 1;
+                cmd->scmd = NULL;
+                cmd->sync_cmd_idx = (u32)ULONG_MAX; /* Set to Invalid */
+                cmd->instance = instance;
+                cmd->io_request =
+                        (struct MPI2_RAID_SCSI_IO_REQUEST *)
+                  (io_req_base + offset);
+                memset(cmd->io_request, 0,
+                       sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
+                cmd->io_request_phys_addr = io_req_base_phys + offset;
+
+                list_add_tail(&cmd->list, &fusion->cmd_pool);
+        }
+
+        /*
+         * Create a frame pool and assign one frame to each cmd
+         */
+        if (megasas_create_frame_pool_fusion(instance)) {
+                printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
+                megasas_free_cmds_fusion(instance);
+                goto fail_req_desc;
+        }
+
+        return 0;
+
+fail_cmd_list:
+        pci_pool_free(fusion->io_request_frames_pool, fusion->io_request_frames,
+                      fusion->io_request_frames_phys);
+        pci_pool_destroy(fusion->io_request_frames_pool);
+fail_io_frames:
+        dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz,
+                          fusion->reply_frames_desc,
+                          fusion->reply_frames_desc_phys);
+        pci_pool_free(fusion->reply_frames_desc_pool,
+                      fusion->reply_frames_desc,
+                      fusion->reply_frames_desc_phys);
+        pci_pool_destroy(fusion->reply_frames_desc_pool);
+
+fail_reply_desc:
+        dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz,
+                          fusion->req_frames_desc,
+                          fusion->req_frames_desc_phys);
+fail_req_desc:
+        return -ENOMEM;
+}
+
+/**
+ * wait_and_poll -      Issues a polling command
+ * @instance:                   Adapter soft state
+ * @cmd:                        Command packet to be issued
+ *
+ * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
+ */
+int
+wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd)
+{
+        int i;
+        struct megasas_header *frame_hdr = &cmd->frame->hdr;
+
+        u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000;
+
+        /*
+         * Wait for cmd_status to change
+         */
+        for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) {
+                rmb();
+                msleep(20);
+        }
+
+        if (frame_hdr->cmd_status == 0xff)
+                return -ETIME;
+
+        return 0;
+}
+
+/**
+ * megasas_ioc_init_fusion -    Initializes the FW
+ * @instance:           Adapter soft state
+ *
+ * Issues the IOC Init cmd
+ */
+int
+megasas_ioc_init_fusion(struct megasas_instance *instance)
+{
+        struct megasas_init_frame *init_frame;
+        struct MPI2_IOC_INIT_REQUEST *IOCInitMessage;
+        dma_addr_t      ioc_init_handle;
+        u32 context;
+        struct megasas_cmd *cmd;
+        u8 ret;
+        struct fusion_context *fusion;
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
+        int i;
+        struct megasas_header *frame_hdr;
+
+        fusion = instance->ctrl_context;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_ERR "Could not allocate cmd for INIT Frame\n");
+                ret = 1;
+                goto fail_get_cmd;
+        }
+
+        IOCInitMessage =
+          dma_alloc_coherent(&instance->pdev->dev,
+                             sizeof(struct MPI2_IOC_INIT_REQUEST),
+                             &ioc_init_handle, GFP_KERNEL);
+
+        if (!IOCInitMessage) {
+                printk(KERN_ERR "Could not allocate memory for "
+                       "IOCInitMessage\n");
+                ret = 1;
+                goto fail_fw_init;
+        }
+
+        memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST));
+
+        IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT;
+        IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
+        IOCInitMessage->MsgVersion = MPI2_VERSION;
+        IOCInitMessage->HeaderVersion = MPI2_HEADER_VERSION;
+        IOCInitMessage->SystemRequestFrameSize =
+                MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4;
+
+        IOCInitMessage->ReplyDescriptorPostQueueDepth = fusion->reply_q_depth;
+        IOCInitMessage->ReplyDescriptorPostQueueAddress =
+                fusion->reply_frames_desc_phys;
+        IOCInitMessage->SystemRequestFrameBaseAddress =
+                fusion->io_request_frames_phys;
+
+        init_frame = (struct megasas_init_frame *)cmd->frame;
+        memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
+
+        frame_hdr = &cmd->frame->hdr;
+        context = init_frame->context;
+        init_frame->context = context;
+
+        frame_hdr->cmd_status = 0xFF;
+        frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
+
+        init_frame->cmd = MFI_CMD_INIT;
+        init_frame->cmd_status = 0xFF;
+
+        init_frame->queue_info_new_phys_addr_lo = ioc_init_handle;
+        init_frame->data_xfer_len = sizeof(struct MPI2_IOC_INIT_REQUEST);
+
+        req_desc =
+          (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)fusion->req_frames_desc;
+
+        req_desc->Words = cmd->frame_phys_addr;
+        req_desc->MFAIo.RequestFlags =
+                (MEGASAS_REQ_DESCRIPT_FLAGS_MFA <<
+                 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+
+        /*
+         * disable the intr before firing the init frame
+         */
+        instance->instancet->disable_intr(instance->reg_set);
+
+        for (i = 0; i < (10 * 1000); i += 20) {
+                if (readl(&instance->reg_set->doorbell) & 1)
+                        msleep(20);
+                else
+                        break;
+        }
+
+        instance->instancet->fire_cmd(instance, req_desc->u.low,
+                                      req_desc->u.high, instance->reg_set);
+
+        wait_and_poll(instance, cmd);
+
+        frame_hdr = &cmd->frame->hdr;
+        if (frame_hdr->cmd_status != 0) {
+                ret = 1;
+                goto fail_fw_init;
+        }
+        printk(KERN_ERR "megasas:IOC Init cmd success\n");
+
+        ret = 0;
+
+fail_fw_init:
+        megasas_return_cmd(instance, cmd);
+        if (IOCInitMessage)
+                dma_free_coherent(&instance->pdev->dev,
+                                  sizeof(struct MPI2_IOC_INIT_REQUEST),
+                                  IOCInitMessage, ioc_init_handle);
+fail_get_cmd:
+        return ret;
+}
+
+/*
+ * megasas_return_cmd_for_smid -        Returns a cmd_fusion for a SMID
+ * @instance:                           Adapter soft state
+ *
+ */
+void
+megasas_return_cmd_for_smid(struct megasas_instance *instance, u16 smid)
+{
+        struct fusion_context *fusion;
+        struct megasas_cmd_fusion *cmd;
+
+        fusion = instance->ctrl_context;
+        cmd = fusion->cmd_list[smid - 1];
+        megasas_return_cmd_fusion(instance, cmd);
+}
+
+/*
+ * megasas_get_ld_map_info -    Returns FW's ld_map structure
+ * @instance:                           Adapter soft state
+ * @pend:                               Pend the command or not
+ * Issues an internal command (DCMD) to get the FW's controller PD
+ * list structure.  This information is mainly used to find out SYSTEM
+ * supported by the FW.
+ */
+static int
+megasas_get_ld_map_info(struct megasas_instance *instance)
+{
+        int ret = 0;
+        struct megasas_cmd *cmd;
+        struct megasas_dcmd_frame *dcmd;
+        struct MR_FW_RAID_MAP_ALL *ci;
+        dma_addr_t ci_h = 0;
+        u32 size_map_info;
+        struct fusion_context *fusion;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_DEBUG "megasas: Failed to get cmd for map info.\n");
+                return -ENOMEM;
+        }
+
+        fusion = instance->ctrl_context;
+
+        if (!fusion) {
+                megasas_return_cmd(instance, cmd);
+                return 1;
+        }
+
+        dcmd = &cmd->frame->dcmd;
+
+        size_map_info = sizeof(struct MR_FW_RAID_MAP) +
+                (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1));
+
+        ci = fusion->ld_map[(instance->map_id & 1)];
+        ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
+
+        if (!ci) {
+                printk(KERN_DEBUG "Failed to alloc mem for ld_map_info\n");
+                megasas_return_cmd(instance, cmd);
+                return -ENOMEM;
+        }
+
+        memset(ci, 0, sizeof(*ci));
+        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
+
+        dcmd->cmd = MFI_CMD_DCMD;
+        dcmd->cmd_status = 0xFF;
+        dcmd->sge_count = 1;
+        dcmd->flags = MFI_FRAME_DIR_READ;
+        dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
+        dcmd->data_xfer_len = size_map_info;
+        dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO;
+        dcmd->sgl.sge32[0].phys_addr = ci_h;
+        dcmd->sgl.sge32[0].length = size_map_info;
+
+        if (!megasas_issue_polled(instance, cmd))
+                ret = 0;
+        else {
+                printk(KERN_ERR "megasas: Get LD Map Info Failed\n");
+                ret = -1;
+        }
+
+        megasas_return_cmd(instance, cmd);
+
+        return ret;
+}
+
+u8
+megasas_get_map_info(struct megasas_instance *instance)
+{
+        struct fusion_context *fusion = instance->ctrl_context;
+
+        fusion->fast_path_io = 0;
+        if (!megasas_get_ld_map_info(instance)) {
+                if (MR_ValidateMapInfo(fusion->ld_map[(instance->map_id & 1)],
+                                       fusion->load_balance_info)) {
+                        fusion->fast_path_io = 1;
+                        return 0;
+                }
+        }
+        return 1;
+}
+
+/*
+ * megasas_sync_map_info -      Returns FW's ld_map structure
+ * @instance:                           Adapter soft state
+ *
+ * Issues an internal command (DCMD) to get the FW's controller PD
+ * list structure.  This information is mainly used to find out SYSTEM
+ * supported by the FW.
+ */
+int
+megasas_sync_map_info(struct megasas_instance *instance)
+{
+        int ret = 0, i;
+        struct megasas_cmd *cmd;
+        struct megasas_dcmd_frame *dcmd;
+        u32 size_sync_info, num_lds;
+        struct fusion_context *fusion;
+        struct MR_LD_TARGET_SYNC *ci = NULL;
+        struct MR_FW_RAID_MAP_ALL *map;
+        struct MR_LD_RAID  *raid;
+        struct MR_LD_TARGET_SYNC *ld_sync;
+        dma_addr_t ci_h = 0;
+        u32 size_map_info;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_DEBUG "megasas: Failed to get cmd for sync"
+                       "info.\n");
+                return -ENOMEM;
+        }
+
+        fusion = instance->ctrl_context;
+
+        if (!fusion) {
+                megasas_return_cmd(instance, cmd);
+                return 1;
+        }
+
+        map = fusion->ld_map[instance->map_id & 1];
+
+        num_lds = map->raidMap.ldCount;
+
+        dcmd = &cmd->frame->dcmd;
+
+        size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds;
+
+        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
+
+        ci = (struct MR_LD_TARGET_SYNC *)
+          fusion->ld_map[(instance->map_id - 1) & 1];
+        memset(ci, 0, sizeof(struct MR_FW_RAID_MAP_ALL));
+
+        ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
+
+        ld_sync = (struct MR_LD_TARGET_SYNC *)ci;
+
+        for (i = 0; i < num_lds; i++, ld_sync++) {
+                raid = MR_LdRaidGet(i, map);
+                ld_sync->targetId = MR_GetLDTgtId(i, map);
+                ld_sync->seqNum = raid->seqNum;
+        }
+
+        size_map_info = sizeof(struct MR_FW_RAID_MAP) +
+                (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1));
+
+        dcmd->cmd = MFI_CMD_DCMD;
+        dcmd->cmd_status = 0xFF;
+        dcmd->sge_count = 1;
+        dcmd->flags = MFI_FRAME_DIR_WRITE;
+        dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
+        dcmd->data_xfer_len = size_map_info;
+        dcmd->mbox.b[0] = num_lds;
+        dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG;
+        dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO;
+        dcmd->sgl.sge32[0].phys_addr = ci_h;
+        dcmd->sgl.sge32[0].length = size_map_info;
+
+        instance->map_update_cmd = cmd;
+
+        instance->instancet->issue_dcmd(instance, cmd);
+
+        return ret;
+}
+
+/**
+ * megasas_init_adapter_fusion -        Initializes the FW
+ * @instance:           Adapter soft state
+ *
+ * This is the main function for initializing firmware.
+ */
+u32
+megasas_init_adapter_fusion(struct megasas_instance *instance)
+{
+        struct megasas_register_set __iomem *reg_set;
+        struct fusion_context *fusion;
+        u32 max_cmd;
+        int i = 0;
+
+        fusion = instance->ctrl_context;
+
+        reg_set = instance->reg_set;
+
+        /*
+         * Get various operational parameters from status register
+         */
+        instance->max_fw_cmds =
+                instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
+        instance->max_fw_cmds = min(instance->max_fw_cmds, (u16)1008);
+
+        /*
+         * Reduce the max supported cmds by 1. This is to ensure that the
+         * reply_q_sz (1 more than the max cmd that driver may send)
+         * does not exceed max cmds that the FW can support
+         */
+        instance->max_fw_cmds = instance->max_fw_cmds-1;
+        /* Only internal cmds (DCMD) need to have MFI frames */
+        instance->max_mfi_cmds = MEGASAS_INT_CMDS;
+
+        max_cmd = instance->max_fw_cmds;
+
+        fusion->reply_q_depth = ((max_cmd + 1 + 15)/16)*16;
+
+        fusion->request_alloc_sz =
+                sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *max_cmd;
+        fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)
+                *(fusion->reply_q_depth);
+        fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE +
+                (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE *
+                 (max_cmd + 1)); /* Extra 1 for SMID 0 */
+
+        fusion->max_sge_in_main_msg =
+          (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
+           offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16;
+
+        fusion->max_sge_in_chain =
+                MEGASAS_MAX_SZ_CHAIN_FRAME / sizeof(union MPI2_SGE_IO_UNION);
+
+        instance->max_num_sge = fusion->max_sge_in_main_msg +
+                fusion->max_sge_in_chain - 2;
+
+        /* Used for pass thru MFI frame (DCMD) */
+        fusion->chain_offset_mfi_pthru =
+                offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16;
+
+        fusion->chain_offset_io_request =
+                (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
+                 sizeof(union MPI2_SGE_IO_UNION))/16;
+
+        fusion->last_reply_idx = 0;
+
+        /*
+         * Allocate memory for descriptors
+         * Create a pool of commands
+         */
+        if (megasas_alloc_cmds(instance))
+                goto fail_alloc_mfi_cmds;
+        if (megasas_alloc_cmds_fusion(instance))
+                goto fail_alloc_cmds;
+
+        if (megasas_ioc_init_fusion(instance))
+                goto fail_ioc_init;
+
+        instance->flag_ieee = 1;
+
+        fusion->map_sz =  sizeof(struct MR_FW_RAID_MAP) +
+          (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1));
+
+        fusion->fast_path_io = 0;
+
+        for (i = 0; i < 2; i++) {
+                fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
+                                                       fusion->map_sz,
+                                                       &fusion->ld_map_phys[i],
+                                                       GFP_KERNEL);
+                if (!fusion->ld_map[i]) {
+                        printk(KERN_ERR "megasas: Could not allocate memory "
+                               "for map info\n");
+                        goto fail_map_info;
+                }
+        }
+
+        if (!megasas_get_map_info(instance))
+                megasas_sync_map_info(instance);
+
+        return 0;
+
+fail_alloc_cmds:
+fail_alloc_mfi_cmds:
+fail_map_info:
+        if (i == 1)
+                dma_free_coherent(&instance->pdev->dev, fusion->map_sz,
+                                  fusion->ld_map[0], fusion->ld_map_phys[0]);
+fail_ioc_init:
+        return 1;
+}
+
+/**
+ * megasas_fire_cmd_fusion -    Sends command to the FW
+ * @frame_phys_addr :           Physical address of cmd
+ * @frame_count :               Number of frames for the command
+ * @regs :                      MFI register set
+ */
+void
+megasas_fire_cmd_fusion(struct megasas_instance *instance,
+                        dma_addr_t req_desc_lo,
+                        u32 req_desc_hi,
+                        struct megasas_register_set __iomem *regs)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&instance->hba_lock, flags);
+
+        writel(req_desc_lo,
+               &(regs)->inbound_low_queue_port);
+        writel(req_desc_hi, &(regs)->inbound_high_queue_port);
+        spin_unlock_irqrestore(&instance->hba_lock, flags);
+}
+
+/**
+ * map_cmd_status -     Maps FW cmd status to OS cmd status
+ * @cmd :               Pointer to cmd
+ * @status :            status of cmd returned by FW
+ * @ext_status :        ext status of cmd returned by FW
+ */
+
+void
+map_cmd_status(struct megasas_cmd_fusion *cmd, u8 status, u8 ext_status)
+{
+
+        switch (status) {
+
+        case MFI_STAT_OK:
+                cmd->scmd->result = DID_OK << 16;
+                break;
+
+        case MFI_STAT_SCSI_IO_FAILED:
+        case MFI_STAT_LD_INIT_IN_PROGRESS:
+                cmd->scmd->result = (DID_ERROR << 16) | ext_status;
+                break;
+
+        case MFI_STAT_SCSI_DONE_WITH_ERROR:
+
+                cmd->scmd->result = (DID_OK << 16) | ext_status;
+                if (ext_status == SAM_STAT_CHECK_CONDITION) {
+                        memset(cmd->scmd->sense_buffer, 0,
+                               SCSI_SENSE_BUFFERSIZE);
+                        memcpy(cmd->scmd->sense_buffer, cmd->sense,
+                               SCSI_SENSE_BUFFERSIZE);
+                        cmd->scmd->result |= DRIVER_SENSE << 24;
+                }
+                break;
+
+        case MFI_STAT_LD_OFFLINE:
+        case MFI_STAT_DEVICE_NOT_FOUND:
+                cmd->scmd->result = DID_BAD_TARGET << 16;
+                break;
+
+        default:
+                printk(KERN_DEBUG "megasas: FW status %#x\n", status);
+                cmd->scmd->result = DID_ERROR << 16;
+                break;
+        }
+}
+
+/**
+ * megasas_make_sgl_fusion -    Prepares 32-bit SGL
+ * @instance:           Adapter soft state
+ * @scp:                SCSI command from the mid-layer
+ * @sgl_ptr:            SGL to be filled in
+ * @cmd:                cmd we are working on
+ *
+ * If successful, this function returns the number of SG elements.
+ */
+static int
+megasas_make_sgl_fusion(struct megasas_instance *instance,
+                        struct scsi_cmnd *scp,
+                        struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
+                        struct megasas_cmd_fusion *cmd)
+{
+        int i, sg_processed;
+        int sge_count, sge_idx;
+        struct scatterlist *os_sgl;
+        struct fusion_context *fusion;
+
+        fusion = instance->ctrl_context;
+
+        cmd->io_request->ChainOffset = 0;
+
+        sge_count = scsi_dma_map(scp);
+
+        BUG_ON(sge_count < 0);
+
+        if (sge_count > instance->max_num_sge || !sge_count)
+                return sge_count;
+
+        if (sge_count > fusion->max_sge_in_main_msg) {
+                /* One element to store the chain info */
+                sge_idx = fusion->max_sge_in_main_msg - 1;
+        } else
+                sge_idx = sge_count;
+
+        scsi_for_each_sg(scp, os_sgl, sge_count, i) {
+                sgl_ptr->Length = sg_dma_len(os_sgl);
+                sgl_ptr->Address = sg_dma_address(os_sgl);
+                sgl_ptr->Flags = 0;
+                sgl_ptr++;
+
+                sg_processed = i + 1;
+
+                if ((sg_processed ==  (fusion->max_sge_in_main_msg - 1)) &&
+                    (sge_count > fusion->max_sge_in_main_msg)) {
+
+                        struct MPI25_IEEE_SGE_CHAIN64 *sg_chain;
+                        cmd->io_request->ChainOffset =
+                                fusion->chain_offset_io_request;
+                        sg_chain = sgl_ptr;
+                        /* Prepare chain element */
+                        sg_chain->NextChainOffset = 0;
+                        sg_chain->Flags = (IEEE_SGE_FLAGS_CHAIN_ELEMENT |
+                                           MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
+                        sg_chain->Length =  (sizeof(union MPI2_SGE_IO_UNION)
+                                             *(sge_count - sg_processed));
+                        sg_chain->Address = cmd->sg_frame_phys_addr;
+
+                        sgl_ptr =
+                          (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
+                }
+        }
+
+        return sge_count;
+}
+
+/**
+ * megasas_set_pd_lba - Sets PD LBA
+ * @cdb:                CDB
+ * @cdb_len:            cdb length
+ * @start_blk:          Start block of IO
+ *
+ * Used to set the PD LBA in CDB for FP IOs
+ */
+void
+megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
+                   struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp,
+                   struct MR_FW_RAID_MAP_ALL *local_map_ptr, u32 ref_tag)
+{
+        struct MR_LD_RAID *raid;
+        u32 ld;
+        u64 start_blk = io_info->pdBlock;
+        u8 *cdb = io_request->CDB.CDB32;
+        u32 num_blocks = io_info->numBlocks;
+        u8 opcode, flagvals, groupnum, control;
+
+        /* Check if T10 PI (DIF) is enabled for this LD */
+        ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr);
+        raid = MR_LdRaidGet(ld, local_map_ptr);
+        if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) {
+                memset(cdb, 0, sizeof(io_request->CDB.CDB32));
+                cdb[0] =  MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
+                cdb[7] =  MEGASAS_SCSI_ADDL_CDB_LEN;
+
+                if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
+                        cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
+                else
+                        cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
+                cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL;
+
+                /* LBA */
+                cdb[12] = (u8)((start_blk >> 56) & 0xff);
+                cdb[13] = (u8)((start_blk >> 48) & 0xff);
+                cdb[14] = (u8)((start_blk >> 40) & 0xff);
+                cdb[15] = (u8)((start_blk >> 32) & 0xff);
+                cdb[16] = (u8)((start_blk >> 24) & 0xff);
+                cdb[17] = (u8)((start_blk >> 16) & 0xff);
+                cdb[18] = (u8)((start_blk >> 8) & 0xff);
+                cdb[19] = (u8)(start_blk & 0xff);
+
+                /* Logical block reference tag */
+                io_request->CDB.EEDP32.PrimaryReferenceTag =
+                        cpu_to_be32(ref_tag);
+                io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0xffff;
+
+                io_request->DataLength = num_blocks * 512;
+                io_request->IoFlags = 32; /* Specify 32-byte cdb */
+
+                /* Transfer length */
+                cdb[28] = (u8)((num_blocks >> 24) & 0xff);
+                cdb[29] = (u8)((num_blocks >> 16) & 0xff);
+                cdb[30] = (u8)((num_blocks >> 8) & 0xff);
+                cdb[31] = (u8)(num_blocks & 0xff);
+
+                /* set SCSI IO EEDPFlags */
+                if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) {
+                        io_request->EEDPFlags =
+                                MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG  |
+                                MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
+                                MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP |
+                                MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG |
+                                MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
+                } else {
+                        io_request->EEDPFlags =
+                                MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
+                                MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
+                }
+                io_request->Control |= (0x4 << 26);
+                io_request->EEDPBlockSize = MEGASAS_EEDPBLOCKSIZE;
+        } else {
+                /* Some drives don't support 16/12 byte CDB's, convert to 10 */
+                if (((cdb_len == 12) || (cdb_len == 16)) &&
+                    (start_blk <= 0xffffffff)) {
+                        if (cdb_len == 16) {
+                                opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10;
+                                flagvals = cdb[1];
+                                groupnum = cdb[14];
+                                control = cdb[15];
+                        } else {
+                                opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10;
+                                flagvals = cdb[1];
+                                groupnum = cdb[10];
+                                control = cdb[11];
+                        }
+
+                        memset(cdb, 0, sizeof(io_request->CDB.CDB32));
+
+                        cdb[0] = opcode;
+                        cdb[1] = flagvals;
+                        cdb[6] = groupnum;
+                        cdb[9] = control;
+
+                        /* Transfer length */
+                        cdb[8] = (u8)(num_blocks & 0xff);
+                        cdb[7] = (u8)((num_blocks >> 8) & 0xff);
+
+                        cdb_len = 10;
+                }
+
+                /* Normal case, just load LBA here */
+                switch (cdb_len) {
+                case 6:
+                {
+                        u8 val = cdb[1] & 0xE0;
+                        cdb[3] = (u8)(start_blk & 0xff);
+                        cdb[2] = (u8)((start_blk >> 8) & 0xff);
+                        cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f);
+                        break;
+                }
+                case 10:
+                        cdb[5] = (u8)(start_blk & 0xff);
+                        cdb[4] = (u8)((start_blk >> 8) & 0xff);
+                        cdb[3] = (u8)((start_blk >> 16) & 0xff);
+                        cdb[2] = (u8)((start_blk >> 24) & 0xff);
+                        break;
+                case 12:
+                        cdb[5]    = (u8)(start_blk & 0xff);
+                        cdb[4]    = (u8)((start_blk >> 8) & 0xff);
+                        cdb[3]    = (u8)((start_blk >> 16) & 0xff);
+                        cdb[2]    = (u8)((start_blk >> 24) & 0xff);
+                        break;
+                case 16:
+                        cdb[9]    = (u8)(start_blk & 0xff);
+                        cdb[8]    = (u8)((start_blk >> 8) & 0xff);
+                        cdb[7]    = (u8)((start_blk >> 16) & 0xff);
+                        cdb[6]    = (u8)((start_blk >> 24) & 0xff);
+                        cdb[5]    = (u8)((start_blk >> 32) & 0xff);
+                        cdb[4]    = (u8)((start_blk >> 40) & 0xff);
+                        cdb[3]    = (u8)((start_blk >> 48) & 0xff);
+                        cdb[2]    = (u8)((start_blk >> 56) & 0xff);
+                        break;
+                }
+        }
+}
+
+/**
+ * megasas_build_ldio_fusion -  Prepares IOs to devices
+ * @instance:           Adapter soft state
+ * @scp:                SCSI command
+ * @cmd:                Command to be prepared
+ *
+ * Prepares the io_request and chain elements (sg_frame) for IO
+ * The IO can be for PD (Fast Path) or LD
+ */
+void
+megasas_build_ldio_fusion(struct megasas_instance *instance,
+                          struct scsi_cmnd *scp,
+                          struct megasas_cmd_fusion *cmd)
+{
+        u8 fp_possible;
+        u32 start_lba_lo, start_lba_hi, device_id;
+        struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
+        struct IO_REQUEST_INFO io_info;
+        struct fusion_context *fusion;
+        struct MR_FW_RAID_MAP_ALL *local_map_ptr;
+
+        device_id = MEGASAS_DEV_INDEX(instance, scp);
+
+        fusion = instance->ctrl_context;
+
+        io_request = cmd->io_request;
+        io_request->RaidContext.VirtualDiskTgtId = device_id;
+        io_request->RaidContext.status = 0;
+        io_request->RaidContext.exStatus = 0;
+
+        req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
+
+        start_lba_lo = 0;
+        start_lba_hi = 0;
+        fp_possible = 0;
+
+        /*
+         * 6-byte READ(0x08) or WRITE(0x0A) cdb
+         */
+        if (scp->cmd_len == 6) {
+                io_request->DataLength = (u32) scp->cmnd[4];
+                start_lba_lo = ((u32) scp->cmnd[1] << 16) |
+                        ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
+
+                start_lba_lo &= 0x1FFFFF;
+        }
+
+        /*
+         * 10-byte READ(0x28) or WRITE(0x2A) cdb
+         */
+        else if (scp->cmd_len == 10) {
+                io_request->DataLength = (u32) scp->cmnd[8] |
+                        ((u32) scp->cmnd[7] << 8);
+                start_lba_lo = ((u32) scp->cmnd[2] << 24) |
+                        ((u32) scp->cmnd[3] << 16) |
+                        ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
+        }
+
+        /*
+         * 12-byte READ(0xA8) or WRITE(0xAA) cdb
+         */
+        else if (scp->cmd_len == 12) {
+                io_request->DataLength = ((u32) scp->cmnd[6] << 24) |
+                        ((u32) scp->cmnd[7] << 16) |
+                        ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
+                start_lba_lo = ((u32) scp->cmnd[2] << 24) |
+                        ((u32) scp->cmnd[3] << 16) |
+                        ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
+        }
+
+        /*
+         * 16-byte READ(0x88) or WRITE(0x8A) cdb
+         */
+        else if (scp->cmd_len == 16) {
+                io_request->DataLength = ((u32) scp->cmnd[10] << 24) |
+                        ((u32) scp->cmnd[11] << 16) |
+                        ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
+                start_lba_lo = ((u32) scp->cmnd[6] << 24) |
+                        ((u32) scp->cmnd[7] << 16) |
+                        ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
+
+                start_lba_hi = ((u32) scp->cmnd[2] << 24) |
+                        ((u32) scp->cmnd[3] << 16) |
+                        ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
+        }
+
+        memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
+        io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo;
+        io_info.numBlocks = io_request->DataLength;
+        io_info.ldTgtId = device_id;
+
+        if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
+                io_info.isRead = 1;
+
+        local_map_ptr = fusion->ld_map[(instance->map_id & 1)];
+
+        if ((MR_TargetIdToLdGet(device_id, local_map_ptr) >=
+             MAX_LOGICAL_DRIVES) || (!fusion->fast_path_io)) {
+                io_request->RaidContext.regLockFlags  = 0;
+                fp_possible = 0;
+        } else {
+                if (MR_BuildRaidContext(&io_info, &io_request->RaidContext,
+                                        local_map_ptr))
+                        fp_possible = io_info.fpOkForIo;
+        }
+
+        if (fp_possible) {
+                megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp,
+                                   local_map_ptr, start_lba_lo);
+                io_request->DataLength = scsi_bufflen(scp);
+                io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
+                cmd->request_desc->SCSIIO.RequestFlags =
+                        (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY
+                         << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+                if ((fusion->load_balance_info[device_id].loadBalanceFlag) &&
+                    (io_info.isRead)) {
+                        io_info.devHandle =
+                                get_updated_dev_handle(
+                                        &fusion->load_balance_info[device_id],
+                                        &io_info);
+                        scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG;
+                } else
+                        scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
+                cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle;
+                io_request->DevHandle = io_info.devHandle;
+        } else {
+                io_request->RaidContext.timeoutValue =
+                        local_map_ptr->raidMap.fpPdIoTimeoutSec;
+                io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
+                io_request->DevHandle = device_id;
+                cmd->request_desc->SCSIIO.RequestFlags =
+                        (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
+                         << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+        } /* Not FP */
+}
+
+/**
+ * megasas_build_dcdb_fusion -  Prepares IOs to devices
+ * @instance:           Adapter soft state
+ * @scp:                SCSI command
+ * @cmd:                Command to be prepared
+ *
+ * Prepares the io_request frame for non-io cmds
+ */
+static void
+megasas_build_dcdb_fusion(struct megasas_instance *instance,
+                          struct scsi_cmnd *scmd,
+                          struct megasas_cmd_fusion *cmd)
+{
+        u32 device_id;
+        struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
+        u16 pd_index = 0;
+        struct MR_FW_RAID_MAP_ALL *local_map_ptr;
+        struct fusion_context *fusion = instance->ctrl_context;
+
+        io_request = cmd->io_request;
+        device_id = MEGASAS_DEV_INDEX(instance, scmd);
+        pd_index = (scmd->device->channel * MEGASAS_MAX_DEV_PER_CHANNEL)
+                +scmd->device->id;
+        local_map_ptr = fusion->ld_map[(instance->map_id & 1)];
+
+        /* Check if this is a system PD I/O */
+        if ((instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) &&
+            (instance->pd_list[pd_index].driveType == TYPE_DISK)) {
+                io_request->Function = 0;
+                io_request->DevHandle =
+                        local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
+                io_request->RaidContext.timeoutValue =
+                        local_map_ptr->raidMap.fpPdIoTimeoutSec;
+                io_request->RaidContext.regLockFlags = 0;
+                io_request->RaidContext.regLockRowLBA = 0;
+                io_request->RaidContext.regLockLength = 0;
+                io_request->RaidContext.RAIDFlags =
+                        MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD <<
+                        MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
+                cmd->request_desc->SCSIIO.RequestFlags =
+                        (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
+                         MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+        } else {
+                io_request->Function  = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
+                io_request->DevHandle = device_id;
+                cmd->request_desc->SCSIIO.RequestFlags =
+                        (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
+                         MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+        }
+        io_request->RaidContext.VirtualDiskTgtId = device_id;
+        io_request->LUN[0] = scmd->device->lun;
+        io_request->DataLength = scsi_bufflen(scmd);
+}
+
+/**
+ * megasas_build_io_fusion -    Prepares IOs to devices
+ * @instance:           Adapter soft state
+ * @scp:                SCSI command
+ * @cmd:                Command to be prepared
+ *
+ * Invokes helper functions to prepare request frames
+ * and sets flags appropriate for IO/Non-IO cmd
+ */
+int
+megasas_build_io_fusion(struct megasas_instance *instance,
+                        struct scsi_cmnd *scp,
+                        struct megasas_cmd_fusion *cmd)
+{
+        u32 device_id, sge_count;
+        struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request;
+
+        device_id = MEGASAS_DEV_INDEX(instance, scp);
+
+        /* Zero out some fields so they don't get reused */
+        io_request->LUN[0] = 0;
+        io_request->CDB.EEDP32.PrimaryReferenceTag = 0;
+        io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0;
+        io_request->EEDPFlags = 0;
+        io_request->Control = 0;
+        io_request->EEDPBlockSize = 0;
+        io_request->IoFlags = 0;
+        io_request->RaidContext.RAIDFlags = 0;
+
+        memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len);
+        /*
+         * Just the CDB length,rest of the Flags are zero
+         * This will be modified for FP in build_ldio_fusion
+         */
+        io_request->IoFlags = scp->cmd_len;
+
+        if (megasas_is_ldio(scp))
+                megasas_build_ldio_fusion(instance, scp, cmd);
+        else
+                megasas_build_dcdb_fusion(instance, scp, cmd);
+
+        /*
+         * Construct SGL
+         */
+
+        sge_count =
+                megasas_make_sgl_fusion(instance, scp,
+                                        (struct MPI25_IEEE_SGE_CHAIN64 *)
+                                        &io_request->SGL, cmd);
+
+        if (sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: Error. sge_count (0x%x) exceeds "
+                       "max (0x%x) allowed\n", sge_count,
+                       instance->max_num_sge);
+                return 1;
+        }
+
+        io_request->RaidContext.numSGE = sge_count;
+
+        io_request->SGLFlags = MPI2_SGE_FLAGS_64_BIT_ADDRESSING;
+
+        if (scp->sc_data_direction == PCI_DMA_TODEVICE)
+                io_request->Control |= MPI2_SCSIIO_CONTROL_WRITE;
+        else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
+                io_request->Control |= MPI2_SCSIIO_CONTROL_READ;
+
+        io_request->SGLOffset0 =
+                offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4;
+
+        io_request->SenseBufferLowAddress = cmd->sense_phys_addr;
+        io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
+
+        cmd->scmd = scp;
+        scp->SCp.ptr = (char *)cmd;
+
+        return 0;
+}
+
+union MEGASAS_REQUEST_DESCRIPTOR_UNION *
+megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
+{
+        u8 *p;
+        struct fusion_context *fusion;
+
+        if (index >= instance->max_fw_cmds) {
+                printk(KERN_ERR "megasas: Invalid SMID (0x%x)request for "
+                       "descriptor\n", index);
+                return NULL;
+        }
+        fusion = instance->ctrl_context;
+        p = fusion->req_frames_desc
+                +sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *index;
+
+        return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p;
+}
+
+/**
+ * megasas_build_and_issue_cmd_fusion -Main routine for building and
+ *                                     issuing non IOCTL cmd
+ * @instance:                   Adapter soft state
+ * @scmd:                       pointer to scsi cmd from OS
+ */
+static u32
+megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
+                                   struct scsi_cmnd *scmd)
+{
+        struct megasas_cmd_fusion *cmd;
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
+        u32 index;
+        struct fusion_context *fusion;
+
+        fusion = instance->ctrl_context;
+
+        cmd = megasas_get_cmd_fusion(instance);
+        if (!cmd)
+                return SCSI_MLQUEUE_HOST_BUSY;
+
+        index = cmd->index;
+
+        req_desc = megasas_get_request_descriptor(instance, index-1);
+        if (!req_desc)
+                return 1;
+
+        req_desc->Words = 0;
+        cmd->request_desc = req_desc;
+        cmd->request_desc->Words = 0;
+
+        if (megasas_build_io_fusion(instance, scmd, cmd)) {
+                megasas_return_cmd_fusion(instance, cmd);
+                printk(KERN_ERR "megasas: Error building command.\n");
+                cmd->request_desc = NULL;
+                return 1;
+        }
+
+        req_desc = cmd->request_desc;
+        req_desc->SCSIIO.SMID = index;
+
+        if (cmd->io_request->ChainOffset != 0 &&
+            cmd->io_request->ChainOffset != 0xF)
+                printk(KERN_ERR "megasas: The chain offset value is not "
+                       "correct : %x\n", cmd->io_request->ChainOffset);
+
+        /*
+         * Issue the command to the FW
+         */
+        atomic_inc(&instance->fw_outstanding);
+
+        instance->instancet->fire_cmd(instance,
+                                      req_desc->u.low, req_desc->u.high,
+                                      instance->reg_set);
+
+        return 0;
+}
+
+/**
+ * complete_cmd_fusion -        Completes command
+ * @instance:                   Adapter soft state
+ * Completes all commands that is in reply descriptor queue
+ */
+int
+complete_cmd_fusion(struct megasas_instance *instance)
+{
+        union MPI2_REPLY_DESCRIPTORS_UNION *desc;
+        struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
+        struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
+        struct fusion_context *fusion;
+        struct megasas_cmd *cmd_mfi;
+        struct megasas_cmd_fusion *cmd_fusion;
+        u16 smid, num_completed;
+        u8 reply_descript_type, arm;
+        u32 status, extStatus, device_id;
+        union desc_value d_val;
+        struct LD_LOAD_BALANCE_INFO *lbinfo;
+
+        fusion = instance->ctrl_context;
+
+        if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
+                return IRQ_HANDLED;
+
+        desc = fusion->reply_frames_desc;
+        desc += fusion->last_reply_idx;
+
+        reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
+
+        d_val.word = desc->Words;
+
+        reply_descript_type = reply_desc->ReplyFlags &
+                MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
+
+        if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
+                return IRQ_NONE;
+
+        d_val.word = desc->Words;
+
+        num_completed = 0;
+
+        while ((d_val.u.low != UINT_MAX) && (d_val.u.high != UINT_MAX)) {
+                smid = reply_desc->SMID;
+
+                cmd_fusion = fusion->cmd_list[smid - 1];
+
+                scsi_io_req =
+                        (struct MPI2_RAID_SCSI_IO_REQUEST *)
+                  cmd_fusion->io_request;
+
+                if (cmd_fusion->scmd)
+                        cmd_fusion->scmd->SCp.ptr = NULL;
+
+                status = scsi_io_req->RaidContext.status;
+                extStatus = scsi_io_req->RaidContext.exStatus;
+
+                switch (scsi_io_req->Function) {
+                case MPI2_FUNCTION_SCSI_IO_REQUEST:  /*Fast Path IO.*/
+                        /* Update load balancing info */
+                        device_id = MEGASAS_DEV_INDEX(instance,
+                                                      cmd_fusion->scmd);
+                        lbinfo = &fusion->load_balance_info[device_id];
+                        if (cmd_fusion->scmd->SCp.Status &
+                            MEGASAS_LOAD_BALANCE_FLAG) {
+                                arm = lbinfo->raid1DevHandle[0] ==
+                                        cmd_fusion->io_request->DevHandle ? 0 :
+                                        1;
+                                atomic_dec(&lbinfo->scsi_pending_cmds[arm]);
+                                cmd_fusion->scmd->SCp.Status &=
+                                        ~MEGASAS_LOAD_BALANCE_FLAG;
+                        }
+                        if (reply_descript_type ==
+                            MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS) {
+                                if (megasas_dbg_lvl == 5)
+                                        printk(KERN_ERR "\nmegasas: FAST Path "
+                                               "IO Success\n");
+                        }
+                        /* Fall thru and complete IO */
+                case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */
+                        /* Map the FW Cmd Status */
+                        map_cmd_status(cmd_fusion, status, extStatus);
+                        scsi_dma_unmap(cmd_fusion->scmd);
+                        cmd_fusion->scmd->scsi_done(cmd_fusion->scmd);
+                        scsi_io_req->RaidContext.status = 0;
+                        scsi_io_req->RaidContext.exStatus = 0;
+                        megasas_return_cmd_fusion(instance, cmd_fusion);
+                        atomic_dec(&instance->fw_outstanding);
+
+                        break;
+                case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */
+                        cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
+                        megasas_complete_cmd(instance, cmd_mfi, DID_OK);
+                        cmd_fusion->flags = 0;
+                        megasas_return_cmd_fusion(instance, cmd_fusion);
+
+                        break;
+                }
+
+                fusion->last_reply_idx++;
+                if (fusion->last_reply_idx >= fusion->reply_q_depth)
+                        fusion->last_reply_idx = 0;
+
+                desc->Words = ULLONG_MAX;
+                num_completed++;
+
+                /* Get the next reply descriptor */
+                if (!fusion->last_reply_idx)
+                        desc = fusion->reply_frames_desc;
+                else
+                        desc++;
+
+                reply_desc =
+                  (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
+
+                d_val.word = desc->Words;
+
+                reply_descript_type = reply_desc->ReplyFlags &
+                        MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
+
+                if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
+                        break;
+        }
+
+        if (!num_completed)
+                return IRQ_NONE;
+
+        wmb();
+        writel(fusion->last_reply_idx,
+               &instance->reg_set->reply_post_host_index);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * megasas_complete_cmd_dpc_fusion -    Completes command
+ * @instance:                   Adapter soft state
+ *
+ * Tasklet to complete cmds
+ */
+void
+megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
+{
+        struct megasas_instance *instance =
+                (struct megasas_instance *)instance_addr;
+        unsigned long flags;
+
+        /* If we have already declared adapter dead, donot complete cmds */
+        spin_lock_irqsave(&instance->hba_lock, flags);
+        if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+                spin_unlock_irqrestore(&instance->hba_lock, flags);
+                return;
+        }
+        spin_unlock_irqrestore(&instance->hba_lock, flags);
+
+        spin_lock_irqsave(&instance->completion_lock, flags);
+        complete_cmd_fusion(instance);
+        spin_unlock_irqrestore(&instance->completion_lock, flags);
+}
+
+/**
+ * megasas_isr_fusion - isr entry point
+ */
+irqreturn_t megasas_isr_fusion(int irq, void *devp)
+{
+        struct megasas_instance *instance = (struct megasas_instance *)devp;
+        u32 mfiStatus, fw_state;
+
+        if (!instance->msi_flag) {
+                mfiStatus = instance->instancet->clear_intr(instance->reg_set);
+                if (!mfiStatus)
+                        return IRQ_NONE;
+        }
+
+        /* If we are resetting, bail */
+        if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags))
+                return IRQ_HANDLED;
+
+        if (!complete_cmd_fusion(instance)) {
+                /* If we didn't complete any commands, check for FW fault */
+                fw_state = instance->instancet->read_fw_status_reg(
+                        instance->reg_set) & MFI_STATE_MASK;
+                if (fw_state == MFI_STATE_FAULT)
+                        schedule_work(&instance->work_init);
+        }
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru
+ * @instance:                   Adapter soft state
+ * mfi_cmd:                     megasas_cmd pointer
+ *
+ */
+u8
+build_mpt_mfi_pass_thru(struct megasas_instance *instance,
+                        struct megasas_cmd *mfi_cmd)
+{
+        struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
+        struct MPI2_RAID_SCSI_IO_REQUEST *io_req;
+        struct megasas_cmd_fusion *cmd;
+        struct fusion_context *fusion;
+        struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr;
+
+        cmd = megasas_get_cmd_fusion(instance);
+        if (!cmd)
+                return 1;
+
+        /*  Save the smid. To be used for returning the cmd */
+        mfi_cmd->context.smid = cmd->index;
+
+        cmd->sync_cmd_idx = mfi_cmd->index;
+
+        /*
+         * For cmds where the flag is set, store the flag and check
+         * on completion. For cmds with this flag, don't call
+         * megasas_complete_cmd
+         */
+
+        if (frame_hdr->flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE)
+                cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
+
+        fusion = instance->ctrl_context;
+        io_req = cmd->io_request;
+        mpi25_ieee_chain =
+          (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
+
+        io_req->Function    = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
+        io_req->SGLOffset0  = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST,
+                                       SGL) / 4;
+        io_req->ChainOffset = fusion->chain_offset_mfi_pthru;
+
+        mpi25_ieee_chain->Address = mfi_cmd->frame_phys_addr;
+
+        mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
+                MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
+
+        mpi25_ieee_chain->Length = MEGASAS_MAX_SZ_CHAIN_FRAME;
+
+        return 0;
+}
+
+/**
+ * build_mpt_cmd - Calls helper function to build a cmd MFI Pass thru cmd
+ * @instance:                   Adapter soft state
+ * @cmd:                        mfi cmd to build
+ *
+ */
+union MEGASAS_REQUEST_DESCRIPTOR_UNION *
+build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
+{
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
+        u16 index;
+
+        if (build_mpt_mfi_pass_thru(instance, cmd)) {
+                printk(KERN_ERR "Couldn't build MFI pass thru cmd\n");
+                return NULL;
+        }
+
+        index = cmd->context.smid;
+
+        req_desc = megasas_get_request_descriptor(instance, index - 1);
+
+        if (!req_desc)
+                return NULL;
+
+        req_desc->Words = 0;
+        req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
+                                         MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+
+        req_desc->SCSIIO.SMID = index;
+
+        return req_desc;
+}
+
+/**
+ * megasas_issue_dcmd_fusion - Issues a MFI Pass thru cmd
+ * @instance:                   Adapter soft state
+ * @cmd:                        mfi cmd pointer
+ *
+ */
+void
+megasas_issue_dcmd_fusion(struct megasas_instance *instance,
+                          struct megasas_cmd *cmd)
+{
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
+        union desc_value d_val;
+
+        req_desc = build_mpt_cmd(instance, cmd);
+        if (!req_desc) {
+                printk(KERN_ERR "Couldn't issue MFI pass thru cmd\n");
+                return;
+        }
+        d_val.word = req_desc->Words;
+
+        instance->instancet->fire_cmd(instance, req_desc->u.low,
+                                      req_desc->u.high, instance->reg_set);
+}
+
+/**
+ * megasas_release_fusion -     Reverses the FW initialization
+ * @intance:                    Adapter soft state
+ */
+void
+megasas_release_fusion(struct megasas_instance *instance)
+{
+        megasas_free_cmds(instance);
+        megasas_free_cmds_fusion(instance);
+
+        iounmap(instance->reg_set);
+
+        pci_release_selected_regions(instance->pdev, instance->bar);
+}
+
+/**
+ * megasas_read_fw_status_reg_fusion - returns the current FW status value
+ * @regs:                       MFI register set
+ */
+static u32
+megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs)
+{
+        return readl(&(regs)->outbound_scratch_pad);
+}
+
+/**
+ * megasas_adp_reset_fusion -   For controller reset
+ * @regs:                               MFI register set
+ */
+static int
+megasas_adp_reset_fusion(struct megasas_instance *instance,
+                         struct megasas_register_set __iomem *regs)
+{
+        return 0;
+}
+
+/**
+ * megasas_check_reset_fusion - For controller reset check
+ * @regs:                               MFI register set
+ */
+static int
+megasas_check_reset_fusion(struct megasas_instance *instance,
+                           struct megasas_register_set __iomem *regs)
+{
+        return 0;
+}
+
+/* This function waits for outstanding commands on fusion to complete */
+int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance)
+{
+        int i, outstanding, retval = 0;
+        u32 fw_state, wait_time = MEGASAS_RESET_WAIT_TIME;
+
+        for (i = 0; i < wait_time; i++) {
+                /* Check if firmware is in fault state */
+                fw_state = instance->instancet->read_fw_status_reg(
+                        instance->reg_set) & MFI_STATE_MASK;
+                if (fw_state == MFI_STATE_FAULT) {
+                        printk(KERN_WARNING "megasas: Found FW in FAULT state,"
+                               " will reset adapter.\n");
+                        retval = 1;
+                        goto out;
+                }
+
+                outstanding = atomic_read(&instance->fw_outstanding);
+                if (!outstanding)
+                        goto out;
+
+                if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
+                        printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
+                               "commands to complete\n", i, outstanding);
+                        megasas_complete_cmd_dpc_fusion(
+                                (unsigned long)instance);
+                }
+                msleep(1000);
+        }
+
+        if (atomic_read(&instance->fw_outstanding)) {
+                printk("megaraid_sas: pending commands remain after waiting, "
+                       "will reset adapter.\n");
+                retval = 1;
+        }
+out:
+        return retval;
+}
+
+void  megasas_reset_reply_desc(struct megasas_instance *instance)
+{
+        int i;
+        struct fusion_context *fusion;
+        union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
+
+        fusion = instance->ctrl_context;
+        fusion->last_reply_idx = 0;
+        reply_desc = fusion->reply_frames_desc;
+        for (i = 0 ; i < fusion->reply_q_depth; i++, reply_desc++)
+                reply_desc->Words = ULLONG_MAX;
+}
+
+/* Core fusion reset function */
+int megasas_reset_fusion(struct Scsi_Host *shost)
+{
+        int retval = SUCCESS, i, j, retry = 0;
+        struct megasas_instance *instance;
+        struct megasas_cmd_fusion *cmd_fusion;
+        struct fusion_context *fusion;
+        struct megasas_cmd *cmd_mfi;
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
+        u32 host_diag, abs_state;
+
+        instance = (struct megasas_instance *)shost->hostdata;
+        fusion = instance->ctrl_context;
+
+        mutex_lock(&instance->reset_mutex);
+        set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
+        instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
+        instance->instancet->disable_intr(instance->reg_set);
+        msleep(1000);
+
+        if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
+                printk(KERN_WARNING "megaraid_sas: Hardware critical error, "
+                       "returning FAILED.\n");
+                retval = FAILED;
+                goto out;
+        }
+
+        /* First try waiting for commands to complete */
+        if (megasas_wait_for_outstanding_fusion(instance)) {
+                printk(KERN_WARNING "megaraid_sas: resetting fusion "
+                       "adapter.\n");
+                /* Now return commands back to the OS */
+                for (i = 0 ; i < instance->max_fw_cmds; i++) {
+                        cmd_fusion = fusion->cmd_list[i];
+                        if (cmd_fusion->scmd) {
+                                scsi_dma_unmap(cmd_fusion->scmd);
+                                cmd_fusion->scmd->result = (DID_RESET << 16);
+                                cmd_fusion->scmd->scsi_done(cmd_fusion->scmd);
+                                megasas_return_cmd_fusion(instance, cmd_fusion);
+                                atomic_dec(&instance->fw_outstanding);
+                        }
+                }
+
+                if (instance->disableOnlineCtrlReset == 1) {
+                        /* Reset not supported, kill adapter */
+                        printk(KERN_WARNING "megaraid_sas: Reset not supported"
+                               ", killing adapter.\n");
+                        megaraid_sas_kill_hba(instance);
+                        instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
+                        retval = FAILED;
+                        goto out;
+                }
+
+                /* Now try to reset the chip */
+                for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) {
+                        writel(MPI2_WRSEQ_FLUSH_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+                        writel(MPI2_WRSEQ_1ST_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+                        writel(MPI2_WRSEQ_2ND_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+                        writel(MPI2_WRSEQ_3RD_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+                        writel(MPI2_WRSEQ_4TH_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+                        writel(MPI2_WRSEQ_5TH_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+                        writel(MPI2_WRSEQ_6TH_KEY_VALUE,
+                               &instance->reg_set->fusion_seq_offset);
+
+                        /* Check that the diag write enable (DRWE) bit is on */
+                        host_diag = readl(&instance->reg_set->fusion_host_diag);
+                        while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
+                                msleep(100);
+                                host_diag =
+                                readl(&instance->reg_set->fusion_host_diag);
+                                if (retry++ == 100) {
+                                        printk(KERN_WARNING "megaraid_sas: "
+                                               "Host diag unlock failed!\n");
+                                        break;
+                                }
+                        }
+                        if (!(host_diag & HOST_DIAG_WRITE_ENABLE))
+                                continue;
+
+                        /* Send chip reset command */
+                        writel(host_diag | HOST_DIAG_RESET_ADAPTER,
+                               &instance->reg_set->fusion_host_diag);
+                        msleep(3000);
+
+                        /* Make sure reset adapter bit is cleared */
+                        host_diag = readl(&instance->reg_set->fusion_host_diag);
+                        retry = 0;
+                        while (host_diag & HOST_DIAG_RESET_ADAPTER) {
+                                msleep(100);
+                                host_diag =
+                                readl(&instance->reg_set->fusion_host_diag);
+                                if (retry++ == 1000) {
+                                        printk(KERN_WARNING "megaraid_sas: "
+                                               "Diag reset adapter never "
+                                               "cleared!\n");
+                                        break;
+                                }
+                        }
+                        if (host_diag & HOST_DIAG_RESET_ADAPTER)
+                                continue;
+
+                        abs_state =
+                                instance->instancet->read_fw_status_reg(
+                                        instance->reg_set);
+                        retry = 0;
+
+                        while ((abs_state <= MFI_STATE_FW_INIT) &&
+                               (retry++ < 1000)) {
+                                msleep(100);
+                                abs_state =
+                                instance->instancet->read_fw_status_reg(
+                                        instance->reg_set);
+                        }
+                        if (abs_state <= MFI_STATE_FW_INIT) {
+                                printk(KERN_WARNING "megaraid_sas: firmware "
+                                       "state < MFI_STATE_FW_INIT, state = "
+                                       "0x%x\n", abs_state);
+                                continue;
+                        }
+
+                        /* Wait for FW to become ready */
+                        if (megasas_transition_to_ready(instance)) {
+                                printk(KERN_WARNING "megaraid_sas: Failed to "
+                                       "transition controller to ready.\n");
+                                continue;
+                        }
+
+                        megasas_reset_reply_desc(instance);
+                        if (megasas_ioc_init_fusion(instance)) {
+                                printk(KERN_WARNING "megaraid_sas: "
+                                       "megasas_ioc_init_fusion() failed!\n");
+                                continue;
+                        }
+
+                        instance->instancet->enable_intr(instance->reg_set);
+                        instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
+
+                        /* Re-fire management commands */
+                        for (j = 0 ; j < instance->max_fw_cmds; j++) {
+                                cmd_fusion = fusion->cmd_list[j];
+                                if (cmd_fusion->sync_cmd_idx !=
+                                    (u32)ULONG_MAX) {
+                                        cmd_mfi =
+                                        instance->
+                                        cmd_list[cmd_fusion->sync_cmd_idx];
+                                        if (cmd_mfi->frame->dcmd.opcode ==
+                                            MR_DCMD_LD_MAP_GET_INFO) {
+                                                megasas_return_cmd(instance,
+                                                                   cmd_mfi);
+                                                megasas_return_cmd_fusion(
+                                                        instance, cmd_fusion);
+                                        } else  {
+                                                req_desc =
+                                                megasas_get_request_descriptor(
+                                                        instance,
+                                                        cmd_mfi->context.smid
+                                                        -1);
+                                                if (!req_desc)
+                                                        printk(KERN_WARNING
+                                                               "req_desc NULL"
+                                                               "\n");
+                                                else {
+                                                        instance->instancet->
+                                                        fire_cmd(instance,
+                                                                 req_desc->
+                                                                 u.low,
+                                                                 req_desc->
+                                                                 u.high,
+                                                                 instance->
+                                                                 reg_set);
+                                                }
+                                        }
+                                }
+                        }
+
+                        /* Reset load balance info */
+                        memset(fusion->load_balance_info, 0,
+                               sizeof(struct LD_LOAD_BALANCE_INFO)
+                               *MAX_LOGICAL_DRIVES);
+
+                        if (!megasas_get_map_info(instance))
+                                megasas_sync_map_info(instance);
+
+                        /* Adapter reset completed successfully */
+                        printk(KERN_WARNING "megaraid_sas: Reset "
+                               "successful.\n");
+                        retval = SUCCESS;
+                        goto out;
+                }
+                /* Reset failed, kill the adapter */
+                printk(KERN_WARNING "megaraid_sas: Reset failed, killing "
+                       "adapter.\n");
+                megaraid_sas_kill_hba(instance);
+                retval = FAILED;
+        } else {
+                instance->instancet->enable_intr(instance->reg_set);
+                instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
+        }
+out:
+        clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
+        mutex_unlock(&instance->reset_mutex);
+        return retval;
+}
+
+/* Fusion OCR work queue */
+void megasas_fusion_ocr_wq(struct work_struct *work)
+{
+        struct megasas_instance *instance =
+                container_of(work, struct megasas_instance, work_init);
+
+        megasas_reset_fusion(instance->host);
+}
+
+struct megasas_instance_template megasas_instance_template_fusion = {
+        .fire_cmd = megasas_fire_cmd_fusion,
+        .enable_intr = megasas_enable_intr_fusion,
+        .disable_intr = megasas_disable_intr_fusion,
+        .clear_intr = megasas_clear_intr_fusion,
+        .read_fw_status_reg = megasas_read_fw_status_reg_fusion,
+        .adp_reset = megasas_adp_reset_fusion,
+        .check_reset = megasas_check_reset_fusion,
+        .service_isr = megasas_isr_fusion,
+        .tasklet = megasas_complete_cmd_dpc_fusion,
+        .init_adapter = megasas_init_adapter_fusion,
+        .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion,
+        .issue_dcmd = megasas_issue_dcmd_fusion,
+};
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.h b/drivers/scsi/megaraid/megaraid_sas_fusion.h
new file mode 100644
index 000000000000..82b577a72c8b
--- /dev/null
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.h
@@ -0,0 +1,695 @@
+/*
+ *  Linux MegaRAID driver for SAS based RAID controllers
+ *
+ *  Copyright (c) 2009-2011  LSI Corporation.
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *  FILE: megaraid_sas_fusion.h
+ *
+ *  Authors: LSI Corporation
+ *           Manoj Jose
+ *           Sumant Patro
+ *
+ *  Send feedback to: <megaraidlinux@lsi.com>
+ *
+ *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
+ *     ATTN: Linuxraid
+ */
+
+#ifndef _MEGARAID_SAS_FUSION_H_
+#define _MEGARAID_SAS_FUSION_H_
+
+/* Fusion defines */
+#define MEGASAS_MAX_SZ_CHAIN_FRAME 1024
+#define MFI_FUSION_ENABLE_INTERRUPT_MASK (0x00000009)
+#define MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE 256
+#define MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST   0xF0
+#define MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST         0xF1
+#define MEGASAS_LOAD_BALANCE_FLAG                   0x1
+#define MEGASAS_DCMD_MBOX_PEND_FLAG                 0x1
+#define HOST_DIAG_WRITE_ENABLE                      0x80
+#define HOST_DIAG_RESET_ADAPTER                     0x4
+#define MEGASAS_FUSION_MAX_RESET_TRIES              3
+
+/* T10 PI defines */
+#define MR_PROT_INFO_TYPE_CONTROLLER                0x8
+#define MEGASAS_SCSI_VARIABLE_LENGTH_CMD            0x7f
+#define MEGASAS_SCSI_SERVICE_ACTION_READ32          0x9
+#define MEGASAS_SCSI_SERVICE_ACTION_WRITE32         0xB
+#define MEGASAS_SCSI_ADDL_CDB_LEN                   0x18
+#define MEGASAS_RD_WR_PROTECT_CHECK_ALL             0x20
+#define MEGASAS_RD_WR_PROTECT_CHECK_NONE            0x60
+#define MEGASAS_EEDPBLOCKSIZE                       512
+
+/*
+ * Raid context flags
+ */
+
+#define MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT   0x4
+#define MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_MASK    0x30
+enum MR_RAID_FLAGS_IO_SUB_TYPE {
+        MR_RAID_FLAGS_IO_SUB_TYPE_NONE = 0,
+        MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD = 1,
+};
+
+/*
+ * Request descriptor types
+ */
+#define MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO           0x7
+#define MEGASAS_REQ_DESCRIPT_FLAGS_MFA             0x1
+
+#define MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT      1
+
+#define MEGASAS_FP_CMD_LEN      16
+#define MEGASAS_FUSION_IN_RESET 0
+
+/*
+ * Raid Context structure which describes MegaRAID specific IO Paramenters
+ * This resides at offset 0x60 where the SGL normally starts in MPT IO Frames
+ */
+
+struct RAID_CONTEXT {
+        u16     resvd0;
+        u16     timeoutValue;
+        u8      regLockFlags;
+        u8      resvd1;
+        u16     VirtualDiskTgtId;
+        u64     regLockRowLBA;
+        u32     regLockLength;
+        u16     nextLMId;
+        u8      exStatus;
+        u8      status;
+        u8      RAIDFlags;
+        u8      numSGE;
+        u16     configSeqNum;
+        u8      spanArm;
+        u8      resvd2[3];
+};
+
+#define RAID_CTX_SPANARM_ARM_SHIFT      (0)
+#define RAID_CTX_SPANARM_ARM_MASK       (0x1f)
+
+#define RAID_CTX_SPANARM_SPAN_SHIFT     (5)
+#define RAID_CTX_SPANARM_SPAN_MASK      (0xE0)
+
+/*
+ * define region lock types
+ */
+enum REGION_TYPE {
+        REGION_TYPE_UNUSED       = 0,
+        REGION_TYPE_SHARED_READ  = 1,
+        REGION_TYPE_SHARED_WRITE = 2,
+        REGION_TYPE_EXCLUSIVE    = 3,
+};
+
+/* MPI2 defines */
+#define MPI2_FUNCTION_IOC_INIT              (0x02) /* IOC Init */
+#define MPI2_WHOINIT_HOST_DRIVER            (0x04)
+#define MPI2_VERSION_MAJOR                  (0x02)
+#define MPI2_VERSION_MINOR                  (0x00)
+#define MPI2_VERSION_MAJOR_MASK             (0xFF00)
+#define MPI2_VERSION_MAJOR_SHIFT            (8)
+#define MPI2_VERSION_MINOR_MASK             (0x00FF)
+#define MPI2_VERSION_MINOR_SHIFT            (0)
+#define MPI2_VERSION ((MPI2_VERSION_MAJOR << MPI2_VERSION_MAJOR_SHIFT) | \
+                      MPI2_VERSION_MINOR)
+#define MPI2_HEADER_VERSION_UNIT            (0x10)
+#define MPI2_HEADER_VERSION_DEV             (0x00)
+#define MPI2_HEADER_VERSION_UNIT_MASK       (0xFF00)
+#define MPI2_HEADER_VERSION_UNIT_SHIFT      (8)
+#define MPI2_HEADER_VERSION_DEV_MASK        (0x00FF)
+#define MPI2_HEADER_VERSION_DEV_SHIFT       (0)
+#define MPI2_HEADER_VERSION ((MPI2_HEADER_VERSION_UNIT << 8) | \
+                             MPI2_HEADER_VERSION_DEV)
+#define MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR      (0x03)
+#define MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG        (0x8000)
+#define MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG          (0x0400)
+#define MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP       (0x0003)
+#define MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG          (0x0200)
+#define MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD           (0x0100)
+#define MPI2_SCSIIO_EEDPFLAGS_INSERT_OP             (0x0004)
+#define MPI2_FUNCTION_SCSI_IO_REQUEST               (0x00) /* SCSI IO */
+#define MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY           (0x06)
+#define MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO                 (0x00)
+#define MPI2_SGE_FLAGS_64_BIT_ADDRESSING        (0x02)
+#define MPI2_SCSIIO_CONTROL_WRITE               (0x01000000)
+#define MPI2_SCSIIO_CONTROL_READ                (0x02000000)
+#define MPI2_REQ_DESCRIPT_FLAGS_TYPE_MASK       (0x0E)
+#define MPI2_RPY_DESCRIPT_FLAGS_UNUSED          (0x0F)
+#define MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS (0x00)
+#define MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK       (0x0F)
+#define MPI2_WRSEQ_FLUSH_KEY_VALUE              (0x0)
+#define MPI2_WRITE_SEQUENCE_OFFSET              (0x00000004)
+#define MPI2_WRSEQ_1ST_KEY_VALUE                (0xF)
+#define MPI2_WRSEQ_2ND_KEY_VALUE                (0x4)
+#define MPI2_WRSEQ_3RD_KEY_VALUE                (0xB)
+#define MPI2_WRSEQ_4TH_KEY_VALUE                (0x2)
+#define MPI2_WRSEQ_5TH_KEY_VALUE                (0x7)
+#define MPI2_WRSEQ_6TH_KEY_VALUE                (0xD)
+
+struct MPI25_IEEE_SGE_CHAIN64 {
+        u64                     Address;
+        u32                     Length;
+        u16                     Reserved1;
+        u8                      NextChainOffset;
+        u8                      Flags;
+};
+
+struct MPI2_SGE_SIMPLE_UNION {
+        u32                     FlagsLength;
+        union {
+                u32                 Address32;
+                u64                 Address64;
+        } u;
+};
+
+struct MPI2_SCSI_IO_CDB_EEDP32 {
+        u8                      CDB[20];                    /* 0x00 */
+        u32                     PrimaryReferenceTag;        /* 0x14 */
+        u16                     PrimaryApplicationTag;      /* 0x18 */
+        u16                     PrimaryApplicationTagMask;  /* 0x1A */
+        u32                     TransferLength;             /* 0x1C */
+};
+
+struct MPI2_SGE_CHAIN_UNION {
+        u16                     Length;
+        u8                      NextChainOffset;
+        u8                      Flags;
+        union {
+                u32                 Address32;
+                u64                 Address64;
+        } u;
+};
+
+struct MPI2_IEEE_SGE_SIMPLE32 {
+        u32                     Address;
+        u32                     FlagsLength;
+};
+
+struct MPI2_IEEE_SGE_CHAIN32 {
+        u32                     Address;
+        u32                     FlagsLength;
+};
+
+struct MPI2_IEEE_SGE_SIMPLE64 {
+        u64                     Address;
+        u32                     Length;
+        u16                     Reserved1;
+        u8                      Reserved2;
+        u8                      Flags;
+};
+
+struct MPI2_IEEE_SGE_CHAIN64 {
+        u64                     Address;
+        u32                     Length;
+        u16                     Reserved1;
+        u8                      Reserved2;
+        u8                      Flags;
+};
+
+union MPI2_IEEE_SGE_SIMPLE_UNION {
+        struct MPI2_IEEE_SGE_SIMPLE32  Simple32;
+        struct MPI2_IEEE_SGE_SIMPLE64  Simple64;
+};
+
+union MPI2_IEEE_SGE_CHAIN_UNION {
+        struct MPI2_IEEE_SGE_CHAIN32   Chain32;
+        struct MPI2_IEEE_SGE_CHAIN64   Chain64;
+};
+
+union MPI2_SGE_IO_UNION {
+        struct MPI2_SGE_SIMPLE_UNION       MpiSimple;
+        struct MPI2_SGE_CHAIN_UNION        MpiChain;
+        union MPI2_IEEE_SGE_SIMPLE_UNION  IeeeSimple;
+        union MPI2_IEEE_SGE_CHAIN_UNION   IeeeChain;
+};
+
+union MPI2_SCSI_IO_CDB_UNION {
+        u8                      CDB32[32];
+        struct MPI2_SCSI_IO_CDB_EEDP32 EEDP32;
+        struct MPI2_SGE_SIMPLE_UNION SGE;
+};
+
+/*
+ * RAID SCSI IO Request Message
+ * Total SGE count will be one less than  _MPI2_SCSI_IO_REQUEST
+ */
+struct MPI2_RAID_SCSI_IO_REQUEST {
+        u16                     DevHandle;                      /* 0x00 */
+        u8                      ChainOffset;                    /* 0x02 */
+        u8                      Function;                       /* 0x03 */
+        u16                     Reserved1;                      /* 0x04 */
+        u8                      Reserved2;                      /* 0x06 */
+        u8                      MsgFlags;                       /* 0x07 */
+        u8                      VP_ID;                          /* 0x08 */
+        u8                      VF_ID;                          /* 0x09 */
+        u16                     Reserved3;                      /* 0x0A */
+        u32                     SenseBufferLowAddress;          /* 0x0C */
+        u16                     SGLFlags;                       /* 0x10 */
+        u8                      SenseBufferLength;              /* 0x12 */
+        u8                      Reserved4;                      /* 0x13 */
+        u8                      SGLOffset0;                     /* 0x14 */
+        u8                      SGLOffset1;                     /* 0x15 */
+        u8                      SGLOffset2;                     /* 0x16 */
+        u8                      SGLOffset3;                     /* 0x17 */
+        u32                     SkipCount;                      /* 0x18 */
+        u32                     DataLength;                     /* 0x1C */
+        u32                     BidirectionalDataLength;        /* 0x20 */
+        u16                     IoFlags;                        /* 0x24 */
+        u16                     EEDPFlags;                      /* 0x26 */
+        u32                     EEDPBlockSize;                  /* 0x28 */
+        u32                     SecondaryReferenceTag;          /* 0x2C */
+        u16                     SecondaryApplicationTag;        /* 0x30 */
+        u16                     ApplicationTagTranslationMask;  /* 0x32 */
+        u8                      LUN[8];                         /* 0x34 */
+        u32                     Control;                        /* 0x3C */
+        union MPI2_SCSI_IO_CDB_UNION  CDB;                      /* 0x40 */
+        struct RAID_CONTEXT     RaidContext;                    /* 0x60 */
+        union MPI2_SGE_IO_UNION       SGL;                      /* 0x80 */
+};
+
+/*
+ * MPT RAID MFA IO Descriptor.
+ */
+struct MEGASAS_RAID_MFA_IO_REQUEST_DESCRIPTOR {
+        u32     RequestFlags:8;
+        u32     MessageAddress1:24; /* bits 31:8*/
+        u32     MessageAddress2;      /* bits 61:32 */
+};
+
+/* Default Request Descriptor */
+struct MPI2_DEFAULT_REQUEST_DESCRIPTOR {
+        u8              RequestFlags;               /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u16             LMID;                       /* 0x04 */
+        u16             DescriptorTypeDependent;    /* 0x06 */
+};
+
+/* High Priority Request Descriptor */
+struct MPI2_HIGH_PRIORITY_REQUEST_DESCRIPTOR {
+        u8              RequestFlags;               /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u16             LMID;                       /* 0x04 */
+        u16             Reserved1;                  /* 0x06 */
+};
+
+/* SCSI IO Request Descriptor */
+struct MPI2_SCSI_IO_REQUEST_DESCRIPTOR {
+        u8              RequestFlags;               /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u16             LMID;                       /* 0x04 */
+        u16             DevHandle;                  /* 0x06 */
+};
+
+/* SCSI Target Request Descriptor */
+struct MPI2_SCSI_TARGET_REQUEST_DESCRIPTOR {
+        u8              RequestFlags;               /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u16             LMID;                       /* 0x04 */
+        u16             IoIndex;                    /* 0x06 */
+};
+
+/* RAID Accelerator Request Descriptor */
+struct MPI2_RAID_ACCEL_REQUEST_DESCRIPTOR {
+        u8              RequestFlags;               /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u16             LMID;                       /* 0x04 */
+        u16             Reserved;                   /* 0x06 */
+};
+
+/* union of Request Descriptors */
+union MEGASAS_REQUEST_DESCRIPTOR_UNION {
+        struct MPI2_DEFAULT_REQUEST_DESCRIPTOR             Default;
+        struct MPI2_HIGH_PRIORITY_REQUEST_DESCRIPTOR       HighPriority;
+        struct MPI2_SCSI_IO_REQUEST_DESCRIPTOR             SCSIIO;
+        struct MPI2_SCSI_TARGET_REQUEST_DESCRIPTOR         SCSITarget;
+        struct MPI2_RAID_ACCEL_REQUEST_DESCRIPTOR          RAIDAccelerator;
+        struct MEGASAS_RAID_MFA_IO_REQUEST_DESCRIPTOR      MFAIo;
+        union {
+                struct {
+                        u32 low;
+                        u32 high;
+                } u;
+                u64 Words;
+        };
+};
+
+/* Default Reply Descriptor */
+struct MPI2_DEFAULT_REPLY_DESCRIPTOR {
+        u8              ReplyFlags;                 /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             DescriptorTypeDependent1;   /* 0x02 */
+        u32             DescriptorTypeDependent2;   /* 0x04 */
+};
+
+/* Address Reply Descriptor */
+struct MPI2_ADDRESS_REPLY_DESCRIPTOR {
+        u8              ReplyFlags;                 /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u32             ReplyFrameAddress;          /* 0x04 */
+};
+
+/* SCSI IO Success Reply Descriptor */
+struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR {
+        u8              ReplyFlags;                 /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u16             TaskTag;                    /* 0x04 */
+        u16             Reserved1;                  /* 0x06 */
+};
+
+/* TargetAssist Success Reply Descriptor */
+struct MPI2_TARGETASSIST_SUCCESS_REPLY_DESCRIPTOR {
+        u8              ReplyFlags;                 /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u8              SequenceNumber;             /* 0x04 */
+        u8              Reserved1;                  /* 0x05 */
+        u16             IoIndex;                    /* 0x06 */
+};
+
+/* Target Command Buffer Reply Descriptor */
+struct MPI2_TARGET_COMMAND_BUFFER_REPLY_DESCRIPTOR {
+        u8              ReplyFlags;                 /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u8              VP_ID;                      /* 0x02 */
+        u8              Flags;                      /* 0x03 */
+        u16             InitiatorDevHandle;         /* 0x04 */
+        u16             IoIndex;                    /* 0x06 */
+};
+
+/* RAID Accelerator Success Reply Descriptor */
+struct MPI2_RAID_ACCELERATOR_SUCCESS_REPLY_DESCRIPTOR {
+        u8              ReplyFlags;                 /* 0x00 */
+        u8              MSIxIndex;                  /* 0x01 */
+        u16             SMID;                       /* 0x02 */
+        u32             Reserved;                   /* 0x04 */
+};
+
+/* union of Reply Descriptors */
+union MPI2_REPLY_DESCRIPTORS_UNION {
+        struct MPI2_DEFAULT_REPLY_DESCRIPTOR                   Default;
+        struct MPI2_ADDRESS_REPLY_DESCRIPTOR                   AddressReply;
+        struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR           SCSIIOSuccess;
+        struct MPI2_TARGETASSIST_SUCCESS_REPLY_DESCRIPTOR TargetAssistSuccess;
+        struct MPI2_TARGET_COMMAND_BUFFER_REPLY_DESCRIPTOR TargetCommandBuffer;
+        struct MPI2_RAID_ACCELERATOR_SUCCESS_REPLY_DESCRIPTOR
+        RAIDAcceleratorSuccess;
+        u64                                             Words;
+};
+
+/* IOCInit Request message */
+struct MPI2_IOC_INIT_REQUEST {
+        u8                      WhoInit;                        /* 0x00 */
+        u8                      Reserved1;                      /* 0x01 */
+        u8                      ChainOffset;                    /* 0x02 */
+        u8                      Function;                       /* 0x03 */
+        u16                     Reserved2;                      /* 0x04 */
+        u8                      Reserved3;                      /* 0x06 */
+        u8                      MsgFlags;                       /* 0x07 */
+        u8                      VP_ID;                          /* 0x08 */
+        u8                      VF_ID;                          /* 0x09 */
+        u16                     Reserved4;                      /* 0x0A */
+        u16                     MsgVersion;                     /* 0x0C */
+        u16                     HeaderVersion;                  /* 0x0E */
+        u32                     Reserved5;                      /* 0x10 */
+        u16                     Reserved6;                      /* 0x14 */
+        u8                      Reserved7;                      /* 0x16 */
+        u8                      HostMSIxVectors;                /* 0x17 */
+        u16                     Reserved8;                      /* 0x18 */
+        u16                     SystemRequestFrameSize;         /* 0x1A */
+        u16                     ReplyDescriptorPostQueueDepth;  /* 0x1C */
+        u16                     ReplyFreeQueueDepth;            /* 0x1E */
+        u32                     SenseBufferAddressHigh;         /* 0x20 */
+        u32                     SystemReplyAddressHigh;         /* 0x24 */
+        u64                     SystemRequestFrameBaseAddress;  /* 0x28 */
+        u64                     ReplyDescriptorPostQueueAddress;/* 0x30 */
+        u64                     ReplyFreeQueueAddress;          /* 0x38 */
+        u64                     TimeStamp;                      /* 0x40 */
+};
+
+/* mrpriv defines */
+#define MR_PD_INVALID 0xFFFF
+#define MAX_SPAN_DEPTH 8
+#define MAX_RAIDMAP_SPAN_DEPTH (MAX_SPAN_DEPTH)
+#define MAX_ROW_SIZE 32
+#define MAX_RAIDMAP_ROW_SIZE (MAX_ROW_SIZE)
+#define MAX_LOGICAL_DRIVES 64
+#define MAX_RAIDMAP_LOGICAL_DRIVES (MAX_LOGICAL_DRIVES)
+#define MAX_RAIDMAP_VIEWS (MAX_LOGICAL_DRIVES)
+#define MAX_ARRAYS 128
+#define MAX_RAIDMAP_ARRAYS (MAX_ARRAYS)
+#define MAX_PHYSICAL_DEVICES 256
+#define MAX_RAIDMAP_PHYSICAL_DEVICES (MAX_PHYSICAL_DEVICES)
+#define MR_DCMD_LD_MAP_GET_INFO             0x0300e101
+
+struct MR_DEV_HANDLE_INFO {
+        u16     curDevHdl;
+        u8      validHandles;
+        u8      reserved;
+        u16     devHandle[2];
+};
+
+struct MR_ARRAY_INFO {
+        u16      pd[MAX_RAIDMAP_ROW_SIZE];
+};
+
+struct MR_QUAD_ELEMENT {
+        u64     logStart;
+        u64     logEnd;
+        u64     offsetInSpan;
+        u32     diff;
+        u32     reserved1;
+};
+
+struct MR_SPAN_INFO {
+        u32             noElements;
+        u32             reserved1;
+        struct MR_QUAD_ELEMENT quad[MAX_RAIDMAP_SPAN_DEPTH];
+};
+
+struct MR_LD_SPAN {
+        u64      startBlk;
+        u64      numBlks;
+        u16      arrayRef;
+        u8       reserved[6];
+};
+
+struct MR_SPAN_BLOCK_INFO {
+        u64          num_rows;
+        struct MR_LD_SPAN   span;
+        struct MR_SPAN_INFO block_span_info;
+};
+
+struct MR_LD_RAID {
+        struct {
+                u32     fpCapable:1;
+                u32     reserved5:3;
+                u32     ldPiMode:4;
+                u32     pdPiMode:4;
+                u32     encryptionType:8;
+                u32     fpWriteCapable:1;
+                u32     fpReadCapable:1;
+                u32     fpWriteAcrossStripe:1;
+                u32     fpReadAcrossStripe:1;
+                u32     reserved4:8;
+        } capability;
+        u32     reserved6;
+        u64     size;
+        u8      spanDepth;
+        u8      level;
+        u8      stripeShift;
+        u8      rowSize;
+        u8      rowDataSize;
+        u8      writeMode;
+        u8      PRL;
+        u8      SRL;
+        u16     targetId;
+        u8      ldState;
+        u8      regTypeReqOnWrite;
+        u8      modFactor;
+        u8      reserved2[1];
+        u16     seqNum;
+
+        struct {
+                u32 ldSyncRequired:1;
+                u32 reserved:31;
+        } flags;
+
+        u8      reserved3[0x5C];
+};
+
+struct MR_LD_SPAN_MAP {
+        struct MR_LD_RAID          ldRaid;
+        u8                  dataArmMap[MAX_RAIDMAP_ROW_SIZE];
+        struct MR_SPAN_BLOCK_INFO  spanBlock[MAX_RAIDMAP_SPAN_DEPTH];
+};
+
+struct MR_FW_RAID_MAP {
+        u32                 totalSize;
+        union {
+                struct {
+                        u32         maxLd;
+                        u32         maxSpanDepth;
+                        u32         maxRowSize;
+                        u32         maxPdCount;
+                        u32         maxArrays;
+                } validationInfo;
+                u32             version[5];
+                u32             reserved1[5];
+        };
+
+        u32                 ldCount;
+        u32                 Reserved1;
+        u8                  ldTgtIdToLd[MAX_RAIDMAP_LOGICAL_DRIVES+
+                                        MAX_RAIDMAP_VIEWS];
+        u8                  fpPdIoTimeoutSec;
+        u8                  reserved2[7];
+        struct MR_ARRAY_INFO       arMapInfo[MAX_RAIDMAP_ARRAYS];
+        struct MR_DEV_HANDLE_INFO  devHndlInfo[MAX_RAIDMAP_PHYSICAL_DEVICES];
+        struct MR_LD_SPAN_MAP      ldSpanMap[1];
+};
+
+struct IO_REQUEST_INFO {
+        u64 ldStartBlock;
+        u32 numBlocks;
+        u16 ldTgtId;
+        u8 isRead;
+        u16 devHandle;
+        u64 pdBlock;
+        u8 fpOkForIo;
+};
+
+struct MR_LD_TARGET_SYNC {
+        u8  targetId;
+        u8  reserved;
+        u16 seqNum;
+};
+
+#define IEEE_SGE_FLAGS_ADDR_MASK            (0x03)
+#define IEEE_SGE_FLAGS_SYSTEM_ADDR          (0x00)
+#define IEEE_SGE_FLAGS_IOCDDR_ADDR          (0x01)
+#define IEEE_SGE_FLAGS_IOCPLB_ADDR          (0x02)
+#define IEEE_SGE_FLAGS_IOCPLBNTA_ADDR       (0x03)
+#define IEEE_SGE_FLAGS_CHAIN_ELEMENT        (0x80)
+#define IEEE_SGE_FLAGS_END_OF_LIST          (0x40)
+
+struct megasas_register_set;
+struct megasas_instance;
+
+union desc_word {
+        u64 word;
+        struct {
+                u32 low;
+                u32 high;
+        } u;
+};
+
+struct megasas_cmd_fusion {
+        struct MPI2_RAID_SCSI_IO_REQUEST        *io_request;
+        dma_addr_t                      io_request_phys_addr;
+
+        union MPI2_SGE_IO_UNION *sg_frame;
+        dma_addr_t              sg_frame_phys_addr;
+
+        u8 *sense;
+        dma_addr_t sense_phys_addr;
+
+        struct list_head list;
+        struct scsi_cmnd *scmd;
+        struct megasas_instance *instance;
+
+        u8 retry_for_fw_reset;
+        union MEGASAS_REQUEST_DESCRIPTOR_UNION  *request_desc;
+
+        /*
+         * Context for a MFI frame.
+         * Used to get the mfi cmd from list when a MFI cmd is completed
+         */
+        u32 sync_cmd_idx;
+        u32 index;
+        u8 flags;
+};
+
+struct LD_LOAD_BALANCE_INFO {
+        u8      loadBalanceFlag;
+        u8      reserved1;
+        u16     raid1DevHandle[2];
+        atomic_t     scsi_pending_cmds[2];
+        u64     last_accessed_block[2];
+};
+
+struct MR_FW_RAID_MAP_ALL {
+        struct MR_FW_RAID_MAP raidMap;
+        struct MR_LD_SPAN_MAP ldSpanMap[MAX_LOGICAL_DRIVES - 1];
+} __attribute__ ((packed));
+
+struct fusion_context {
+        struct megasas_cmd_fusion **cmd_list;
+        struct list_head cmd_pool;
+
+        spinlock_t cmd_pool_lock;
+
+        dma_addr_t req_frames_desc_phys;
+        u8 *req_frames_desc;
+
+        struct dma_pool *io_request_frames_pool;
+        dma_addr_t io_request_frames_phys;
+        u8 *io_request_frames;
+
+        struct dma_pool *sg_dma_pool;
+        struct dma_pool *sense_dma_pool;
+
+        dma_addr_t reply_frames_desc_phys;
+        union MPI2_REPLY_DESCRIPTORS_UNION *reply_frames_desc;
+        struct dma_pool *reply_frames_desc_pool;
+
+        u16 last_reply_idx;
+
+        u32 reply_q_depth;
+        u32 request_alloc_sz;
+        u32 reply_alloc_sz;
+        u32 io_frames_alloc_sz;
+
+        u16     max_sge_in_main_msg;
+        u16     max_sge_in_chain;
+
+        u8      chain_offset_io_request;
+        u8      chain_offset_mfi_pthru;
+
+        struct MR_FW_RAID_MAP_ALL *ld_map[2];
+        dma_addr_t ld_map_phys[2];
+
+        u32 map_sz;
+        u8 fast_path_io;
+        struct LD_LOAD_BALANCE_INFO load_balance_info[MAX_LOGICAL_DRIVES];
+};
+
+union desc_value {
+        u64 word;
+        struct {
+                u32 low;
+                u32 high;
+        } u;
+};
+
+#endif /* _MEGARAID_SAS_FUSION_H_ */
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2.h b/drivers/scsi/mpt2sas/mpi/mpi2.h
index 4b1c2f0350f9..8be75e65f763 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2.h
@@ -8,7 +8,7 @@
  *                  scatter/gather formats.
  *  Creation Date:  June 21, 2006
  *
- *  mpi2.h Version:  02.00.15
+ *  mpi2.h Version:  02.00.16
  *
  *  Version History
  *  ---------------
@@ -61,6 +61,8 @@
  *                      Added define for MPI2_FUNCTION_PWR_MGMT_CONTROL.
  *                      Added defines for product-specific range of message
  *                      function codes, 0xF0 to 0xFF.
+ *  05-12-10  02.00.16  Bumped MPI2_HEADER_VERSION_UNIT.
+ *                      Added alternative defines for the SGE Direction bit.
  *  --------------------------------------------------------------------------
  */
 
@@ -86,7 +88,7 @@
 #define MPI2_VERSION_02_00                  (0x0200)
 
 /* versioning for this MPI header set */
-#define MPI2_HEADER_VERSION_UNIT            (0x0F)
+#define MPI2_HEADER_VERSION_UNIT            (0x10)
 #define MPI2_HEADER_VERSION_DEV             (0x00)
 #define MPI2_HEADER_VERSION_UNIT_MASK       (0xFF00)
 #define MPI2_HEADER_VERSION_UNIT_SHIFT      (8)
@@ -929,6 +931,9 @@ typedef struct _MPI2_MPI_SGE_UNION
 #define MPI2_SGE_FLAGS_IOC_TO_HOST              (0x00)
 #define MPI2_SGE_FLAGS_HOST_TO_IOC              (0x04)
 
+#define MPI2_SGE_FLAGS_DEST                     (MPI2_SGE_FLAGS_IOC_TO_HOST)
+#define MPI2_SGE_FLAGS_SOURCE                   (MPI2_SGE_FLAGS_HOST_TO_IOC)
+
 /* Address Size */
 
 #define MPI2_SGE_FLAGS_32_BIT_ADDRESSING        (0x00)
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
index e3728d736d85..d76a65847603 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Configuration messages and pages
  *  Creation Date:  November 10, 2006
  *
- *    mpi2_cnfg.h Version:  02.00.14
+ *    mpi2_cnfg.h Version:  02.00.15
  *
  *  Version History
  *  ---------------
@@ -121,6 +121,10 @@
  *                      Added MPI2_CONFIG_PAGE_SASIOUNIT_6 and related defines.
  *                      Added MPI2_CONFIG_PAGE_SASIOUNIT_7 and related defines.
  *                      Added MPI2_CONFIG_PAGE_SASIOUNIT_8 and related defines.
+ *  05-12-10  02.00.15  Added MPI2_RAIDVOL0_STATUS_FLAG_VOL_NOT_CONSISTENT
+ *                      define.
+ *                      Added MPI2_PHYSDISK0_INCOMPATIBLE_MEDIA_TYPE define.
+ *                      Added MPI2_SAS_NEG_LINK_RATE_UNSUPPORTED_PHY define.
  *  --------------------------------------------------------------------------
  */
 
@@ -333,7 +337,7 @@ typedef struct _MPI2_CONFIG_REQUEST
 #define MPI2_CONFIG_ACTION_PAGE_READ_NVRAM          (0x06)
 #define MPI2_CONFIG_ACTION_PAGE_GET_CHANGEABLE      (0x07)
 
-/* values for SGLFlags field are in the SGL section of mpi2.h */
+/* use MPI2_SGLFLAGS_ defines from mpi2.h for the SGLFlags field */
 
 
 /* Config Reply Message */
@@ -379,6 +383,8 @@ typedef struct _MPI2_CONFIG_REPLY
 #define MPI2_MFGPAGE_DEVID_SAS2116_1                (0x0064)
 #define MPI2_MFGPAGE_DEVID_SAS2116_2                (0x0065)
 
+#define MPI2_MFGPAGE_DEVID_SSS6200                  (0x007E)
+
 #define MPI2_MFGPAGE_DEVID_SAS2208_1                (0x0080)
 #define MPI2_MFGPAGE_DEVID_SAS2208_2                (0x0081)
 #define MPI2_MFGPAGE_DEVID_SAS2208_3                (0x0082)
@@ -390,6 +396,8 @@ typedef struct _MPI2_CONFIG_REPLY
 #define MPI2_MFGPAGE_DEVID_SAS2308_3                (0x006E)
 
 
+
+
 /* Manufacturing Page 0 */
 
 typedef struct _MPI2_CONFIG_PAGE_MAN_0
@@ -729,6 +737,7 @@ typedef struct _MPI2_CONFIG_PAGE_IO_UNIT_1
 /* IO Unit Page 1 Flags defines */
 #define MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY    (0x00000800)
 #define MPI2_IOUNITPAGE1_MASK_SATA_WRITE_CACHE          (0x00000600)
+#define MPI2_IOUNITPAGE1_SATA_WRITE_CACHE_SHIFT         (9)
 #define MPI2_IOUNITPAGE1_ENABLE_SATA_WRITE_CACHE        (0x00000000)
 #define MPI2_IOUNITPAGE1_DISABLE_SATA_WRITE_CACHE       (0x00000200)
 #define MPI2_IOUNITPAGE1_UNCHANGED_SATA_WRITE_CACHE     (0x00000400)
@@ -1347,6 +1356,7 @@ typedef struct _MPI2_CONFIG_PAGE_RAID_VOL_0
 #define MPI2_RAIDVOL0_STATUS_FLAG_CAPACITY_EXPANSION        (0x00040000)
 #define MPI2_RAIDVOL0_STATUS_FLAG_BACKGROUND_INIT           (0x00020000)
 #define MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS        (0x00010000)
+#define MPI2_RAIDVOL0_STATUS_FLAG_VOL_NOT_CONSISTENT        (0x00000080)
 #define MPI2_RAIDVOL0_STATUS_FLAG_OCE_ALLOWED               (0x00000040)
 #define MPI2_RAIDVOL0_STATUS_FLAG_BGI_COMPLETE              (0x00000020)
 #define MPI2_RAIDVOL0_STATUS_FLAG_1E_OFFSET_MIRROR          (0x00000000)
@@ -1469,11 +1479,15 @@ typedef struct _MPI2_CONFIG_PAGE_RD_PDISK_0
 #define MPI2_PHYSDISK0_INCOMPATIBLE_MAX_LBA             (0x03)
 #define MPI2_PHYSDISK0_INCOMPATIBLE_SATA_EXTENDED_CMD   (0x04)
 #define MPI2_PHYSDISK0_INCOMPATIBLE_REMOVEABLE_MEDIA    (0x05)
+#define MPI2_PHYSDISK0_INCOMPATIBLE_MEDIA_TYPE          (0x06)
 #define MPI2_PHYSDISK0_INCOMPATIBLE_UNKNOWN             (0xFF)
 
 /* PhysDiskAttributes defines */
+#define MPI2_PHYSDISK0_ATTRIB_MEDIA_MASK                (0x0C)
 #define MPI2_PHYSDISK0_ATTRIB_SOLID_STATE_DRIVE         (0x08)
 #define MPI2_PHYSDISK0_ATTRIB_HARD_DISK_DRIVE           (0x04)
+
+#define MPI2_PHYSDISK0_ATTRIB_PROTOCOL_MASK             (0x03)
 #define MPI2_PHYSDISK0_ATTRIB_SAS_PROTOCOL              (0x02)
 #define MPI2_PHYSDISK0_ATTRIB_SATA_PROTOCOL             (0x01)
 
@@ -1545,6 +1559,7 @@ typedef struct _MPI2_CONFIG_PAGE_RD_PDISK_1
 #define MPI2_SAS_NEG_LINK_RATE_SATA_OOB_COMPLETE        (0x03)
 #define MPI2_SAS_NEG_LINK_RATE_PORT_SELECTOR            (0x04)
 #define MPI2_SAS_NEG_LINK_RATE_SMP_RESET_IN_PROGRESS    (0x05)
+#define MPI2_SAS_NEG_LINK_RATE_UNSUPPORTED_PHY          (0x06)
 #define MPI2_SAS_NEG_LINK_RATE_1_5                      (0x08)
 #define MPI2_SAS_NEG_LINK_RATE_3_0                      (0x09)
 #define MPI2_SAS_NEG_LINK_RATE_6_0                      (0x0A)
@@ -1571,6 +1586,7 @@ typedef struct _MPI2_CONFIG_PAGE_RD_PDISK_1
 #define MPI2_SAS_PHYINFO_PHY_VACANT                     (0x80000000)
 
 #define MPI2_SAS_PHYINFO_PHY_POWER_CONDITION_MASK       (0x18000000)
+#define MPI2_SAS_PHYINFO_SHIFT_PHY_POWER_CONDITION      (27)
 #define MPI2_SAS_PHYINFO_PHY_POWER_ACTIVE               (0x00000000)
 #define MPI2_SAS_PHYINFO_PHY_POWER_PARTIAL              (0x08000000)
 #define MPI2_SAS_PHYINFO_PHY_POWER_SLUMBER              (0x10000000)
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_history.txt b/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
index bd6c92b5fae5..b1e88f26b748 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
@@ -291,6 +291,7 @@ mpi2_raid.h
  *                      can be sized by the build environment.
  *  07-30-09  02.00.04  Added proper define for the Use Default Settings bit of
  *                      VolumeCreationFlags and marked the old one as obsolete.
+ *  05-12-10  02.00.05  Added MPI2_RAID_VOL_FLAGS_OP_MDC define.
  *  --------------------------------------------------------------------------
 
 mpi2_sas.h
@@ -301,6 +302,7 @@ mpi2_sas.h
  *                      Request.
  *  10-28-09  02.00.03  Changed the type of SGL in MPI2_SATA_PASSTHROUGH_REQUEST
  *                      to MPI2_SGE_IO_UNION since it supports chained SGLs.
+ *  05-12-10  02.00.04  Modified some comments.
  *  --------------------------------------------------------------------------
 
 mpi2_targ.h
@@ -324,6 +326,7 @@ mpi2_tool.h
  *                      and reply messages.
  *                      Added MPI2_DIAG_BUF_TYPE_EXTENDED.
  *                      Incremented MPI2_DIAG_BUF_TYPE_COUNT.
+ *  05-12-10  02.00.05  Added Diagnostic Data Upload tool.
  *  --------------------------------------------------------------------------
 
 mpi2_type.h
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_init.h b/drivers/scsi/mpt2sas/mpi/mpi2_init.h
index c4c99dfcb820..20e6b8869341 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_init.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_init.h
@@ -6,7 +6,7 @@
  *          Title:  MPI SCSI initiator mode messages and structures
  *  Creation Date:  June 23, 2006
  *
- *    mpi2_init.h Version:  02.00.09
+ *    mpi2_init.h Version:  02.00.10
  *
  *  Version History
  *  ---------------
@@ -32,6 +32,7 @@
  *                      Added ResponseInfo field to MPI2_SCSI_TASK_MANAGE_REPLY.
  *                      Added MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG define.
  *  02-10-10  02.00.09  Removed unused structure that had "#if 0" around it.
+ *  05-12-10  02.00.10  Added optional vendor-unique region to SCSI IO Request.
  *  --------------------------------------------------------------------------
  */
 
@@ -98,7 +99,13 @@ typedef struct _MPI2_SCSI_IO_REQUEST
     U8                      LUN[8];                         /* 0x34 */
     U32                     Control;                        /* 0x3C */
     MPI2_SCSI_IO_CDB_UNION  CDB;                            /* 0x40 */
+
+#ifdef MPI2_SCSI_IO_VENDOR_UNIQUE_REGION /* typically this is left undefined */
+        MPI2_SCSI_IO_VENDOR_UNIQUE VendorRegion;
+#endif
+
     MPI2_SGE_IO_UNION       SGL;                            /* 0x60 */
+
 } MPI2_SCSI_IO_REQUEST, MPI2_POINTER PTR_MPI2_SCSI_IO_REQUEST,
   Mpi2SCSIIORequest_t, MPI2_POINTER pMpi2SCSIIORequest_t;
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
index 495bedc4d1f7..761cbdb8a033 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
@@ -6,7 +6,7 @@
  *          Title:  MPI IOC, Port, Event, FW Download, and FW Upload messages
  *  Creation Date:  October 11, 2006
  *
- *  mpi2_ioc.h Version:  02.00.14
+ *  mpi2_ioc.h Version:  02.00.15
  *
  *  Version History
  *  ---------------
@@ -101,6 +101,8 @@
  *  02-10-10  02.00.14  Added SAS Quiesce Event structure and defines.
  *                      Added PowerManagementControl Request structures and
  *                      defines.
+ *  05-12-10  02.00.15  Marked Task Set Full Event as obsolete.
+ *                      Added MPI2_EVENT_SAS_TOPO_LR_UNSUPPORTED_PHY define.
  *  --------------------------------------------------------------------------
  */
 
@@ -456,7 +458,7 @@ typedef struct _MPI2_EVENT_NOTIFICATION_REPLY
 #define MPI2_EVENT_STATE_CHANGE                     (0x0002)
 #define MPI2_EVENT_HARD_RESET_RECEIVED              (0x0005)
 #define MPI2_EVENT_EVENT_CHANGE                     (0x000A)
-#define MPI2_EVENT_TASK_SET_FULL                    (0x000E)
+#define MPI2_EVENT_TASK_SET_FULL                    (0x000E) /* obsolete */
 #define MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE         (0x000F)
 #define MPI2_EVENT_IR_OPERATION_STATUS              (0x0014)
 #define MPI2_EVENT_SAS_DISCOVERY                    (0x0016)
@@ -517,6 +519,7 @@ typedef struct _MPI2_EVENT_DATA_HARD_RESET_RECEIVED
   MPI2_POINTER pMpi2EventDataHardResetReceived_t;
 
 /* Task Set Full Event data */
+/*   this event is obsolete */
 
 typedef struct _MPI2_EVENT_DATA_TASK_SET_FULL
 {
@@ -831,6 +834,7 @@ typedef struct _MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST
 #define MPI2_EVENT_SAS_TOPO_LR_SATA_OOB_COMPLETE            (0x03)
 #define MPI2_EVENT_SAS_TOPO_LR_PORT_SELECTOR                (0x04)
 #define MPI2_EVENT_SAS_TOPO_LR_SMP_RESET_IN_PROGRESS        (0x05)
+#define MPI2_EVENT_SAS_TOPO_LR_UNSUPPORTED_PHY              (0x06)
 #define MPI2_EVENT_SAS_TOPO_LR_RATE_1_5                     (0x08)
 #define MPI2_EVENT_SAS_TOPO_LR_RATE_3_0                     (0x09)
 #define MPI2_EVENT_SAS_TOPO_LR_RATE_6_0                     (0x0A)
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_raid.h b/drivers/scsi/mpt2sas/mpi/mpi2_raid.h
index 5160c33d2a00..bd61a7b60a2b 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_raid.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_raid.h
@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2000-2008 LSI Corporation.
+ *  Copyright (c) 2000-2010 LSI Corporation.
  *
  *
  *           Name:  mpi2_raid.h
  *          Title:  MPI Integrated RAID messages and structures
  *  Creation Date:  April 26, 2007
  *
- *    mpi2_raid.h Version:  02.00.04
+ *    mpi2_raid.h Version:  02.00.05
  *
  *  Version History
  *  ---------------
@@ -22,6 +22,7 @@
  *                      can be sized by the build environment.
  *  07-30-09  02.00.04  Added proper define for the Use Default Settings bit of
  *                      VolumeCreationFlags and marked the old one as obsolete.
+ *  05-12-10  02.00.05  Added MPI2_RAID_VOL_FLAGS_OP_MDC define.
  *  --------------------------------------------------------------------------
  */
 
@@ -260,6 +261,7 @@ typedef struct _MPI2_RAID_VOL_INDICATOR
 #define MPI2_RAID_VOL_FLAGS_OP_ONLINE_CAP_EXPANSION (0x00000001)
 #define MPI2_RAID_VOL_FLAGS_OP_CONSISTENCY_CHECK    (0x00000002)
 #define MPI2_RAID_VOL_FLAGS_OP_RESYNC               (0x00000003)
+#define MPI2_RAID_VOL_FLAGS_OP_MDC                  (0x00000004)
 
 
 /* RAID Action Reply ActionData union */
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_sas.h b/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
index 2d8aeed51392..608f6d6e6fca 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2000-2007 LSI Corporation.
+ *  Copyright (c) 2000-2010 LSI Corporation.
  *
  *
  *           Name:  mpi2_sas.h
  *          Title:  MPI Serial Attached SCSI structures and definitions
  *  Creation Date:  February 9, 2007
  *
- *  mpi2.h Version:  02.00.03
+ *  mpi2_sas.h Version:  02.00.04
  *
  *  Version History
  *  ---------------
@@ -20,6 +20,7 @@
  *                      Request.
  *  10-28-09  02.00.03  Changed the type of SGL in MPI2_SATA_PASSTHROUGH_REQUEST
  *                      to MPI2_SGE_IO_UNION since it supports chained SGLs.
+ *  05-12-10  02.00.04  Modified some comments.
  *  --------------------------------------------------------------------------
  */
 
@@ -110,7 +111,7 @@ typedef struct _MPI2_SMP_PASSTHROUGH_REQUEST
 /* values for PassthroughFlags field */
 #define MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE      (0x80)
 
-/* values for SGLFlags field are in the SGL section of mpi2.h */
+/* use MPI2_SGLFLAGS_ defines from mpi2.h for the SGLFlags field */
 
 
 /* SMP Passthrough Reply Message */
@@ -174,7 +175,7 @@ typedef struct _MPI2_SATA_PASSTHROUGH_REQUEST
 #define MPI2_SATA_PT_REQ_PT_FLAGS_WRITE             (0x0002)
 #define MPI2_SATA_PT_REQ_PT_FLAGS_READ              (0x0001)
 
-/* values for SGLFlags field are in the SGL section of mpi2.h */
+/* use MPI2_SGLFLAGS_ defines from mpi2.h for the SGLFlags field */
 
 
 /* SATA Passthrough Reply Message */
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_tool.h b/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
index 686b09b81219..5c6e3a67bb94 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
@@ -6,7 +6,7 @@
  *          Title:  MPI diagnostic tool structures and definitions
  *  Creation Date:  March 26, 2007
  *
- *    mpi2_tool.h Version:  02.00.04
+ *    mpi2_tool.h Version:  02.00.05
  *
  *  Version History
  *  ---------------
@@ -22,6 +22,7 @@
  *                      and reply messages.
  *                      Added MPI2_DIAG_BUF_TYPE_EXTENDED.
  *                      Incremented MPI2_DIAG_BUF_TYPE_COUNT.
+ *  05-12-10  02.00.05  Added Diagnostic Data Upload tool.
  *  --------------------------------------------------------------------------
  */
 
@@ -37,6 +38,7 @@
 /* defines for the Tools */
 #define MPI2_TOOLBOX_CLEAN_TOOL                     (0x00)
 #define MPI2_TOOLBOX_MEMORY_MOVE_TOOL               (0x01)
+#define MPI2_TOOLBOX_DIAG_DATA_UPLOAD_TOOL          (0x02)
 #define MPI2_TOOLBOX_ISTWI_READ_WRITE_TOOL          (0x03)
 #define MPI2_TOOLBOX_BEACON_TOOL                    (0x05)
 #define MPI2_TOOLBOX_DIAGNOSTIC_CLI_TOOL            (0x06)
@@ -102,8 +104,7 @@ typedef struct _MPI2_TOOLBOX_CLEAN_REQUEST
 *  Toolbox Memory Move request
 ****************************************************************************/
 
-typedef struct _MPI2_TOOLBOX_MEM_MOVE_REQUEST
-{
+typedef struct _MPI2_TOOLBOX_MEM_MOVE_REQUEST {
     U8                      Tool;                       /* 0x00 */
     U8                      Reserved1;                  /* 0x01 */
     U8                      ChainOffset;                /* 0x02 */
@@ -120,6 +121,44 @@ typedef struct _MPI2_TOOLBOX_MEM_MOVE_REQUEST
 
 
 /****************************************************************************
+*  Toolbox Diagnostic Data Upload request
+****************************************************************************/
+
+typedef struct _MPI2_TOOLBOX_DIAG_DATA_UPLOAD_REQUEST {
+        U8                      Tool;                       /* 0x00 */
+        U8                      Reserved1;                  /* 0x01 */
+        U8                      ChainOffset;                /* 0x02 */
+        U8                      Function;                   /* 0x03 */
+        U16                     Reserved2;                  /* 0x04 */
+        U8                      Reserved3;                  /* 0x06 */
+        U8                      MsgFlags;                   /* 0x07 */
+        U8                      VP_ID;                      /* 0x08 */
+        U8                      VF_ID;                      /* 0x09 */
+        U16                     Reserved4;                  /* 0x0A */
+        U8                      SGLFlags;                   /* 0x0C */
+        U8                      Reserved5;                  /* 0x0D */
+        U16                     Reserved6;                  /* 0x0E */
+        U32                     Flags;                      /* 0x10 */
+        U32                     DataLength;                 /* 0x14 */
+        MPI2_SGE_SIMPLE_UNION   SGL;                        /* 0x18 */
+} MPI2_TOOLBOX_DIAG_DATA_UPLOAD_REQUEST,
+MPI2_POINTER PTR_MPI2_TOOLBOX_DIAG_DATA_UPLOAD_REQUEST,
+Mpi2ToolboxDiagDataUploadRequest_t,
+MPI2_POINTER pMpi2ToolboxDiagDataUploadRequest_t;
+
+/* use MPI2_SGLFLAGS_ defines from mpi2.h for the SGLFlags field */
+
+
+typedef struct _MPI2_DIAG_DATA_UPLOAD_HEADER {
+        U32                     DiagDataLength;             /* 00h */
+        U8                      FormatCode;                 /* 04h */
+        U8                      Reserved1;                  /* 05h */
+        U16                     Reserved2;                  /* 06h */
+} MPI2_DIAG_DATA_UPLOAD_HEADER, MPI2_POINTER PTR_MPI2_DIAG_DATA_UPLOAD_HEADER,
+Mpi2DiagDataUploadHeader_t, MPI2_POINTER pMpi2DiagDataUploadHeader_t;
+
+
+/****************************************************************************
 *  Toolbox ISTWI Read Write Tool
 ****************************************************************************/
 
@@ -162,7 +201,7 @@ typedef struct _MPI2_TOOLBOX_ISTWI_READ_WRITE_REQUEST {
 #define MPI2_TOOL_ISTWI_ACTION_RELEASE_BUS          (0x11)
 #define MPI2_TOOL_ISTWI_ACTION_RESET                (0x12)
 
-/* values for SGLFlags field are in the SGL section of mpi2.h */
+/* use MPI2_SGLFLAGS_ defines from mpi2.h for the SGLFlags field */
 
 
 /* Toolbox ISTWI Read Write Tool reply message */
@@ -248,7 +287,7 @@ typedef struct _MPI2_TOOLBOX_DIAGNOSTIC_CLI_REQUEST {
   Mpi2ToolboxDiagnosticCliRequest_t,
   MPI2_POINTER pMpi2ToolboxDiagnosticCliRequest_t;
 
-/* values for SGLFlags field are in the SGL section of mpi2.h */
+/* use MPI2_SGLFLAGS_ defines from mpi2.h for the SGLFlags field */
 
 
 /* Toolbox Diagnostic CLI Tool reply message */
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 12faf64f91b0..b2a817055b8b 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -65,7 +65,6 @@
 static MPT_CALLBACK     mpt_callbacks[MPT_MAX_CALLBACKS];
 
 #define FAULT_POLLING_INTERVAL 1000 /* in milliseconds */
-#define MPT2SAS_MAX_REQUEST_QUEUE 600 /* maximum controller queue depth */
 
 static int max_queue_depth = -1;
 module_param(max_queue_depth, int, 0);
@@ -79,6 +78,10 @@ static int msix_disable = -1;
 module_param(msix_disable, int, 0);
 MODULE_PARM_DESC(msix_disable, " disable msix routed interrupts (default=0)");
 
+static int missing_delay[2] = {-1, -1};
+module_param_array(missing_delay, int, NULL, 0);
+MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay");
+
 /* diag_buffer_enable is bitwise
  * bit 0 set = TRACE
  * bit 1 set = SNAPSHOT
@@ -515,9 +518,6 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
         case MPI2_EVENT_EVENT_CHANGE:
                 desc = "Event Change";
                 break;
-        case MPI2_EVENT_TASK_SET_FULL:
-                desc = "Task Set Full";
-                break;
         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
                 desc = "Device Status Change";
                 break;
@@ -758,7 +758,7 @@ _base_get_cb_idx(struct MPT2SAS_ADAPTER *ioc, u16 smid)
                 if (smid < ioc->internal_smid) {
                         i = smid - ioc->hi_priority_smid;
                         cb_idx = ioc->hpr_lookup[i].cb_idx;
-                } else {
+                } else if (smid <= ioc->hba_queue_depth)  {
                         i = smid - ioc->internal_smid;
                         cb_idx = ioc->internal_lookup[i].cb_idx;
                 }
@@ -848,6 +848,7 @@ _base_interrupt(int irq, void *bus_id)
                 return IRQ_NONE;
 
         completed_cmds = 0;
+        cb_idx = 0xFF;
         do {
                 rd.word = rpf->Words;
                 if (rd.u.low == UINT_MAX || rd.u.high == UINT_MAX)
@@ -860,6 +861,9 @@ _base_interrupt(int irq, void *bus_id)
                     MPI2_RPY_DESCRIPT_FLAGS_ADDRESS_REPLY) {
                         reply = le32_to_cpu
                                 (rpf->AddressReply.ReplyFrameAddress);
+                        if (reply > ioc->reply_dma_max_address ||
+                            reply < ioc->reply_dma_min_address)
+                                reply = 0;
                 } else if (request_desript_type ==
                     MPI2_RPY_DESCRIPT_FLAGS_TARGET_COMMAND_BUFFER)
                         goto next;
@@ -1489,6 +1493,7 @@ mpt2sas_base_free_smid(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
         unsigned long flags;
         int i;
+        struct chain_tracker *chain_req, *next;
 
         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
         if (smid >= ioc->hi_priority_smid) {
@@ -1511,6 +1516,14 @@ mpt2sas_base_free_smid(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 
         /* scsiio queue */
         i = smid - 1;
+        if (!list_empty(&ioc->scsi_lookup[i].chain_list)) {
+                list_for_each_entry_safe(chain_req, next,
+                    &ioc->scsi_lookup[i].chain_list, tracker_list) {
+                        list_del_init(&chain_req->tracker_list);
+                        list_add_tail(&chain_req->tracker_list,
+                            &ioc->free_chain_list);
+                }
+        }
         ioc->scsi_lookup[i].cb_idx = 0xFF;
         ioc->scsi_lookup[i].scmd = NULL;
         list_add_tail(&ioc->scsi_lookup[i].tracker_list,
@@ -1819,6 +1832,97 @@ _base_display_ioc_capabilities(struct MPT2SAS_ADAPTER *ioc)
 }
 
 /**
+ * _base_update_missing_delay - change the missing delay timers
+ * @ioc: per adapter object
+ * @device_missing_delay: amount of time till device is reported missing
+ * @io_missing_delay: interval IO is returned when there is a missing device
+ *
+ * Return nothing.
+ *
+ * Passed on the command line, this function will modify the device missing
+ * delay, as well as the io missing delay. This should be called at driver
+ * load time.
+ */
+static void
+_base_update_missing_delay(struct MPT2SAS_ADAPTER *ioc,
+        u16 device_missing_delay, u8 io_missing_delay)
+{
+        u16 dmd, dmd_new, dmd_orignal;
+        u8 io_missing_delay_original;
+        u16 sz;
+        Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
+        Mpi2ConfigReply_t mpi_reply;
+        u8 num_phys = 0;
+        u16 ioc_status;
+
+        mpt2sas_config_get_number_hba_phys(ioc, &num_phys);
+        if (!num_phys)
+                return;
+
+        sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (num_phys *
+            sizeof(Mpi2SasIOUnit1PhyData_t));
+        sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
+        if (!sas_iounit_pg1) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+        if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
+            sas_iounit_pg1, sz))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+
+        /* device missing delay */
+        dmd = sas_iounit_pg1->ReportDeviceMissingDelay;
+        if (dmd & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
+                dmd = (dmd & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
+        else
+                dmd = dmd & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
+        dmd_orignal = dmd;
+        if (device_missing_delay > 0x7F) {
+                dmd = (device_missing_delay > 0x7F0) ? 0x7F0 :
+                    device_missing_delay;
+                dmd = dmd / 16;
+                dmd |= MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16;
+        } else
+                dmd = device_missing_delay;
+        sas_iounit_pg1->ReportDeviceMissingDelay = dmd;
+
+        /* io missing delay */
+        io_missing_delay_original = sas_iounit_pg1->IODeviceMissingDelay;
+        sas_iounit_pg1->IODeviceMissingDelay = io_missing_delay;
+
+        if (!mpt2sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
+            sz)) {
+                if (dmd & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16)
+                        dmd_new = (dmd &
+                            MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16;
+                else
+                        dmd_new =
+                    dmd & MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
+                printk(MPT2SAS_INFO_FMT "device_missing_delay: old(%d), "
+                    "new(%d)\n", ioc->name, dmd_orignal, dmd_new);
+                printk(MPT2SAS_INFO_FMT "ioc_missing_delay: old(%d), "
+                    "new(%d)\n", ioc->name, io_missing_delay_original,
+                    io_missing_delay);
+                ioc->device_missing_delay = dmd_new;
+                ioc->io_missing_delay = io_missing_delay;
+        }
+
+out:
+        kfree(sas_iounit_pg1);
+}
+
+/**
  * _base_static_config_pages - static start of day config pages
  * @ioc: per adapter object
  *
@@ -1855,6 +1959,7 @@ _base_static_config_pages(struct MPT2SAS_ADAPTER *ioc)
                     MPI2_IOUNITPAGE1_DISABLE_TASK_SET_FULL_HANDLING;
         ioc->iounit_pg1.Flags = cpu_to_le32(iounit_pg1_flags);
         mpt2sas_config_set_iounit_pg1(ioc, &mpi_reply, &ioc->iounit_pg1);
+
 }
 
 /**
@@ -1868,6 +1973,8 @@ _base_static_config_pages(struct MPT2SAS_ADAPTER *ioc)
 static void
 _base_release_memory_pools(struct MPT2SAS_ADAPTER *ioc)
 {
+        int i;
+
         dexitprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
 
@@ -1932,6 +2039,20 @@ _base_release_memory_pools(struct MPT2SAS_ADAPTER *ioc)
         }
         kfree(ioc->hpr_lookup);
         kfree(ioc->internal_lookup);
+        if (ioc->chain_lookup) {
+                for (i = 0; i < ioc->chain_depth; i++) {
+                        if (ioc->chain_lookup[i].chain_buffer)
+                                pci_pool_free(ioc->chain_dma_pool,
+                                    ioc->chain_lookup[i].chain_buffer,
+                                    ioc->chain_lookup[i].chain_buffer_dma);
+                }
+                if (ioc->chain_dma_pool)
+                        pci_pool_destroy(ioc->chain_dma_pool);
+        }
+        if (ioc->chain_lookup) {
+                free_pages((ulong)ioc->chain_lookup, ioc->chain_pages);
+                ioc->chain_lookup = NULL;
+        }
 }
 
 
@@ -1953,6 +2074,7 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         u32 sz, total_sz;
         u32 retry_sz;
         u16 max_request_credit;
+        int i;
 
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -1970,14 +2092,11 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         }
 
         /* command line tunables  for max controller queue depth */
-        if (max_queue_depth != -1) {
+        if (max_queue_depth != -1)
                 max_request_credit = (max_queue_depth < facts->RequestCredit)
                     ? max_queue_depth : facts->RequestCredit;
-        } else {
-                max_request_credit = (facts->RequestCredit >
-                    MPT2SAS_MAX_REQUEST_QUEUE) ? MPT2SAS_MAX_REQUEST_QUEUE :
-                    facts->RequestCredit;
-        }
+        else
+                max_request_credit = facts->RequestCredit;
 
         ioc->hba_queue_depth = max_request_credit;
         ioc->hi_priority_depth = facts->HighPriorityCredit;
@@ -2083,7 +2202,7 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
          * "frame for smid=0
          */
         ioc->chain_depth = ioc->chains_needed_per_io * ioc->scsiio_depth;
-        sz = ((ioc->scsiio_depth + 1 + ioc->chain_depth) * ioc->request_sz);
+        sz = ((ioc->scsiio_depth + 1) * ioc->request_sz);
 
         /* hi-priority queue */
         sz += (ioc->hi_priority_depth * ioc->request_sz);
@@ -2124,19 +2243,11 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         ioc->internal_dma = ioc->hi_priority_dma + (ioc->hi_priority_depth *
             ioc->request_sz);
 
-        ioc->chain = ioc->internal + (ioc->internal_depth *
-            ioc->request_sz);
-        ioc->chain_dma = ioc->internal_dma + (ioc->internal_depth *
-            ioc->request_sz);
 
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "request pool(0x%p): "
             "depth(%d), frame_size(%d), pool_size(%d kB)\n", ioc->name,
             ioc->request, ioc->hba_queue_depth, ioc->request_sz,
             (ioc->hba_queue_depth * ioc->request_sz)/1024));
-        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "chain pool(0x%p): depth"
-            "(%d), frame_size(%d), pool_size(%d kB)\n", ioc->name, ioc->chain,
-            ioc->chain_depth, ioc->request_sz, ((ioc->chain_depth *
-            ioc->request_sz))/1024));
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "request pool: dma(0x%llx)\n",
             ioc->name, (unsigned long long) ioc->request_dma));
         total_sz += sz;
@@ -2155,6 +2266,38 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
             "depth(%d)\n", ioc->name, ioc->request,
             ioc->scsiio_depth));
 
+        /* loop till the allocation succeeds */
+        do {
+                sz = ioc->chain_depth * sizeof(struct chain_tracker);
+                ioc->chain_pages = get_order(sz);
+                ioc->chain_lookup = (struct chain_tracker *)__get_free_pages(
+                    GFP_KERNEL, ioc->chain_pages);
+                if (ioc->chain_lookup == NULL)
+                        ioc->chain_depth -= 100;
+        } while (ioc->chain_lookup == NULL);
+        ioc->chain_dma_pool = pci_pool_create("chain pool", ioc->pdev,
+            ioc->request_sz, 16, 0);
+        if (!ioc->chain_dma_pool) {
+                printk(MPT2SAS_ERR_FMT "chain_dma_pool: pci_pool_create "
+                    "failed\n", ioc->name);
+                goto out;
+        }
+        for (i = 0; i < ioc->chain_depth; i++) {
+                ioc->chain_lookup[i].chain_buffer = pci_pool_alloc(
+                    ioc->chain_dma_pool , GFP_KERNEL,
+                    &ioc->chain_lookup[i].chain_buffer_dma);
+                if (!ioc->chain_lookup[i].chain_buffer) {
+                        ioc->chain_depth = i;
+                        goto chain_done;
+                }
+                total_sz += ioc->request_sz;
+        }
+chain_done:
+        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "chain pool depth"
+            "(%d), frame_size(%d), pool_size(%d kB)\n", ioc->name,
+            ioc->chain_depth, ioc->request_sz, ((ioc->chain_depth *
+            ioc->request_sz))/1024));
+
         /* initialize hi-priority queue smid's */
         ioc->hpr_lookup = kcalloc(ioc->hi_priority_depth,
             sizeof(struct request_tracker), GFP_KERNEL);
@@ -2221,6 +2364,8 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
                     ioc->name);
                 goto out;
         }
+        ioc->reply_dma_min_address = (u32)(ioc->reply_dma);
+        ioc->reply_dma_max_address = (u32)(ioc->reply_dma) + sz;
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "reply pool(0x%p): depth"
             "(%d), frame_size(%d), pool_size(%d kB)\n", ioc->name, ioc->reply,
             ioc->reply_free_queue_depth, ioc->reply_sz, sz/1024));
@@ -2302,7 +2447,6 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         return 0;
 
  out:
-        _base_release_memory_pools(ioc);
         return -ENOMEM;
 }
 
@@ -3485,6 +3629,7 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         INIT_LIST_HEAD(&ioc->free_list);
         smid = 1;
         for (i = 0; i < ioc->scsiio_depth; i++, smid++) {
+                INIT_LIST_HEAD(&ioc->scsi_lookup[i].chain_list);
                 ioc->scsi_lookup[i].cb_idx = 0xFF;
                 ioc->scsi_lookup[i].smid = smid;
                 ioc->scsi_lookup[i].scmd = NULL;
@@ -3511,6 +3656,13 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
                 list_add_tail(&ioc->internal_lookup[i].tracker_list,
                     &ioc->internal_free_list);
         }
+
+        /* chain pool */
+        INIT_LIST_HEAD(&ioc->free_chain_list);
+        for (i = 0; i < ioc->chain_depth; i++)
+                list_add_tail(&ioc->chain_lookup[i].tracker_list,
+                    &ioc->free_chain_list);
+
         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
 
         /* initialize Reply Free Queue */
@@ -3708,12 +3860,15 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         _base_unmask_events(ioc, MPI2_EVENT_IR_VOLUME);
         _base_unmask_events(ioc, MPI2_EVENT_IR_PHYSICAL_DISK);
         _base_unmask_events(ioc, MPI2_EVENT_IR_OPERATION_STATUS);
-        _base_unmask_events(ioc, MPI2_EVENT_TASK_SET_FULL);
         _base_unmask_events(ioc, MPI2_EVENT_LOG_ENTRY_ADDED);
         r = _base_make_ioc_operational(ioc, CAN_SLEEP);
         if (r)
                 goto out_free_resources;
 
+        if (missing_delay[0] != -1 && missing_delay[1] != -1)
+                _base_update_missing_delay(ioc, missing_delay[0],
+                    missing_delay[1]);
+
         mpt2sas_base_start_watchdog(ioc);
         return 0;
 
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index 0b15a8bdebfc..283568c6fb04 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,8 +69,8 @@
 #define MPT2SAS_DRIVER_NAME             "mpt2sas"
 #define MPT2SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
 #define MPT2SAS_DESCRIPTION     "LSI MPT Fusion SAS 2.0 Device Driver"
-#define MPT2SAS_DRIVER_VERSION          "06.100.00.00"
-#define MPT2SAS_MAJOR_VERSION           06
+#define MPT2SAS_DRIVER_VERSION          "07.100.00.00"
+#define MPT2SAS_MAJOR_VERSION           07
 #define MPT2SAS_MINOR_VERSION           100
 #define MPT2SAS_BUILD_VERSION           00
 #define MPT2SAS_RELEASE_VERSION         00
@@ -419,6 +419,18 @@ enum reset_type {
 };
 
 /**
+ * struct chain_tracker - firmware chain tracker
+ * @chain_buffer: chain buffer
+ * @chain_buffer_dma: physical address
+ * @tracker_list: list of free request (ioc->free_chain_list)
+ */
+struct chain_tracker {
+        void *chain_buffer;
+        dma_addr_t chain_buffer_dma;
+        struct list_head tracker_list;
+};
+
+/**
  * struct request_tracker - firmware request tracker
  * @smid: system message id
  * @scmd: scsi request pointer
@@ -430,6 +442,7 @@ struct request_tracker {
         u16     smid;
         struct scsi_cmnd *scmd;
         u8      cb_idx;
+        struct list_head chain_list;
         struct list_head tracker_list;
 };
 
@@ -704,8 +717,10 @@ struct MPT2SAS_ADAPTER {
         wait_queue_head_t reset_wq;
 
         /* chain */
-        u8              *chain;
-        dma_addr_t      chain_dma;
+        struct chain_tracker *chain_lookup;
+        struct list_head free_chain_list;
+        struct dma_pool *chain_dma_pool;
+        ulong           chain_pages;
         u16             max_sges_in_main_message;
         u16             max_sges_in_chain_message;
         u16             chains_needed_per_io;
@@ -737,6 +752,8 @@ struct MPT2SAS_ADAPTER {
         u16             reply_sz;
         u8              *reply;
         dma_addr_t      reply_dma;
+        u32             reply_dma_max_address;
+        u32             reply_dma_min_address;
         struct dma_pool *reply_dma_pool;
 
         /* reply free queue */
@@ -832,6 +849,8 @@ int mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle,
     ulong timeout, struct scsi_cmnd *scmd);
 void mpt2sas_scsih_set_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle);
 void mpt2sas_scsih_clear_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle);
+void mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address);
+void mpt2sas_device_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address);
 struct _sas_node *mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc,
     u16 handle);
 struct _sas_node *mpt2sas_scsih_expander_find_by_sas_address(struct MPT2SAS_ADAPTER
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index 40cb8aeb21b1..e92b77af5484 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -81,6 +81,7 @@ enum block_state {
         BLOCKING,
 };
 
+#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
  * _ctl_sas_device_find_by_handle - sas device search
  * @ioc: per adapter object
@@ -107,7 +108,6 @@ _ctl_sas_device_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         return r;
 }
 
-#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
  * _ctl_display_some_debug - debug routine
  * @ioc: per adapter object
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index 1a96a00418a4..eda347c57979 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -931,31 +931,32 @@ _scsih_scsi_lookup_find_by_lun(struct MPT2SAS_ADAPTER *ioc, int id,
 }
 
 /**
- * _scsih_get_chain_buffer_dma - obtain block of chains (dma address)
+ * _scsih_get_chain_buffer_tracker - obtain chain tracker
  * @ioc: per adapter object
- * @smid: system request message index
+ * @smid: smid associated to an IO request
  *
- * Returns phys pointer to chain buffer.
+ * Returns chain tracker(from ioc->free_chain_list)
  */
-static dma_addr_t
-_scsih_get_chain_buffer_dma(struct MPT2SAS_ADAPTER *ioc, u16 smid)
+static struct chain_tracker *
+_scsih_get_chain_buffer_tracker(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
-        return ioc->chain_dma + ((smid - 1) * (ioc->request_sz *
-            ioc->chains_needed_per_io));
-}
+        struct chain_tracker *chain_req;
+        unsigned long flags;
 
-/**
- * _scsih_get_chain_buffer - obtain block of chains assigned to a mf request
- * @ioc: per adapter object
- * @smid: system request message index
- *
- * Returns virt pointer to chain buffer.
- */
-static void *
-_scsih_get_chain_buffer(struct MPT2SAS_ADAPTER *ioc, u16 smid)
-{
-        return (void *)(ioc->chain + ((smid - 1) * (ioc->request_sz *
-            ioc->chains_needed_per_io)));
+        spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
+        if (list_empty(&ioc->free_chain_list)) {
+                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+                printk(MPT2SAS_WARN_FMT "chain buffers not available\n",
+                    ioc->name);
+                return NULL;
+        }
+        chain_req = list_entry(ioc->free_chain_list.next,
+            struct chain_tracker, tracker_list);
+        list_del_init(&chain_req->tracker_list);
+        list_add_tail(&chain_req->tracker_list,
+            &ioc->scsi_lookup[smid - 1].chain_list);
+        spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+        return chain_req;
 }
 
 /**
@@ -986,6 +987,7 @@ _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
         u32 sgl_flags;
         u32 sgl_flags_last_element;
         u32 sgl_flags_end_buffer;
+        struct chain_tracker *chain_req;
 
         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
 
@@ -1033,8 +1035,11 @@ _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
 
         /* initializing the chain flags and pointers */
         chain_flags = MPI2_SGE_FLAGS_CHAIN_ELEMENT << MPI2_SGE_FLAGS_SHIFT;
-        chain = _scsih_get_chain_buffer(ioc, smid);
-        chain_dma = _scsih_get_chain_buffer_dma(ioc, smid);
+        chain_req = _scsih_get_chain_buffer_tracker(ioc, smid);
+        if (!chain_req)
+                return -1;
+        chain = chain_req->chain_buffer;
+        chain_dma = chain_req->chain_buffer_dma;
         do {
                 sges_in_segment = (sges_left <=
                     ioc->max_sges_in_chain_message) ? sges_left :
@@ -1070,8 +1075,11 @@ _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
                         sges_in_segment--;
                 }
 
-                chain_dma += ioc->request_sz;
-                chain += ioc->request_sz;
+                chain_req = _scsih_get_chain_buffer_tracker(ioc, smid);
+                if (!chain_req)
+                        return -1;
+                chain = chain_req->chain_buffer;
+                chain_dma = chain_req->chain_buffer_dma;
         } while (1);
 
 
@@ -1094,28 +1102,24 @@ _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
- * _scsih_change_queue_depth - setting device queue depth
+ * _scsih_adjust_queue_depth - setting device queue depth
  * @sdev: scsi device struct
  * @qdepth: requested queue depth
- * @reason: calling context
  *
- * Returns queue depth.
+ *
+ * Returns nothing
  */
-static int
-_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
+static void
+_scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
 {
         struct Scsi_Host *shost = sdev->host;
         int max_depth;
-        int tag_type;
         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         struct MPT2SAS_TARGET *sas_target_priv_data;
         struct _sas_device *sas_device;
         unsigned long flags;
 
-        if (reason != SCSI_QDEPTH_DEFAULT)
-                return -EOPNOTSUPP;
-
         max_depth = shost->can_queue;
 
         /* limit max device queue for SATA to 32 */
@@ -1141,8 +1145,27 @@ _scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
                 max_depth = 1;
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        tag_type = (qdepth == 1) ? 0 : MSG_SIMPLE_TAG;
-        scsi_adjust_queue_depth(sdev, tag_type, qdepth);
+        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+}
+
+/**
+ * _scsih_change_queue_depth - setting device queue depth
+ * @sdev: scsi device struct
+ * @qdepth: requested queue depth
+ * @reason: SCSI_QDEPTH_DEFAULT/SCSI_QDEPTH_QFULL/SCSI_QDEPTH_RAMP_UP
+ * (see include/scsi/scsi_host.h for definition)
+ *
+ * Returns queue depth.
+ */
+static int
+_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
+{
+        if (reason == SCSI_QDEPTH_DEFAULT || reason == SCSI_QDEPTH_RAMP_UP)
+                _scsih_adjust_queue_depth(sdev, qdepth);
+        else if (reason == SCSI_QDEPTH_QFULL)
+                scsi_track_queue_full(sdev, qdepth);
+        else
+                return -EOPNOTSUPP;
 
         if (sdev->inquiry_len > 7)
                 sdev_printk(KERN_INFO, sdev, "qdepth(%d), tagged(%d), "
@@ -2251,13 +2274,13 @@ _scsih_dev_reset(struct scsi_cmnd *scmd)
 
         struct scsi_target *starget = scmd->device->sdev_target;
 
-        starget_printk(KERN_INFO, starget, "attempting target reset! "
+        starget_printk(KERN_INFO, starget, "attempting device reset! "
             "scmd(%p)\n", scmd);
         _scsih_tm_display_info(ioc, scmd);
 
         sas_device_priv_data = scmd->device->hostdata;
         if (!sas_device_priv_data || !sas_device_priv_data->sas_target) {
-                starget_printk(KERN_INFO, starget, "target been deleted! "
+                starget_printk(KERN_INFO, starget, "device been deleted! "
                     "scmd(%p)\n", scmd);
                 scmd->result = DID_NO_CONNECT << 16;
                 scmd->scsi_done(scmd);
@@ -2576,9 +2599,9 @@ _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
            &sas_expander->sas_port_list, port_list) {
 
                 if (mpt2sas_port->remote_identify.device_type ==
-                    MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
+                    SAS_EDGE_EXPANDER_DEVICE ||
                     mpt2sas_port->remote_identify.device_type ==
-                    MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
+                    SAS_FANOUT_EXPANDER_DEVICE) {
 
                         spin_lock_irqsave(&ioc->sas_node_lock, flags);
                         expander_sibling =
@@ -2715,9 +2738,10 @@ static u8
 _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
     u8 msix_index, u32 reply)
 {
+#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         Mpi2SasIoUnitControlReply_t *mpi_reply =
             mpt2sas_base_get_reply_virt_addr(ioc, reply);
-
+#endif
         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
             "sc_complete:handle(0x%04x), (open) "
             "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
@@ -3963,6 +3987,7 @@ _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
         Mpi2ConfigReply_t mpi_reply;
         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
         u16 attached_handle;
+        u8 link_rate;
 
         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
             "updating handles for sas_host(0x%016llx)\n",
@@ -3984,15 +4009,17 @@ _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
         if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
                 goto out;
         for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
+                link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4;
                 if (i == 0)
                         ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
                             PhyData[0].ControllerDevHandle);
                 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
                 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
                     AttachedDevHandle);
+                if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5)
+                        link_rate = MPI2_SAS_NEG_LINK_RATE_1_5;
                 mpt2sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
-                    attached_handle, i, sas_iounit_pg0->PhyData[i].
-                    NegotiatedLinkRate >> 4);
+                    attached_handle, i, link_rate);
         }
  out:
         kfree(sas_iounit_pg0);
@@ -4336,14 +4363,14 @@ _scsih_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
 }
 
 /**
- * _scsih_expander_remove - removing expander object
+ * mpt2sas_expander_remove - removing expander object
  * @ioc: per adapter object
  * @sas_address: expander sas_address
  *
  * Return nothing.
  */
-static void
-_scsih_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
+void
+mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
 {
         struct _sas_node *sas_expander;
         unsigned long flags;
@@ -4354,6 +4381,11 @@ _scsih_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
             sas_address);
+        if (!sas_expander) {
+                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
+                return;
+        }
+        list_del(&sas_expander->list);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         _scsih_expander_node_remove(ioc, sas_expander);
 }
@@ -4643,6 +4675,33 @@ _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
             sas_device_backup.sas_address));
 }
 
+/**
+ * mpt2sas_device_remove - removing device object
+ * @ioc: per adapter object
+ * @sas_address: expander sas_address
+ *
+ * Return nothing.
+ */
+void
+mpt2sas_device_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
+{
+        struct _sas_device *sas_device;
+        unsigned long flags;
+
+        if (ioc->shost_recovery)
+                return;
+
+        spin_lock_irqsave(&ioc->sas_device_lock, flags);
+        sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
+            sas_address);
+        if (!sas_device) {
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+                return;
+        }
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+        _scsih_remove_device(ioc, sas_device);
+}
+
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
  * _scsih_sas_topology_change_event_debug - debug for topology event
@@ -4737,7 +4796,7 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
         int i;
         u16 parent_handle, handle;
         u16 reason_code;
-        u8 phy_number;
+        u8 phy_number, max_phys;
         struct _sas_node *sas_expander;
         struct _sas_device *sas_device;
         u64 sas_address;
@@ -4775,11 +4834,13 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
         sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
             parent_handle);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
-        if (sas_expander)
+        if (sas_expander) {
                 sas_address = sas_expander->sas_address;
-        else if (parent_handle < ioc->sas_hba.num_phys)
+                max_phys = sas_expander->num_phys;
+        } else if (parent_handle < ioc->sas_hba.num_phys) {
                 sas_address = ioc->sas_hba.sas_address;
-        else
+                max_phys = ioc->sas_hba.num_phys;
+        } else
                 return;
 
         /* handle siblings events */
@@ -4793,6 +4854,8 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
                     ioc->pci_error_recovery)
                         return;
                 phy_number = event_data->StartPhyNum + i;
+                if (phy_number >= max_phys)
+                        continue;
                 reason_code = event_data->PHY[i].PhyStatus &
                     MPI2_EVENT_SAS_TOPO_RC_MASK;
                 if ((event_data->PHY[i].PhyStatus &
@@ -4844,7 +4907,7 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
         /* handle expander removal */
         if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
             sas_expander)
-                _scsih_expander_remove(ioc, sas_address);
+                mpt2sas_expander_remove(ioc, sas_address);
 
 }
 
@@ -5773,90 +5836,6 @@ _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
- * _scsih_task_set_full - handle task set full
- * @ioc: per adapter object
- * @fw_event: The fw_event_work object
- * Context: user.
- *
- * Throttle back qdepth.
- */
-static void
-_scsih_task_set_full(struct MPT2SAS_ADAPTER *ioc, struct fw_event_work
-        *fw_event)
-{
-        unsigned long flags;
-        struct _sas_device *sas_device;
-        static struct _raid_device *raid_device;
-        struct scsi_device *sdev;
-        int depth;
-        u16 current_depth;
-        u16 handle;
-        int id, channel;
-        u64 sas_address;
-        Mpi2EventDataTaskSetFull_t *event_data = fw_event->event_data;
-
-        current_depth = le16_to_cpu(event_data->CurrentDepth);
-        handle = le16_to_cpu(event_data->DevHandle);
-        spin_lock_irqsave(&ioc->sas_device_lock, flags);
-        sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
-        if (!sas_device) {
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                return;
-        }
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-        id = sas_device->id;
-        channel = sas_device->channel;
-        sas_address = sas_device->sas_address;
-
-        /* if hidden raid component, then change to volume characteristics */
-        if (test_bit(handle, ioc->pd_handles) && sas_device->volume_handle) {
-                spin_lock_irqsave(&ioc->raid_device_lock, flags);
-                raid_device = _scsih_raid_device_find_by_handle(
-                    ioc, sas_device->volume_handle);
-                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
-                if (raid_device) {
-                        id = raid_device->id;
-                        channel = raid_device->channel;
-                        handle = raid_device->handle;
-                        sas_address = raid_device->wwid;
-                }
-        }
-
-        if (ioc->logging_level & MPT_DEBUG_TASK_SET_FULL)
-                starget_printk(KERN_INFO, sas_device->starget, "task set "
-                    "full: handle(0x%04x), sas_addr(0x%016llx), depth(%d)\n",
-                    handle, (unsigned long long)sas_address, current_depth);
-
-        shost_for_each_device(sdev, ioc->shost) {
-                if (sdev->id == id && sdev->channel == channel) {
-                        if (current_depth > sdev->queue_depth) {
-                                if (ioc->logging_level &
-                                    MPT_DEBUG_TASK_SET_FULL)
-                                        sdev_printk(KERN_INFO, sdev, "strange "
-                                            "observation, the queue depth is"
-                                            " (%d) meanwhile fw queue depth "
-                                            "is (%d)\n", sdev->queue_depth,
-                                            current_depth);
-                                continue;
-                        }
-                        depth = scsi_track_queue_full(sdev,
-                            current_depth - 1);
-                        if (depth > 0)
-                                sdev_printk(KERN_INFO, sdev, "Queue depth "
-                                    "reduced to (%d)\n", depth);
-                        else if (depth < 0)
-                                sdev_printk(KERN_INFO, sdev, "Tagged Command "
-                                    "Queueing is being disabled\n");
-                        else if (depth == 0)
-                                if (ioc->logging_level &
-                                     MPT_DEBUG_TASK_SET_FULL)
-                                        sdev_printk(KERN_INFO, sdev,
-                                             "Queue depth not changed yet\n");
-                }
-        }
-}
-
-/**
  * _scsih_prep_device_scan - initialize parameters prior to device scan
  * @ioc: per adapter object
  *
@@ -6219,7 +6198,7 @@ _scsih_remove_unresponding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
                         sas_expander->responding = 0;
                         continue;
                 }
-                _scsih_expander_remove(ioc, sas_expander->sas_address);
+                mpt2sas_expander_remove(ioc, sas_expander->sas_address);
                 goto retry_expander_search;
         }
 }
@@ -6343,9 +6322,6 @@ _firmware_event_work(struct work_struct *work)
         case MPI2_EVENT_IR_OPERATION_STATUS:
                 _scsih_sas_ir_operation_status_event(ioc, fw_event);
                 break;
-        case MPI2_EVENT_TASK_SET_FULL:
-                _scsih_task_set_full(ioc, fw_event);
-                break;
         }
         _scsih_fw_event_free(ioc, fw_event);
 }
@@ -6415,7 +6391,6 @@ mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
         case MPI2_EVENT_SAS_DISCOVERY:
         case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE:
         case MPI2_EVENT_IR_PHYSICAL_DISK:
-        case MPI2_EVENT_TASK_SET_FULL:
                 break;
 
         default: /* ignore the rest */
@@ -6490,56 +6465,23 @@ static void
 _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
     struct _sas_node *sas_expander)
 {
-        struct _sas_port *mpt2sas_port;
-        struct _sas_device *sas_device;
-        struct _sas_node *expander_sibling;
-        unsigned long flags;
-
-        if (!sas_expander)
-                return;
+        struct _sas_port *mpt2sas_port, *next;
 
         /* remove sibling ports attached to this expander */
- retry_device_search:
-        list_for_each_entry(mpt2sas_port,
+        list_for_each_entry_safe(mpt2sas_port, next,
            &sas_expander->sas_port_list, port_list) {
+                if (ioc->shost_recovery)
+                        return;
                 if (mpt2sas_port->remote_identify.device_type ==
-                    SAS_END_DEVICE) {
-                        spin_lock_irqsave(&ioc->sas_device_lock, flags);
-                        sas_device =
-                            mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
-                           mpt2sas_port->remote_identify.sas_address);
-                        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                        if (!sas_device)
-                                continue;
-                        _scsih_remove_device(ioc, sas_device);
-                        if (ioc->shost_recovery)
-                                return;
-                        goto retry_device_search;
-                }
-        }
-
- retry_expander_search:
-        list_for_each_entry(mpt2sas_port,
-           &sas_expander->sas_port_list, port_list) {
-
-                if (mpt2sas_port->remote_identify.device_type ==
-                    MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
+                    SAS_END_DEVICE)
+                        mpt2sas_device_remove(ioc,
+                            mpt2sas_port->remote_identify.sas_address);
+                else if (mpt2sas_port->remote_identify.device_type ==
+                    SAS_EDGE_EXPANDER_DEVICE ||
                     mpt2sas_port->remote_identify.device_type ==
-                    MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
-
-                        spin_lock_irqsave(&ioc->sas_node_lock, flags);
-                        expander_sibling =
-                            mpt2sas_scsih_expander_find_by_sas_address(
-                            ioc, mpt2sas_port->remote_identify.sas_address);
-                        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
-                        if (!expander_sibling)
-                                continue;
-                        _scsih_expander_remove(ioc,
-                            expander_sibling->sas_address);
-                        if (ioc->shost_recovery)
-                                return;
-                        goto retry_expander_search;
-                }
+                    SAS_FANOUT_EXPANDER_DEVICE)
+                        mpt2sas_expander_remove(ioc,
+                            mpt2sas_port->remote_identify.sas_address);
         }
 
         mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
@@ -6550,7 +6492,6 @@ _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
             sas_expander->handle, (unsigned long long)
             sas_expander->sas_address);
 
-        list_del(&sas_expander->list);
         kfree(sas_expander->phy);
         kfree(sas_expander);
 }
@@ -6668,9 +6609,7 @@ _scsih_remove(struct pci_dev *pdev)
 {
         struct Scsi_Host *shost = pci_get_drvdata(pdev);
         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
-        struct _sas_port *mpt2sas_port;
-        struct _sas_device *sas_device;
-        struct _sas_node *expander_sibling;
+        struct _sas_port *mpt2sas_port, *next_port;
         struct _raid_device *raid_device, *next;
         struct MPT2SAS_TARGET *sas_target_priv_data;
         struct workqueue_struct *wq;
@@ -6702,28 +6641,18 @@ _scsih_remove(struct pci_dev *pdev)
         }
 
         /* free ports attached to the sas_host */
- retry_again:
-        list_for_each_entry(mpt2sas_port,
+        list_for_each_entry_safe(mpt2sas_port, next_port,
            &ioc->sas_hba.sas_port_list, port_list) {
                 if (mpt2sas_port->remote_identify.device_type ==
-                    SAS_END_DEVICE) {
-                        sas_device =
-                            mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
-                           mpt2sas_port->remote_identify.sas_address);
-                        if (sas_device) {
-                                _scsih_remove_device(ioc, sas_device);
-                                goto retry_again;
-                        }
-                } else {
-                        expander_sibling =
-                            mpt2sas_scsih_expander_find_by_sas_address(ioc,
+                    SAS_END_DEVICE)
+                        mpt2sas_device_remove(ioc,
+                            mpt2sas_port->remote_identify.sas_address);
+                else if (mpt2sas_port->remote_identify.device_type ==
+                    SAS_EDGE_EXPANDER_DEVICE ||
+                    mpt2sas_port->remote_identify.device_type ==
+                    SAS_FANOUT_EXPANDER_DEVICE)
+                        mpt2sas_expander_remove(ioc,
                             mpt2sas_port->remote_identify.sas_address);
-                        if (expander_sibling) {
-                                _scsih_expander_remove(ioc,
-                                    expander_sibling->sas_address);
-                                goto retry_again;
-                        }
-                }
         }
 
         /* free phys attached to the sas_host */
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index b55c6dc07470..cb1cdecbe0f8 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -465,62 +465,149 @@ _transport_expander_report_manufacture(struct MPT2SAS_ADAPTER *ioc,
         return rc;
 }
 
+/**
+ * _transport_delete_port - helper function to removing a port
+ * @ioc: per adapter object
+ * @mpt2sas_port: mpt2sas per port object
+ *
+ * Returns nothing.
+ */
+static void
+_transport_delete_port(struct MPT2SAS_ADAPTER *ioc,
+        struct _sas_port *mpt2sas_port)
+{
+        u64 sas_address = mpt2sas_port->remote_identify.sas_address;
+        enum sas_device_type device_type =
+            mpt2sas_port->remote_identify.device_type;
+
+        dev_printk(KERN_INFO, &mpt2sas_port->port->dev,
+            "remove: sas_addr(0x%016llx)\n",
+            (unsigned long long) sas_address);
+
+        ioc->logging_level |= MPT_DEBUG_TRANSPORT;
+        if (device_type == SAS_END_DEVICE)
+                mpt2sas_device_remove(ioc, sas_address);
+        else if (device_type == SAS_EDGE_EXPANDER_DEVICE ||
+            device_type == SAS_FANOUT_EXPANDER_DEVICE)
+                mpt2sas_expander_remove(ioc, sas_address);
+        ioc->logging_level &= ~MPT_DEBUG_TRANSPORT;
+}
 
 /**
- * _transport_delete_duplicate_port - (see below description)
+ * _transport_delete_phy - helper function to removing single phy from port
  * @ioc: per adapter object
- * @sas_node: sas node object (either expander or sas host)
- * @sas_address: sas address of device being added
- * @phy_num: phy number
+ * @mpt2sas_port: mpt2sas per port object
+ * @mpt2sas_phy: mpt2sas per phy object
  *
- * This function is called when attempting to add a new port that is claiming
- * the same phy resources already in use by another port.  If we don't release
- * the claimed phy resources, the sas transport layer will hang from the BUG
- * in sas_port_add_phy.
+ * Returns nothing.
+ */
+static void
+_transport_delete_phy(struct MPT2SAS_ADAPTER *ioc,
+        struct _sas_port *mpt2sas_port, struct _sas_phy *mpt2sas_phy)
+{
+        u64 sas_address = mpt2sas_port->remote_identify.sas_address;
+
+        dev_printk(KERN_INFO, &mpt2sas_phy->phy->dev,
+            "remove: sas_addr(0x%016llx), phy(%d)\n",
+            (unsigned long long) sas_address, mpt2sas_phy->phy_id);
+
+        list_del(&mpt2sas_phy->port_siblings);
+        mpt2sas_port->num_phys--;
+        sas_port_delete_phy(mpt2sas_port->port, mpt2sas_phy->phy);
+        mpt2sas_phy->phy_belongs_to_port = 0;
+}
+
+/**
+ * _transport_add_phy - helper function to adding single phy to port
+ * @ioc: per adapter object
+ * @mpt2sas_port: mpt2sas per port object
+ * @mpt2sas_phy: mpt2sas per phy object
  *
- * The reason we would hit this issue is becuase someone is changing the
- * sas address of a device on the fly, meanwhile controller firmware sends
- * EVENTs out of order when removing the previous instance of the device.
+ * Returns nothing.
  */
 static void
-_transport_delete_duplicate_port(struct MPT2SAS_ADAPTER *ioc,
-    struct _sas_node *sas_node, u64 sas_address, int phy_num)
+_transport_add_phy(struct MPT2SAS_ADAPTER *ioc, struct _sas_port *mpt2sas_port,
+        struct _sas_phy *mpt2sas_phy)
 {
-        struct _sas_port *mpt2sas_port, *mpt2sas_port_duplicate;
-        struct _sas_phy *mpt2sas_phy;
+        u64 sas_address = mpt2sas_port->remote_identify.sas_address;
 
-        printk(MPT2SAS_ERR_FMT "new device located at sas_addr(0x%016llx), "
-            "phy_id(%d)\n", ioc->name, (unsigned long long)sas_address,
-            phy_num);
+        dev_printk(KERN_INFO, &mpt2sas_phy->phy->dev,
+            "add: sas_addr(0x%016llx), phy(%d)\n", (unsigned long long)
+            sas_address, mpt2sas_phy->phy_id);
 
-        mpt2sas_port_duplicate = NULL;
-        list_for_each_entry(mpt2sas_port, &sas_node->sas_port_list, port_list) {
-                dev_printk(KERN_ERR, &mpt2sas_port->port->dev,
-                    "existing device at sas_addr(0x%016llx), num_phys(%d)\n",
-                    (unsigned long long)
-                    mpt2sas_port->remote_identify.sas_address,
-                    mpt2sas_port->num_phys);
-                list_for_each_entry(mpt2sas_phy, &mpt2sas_port->phy_list,
+        list_add_tail(&mpt2sas_phy->port_siblings, &mpt2sas_port->phy_list);
+        mpt2sas_port->num_phys++;
+        sas_port_add_phy(mpt2sas_port->port, mpt2sas_phy->phy);
+        mpt2sas_phy->phy_belongs_to_port = 1;
+}
+
+/**
+ * _transport_add_phy_to_an_existing_port - adding new phy to existing port
+ * @ioc: per adapter object
+ * @sas_node: sas node object (either expander or sas host)
+ * @mpt2sas_phy: mpt2sas per phy object
+ * @sas_address: sas address of device/expander were phy needs to be added to
+ *
+ * Returns nothing.
+ */
+static void
+_transport_add_phy_to_an_existing_port(struct MPT2SAS_ADAPTER *ioc,
+struct _sas_node *sas_node, struct _sas_phy *mpt2sas_phy, u64 sas_address)
+{
+        struct _sas_port *mpt2sas_port;
+        struct _sas_phy *phy_srch;
+
+        if (mpt2sas_phy->phy_belongs_to_port == 1)
+                return;
+
+        list_for_each_entry(mpt2sas_port, &sas_node->sas_port_list,
+            port_list) {
+                if (mpt2sas_port->remote_identify.sas_address !=
+                    sas_address)
+                        continue;
+                list_for_each_entry(phy_srch, &mpt2sas_port->phy_list,
                     port_siblings) {
-                        dev_printk(KERN_ERR, &mpt2sas_phy->phy->dev,
-                            "phy_number(%d)\n", mpt2sas_phy->phy_id);
-                        if (mpt2sas_phy->phy_id == phy_num)
-                                mpt2sas_port_duplicate = mpt2sas_port;
+                        if (phy_srch == mpt2sas_phy)
+                                return;
                 }
+                _transport_add_phy(ioc, mpt2sas_port, mpt2sas_phy);
+                        return;
         }
 
-        if (!mpt2sas_port_duplicate)
+}
+
+/**
+ * _transport_del_phy_from_an_existing_port - delete phy from existing port
+ * @ioc: per adapter object
+ * @sas_node: sas node object (either expander or sas host)
+ * @mpt2sas_phy: mpt2sas per phy object
+ *
+ * Returns nothing.
+ */
+static void
+_transport_del_phy_from_an_existing_port(struct MPT2SAS_ADAPTER *ioc,
+        struct _sas_node *sas_node, struct _sas_phy *mpt2sas_phy)
+{
+        struct _sas_port *mpt2sas_port, *next;
+        struct _sas_phy *phy_srch;
+
+        if (mpt2sas_phy->phy_belongs_to_port == 0)
                 return;
 
-        dev_printk(KERN_ERR, &mpt2sas_port_duplicate->port->dev,
-            "deleting duplicate device at sas_addr(0x%016llx), phy(%d)!!!!\n",
-            (unsigned long long)
-            mpt2sas_port_duplicate->remote_identify.sas_address, phy_num);
-        ioc->logging_level |= MPT_DEBUG_TRANSPORT;
-        mpt2sas_transport_port_remove(ioc,
-            mpt2sas_port_duplicate->remote_identify.sas_address,
-            sas_node->sas_address);
-        ioc->logging_level &= ~MPT_DEBUG_TRANSPORT;
+        list_for_each_entry_safe(mpt2sas_port, next, &sas_node->sas_port_list,
+            port_list) {
+                list_for_each_entry(phy_srch, &mpt2sas_port->phy_list,
+                    port_siblings) {
+                        if (phy_srch != mpt2sas_phy)
+                                continue;
+                        if (mpt2sas_port->num_phys == 1)
+                                _transport_delete_port(ioc, mpt2sas_port);
+                        else
+                                _transport_delete_phy(ioc, mpt2sas_port,
+                                    mpt2sas_phy);
+                        return;
+                }
+        }
 }
 
 /**
@@ -537,11 +624,13 @@ _transport_sanity_check(struct MPT2SAS_ADAPTER *ioc, struct _sas_node *sas_node,
 {
         int i;
 
-        for (i = 0; i < sas_node->num_phys; i++)
-                if (sas_node->phy[i].remote_identify.sas_address == sas_address)
-                        if (sas_node->phy[i].phy_belongs_to_port)
-                                _transport_delete_duplicate_port(ioc, sas_node,
-                                        sas_address, i);
+        for (i = 0; i < sas_node->num_phys; i++) {
+                if (sas_node->phy[i].remote_identify.sas_address != sas_address)
+                        continue;
+                if (sas_node->phy[i].phy_belongs_to_port == 1)
+                        _transport_del_phy_from_an_existing_port(ioc, sas_node,
+                            &sas_node->phy[i]);
+        }
 }
 
 /**
@@ -905,10 +994,12 @@ mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER *ioc,
 
         mpt2sas_phy = &sas_node->phy[phy_number];
         mpt2sas_phy->attached_handle = handle;
-        if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5))
+        if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) {
                 _transport_set_identify(ioc, handle,
                     &mpt2sas_phy->remote_identify);
-        else
+                _transport_add_phy_to_an_existing_port(ioc, sas_node,
+                    mpt2sas_phy, mpt2sas_phy->remote_identify.sas_address);
+        } else
                 memset(&mpt2sas_phy->remote_identify, 0 , sizeof(struct
                     sas_identify));
 
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index bc8194f74625..44578b56ad0a 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -1309,6 +1309,31 @@ qla2x00_fabric_param_show(struct device *dev, struct device_attribute *attr,
 }
 
 static ssize_t
+qla2x00_thermal_temp_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
+        int rval = QLA_FUNCTION_FAILED;
+        uint16_t temp, frac;
+
+        if (!vha->hw->flags.thermal_supported)
+                return snprintf(buf, PAGE_SIZE, "\n");
+
+        temp = frac = 0;
+        if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
+            test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
+                DEBUG2_3_11(printk(KERN_WARNING
+                    "%s(%ld): isp reset in progress.\n",
+                    __func__, vha->host_no));
+        else if (!vha->hw->flags.eeh_busy)
+                rval = qla2x00_get_thermal_temp(vha, &temp, &frac);
+        if (rval != QLA_SUCCESS)
+                temp = frac = 0;
+
+        return snprintf(buf, PAGE_SIZE, "%d.%02d\n", temp, frac);
+}
+
+static ssize_t
 qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
     char *buf)
 {
@@ -1366,6 +1391,7 @@ static DEVICE_ATTR(vn_port_mac_address, S_IRUGO,
                    qla2x00_vn_port_mac_address_show, NULL);
 static DEVICE_ATTR(fabric_param, S_IRUGO, qla2x00_fabric_param_show, NULL);
 static DEVICE_ATTR(fw_state, S_IRUGO, qla2x00_fw_state_show, NULL);
+static DEVICE_ATTR(thermal_temp, S_IRUGO, qla2x00_thermal_temp_show, NULL);
 
 struct device_attribute *qla2x00_host_attrs[] = {
         &dev_attr_driver_version,
@@ -1394,6 +1420,7 @@ struct device_attribute *qla2x00_host_attrs[] = {
         &dev_attr_fabric_param,
         &dev_attr_fw_state,
         &dev_attr_optrom_gold_fw_version,
+        &dev_attr_thermal_temp,
         NULL,
 };
 
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 31a4121a2be1..903b0586ded3 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -103,7 +103,7 @@ qla24xx_proc_fcp_prio_cfg_cmd(struct fc_bsg_job *bsg_job)
 
         bsg_job->reply->reply_payload_rcv_len = 0;
 
-        if (!IS_QLA24XX_TYPE(ha) || !IS_QLA25XX(ha)) {
+        if (!(IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))) {
                 ret = -EINVAL;
                 goto exit_fcp_prio_cfg;
         }
@@ -753,7 +753,7 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                         command_sent = INT_DEF_LB_LOOPBACK_CMD;
                         rval = qla2x00_loopback_test(vha, &elreq, response);
 
-                        if (new_config[1]) {
+                        if (new_config[0]) {
                                 /* Revert back to original port config
                                  * Also clear internal loopback
                                  */
@@ -1512,6 +1512,7 @@ qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
                                 if (((sp_bsg->type == SRB_CT_CMD) ||
                                         (sp_bsg->type == SRB_ELS_CMD_HST))
                                         && (sp_bsg->u.bsg_job == bsg_job)) {
+                                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
                                         if (ha->isp_ops->abort_command(sp)) {
                                                 DEBUG2(qla_printk(KERN_INFO, ha,
                                                     "scsi(%ld): mbx "
@@ -1527,6 +1528,7 @@ qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
                                                 bsg_job->req->errors =
                                                 bsg_job->reply->result = 0;
                                         }
+                                        spin_lock_irqsave(&ha->hardware_lock, flags);
                                         goto done;
                                 }
                         }
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 9ce539d4557e..ccfc8e78be21 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2425,6 +2425,9 @@ struct qla_hw_data {
                 uint32_t        disable_msix_handshake  :1;
                 uint32_t        fcp_prio_enabled        :1;
                 uint32_t        fw_hung :1;
+                uint32_t        quiesce_owner:1;
+                uint32_t        thermal_supported:1;
+                /* 26 bits */
         } flags;
 
         /* This spinlock is used to protect "io transactions", you must
@@ -2863,6 +2866,7 @@ typedef struct scsi_qla_host {
 #define ISP_UNRECOVERABLE       17
 #define FCOE_CTX_RESET_NEEDED   18      /* Initiate FCoE context reset */
 #define MPI_RESET_NEEDED        19      /* Initiate MPI FW reset */
+#define ISP_QUIESCE_NEEDED      20      /* Driver need some quiescence */
 
         uint32_t        device_flags;
 #define SWITCH_FOUND            BIT_0
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 9382a816c133..89e900adb679 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -36,6 +36,7 @@ extern int qla2x00_load_risc(struct scsi_qla_host *, uint32_t *);
 extern int qla24xx_load_risc(scsi_qla_host_t *, uint32_t *);
 extern int qla81xx_load_risc(scsi_qla_host_t *, uint32_t *);
 
+extern int qla2x00_perform_loop_resync(scsi_qla_host_t *);
 extern int qla2x00_loop_resync(scsi_qla_host_t *);
 
 extern int qla2x00_fabric_login(scsi_qla_host_t *, fc_port_t *, uint16_t *);
@@ -45,12 +46,15 @@ extern void qla2x00_update_fcports(scsi_qla_host_t *);
 
 extern int qla2x00_abort_isp(scsi_qla_host_t *);
 extern void qla2x00_abort_isp_cleanup(scsi_qla_host_t *);
+extern void qla82xx_quiescent_state_cleanup(scsi_qla_host_t *);
 
 extern void qla2x00_update_fcport(scsi_qla_host_t *, fc_port_t *);
 
 extern void qla2x00_alloc_fw_dump(scsi_qla_host_t *);
 extern void qla2x00_try_to_stop_firmware(scsi_qla_host_t *);
 
+extern int qla2x00_get_thermal_temp(scsi_qla_host_t *, uint16_t *, uint16_t *);
+
 extern void qla84xx_put_chip(struct scsi_qla_host *);
 
 extern int qla2x00_async_login(struct scsi_qla_host *, fc_port_t *,
@@ -68,6 +72,7 @@ extern void qla2x00_async_adisc_done(struct scsi_qla_host *, fc_port_t *,
 extern void qla2x00_async_tm_cmd_done(struct scsi_qla_host *, fc_port_t *,
         struct srb_iocb *);
 extern void *qla2x00_alloc_iocbs(struct scsi_qla_host *, srb_t *);
+extern int qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *, fc_port_t *);
 
 extern fc_port_t *
 qla2x00_alloc_fcport(scsi_qla_host_t *, gfp_t );
@@ -90,7 +95,6 @@ extern int ql2xfwloadbin;
 extern int ql2xetsenable;
 extern int ql2xshiftctondsd;
 extern int ql2xdbwr;
-extern int ql2xdontresethba;
 extern int ql2xasynctmfenable;
 extern int ql2xgffidenable;
 extern int ql2xenabledif;
@@ -549,9 +553,11 @@ extern void qla82xx_rom_unlock(struct qla_hw_data *);
 
 /* ISP 8021 IDC */
 extern void qla82xx_clear_drv_active(struct qla_hw_data *);
+extern uint32_t  qla82xx_wait_for_state_change(scsi_qla_host_t *, uint32_t);
 extern int qla82xx_idc_lock(struct qla_hw_data *);
 extern void qla82xx_idc_unlock(struct qla_hw_data *);
 extern int qla82xx_device_state_handler(scsi_qla_host_t *);
+extern void qla82xx_clear_qsnt_ready(scsi_qla_host_t *);
 
 extern void qla2x00_set_model_info(scsi_qla_host_t *, uint8_t *,
     size_t, char *);
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 259f51137493..f948e1a73aec 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -498,6 +498,7 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         vha->flags.reset_active = 0;
         ha->flags.pci_channel_io_perm_failure = 0;
         ha->flags.eeh_busy = 0;
+        ha->flags.thermal_supported = 1;
         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
         atomic_set(&vha->loop_state, LOOP_DOWN);
         vha->device_flags = DFLG_NO_CABLE;
@@ -2023,6 +2024,7 @@ qla2x00_configure_hba(scsi_qla_host_t *vha)
             &loop_id, &al_pa, &area, &domain, &topo, &sw_cap);
         if (rval != QLA_SUCCESS) {
                 if (LOOP_TRANSITION(vha) || atomic_read(&ha->loop_down_timer) ||
+                    IS_QLA8XXX_TYPE(ha) ||
                     (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
                         DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
                             __func__, vha->host_no));
@@ -2928,6 +2930,7 @@ qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
         fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
 
         qla2x00_iidma_fcport(vha, fcport);
+        qla24xx_update_fcport_fcp_prio(vha, fcport);
         qla2x00_reg_remote_port(vha, fcport);
         atomic_set(&fcport->state, FCS_ONLINE);
 }
@@ -3844,6 +3847,37 @@ qla2x00_loop_resync(scsi_qla_host_t *vha)
         return (rval);
 }
 
+/*
+* qla2x00_perform_loop_resync
+* Description: This function will set the appropriate flags and call
+*              qla2x00_loop_resync. If successful loop will be resynced
+* Arguments : scsi_qla_host_t pointer
+* returm    : Success or Failure
+*/
+
+int qla2x00_perform_loop_resync(scsi_qla_host_t *ha)
+{
+        int32_t rval = 0;
+
+        if (!test_and_set_bit(LOOP_RESYNC_ACTIVE, &ha->dpc_flags)) {
+                /*Configure the flags so that resync happens properly*/
+                atomic_set(&ha->loop_down_timer, 0);
+                if (!(ha->device_flags & DFLG_NO_CABLE)) {
+                        atomic_set(&ha->loop_state, LOOP_UP);
+                        set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
+                        set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
+                        set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
+
+                        rval = qla2x00_loop_resync(ha);
+                } else
+                        atomic_set(&ha->loop_state, LOOP_DEAD);
+
+                clear_bit(LOOP_RESYNC_ACTIVE, &ha->dpc_flags);
+        }
+
+        return rval;
+}
+
 void
 qla2x00_update_fcports(scsi_qla_host_t *base_vha)
 {
@@ -3857,7 +3891,7 @@ qla2x00_update_fcports(scsi_qla_host_t *base_vha)
         list_for_each_entry(vha, &base_vha->hw->vp_list, list) {
                 atomic_inc(&vha->vref_count);
                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
-                        if (fcport && fcport->drport &&
+                        if (fcport->drport &&
                             atomic_read(&fcport->state) != FCS_UNCONFIGURED) {
                                 spin_unlock_irqrestore(&ha->vport_slock, flags);
 
@@ -3871,11 +3905,43 @@ qla2x00_update_fcports(scsi_qla_host_t *base_vha)
         spin_unlock_irqrestore(&ha->vport_slock, flags);
 }
 
+/*
+* qla82xx_quiescent_state_cleanup
+* Description: This function will block the new I/Os
+*              Its not aborting any I/Os as context
+*              is not destroyed during quiescence
+* Arguments: scsi_qla_host_t
+* return   : void
+*/
+void
+qla82xx_quiescent_state_cleanup(scsi_qla_host_t *vha)
+{
+        struct qla_hw_data *ha = vha->hw;
+        struct scsi_qla_host *vp;
+
+        qla_printk(KERN_INFO, ha,
+                        "Performing ISP error recovery - ha= %p.\n", ha);
+
+        atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
+        if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
+                atomic_set(&vha->loop_state, LOOP_DOWN);
+                qla2x00_mark_all_devices_lost(vha, 0);
+                list_for_each_entry(vp, &ha->vp_list, list)
+                        qla2x00_mark_all_devices_lost(vha, 0);
+        } else {
+                if (!atomic_read(&vha->loop_down_timer))
+                        atomic_set(&vha->loop_down_timer,
+                                        LOOP_DOWN_TIME);
+        }
+        /* Wait for pending cmds to complete */
+        qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST);
+}
+
 void
 qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
 {
         struct qla_hw_data *ha = vha->hw;
-        struct scsi_qla_host *vp, *base_vha = pci_get_drvdata(ha->pdev);
+        struct scsi_qla_host *vp;
         unsigned long flags;
 
         vha->flags.online = 0;
@@ -3896,7 +3962,7 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
                 qla2x00_mark_all_devices_lost(vha, 0);
 
                 spin_lock_irqsave(&ha->vport_slock, flags);
-                list_for_each_entry(vp, &base_vha->hw->vp_list, list) {
+                list_for_each_entry(vp, &ha->vp_list, list) {
                         atomic_inc(&vp->vref_count);
                         spin_unlock_irqrestore(&ha->vport_slock, flags);
 
@@ -5410,7 +5476,7 @@ qla81xx_update_fw_options(scsi_qla_host_t *vha)
  *      the tag (priority) value is returned.
  *
  * Input:
- *      ha = adapter block po
+ *      vha = scsi host structure pointer.
  *      fcport = port structure pointer.
  *
  * Return:
@@ -5504,7 +5570,7 @@ qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
  *      Activates fcp priority for the logged in fc port
  *
  * Input:
- *      ha = adapter block pointer.
+ *      vha = scsi host structure pointer.
  *      fcp = port structure pointer.
  *
  * Return:
@@ -5514,25 +5580,24 @@ qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
  *      Kernel context.
  */
 int
-qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *ha, fc_port_t *fcport)
+qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int ret;
         uint8_t priority;
         uint16_t mb[5];
 
-        if (atomic_read(&fcport->state) == FCS_UNCONFIGURED ||
-                fcport->port_type != FCT_TARGET ||
-                fcport->loop_id == FC_NO_LOOP_ID)
+        if (fcport->port_type != FCT_TARGET ||
+            fcport->loop_id == FC_NO_LOOP_ID)
                 return QLA_FUNCTION_FAILED;
 
-        priority = qla24xx_get_fcp_prio(ha, fcport);
-        ret = qla24xx_set_fcp_prio(ha, fcport->loop_id, priority, mb);
+        priority = qla24xx_get_fcp_prio(vha, fcport);
+        ret = qla24xx_set_fcp_prio(vha, fcport->loop_id, priority, mb);
         if (ret == QLA_SUCCESS)
                 fcport->fcp_prio = priority;
         else
                 DEBUG2(printk(KERN_WARNING
                         "scsi(%ld): Unable to activate fcp priority, "
-                        " ret=0x%x\n", ha->host_no, ret));
+                        " ret=0x%x\n", vha->host_no, ret));
 
         return  ret;
 }
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 7f77898486a9..d17ed9a94a0c 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -321,6 +321,7 @@ qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
         struct qla_hw_data *ha = vha->hw;
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
         struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
+        struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
         uint32_t        rscn_entry, host_pid;
         uint8_t         rscn_queue_index;
         unsigned long   flags;
@@ -498,6 +499,7 @@ skip_rio:
 
         case MBA_LOOP_DOWN:             /* Loop Down Event */
                 mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox4) : 0;
+                mbx = IS_QLA82XX(ha) ? RD_REG_WORD(&reg82->mailbox_out[4]) : mbx;
                 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
                     "(%x %x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3],
                     mbx));
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index effd8a1403d9..e473e9fb363c 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -4125,7 +4125,7 @@ qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
                 return QLA_FUNCTION_FAILED;
 
         DEBUG11(printk(KERN_INFO
-            "%s(%ld): entered.\n", __func__, ha->host_no));
+            "%s(%ld): entered.\n", __func__, vha->host_no));
 
         mcp->mb[0] = MBC_PORT_PARAMS;
         mcp->mb[1] = loop_id;
@@ -4160,6 +4160,71 @@ qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
 }
 
 int
+qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        struct qla_hw_data *ha = vha->hw;
+
+        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, ha->host_no));
+
+        /* High bits. */
+        mcp->mb[0] = MBC_READ_SFP;
+        mcp->mb[1] = 0x98;
+        mcp->mb[2] = 0;
+        mcp->mb[3] = 0;
+        mcp->mb[6] = 0;
+        mcp->mb[7] = 0;
+        mcp->mb[8] = 1;
+        mcp->mb[9] = 0x01;
+        mcp->mb[10] = BIT_13|BIT_0;
+        mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+        mcp->in_mb = MBX_1|MBX_0;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = 0;
+        rval = qla2x00_mailbox_command(vha, mcp);
+        if (rval != QLA_SUCCESS) {
+                DEBUG2_3_11(printk(KERN_WARNING
+                    "%s(%ld): failed=%x (%x).\n", __func__,
+                    vha->host_no, rval, mcp->mb[0]));
+                ha->flags.thermal_supported = 0;
+                goto fail;
+        }
+        *temp = mcp->mb[1] & 0xFF;
+
+        /* Low bits. */
+        mcp->mb[0] = MBC_READ_SFP;
+        mcp->mb[1] = 0x98;
+        mcp->mb[2] = 0;
+        mcp->mb[3] = 0;
+        mcp->mb[6] = 0;
+        mcp->mb[7] = 0;
+        mcp->mb[8] = 1;
+        mcp->mb[9] = 0x10;
+        mcp->mb[10] = BIT_13|BIT_0;
+        mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+        mcp->in_mb = MBX_1|MBX_0;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = 0;
+        rval = qla2x00_mailbox_command(vha, mcp);
+        if (rval != QLA_SUCCESS) {
+                DEBUG2_3_11(printk(KERN_WARNING
+                    "%s(%ld): failed=%x (%x).\n", __func__,
+                    vha->host_no, rval, mcp->mb[0]));
+                ha->flags.thermal_supported = 0;
+                goto fail;
+        }
+        *frac = ((mcp->mb[1] & 0xFF) >> 6) * 25;
+
+        if (rval == QLA_SUCCESS)
+                DEBUG11(printk(KERN_INFO
+                    "%s(%ld): done.\n", __func__, ha->host_no));
+fail:
+        return rval;
+}
+
+int
 qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
 {
         int rval;
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index ae2acacc0003..fdb96a3584a5 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -1079,11 +1079,55 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
 
         /* Halt all the indiviual PEGs and other blocks of the ISP */
         qla82xx_rom_lock(ha);
+
+        /* mask all niu interrupts */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
+        /* disable xge rx/tx */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
+        /* disable xg1 rx/tx */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x80000, 0x00);
+
+        /* halt sre */
+        val = qla82xx_rd_32(ha, QLA82XX_CRB_SRE + 0x1000);
+        qla82xx_wr_32(ha, QLA82XX_CRB_SRE + 0x1000, val & (~(0x1)));
+
+        /* halt epg */
+        qla82xx_wr_32(ha, QLA82XX_CRB_EPG + 0x1300, 0x1);
+
+        /* halt timers */
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x0, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x8, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x10, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x18, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x100, 0x0);
+
+        /* halt pegs */
+        qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
+        qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_1 + 0x3c, 1);
+        qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c, 1);
+        qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3 + 0x3c, 1);
+        qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_4 + 0x3c, 1);
+
+        /* big hammer */
+        msleep(1000);
         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
                 /* don't reset CAM block on reset */
                 qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
         else
                 qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xffffffff);
+
+        /* reset ms */
+        val = qla82xx_rd_32(ha, QLA82XX_CRB_QDR_NET + 0xe4);
+        val |= (1 << 1);
+        qla82xx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
+        msleep(20);
+
+        /* unreset ms */
+        val = qla82xx_rd_32(ha, QLA82XX_CRB_QDR_NET + 0xe4);
+        val &= ~(1 << 1);
+        qla82xx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
+        msleep(20);
+
         qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
 
         /* Read the signature value from the flash.
@@ -1210,25 +1254,6 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
 }
 
 static int
-qla82xx_check_for_bad_spd(struct qla_hw_data *ha)
-{
-        u32 val = 0;
-        val = qla82xx_rd_32(ha, BOOT_LOADER_DIMM_STATUS);
-        val &= QLA82XX_BOOT_LOADER_MN_ISSUE;
-        if (val & QLA82XX_PEG_TUNE_MN_SPD_ZEROED) {
-                qla_printk(KERN_INFO, ha,
-                        "Memory DIMM SPD not programmed. "
-                        " Assumed valid.\n");
-                return 1;
-        } else if (val) {
-                qla_printk(KERN_INFO, ha,
-                        "Memory DIMM type incorrect.Info:%08X.\n", val);
-                return 2;
-        }
-        return 0;
-}
-
-static int
 qla82xx_pci_mem_write_2M(struct qla_hw_data *ha,
                 u64 off, void *data, int size)
 {
@@ -1293,11 +1318,6 @@ qla82xx_pci_mem_write_2M(struct qla_hw_data *ha,
                 word[startword+1] |= tmpw >> (sz[0] * 8);
         }
 
-        /*
-         * don't lock here - write_wx gets the lock if each time
-         * write_lock_irqsave(&adapter->adapter_lock, flags);
-         * netxen_nic_pci_change_crbwindow_128M(adapter, 0);
-         */
         for (i = 0; i < loop; i++) {
                 temp = off8 + (i << shift_amount);
                 qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_LO, temp);
@@ -1399,12 +1419,6 @@ qla82xx_pci_mem_read_2M(struct qla_hw_data *ha,
         off0[1] = 0;
         sz[1] = size - sz[0];
 
-        /*
-         * don't lock here - write_wx gets the lock if each time
-         * write_lock_irqsave(&adapter->adapter_lock, flags);
-         * netxen_nic_pci_change_crbwindow_128M(adapter, 0);
-         */
-
         for (i = 0; i < loop; i++) {
                 temp = off8 + (i << shift_amount);
                 qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_ADDR_LO, temp);
@@ -1437,11 +1451,6 @@ qla82xx_pci_mem_read_2M(struct qla_hw_data *ha,
                 }
         }
 
-        /*
-         * netxen_nic_pci_change_crbwindow_128M(adapter, 1);
-         * write_unlock_irqrestore(&adapter->adapter_lock, flags);
-         */
-
         if (j >= MAX_CTL_CHECK)
                 return -1;
 
@@ -1872,7 +1881,6 @@ qla82xx_check_cmdpeg_state(struct qla_hw_data *ha)
         qla_printk(KERN_INFO, ha,
             "Cmd Peg initialization failed: 0x%x.\n", val);
 
-        qla82xx_check_for_bad_spd(ha);
         val = qla82xx_rd_32(ha, QLA82XX_ROMUSB_GLB_PEGTUNE_DONE);
         read_lock(&ha->hw_lock);
         qla82xx_wr_32(ha, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
@@ -2343,6 +2351,17 @@ qla82xx_set_qsnt_ready(struct qla_hw_data *ha)
         qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, qsnt_state);
 }
 
+void
+qla82xx_clear_qsnt_ready(scsi_qla_host_t *vha)
+{
+        struct qla_hw_data *ha = vha->hw;
+        uint32_t qsnt_state;
+
+        qsnt_state = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
+        qsnt_state &= ~(QLA82XX_DRVST_QSNT_RDY << (ha->portnum * 4));
+        qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, qsnt_state);
+}
+
 static int
 qla82xx_load_fw(scsi_qla_host_t *vha)
 {
@@ -2542,7 +2561,7 @@ qla2xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
                         *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
                         *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
                         *cur_dsd++ = cpu_to_le32(sg_dma_len(cur_seg));
-                        cur_seg++;
+                        cur_seg = sg_next(cur_seg);
                         avail_dsds--;
                 }
         }
@@ -3261,6 +3280,104 @@ dev_ready:
         return QLA_SUCCESS;
 }
 
+/*
+* qla82xx_need_qsnt_handler
+*    Code to start quiescence sequence
+*
+* Note:
+*      IDC lock must be held upon entry
+*
+* Return: void
+*/
+
+static void
+qla82xx_need_qsnt_handler(scsi_qla_host_t *vha)
+{
+        struct qla_hw_data *ha = vha->hw;
+        uint32_t dev_state, drv_state, drv_active;
+        unsigned long reset_timeout;
+
+        if (vha->flags.online) {
+                /*Block any further I/O and wait for pending cmnds to complete*/
+                qla82xx_quiescent_state_cleanup(vha);
+        }
+
+        /* Set the quiescence ready bit */
+        qla82xx_set_qsnt_ready(ha);
+
+        /*wait for 30 secs for other functions to ack */
+        reset_timeout = jiffies + (30 * HZ);
+
+        drv_state = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
+        drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
+        /* Its 2 that is written when qsnt is acked, moving one bit */
+        drv_active = drv_active << 0x01;
+
+        while (drv_state != drv_active) {
+
+                if (time_after_eq(jiffies, reset_timeout)) {
+                        /* quiescence timeout, other functions didn't ack
+                         * changing the state to DEV_READY
+                         */
+                        qla_printk(KERN_INFO, ha,
+                            "%s: QUIESCENT TIMEOUT\n", QLA2XXX_DRIVER_NAME);
+                        qla_printk(KERN_INFO, ha,
+                            "DRV_ACTIVE:%d DRV_STATE:%d\n", drv_active,
+                            drv_state);
+                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                                                QLA82XX_DEV_READY);
+                        qla_printk(KERN_INFO, ha,
+                            "HW State: DEV_READY\n");
+                        qla82xx_idc_unlock(ha);
+                        qla2x00_perform_loop_resync(vha);
+                        qla82xx_idc_lock(ha);
+
+                        qla82xx_clear_qsnt_ready(vha);
+                        return;
+                }
+
+                qla82xx_idc_unlock(ha);
+                msleep(1000);
+                qla82xx_idc_lock(ha);
+
+                drv_state = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
+                drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
+                drv_active = drv_active << 0x01;
+        }
+        dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
+        /* everyone acked so set the state to DEV_QUIESCENCE */
+        if (dev_state == QLA82XX_DEV_NEED_QUIESCENT) {
+                qla_printk(KERN_INFO, ha, "HW State: DEV_QUIESCENT\n");
+                qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, QLA82XX_DEV_QUIESCENT);
+        }
+}
+
+/*
+* qla82xx_wait_for_state_change
+*    Wait for device state to change from given current state
+*
+* Note:
+*     IDC lock must not be held upon entry
+*
+* Return:
+*    Changed device state.
+*/
+uint32_t
+qla82xx_wait_for_state_change(scsi_qla_host_t *vha, uint32_t curr_state)
+{
+        struct qla_hw_data *ha = vha->hw;
+        uint32_t dev_state;
+
+        do {
+                msleep(1000);
+                qla82xx_idc_lock(ha);
+                dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
+                qla82xx_idc_unlock(ha);
+        } while (dev_state == curr_state);
+
+        return dev_state;
+}
+
 static void
 qla82xx_dev_failed_handler(scsi_qla_host_t *vha)
 {
@@ -3439,15 +3556,28 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         qla82xx_idc_lock(ha);
                         break;
                 case QLA82XX_DEV_NEED_RESET:
-                        if (!ql2xdontresethba)
-                                qla82xx_need_reset_handler(vha);
+                        qla82xx_need_reset_handler(vha);
                         break;
                 case QLA82XX_DEV_NEED_QUIESCENT:
-                        qla82xx_set_qsnt_ready(ha);
+                        qla82xx_need_qsnt_handler(vha);
+                        /* Reset timeout value after quiescence handler */
+                        dev_init_timeout = jiffies + (ha->nx_dev_init_timeout\
+                                                         * HZ);
+                        break;
                 case QLA82XX_DEV_QUIESCENT:
+                        /* Owner will exit and other will wait for the state
+                         * to get changed
+                         */
+                        if (ha->flags.quiesce_owner)
+                                goto exit;
+
                         qla82xx_idc_unlock(ha);
                         msleep(1000);
                         qla82xx_idc_lock(ha);
+
+                        /* Reset timeout value after quiescence handler */
+                        dev_init_timeout = jiffies + (ha->nx_dev_init_timeout\
+                                                         * HZ);
                         break;
                 case QLA82XX_DEV_FAILED:
                         qla82xx_dev_failed_handler(vha);
@@ -3490,6 +3620,13 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                                         &ha->mbx_cmd_flags))
                                         complete(&ha->mbx_intr_comp);
                         }
+                } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
+                        !test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags)) {
+                        DEBUG(qla_printk(KERN_INFO, ha,
+                                "scsi(%ld) %s - detected quiescence needed\n",
+                                vha->host_no, __func__));
+                        set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
+                        qla2xxx_wake_dpc(vha);
                 } else {
                         qla82xx_check_fw_alive(vha);
                 }
diff --git a/drivers/scsi/qla2xxx/qla_nx.h b/drivers/scsi/qla2xxx/qla_nx.h
index 51ec0c5380e8..ed5883f1778a 100644
--- a/drivers/scsi/qla2xxx/qla_nx.h
+++ b/drivers/scsi/qla2xxx/qla_nx.h
@@ -523,8 +523,6 @@
 # define QLA82XX_CAM_RAM_BASE           (QLA82XX_CRB_CAM + 0x02000)
 # define QLA82XX_CAM_RAM(reg)           (QLA82XX_CAM_RAM_BASE + (reg))
 
-#define QLA82XX_PEG_TUNE_MN_SPD_ZEROED  0x80000000
-#define QLA82XX_BOOT_LOADER_MN_ISSUE    0xff00ffff
 #define QLA82XX_PORT_MODE_ADDR          (QLA82XX_CAM_RAM(0x24))
 #define QLA82XX_PEG_HALT_STATUS1        (QLA82XX_CAM_RAM(0xa8))
 #define QLA82XX_PEG_HALT_STATUS2        (QLA82XX_CAM_RAM(0xac))
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 2c0876c81a3f..c194c23ca1fb 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -37,12 +37,12 @@ static struct kmem_cache *srb_cachep;
 static struct kmem_cache *ctx_cachep;
 
 int ql2xlogintimeout = 20;
-module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR);
+module_param(ql2xlogintimeout, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xlogintimeout,
                 "Login timeout value in seconds.");
 
 int qlport_down_retry;
-module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR);
+module_param(qlport_down_retry, int, S_IRUGO);
 MODULE_PARM_DESC(qlport_down_retry,
                 "Maximum number of command retries to a port that returns "
                 "a PORT-DOWN status.");
@@ -55,12 +55,12 @@ MODULE_PARM_DESC(ql2xplogiabsentdevice,
                 "Default is 0 - no PLOGI. 1 - perfom PLOGI.");
 
 int ql2xloginretrycount = 0;
-module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR);
+module_param(ql2xloginretrycount, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xloginretrycount,
                 "Specify an alternate value for the NVRAM login retry count.");
 
 int ql2xallocfwdump = 1;
-module_param(ql2xallocfwdump, int, S_IRUGO|S_IRUSR);
+module_param(ql2xallocfwdump, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xallocfwdump,
                 "Option to enable allocation of memory for a firmware dump "
                 "during HBA initialization.  Memory allocation requirements "
@@ -73,7 +73,7 @@ MODULE_PARM_DESC(ql2xextended_error_logging,
                 "Default is 0 - no logging. 1 - log errors.");
 
 int ql2xshiftctondsd = 6;
-module_param(ql2xshiftctondsd, int, S_IRUGO|S_IRUSR);
+module_param(ql2xshiftctondsd, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xshiftctondsd,
                 "Set to control shifting of command type processing "
                 "based on total number of SG elements.");
@@ -81,7 +81,7 @@ MODULE_PARM_DESC(ql2xshiftctondsd,
 static void qla2x00_free_device(scsi_qla_host_t *);
 
 int ql2xfdmienable=1;
-module_param(ql2xfdmienable, int, S_IRUGO|S_IRUSR);
+module_param(ql2xfdmienable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xfdmienable,
                 "Enables FDMI registrations. "
                 "0 - no FDMI. Default is 1 - perform FDMI.");
@@ -106,27 +106,27 @@ MODULE_PARM_DESC(ql2xenablehba_err_chk,
                 " Default is 0 - Error isolation disabled, 1 - Enable it");
 
 int ql2xiidmaenable=1;
-module_param(ql2xiidmaenable, int, S_IRUGO|S_IRUSR);
+module_param(ql2xiidmaenable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xiidmaenable,
                 "Enables iIDMA settings "
                 "Default is 1 - perform iIDMA. 0 - no iIDMA.");
 
 int ql2xmaxqueues = 1;
-module_param(ql2xmaxqueues, int, S_IRUGO|S_IRUSR);
+module_param(ql2xmaxqueues, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xmaxqueues,
                 "Enables MQ settings "
                 "Default is 1 for single queue. Set it to number "
                 "of queues in MQ mode.");
 
 int ql2xmultique_tag;
-module_param(ql2xmultique_tag, int, S_IRUGO|S_IRUSR);
+module_param(ql2xmultique_tag, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xmultique_tag,
                 "Enables CPU affinity settings for the driver "
                 "Default is 0 for no affinity of request and response IO. "
                 "Set it to 1 to turn on the cpu affinity.");
 
 int ql2xfwloadbin;
-module_param(ql2xfwloadbin, int, S_IRUGO|S_IRUSR);
+module_param(ql2xfwloadbin, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xfwloadbin,
                 "Option to specify location from which to load ISP firmware:\n"
                 " 2 -- load firmware via the request_firmware() (hotplug)\n"
@@ -135,39 +135,32 @@ MODULE_PARM_DESC(ql2xfwloadbin,
                 " 0 -- use default semantics.\n");
 
 int ql2xetsenable;
-module_param(ql2xetsenable, int, S_IRUGO|S_IRUSR);
+module_param(ql2xetsenable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xetsenable,
                 "Enables firmware ETS burst."
                 "Default is 0 - skip ETS enablement.");
 
 int ql2xdbwr = 1;
-module_param(ql2xdbwr, int, S_IRUGO|S_IRUSR);
+module_param(ql2xdbwr, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xdbwr,
         "Option to specify scheme for request queue posting\n"
         " 0 -- Regular doorbell.\n"
         " 1 -- CAMRAM doorbell (faster).\n");
 
-int ql2xdontresethba;
-module_param(ql2xdontresethba, int, S_IRUGO|S_IRUSR);
-MODULE_PARM_DESC(ql2xdontresethba,
-        "Option to specify reset behaviour\n"
-        " 0 (Default) -- Reset on failure.\n"
-        " 1 -- Do not reset on failure.\n");
-
 int ql2xtargetreset = 1;
-module_param(ql2xtargetreset, int, S_IRUGO|S_IRUSR);
+module_param(ql2xtargetreset, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xtargetreset,
                  "Enable target reset."
                  "Default is 1 - use hw defaults.");
 
 int ql2xgffidenable;
-module_param(ql2xgffidenable, int, S_IRUGO|S_IRUSR);
+module_param(ql2xgffidenable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xgffidenable,
                 "Enables GFF_ID checks of port type. "
                 "Default is 0 - Do not use GFF_ID information.");
 
 int ql2xasynctmfenable;
-module_param(ql2xasynctmfenable, int, S_IRUGO|S_IRUSR);
+module_param(ql2xasynctmfenable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xasynctmfenable,
                 "Enables issue of TM IOCBs asynchronously via IOCB mechanism"
                 "Default is 0 - Issue TM IOCBs via mailbox mechanism.");
@@ -2371,7 +2364,7 @@ qla2x00_remove_one(struct pci_dev *pdev)
         list_for_each_entry(vha, &ha->vp_list, list) {
                 atomic_inc(&vha->vref_count);
 
-                if (vha && vha->fc_vport) {
+                if (vha->fc_vport) {
                         spin_unlock_irqrestore(&ha->vport_slock, flags);
 
                         fc_vport_terminate(vha->fc_vport);
@@ -3386,6 +3379,21 @@ qla2x00_do_dpc(void *data)
                         clear_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags);
                 }
 
+                if (test_bit(ISP_QUIESCE_NEEDED, &base_vha->dpc_flags)) {
+                        DEBUG(printk(KERN_INFO "scsi(%ld): dpc: sched "
+                            "qla2x00_quiesce_needed ha = %p\n",
+                            base_vha->host_no, ha));
+                        qla82xx_device_state_handler(base_vha);
+                        clear_bit(ISP_QUIESCE_NEEDED, &base_vha->dpc_flags);
+                        if (!ha->flags.quiesce_owner) {
+                                qla2x00_perform_loop_resync(base_vha);
+
+                                qla82xx_idc_lock(ha);
+                                qla82xx_clear_qsnt_ready(base_vha);
+                                qla82xx_idc_unlock(ha);
+                        }
+                }
+
                 if (test_and_clear_bit(RESET_MARKER_NEEDED,
                                                         &base_vha->dpc_flags) &&
                     (!(test_and_set_bit(RESET_ACTIVE, &base_vha->dpc_flags)))) {
@@ -3589,13 +3597,16 @@ qla2x00_timer(scsi_qla_host_t *vha)
                 return;
         }
 
-        if (IS_QLA82XX(ha))
-                qla82xx_watchdog(vha);
-
         /* Hardware read to raise pending EEH errors during mailbox waits. */
         if (!pci_channel_offline(ha->pdev))
                 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
 
+        if (IS_QLA82XX(ha)) {
+                if (test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags))
+                        start_dpc++;
+                qla82xx_watchdog(vha);
+        }
+
         /* Loop down handler. */
         if (atomic_read(&vha->loop_down_timer) > 0 &&
             !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 76de9574b385..22070621206c 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -669,6 +669,13 @@ qla2xxx_get_flt_info(scsi_qla_host_t *vha, uint32_t flt_addr)
                 def = 1;
         else if (IS_QLA81XX(ha))
                 def = 2;
+
+        /* Assign FCP prio region since older adapters may not have FLT, or
+           FCP prio region in it's FLT.
+         */
+        ha->flt_region_fcp_prio = ha->flags.port0 ?
+            fcp_prio_cfg0[def] : fcp_prio_cfg1[def];
+
         ha->flt_region_flt = flt_addr;
         wptr = (uint16_t *)req->ring;
         flt = (struct qla_flt_header *)req->ring;
@@ -696,10 +703,6 @@ qla2xxx_get_flt_info(scsi_qla_host_t *vha, uint32_t flt_addr)
                 goto no_flash_data;
         }
 
-        /* Assign FCP prio region since older FLT's may not have it */
-        ha->flt_region_fcp_prio = ha->flags.port0 ?
-            fcp_prio_cfg0[def] : fcp_prio_cfg1[def];
-
         loc = locations[1];
         cnt = le16_to_cpu(flt->length) / sizeof(struct qla_flt_region);
         for ( ; cnt; cnt--, region++) {
diff --git a/drivers/scsi/qla4xxx/ql4_dbg.c b/drivers/scsi/qla4xxx/ql4_dbg.c
index edcf048215dd..af62c3cf8752 100644
--- a/drivers/scsi/qla4xxx/ql4_dbg.c
+++ b/drivers/scsi/qla4xxx/ql4_dbg.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_dbg.h b/drivers/scsi/qla4xxx/ql4_dbg.h
index d861c3b411c8..abd83602cdda 100644
--- a/drivers/scsi/qla4xxx/ql4_dbg.h
+++ b/drivers/scsi/qla4xxx/ql4_dbg.h
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_def.h b/drivers/scsi/qla4xxx/ql4_def.h
index 0f3bfc3da5cf..2fc0045b1a52 100644
--- a/drivers/scsi/qla4xxx/ql4_def.h
+++ b/drivers/scsi/qla4xxx/ql4_def.h
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
@@ -175,7 +175,7 @@
 struct srb {
         struct list_head list;  /* (8)   */
         struct scsi_qla_host *ha;       /* HA the SP is queued on */
-        struct ddb_entry        *ddb;
+        struct ddb_entry *ddb;
         uint16_t flags;         /* (1) Status flags. */
 
 #define SRB_DMA_VALID           BIT_3   /* DMA Buffer mapped. */
@@ -191,7 +191,6 @@ struct srb {
         struct scsi_cmnd *cmd;  /* (4) SCSI command block */
         dma_addr_t dma_handle;  /* (4) for unmap of single transfers */
         struct kref srb_ref;    /* reference count for this srb */
-        uint32_t fw_ddb_index;
         uint8_t err_id;         /* error id */
 #define SRB_ERR_PORT       1    /* Request failed because "port down" */
 #define SRB_ERR_LOOP       2    /* Request failed because "loop down" */
diff --git a/drivers/scsi/qla4xxx/ql4_fw.h b/drivers/scsi/qla4xxx/ql4_fw.h
index 5e757d7fff7d..c1985792f034 100644
--- a/drivers/scsi/qla4xxx/ql4_fw.h
+++ b/drivers/scsi/qla4xxx/ql4_fw.h
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_glbl.h b/drivers/scsi/qla4xxx/ql4_glbl.h
index 6575a47501e5..8fad99b7eef4 100644
--- a/drivers/scsi/qla4xxx/ql4_glbl.h
+++ b/drivers/scsi/qla4xxx/ql4_glbl.h
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index dc01fa3da5d1..1629c48c35ef 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_inline.h b/drivers/scsi/qla4xxx/ql4_inline.h
index 9471ac755000..62f90bdec5d5 100644
--- a/drivers/scsi/qla4xxx/ql4_inline.h
+++ b/drivers/scsi/qla4xxx/ql4_inline.h
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_iocb.c b/drivers/scsi/qla4xxx/ql4_iocb.c
index 5ae49fd87846..75fcd82a8fca 100644
--- a/drivers/scsi/qla4xxx/ql4_iocb.c
+++ b/drivers/scsi/qla4xxx/ql4_iocb.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_isr.c b/drivers/scsi/qla4xxx/ql4_isr.c
index 7c33fd5943d5..6ffbe9727dff 100644
--- a/drivers/scsi/qla4xxx/ql4_isr.c
+++ b/drivers/scsi/qla4xxx/ql4_isr.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
@@ -554,7 +554,8 @@ static void qla4xxx_isr_decode_mailbox(struct scsi_qla_host * ha,
                         /* mbox_sts[2] = Old ACB state
                          * mbox_sts[3] = new ACB state */
                         if ((mbox_sts[3] == ACB_STATE_VALID) &&
-                            (mbox_sts[2] == ACB_STATE_TENTATIVE))
+                            ((mbox_sts[2] == ACB_STATE_TENTATIVE) ||
+                            (mbox_sts[2] == ACB_STATE_ACQUIRING)))
                                 set_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags);
                         else if ((mbox_sts[3] == ACB_STATE_ACQUIRING) &&
                             (mbox_sts[2] == ACB_STATE_VALID))
@@ -1077,7 +1078,7 @@ try_msi:
         ret = pci_enable_msi(ha->pdev);
         if (!ret) {
                 ret = request_irq(ha->pdev->irq, qla4_8xxx_msi_handler,
-                        IRQF_DISABLED|IRQF_SHARED, DRIVER_NAME, ha);
+                        0, DRIVER_NAME, ha);
                 if (!ret) {
                         DEBUG2(ql4_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
                         set_bit(AF_MSI_ENABLED, &ha->flags);
@@ -1095,7 +1096,7 @@ try_msi:
 try_intx:
         /* Trying INTx */
         ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
-            IRQF_DISABLED|IRQF_SHARED, DRIVER_NAME, ha);
+            IRQF_SHARED, DRIVER_NAME, ha);
         if (!ret) {
                 DEBUG2(ql4_printk(KERN_INFO, ha, "INTx: Enabled.\n"));
                 set_bit(AF_INTx_ENABLED, &ha->flags);
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index 2d2f9c879bfd..f65626aec7c1 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
@@ -81,23 +81,7 @@ int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
          */
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
-        if (is_qla8022(ha)) {
-                intr_status = readl(&ha->qla4_8xxx_reg->host_int);
-                if (intr_status & ISRX_82XX_RISC_INT) {
-                        /* Service existing interrupt */
-                        DEBUG2(printk("scsi%ld: %s: "
-                            "servicing existing interrupt\n",
-                            ha->host_no, __func__));
-                        intr_status = readl(&ha->qla4_8xxx_reg->host_status);
-                        ha->isp_ops->interrupt_service_routine(ha, intr_status);
-                        clear_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
-                        if (test_bit(AF_INTERRUPTS_ON, &ha->flags) &&
-                            test_bit(AF_INTx_ENABLED, &ha->flags))
-                                qla4_8xxx_wr_32(ha,
-                                    ha->nx_legacy_intr.tgt_mask_reg,
-                                    0xfbff);
-                }
-        } else {
+        if (!is_qla8022(ha)) {
                 intr_status = readl(&ha->reg->ctrl_status);
                 if (intr_status & CSR_SCSI_PROCESSOR_INTR) {
                         /* Service existing interrupt */
@@ -934,7 +918,7 @@ int qla4xxx_abort_task(struct scsi_qla_host *ha, struct srb *srb)
                 return status;
 
         mbox_cmd[0] = MBOX_CMD_ABORT_TASK;
-        mbox_cmd[1] = srb->fw_ddb_index;
+        mbox_cmd[1] = srb->ddb->fw_ddb_index;
         mbox_cmd[2] = index;
         /* Immediate Command Enable */
         mbox_cmd[5] = 0x01;
diff --git a/drivers/scsi/qla4xxx/ql4_nvram.c b/drivers/scsi/qla4xxx/ql4_nvram.c
index f0d0fbf88aa2..b4b859b2d47e 100644
--- a/drivers/scsi/qla4xxx/ql4_nvram.c
+++ b/drivers/scsi/qla4xxx/ql4_nvram.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_nvram.h b/drivers/scsi/qla4xxx/ql4_nvram.h
index 7a8fc66a760d..b3831bd29479 100644
--- a/drivers/scsi/qla4xxx/ql4_nvram.h
+++ b/drivers/scsi/qla4xxx/ql4_nvram.h
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
index 474b10d71364..3d5ef2df4134 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.c
+++ b/drivers/scsi/qla4xxx/ql4_nx.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2009 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
@@ -942,12 +942,55 @@ qla4_8xxx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
 
         /* Halt all the indiviual PEGs and other blocks of the ISP */
         qla4_8xxx_rom_lock(ha);
+
+        /* mask all niu interrupts */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
+        /* disable xge rx/tx */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
+        /* disable xg1 rx/tx */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x80000, 0x00);
+
+        /* halt sre */
+        val = qla4_8xxx_rd_32(ha, QLA82XX_CRB_SRE + 0x1000);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_SRE + 0x1000, val & (~(0x1)));
+
+        /* halt epg */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_EPG + 0x1300, 0x1);
+
+        /* halt timers */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x0, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x8, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x10, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x18, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x100, 0x0);
+
+        /* halt pegs */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_1 + 0x3c, 1);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c, 1);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_3 + 0x3c, 1);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_4 + 0x3c, 1);
+
+        /* big hammer */
+        msleep(1000);
         if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
                 /* don't reset CAM block on reset */
                 qla4_8xxx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
         else
                 qla4_8xxx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xffffffff);
 
+        /* reset ms */
+        val = qla4_8xxx_rd_32(ha, QLA82XX_CRB_QDR_NET + 0xe4);
+        val |= (1 << 1);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
+
+        msleep(20);
+        /* unreset ms */
+        val = qla4_8xxx_rd_32(ha, QLA82XX_CRB_QDR_NET + 0xe4);
+        val &= ~(1 << 1);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
+        msleep(20);
+
         qla4_8xxx_rom_unlock(ha);
 
         /* Read the signature value from the flash.
@@ -1084,14 +1127,14 @@ qla4_8xxx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
 static int
 qla4_8xxx_load_from_flash(struct scsi_qla_host *ha, uint32_t image_start)
 {
-        int  i;
+        int  i, rval = 0;
         long size = 0;
         long flashaddr, memaddr;
         u64 data;
         u32 high, low;
 
         flashaddr = memaddr = ha->hw.flt_region_bootload;
-        size = (image_start - flashaddr)/8;
+        size = (image_start - flashaddr) / 8;
 
         DEBUG2(printk("scsi%ld: %s: bootldr=0x%lx, fw_image=0x%x\n",
             ha->host_no, __func__, flashaddr, image_start));
@@ -1100,14 +1143,18 @@ qla4_8xxx_load_from_flash(struct scsi_qla_host *ha, uint32_t image_start)
                 if ((qla4_8xxx_rom_fast_read(ha, flashaddr, (int *)&low)) ||
                     (qla4_8xxx_rom_fast_read(ha, flashaddr + 4,
                     (int *)&high))) {
-                        return -1;
+                        rval = -1;
+                        goto exit_load_from_flash;
                 }
                 data = ((u64)high << 32) | low ;
-                qla4_8xxx_pci_mem_write_2M(ha, memaddr, &data, 8);
+                rval = qla4_8xxx_pci_mem_write_2M(ha, memaddr, &data, 8);
+                if (rval)
+                        goto exit_load_from_flash;
+
                 flashaddr += 8;
                 memaddr   += 8;
 
-                if (i%0x1000 == 0)
+                if (i % 0x1000 == 0)
                         msleep(1);
 
         }
@@ -1119,7 +1166,8 @@ qla4_8xxx_load_from_flash(struct scsi_qla_host *ha, uint32_t image_start)
         qla4_8xxx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0x80001e);
         read_unlock(&ha->hw_lock);
 
-        return 0;
+exit_load_from_flash:
+        return rval;
 }
 
 static int qla4_8xxx_load_fw(struct scsi_qla_host *ha, uint32_t image_start)
diff --git a/drivers/scsi/qla4xxx/ql4_nx.h b/drivers/scsi/qla4xxx/ql4_nx.h
index ff689bf53007..35376a1c3f1b 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.h
+++ b/drivers/scsi/qla4xxx/ql4_nx.h
@@ -1,8 +1,8 @@
 /*
- * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2008 QLogic Corporation
+ * QLogic iSCSI HBA Driver
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
- * See LICENSE.qla2xxx for copyright and licensing details.
+ * See LICENSE.qla4xxx for copyright and licensing details.
  */
 #ifndef __QLA_NX_H
 #define __QLA_NX_H
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 0d48fb4d1044..3fc1d256636f 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -1,6 +1,6 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
@@ -706,18 +706,22 @@ void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
         dev_state = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
 
         /* don't poll if reset is going on */
-        if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags)) {
+        if (!(test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
+            test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
+            test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags))) {
                 if (dev_state == QLA82XX_DEV_NEED_RESET &&
                     !test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
-                        printk("scsi%ld: %s: HW State: NEED RESET!\n",
-                            ha->host_no, __func__);
-                        set_bit(DPC_RESET_HA, &ha->dpc_flags);
-                        qla4xxx_wake_dpc(ha);
-                        qla4xxx_mailbox_premature_completion(ha);
+                        if (!ql4xdontresethba) {
+                                ql4_printk(KERN_INFO, ha, "%s: HW State: "
+                                    "NEED RESET!\n", __func__);
+                                set_bit(DPC_RESET_HA, &ha->dpc_flags);
+                                qla4xxx_wake_dpc(ha);
+                                qla4xxx_mailbox_premature_completion(ha);
+                        }
                 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
                     !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {
-                        printk("scsi%ld: %s: HW State: NEED QUIES!\n",
-                            ha->host_no, __func__);
+                        ql4_printk(KERN_INFO, ha, "%s: HW State: NEED QUIES!\n",
+                            __func__);
                         set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags);
                         qla4xxx_wake_dpc(ha);
                 } else  {
@@ -1721,6 +1725,14 @@ static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev,
         if (!test_bit(AF_ONLINE, &ha->flags)) {
                 ql4_printk(KERN_WARNING, ha, "Failed to initialize adapter\n");
 
+                if (is_qla8022(ha) && ql4xdontresethba) {
+                        /* Put the device in failed state. */
+                        DEBUG2(printk(KERN_ERR "HW STATE: FAILED\n"));
+                        qla4_8xxx_idc_lock(ha);
+                        qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                            QLA82XX_DEV_FAILED);
+                        qla4_8xxx_idc_unlock(ha);
+                }
                 ret = -ENODEV;
                 goto probe_failed;
         }
diff --git a/drivers/scsi/qla4xxx/ql4_version.h b/drivers/scsi/qla4xxx/ql4_version.h
index 9bfacf4ed137..8475b308e01b 100644
--- a/drivers/scsi/qla4xxx/ql4_version.h
+++ b/drivers/scsi/qla4xxx/ql4_version.h
@@ -1,8 +1,8 @@
 /*
  * QLogic iSCSI HBA Driver
- * Copyright (c)  2003-2006 QLogic Corporation
+ * Copyright (c)  2003-2010 QLogic Corporation
  *
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
 
-#define QLA4XXX_DRIVER_VERSION  "5.02.00-k4"
+#define QLA4XXX_DRIVER_VERSION  "5.02.00-k5"
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 2f1f9b079b10..7b310934efed 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -1805,6 +1805,7 @@ static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
                         devip->sense_buff[5] = (ret >> 8) & 0xff;
                         devip->sense_buff[6] = ret & 0xff;
                 }
+                scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
                 return check_condition_result;
         }
 
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 30ac116186f5..45c75649b9e0 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1124,51 +1124,40 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
                                 struct list_head *work_q,
                                 struct list_head *done_q)
 {
-        struct scsi_cmnd *scmd, *tgtr_scmd, *next;
-        unsigned int id = 0;
-        int rtn;
+        LIST_HEAD(tmp_list);
 
-        do {
-                tgtr_scmd = NULL;
-                list_for_each_entry(scmd, work_q, eh_entry) {
-                        if (id == scmd_id(scmd)) {
-                                tgtr_scmd = scmd;
-                                break;
-                        }
-                }
-                if (!tgtr_scmd) {
-                        /* not one exactly equal; find the next highest */
-                        list_for_each_entry(scmd, work_q, eh_entry) {
-                                if (scmd_id(scmd) > id &&
-                                    (!tgtr_scmd ||
-                                     scmd_id(tgtr_scmd) > scmd_id(scmd)))
-                                                tgtr_scmd = scmd;
-                        }
-                }
-                if (!tgtr_scmd)
-                        /* no more commands, that's it */
-                        break;
+        list_splice_init(work_q, &tmp_list);
+
+        while (!list_empty(&tmp_list)) {
+                struct scsi_cmnd *next, *scmd;
+                int rtn;
+                unsigned int id;
+
+                scmd = list_entry(tmp_list.next, struct scsi_cmnd, eh_entry);
+                id = scmd_id(scmd);
 
                 SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Sending target reset "
                                                   "to target %d\n",
                                                   current->comm, id));
-                rtn = scsi_try_target_reset(tgtr_scmd);
-                if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
-                        list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
-                                if (id == scmd_id(scmd))
-                                        if (!scsi_device_online(scmd->device) ||
-                                            rtn == FAST_IO_FAIL ||
-                                            !scsi_eh_tur(tgtr_scmd))
-                                                scsi_eh_finish_cmd(scmd,
-                                                                   done_q);
-                        }
-                } else
+                rtn = scsi_try_target_reset(scmd);
+                if (rtn != SUCCESS && rtn != FAST_IO_FAIL)
                         SCSI_LOG_ERROR_RECOVERY(3, printk("%s: Target reset"
                                                           " failed target: "
                                                           "%d\n",
                                                           current->comm, id));
-                id++;
-        } while(id != 0);
+                list_for_each_entry_safe(scmd, next, &tmp_list, eh_entry) {
+                        if (scmd_id(scmd) != id)
+                                continue;
+
+                        if ((rtn == SUCCESS || rtn == FAST_IO_FAIL)
+                            && (!scsi_device_online(scmd->device) ||
+                                 rtn == FAST_IO_FAIL || !scsi_eh_tur(scmd)))
+                                scsi_eh_finish_cmd(scmd, done_q);
+                        else
+                                /* push back on work queue for further processing */
+                                list_move(&scmd->eh_entry, work_q);
+                }
+        }
 
         return list_empty(work_q);
 }
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 4a3842212c50..501f67bef719 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1278,11 +1278,10 @@ static inline int scsi_target_queue_ready(struct Scsi_Host *shost,
         }
 
         if (scsi_target_is_busy(starget)) {
-                if (list_empty(&sdev->starved_entry)) {
+                if (list_empty(&sdev->starved_entry))
                         list_add_tail(&sdev->starved_entry,
                                       &shost->starved_list);
-                        return 0;
-                }
+                return 0;
         }
 
         /* We're OK to process the command, so we can't be starved */
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 76ee2e784f75..4c68d36f9ac2 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -993,16 +993,14 @@ static int __remove_child (struct device * dev, void * data)
  */
 void scsi_remove_target(struct device *dev)
 {
-        struct device *rdev;
-
         if (scsi_is_target_device(dev)) {
                 __scsi_remove_target(to_scsi_target(dev));
                 return;
         }
 
-        rdev = get_device(dev);
+        get_device(dev);
         device_for_each_child(dev, NULL, __remove_child);
-        put_device(rdev);
+        put_device(dev);
 }
 EXPORT_SYMBOL(scsi_remove_target);
 
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 332387a6bc25..f905ecb5704d 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -2200,3 +2200,4 @@ MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
 MODULE_DESCRIPTION("iSCSI Transport Interface");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(ISCSI_TRANSPORT_VERSION);
+MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI);
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 956496182c80..365024b0c407 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -583,7 +583,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                  * quietly refuse to do anything to a changed disc until 
                  * the changed bit has been reset
                  */
-                /* printk("SCSI disk has been changed. Prohibiting further I/O.\n"); */
+                /* printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); */
                 goto out;
         }
 
@@ -1023,7 +1023,6 @@ static int sd_media_changed(struct gendisk *disk)
          */
         if (!scsi_device_online(sdp)) {
                 set_media_not_present(sdkp);
-                retval = 1;
                 goto out;
         }
 
@@ -1054,7 +1053,6 @@ static int sd_media_changed(struct gendisk *disk)
                        /* 0x3a is medium not present */
                        sshdr->asc == 0x3a)) {
                 set_media_not_present(sdkp);
-                retval = 1;
                 goto out;
         }
 
@@ -1065,12 +1063,27 @@ static int sd_media_changed(struct gendisk *disk)
          */
         sdkp->media_present = 1;
 
-        retval = sdp->changed;
-        sdp->changed = 0;
 out:
-        if (retval != sdkp->previous_state)
+        /*
+         * Report a media change under the following conditions:
+         *
+         *      Medium is present now and wasn't present before.
+         *      Medium wasn't present before and is present now.
+         *      Medium was present at all times, but it changed while
+         *              we weren't looking (sdp->changed is set).
+         *
+         * If there was no medium before and there is no medium now then
+         * don't report a change, even if a medium was inserted and removed
+         * while we weren't looking.
+         */
+        retval = (sdkp->media_present != sdkp->previous_state ||
+                        (sdkp->media_present && sdp->changed));
+        if (retval)
                 sdev_evt_send_simple(sdp, SDEV_EVT_MEDIA_CHANGE, GFP_KERNEL);
-        sdkp->previous_state = retval;
+        sdkp->previous_state = sdkp->media_present;
+
+        /* sdp->changed indicates medium was changed or is not present */
+        sdp->changed = !sdkp->media_present;
         kfree(sshdr);
         return retval;
 }
@@ -1175,6 +1188,12 @@ static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
         u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
         u64 bad_lba;
         int info_valid;
+        /*
+         * resid is optional but mostly filled in.  When it's unused,
+         * its value is zero, so we assume the whole buffer transferred
+         */
+        unsigned int transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
+        unsigned int good_bytes;
 
         if (scmd->request->cmd_type != REQ_TYPE_FS)
                 return 0;
@@ -1208,7 +1227,8 @@ static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
         /* This computation should always be done in terms of
          * the resolution of the device's medium.
          */
-        return (bad_lba - start_lba) * scmd->device->sector_size;
+        good_bytes = (bad_lba - start_lba) * scmd->device->sector_size;
+        return min(good_bytes, transferred);
 }
 
 /**
@@ -1902,10 +1922,14 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
         int old_rcd = sdkp->RCD;
         int old_dpofua = sdkp->DPOFUA;
 
-        if (sdp->skip_ms_page_8)
-                goto defaults;
-
-        if (sdp->type == TYPE_RBC) {
+        if (sdp->skip_ms_page_8) {
+                if (sdp->type == TYPE_RBC)
+                        goto defaults;
+                else {
+                        modepage = 0x3F;
+                        dbd = 0;
+                }
+        } else if (sdp->type == TYPE_RBC) {
                 modepage = 6;
                 dbd = 8;
         } else {
@@ -1933,13 +1957,11 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
          */
         if (len < 3)
                 goto bad_sense;
-        if (len > 20)
-                len = 20;
-
-        /* Take headers and block descriptors into account */
-        len += data.header_length + data.block_descriptor_length;
-        if (len > SD_BUF_SIZE)
-                goto bad_sense;
+        else if (len > SD_BUF_SIZE) {
+                sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
+                          "data from %d to %d bytes\n", len, SD_BUF_SIZE);
+                len = SD_BUF_SIZE;
+        }
 
         /* Get the data */
         res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
@@ -1947,16 +1969,45 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
         if (scsi_status_is_good(res)) {
                 int offset = data.header_length + data.block_descriptor_length;
 
-                if (offset >= SD_BUF_SIZE - 2) {
-                        sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n");
-                        goto defaults;
+                while (offset < len) {
+                        u8 page_code = buffer[offset] & 0x3F;
+                        u8 spf       = buffer[offset] & 0x40;
+
+                        if (page_code == 8 || page_code == 6) {
+                                /* We're interested only in the first 3 bytes.
+                                 */
+                                if (len - offset <= 2) {
+                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
+                                                  "mode parameter data\n");
+                                        goto defaults;
+                                } else {
+                                        modepage = page_code;
+                                        goto Page_found;
+                                }
+                        } else {
+                                /* Go to the next page */
+                                if (spf && len - offset > 3)
+                                        offset += 4 + (buffer[offset+2] << 8) +
+                                                buffer[offset+3];
+                                else if (!spf && len - offset > 1)
+                                        offset += 2 + buffer[offset+1];
+                                else {
+                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
+                                                  "mode parameter data\n");
+                                        goto defaults;
+                                }
+                        }
                 }
 
-                if ((buffer[offset] & 0x3f) != modepage) {
+                if (modepage == 0x3F) {
+                        sd_printk(KERN_ERR, sdkp, "No Caching mode page "
+                                  "present\n");
+                        goto defaults;
+                } else if ((buffer[offset] & 0x3f) != modepage) {
                         sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
                         goto defaults;
                 }
-
+        Page_found:
                 if (modepage == 8) {
                         sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
                         sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 5b7388f1c835..1871b8ae83ae 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -17,7 +17,7 @@
    Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
  */
 
-static const char *verstr = "20100829";
+static const char *verstr = "20101219";
 
 #include <linux/module.h>
 
@@ -3729,9 +3729,11 @@ static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dm
                 b_size = PAGE_SIZE << order;
         } else {
                 for (b_size = PAGE_SIZE, order = 0;
-                     order < ST_MAX_ORDER && b_size < new_size;
+                     order < ST_MAX_ORDER &&
+                             max_segs * (PAGE_SIZE << order) < new_size;
                      order++, b_size *= 2)
                         ;  /* empty */
+                STbuffer->reserved_page_order = order;
         }
         if (max_segs * (PAGE_SIZE << order) < new_size) {
                 if (order == ST_MAX_ORDER)
@@ -3758,7 +3760,6 @@ static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dm
                 segs++;
         }
         STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
-        STbuffer->reserved_page_order = order;
 
         return 1;
 }
diff --git a/drivers/staging/autofs/root.c b/drivers/staging/autofs/root.c
index 0fdec4befd84..bf0e9755da67 100644
--- a/drivers/staging/autofs/root.c
+++ b/drivers/staging/autofs/root.c
@@ -154,13 +154,16 @@ static int try_to_fill_dentry(struct dentry *dentry, struct super_block *sb, str
  * yet completely filled in, and revalidate has to delay such
  * lookups..
  */
-static int autofs_revalidate(struct dentry * dentry, struct nameidata *nd)
+static int autofs_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
         struct inode * dir;
         struct autofs_sb_info *sbi;
         struct autofs_dir_ent *ent;
         int res;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
         lock_kernel();
         dir = dentry->d_parent->d_inode;
         sbi = autofs_sbi(dir->i_sb);
@@ -237,7 +240,7 @@ static struct dentry *autofs_root_lookup(struct inode *dir, struct dentry *dentr
          *
          * We need to do this before we release the directory semaphore.
          */
-        dentry->d_op = &autofs_dentry_operations;
+        d_set_d_op(dentry, &autofs_dentry_operations);
         dentry->d_flags |= DCACHE_AUTOFS_PENDING;
         d_add(dentry, NULL);
 
diff --git a/drivers/staging/bcm/InterfaceInit.c b/drivers/staging/bcm/InterfaceInit.c
index 824f9a45007a..e97ad99b1bb4 100644
--- a/drivers/staging/bcm/InterfaceInit.c
+++ b/drivers/staging/bcm/InterfaceInit.c
@@ -277,7 +277,7 @@ usbbcm_device_probe(struct usb_interface *intf, const struct usb_device_id *id)
                 if(psAdapter->bDoSuspend)
                 {
 #ifdef CONFIG_PM
-                        udev->autosuspend_delay = 0;
+                        pm_runtime_set_autosuspend_delay(&udev->dev, 0);
                         intf->needs_remote_wakeup = 1;
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
                         udev->autosuspend_disabled = 0;
diff --git a/drivers/staging/pohmelfs/inode.c b/drivers/staging/pohmelfs/inode.c
index 61685ccceda8..cc8d2840f9b6 100644
--- a/drivers/staging/pohmelfs/inode.c
+++ b/drivers/staging/pohmelfs/inode.c
@@ -826,6 +826,13 @@ const struct address_space_operations pohmelfs_aops = {
         .set_page_dirty         = __set_page_dirty_nobuffers,
 };
 
+static void pohmelfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(pohmelfs_inode_cache, POHMELFS_I(inode));
+}
+
 /*
  * ->detroy_inode() callback. Deletes inode from the caches
  *  and frees private data.
@@ -842,8 +849,8 @@ static void pohmelfs_destroy_inode(struct inode *inode)
 
         dprintk("%s: pi: %p, inode: %p, ino: %llu.\n",
                 __func__, pi, &pi->vfs_inode, pi->ino);
-        kmem_cache_free(pohmelfs_inode_cache, pi);
         atomic_long_dec(&psb->total_inodes);
+        call_rcu(&inode->i_rcu, pohmelfs_i_callback);
 }
 
 /*
diff --git a/drivers/staging/pohmelfs/path_entry.c b/drivers/staging/pohmelfs/path_entry.c
index 8ec83d2dffb7..400a9fc386ad 100644
--- a/drivers/staging/pohmelfs/path_entry.c
+++ b/drivers/staging/pohmelfs/path_entry.c
@@ -83,10 +83,11 @@ out:
 int pohmelfs_path_length(struct pohmelfs_inode *pi)
 {
         struct dentry *d, *root, *first;
-        int len = 1; /* Root slash */
+        int len;
+        unsigned seq;
 
-        first = d = d_find_alias(&pi->vfs_inode);
-        if (!d) {
+        first = d_find_alias(&pi->vfs_inode);
+        if (!first) {
                 dprintk("%s: ino: %llu, mode: %o.\n", __func__, pi->ino, pi->vfs_inode.i_mode);
                 return -ENOENT;
         }
@@ -95,7 +96,11 @@ int pohmelfs_path_length(struct pohmelfs_inode *pi)
         root = dget(current->fs->root.dentry);
         spin_unlock(&current->fs->lock);
 
-        spin_lock(&dcache_lock);
+rename_retry:
+        len = 1; /* Root slash */
+        d = first;
+        seq = read_seqbegin(&rename_lock);
+        rcu_read_lock();
 
         if (!IS_ROOT(d) && d_unhashed(d))
                 len += UNHASHED_OBSCURE_STRING_SIZE; /* Obscure " (deleted)" string */
@@ -104,7 +109,9 @@ int pohmelfs_path_length(struct pohmelfs_inode *pi)
                 len += d->d_name.len + 1; /* Plus slash */
                 d = d->d_parent;
         }
-        spin_unlock(&dcache_lock);
+        rcu_read_unlock();
+        if (read_seqretry(&rename_lock, seq))
+                goto rename_retry;
 
         dput(root);
         dput(first);
diff --git a/drivers/staging/smbfs/cache.c b/drivers/staging/smbfs/cache.c
index dbb98658148b..f2a1323ca827 100644
--- a/drivers/staging/smbfs/cache.c
+++ b/drivers/staging/smbfs/cache.c
@@ -62,7 +62,7 @@ smb_invalidate_dircache_entries(struct dentry *parent)
         struct list_head *next;
         struct dentry *dentry;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
                 dentry = list_entry(next, struct dentry, d_u.d_child);
@@ -70,7 +70,7 @@ smb_invalidate_dircache_entries(struct dentry *parent)
                 smb_age_dentry(server, dentry);
                 next = next->next;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
 }
 
 /*
@@ -96,13 +96,13 @@ smb_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
         }
 
         /* If a pointer is invalid, we search the dentry. */
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
                 dent = list_entry(next, struct dentry, d_u.d_child);
                 if ((unsigned long)dent->d_fsdata == fpos) {
                         if (dent->d_inode)
-                                dget_locked(dent);
+                                dget(dent);
                         else
                                 dent = NULL;
                         goto out_unlock;
@@ -111,7 +111,7 @@ smb_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
         }
         dent = NULL;
 out_unlock:
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
         return dent;
 }
 
@@ -134,7 +134,7 @@ smb_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
         qname->hash = full_name_hash(qname->name, qname->len);
 
         if (dentry->d_op && dentry->d_op->d_hash)
-                if (dentry->d_op->d_hash(dentry, qname) != 0)
+                if (dentry->d_op->d_hash(dentry, inode, qname) != 0)
                         goto end_advance;
 
         newdent = d_lookup(dentry, qname);
@@ -145,8 +145,8 @@ smb_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                         goto end_advance;
         } else {
                 hashed = 1;
-                memcpy((char *) newdent->d_name.name, qname->name,
-                       newdent->d_name.len);
+                /* dir i_mutex is locked because we're in readdir */
+                dentry_update_name_case(newdent, qname);
         }
 
         if (!newdent->d_inode) {
diff --git a/drivers/staging/smbfs/dir.c b/drivers/staging/smbfs/dir.c
index f088ea2f6ac9..dd612f50749f 100644
--- a/drivers/staging/smbfs/dir.c
+++ b/drivers/staging/smbfs/dir.c
@@ -14,6 +14,7 @@
 #include <linux/ctype.h>
 #include <linux/net.h>
 #include <linux/sched.h>
+#include <linux/namei.h>
 
 #include "smb_fs.h"
 #include "smb_mount.h"
@@ -274,9 +275,13 @@ smb_dir_open(struct inode *dir, struct file *file)
  * Dentry operations routines
  */
 static int smb_lookup_validate(struct dentry *, struct nameidata *);
-static int smb_hash_dentry(struct dentry *, struct qstr *);
-static int smb_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
-static int smb_delete_dentry(struct dentry *);
+static int smb_hash_dentry(const struct dentry *, const struct inode *,
+                struct qstr *);
+static int smb_compare_dentry(const struct dentry *,
+                const struct inode *,
+                const struct dentry *, const struct inode *,
+                unsigned int, const char *, const struct qstr *);
+static int smb_delete_dentry(const struct dentry *);
 
 static const struct dentry_operations smbfs_dentry_operations =
 {
@@ -297,13 +302,20 @@ static const struct dentry_operations smbfs_dentry_operations_case =
  * This is the callback when the dcache has a lookup hit.
  */
 static int
-smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
+smb_lookup_validate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct smb_sb_info *server = server_from_dentry(dentry);
-        struct inode * inode = dentry->d_inode;
-        unsigned long age = jiffies - dentry->d_time;
+        struct smb_sb_info *server;
+        struct inode *inode;
+        unsigned long age;
         int valid;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        server = server_from_dentry(dentry);
+        inode = dentry->d_inode;
+        age = jiffies - dentry->d_time;
+
         /*
          * The default validation is based on dentry age:
          * we believe in dentries for a few seconds.  (But each
@@ -333,7 +345,8 @@ smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
 }
 
 static int 
-smb_hash_dentry(struct dentry *dir, struct qstr *this)
+smb_hash_dentry(const struct dentry *dir, const struct inode *inode,
+                struct qstr *this)
 {
         unsigned long hash;
         int i;
@@ -347,14 +360,17 @@ smb_hash_dentry(struct dentry *dir, struct qstr *this)
 }
 
 static int
-smb_compare_dentry(struct dentry *dir, struct qstr *a, struct qstr *b)
+smb_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
         int i, result = 1;
 
-        if (a->len != b->len)
+        if (len != name->len)
                 goto out;
-        for (i=0; i < a->len; i++) {
-                if (tolower(a->name[i]) != tolower(b->name[i]))
+        for (i=0; i < len; i++) {
+                if (tolower(str[i]) != tolower(name->name[i]))
                         goto out;
         }
         result = 0;
@@ -367,7 +383,7 @@ out:
  * We use this to unhash dentries with bad inodes.
  */
 static int
-smb_delete_dentry(struct dentry * dentry)
+smb_delete_dentry(const struct dentry *dentry)
 {
         if (dentry->d_inode) {
                 if (is_bad_inode(dentry->d_inode)) {
@@ -390,9 +406,9 @@ smb_new_dentry(struct dentry *dentry)
         struct smb_sb_info *server = server_from_dentry(dentry);
 
         if (server->mnt->flags & SMB_MOUNT_CASE)
-                dentry->d_op = &smbfs_dentry_operations_case;
+                d_set_d_op(dentry, &smbfs_dentry_operations_case);
         else
-                dentry->d_op = &smbfs_dentry_operations;
+                d_set_d_op(dentry, &smbfs_dentry_operations);
         dentry->d_time = jiffies;
 }
 
@@ -454,9 +470,9 @@ smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         add_entry:
                         server = server_from_dentry(dentry);
                         if (server->mnt->flags & SMB_MOUNT_CASE)
-                                dentry->d_op = &smbfs_dentry_operations_case;
+                                d_set_d_op(dentry, &smbfs_dentry_operations_case);
                         else
-                                dentry->d_op = &smbfs_dentry_operations;
+                                d_set_d_op(dentry, &smbfs_dentry_operations);
 
                         d_add(dentry, inode);
                         smb_renew_times(dentry);
diff --git a/drivers/staging/smbfs/file.c b/drivers/staging/smbfs/file.c
index 5dcd19c60eb9..31372e7b12de 100644
--- a/drivers/staging/smbfs/file.c
+++ b/drivers/staging/smbfs/file.c
@@ -407,11 +407,14 @@ smb_file_release(struct inode *inode, struct file * file)
  * privileges, so we need our own check for this.
  */
 static int
-smb_file_permission(struct inode *inode, int mask)
+smb_file_permission(struct inode *inode, int mask, unsigned int flags)
 {
         int mode = inode->i_mode;
         int error = 0;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         VERBOSE("mode=%x, mask=%x\n", mode, mask);
 
         /* Look at user permissions */
diff --git a/drivers/staging/smbfs/inode.c b/drivers/staging/smbfs/inode.c
index 540a984bb516..244319dc9702 100644
--- a/drivers/staging/smbfs/inode.c
+++ b/drivers/staging/smbfs/inode.c
@@ -62,11 +62,18 @@ static struct inode *smb_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void smb_destroy_inode(struct inode *inode)
+static void smb_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(smb_inode_cachep, SMB_I(inode));
 }
 
+static void smb_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, smb_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct smb_inode_info *ei = (struct smb_inode_info *) foo;
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 5a7c8f1d76c6..fceea5e4e02f 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -42,17 +42,13 @@ config USB_ARCH_HAS_OHCI
         default y if ARCH_W90X900
         default y if ARCH_DAVINCI_DA8XX
         default y if ARCH_CNS3XXX
+        default y if PLAT_SPEAR
         # PPC:
         default y if STB03xxx
         default y if PPC_MPC52xx
         # MIPS:
         default y if MIPS_ALCHEMY
         default y if MACH_JZ4740
-        # SH:
-        default y if CPU_SUBTYPE_SH7720
-        default y if CPU_SUBTYPE_SH7721
-        default y if CPU_SUBTYPE_SH7763
-        default y if CPU_SUBTYPE_SH7786
         # more:
         default PCI
 
@@ -68,6 +64,9 @@ config USB_ARCH_HAS_EHCI
         default y if ARCH_MXC
         default y if ARCH_OMAP3
         default y if ARCH_CNS3XXX
+        default y if ARCH_VT8500
+        default y if PLAT_SPEAR
+        default y if ARCH_MSM
         default PCI
 
 # ARM SA1111 chips have a non-PCI based "OHCI-compatible" USB host interface.
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index c0e60fbcb048..b9278a1fb9e5 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -27,7 +27,6 @@
 #include <linux/usb.h>
 #include <linux/usb/quirks.h>
 #include <linux/usb/hcd.h>
-#include <linux/pm_runtime.h>
 
 #include "usb.h"
 
@@ -1262,6 +1261,7 @@ static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
                                         udev->reset_resume);
                 }
         }
+        usb_mark_last_busy(udev);
 
  done:
         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
@@ -1329,7 +1329,6 @@ int usb_resume(struct device *dev, pm_message_t msg)
                         pm_runtime_disable(dev);
                         pm_runtime_set_active(dev);
                         pm_runtime_enable(dev);
-                        udev->last_busy = jiffies;
                         do_unbind_rebind(udev, DO_REBIND);
                 }
         }
@@ -1397,33 +1396,8 @@ void usb_autosuspend_device(struct usb_device *udev)
 {
         int     status;
 
-        udev->last_busy = jiffies;
-        status = pm_runtime_put_sync(&udev->dev);
-        dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
-                        __func__, atomic_read(&udev->dev.power.usage_count),
-                        status);
-}
-
-/**
- * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces
- * @udev: the usb_device to autosuspend
- *
- * This routine should be called when a core subsystem thinks @udev may
- * be ready to autosuspend.
- *
- * @udev's usage counter left unchanged.  If it is 0 and all the interfaces
- * are inactive then an autosuspend will be attempted.  The attempt may
- * fail or be delayed.
- *
- * The caller must hold @udev's device lock.
- *
- * This routine can run only in process context.
- */
-void usb_try_autosuspend_device(struct usb_device *udev)
-{
-        int     status;
-
-        status = pm_runtime_idle(&udev->dev);
+        usb_mark_last_busy(udev);
+        status = pm_runtime_put_sync_autosuspend(&udev->dev);
         dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&udev->dev.power.usage_count),
                         status);
@@ -1482,7 +1456,7 @@ void usb_autopm_put_interface(struct usb_interface *intf)
         struct usb_device       *udev = interface_to_usbdev(intf);
         int                     status;
 
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_dec(&intf->pm_usage_cnt);
         status = pm_runtime_put_sync(&intf->dev);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
@@ -1509,32 +1483,11 @@ EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 void usb_autopm_put_interface_async(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
-        unsigned long           last_busy;
-        int                     status = 0;
+        int                     status;
 
-        last_busy = udev->last_busy;
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_dec(&intf->pm_usage_cnt);
-        pm_runtime_put_noidle(&intf->dev);
-
-        if (udev->dev.power.runtime_auto) {
-                /* Optimization: Don't schedule a delayed autosuspend if
-                 * the timer is already running and the expiration time
-                 * wouldn't change.
-                 *
-                 * We have to use the interface's timer.  Attempts to
-                 * schedule a suspend for the device would fail because
-                 * the interface is still active.
-                 */
-                if (intf->dev.power.timer_expires == 0 ||
-                                round_jiffies_up(last_busy) !=
-                                round_jiffies_up(jiffies)) {
-                        status = pm_schedule_suspend(&intf->dev,
-                                        jiffies_to_msecs(
-                                        round_jiffies_up_relative(
-                                                udev->autosuspend_delay)));
-                }
-        }
+        status = pm_runtime_put(&intf->dev);
         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
                         __func__, atomic_read(&intf->dev.power.usage_count),
                         status);
@@ -1554,7 +1507,7 @@ void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
 
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_dec(&intf->pm_usage_cnt);
         pm_runtime_put_noidle(&intf->dev);
 }
@@ -1612,18 +1565,9 @@ EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
  */
 int usb_autopm_get_interface_async(struct usb_interface *intf)
 {
-        int             status = 0;
-        enum rpm_status s;
-
-        /* Don't request a resume unless the interface is already suspending
-         * or suspended.  Doing so would force a running suspend timer to be
-         * cancelled.
-         */
-        pm_runtime_get_noresume(&intf->dev);
-        s = ACCESS_ONCE(intf->dev.power.runtime_status);
-        if (s == RPM_SUSPENDING || s == RPM_SUSPENDED)
-                status = pm_request_resume(&intf->dev);
+        int     status;
 
+        status = pm_runtime_get(&intf->dev);
         if (status < 0 && status != -EINPROGRESS)
                 pm_runtime_put_noidle(&intf->dev);
         else
@@ -1650,7 +1594,7 @@ void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
 {
         struct usb_device       *udev = interface_to_usbdev(intf);
 
-        udev->last_busy = jiffies;
+        usb_mark_last_busy(udev);
         atomic_inc(&intf->pm_usage_cnt);
         pm_runtime_get_noresume(&intf->dev);
 }
@@ -1661,7 +1605,6 @@ static int autosuspend_check(struct usb_device *udev)
 {
         int                     w, i;
         struct usb_interface    *intf;
-        unsigned long           suspend_time, j;
 
         /* Fail if autosuspend is disabled, or any interfaces are in use, or
          * any interface drivers require remote wakeup but it isn't available.
@@ -1701,87 +1644,46 @@ static int autosuspend_check(struct usb_device *udev)
                 return -EOPNOTSUPP;
         }
         udev->do_remote_wakeup = w;
-
-        /* If everything is okay but the device hasn't been idle for long
-         * enough, queue a delayed autosuspend request.
-         */
-        j = ACCESS_ONCE(jiffies);
-        suspend_time = udev->last_busy + udev->autosuspend_delay;
-        if (time_before(j, suspend_time)) {
-                pm_schedule_suspend(&udev->dev, jiffies_to_msecs(
-                                round_jiffies_up_relative(suspend_time - j)));
-                return -EAGAIN;
-        }
         return 0;
 }
 
 static int usb_runtime_suspend(struct device *dev)
 {
-        int     status = 0;
+        struct usb_device       *udev = to_usb_device(dev);
+        int                     status;
 
         /* A USB device can be suspended if it passes the various autosuspend
          * checks.  Runtime suspend for a USB device means suspending all the
          * interfaces and then the device itself.
          */
-        if (is_usb_device(dev)) {
-                struct usb_device       *udev = to_usb_device(dev);
-
-                if (autosuspend_check(udev) != 0)
-                        return -EAGAIN;
-
-                status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
-
-                /* If an interface fails the suspend, adjust the last_busy
-                 * time so that we don't get another suspend attempt right
-                 * away.
-                 */
-                if (status) {
-                        udev->last_busy = jiffies +
-                                        (udev->autosuspend_delay == 0 ?
-                                                HZ/2 : 0);
-                }
-
-                /* Prevent the parent from suspending immediately after */
-                else if (udev->parent)
-                        udev->parent->last_busy = jiffies;
-        }
+        if (autosuspend_check(udev) != 0)
+                return -EAGAIN;
 
-        /* Runtime suspend for a USB interface doesn't mean anything. */
+        status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
         return status;
 }
 
 static int usb_runtime_resume(struct device *dev)
 {
+        struct usb_device       *udev = to_usb_device(dev);
+        int                     status;
+
         /* Runtime resume for a USB device means resuming both the device
          * and all its interfaces.
          */
-        if (is_usb_device(dev)) {
-                struct usb_device       *udev = to_usb_device(dev);
-                int                     status;
-
-                status = usb_resume_both(udev, PMSG_AUTO_RESUME);
-                udev->last_busy = jiffies;
-                return status;
-        }
-
-        /* Runtime resume for a USB interface doesn't mean anything. */
-        return 0;
+        status = usb_resume_both(udev, PMSG_AUTO_RESUME);
+        return status;
 }
 
 static int usb_runtime_idle(struct device *dev)
 {
+        struct usb_device       *udev = to_usb_device(dev);
+
         /* An idle USB device can be suspended if it passes the various
-         * autosuspend checks.  An idle interface can be suspended at
-         * any time.
+         * autosuspend checks.
          */
-        if (is_usb_device(dev)) {
-                struct usb_device       *udev = to_usb_device(dev);
-
-                if (autosuspend_check(udev) != 0)
-                        return 0;
-        }
-
-        pm_runtime_suspend(dev);
+        if (autosuspend_check(udev) == 0)
+                pm_runtime_autosuspend(dev);
         return 0;
 }
 
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index 3799573bd385..b55d46070a25 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -19,7 +19,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
-#include <linux/pm_runtime.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index ced846ac4141..6a95017fa62b 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -38,7 +38,6 @@
 #include <asm/unaligned.h>
 #include <linux/platform_device.h>
 #include <linux/workqueue.h>
-#include <linux/pm_runtime.h>
 
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 27115b45edc5..b98efae6a1cf 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -24,7 +24,6 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
-#include <linux/pm_runtime.h>
 
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
@@ -1804,8 +1803,15 @@ int usb_new_device(struct usb_device *udev)
 
         /* Tell the runtime-PM framework the device is active */
         pm_runtime_set_active(&udev->dev);
+        pm_runtime_get_noresume(&udev->dev);
+        pm_runtime_use_autosuspend(&udev->dev);
         pm_runtime_enable(&udev->dev);
 
+        /* By default, forbid autosuspend for all devices.  It will be
+         * allowed for hubs during binding.
+         */
+        usb_disable_autosuspend(udev);
+
         err = usb_enumerate_device(udev);       /* Read descriptors */
         if (err < 0)
                 goto fail;
@@ -1831,6 +1837,8 @@ int usb_new_device(struct usb_device *udev)
         }
 
         (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
+        usb_mark_last_busy(udev);
+        pm_runtime_put_sync_autosuspend(&udev->dev);
         return err;
 
 fail:
@@ -2221,6 +2229,7 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
                 msleep(10);
         }
+        usb_mark_last_busy(hub->hdev);
         return status;
 }
 
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index b690aa35df9a..1b125c224dcf 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -343,17 +343,19 @@ static int usbfs_empty (struct dentry *dentry)
 {
         struct list_head *list;
 
-        spin_lock(&dcache_lock);
-
+        spin_lock(&dentry->d_lock);
         list_for_each(list, &dentry->d_subdirs) {
                 struct dentry *de = list_entry(list, struct dentry, d_u.d_child);
+
+                spin_lock_nested(&de->d_lock, DENTRY_D_LOCK_NESTED);
                 if (usbfs_positive(de)) {
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&de->d_lock);
+                        spin_unlock(&dentry->d_lock);
                         return 0;
                 }
+                spin_unlock(&de->d_lock);
         }
-
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
         return 1;
 }
 
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index d6e3e410477e..832487423826 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1804,6 +1804,7 @@ free_interfaces:
                 INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
                 intf->minor = -1;
                 device_initialize(&intf->dev);
+                pm_runtime_no_callbacks(&intf->dev);
                 dev_set_name(&intf->dev, "%d-%s:%d.%d",
                         dev->bus->busnum, dev->devpath,
                         configuration, alt->desc.bInterfaceNumber);
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 25719da45e33..44c595432d6f 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -117,21 +117,6 @@ void usb_detect_quirks(struct usb_device *udev)
                 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
                                 udev->quirks);
 
-#ifdef  CONFIG_USB_SUSPEND
-
-        /* By default, disable autosuspend for all devices.  The hub driver
-         * will enable it for hubs.
-         */
-        usb_disable_autosuspend(udev);
-
-        /* Autosuspend can also be disabled if the initial autosuspend_delay
-         * is negative.
-         */
-        if (udev->autosuspend_delay < 0)
-                usb_autoresume_device(udev);
-
-#endif
-
         /* For the present, all devices default to USB-PERSIST enabled */
 #if 0           /* was: #ifdef CONFIG_PM */
         /* Hubs are automatically enabled for USB-PERSIST */
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 448f5b47fc48..6781c369ce2d 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -233,8 +233,6 @@ static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
 
 #ifdef  CONFIG_PM
 
-static const char power_group[] = "power";
-
 static ssize_t
 show_persist(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -278,7 +276,7 @@ static int add_persist_attributes(struct device *dev)
                 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
                         rc = sysfs_add_file_to_group(&dev->kobj,
                                         &dev_attr_persist.attr,
-                                        power_group);
+                                        power_group_name);
         }
         return rc;
 }
@@ -287,7 +285,7 @@ static void remove_persist_attributes(struct device *dev)
 {
         sysfs_remove_file_from_group(&dev->kobj,
                         &dev_attr_persist.attr,
-                        power_group);
+                        power_group_name);
 }
 #else
 
@@ -336,44 +334,20 @@ static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL);
 static ssize_t
 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct usb_device *udev = to_usb_device(dev);
-
-        return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ);
+        return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
 }
 
 static ssize_t
 set_autosuspend(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct usb_device *udev = to_usb_device(dev);
-        int value, old_delay;
-        int rc;
+        int value;
 
-        if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
-                        value <= - INT_MAX/HZ)
+        if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
+                        value <= -INT_MAX/1000)
                 return -EINVAL;
-        value *= HZ;
-
-        usb_lock_device(udev);
-        old_delay = udev->autosuspend_delay;
-        udev->autosuspend_delay = value;
-
-        if (old_delay < 0) {    /* Autosuspend wasn't allowed */
-                if (value >= 0)
-                        usb_autosuspend_device(udev);
-        } else {                /* Autosuspend was allowed */
-                if (value < 0) {
-                        rc = usb_autoresume_device(udev);
-                        if (rc < 0) {
-                                count = rc;
-                                udev->autosuspend_delay = old_delay;
-                        }
-                } else {
-                        usb_try_autosuspend_device(udev);
-                }
-        }
 
-        usb_unlock_device(udev);
+        pm_runtime_set_autosuspend_delay(dev, value * 1000);
         return count;
 }
 
@@ -438,44 +412,30 @@ set_level(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
 
+static struct attribute *power_attrs[] = {
+        &dev_attr_autosuspend.attr,
+        &dev_attr_level.attr,
+        &dev_attr_connected_duration.attr,
+        &dev_attr_active_duration.attr,
+        NULL,
+};
+static struct attribute_group power_attr_group = {
+        .name   = power_group_name,
+        .attrs  = power_attrs,
+};
+
 static int add_power_attributes(struct device *dev)
 {
         int rc = 0;
 
-        if (is_usb_device(dev)) {
-                rc = sysfs_add_file_to_group(&dev->kobj,
-                                &dev_attr_autosuspend.attr,
-                                power_group);
-                if (rc == 0)
-                        rc = sysfs_add_file_to_group(&dev->kobj,
-                                        &dev_attr_level.attr,
-                                        power_group);
-                if (rc == 0)
-                        rc = sysfs_add_file_to_group(&dev->kobj,
-                                        &dev_attr_connected_duration.attr,
-                                        power_group);
-                if (rc == 0)
-                        rc = sysfs_add_file_to_group(&dev->kobj,
-                                        &dev_attr_active_duration.attr,
-                                        power_group);
-        }
+        if (is_usb_device(dev))
+                rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
         return rc;
 }
 
 static void remove_power_attributes(struct device *dev)
 {
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_active_duration.attr,
-                        power_group);
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_connected_duration.attr,
-                        power_group);
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_level.attr,
-                        power_group);
-        sysfs_remove_file_from_group(&dev->kobj,
-                        &dev_attr_autosuspend.attr,
-                        power_group);
+        sysfs_unmerge_group(&dev->kobj, &power_attr_group);
 }
 
 #else
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index fdd4130fbb7d..079cb57bab4f 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -445,7 +445,8 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
         INIT_LIST_HEAD(&dev->filelist);
 
 #ifdef  CONFIG_PM
-        dev->autosuspend_delay = usb_autosuspend_delay * HZ;
+        pm_runtime_set_autosuspend_delay(&dev->dev,
+                        usb_autosuspend_delay * 1000);
         dev->connect_time = jiffies;
         dev->active_duration = -jiffies;
 #endif
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index cd882203ad34..b975450f403e 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -75,14 +75,12 @@ static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 #ifdef CONFIG_USB_SUSPEND
 
 extern void usb_autosuspend_device(struct usb_device *udev);
-extern void usb_try_autosuspend_device(struct usb_device *udev);
 extern int usb_autoresume_device(struct usb_device *udev);
 extern int usb_remote_wakeup(struct usb_device *dev);
 
 #else
 
 #define usb_autosuspend_device(udev)            do {} while (0)
-#define usb_try_autosuspend_device(udev)        do {} while (0)
 static inline int usb_autoresume_device(struct usb_device *udev)
 {
         return 0;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 607d0db4a988..1dc9739277b4 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -338,6 +338,19 @@ config USB_S3C2410_DEBUG
         boolean "S3C2410 udc debug messages"
         depends on USB_GADGET_S3C2410
 
+config USB_GADGET_PXA_U2O
+        boolean "PXA9xx Processor USB2.0 controller"
+        select USB_GADGET_DUALSPEED
+        help
+          PXA9xx Processor series include a high speed USB2.0 device
+          controller, which support high speed and full speed USB peripheral.
+
+config USB_PXA_U2O
+        tristate
+        depends on USB_GADGET_PXA_U2O
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 #
 # Controllers available in both integrated and discrete versions
 #
@@ -414,8 +427,8 @@ config USB_FSL_QE
         default USB_GADGET
         select USB_GADGET_SELECTED
 
-config USB_GADGET_CI13XXX
-        boolean "MIPS USB CI13xxx"
+config USB_GADGET_CI13XXX_PCI
+        boolean "MIPS USB CI13xxx PCI UDC"
         depends on PCI
         select USB_GADGET_DUALSPEED
         help
@@ -426,9 +439,9 @@ config USB_GADGET_CI13XXX
           dynamically linked module called "ci13xxx_udc" and force all
           gadget drivers to also be dynamically linked.
 
-config USB_CI13XXX
+config USB_CI13XXX_PCI
         tristate
-        depends on USB_GADGET_CI13XXX
+        depends on USB_GADGET_CI13XXX_PCI
         default USB_GADGET
         select USB_GADGET_SELECTED
 
@@ -495,6 +508,49 @@ config USB_LANGWELL
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_EG20T
+        boolean "Intel EG20T(Topcliff) USB Device controller"
+        depends on PCI
+        select USB_GADGET_DUALSPEED
+        help
+          This is a USB device driver for EG20T PCH.
+          EG20T PCH is the platform controller hub that is used in Intel's
+          general embedded platform. EG20T PCH has USB device interface.
+          Using this interface, it is able to access system devices connected
+          to USB device.
+          This driver enables USB device function.
+          USB device is a USB peripheral controller which
+          supports both full and high speed USB 2.0 data transfers.
+          This driver supports both control transfer and bulk transfer modes.
+          This driver dose not support interrupt transfer or isochronous
+          transfer modes.
+
+config USB_EG20T
+        tristate
+        depends on USB_GADGET_EG20T
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
+config USB_GADGET_CI13XXX_MSM
+        boolean "MIPS USB CI13xxx for MSM"
+        depends on ARCH_MSM
+        select USB_GADGET_DUALSPEED
+        select USB_MSM_OTG_72K
+        help
+          MSM SoC has chipidea USB controller.  This driver uses
+          ci13xxx_udc core.
+          This driver depends on OTG driver for PHY initialization,
+          clock management, powering up VBUS, and power management.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "ci13xxx_msm" and force all
+          gadget drivers to also be dynamically linked.
+
+config USB_CI13XXX_MSM
+        tristate
+        depends on USB_GADGET_CI13XXX_MSM
+        default USB_GADGET
+        select USB_GADGET_SELECTED
 
 #
 # LAST -- dummy/emulated controller
@@ -685,6 +741,19 @@ config USB_ETH_EEM
          If you say "y" here, the Ethernet gadget driver will use the EEM
          protocol rather than ECM.  If unsure, say "n".
 
+config USB_G_NCM
+        tristate "Network Control Model (NCM) support"
+        depends on NET
+        select CRC32
+        help
+          This driver implements USB CDC NCM subclass standard. NCM is
+          an advanced protocol for Ethernet encapsulation, allows grouping
+          of several ethernet frames into one USB transfer and diffferent
+          alignment possibilities.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "g_ncm".
+
 config USB_GADGETFS
         tristate "Gadget Filesystem (EXPERIMENTAL)"
         depends on EXPERIMENTAL
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 5780db42417b..55f5e8ae5924 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -21,9 +21,13 @@ fsl_usb2_udc-$(CONFIG_ARCH_MXC)	+= fsl_mxc_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 obj-$(CONFIG_USB_R8A66597)      += r8a66597-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
-obj-$(CONFIG_USB_CI13XXX)       += ci13xxx_udc.o
+obj-$(CONFIG_USB_CI13XXX_PCI)   += ci13xxx_pci.o
 obj-$(CONFIG_USB_S3C_HSOTG)     += s3c-hsotg.o
 obj-$(CONFIG_USB_LANGWELL)      += langwell_udc.o
+obj-$(CONFIG_USB_EG20T)         += pch_udc.o
+obj-$(CONFIG_USB_PXA_U2O)       += mv_udc.o
+mv_udc-y                        := mv_udc_core.o mv_udc_phy.o
+obj-$(CONFIG_USB_CI13XXX_MSM)   += ci13xxx_msm.o
 
 #
 # USB gadget drivers
@@ -43,6 +47,7 @@ g_hid-y				:= hid.o
 g_dbgp-y                        := dbgp.o
 g_nokia-y                       := nokia.o
 g_webcam-y                      := webcam.o
+g_ncm-y                         := ncm.o
 
 obj-$(CONFIG_USB_ZERO)          += g_zero.o
 obj-$(CONFIG_USB_AUDIO)         += g_audio.o
@@ -60,3 +65,4 @@ obj-$(CONFIG_USB_G_DBGP)	+= g_dbgp.o
 obj-$(CONFIG_USB_G_MULTI)       += g_multi.o
 obj-$(CONFIG_USB_G_NOKIA)       += g_nokia.o
 obj-$(CONFIG_USB_G_WEBCAM)      += g_webcam.o
+obj-$(CONFIG_USB_G_NCM)         += g_ncm.o
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 9034e0344723..f8dd7269d79c 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -3359,7 +3359,6 @@ static int udc_probe(struct udc *dev)
         dev_set_name(&dev->gadget.dev, "gadget");
         dev->gadget.dev.release = gadget_release;
         dev->gadget.name = name;
-        dev->gadget.name = name;
         dev->gadget.is_dualspeed = 1;
 
         /* init registers, interrupts, ... */
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index 717ff653fa23..e7c65a4408fb 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -2057,8 +2057,10 @@ static int __exit usba_udc_remove(struct platform_device *pdev)
                 usba_ep_cleanup_debugfs(&usba_ep[i]);
         usba_cleanup_debugfs(udc);
 
-        if (gpio_is_valid(udc->vbus_pin))
+        if (gpio_is_valid(udc->vbus_pin)) {
+                free_irq(gpio_to_irq(udc->vbus_pin), udc);
                 gpio_free(udc->vbus_pin);
+        }
 
         free_irq(udc->irq, udc);
         kfree(usba_ep);
diff --git a/drivers/usb/gadget/ci13xxx_msm.c b/drivers/usb/gadget/ci13xxx_msm.c
new file mode 100644
index 000000000000..139ac9419597
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_msm.c
@@ -0,0 +1,134 @@
+/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/usb/msm_hsusb_hw.h>
+#include <linux/usb/ulpi.h>
+
+#include "ci13xxx_udc.c"
+
+#define MSM_USB_BASE    (udc->regs)
+
+static irqreturn_t msm_udc_irq(int irq, void *data)
+{
+        return udc_irq();
+}
+
+static void ci13xxx_msm_notify_event(struct ci13xxx *udc, unsigned event)
+{
+        struct device *dev = udc->gadget.dev.parent;
+        int val;
+
+        switch (event) {
+        case CI13XXX_CONTROLLER_RESET_EVENT:
+                dev_dbg(dev, "CI13XXX_CONTROLLER_RESET_EVENT received\n");
+                writel(0, USB_AHBBURST);
+                writel(0, USB_AHBMODE);
+                break;
+        case CI13XXX_CONTROLLER_STOPPED_EVENT:
+                dev_dbg(dev, "CI13XXX_CONTROLLER_STOPPED_EVENT received\n");
+                /*
+                 * Put the transceiver in non-driving mode. Otherwise host
+                 * may not detect soft-disconnection.
+                 */
+                val = otg_io_read(udc->transceiver, ULPI_FUNC_CTRL);
+                val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+                val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
+                otg_io_write(udc->transceiver, val, ULPI_FUNC_CTRL);
+                break;
+        default:
+                dev_dbg(dev, "unknown ci13xxx_udc event\n");
+                break;
+        }
+}
+
+static struct ci13xxx_udc_driver ci13xxx_msm_udc_driver = {
+        .name                   = "ci13xxx_msm",
+        .flags                  = CI13XXX_REGS_SHARED |
+                                  CI13XXX_REQUIRE_TRANSCEIVER |
+                                  CI13XXX_PULLUP_ON_VBUS |
+                                  CI13XXX_DISABLE_STREAMING,
+
+        .notify_event           = ci13xxx_msm_notify_event,
+};
+
+static int ci13xxx_msm_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        void __iomem *regs;
+        int irq;
+        int ret;
+
+        dev_dbg(&pdev->dev, "ci13xxx_msm_probe\n");
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get platform resource mem\n");
+                return -ENXIO;
+        }
+
+        regs = ioremap(res->start, resource_size(res));
+        if (!regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                return -ENOMEM;
+        }
+
+        ret = udc_probe(&ci13xxx_msm_udc_driver, &pdev->dev, regs);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "udc_probe failed\n");
+                goto iounmap;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "IRQ not found\n");
+                ret = -ENXIO;
+                goto udc_remove;
+        }
+
+        ret = request_irq(irq, msm_udc_irq, IRQF_SHARED, pdev->name, pdev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "request_irq failed\n");
+                goto udc_remove;
+        }
+
+        pm_runtime_no_callbacks(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        return 0;
+
+udc_remove:
+        udc_remove();
+iounmap:
+        iounmap(regs);
+
+        return ret;
+}
+
+static struct platform_driver ci13xxx_msm_driver = {
+        .probe = ci13xxx_msm_probe,
+        .driver = { .name = "msm_hsusb", },
+};
+
+static int __init ci13xxx_msm_init(void)
+{
+        return platform_driver_register(&ci13xxx_msm_driver);
+}
+module_init(ci13xxx_msm_init);
diff --git a/drivers/usb/gadget/ci13xxx_pci.c b/drivers/usb/gadget/ci13xxx_pci.c
new file mode 100644
index 000000000000..883ab5e832d1
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_pci.c
@@ -0,0 +1,176 @@
+/*
+ * ci13xxx_pci.c - MIPS USB IP core family device controller
+ *
+ * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
+ *
+ * Author: David Lopo
+ *
+ * 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/pci.h>
+
+#include "ci13xxx_udc.c"
+
+/* driver name */
+#define UDC_DRIVER_NAME   "ci13xxx_pci"
+
+/******************************************************************************
+ * PCI block
+ *****************************************************************************/
+/**
+ * ci13xxx_pci_irq: interrut handler
+ * @irq:  irq number
+ * @pdev: USB Device Controller interrupt source
+ *
+ * This function returns IRQ_HANDLED if the IRQ has been handled
+ * This is an ISR don't trace, use attribute interface instead
+ */
+static irqreturn_t ci13xxx_pci_irq(int irq, void *pdev)
+{
+        if (irq == 0) {
+                dev_err(&((struct pci_dev *)pdev)->dev, "Invalid IRQ0 usage!");
+                return IRQ_HANDLED;
+        }
+        return udc_irq();
+}
+
+static struct ci13xxx_udc_driver ci13xxx_pci_udc_driver = {
+        .name           = UDC_DRIVER_NAME,
+};
+
+/**
+ * ci13xxx_pci_probe: PCI probe
+ * @pdev: USB device controller being probed
+ * @id:   PCI hotplug ID connecting controller to UDC framework
+ *
+ * This function returns an error code
+ * Allocates basic PCI resources for this USB device controller, and then
+ * invokes the udc_probe() method to start the UDC associated with it
+ */
+static int __devinit ci13xxx_pci_probe(struct pci_dev *pdev,
+                                       const struct pci_device_id *id)
+{
+        void __iomem *regs = NULL;
+        int retval = 0;
+
+        if (id == NULL)
+                return -EINVAL;
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto done;
+
+        if (!pdev->irq) {
+                dev_err(&pdev->dev, "No IRQ, check BIOS/PCI setup!");
+                retval = -ENODEV;
+                goto disable_device;
+        }
+
+        retval = pci_request_regions(pdev, UDC_DRIVER_NAME);
+        if (retval)
+                goto disable_device;
+
+        /* BAR 0 holds all the registers */
+        regs = pci_iomap(pdev, 0, 0);
+        if (!regs) {
+                dev_err(&pdev->dev, "Error mapping memory!");
+                retval = -EFAULT;
+                goto release_regions;
+        }
+        pci_set_drvdata(pdev, (__force void *)regs);
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        retval = udc_probe(&ci13xxx_pci_udc_driver, &pdev->dev, regs);
+        if (retval)
+                goto iounmap;
+
+        /* our device does not have MSI capability */
+
+        retval = request_irq(pdev->irq, ci13xxx_pci_irq, IRQF_SHARED,
+                             UDC_DRIVER_NAME, pdev);
+        if (retval)
+                goto gadget_remove;
+
+        return 0;
+
+ gadget_remove:
+        udc_remove();
+ iounmap:
+        pci_iounmap(pdev, regs);
+ release_regions:
+        pci_release_regions(pdev);
+ disable_device:
+        pci_disable_device(pdev);
+ done:
+        return retval;
+}
+
+/**
+ * ci13xxx_pci_remove: PCI remove
+ * @pdev: USB Device Controller being removed
+ *
+ * Reverses the effect of ci13xxx_pci_probe(),
+ * first invoking the udc_remove() and then releases
+ * all PCI resources allocated for this USB device controller
+ */
+static void __devexit ci13xxx_pci_remove(struct pci_dev *pdev)
+{
+        free_irq(pdev->irq, pdev);
+        udc_remove();
+        pci_iounmap(pdev, (__force void __iomem *)pci_get_drvdata(pdev));
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+/**
+ * PCI device table
+ * PCI device structure
+ *
+ * Check "pci.h" for details
+ */
+static DEFINE_PCI_DEVICE_TABLE(ci13xxx_pci_id_table) = {
+        { PCI_DEVICE(0x153F, 0x1004) },
+        { PCI_DEVICE(0x153F, 0x1006) },
+        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
+};
+MODULE_DEVICE_TABLE(pci, ci13xxx_pci_id_table);
+
+static struct pci_driver ci13xxx_pci_driver = {
+        .name         = UDC_DRIVER_NAME,
+        .id_table     = ci13xxx_pci_id_table,
+        .probe        = ci13xxx_pci_probe,
+        .remove       = __devexit_p(ci13xxx_pci_remove),
+};
+
+/**
+ * ci13xxx_pci_init: module init
+ *
+ * Driver load
+ */
+static int __init ci13xxx_pci_init(void)
+{
+        return pci_register_driver(&ci13xxx_pci_driver);
+}
+module_init(ci13xxx_pci_init);
+
+/**
+ * ci13xxx_pci_exit: module exit
+ *
+ * Driver unload
+ */
+static void __exit ci13xxx_pci_exit(void)
+{
+        pci_unregister_driver(&ci13xxx_pci_driver);
+}
+module_exit(ci13xxx_pci_exit);
+
+MODULE_AUTHOR("MIPS - David Lopo <dlopo@chipidea.mips.com>");
+MODULE_DESCRIPTION("MIPS CI13XXX USB Peripheral Controller");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("June 2008");
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index 98b36fc88c77..31656a2b4ab4 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -22,7 +22,6 @@
  * - ENDPT:  endpoint operations (Gadget API)
  * - GADGET: gadget operations (Gadget API)
  * - BUS:    bus glue code, bus abstraction layer
- * - PCI:    PCI core interface and PCI resources (interrupts, memory...)
  *
  * Compile Options
  * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
@@ -60,11 +59,11 @@
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
 
 #include "ci13xxx_udc.h"
 
@@ -75,9 +74,6 @@
 /* ctrl register bank access */
 static DEFINE_SPINLOCK(udc_lock);
 
-/* driver name */
-#define UDC_DRIVER_NAME   "ci13xxx_udc"
-
 /* control endpoint description */
 static const struct usb_endpoint_descriptor
 ctrl_endpt_desc = {
@@ -132,6 +128,9 @@ static struct {
         size_t        size;   /* bank size */
 } hw_bank;
 
+/* MSM specific */
+#define ABS_AHBBURST        (0x0090UL)
+#define ABS_AHBMODE         (0x0098UL)
 /* UDC register map */
 #define ABS_CAPLENGTH       (0x100UL)
 #define ABS_HCCPARAMS       (0x108UL)
@@ -248,13 +247,7 @@ static u32 hw_ctest_and_write(u32 addr, u32 mask, u32 data)
         return (reg & mask) >> ffs_nr(mask);
 }
 
-/**
- * hw_device_reset: resets chip (execute without interruption)
- * @base: register base address
- *
- * This function returns an error code
- */
-static int hw_device_reset(void __iomem *base)
+static int hw_device_init(void __iomem *base)
 {
         u32 reg;
 
@@ -271,6 +264,28 @@ static int hw_device_reset(void __iomem *base)
         hw_bank.size += CAP_LAST;
         hw_bank.size /= sizeof(u32);
 
+        reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
+        if (reg == 0 || reg > ENDPT_MAX)
+                return -ENODEV;
+
+        hw_ep_max = reg;   /* cache hw ENDPT_MAX */
+
+        /* setup lock mode ? */
+
+        /* ENDPTSETUPSTAT is '0' by default */
+
+        /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
+
+        return 0;
+}
+/**
+ * hw_device_reset: resets chip (execute without interruption)
+ * @base: register base address
+ *
+ * This function returns an error code
+ */
+static int hw_device_reset(struct ci13xxx *udc)
+{
         /* should flush & stop before reset */
         hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0);
         hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
@@ -279,6 +294,14 @@ static int hw_device_reset(void __iomem *base)
         while (hw_cread(CAP_USBCMD, USBCMD_RST))
                 udelay(10);             /* not RTOS friendly */
 
+
+        if (udc->udc_driver->notify_event)
+                udc->udc_driver->notify_event(udc,
+                        CI13XXX_CONTROLLER_RESET_EVENT);
+
+        if (udc->udc_driver->flags && CI13XXX_DISABLE_STREAMING)
+                hw_cwrite(CAP_USBMODE, USBMODE_SDIS, USBMODE_SDIS);
+
         /* USBMODE should be configured step by step */
         hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_IDLE);
         hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_DEVICE);
@@ -290,18 +313,6 @@ static int hw_device_reset(void __iomem *base)
                 return -ENODEV;
         }
 
-        reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
-        if (reg == 0 || reg > ENDPT_MAX)
-                return -ENODEV;
-
-        hw_ep_max = reg;   /* cache hw ENDPT_MAX */
-
-        /* setup lock mode ? */
-
-        /* ENDPTSETUPSTAT is '0' by default */
-
-        /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
-
         return 0;
 }
 
@@ -1449,7 +1460,7 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
         mReq->ptr->page[0]  = mReq->req.dma;
         for (i = 1; i < 5; i++)
                 mReq->ptr->page[i] =
-                        (mReq->req.dma + i * PAGE_SIZE) & ~TD_RESERVED_MASK;
+                        (mReq->req.dma + i * CI13XXX_PAGE_SIZE) & ~TD_RESERVED_MASK;
 
         /*
          *  QH configuration
@@ -1540,7 +1551,7 @@ __acquires(mEp->lock)
                 list_del_init(&mReq->queue);
                 mReq->req.status = -ESHUTDOWN;
 
-                if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                if (mReq->req.complete != NULL) {
                         spin_unlock(mEp->lock);
                         mReq->req.complete(&mEp->ep, &mReq->req);
                         spin_lock(mEp->lock);
@@ -1557,8 +1568,6 @@ __acquires(mEp->lock)
  * Caller must hold lock
  */
 static int _gadget_stop_activity(struct usb_gadget *gadget)
-__releases(udc->lock)
-__acquires(udc->lock)
 {
         struct usb_ep *ep;
         struct ci13xxx    *udc = container_of(gadget, struct ci13xxx, gadget);
@@ -1570,8 +1579,6 @@ __acquires(udc->lock)
         if (gadget == NULL)
                 return -EINVAL;
 
-        spin_unlock(udc->lock);
-
         /* flush all endpoints */
         gadget_for_each_ep(ep, gadget) {
                 usb_ep_fifo_flush(ep);
@@ -1591,8 +1598,6 @@ __acquires(udc->lock)
                 mEp->status = NULL;
         }
 
-        spin_lock(udc->lock);
-
         return 0;
 }
 
@@ -1621,6 +1626,7 @@ __acquires(udc->lock)
 
         dbg_event(0xFF, "BUS RST", 0);
 
+        spin_unlock(udc->lock);
         retval = _gadget_stop_activity(&udc->gadget);
         if (retval)
                 goto done;
@@ -1629,10 +1635,9 @@ __acquires(udc->lock)
         if (retval)
                 goto done;
 
-        spin_unlock(udc->lock);
         retval = usb_ep_enable(&mEp->ep, &ctrl_endpt_desc);
         if (!retval) {
-                mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_KERNEL);
+                mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_ATOMIC);
                 if (mEp->status == NULL) {
                         usb_ep_disable(&mEp->ep);
                         retval = -ENOMEM;
@@ -1789,18 +1794,20 @@ __acquires(mEp->lock)
 
         dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
 
-        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+        if (!list_empty(&mEp->qh[mEp->dir].queue)) {
+                struct ci13xxx_req* mReqEnq;
+
+                mReqEnq = list_entry(mEp->qh[mEp->dir].queue.next,
+                                  struct ci13xxx_req, queue);
+                _hardware_enqueue(mEp, mReqEnq);
+        }
+
+        if (mReq->req.complete != NULL) {
                 spin_unlock(mEp->lock);
                 mReq->req.complete(&mEp->ep, &mReq->req);
                 spin_lock(mEp->lock);
         }
 
-        if (!list_empty(&mEp->qh[mEp->dir].queue)) {
-                mReq = list_entry(mEp->qh[mEp->dir].queue.next,
-                                  struct ci13xxx_req, queue);
-                _hardware_enqueue(mEp, mReq);
-        }
-
  done:
         return retval;
 }
@@ -2061,7 +2068,6 @@ static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 {
         struct ci13xxx_ep  *mEp  = container_of(ep, struct ci13xxx_ep, ep);
         struct ci13xxx_req *mReq = NULL;
-        unsigned long flags;
 
         trace("%p, %i", ep, gfp_flags);
 
@@ -2070,8 +2076,6 @@ static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
                 return NULL;
         }
 
-        spin_lock_irqsave(mEp->lock, flags);
-
         mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
         if (mReq != NULL) {
                 INIT_LIST_HEAD(&mReq->queue);
@@ -2086,8 +2090,6 @@ static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
 
         dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
 
-        spin_unlock_irqrestore(mEp->lock, flags);
-
         return (mReq == NULL) ? NULL : &mReq->req;
 }
 
@@ -2157,8 +2159,8 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
                 goto done;
         }
 
-        if (req->length > (4 * PAGE_SIZE)) {
-                req->length = (4 * PAGE_SIZE);
+        if (req->length > (4 * CI13XXX_PAGE_SIZE)) {
+                req->length = (4 * CI13XXX_PAGE_SIZE);
                 retval = -EMSGSIZE;
                 warn("request length truncated");
         }
@@ -2170,8 +2172,10 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
         mReq->req.actual = 0;
         list_add_tail(&mReq->queue, &mEp->qh[mEp->dir].queue);
 
-        retval = _hardware_enqueue(mEp, mReq);
-        if (retval == -EALREADY || retval == -EBUSY) {
+        if (list_is_singular(&mEp->qh[mEp->dir].queue))
+                retval = _hardware_enqueue(mEp, mReq);
+
+        if (retval == -EALREADY) {
                 dbg_event(_usb_addr(mEp), "QUEUE", retval);
                 retval = 0;
         }
@@ -2209,7 +2213,7 @@ static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
         list_del_init(&mReq->queue);
         req->status = -ECONNRESET;
 
-        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+        if (mReq->req.complete != NULL) {
                 spin_unlock(mEp->lock);
                 mReq->req.complete(&mEp->ep, &mReq->req);
                 spin_lock(mEp->lock);
@@ -2332,12 +2336,47 @@ static const struct usb_ep_ops usb_ep_ops = {
 /******************************************************************************
  * GADGET block
  *****************************************************************************/
+static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
+{
+        struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
+        unsigned long flags;
+        int gadget_ready = 0;
+
+        if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS))
+                return -EOPNOTSUPP;
+
+        spin_lock_irqsave(udc->lock, flags);
+        udc->vbus_active = is_active;
+        if (udc->driver)
+                gadget_ready = 1;
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        if (gadget_ready) {
+                if (is_active) {
+                        pm_runtime_get_sync(&_gadget->dev);
+                        hw_device_reset(udc);
+                        hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
+                } else {
+                        hw_device_state(0);
+                        if (udc->udc_driver->notify_event)
+                                udc->udc_driver->notify_event(udc,
+                                CI13XXX_CONTROLLER_STOPPED_EVENT);
+                        _gadget_stop_activity(&udc->gadget);
+                        pm_runtime_put_sync(&_gadget->dev);
+                }
+        }
+
+        return 0;
+}
+
 /**
  * Device operations part of the API to the USB controller hardware,
  * which don't involve endpoints (or i/o)
  * Check  "usb_gadget.h" for details
  */
-static const struct usb_gadget_ops usb_gadget_ops;
+static const struct usb_gadget_ops usb_gadget_ops = {
+        .vbus_session   = ci13xxx_vbus_session,
+};
 
 /**
  * usb_gadget_probe_driver: register a gadget driver
@@ -2358,7 +2397,6 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
 
         if (driver             == NULL ||
             bind               == NULL ||
-            driver->unbind     == NULL ||
             driver->setup      == NULL ||
             driver->disconnect == NULL ||
             driver->suspend    == NULL ||
@@ -2372,13 +2410,13 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
         /* alloc resources */
         udc->qh_pool = dma_pool_create("ci13xxx_qh", &udc->gadget.dev,
                                        sizeof(struct ci13xxx_qh),
-                                       64, PAGE_SIZE);
+                                       64, CI13XXX_PAGE_SIZE);
         if (udc->qh_pool == NULL)
                 return -ENOMEM;
 
         udc->td_pool = dma_pool_create("ci13xxx_td", &udc->gadget.dev,
                                        sizeof(struct ci13xxx_td),
-                                       64, PAGE_SIZE);
+                                       64, CI13XXX_PAGE_SIZE);
         if (udc->td_pool == NULL) {
                 dma_pool_destroy(udc->qh_pool);
                 udc->qh_pool = NULL;
@@ -2390,7 +2428,6 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
         info("hw_ep_max = %d", hw_ep_max);
 
         udc->driver = driver;
-        udc->gadget.ops        = NULL;
         udc->gadget.dev.driver = NULL;
 
         retval = 0;
@@ -2410,9 +2447,11 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
                 /* this allocation cannot be random */
                 for (k = RX; k <= TX; k++) {
                         INIT_LIST_HEAD(&mEp->qh[k].queue);
+                        spin_unlock_irqrestore(udc->lock, flags);
                         mEp->qh[k].ptr = dma_pool_alloc(udc->qh_pool,
                                                         GFP_KERNEL,
                                                         &mEp->qh[k].dma);
+                        spin_lock_irqsave(udc->lock, flags);
                         if (mEp->qh[k].ptr == NULL)
                                 retval = -ENOMEM;
                         else
@@ -2429,7 +2468,6 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
 
         /* bind gadget */
         driver->driver.bus     = NULL;
-        udc->gadget.ops        = &usb_gadget_ops;
         udc->gadget.dev.driver = &driver->driver;
 
         spin_unlock_irqrestore(udc->lock, flags);
@@ -2437,12 +2475,24 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
         spin_lock_irqsave(udc->lock, flags);
 
         if (retval) {
-                udc->gadget.ops        = NULL;
                 udc->gadget.dev.driver = NULL;
                 goto done;
         }
 
+        pm_runtime_get_sync(&udc->gadget.dev);
+        if (udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) {
+                if (udc->vbus_active) {
+                        if (udc->udc_driver->flags & CI13XXX_REGS_SHARED)
+                                hw_device_reset(udc);
+                } else {
+                        pm_runtime_put_sync(&udc->gadget.dev);
+                        goto done;
+                }
+        }
+
         retval = hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
+        if (retval)
+                pm_runtime_put_sync(&udc->gadget.dev);
 
  done:
         spin_unlock_irqrestore(udc->lock, flags);
@@ -2475,19 +2525,22 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 
         spin_lock_irqsave(udc->lock, flags);
 
-        hw_device_state(0);
-
-        /* unbind gadget */
-        if (udc->gadget.ops != NULL) {
+        if (!(udc->udc_driver->flags & CI13XXX_PULLUP_ON_VBUS) ||
+                        udc->vbus_active) {
+                hw_device_state(0);
+                if (udc->udc_driver->notify_event)
+                        udc->udc_driver->notify_event(udc,
+                        CI13XXX_CONTROLLER_STOPPED_EVENT);
                 _gadget_stop_activity(&udc->gadget);
+                pm_runtime_put(&udc->gadget.dev);
+        }
 
-                spin_unlock_irqrestore(udc->lock, flags);
-                driver->unbind(&udc->gadget);               /* MAY SLEEP */
-                spin_lock_irqsave(udc->lock, flags);
+        /* unbind gadget */
+        spin_unlock_irqrestore(udc->lock, flags);
+        driver->unbind(&udc->gadget);               /* MAY SLEEP */
+        spin_lock_irqsave(udc->lock, flags);
 
-                udc->gadget.ops        = NULL;
-                udc->gadget.dev.driver = NULL;
-        }
+        udc->gadget.dev.driver = NULL;
 
         /* free resources */
         for (i = 0; i < hw_ep_max; i++) {
@@ -2544,6 +2597,14 @@ static irqreturn_t udc_irq(void)
         }
 
         spin_lock(udc->lock);
+
+        if (udc->udc_driver->flags & CI13XXX_REGS_SHARED) {
+                if (hw_cread(CAP_USBMODE, USBMODE_CM) !=
+                                USBMODE_CM_DEVICE) {
+                        spin_unlock(udc->lock);
+                        return IRQ_NONE;
+                }
+        }
         intr = hw_test_and_clear_intr_active();
         if (intr) {
                 isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intr;
@@ -2602,14 +2663,16 @@ static void udc_release(struct device *dev)
  * No interrupts active, the IRQ has not been requested yet
  * Kernel assumes 32-bit DMA operations by default, no need to dma_set_mask
  */
-static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
+static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
+                void __iomem *regs)
 {
         struct ci13xxx *udc;
         int retval = 0;
 
         trace("%p, %p, %p", dev, regs, name);
 
-        if (dev == NULL || regs == NULL || name == NULL)
+        if (dev == NULL || regs == NULL || driver == NULL ||
+                        driver->name == NULL)
                 return -EINVAL;
 
         udc = kzalloc(sizeof(struct ci13xxx), GFP_KERNEL);
@@ -2617,42 +2680,77 @@ static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
                 return -ENOMEM;
 
         udc->lock = &udc_lock;
+        udc->regs = regs;
+        udc->udc_driver = driver;
 
-        retval = hw_device_reset(regs);
-        if (retval)
-                goto done;
-
-        udc->gadget.ops          = NULL;
+        udc->gadget.ops          = &usb_gadget_ops;
         udc->gadget.speed        = USB_SPEED_UNKNOWN;
         udc->gadget.is_dualspeed = 1;
         udc->gadget.is_otg       = 0;
-        udc->gadget.name         = name;
+        udc->gadget.name         = driver->name;
 
         INIT_LIST_HEAD(&udc->gadget.ep_list);
         udc->gadget.ep0 = NULL;
 
         dev_set_name(&udc->gadget.dev, "gadget");
         udc->gadget.dev.dma_mask = dev->dma_mask;
+        udc->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
         udc->gadget.dev.parent   = dev;
         udc->gadget.dev.release  = udc_release;
 
+        retval = hw_device_init(regs);
+        if (retval < 0)
+                goto free_udc;
+
+        udc->transceiver = otg_get_transceiver();
+
+        if (udc->udc_driver->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
+                if (udc->transceiver == NULL) {
+                        retval = -ENODEV;
+                        goto free_udc;
+                }
+        }
+
+        if (!(udc->udc_driver->flags & CI13XXX_REGS_SHARED)) {
+                retval = hw_device_reset(udc);
+                if (retval)
+                        goto put_transceiver;
+        }
+
         retval = device_register(&udc->gadget.dev);
-        if (retval)
-                goto done;
+        if (retval) {
+                put_device(&udc->gadget.dev);
+                goto put_transceiver;
+        }
 
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
         retval = dbg_create_files(&udc->gadget.dev);
 #endif
-        if (retval) {
-                device_unregister(&udc->gadget.dev);
-                goto done;
+        if (retval)
+                goto unreg_device;
+
+        if (udc->transceiver) {
+                retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                if (retval)
+                        goto remove_dbg;
         }
+        pm_runtime_no_callbacks(&udc->gadget.dev);
+        pm_runtime_enable(&udc->gadget.dev);
 
         _udc = udc;
         return retval;
 
- done:
         err("error = %i", retval);
+remove_dbg:
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        dbg_remove_files(&udc->gadget.dev);
+#endif
+unreg_device:
+        device_unregister(&udc->gadget.dev);
+put_transceiver:
+        if (udc->transceiver)
+                otg_put_transceiver(udc->transceiver);
+free_udc:
         kfree(udc);
         _udc = NULL;
         return retval;
@@ -2672,6 +2770,10 @@ static void udc_remove(void)
                 return;
         }
 
+        if (udc->transceiver) {
+                otg_set_peripheral(udc->transceiver, &udc->gadget);
+                otg_put_transceiver(udc->transceiver);
+        }
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
         dbg_remove_files(&udc->gadget.dev);
 #endif
@@ -2680,156 +2782,3 @@ static void udc_remove(void)
         kfree(udc);
         _udc = NULL;
 }
-
-/******************************************************************************
- * PCI block
- *****************************************************************************/
-/**
- * ci13xxx_pci_irq: interrut handler
- * @irq:  irq number
- * @pdev: USB Device Controller interrupt source
- *
- * This function returns IRQ_HANDLED if the IRQ has been handled
- * This is an ISR don't trace, use attribute interface instead
- */
-static irqreturn_t ci13xxx_pci_irq(int irq, void *pdev)
-{
-        if (irq == 0) {
-                dev_err(&((struct pci_dev *)pdev)->dev, "Invalid IRQ0 usage!");
-                return IRQ_HANDLED;
-        }
-        return udc_irq();
-}
-
-/**
- * ci13xxx_pci_probe: PCI probe
- * @pdev: USB device controller being probed
- * @id:   PCI hotplug ID connecting controller to UDC framework
- *
- * This function returns an error code
- * Allocates basic PCI resources for this USB device controller, and then
- * invokes the udc_probe() method to start the UDC associated with it
- */
-static int __devinit ci13xxx_pci_probe(struct pci_dev *pdev,
-                                       const struct pci_device_id *id)
-{
-        void __iomem *regs = NULL;
-        int retval = 0;
-
-        if (id == NULL)
-                return -EINVAL;
-
-        retval = pci_enable_device(pdev);
-        if (retval)
-                goto done;
-
-        if (!pdev->irq) {
-                dev_err(&pdev->dev, "No IRQ, check BIOS/PCI setup!");
-                retval = -ENODEV;
-                goto disable_device;
-        }
-
-        retval = pci_request_regions(pdev, UDC_DRIVER_NAME);
-        if (retval)
-                goto disable_device;
-
-        /* BAR 0 holds all the registers */
-        regs = pci_iomap(pdev, 0, 0);
-        if (!regs) {
-                dev_err(&pdev->dev, "Error mapping memory!");
-                retval = -EFAULT;
-                goto release_regions;
-        }
-        pci_set_drvdata(pdev, (__force void *)regs);
-
-        pci_set_master(pdev);
-        pci_try_set_mwi(pdev);
-
-        retval = udc_probe(&pdev->dev, regs, UDC_DRIVER_NAME);
-        if (retval)
-                goto iounmap;
-
-        /* our device does not have MSI capability */
-
-        retval = request_irq(pdev->irq, ci13xxx_pci_irq, IRQF_SHARED,
-                             UDC_DRIVER_NAME, pdev);
-        if (retval)
-                goto gadget_remove;
-
-        return 0;
-
- gadget_remove:
-        udc_remove();
- iounmap:
-        pci_iounmap(pdev, regs);
- release_regions:
-        pci_release_regions(pdev);
- disable_device:
-        pci_disable_device(pdev);
- done:
-        return retval;
-}
-
-/**
- * ci13xxx_pci_remove: PCI remove
- * @pdev: USB Device Controller being removed
- *
- * Reverses the effect of ci13xxx_pci_probe(),
- * first invoking the udc_remove() and then releases
- * all PCI resources allocated for this USB device controller
- */
-static void __devexit ci13xxx_pci_remove(struct pci_dev *pdev)
-{
-        free_irq(pdev->irq, pdev);
-        udc_remove();
-        pci_iounmap(pdev, (__force void __iomem *)pci_get_drvdata(pdev));
-        pci_release_regions(pdev);
-        pci_disable_device(pdev);
-}
-
-/**
- * PCI device table
- * PCI device structure
- *
- * Check "pci.h" for details
- */
-static DEFINE_PCI_DEVICE_TABLE(ci13xxx_pci_id_table) = {
-        { PCI_DEVICE(0x153F, 0x1004) },
-        { PCI_DEVICE(0x153F, 0x1006) },
-        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
-};
-MODULE_DEVICE_TABLE(pci, ci13xxx_pci_id_table);
-
-static struct pci_driver ci13xxx_pci_driver = {
-        .name         = UDC_DRIVER_NAME,
-        .id_table     = ci13xxx_pci_id_table,
-        .probe        = ci13xxx_pci_probe,
-        .remove       = __devexit_p(ci13xxx_pci_remove),
-};
-
-/**
- * ci13xxx_pci_init: module init
- *
- * Driver load
- */
-static int __init ci13xxx_pci_init(void)
-{
-        return pci_register_driver(&ci13xxx_pci_driver);
-}
-module_init(ci13xxx_pci_init);
-
-/**
- * ci13xxx_pci_exit: module exit
- *
- * Driver unload
- */
-static void __exit ci13xxx_pci_exit(void)
-{
-        pci_unregister_driver(&ci13xxx_pci_driver);
-}
-module_exit(ci13xxx_pci_exit);
-
-MODULE_AUTHOR("MIPS - David Lopo <dlopo@chipidea.mips.com>");
-MODULE_DESCRIPTION("MIPS CI13XXX USB Peripheral Controller");
-MODULE_LICENSE("GPL");
-MODULE_VERSION("June 2008");
diff --git a/drivers/usb/gadget/ci13xxx_udc.h b/drivers/usb/gadget/ci13xxx_udc.h
index 4026e9cede34..f61fed07f76b 100644
--- a/drivers/usb/gadget/ci13xxx_udc.h
+++ b/drivers/usb/gadget/ci13xxx_udc.h
@@ -19,6 +19,7 @@
 /******************************************************************************
  * DEFINE
  *****************************************************************************/
+#define CI13XXX_PAGE_SIZE  4096ul /* page size for TD's */
 #define ENDPT_MAX          (16)
 #define CTRL_PAYLOAD_MAX   (64)
 #define RX        (0)  /* similar to USB_DIR_OUT but can be used as an index */
@@ -97,9 +98,24 @@ struct ci13xxx_ep {
         struct dma_pool                       *td_pool;
 };
 
+struct ci13xxx;
+struct ci13xxx_udc_driver {
+        const char      *name;
+        unsigned long    flags;
+#define CI13XXX_REGS_SHARED             BIT(0)
+#define CI13XXX_REQUIRE_TRANSCEIVER     BIT(1)
+#define CI13XXX_PULLUP_ON_VBUS          BIT(2)
+#define CI13XXX_DISABLE_STREAMING       BIT(3)
+
+#define CI13XXX_CONTROLLER_RESET_EVENT          0
+#define CI13XXX_CONTROLLER_STOPPED_EVENT        1
+        void    (*notify_event) (struct ci13xxx *udc, unsigned event);
+};
+
 /* CI13XXX UDC descriptor & global resources */
 struct ci13xxx {
         spinlock_t                *lock;      /* ctrl register bank access */
+        void __iomem              *regs;      /* registers address space */
 
         struct dma_pool           *qh_pool;   /* DMA pool for queue heads */
         struct dma_pool           *td_pool;   /* DMA pool for transfer descs */
@@ -108,6 +124,9 @@ struct ci13xxx {
         struct ci13xxx_ep          ci13xxx_ep[ENDPT_MAX]; /* extended endpts */
 
         struct usb_gadget_driver  *driver;     /* 3rd party gadget driver */
+        struct ci13xxx_udc_driver *udc_driver; /* device controller driver */
+        int                        vbus_active; /* is VBUS active */
+        struct otg_transceiver    *transceiver; /* Transceiver struct */
 };
 
 /******************************************************************************
@@ -157,6 +176,7 @@ struct ci13xxx {
 #define    USBMODE_CM_DEVICE  (0x02UL <<  0)
 #define    USBMODE_CM_HOST    (0x03UL <<  0)
 #define USBMODE_SLOM          BIT(3)
+#define USBMODE_SDIS          BIT(4)
 
 /* ENDPTCTRL */
 #define ENDPTCTRL_RXS         BIT(0)
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 8572dad5ecbb..f6ff8456d52d 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -1126,7 +1126,7 @@ static int composite_bind(struct usb_gadget *gadget)
         if (bcdDevice)
                 cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
 
-        /* stirng overrides */
+        /* string overrides */
         if (iManufacturer || !cdev->desc.iManufacturer) {
                 if (!iManufacturer && !composite->iManufacturer &&
                     !*composite_manufacturer)
@@ -1188,6 +1188,8 @@ composite_suspend(struct usb_gadget *gadget)
                 composite->suspend(cdev);
 
         cdev->suspended = 1;
+
+        usb_gadget_vbus_draw(gadget, 2);
 }
 
 static void
@@ -1195,6 +1197,7 @@ composite_resume(struct usb_gadget *gadget)
 {
         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
         struct usb_function             *f;
+        u8                              maxpower;
 
         /* REVISIT:  should we have config level
          * suspend/resume callbacks?
@@ -1207,6 +1210,11 @@ composite_resume(struct usb_gadget *gadget)
                         if (f->resume)
                                 f->resume(f);
                 }
+
+                maxpower = cdev->config->bMaxPower;
+
+                usb_gadget_vbus_draw(gadget, maxpower ?
+                        (2 * maxpower) : CONFIG_USB_GADGET_VBUS_DRAW);
         }
 
         cdev->suspended = 0;
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 1d2a2abbfa80..13b9f47feecd 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -1197,6 +1197,139 @@ static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
 #define Ep_Request      (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
 #define Ep_InRequest    (Ep_Request | USB_DIR_IN)
 
+
+/**
+ * handle_control_request() - handles all control transfers
+ * @dum: pointer to dummy (the_controller)
+ * @urb: the urb request to handle
+ * @setup: pointer to the setup data for a USB device control
+ *       request
+ * @status: pointer to request handling status
+ *
+ * Return 0 - if the request was handled
+ *        1 - if the request wasn't handles
+ *        error code on error
+ */
+static int handle_control_request(struct dummy *dum, struct urb *urb,
+                                  struct usb_ctrlrequest *setup,
+                                  int *status)
+{
+        struct dummy_ep         *ep2;
+        int                     ret_val = 1;
+        unsigned        w_index;
+        unsigned        w_value;
+
+        w_index = le16_to_cpu(setup->wIndex);
+        w_value = le16_to_cpu(setup->wValue);
+        switch (setup->bRequest) {
+        case USB_REQ_SET_ADDRESS:
+                if (setup->bRequestType != Dev_Request)
+                        break;
+                dum->address = w_value;
+                *status = 0;
+                dev_dbg(udc_dev(dum), "set_address = %d\n",
+                                w_value);
+                ret_val = 0;
+                break;
+        case USB_REQ_SET_FEATURE:
+                if (setup->bRequestType == Dev_Request) {
+                        ret_val = 0;
+                        switch (w_value) {
+                        case USB_DEVICE_REMOTE_WAKEUP:
+                                break;
+                        case USB_DEVICE_B_HNP_ENABLE:
+                                dum->gadget.b_hnp_enable = 1;
+                                break;
+                        case USB_DEVICE_A_HNP_SUPPORT:
+                                dum->gadget.a_hnp_support = 1;
+                                break;
+                        case USB_DEVICE_A_ALT_HNP_SUPPORT:
+                                dum->gadget.a_alt_hnp_support = 1;
+                                break;
+                        default:
+                                ret_val = -EOPNOTSUPP;
+                        }
+                        if (ret_val == 0) {
+                                dum->devstatus |= (1 << w_value);
+                                *status = 0;
+                        }
+                } else if (setup->bRequestType == Ep_Request) {
+                        /* endpoint halt */
+                        ep2 = find_endpoint(dum, w_index);
+                        if (!ep2 || ep2->ep.name == ep0name) {
+                                ret_val = -EOPNOTSUPP;
+                                break;
+                        }
+                        ep2->halted = 1;
+                        ret_val = 0;
+                        *status = 0;
+                }
+                break;
+        case USB_REQ_CLEAR_FEATURE:
+                if (setup->bRequestType == Dev_Request) {
+                        ret_val = 0;
+                        switch (w_value) {
+                        case USB_DEVICE_REMOTE_WAKEUP:
+                                w_value = USB_DEVICE_REMOTE_WAKEUP;
+                                break;
+                        default:
+                                ret_val = -EOPNOTSUPP;
+                                break;
+                        }
+                        if (ret_val == 0) {
+                                dum->devstatus &= ~(1 << w_value);
+                                *status = 0;
+                        }
+                } else if (setup->bRequestType == Ep_Request) {
+                        /* endpoint halt */
+                        ep2 = find_endpoint(dum, w_index);
+                        if (!ep2) {
+                                ret_val = -EOPNOTSUPP;
+                                break;
+                        }
+                        if (!ep2->wedged)
+                                ep2->halted = 0;
+                        ret_val = 0;
+                        *status = 0;
+                }
+                break;
+        case USB_REQ_GET_STATUS:
+                if (setup->bRequestType == Dev_InRequest
+                                || setup->bRequestType == Intf_InRequest
+                                || setup->bRequestType == Ep_InRequest) {
+                        char *buf;
+                        /*
+                         * device: remote wakeup, selfpowered
+                         * interface: nothing
+                         * endpoint: halt
+                         */
+                        buf = (char *)urb->transfer_buffer;
+                        if (urb->transfer_buffer_length > 0) {
+                                if (setup->bRequestType == Ep_InRequest) {
+                                        ep2 = find_endpoint(dum, w_index);
+                                        if (!ep2) {
+                                                ret_val = -EOPNOTSUPP;
+                                                break;
+                                        }
+                                        buf[0] = ep2->halted;
+                                } else if (setup->bRequestType ==
+                                           Dev_InRequest) {
+                                        buf[0] = (u8)dum->devstatus;
+                                } else
+                                        buf[0] = 0;
+                        }
+                        if (urb->transfer_buffer_length > 1)
+                                buf[1] = 0;
+                        urb->actual_length = min_t(u32, 2,
+                                urb->transfer_buffer_length);
+                        ret_val = 0;
+                        *status = 0;
+                }
+                break;
+        }
+        return ret_val;
+}
+
 /* drive both sides of the transfers; looks like irq handlers to
  * both drivers except the callbacks aren't in_irq().
  */
@@ -1299,14 +1432,8 @@ restart:
                 if (ep == &dum->ep [0] && ep->setup_stage) {
                         struct usb_ctrlrequest          setup;
                         int                             value = 1;
-                        struct dummy_ep                 *ep2;
-                        unsigned                        w_index;
-                        unsigned                        w_value;
 
                         setup = *(struct usb_ctrlrequest*) urb->setup_packet;
-                        w_index = le16_to_cpu(setup.wIndex);
-                        w_value = le16_to_cpu(setup.wValue);
-
                         /* paranoia, in case of stale queued data */
                         list_for_each_entry (req, &ep->queue, queue) {
                                 list_del_init (&req->queue);
@@ -1328,117 +1455,9 @@ restart:
                         ep->last_io = jiffies;
                         ep->setup_stage = 0;
                         ep->halted = 0;
-                        switch (setup.bRequest) {
-                        case USB_REQ_SET_ADDRESS:
-                                if (setup.bRequestType != Dev_Request)
-                                        break;
-                                dum->address = w_value;
-                                status = 0;
-                                dev_dbg (udc_dev(dum), "set_address = %d\n",
-                                                w_value);
-                                value = 0;
-                                break;
-                        case USB_REQ_SET_FEATURE:
-                                if (setup.bRequestType == Dev_Request) {
-                                        value = 0;
-                                        switch (w_value) {
-                                        case USB_DEVICE_REMOTE_WAKEUP:
-                                                break;
-                                        case USB_DEVICE_B_HNP_ENABLE:
-                                                dum->gadget.b_hnp_enable = 1;
-                                                break;
-                                        case USB_DEVICE_A_HNP_SUPPORT:
-                                                dum->gadget.a_hnp_support = 1;
-                                                break;
-                                        case USB_DEVICE_A_ALT_HNP_SUPPORT:
-                                                dum->gadget.a_alt_hnp_support
-                                                        = 1;
-                                                break;
-                                        default:
-                                                value = -EOPNOTSUPP;
-                                        }
-                                        if (value == 0) {
-                                                dum->devstatus |=
-                                                        (1 << w_value);
-                                                status = 0;
-                                        }
 
-                                } else if (setup.bRequestType == Ep_Request) {
-                                        // endpoint halt
-                                        ep2 = find_endpoint (dum, w_index);
-                                        if (!ep2 || ep2->ep.name == ep0name) {
-                                                value = -EOPNOTSUPP;
-                                                break;
-                                        }
-                                        ep2->halted = 1;
-                                        value = 0;
-                                        status = 0;
-                                }
-                                break;
-                        case USB_REQ_CLEAR_FEATURE:
-                                if (setup.bRequestType == Dev_Request) {
-                                        switch (w_value) {
-                                        case USB_DEVICE_REMOTE_WAKEUP:
-                                                dum->devstatus &= ~(1 <<
-                                                        USB_DEVICE_REMOTE_WAKEUP);
-                                                value = 0;
-                                                status = 0;
-                                                break;
-                                        default:
-                                                value = -EOPNOTSUPP;
-                                                break;
-                                        }
-                                } else if (setup.bRequestType == Ep_Request) {
-                                        // endpoint halt
-                                        ep2 = find_endpoint (dum, w_index);
-                                        if (!ep2) {
-                                                value = -EOPNOTSUPP;
-                                                break;
-                                        }
-                                        if (!ep2->wedged)
-                                                ep2->halted = 0;
-                                        value = 0;
-                                        status = 0;
-                                }
-                                break;
-                        case USB_REQ_GET_STATUS:
-                                if (setup.bRequestType == Dev_InRequest
-                                                || setup.bRequestType
-                                                        == Intf_InRequest
-                                                || setup.bRequestType
-                                                        == Ep_InRequest
-                                                ) {
-                                        char *buf;
-
-                                        // device: remote wakeup, selfpowered
-                                        // interface: nothing
-                                        // endpoint: halt
-                                        buf = (char *)urb->transfer_buffer;
-                                        if (urb->transfer_buffer_length > 0) {
-                                                if (setup.bRequestType ==
-                                                                Ep_InRequest) {
-        ep2 = find_endpoint (dum, w_index);
-        if (!ep2) {
-                value = -EOPNOTSUPP;
-                break;
-        }
-        buf [0] = ep2->halted;
-                                                } else if (setup.bRequestType ==
-                                                                Dev_InRequest) {
-                                                        buf [0] = (u8)
-                                                                dum->devstatus;
-                                                } else
-                                                        buf [0] = 0;
-                                        }
-                                        if (urb->transfer_buffer_length > 1)
-                                                buf [1] = 0;
-                                        urb->actual_length = min_t(u32, 2,
-                                                urb->transfer_buffer_length);
-                                        value = 0;
-                                        status = 0;
-                                }
-                                break;
-                        }
+                        value = handle_control_request(dum, urb, &setup,
+                                                       &status);
 
                         /* gadget driver handles all other requests.  block
                          * until setup() returns; no reentrancy issues etc.
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 484c5ba5450e..1499f9e4afa8 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -1,10 +1,10 @@
 /*
- * f_fs.c -- user mode filesystem api for usb composite funtcion controllers
+ * f_fs.c -- user mode file system API for USB composite function controllers
  *
  * Copyright (C) 2010 Samsung Electronics
  * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
  *
- * Based on inode.c (GadgetFS):
+ * Based on inode.c (GadgetFS) which was:
  * Copyright (C) 2003-2004 David Brownell
  * Copyright (C) 2003 Agilent Technologies
  *
@@ -38,62 +38,56 @@
 #define FUNCTIONFS_MAGIC        0xa647361 /* Chosen by a honest dice roll ;) */
 
 
-/* Debuging *****************************************************************/
-
-#define ffs_printk(level, fmt, args...) printk(level "f_fs: " fmt "\n", ## args)
-
-#define FERR(...)  ffs_printk(KERN_ERR,  __VA_ARGS__)
-#define FINFO(...) ffs_printk(KERN_INFO, __VA_ARGS__)
-
-#ifdef DEBUG
-#  define FDBG(...) ffs_printk(KERN_DEBUG, __VA_ARGS__)
-#else
-#  define FDBG(...) do { } while (0)
-#endif /* DEBUG */
-
-#ifdef VERBOSE_DEBUG
-#  define FVDBG FDBG
-#else
-#  define FVDBG(...) do { } while (0)
-#endif /* VERBOSE_DEBUG */
-
-#define ENTER()    FVDBG("%s()", __func__)
+/* Debugging ****************************************************************/
 
 #ifdef VERBOSE_DEBUG
+#  define pr_vdebug pr_debug
 #  define ffs_dump_mem(prefix, ptr, len) \
-        print_hex_dump_bytes("f_fs" prefix ": ", DUMP_PREFIX_NONE, ptr, len)
+        print_hex_dump_bytes(pr_fmt(prefix ": "), DUMP_PREFIX_NONE, ptr, len)
 #else
+#  define pr_vdebug(...)                 do { } while (0)
 #  define ffs_dump_mem(prefix, ptr, len) do { } while (0)
-#endif
+#endif /* VERBOSE_DEBUG */
+
+#define ENTER()    pr_vdebug("%s()\n", __func__)
 
 
 /* The data structure and setup file ****************************************/
 
 enum ffs_state {
-        /* Waiting for descriptors and strings. */
-        /* In this state no open(2), read(2) or write(2) on epfiles
+        /*
+         * Waiting for descriptors and strings.
+         *
+         * In this state no open(2), read(2) or write(2) on epfiles
          * may succeed (which should not be the problem as there
-         * should be no such files opened in the firts place). */
+         * should be no such files opened in the first place).
+         */
         FFS_READ_DESCRIPTORS,
         FFS_READ_STRINGS,
 
-        /* We've got descriptors and strings.  We are or have called
+        /*
+         * We've got descriptors and strings.  We are or have called
          * functionfs_ready_callback().  functionfs_bind() may have
-         * been called but we don't know. */
-        /* This is the only state in which operations on epfiles may
-         * succeed. */
+         * been called but we don't know.
+         *
+         * This is the only state in which operations on epfiles may
+         * succeed.
+         */
         FFS_ACTIVE,
 
-        /* All endpoints have been closed.  This state is also set if
+        /*
+         * All endpoints have been closed.  This state is also set if
          * we encounter an unrecoverable error.  The only
          * unrecoverable error is situation when after reading strings
-         * from user space we fail to initialise EP files or
-         * functionfs_ready_callback() returns with error (<0). */
-        /* In this state no open(2), read(2) or write(2) (both on ep0
+         * from user space we fail to initialise epfiles or
+         * functionfs_ready_callback() returns with error (<0).
+         *
+         * In this state no open(2), read(2) or write(2) (both on ep0
          * as well as epfile) may succeed (at this point epfiles are
          * unlinked and all closed so this is not a problem; ep0 is
          * also closed but ep0 file exists and so open(2) on ep0 must
-         * fail). */
+         * fail).
+         */
         FFS_CLOSING
 };
 
@@ -101,14 +95,18 @@ enum ffs_state {
 enum ffs_setup_state {
         /* There is no setup request pending. */
         FFS_NO_SETUP,
-        /* User has read events and there was a setup request event
+        /*
+         * User has read events and there was a setup request event
          * there.  The next read/write on ep0 will handle the
-         * request. */
+         * request.
+         */
         FFS_SETUP_PENDING,
-        /* There was event pending but before user space handled it
+        /*
+         * There was event pending but before user space handled it
          * some other event was introduced which canceled existing
          * setup.  If this state is set read/write on ep0 return
-         * -EIDRM.  This state is only set when adding event. */
+         * -EIDRM.  This state is only set when adding event.
+         */
         FFS_SETUP_CANCELED
 };
 
@@ -120,23 +118,29 @@ struct ffs_function;
 struct ffs_data {
         struct usb_gadget               *gadget;
 
-        /* Protect access read/write operations, only one read/write
+        /*
+         * Protect access read/write operations, only one read/write
          * at a time.  As a consequence protects ep0req and company.
          * While setup request is being processed (queued) this is
-         * held. */
+         * held.
+         */
         struct mutex                    mutex;
 
-        /* Protect access to enpoint related structures (basically
+        /*
+         * Protect access to endpoint related structures (basically
          * usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for
-         * endpint zero. */
+         * endpoint zero.
+         */
         spinlock_t                      eps_lock;
 
-        /* XXX REVISIT do we need our own request? Since we are not
-         * handling setup requests immidiatelly user space may be so
+        /*
+         * XXX REVISIT do we need our own request? Since we are not
+         * handling setup requests immediately user space may be so
          * slow that another setup will be sent to the gadget but this
          * time not to us but another function and then there could be
          * a race.  Is that the case? Or maybe we can use cdev->req
-         * after all, maybe we just need some spinlock for that? */
+         * after all, maybe we just need some spinlock for that?
+         */
         struct usb_request              *ep0req;                /* P: mutex */
         struct completion               ep0req_completion;      /* P: mutex */
         int                             ep0req_status;          /* P: mutex */
@@ -150,7 +154,7 @@ struct ffs_data {
         enum ffs_state                  state;
 
         /*
-         * Possible transations:
+         * Possible transitions:
          * + FFS_NO_SETUP       -> FFS_SETUP_PENDING  -- P: ev.waitq.lock
          *               happens only in ep0 read which is P: mutex
          * + FFS_SETUP_PENDING  -> FFS_NO_SETUP       -- P: ev.waitq.lock
@@ -183,18 +187,21 @@ struct ffs_data {
         /* Active function */
         struct ffs_function             *func;
 
-        /* Device name, write once when file system is mounted.
-         * Intendet for user to read if she wants. */
+        /*
+         * Device name, write once when file system is mounted.
+         * Intended for user to read if she wants.
+         */
         const char                      *dev_name;
-        /* Private data for our user (ie. gadget).  Managed by
-         * user. */
+        /* Private data for our user (ie. gadget).  Managed by user. */
         void                            *private_data;
 
         /* filled by __ffs_data_got_descs() */
-        /* real descriptors are 16 bytes after raw_descs (so you need
+        /*
+         * Real descriptors are 16 bytes after raw_descs (so you need
          * to skip 16 bytes (ie. ffs->raw_descs + 16) to get to the
          * first full speed descriptor).  raw_descs_length and
-         * raw_fs_descs_length do not have those 16 bytes added. */
+         * raw_fs_descs_length do not have those 16 bytes added.
+         */
         const void                      *raw_descs;
         unsigned                        raw_descs_length;
         unsigned                        raw_fs_descs_length;
@@ -211,18 +218,23 @@ struct ffs_data {
         const void                      *raw_strings;
         struct usb_gadget_strings       **stringtabs;
 
-        /* File system's super block, write once when file system is mounted. */
+        /*
+         * File system's super block, write once when file system is
+         * mounted.
+         */
         struct super_block              *sb;
 
-        /* File permissions, written once when fs is mounted*/
+        /* File permissions, written once when fs is mounted */
         struct ffs_file_perms {
                 umode_t                         mode;
                 uid_t                           uid;
                 gid_t                           gid;
         }                               file_perms;
 
-        /* The endpoint files, filled by ffs_epfiles_create(),
-         * destroyed by ffs_epfiles_destroy(). */
+        /*
+         * The endpoint files, filled by ffs_epfiles_create(),
+         * destroyed by ffs_epfiles_destroy().
+         */
         struct ffs_epfile               *epfiles;
 };
 
@@ -236,7 +248,7 @@ static struct ffs_data *__must_check ffs_data_new(void) __attribute__((malloc));
 static void ffs_data_opened(struct ffs_data *ffs);
 static void ffs_data_closed(struct ffs_data *ffs);
 
-/* Called with ffs->mutex held; take over ownerrship of data. */
+/* Called with ffs->mutex held; take over ownership of data. */
 static int __must_check
 __ffs_data_got_descs(struct ffs_data *ffs, char *data, size_t len);
 static int __must_check
@@ -267,11 +279,9 @@ static struct ffs_function *ffs_func_from_usb(struct usb_function *f)
 
 static void ffs_func_free(struct ffs_function *func);
 
-
 static void ffs_func_eps_disable(struct ffs_function *func);
 static int __must_check ffs_func_eps_enable(struct ffs_function *func);
 
-
 static int ffs_func_bind(struct usb_configuration *,
                          struct usb_function *);
 static void ffs_func_unbind(struct usb_configuration *,
@@ -288,7 +298,6 @@ static int ffs_func_revmap_ep(struct ffs_function *func, u8 num);
 static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf);
 
 
-
 /* The endpoints structures *************************************************/
 
 struct ffs_ep {
@@ -321,7 +330,6 @@ struct ffs_epfile {
         unsigned char                   _pad;
 };
 
-
 static int  __must_check ffs_epfiles_create(struct ffs_data *ffs);
 static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count);
 
@@ -348,7 +356,6 @@ static void ffs_ep0_complete(struct usb_ep *ep, struct usb_request *req)
         complete_all(&ffs->ep0req_completion);
 }
 
-
 static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
 {
         struct usb_request *req = ffs->ep0req;
@@ -380,17 +387,16 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
 static int __ffs_ep0_stall(struct ffs_data *ffs)
 {
         if (ffs->ev.can_stall) {
-                FVDBG("ep0 stall\n");
+                pr_vdebug("ep0 stall\n");
                 usb_ep_set_halt(ffs->gadget->ep0);
                 ffs->setup_state = FFS_NO_SETUP;
                 return -EL2HLT;
         } else {
-                FDBG("bogus ep0 stall!\n");
+                pr_debug("bogus ep0 stall!\n");
                 return -ESRCH;
         }
 }
 
-
 static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                              size_t len, loff_t *ptr)
 {
@@ -409,7 +415,6 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
         if (unlikely(ret < 0))
                 return ret;
 
-
         /* Check state */
         switch (ffs->state) {
         case FFS_READ_DESCRIPTORS:
@@ -421,14 +426,14 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                 }
 
                 data = ffs_prepare_buffer(buf, len);
-                if (unlikely(IS_ERR(data))) {
+                if (IS_ERR(data)) {
                         ret = PTR_ERR(data);
                         break;
                 }
 
                 /* Handle data */
                 if (ffs->state == FFS_READ_DESCRIPTORS) {
-                        FINFO("read descriptors");
+                        pr_info("read descriptors\n");
                         ret = __ffs_data_got_descs(ffs, data, len);
                         if (unlikely(ret < 0))
                                 break;
@@ -436,7 +441,7 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                         ffs->state = FFS_READ_STRINGS;
                         ret = len;
                 } else {
-                        FINFO("read strings");
+                        pr_info("read strings\n");
                         ret = __ffs_data_got_strings(ffs, data, len);
                         if (unlikely(ret < 0))
                                 break;
@@ -461,11 +466,12 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                 }
                 break;
 
-
         case FFS_ACTIVE:
                 data = NULL;
-                /* We're called from user space, we can use _irq
-                 * rather then _irqsave */
+                /*
+                 * We're called from user space, we can use _irq
+                 * rather then _irqsave
+                 */
                 spin_lock_irq(&ffs->ev.waitq.lock);
                 switch (FFS_SETUP_STATE(ffs)) {
                 case FFS_SETUP_CANCELED:
@@ -493,23 +499,25 @@ static ssize_t ffs_ep0_write(struct file *file, const char __user *buf,
                 spin_unlock_irq(&ffs->ev.waitq.lock);
 
                 data = ffs_prepare_buffer(buf, len);
-                if (unlikely(IS_ERR(data))) {
+                if (IS_ERR(data)) {
                         ret = PTR_ERR(data);
                         break;
                 }
 
                 spin_lock_irq(&ffs->ev.waitq.lock);
 
-                /* We are guaranteed to be still in FFS_ACTIVE state
+                /*
+                 * We are guaranteed to be still in FFS_ACTIVE state
                  * but the state of setup could have changed from
                  * FFS_SETUP_PENDING to FFS_SETUP_CANCELED so we need
                  * to check for that.  If that happened we copied data
-                 * from user space in vain but it's unlikely. */
-                /* For sure we are not in FFS_NO_SETUP since this is
+                 * from user space in vain but it's unlikely.
+                 *
+                 * For sure we are not in FFS_NO_SETUP since this is
                  * the only place FFS_SETUP_PENDING -> FFS_NO_SETUP
                  * transition can be performed and it's protected by
-                 * mutex. */
-
+                 * mutex.
+                 */
                 if (FFS_SETUP_STATE(ffs) == FFS_SETUP_CANCELED) {
                         ret = -EIDRM;
 done_spin:
@@ -521,25 +529,22 @@ done_spin:
                 kfree(data);
                 break;
 
-
         default:
                 ret = -EBADFD;
                 break;
         }
 
-
         mutex_unlock(&ffs->mutex);
         return ret;
 }
 
-
-
 static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf,
                                      size_t n)
 {
-        /* We are holding ffs->ev.waitq.lock and ffs->mutex and we need
-         * to release them. */
-
+        /*
+         * We are holding ffs->ev.waitq.lock and ffs->mutex and we need
+         * to release them.
+         */
         struct usb_functionfs_event events[n];
         unsigned i = 0;
 
@@ -568,7 +573,6 @@ static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf,
                 ? -EFAULT : sizeof events;
 }
 
-
 static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
                             size_t len, loff_t *ptr)
 {
@@ -588,16 +592,16 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
         if (unlikely(ret < 0))
                 return ret;
 
-
         /* Check state */
         if (ffs->state != FFS_ACTIVE) {
                 ret = -EBADFD;
                 goto done_mutex;
         }
 
-
-        /* We're called from user space, we can use _irq rather then
-         * _irqsave */
+        /*
+         * We're called from user space, we can use _irq rather then
+         * _irqsave
+         */
         spin_lock_irq(&ffs->ev.waitq.lock);
 
         switch (FFS_SETUP_STATE(ffs)) {
@@ -617,7 +621,8 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
                         break;
                 }
 
-                if (unlikely(wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq, ffs->ev.count))) {
+                if (wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq,
+                                                        ffs->ev.count)) {
                         ret = -EINTR;
                         break;
                 }
@@ -625,7 +630,6 @@ static ssize_t ffs_ep0_read(struct file *file, char __user *buf,
                 return __ffs_ep0_read_events(ffs, buf,
                                              min(n, (size_t)ffs->ev.count));
 
-
         case FFS_SETUP_PENDING:
                 if (ffs->ev.setup.bRequestType & USB_DIR_IN) {
                         spin_unlock_irq(&ffs->ev.waitq.lock);
@@ -671,8 +675,6 @@ done_mutex:
         return ret;
 }
 
-
-
 static int ffs_ep0_open(struct inode *inode, struct file *file)
 {
         struct ffs_data *ffs = inode->i_private;
@@ -688,7 +690,6 @@ static int ffs_ep0_open(struct inode *inode, struct file *file)
         return 0;
 }
 
-
 static int ffs_ep0_release(struct inode *inode, struct file *file)
 {
         struct ffs_data *ffs = file->private_data;
@@ -700,7 +701,6 @@ static int ffs_ep0_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-
 static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
 {
         struct ffs_data *ffs = file->private_data;
@@ -721,7 +721,6 @@ static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
         return ret;
 }
 
-
 static const struct file_operations ffs_ep0_operations = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
@@ -736,7 +735,6 @@ static const struct file_operations ffs_ep0_operations = {
 
 /* "Normal" endpoints operations ********************************************/
 
-
 static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)
 {
         ENTER();
@@ -747,7 +745,6 @@ static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)
         }
 }
 
-
 static ssize_t ffs_epfile_io(struct file *file,
                              char __user *buf, size_t len, int read)
 {
@@ -777,8 +774,8 @@ first_try:
                                 goto error;
                         }
 
-                        if (unlikely(wait_event_interruptible
-                                     (epfile->wait, (ep = epfile->ep)))) {
+                        if (wait_event_interruptible(epfile->wait,
+                                                     (ep = epfile->ep))) {
                                 ret = -EINTR;
                                 goto error;
                         }
@@ -810,12 +807,16 @@ first_try:
                 if (unlikely(ret))
                         goto error;
 
-                /* We're called from user space, we can use _irq rather then
-                 * _irqsave */
+                /*
+                 * We're called from user space, we can use _irq rather then
+                 * _irqsave
+                 */
                 spin_lock_irq(&epfile->ffs->eps_lock);
 
-                /* While we were acquiring mutex endpoint got disabled
-                 * or changed? */
+                /*
+                 * While we were acquiring mutex endpoint got disabled
+                 * or changed?
+                 */
         } while (unlikely(epfile->ep != ep));
 
         /* Halt */
@@ -857,7 +858,6 @@ error:
         return ret;
 }
 
-
 static ssize_t
 ffs_epfile_write(struct file *file, const char __user *buf, size_t len,
                  loff_t *ptr)
@@ -903,7 +903,6 @@ ffs_epfile_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-
 static long ffs_epfile_ioctl(struct file *file, unsigned code,
                              unsigned long value)
 {
@@ -942,7 +941,6 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code,
         return ret;
 }
 
-
 static const struct file_operations ffs_epfile_operations = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
@@ -955,15 +953,13 @@ static const struct file_operations ffs_epfile_operations = {
 };
 
 
-
 /* File system and super block operations ***********************************/
 
 /*
- * Mounting the filesystem creates a controller file, used first for
+ * Mounting the file system creates a controller file, used first for
  * function configuration then later for event monitoring.
  */
 
-
 static struct inode *__must_check
 ffs_sb_make_inode(struct super_block *sb, void *data,
                   const struct file_operations *fops,
@@ -996,9 +992,7 @@ ffs_sb_make_inode(struct super_block *sb, void *data,
         return inode;
 }
 
-
 /* Create "regular" file */
-
 static struct inode *ffs_sb_create_file(struct super_block *sb,
                                         const char *name, void *data,
                                         const struct file_operations *fops,
@@ -1027,9 +1021,7 @@ static struct inode *ffs_sb_create_file(struct super_block *sb,
         return inode;
 }
 
-
 /* Super block */
-
 static const struct super_operations ffs_sb_operations = {
         .statfs =       simple_statfs,
         .drop_inode =   generic_delete_inode,
@@ -1050,7 +1042,7 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
 
         ENTER();
 
-        /* Initialize data */
+        /* Initialise data */
         ffs = ffs_data_new();
         if (unlikely(!ffs))
                 goto enomem0;
@@ -1096,7 +1088,6 @@ enomem0:
         return -ENOMEM;
 }
 
-
 static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
 {
         ENTER();
@@ -1116,7 +1107,7 @@ static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
                 /* Value limit */
                 eq = strchr(opts, '=');
                 if (unlikely(!eq)) {
-                        FERR("'=' missing in %s", opts);
+                        pr_err("'=' missing in %s\n", opts);
                         return -EINVAL;
                 }
                 *eq = 0;
@@ -1124,7 +1115,7 @@ static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
                 /* Parse value */
                 value = simple_strtoul(eq + 1, &end, 0);
                 if (unlikely(*end != ',' && *end != 0)) {
-                        FERR("%s: invalid value: %s", opts, eq + 1);
+                        pr_err("%s: invalid value: %s\n", opts, eq + 1);
                         return -EINVAL;
                 }
 
@@ -1159,7 +1150,7 @@ static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
 
                 default:
 invalid:
-                        FERR("%s: invalid option", opts);
+                        pr_err("%s: invalid option\n", opts);
                         return -EINVAL;
                 }
 
@@ -1172,7 +1163,6 @@ invalid:
         return 0;
 }
 
-
 /* "mount -t functionfs dev_name /dev/function" ends up here */
 
 static struct dentry *
@@ -1224,10 +1214,8 @@ static struct file_system_type ffs_fs_type = {
 };
 
 
-
 /* Driver's main init/cleanup functions *************************************/
 
-
 static int functionfs_init(void)
 {
         int ret;
@@ -1236,9 +1224,9 @@ static int functionfs_init(void)
 
         ret = register_filesystem(&ffs_fs_type);
         if (likely(!ret))
-                FINFO("file system registered");
+                pr_info("file system registered\n");
         else
-                FERR("failed registering file system (%d)", ret);
+                pr_err("failed registering file system (%d)\n", ret);
 
         return ret;
 }
@@ -1247,18 +1235,16 @@ static void functionfs_cleanup(void)
 {
         ENTER();
 
-        FINFO("unloading");
+        pr_info("unloading\n");
         unregister_filesystem(&ffs_fs_type);
 }
 
 
-
 /* ffs_data and ffs_function construction and destruction code **************/
 
 static void ffs_data_clear(struct ffs_data *ffs);
 static void ffs_data_reset(struct ffs_data *ffs);
 
-
 static void ffs_data_get(struct ffs_data *ffs)
 {
         ENTER();
@@ -1279,7 +1265,7 @@ static void ffs_data_put(struct ffs_data *ffs)
         ENTER();
 
         if (unlikely(atomic_dec_and_test(&ffs->ref))) {
-                FINFO("%s(): freeing", __func__);
+                pr_info("%s(): freeing\n", __func__);
                 ffs_data_clear(ffs);
                 BUG_ON(mutex_is_locked(&ffs->mutex) ||
                        spin_is_locked(&ffs->ev.waitq.lock) ||
@@ -1289,8 +1275,6 @@ static void ffs_data_put(struct ffs_data *ffs)
         }
 }
 
-
-
 static void ffs_data_closed(struct ffs_data *ffs)
 {
         ENTER();
@@ -1303,7 +1287,6 @@ static void ffs_data_closed(struct ffs_data *ffs)
         ffs_data_put(ffs);
 }
 
-
 static struct ffs_data *ffs_data_new(void)
 {
         struct ffs_data *ffs = kzalloc(sizeof *ffs, GFP_KERNEL);
@@ -1326,7 +1309,6 @@ static struct ffs_data *ffs_data_new(void)
         return ffs;
 }
 
-
 static void ffs_data_clear(struct ffs_data *ffs)
 {
         ENTER();
@@ -1344,7 +1326,6 @@ static void ffs_data_clear(struct ffs_data *ffs)
         kfree(ffs->stringtabs);
 }
 
-
 static void ffs_data_reset(struct ffs_data *ffs)
 {
         ENTER();
@@ -1407,7 +1388,6 @@ static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
         return 0;
 }
 
-
 static void functionfs_unbind(struct ffs_data *ffs)
 {
         ENTER();
@@ -1420,7 +1400,6 @@ static void functionfs_unbind(struct ffs_data *ffs)
         }
 }
 
-
 static int ffs_epfiles_create(struct ffs_data *ffs)
 {
         struct ffs_epfile *epfile, *epfiles;
@@ -1451,7 +1430,6 @@ static int ffs_epfiles_create(struct ffs_data *ffs)
         return 0;
 }
 
-
 static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)
 {
         struct ffs_epfile *epfile = epfiles;
@@ -1471,7 +1449,6 @@ static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)
         kfree(epfiles);
 }
 
-
 static int functionfs_bind_config(struct usb_composite_dev *cdev,
                                   struct usb_configuration *c,
                                   struct ffs_data *ffs)
@@ -1491,7 +1468,6 @@ static int functionfs_bind_config(struct usb_composite_dev *cdev,
         func->function.bind    = ffs_func_bind;
         func->function.unbind  = ffs_func_unbind;
         func->function.set_alt = ffs_func_set_alt;
-        /*func->function.get_alt = ffs_func_get_alt;*/
         func->function.disable = ffs_func_disable;
         func->function.setup   = ffs_func_setup;
         func->function.suspend = ffs_func_suspend;
@@ -1516,14 +1492,15 @@ static void ffs_func_free(struct ffs_function *func)
         ffs_data_put(func->ffs);
 
         kfree(func->eps);
-        /* eps and interfaces_nums are allocated in the same chunk so
+        /*
+         * eps and interfaces_nums are allocated in the same chunk so
          * only one free is required.  Descriptors are also allocated
-         * in the same chunk. */
+         * in the same chunk.
+         */
 
         kfree(func);
 }
 
-
 static void ffs_func_eps_disable(struct ffs_function *func)
 {
         struct ffs_ep *ep         = func->eps;
@@ -1581,11 +1558,12 @@ static int ffs_func_eps_enable(struct ffs_function *func)
 
 /* Parsing and building descriptors and strings *****************************/
 
-
-/* This validates if data pointed by data is a valid USB descriptor as
+/*
+ * This validates if data pointed by data is a valid USB descriptor as
  * well as record how many interfaces, endpoints and strings are
- * required by given configuration.  Returns address afther the
- * descriptor or NULL if data is invalid. */
+ * required by given configuration.  Returns address after the
+ * descriptor or NULL if data is invalid.
+ */
 
 enum ffs_entity_type {
         FFS_DESCRIPTOR, FFS_INTERFACE, FFS_STRING, FFS_ENDPOINT
@@ -1607,14 +1585,14 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 
         /* At least two bytes are required: length and type */
         if (len < 2) {
-                FVDBG("descriptor too short");
+                pr_vdebug("descriptor too short\n");
                 return -EINVAL;
         }
 
         /* If we have at least as many bytes as the descriptor takes? */
         length = _ds->bLength;
         if (len < length) {
-                FVDBG("descriptor longer then available data");
+                pr_vdebug("descriptor longer then available data\n");
                 return -EINVAL;
         }
 
@@ -1622,15 +1600,15 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 #define __entity_check_STRING(val)     (val)
 #define __entity_check_ENDPOINT(val)   ((val) & USB_ENDPOINT_NUMBER_MASK)
 #define __entity(type, val) do {                                        \
-                FVDBG("entity " #type "(%02x)", (val));                 \
+                pr_vdebug("entity " #type "(%02x)\n", (val));           \
                 if (unlikely(!__entity_check_ ##type(val))) {           \
-                        FVDBG("invalid entity's value");                \
+                        pr_vdebug("invalid entity's value\n");          \
                         return -EINVAL;                                 \
                 }                                                       \
                 ret = entity(FFS_ ##type, &val, _ds, priv);             \
                 if (unlikely(ret < 0)) {                                \
-                        FDBG("entity " #type "(%02x); ret = %d",        \
-                             (val), ret);                               \
+                        pr_debug("entity " #type "(%02x); ret = %d\n",  \
+                                 (val), ret);                           \
                         return ret;                                     \
                 }                                                       \
         } while (0)
@@ -1642,12 +1620,13 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
         case USB_DT_STRING:
         case USB_DT_DEVICE_QUALIFIER:
                 /* function can't have any of those */
-                FVDBG("descriptor reserved for gadget: %d", _ds->bDescriptorType);
+                pr_vdebug("descriptor reserved for gadget: %d\n",
+                      _ds->bDescriptorType);
                 return -EINVAL;
 
         case USB_DT_INTERFACE: {
                 struct usb_interface_descriptor *ds = (void *)_ds;
-                FVDBG("interface descriptor");
+                pr_vdebug("interface descriptor\n");
                 if (length != sizeof *ds)
                         goto inv_length;
 
@@ -1659,7 +1638,7 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 
         case USB_DT_ENDPOINT: {
                 struct usb_endpoint_descriptor *ds = (void *)_ds;
-                FVDBG("endpoint descriptor");
+                pr_vdebug("endpoint descriptor\n");
                 if (length != USB_DT_ENDPOINT_SIZE &&
                     length != USB_DT_ENDPOINT_AUDIO_SIZE)
                         goto inv_length;
@@ -1674,7 +1653,7 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
 
         case USB_DT_INTERFACE_ASSOCIATION: {
                 struct usb_interface_assoc_descriptor *ds = (void *)_ds;
-                FVDBG("interface association descriptor");
+                pr_vdebug("interface association descriptor\n");
                 if (length != sizeof *ds)
                         goto inv_length;
                 if (ds->iFunction)
@@ -1688,17 +1667,17 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
         case USB_DT_SECURITY:
         case USB_DT_CS_RADIO_CONTROL:
                 /* TODO */
-                FVDBG("unimplemented descriptor: %d", _ds->bDescriptorType);
+                pr_vdebug("unimplemented descriptor: %d\n", _ds->bDescriptorType);
                 return -EINVAL;
 
         default:
                 /* We should never be here */
-                FVDBG("unknown descriptor: %d", _ds->bDescriptorType);
+                pr_vdebug("unknown descriptor: %d\n", _ds->bDescriptorType);
                 return -EINVAL;
 
-        inv_length:
-                FVDBG("invalid length: %d (descriptor %d)",
-                      _ds->bLength, _ds->bDescriptorType);
+inv_length:
+                pr_vdebug("invalid length: %d (descriptor %d)\n",
+                          _ds->bLength, _ds->bDescriptorType);
                 return -EINVAL;
         }
 
@@ -1711,7 +1690,6 @@ static int __must_check ffs_do_desc(char *data, unsigned len,
         return length;
 }
 
-
 static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
                                      ffs_entity_callback entity, void *priv)
 {
@@ -1726,10 +1704,11 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
                 if (num == count)
                         data = NULL;
 
-                /* Record "descriptor" entitny */
+                /* Record "descriptor" entity */
                 ret = entity(FFS_DESCRIPTOR, (u8 *)num, (void *)data, priv);
                 if (unlikely(ret < 0)) {
-                        FDBG("entity DESCRIPTOR(%02lx); ret = %d", num, ret);
+                        pr_debug("entity DESCRIPTOR(%02lx); ret = %d\n",
+                                 num, ret);
                         return ret;
                 }
 
@@ -1738,7 +1717,7 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
 
                 ret = ffs_do_desc(data, len, entity, priv);
                 if (unlikely(ret < 0)) {
-                        FDBG("%s returns %d", __func__, ret);
+                        pr_debug("%s returns %d\n", __func__, ret);
                         return ret;
                 }
 
@@ -1748,7 +1727,6 @@ static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
         }
 }
 
-
 static int __ffs_data_do_entity(enum ffs_entity_type type,
                                 u8 *valuep, struct usb_descriptor_header *desc,
                                 void *priv)
@@ -1762,16 +1740,20 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
                 break;
 
         case FFS_INTERFACE:
-                /* Interfaces are indexed from zero so if we
+                /*
+                 * Interfaces are indexed from zero so if we
                  * encountered interface "n" then there are at least
-                 * "n+1" interfaces. */
+                 * "n+1" interfaces.
+                 */
                 if (*valuep >= ffs->interfaces_count)
                         ffs->interfaces_count = *valuep + 1;
                 break;
 
         case FFS_STRING:
-                /* Strings are indexed from 1 (0 is magic ;) reserved
-                 * for languages list or some such) */
+                /*
+                 * Strings are indexed from 1 (0 is magic ;) reserved
+                 * for languages list or some such)
+                 */
                 if (*valuep > ffs->strings_count)
                         ffs->strings_count = *valuep;
                 break;
@@ -1786,7 +1768,6 @@ static int __ffs_data_do_entity(enum ffs_entity_type type,
         return 0;
 }
 
-
 static int __ffs_data_got_descs(struct ffs_data *ffs,
                                 char *const _data, size_t len)
 {
@@ -1849,8 +1830,6 @@ error:
         return ret;
 }
 
-
-
 static int __ffs_data_got_strings(struct ffs_data *ffs,
                                   char *const _data, size_t len)
 {
@@ -1876,17 +1855,17 @@ static int __ffs_data_got_strings(struct ffs_data *ffs,
         if (unlikely(str_count < needed_count))
                 goto error;
 
-        /* If we don't need any strings just return and free all
-         * memory */
+        /*
+         * If we don't need any strings just return and free all
+         * memory.
+         */
         if (!needed_count) {
                 kfree(_data);
                 return 0;
         }
 
-        /* Allocate */
+        /* Allocate everything in one chunk so there's less maintenance. */
         {
-                /* Allocate everything in one chunk so there's less
-                 * maintanance. */
                 struct {
                         struct usb_gadget_strings *stringtabs[lang_count + 1];
                         struct usb_gadget_strings stringtab[lang_count];
@@ -1937,13 +1916,17 @@ static int __ffs_data_got_strings(struct ffs_data *ffs,
                         if (unlikely(length == len))
                                 goto error_free;
 
-                        /* user may provide more strings then we need,
-                         * if that's the case we simply ingore the
-                         * rest */
+                        /*
+                         * User may provide more strings then we need,
+                         * if that's the case we simply ignore the
+                         * rest
+                         */
                         if (likely(needed)) {
-                                /* s->id will be set while adding
+                                /*
+                                 * s->id will be set while adding
                                  * function to configuration so for
-                                 * now just leave garbage here. */
+                                 * now just leave garbage here.
+                                 */
                                 s->s = data;
                                 --needed;
                                 ++s;
@@ -1977,8 +1960,6 @@ error:
 }
 
 
-
-
 /* Events handling and management *******************************************/
 
 static void __ffs_event_add(struct ffs_data *ffs,
@@ -1987,29 +1968,32 @@ static void __ffs_event_add(struct ffs_data *ffs,
         enum usb_functionfs_event_type rem_type1, rem_type2 = type;
         int neg = 0;
 
-        /* Abort any unhandled setup */
-        /* We do not need to worry about some cmpxchg() changing value
+        /*
+         * Abort any unhandled setup
+         *
+         * We do not need to worry about some cmpxchg() changing value
          * of ffs->setup_state without holding the lock because when
          * state is FFS_SETUP_PENDING cmpxchg() in several places in
-         * the source does nothing. */
+         * the source does nothing.
+         */
         if (ffs->setup_state == FFS_SETUP_PENDING)
                 ffs->setup_state = FFS_SETUP_CANCELED;
 
         switch (type) {
         case FUNCTIONFS_RESUME:
                 rem_type2 = FUNCTIONFS_SUSPEND;
-                /* FALL THGOUTH */
+                /* FALL THROUGH */
         case FUNCTIONFS_SUSPEND:
         case FUNCTIONFS_SETUP:
                 rem_type1 = type;
-                /* discard all similar events */
+                /* Discard all similar events */
                 break;
 
         case FUNCTIONFS_BIND:
         case FUNCTIONFS_UNBIND:
         case FUNCTIONFS_DISABLE:
         case FUNCTIONFS_ENABLE:
-                /* discard everything other then power management. */
+                /* Discard everything other then power management. */
                 rem_type1 = FUNCTIONFS_SUSPEND;
                 rem_type2 = FUNCTIONFS_RESUME;
                 neg = 1;
@@ -2026,11 +2010,11 @@ static void __ffs_event_add(struct ffs_data *ffs,
                         if ((*ev == rem_type1 || *ev == rem_type2) == neg)
                                 *out++ = *ev;
                         else
-                                FVDBG("purging event %d", *ev);
+                                pr_vdebug("purging event %d\n", *ev);
                 ffs->ev.count = out - ffs->ev.types;
         }
 
-        FVDBG("adding event %d", type);
+        pr_vdebug("adding event %d\n", type);
         ffs->ev.types[ffs->ev.count++] = type;
         wake_up_locked(&ffs->ev.waitq);
 }
@@ -2055,8 +2039,10 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         struct ffs_function *func = priv;
         struct ffs_ep *ffs_ep;
 
-        /* If hs_descriptors is not NULL then we are reading hs
-         * descriptors now */
+        /*
+         * If hs_descriptors is not NULL then we are reading hs
+         * descriptors now
+         */
         const int isHS = func->function.hs_descriptors != NULL;
         unsigned idx;
 
@@ -2075,9 +2061,9 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         ffs_ep = func->eps + idx;
 
         if (unlikely(ffs_ep->descs[isHS])) {
-                FVDBG("two %sspeed descriptors for EP %d",
-                      isHS ? "high" : "full",
-                      ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+                pr_vdebug("two %sspeed descriptors for EP %d\n",
+                          isHS ? "high" : "full",
+                          ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
                 return -EINVAL;
         }
         ffs_ep->descs[isHS] = ds;
@@ -2091,11 +2077,11 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
                 struct usb_request *req;
                 struct usb_ep *ep;
 
-                FVDBG("autoconfig");
+                pr_vdebug("autoconfig\n");
                 ep = usb_ep_autoconfig(func->gadget, ds);
                 if (unlikely(!ep))
                         return -ENOTSUPP;
-                ep->driver_data = func->eps + idx;;
+                ep->driver_data = func->eps + idx;
 
                 req = usb_ep_alloc_request(ep, GFP_KERNEL);
                 if (unlikely(!req))
@@ -2111,7 +2097,6 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         return 0;
 }
 
-
 static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
                                    struct usb_descriptor_header *desc,
                                    void *priv)
@@ -2143,8 +2128,10 @@ static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
                 break;
 
         case FFS_ENDPOINT:
-                /* USB_DT_ENDPOINT are handled in
-                 * __ffs_func_bind_do_descs(). */
+                /*
+                 * USB_DT_ENDPOINT are handled in
+                 * __ffs_func_bind_do_descs().
+                 */
                 if (desc->bDescriptorType == USB_DT_ENDPOINT)
                         return 0;
 
@@ -2160,7 +2147,7 @@ static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
                 break;
         }
 
-        FVDBG("%02x -> %02x", *valuep, newValue);
+        pr_vdebug("%02x -> %02x\n", *valuep, newValue);
         *valuep = newValue;
         return 0;
 }
@@ -2211,9 +2198,11 @@ static int ffs_func_bind(struct usb_configuration *c,
         func->eps             = data->eps;
         func->interfaces_nums = data->inums;
 
-        /* Go throught all the endpoint descriptors and allocate
+        /*
+         * Go through all the endpoint descriptors and allocate
          * endpoints first, so that later we can rewrite the endpoint
-         * numbers without worying that it may be described later on. */
+         * numbers without worrying that it may be described later on.
+         */
         if (likely(full)) {
                 func->function.descriptors = data->fs_descs;
                 ret = ffs_do_descs(ffs->fs_descs_count,
@@ -2234,9 +2223,11 @@ static int ffs_func_bind(struct usb_configuration *c,
                                    __ffs_func_bind_do_descs, func);
         }
 
-        /* Now handle interface numbers allocation and interface and
-         * enpoint numbers rewritting.  We can do that in one go
-         * now. */
+        /*
+         * Now handle interface numbers allocation and interface and
+         * endpoint numbers rewriting.  We can do that in one go
+         * now.
+         */
         ret = ffs_do_descs(ffs->fs_descs_count +
                            (high ? ffs->hs_descs_count : 0),
                            data->raw_descs, sizeof data->raw_descs,
@@ -2274,7 +2265,6 @@ static void ffs_func_unbind(struct usb_configuration *c,
         ffs_func_free(func);
 }
 
-
 static int ffs_func_set_alt(struct usb_function *f,
                             unsigned interface, unsigned alt)
 {
@@ -2322,20 +2312,21 @@ static int ffs_func_setup(struct usb_function *f,
 
         ENTER();
 
-        FVDBG("creq->bRequestType = %02x", creq->bRequestType);
-        FVDBG("creq->bRequest     = %02x", creq->bRequest);
-        FVDBG("creq->wValue       = %04x", le16_to_cpu(creq->wValue));
-        FVDBG("creq->wIndex       = %04x", le16_to_cpu(creq->wIndex));
-        FVDBG("creq->wLength      = %04x", le16_to_cpu(creq->wLength));
+        pr_vdebug("creq->bRequestType = %02x\n", creq->bRequestType);
+        pr_vdebug("creq->bRequest     = %02x\n", creq->bRequest);
+        pr_vdebug("creq->wValue       = %04x\n", le16_to_cpu(creq->wValue));
+        pr_vdebug("creq->wIndex       = %04x\n", le16_to_cpu(creq->wIndex));
+        pr_vdebug("creq->wLength      = %04x\n", le16_to_cpu(creq->wLength));
 
-        /* Most requests directed to interface go throught here
+        /*
+         * Most requests directed to interface go through here
          * (notable exceptions are set/get interface) so we need to
          * handle them.  All other either handled by composite or
          * passed to usb_configuration->setup() (if one is set).  No
          * matter, we will handle requests directed to endpoint here
          * as well (as it's straightforward) but what to do with any
-         * other request? */
-
+         * other request?
+         */
         if (ffs->state != FFS_ACTIVE)
                 return -ENODEV;
 
@@ -2378,8 +2369,7 @@ static void ffs_func_resume(struct usb_function *f)
 }
 
 
-
-/* Enpoint and interface numbers reverse mapping ****************************/
+/* Endpoint and interface numbers reverse mapping ***************************/
 
 static int ffs_func_revmap_ep(struct ffs_function *func, u8 num)
 {
@@ -2410,7 +2400,6 @@ static int ffs_mutex_lock(struct mutex *mutex, unsigned nonblock)
                 : mutex_lock_interruptible(mutex);
 }
 
-
 static char *ffs_prepare_buffer(const char * __user buf, size_t len)
 {
         char *data;
@@ -2427,7 +2416,7 @@ static char *ffs_prepare_buffer(const char * __user buf, size_t len)
                 return ERR_PTR(-EFAULT);
         }
 
-        FVDBG("Buffer from user space:");
+        pr_vdebug("Buffer from user space:\n");
         ffs_dump_mem("", data, len);
 
         return data;
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 838286b1cd14..b5dbb2308f56 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -37,7 +37,6 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-
 /*
  * The Mass Storage Function acts as a USB Mass Storage device,
  * appearing to the host as a disk drive or as a CD-ROM drive.  In
@@ -185,7 +184,6 @@
  * <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
  */
 
-
 /*
  *                              Driver Design
  *
@@ -275,7 +273,6 @@
 /* #define VERBOSE_DEBUG */
 /* #define DUMP_MSGS */
 
-
 #include <linux/blkdev.h>
 #include <linux/completion.h>
 #include <linux/dcache.h>
@@ -300,7 +297,6 @@
 #include "gadget_chips.h"
 
 
-
 /*------------------------------------------------------------------------*/
 
 #define FSG_DRIVER_DESC         "Mass Storage Function"
@@ -308,7 +304,6 @@
 
 static const char fsg_string_interface[] = "Mass Storage";
 
-
 #define FSG_NO_INTR_EP 1
 #define FSG_NO_DEVICE_STRINGS    1
 #define FSG_NO_OTG               1
@@ -324,25 +319,30 @@ struct fsg_common;
 
 /* FSF callback functions */
 struct fsg_operations {
-        /* Callback function to call when thread exits.  If no
+        /*
+         * Callback function to call when thread exits.  If no
          * callback is set or it returns value lower then zero MSF
          * will force eject all LUNs it operates on (including those
          * marked as non-removable or with prevent_medium_removal flag
-         * set). */
+         * set).
+         */
         int (*thread_exits)(struct fsg_common *common);
 
-        /* Called prior to ejection.  Negative return means error,
+        /*
+         * Called prior to ejection.  Negative return means error,
          * zero means to continue with ejection, positive means not to
-         * eject. */
+         * eject.
+         */
         int (*pre_eject)(struct fsg_common *common,
                          struct fsg_lun *lun, int num);
-        /* Called after ejection.  Negative return means error, zero
-         * or positive is just a success. */
+        /*
+         * Called after ejection.  Negative return means error, zero
+         * or positive is just a success.
+         */
         int (*post_eject)(struct fsg_common *common,
                           struct fsg_lun *lun, int num);
 };
 
-
 /* Data shared by all the FSG instances. */
 struct fsg_common {
         struct usb_gadget       *gadget;
@@ -398,14 +398,15 @@ struct fsg_common {
         /* Gadget's private data. */
         void                    *private_data;
 
-        /* Vendor (8 chars), product (16 chars), release (4
-         * hexadecimal digits) and NUL byte */
+        /*
+         * Vendor (8 chars), product (16 chars), release (4
+         * hexadecimal digits) and NUL byte
+         */
         char inquiry_string[8 + 16 + 4 + 1];
 
         struct kref             ref;
 };
 
-
 struct fsg_config {
         unsigned nluns;
         struct fsg_lun_config {
@@ -431,7 +432,6 @@ struct fsg_config {
         char                    can_stall;
 };
 
-
 struct fsg_dev {
         struct usb_function     function;
         struct usb_gadget       *gadget;        /* Copy of cdev->gadget */
@@ -449,7 +449,6 @@ struct fsg_dev {
         struct usb_ep           *bulk_out;
 };
 
-
 static inline int __fsg_is_set(struct fsg_common *common,
                                const char *func, unsigned line)
 {
@@ -462,13 +461,11 @@ static inline int __fsg_is_set(struct fsg_common *common,
 
 #define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
 
-
 static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
 {
         return container_of(f, struct fsg_dev, function);
 }
 
-
 typedef void (*fsg_routine_t)(struct fsg_dev *);
 
 static int exception_in_progress(struct fsg_common *common)
@@ -478,7 +475,7 @@ static int exception_in_progress(struct fsg_common *common)
 
 /* Make bulk-out requests be divisible by the maxpacket size */
 static void set_bulk_out_req_length(struct fsg_common *common,
-                struct fsg_buffhd *bh, unsigned int length)
+                                    struct fsg_buffhd *bh, unsigned int length)
 {
         unsigned int    rem;
 
@@ -489,6 +486,7 @@ static void set_bulk_out_req_length(struct fsg_common *common,
         bh->outreq->length = length;
 }
 
+
 /*-------------------------------------------------------------------------*/
 
 static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
@@ -519,14 +517,15 @@ static void wakeup_thread(struct fsg_common *common)
                 wake_up_process(common->thread_task);
 }
 
-
 static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
 {
         unsigned long           flags;
 
-        /* Do nothing if a higher-priority exception is already in progress.
+        /*
+         * Do nothing if a higher-priority exception is already in progress.
          * If a lower-or-equal priority exception is in progress, preempt it
-         * and notify the main thread by sending it a signal. */
+         * and notify the main thread by sending it a signal.
+         */
         spin_lock_irqsave(&common->lock, flags);
         if (common->state <= new_state) {
                 common->exception_req_tag = common->ep0_req_tag;
@@ -555,10 +554,10 @@ static int ep0_queue(struct fsg_common *common)
         return rc;
 }
 
+
 /*-------------------------------------------------------------------------*/
 
-/* Bulk and interrupt endpoint completion handlers.
- * These always run in_irq. */
+/* Completion handlers. These always run in_irq. */
 
 static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 {
@@ -567,7 +566,7 @@ static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 
         if (req->status || req->actual != req->length)
                 DBG(common, "%s --> %d, %u/%u\n", __func__,
-                                req->status, req->actual, req->length);
+                    req->status, req->actual, req->length);
         if (req->status == -ECONNRESET)         /* Request was cancelled */
                 usb_ep_fifo_flush(ep);
 
@@ -588,8 +587,7 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
         dump_msg(common, "bulk-out", req->buf, req->actual);
         if (req->status || req->actual != bh->bulk_out_intended_length)
                 DBG(common, "%s --> %d, %u/%u\n", __func__,
-                                req->status, req->actual,
-                                bh->bulk_out_intended_length);
+                    req->status, req->actual, bh->bulk_out_intended_length);
         if (req->status == -ECONNRESET)         /* Request was cancelled */
                 usb_ep_fifo_flush(ep);
 
@@ -602,13 +600,8 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
         spin_unlock(&common->lock);
 }
 
-
-/*-------------------------------------------------------------------------*/
-
-/* Ep0 class-specific handlers.  These always run in_irq. */
-
 static int fsg_setup(struct usb_function *f,
-                const struct usb_ctrlrequest *ctrl)
+                     const struct usb_ctrlrequest *ctrl)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
         struct usb_request      *req = fsg->common->ep0req;
@@ -628,8 +621,10 @@ static int fsg_setup(struct usb_function *f,
                 if (w_index != fsg->interface_number || w_value != 0)
                         return -EDOM;
 
-                /* Raise an exception to stop the current operation
-                 * and reinitialize our state. */
+                /*
+                 * Raise an exception to stop the current operation
+                 * and reinitialize our state.
+                 */
                 DBG(fsg, "bulk reset request\n");
                 raise_exception(fsg->common, FSG_STATE_RESET);
                 return DELAYED_STATUS;
@@ -641,7 +636,7 @@ static int fsg_setup(struct usb_function *f,
                 if (w_index != fsg->interface_number || w_value != 0)
                         return -EDOM;
                 VDBG(fsg, "get max LUN\n");
-                *(u8 *) req->buf = fsg->common->nluns - 1;
+                *(u8 *)req->buf = fsg->common->nluns - 1;
 
                 /* Respond with data/status */
                 req->length = min((u16)1, w_length);
@@ -649,8 +644,7 @@ static int fsg_setup(struct usb_function *f,
         }
 
         VDBG(fsg,
-             "unknown class-specific control req "
-             "%02x.%02x v%04x i%04x l%u\n",
+             "unknown class-specific control req %02x.%02x v%04x i%04x l%u\n",
              ctrl->bRequestType, ctrl->bRequest,
              le16_to_cpu(ctrl->wValue), w_index, w_length);
         return -EOPNOTSUPP;
@@ -661,11 +655,10 @@ static int fsg_setup(struct usb_function *f,
 
 /* All the following routines run in process context */
 
-
 /* Use this for bulk or interrupt transfers, not ep0 */
 static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
-                struct usb_request *req, int *pbusy,
-                enum fsg_buffer_state *state)
+                           struct usb_request *req, int *pbusy,
+                           enum fsg_buffer_state *state)
 {
         int     rc;
 
@@ -683,25 +676,34 @@ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
 
                 /* We can't do much more than wait for a reset */
 
-                /* Note: currently the net2280 driver fails zero-length
-                 * submissions if DMA is enabled. */
-                if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
-                                                req->length == 0))
+                /*
+                 * Note: currently the net2280 driver fails zero-length
+                 * submissions if DMA is enabled.
+                 */
+                if (rc != -ESHUTDOWN &&
+                    !(rc == -EOPNOTSUPP && req->length == 0))
                         WARNING(fsg, "error in submission: %s --> %d\n",
-                                        ep->name, rc);
+                                ep->name, rc);
         }
 }
 
-#define START_TRANSFER_OR(common, ep_name, req, pbusy, state)           \
-        if (fsg_is_set(common))                                         \
-                start_transfer((common)->fsg, (common)->fsg->ep_name,   \
-                               req, pbusy, state);                      \
-        else
-
-#define START_TRANSFER(common, ep_name, req, pbusy, state)              \
-        START_TRANSFER_OR(common, ep_name, req, pbusy, state) (void)0
-
+static bool start_in_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        if (!fsg_is_set(common))
+                return false;
+        start_transfer(common->fsg, common->fsg->bulk_in,
+                       bh->inreq, &bh->inreq_busy, &bh->state);
+        return true;
+}
 
+static bool start_out_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
+{
+        if (!fsg_is_set(common))
+                return false;
+        start_transfer(common->fsg, common->fsg->bulk_out,
+                       bh->outreq, &bh->outreq_busy, &bh->state);
+        return true;
+}
 
 static int sleep_thread(struct fsg_common *common)
 {
@@ -739,16 +741,20 @@ static int do_read(struct fsg_common *common)
         unsigned int            partial_page;
         ssize_t                 nread;
 
-        /* Get the starting Logical Block Address and check that it's
-         * not too big */
+        /*
+         * Get the starting Logical Block Address and check that it's
+         * not too big.
+         */
         if (common->cmnd[0] == READ_6)
                 lba = get_unaligned_be24(&common->cmnd[1]);
         else {
                 lba = get_unaligned_be32(&common->cmnd[2]);
 
-                /* We allow DPO (Disable Page Out = don't save data in the
+                /*
+                 * We allow DPO (Disable Page Out = don't save data in the
                  * cache) and FUA (Force Unit Access = don't read from the
-                 * cache), but we don't implement them. */
+                 * cache), but we don't implement them.
+                 */
                 if ((common->cmnd[1] & ~0x18) != 0) {
                         curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
                         return -EINVAL;
@@ -766,22 +772,23 @@ static int do_read(struct fsg_common *common)
                 return -EIO;            /* No default reply */
 
         for (;;) {
-
-                /* Figure out how much we need to read:
+                /*
+                 * Figure out how much we need to read:
                  * Try to read the remaining amount.
                  * But don't read more than the buffer size.
                  * And don't try to read past the end of the file.
                  * Finally, if we're not at a page boundary, don't read past
                  *      the next page.
                  * If this means reading 0 then we were asked to read past
-                 *      the end of file. */
+                 *      the end of file.
+                 */
                 amount = min(amount_left, FSG_BUFLEN);
-                amount = min((loff_t) amount,
-                                curlun->file_length - file_offset);
+                amount = min((loff_t)amount,
+                             curlun->file_length - file_offset);
                 partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
                 if (partial_page > 0)
-                        amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
-                                        partial_page);
+                        amount = min(amount, (unsigned int)PAGE_CACHE_SIZE -
+                                             partial_page);
 
                 /* Wait for the next buffer to become available */
                 bh = common->next_buffhd_to_fill;
@@ -791,8 +798,10 @@ static int do_read(struct fsg_common *common)
                                 return rc;
                 }
 
-                /* If we were asked to read past the end of file,
-                 * end with an empty buffer. */
+                /*
+                 * If we were asked to read past the end of file,
+                 * end with an empty buffer.
+                 */
                 if (amount == 0) {
                         curlun->sense_data =
                                         SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
@@ -806,21 +815,19 @@ static int do_read(struct fsg_common *common)
                 /* Perform the read */
                 file_offset_tmp = file_offset;
                 nread = vfs_read(curlun->filp,
-                                (char __user *) bh->buf,
-                                amount, &file_offset_tmp);
+                                 (char __user *)bh->buf,
+                                 amount, &file_offset_tmp);
                 VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
-                                (unsigned long long) file_offset,
-                                (int) nread);
+                      (unsigned long long)file_offset, (int)nread);
                 if (signal_pending(current))
                         return -EINTR;
 
                 if (nread < 0) {
-                        LDBG(curlun, "error in file read: %d\n",
-                                        (int) nread);
+                        LDBG(curlun, "error in file read: %d\n", (int)nread);
                         nread = 0;
                 } else if (nread < amount) {
                         LDBG(curlun, "partial file read: %d/%u\n",
-                                        (int) nread, amount);
+                             (int)nread, amount);
                         nread -= (nread & 511); /* Round down to a block */
                 }
                 file_offset  += nread;
@@ -842,10 +849,8 @@ static int do_read(struct fsg_common *common)
 
                 /* Send this buffer and go read some more */
                 bh->inreq->zero = 0;
-                START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                               &bh->inreq_busy, &bh->state)
-                        /* Don't know what to do if
-                         * common->fsg is NULL */
+                if (!start_in_transfer(common, bh))
+                        /* Don't know what to do if common->fsg is NULL */
                         return -EIO;
                 common->next_buffhd_to_fill = bh->next;
         }
@@ -877,17 +882,21 @@ static int do_write(struct fsg_common *common)
         curlun->filp->f_flags &= ~O_SYNC;       /* Default is not to wait */
         spin_unlock(&curlun->filp->f_lock);
 
-        /* Get the starting Logical Block Address and check that it's
-         * not too big */
+        /*
+         * Get the starting Logical Block Address and check that it's
+         * not too big
+         */
         if (common->cmnd[0] == WRITE_6)
                 lba = get_unaligned_be24(&common->cmnd[1]);
         else {
                 lba = get_unaligned_be32(&common->cmnd[2]);
 
-                /* We allow DPO (Disable Page Out = don't save data in the
+                /*
+                 * We allow DPO (Disable Page Out = don't save data in the
                  * cache) and FUA (Force Unit Access = write directly to the
                  * medium).  We don't implement DPO; we implement FUA by
-                 * performing synchronous output. */
+                 * performing synchronous output.
+                 */
                 if (common->cmnd[1] & ~0x18) {
                         curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
                         return -EINVAL;
@@ -915,7 +924,8 @@ static int do_write(struct fsg_common *common)
                 bh = common->next_buffhd_to_fill;
                 if (bh->state == BUF_STATE_EMPTY && get_some_more) {
 
-                        /* Figure out how much we want to get:
+                        /*
+                         * Figure out how much we want to get:
                          * Try to get the remaining amount.
                          * But don't get more than the buffer size.
                          * And don't try to go past the end of the file.
@@ -923,14 +933,15 @@ static int do_write(struct fsg_common *common)
                          *      don't go past the next page.
                          * If this means getting 0, then we were asked
                          *      to write past the end of file.
-                         * Finally, round down to a block boundary. */
+                         * Finally, round down to a block boundary.
+                         */
                         amount = min(amount_left_to_req, FSG_BUFLEN);
-                        amount = min((loff_t) amount, curlun->file_length -
-                                        usb_offset);
+                        amount = min((loff_t)amount,
+                                     curlun->file_length - usb_offset);
                         partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
                         if (partial_page > 0)
                                 amount = min(amount,
-        (unsigned int) PAGE_CACHE_SIZE - partial_page);
+        (unsigned int)PAGE_CACHE_SIZE - partial_page);
 
                         if (amount == 0) {
                                 get_some_more = 0;
@@ -940,11 +951,13 @@ static int do_write(struct fsg_common *common)
                                 curlun->info_valid = 1;
                                 continue;
                         }
-                        amount -= (amount & 511);
+                        amount -= amount & 511;
                         if (amount == 0) {
 
-                                /* Why were we were asked to transfer a
-                                 * partial block? */
+                                /*
+                                 * Why were we were asked to transfer a
+                                 * partial block?
+                                 */
                                 get_some_more = 0;
                                 continue;
                         }
@@ -956,15 +969,15 @@ static int do_write(struct fsg_common *common)
                         if (amount_left_to_req == 0)
                                 get_some_more = 0;
 
-                        /* amount is always divisible by 512, hence by
-                         * the bulk-out maxpacket size */
+                        /*
+                         * amount is always divisible by 512, hence by
+                         * the bulk-out maxpacket size
+                         */
                         bh->outreq->length = amount;
                         bh->bulk_out_intended_length = amount;
                         bh->outreq->short_not_ok = 1;
-                        START_TRANSFER_OR(common, bulk_out, bh->outreq,
-                                          &bh->outreq_busy, &bh->state)
-                                /* Don't know what to do if
-                                 * common->fsg is NULL */
+                        if (!start_out_transfer(common, bh))
+                                /* Dunno what to do if common->fsg is NULL */
                                 return -EIO;
                         common->next_buffhd_to_fill = bh->next;
                         continue;
@@ -990,30 +1003,29 @@ static int do_write(struct fsg_common *common)
                         amount = bh->outreq->actual;
                         if (curlun->file_length - file_offset < amount) {
                                 LERROR(curlun,
-        "write %u @ %llu beyond end %llu\n",
-        amount, (unsigned long long) file_offset,
-        (unsigned long long) curlun->file_length);
+                                       "write %u @ %llu beyond end %llu\n",
+                                       amount, (unsigned long long)file_offset,
+                                       (unsigned long long)curlun->file_length);
                                 amount = curlun->file_length - file_offset;
                         }
 
                         /* Perform the write */
                         file_offset_tmp = file_offset;
                         nwritten = vfs_write(curlun->filp,
-                                        (char __user *) bh->buf,
-                                        amount, &file_offset_tmp);
+                                             (char __user *)bh->buf,
+                                             amount, &file_offset_tmp);
                         VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
-                                        (unsigned long long) file_offset,
-                                        (int) nwritten);
+                              (unsigned long long)file_offset, (int)nwritten);
                         if (signal_pending(current))
                                 return -EINTR;          /* Interrupted! */
 
                         if (nwritten < 0) {
                                 LDBG(curlun, "error in file write: %d\n",
-                                                (int) nwritten);
+                                     (int)nwritten);
                                 nwritten = 0;
                         } else if (nwritten < amount) {
                                 LDBG(curlun, "partial file write: %d/%u\n",
-                                                (int) nwritten, amount);
+                                     (int)nwritten, amount);
                                 nwritten -= (nwritten & 511);
                                 /* Round down to a block */
                         }
@@ -1086,16 +1098,20 @@ static int do_verify(struct fsg_common *common)
         unsigned int            amount;
         ssize_t                 nread;
 
-        /* Get the starting Logical Block Address and check that it's
-         * not too big */
+        /*
+         * Get the starting Logical Block Address and check that it's
+         * not too big.
+         */
         lba = get_unaligned_be32(&common->cmnd[2]);
         if (lba >= curlun->num_sectors) {
                 curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
                 return -EINVAL;
         }
 
-        /* We allow DPO (Disable Page Out = don't save data in the
-         * cache) but we don't implement it. */
+        /*
+         * We allow DPO (Disable Page Out = don't save data in the
+         * cache) but we don't implement it.
+         */
         if (common->cmnd[1] & ~0x10) {
                 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
                 return -EINVAL;
@@ -1120,16 +1136,17 @@ static int do_verify(struct fsg_common *common)
 
         /* Just try to read the requested blocks */
         while (amount_left > 0) {
-
-                /* Figure out how much we need to read:
+                /*
+                 * Figure out how much we need to read:
                  * Try to read the remaining amount, but not more than
                  * the buffer size.
                  * And don't try to read past the end of the file.
                  * If this means reading 0 then we were asked to read
-                 * past the end of file. */
+                 * past the end of file.
+                 */
                 amount = min(amount_left, FSG_BUFLEN);
-                amount = min((loff_t) amount,
-                                curlun->file_length - file_offset);
+                amount = min((loff_t)amount,
+                             curlun->file_length - file_offset);
                 if (amount == 0) {
                         curlun->sense_data =
                                         SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
@@ -1150,13 +1167,12 @@ static int do_verify(struct fsg_common *common)
                         return -EINTR;
 
                 if (nread < 0) {
-                        LDBG(curlun, "error in file verify: %d\n",
-                                        (int) nread);
+                        LDBG(curlun, "error in file verify: %d\n", (int)nread);
                         nread = 0;
                 } else if (nread < amount) {
                         LDBG(curlun, "partial file verify: %d/%u\n",
-                                        (int) nread, amount);
-                        nread -= (nread & 511); /* Round down to a sector */
+                             (int)nread, amount);
+                        nread -= nread & 511;   /* Round down to a sector */
                 }
                 if (nread == 0) {
                         curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
@@ -1198,7 +1214,6 @@ static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
         return 36;
 }
 
-
 static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1252,13 +1267,12 @@ static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
         return 18;
 }
 
-
 static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
         u32             lba = get_unaligned_be32(&common->cmnd[2]);
         int             pmi = common->cmnd[8];
-        u8              *buf = (u8 *) bh->buf;
+        u8              *buf = (u8 *)bh->buf;
 
         /* Check the PMI and LBA fields */
         if (pmi > 1 || (pmi == 0 && lba != 0)) {
@@ -1272,13 +1286,12 @@ static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
         return 8;
 }
 
-
 static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
         int             msf = common->cmnd[1] & 0x02;
         u32             lba = get_unaligned_be32(&common->cmnd[2]);
-        u8              *buf = (u8 *) bh->buf;
+        u8              *buf = (u8 *)bh->buf;
 
         if (common->cmnd[1] & ~0x02) {          /* Mask away MSF */
                 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
@@ -1295,13 +1308,12 @@ static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
         return 8;
 }
 
-
 static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
         int             msf = common->cmnd[1] & 0x02;
         int             start_track = common->cmnd[6];
-        u8              *buf = (u8 *) bh->buf;
+        u8              *buf = (u8 *)bh->buf;
 
         if ((common->cmnd[1] & ~0x02) != 0 ||   /* Mask away MSF */
                         start_track > 1) {
@@ -1323,7 +1335,6 @@ static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
         return 20;
 }
 
-
 static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1348,10 +1359,12 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
         changeable_values = (pc == 1);
         all_pages = (page_code == 0x3f);
 
-        /* Write the mode parameter header.  Fixed values are: default
+        /*
+         * Write the mode parameter header.  Fixed values are: default
          * medium type, no cache control (DPOFUA), and no block descriptors.
          * The only variable value is the WriteProtect bit.  We will fill in
-         * the mode data length later. */
+         * the mode data length later.
+         */
         memset(buf, 0, 8);
         if (mscmnd == MODE_SENSE) {
                 buf[2] = (curlun->ro ? 0x80 : 0x00);            /* WP, DPOFUA */
@@ -1365,8 +1378,10 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 
         /* No block descriptors */
 
-        /* The mode pages, in numerical order.  The only page we support
-         * is the Caching page. */
+        /*
+         * The mode pages, in numerical order.  The only page we support
+         * is the Caching page.
+         */
         if (page_code == 0x08 || all_pages) {
                 valid_page = 1;
                 buf[0] = 0x08;          /* Page code */
@@ -1388,8 +1403,10 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
                 buf += 12;
         }
 
-        /* Check that a valid page was requested and the mode data length
-         * isn't too long. */
+        /*
+         * Check that a valid page was requested and the mode data length
+         * isn't too long.
+         */
         len = buf - buf0;
         if (!valid_page || len > limit) {
                 curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
@@ -1404,7 +1421,6 @@ static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
         return len;
 }
 
-
 static int do_start_stop(struct fsg_common *common)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1424,8 +1440,10 @@ static int do_start_stop(struct fsg_common *common)
         loej  = common->cmnd[4] & 0x02;
         start = common->cmnd[4] & 0x01;
 
-        /* Our emulation doesn't support mounting; the medium is
-         * available for use as soon as it is loaded. */
+        /*
+         * Our emulation doesn't support mounting; the medium is
+         * available for use as soon as it is loaded.
+         */
         if (start) {
                 if (!fsg_lun_is_open(curlun)) {
                         curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
@@ -1466,7 +1484,6 @@ static int do_start_stop(struct fsg_common *common)
                 : 0;
 }
 
-
 static int do_prevent_allow(struct fsg_common *common)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1491,7 +1508,6 @@ static int do_prevent_allow(struct fsg_common *common)
         return 0;
 }
 
-
 static int do_read_format_capacities(struct fsg_common *common,
                         struct fsg_buffhd *bh)
 {
@@ -1509,7 +1525,6 @@ static int do_read_format_capacities(struct fsg_common *common,
         return 12;
 }
 
-
 static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
 {
         struct fsg_lun  *curlun = common->curlun;
@@ -1591,7 +1606,7 @@ static int pad_with_zeros(struct fsg_dev *fsg)
                 bh->inreq->length = nsend;
                 bh->inreq->zero = 0;
                 start_transfer(fsg, fsg->bulk_in, bh->inreq,
-                                &bh->inreq_busy, &bh->state);
+                               &bh->inreq_busy, &bh->state);
                 bh = fsg->common->next_buffhd_to_fill = bh->next;
                 fsg->common->usb_amount_left -= nsend;
                 nkeep = 0;
@@ -1617,7 +1632,7 @@ static int throw_away_data(struct fsg_common *common)
 
                         /* A short packet or an error ends everything */
                         if (bh->outreq->actual != bh->outreq->length ||
-                                        bh->outreq->status != 0) {
+                            bh->outreq->status != 0) {
                                 raise_exception(common,
                                                 FSG_STATE_ABORT_BULK_OUT);
                                 return -EINTR;
@@ -1631,15 +1646,15 @@ static int throw_away_data(struct fsg_common *common)
                  && common->usb_amount_left > 0) {
                         amount = min(common->usb_amount_left, FSG_BUFLEN);
 
-                        /* amount is always divisible by 512, hence by
-                         * the bulk-out maxpacket size */
+                        /*
+                         * amount is always divisible by 512, hence by
+                         * the bulk-out maxpacket size.
+                         */
                         bh->outreq->length = amount;
                         bh->bulk_out_intended_length = amount;
                         bh->outreq->short_not_ok = 1;
-                        START_TRANSFER_OR(common, bulk_out, bh->outreq,
-                                          &bh->outreq_busy, &bh->state)
-                                /* Don't know what to do if
-                                 * common->fsg is NULL */
+                        if (!start_out_transfer(common, bh))
+                                /* Dunno what to do if common->fsg is NULL */
                                 return -EIO;
                         common->next_buffhd_to_fill = bh->next;
                         common->usb_amount_left -= amount;
@@ -1654,7 +1669,6 @@ static int throw_away_data(struct fsg_common *common)
         return 0;
 }
 
-
 static int finish_reply(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh = common->next_buffhd_to_fill;
@@ -1664,10 +1678,12 @@ static int finish_reply(struct fsg_common *common)
         case DATA_DIR_NONE:
                 break;                  /* Nothing to send */
 
-        /* If we don't know whether the host wants to read or write,
+        /*
+         * If we don't know whether the host wants to read or write,
          * this must be CB or CBI with an unknown command.  We mustn't
          * try to send or receive any data.  So stall both bulk pipes
-         * if we can and wait for a reset. */
+         * if we can and wait for a reset.
+         */
         case DATA_DIR_UNKNOWN:
                 if (!common->can_stall) {
                         /* Nothing */
@@ -1688,18 +1704,18 @@ static int finish_reply(struct fsg_common *common)
                 /* If there's no residue, simply send the last buffer */
                 } else if (common->residue == 0) {
                         bh->inreq->zero = 0;
-                        START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                                          &bh->inreq_busy, &bh->state)
+                        if (!start_in_transfer(common, bh))
                                 return -EIO;
                         common->next_buffhd_to_fill = bh->next;
 
-                /* For Bulk-only, if we're allowed to stall then send the
+                /*
+                 * For Bulk-only, if we're allowed to stall then send the
                  * short packet and halt the bulk-in endpoint.  If we can't
-                 * stall, pad out the remaining data with 0's. */
+                 * stall, pad out the remaining data with 0's.
+                 */
                 } else if (common->can_stall) {
                         bh->inreq->zero = 1;
-                        START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                                          &bh->inreq_busy, &bh->state)
+                        if (!start_in_transfer(common, bh))
                                 /* Don't know what to do if
                                  * common->fsg is NULL */
                                 rc = -EIO;
@@ -1714,8 +1730,10 @@ static int finish_reply(struct fsg_common *common)
                 }
                 break;
 
-        /* We have processed all we want from the data the host has sent.
-         * There may still be outstanding bulk-out requests. */
+        /*
+         * We have processed all we want from the data the host has sent.
+         * There may still be outstanding bulk-out requests.
+         */
         case DATA_DIR_FROM_HOST:
                 if (common->residue == 0) {
                         /* Nothing to receive */
@@ -1725,12 +1743,14 @@ static int finish_reply(struct fsg_common *common)
                         raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
                         rc = -EINTR;
 
-                /* We haven't processed all the incoming data.  Even though
+                /*
+                 * We haven't processed all the incoming data.  Even though
                  * we may be allowed to stall, doing so would cause a race.
                  * The controller may already have ACK'ed all the remaining
                  * bulk-out packets, in which case the host wouldn't see a
                  * STALL.  Not realizing the endpoint was halted, it wouldn't
-                 * clear the halt -- leading to problems later on. */
+                 * clear the halt -- leading to problems later on.
+                 */
 #if 0
                 } else if (common->can_stall) {
                         if (fsg_is_set(common))
@@ -1740,8 +1760,10 @@ static int finish_reply(struct fsg_common *common)
                         rc = -EINTR;
 #endif
 
-                /* We can't stall.  Read in the excess data and throw it
-                 * all away. */
+                /*
+                 * We can't stall.  Read in the excess data and throw it
+                 * all away.
+                 */
                 } else {
                         rc = throw_away_data(common);
                 }
@@ -1750,7 +1772,6 @@ static int finish_reply(struct fsg_common *common)
         return rc;
 }
 
-
 static int send_status(struct fsg_common *common)
 {
         struct fsg_lun          *curlun = common->curlun;
@@ -1798,8 +1819,7 @@ static int send_status(struct fsg_common *common)
 
         bh->inreq->length = USB_BULK_CS_WRAP_LEN;
         bh->inreq->zero = 0;
-        START_TRANSFER_OR(common, bulk_in, bh->inreq,
-                          &bh->inreq_busy, &bh->state)
+        if (!start_in_transfer(common, bh))
                 /* Don't know what to do if common->fsg is NULL */
                 return -EIO;
 
@@ -1810,11 +1830,13 @@ static int send_status(struct fsg_common *common)
 
 /*-------------------------------------------------------------------------*/
 
-/* Check whether the command is properly formed and whether its data size
- * and direction agree with the values we already have. */
+/*
+ * Check whether the command is properly formed and whether its data size
+ * and direction agree with the values we already have.
+ */
 static int check_command(struct fsg_common *common, int cmnd_size,
-                enum data_direction data_dir, unsigned int mask,
-                int needs_medium, const char *name)
+                         enum data_direction data_dir, unsigned int mask,
+                         int needs_medium, const char *name)
 {
         int                     i;
         int                     lun = common->cmnd[1] >> 5;
@@ -1825,19 +1847,23 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         hdlen[0] = 0;
         if (common->data_dir != DATA_DIR_UNKNOWN)
                 sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
-                                common->data_size);
+                        common->data_size);
         VDBG(common, "SCSI command: %s;  Dc=%d, D%c=%u;  Hc=%d%s\n",
              name, cmnd_size, dirletter[(int) data_dir],
              common->data_size_from_cmnd, common->cmnd_size, hdlen);
 
-        /* We can't reply at all until we know the correct data direction
-         * and size. */
+        /*
+         * We can't reply at all until we know the correct data direction
+         * and size.
+         */
         if (common->data_size_from_cmnd == 0)
                 data_dir = DATA_DIR_NONE;
         if (common->data_size < common->data_size_from_cmnd) {
-                /* Host data size < Device data size is a phase error.
+                /*
+                 * Host data size < Device data size is a phase error.
                  * Carry out the command, but only transfer as much as
-                 * we are allowed. */
+                 * we are allowed.
+                 */
                 common->data_size_from_cmnd = common->data_size;
                 common->phase_error = 1;
         }
@@ -1845,8 +1871,7 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         common->usb_amount_left = common->data_size;
 
         /* Conflicting data directions is a phase error */
-        if (common->data_dir != data_dir
-         && common->data_size_from_cmnd > 0) {
+        if (common->data_dir != data_dir && common->data_size_from_cmnd > 0) {
                 common->phase_error = 1;
                 return -EINVAL;
         }
@@ -1854,7 +1879,8 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         /* Verify the length of the command itself */
         if (cmnd_size != common->cmnd_size) {
 
-                /* Special case workaround: There are plenty of buggy SCSI
+                /*
+                 * Special case workaround: There are plenty of buggy SCSI
                  * implementations. Many have issues with cbw->Length
                  * field passing a wrong command size. For those cases we
                  * always try to work around the problem by using the length
@@ -1896,8 +1922,10 @@ static int check_command(struct fsg_common *common, int cmnd_size,
                 curlun = NULL;
                 common->bad_lun_okay = 0;
 
-                /* INQUIRY and REQUEST SENSE commands are explicitly allowed
-                 * to use unsupported LUNs; all others may not. */
+                /*
+                 * INQUIRY and REQUEST SENSE commands are explicitly allowed
+                 * to use unsupported LUNs; all others may not.
+                 */
                 if (common->cmnd[0] != INQUIRY &&
                     common->cmnd[0] != REQUEST_SENSE) {
                         DBG(common, "unsupported LUN %d\n", common->lun);
@@ -1905,11 +1933,13 @@ static int check_command(struct fsg_common *common, int cmnd_size,
                 }
         }
 
-        /* If a unit attention condition exists, only INQUIRY and
-         * REQUEST SENSE commands are allowed; anything else must fail. */
+        /*
+         * If a unit attention condition exists, only INQUIRY and
+         * REQUEST SENSE commands are allowed; anything else must fail.
+         */
         if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
-                        common->cmnd[0] != INQUIRY &&
-                        common->cmnd[0] != REQUEST_SENSE) {
+            common->cmnd[0] != INQUIRY &&
+            common->cmnd[0] != REQUEST_SENSE) {
                 curlun->sense_data = curlun->unit_attention_data;
                 curlun->unit_attention_data = SS_NO_SENSE;
                 return -EINVAL;
@@ -1935,7 +1965,6 @@ static int check_command(struct fsg_common *common, int cmnd_size,
         return 0;
 }
 
-
 static int do_scsi_command(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh;
@@ -2123,8 +2152,10 @@ static int do_scsi_command(struct fsg_common *common)
                                 "TEST UNIT READY");
                 break;
 
-        /* Although optional, this command is used by MS-Windows.  We
-         * support a minimal version: BytChk must be 0. */
+        /*
+         * Although optional, this command is used by MS-Windows.  We
+         * support a minimal version: BytChk must be 0.
+         */
         case VERIFY:
                 common->data_size_from_cmnd = 0;
                 reply = check_command(common, 10, DATA_DIR_NONE,
@@ -2164,10 +2195,12 @@ static int do_scsi_command(struct fsg_common *common)
                         reply = do_write(common);
                 break;
 
-        /* Some mandatory commands that we recognize but don't implement.
+        /*
+         * Some mandatory commands that we recognize but don't implement.
          * They don't mean much in this setting.  It's left as an exercise
          * for anyone interested to implement RESERVE and RELEASE in terms
-         * of Posix locks. */
+         * of Posix locks.
+         */
         case FORMAT_UNIT:
         case RELEASE:
         case RESERVE:
@@ -2195,7 +2228,7 @@ unknown_cmnd:
         if (reply == -EINVAL)
                 reply = 0;              /* Error reply length */
         if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
-                reply = min((u32) reply, common->data_size_from_cmnd);
+                reply = min((u32)reply, common->data_size_from_cmnd);
                 bh->inreq->length = reply;
                 bh->state = BUF_STATE_FULL;
                 common->residue -= reply;
@@ -2225,7 +2258,8 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                                 req->actual,
                                 le32_to_cpu(cbw->Signature));
 
-                /* The Bulk-only spec says we MUST stall the IN endpoint
+                /*
+                 * The Bulk-only spec says we MUST stall the IN endpoint
                  * (6.6.1), so it's unavoidable.  It also says we must
                  * retain this state until the next reset, but there's
                  * no way to tell the controller driver it should ignore
@@ -2233,7 +2267,8 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                  *
                  * We aren't required to halt the OUT endpoint; instead
                  * we can simply accept and discard any data received
-                 * until the next reset. */
+                 * until the next reset.
+                 */
                 wedge_bulk_in_endpoint(fsg);
                 set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
                 return -EINVAL;
@@ -2246,8 +2281,10 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                                 "cmdlen %u\n",
                                 cbw->Lun, cbw->Flags, cbw->Length);
 
-                /* We can do anything we want here, so let's stall the
-                 * bulk pipes if we are allowed to. */
+                /*
+                 * We can do anything we want here, so let's stall the
+                 * bulk pipes if we are allowed to.
+                 */
                 if (common->can_stall) {
                         fsg_set_halt(fsg, fsg->bulk_out);
                         halt_bulk_in_endpoint(fsg);
@@ -2270,7 +2307,6 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         return 0;
 }
 
-
 static int get_next_command(struct fsg_common *common)
 {
         struct fsg_buffhd       *bh;
@@ -2287,14 +2323,15 @@ static int get_next_command(struct fsg_common *common)
         /* Queue a request to read a Bulk-only CBW */
         set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
         bh->outreq->short_not_ok = 1;
-        START_TRANSFER_OR(common, bulk_out, bh->outreq,
-                          &bh->outreq_busy, &bh->state)
+        if (!start_out_transfer(common, bh))
                 /* Don't know what to do if common->fsg is NULL */
                 return -EIO;
 
-        /* We will drain the buffer in software, which means we
+        /*
+         * We will drain the buffer in software, which means we
          * can reuse it for the next filling.  No need to advance
-         * next_buffhd_to_fill. */
+         * next_buffhd_to_fill.
+         */
 
         /* Wait for the CBW to arrive */
         while (bh->state != BUF_STATE_FULL) {
@@ -2425,7 +2462,6 @@ reset:
 
 /****************************** ALT CONFIGS ******************************/
 
-
 static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 {
         struct fsg_dev *fsg = fsg_from_func(f);
@@ -2453,8 +2489,10 @@ static void handle_exception(struct fsg_common *common)
         struct fsg_lun          *curlun;
         unsigned int            exception_req_tag;
 
-        /* Clear the existing signals.  Anything but SIGUSR1 is converted
-         * into a high-priority EXIT exception. */
+        /*
+         * Clear the existing signals.  Anything but SIGUSR1 is converted
+         * into a high-priority EXIT exception.
+         */
         for (;;) {
                 int sig =
                         dequeue_signal_lock(current, &current->blocked, &info);
@@ -2498,8 +2536,10 @@ static void handle_exception(struct fsg_common *common)
                         usb_ep_fifo_flush(common->fsg->bulk_out);
         }
 
-        /* Reset the I/O buffer states and pointers, the SCSI
-         * state, and the exception.  Then invoke the handler. */
+        /*
+         * Reset the I/O buffer states and pointers, the SCSI
+         * state, and the exception.  Then invoke the handler.
+         */
         spin_lock_irq(&common->lock);
 
         for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
@@ -2537,9 +2577,11 @@ static void handle_exception(struct fsg_common *common)
                 break;
 
         case FSG_STATE_RESET:
-                /* In case we were forced against our will to halt a
+                /*
+                 * In case we were forced against our will to halt a
                  * bulk endpoint, clear the halt now.  (The SuperH UDC
-                 * requires this.) */
+                 * requires this.)
+                 */
                 if (!fsg_is_set(common))
                         break;
                 if (test_and_clear_bit(IGNORE_BULK_OUT,
@@ -2549,9 +2591,11 @@ static void handle_exception(struct fsg_common *common)
                 if (common->ep0_req_tag == exception_req_tag)
                         ep0_queue(common);      /* Complete the status stage */
 
-                /* Technically this should go here, but it would only be
+                /*
+                 * Technically this should go here, but it would only be
                  * a waste of time.  Ditto for the INTERFACE_CHANGE and
-                 * CONFIG_CHANGE cases. */
+                 * CONFIG_CHANGE cases.
+                 */
                 /* for (i = 0; i < common->nluns; ++i) */
                 /*      common->luns[i].unit_attention_data = */
                 /*              SS_RESET_OCCURRED;  */
@@ -2586,8 +2630,10 @@ static int fsg_main_thread(void *common_)
 {
         struct fsg_common       *common = common_;
 
-        /* Allow the thread to be killed by a signal, but set the signal mask
-         * to block everything but INT, TERM, KILL, and USR1. */
+        /*
+         * Allow the thread to be killed by a signal, but set the signal mask
+         * to block everything but INT, TERM, KILL, and USR1.
+         */
         allow_signal(SIGINT);
         allow_signal(SIGTERM);
         allow_signal(SIGKILL);
@@ -2596,9 +2642,11 @@ static int fsg_main_thread(void *common_)
         /* Allow the thread to be frozen */
         set_freezable();
 
-        /* Arrange for userspace references to be interpreted as kernel
+        /*
+         * Arrange for userspace references to be interpreted as kernel
          * pointers.  That way we can pass a kernel pointer to a routine
-         * that expects a __user pointer and it will work okay. */
+         * that expects a __user pointer and it will work okay.
+         */
         set_fs(get_ds());
 
         /* The main loop */
@@ -2658,7 +2706,7 @@ static int fsg_main_thread(void *common_)
                 up_write(&common->filesem);
         }
 
-        /* Let the unbind and cleanup routines know the thread has exited */
+        /* Let fsg_unbind() know the thread has exited */
         complete_and_exit(&common->thread_notifier, 0);
 }
 
@@ -2690,7 +2738,6 @@ static inline void fsg_common_put(struct fsg_common *common)
         kref_put(&common->ref, fsg_common_release);
 }
 
-
 static struct fsg_common *fsg_common_init(struct fsg_common *common,
                                           struct usb_composite_dev *cdev,
                                           struct fsg_config *cfg)
@@ -2736,8 +2783,10 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
                 fsg_intf_desc.iInterface = rc;
         }
 
-        /* Create the LUNs, open their backing files, and register the
-         * LUN devices in sysfs. */
+        /*
+         * Create the LUNs, open their backing files, and register the
+         * LUN devices in sysfs.
+         */
         curlun = kzalloc(nluns * sizeof *curlun, GFP_KERNEL);
         if (unlikely(!curlun)) {
                 rc = -ENOMEM;
@@ -2765,6 +2814,7 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
                 if (rc) {
                         INFO(common, "failed to register LUN%d: %d\n", i, rc);
                         common->nluns = i;
+                        put_device(&curlun->dev);
                         goto error_release;
                 }
 
@@ -2790,7 +2840,6 @@ static struct fsg_common *fsg_common_init(struct fsg_common *common,
         }
         common->nluns = nluns;
 
-
         /* Data buffers cyclic list */
         bh = common->buffhds;
         i = FSG_NUM_BUFFERS;
@@ -2807,7 +2856,6 @@ buffhds_first_it:
         } while (--i);
         bh->next = common->buffhds;
 
-
         /* Prepare inquiryString */
         if (cfg->release != 0xffff) {
                 i = cfg->release;
@@ -2821,41 +2869,35 @@ buffhds_first_it:
                         i = 0x0399;
                 }
         }
-#define OR(x, y) ((x) ? (x) : (y))
         snprintf(common->inquiry_string, sizeof common->inquiry_string,
-                 "%-8s%-16s%04x",
-                 OR(cfg->vendor_name, "Linux   "),
+                 "%-8s%-16s%04x", cfg->vendor_name ?: "Linux",
                  /* Assume product name dependent on the first LUN */
-                 OR(cfg->product_name, common->luns->cdrom
+                 cfg->product_name ?: (common->luns->cdrom
                                      ? "File-Stor Gadget"
-                                     : "File-CD Gadget  "),
+                                     : "File-CD Gadget"),
                  i);
 
-
-        /* Some peripheral controllers are known not to be able to
+        /*
+         * Some peripheral controllers are known not to be able to
          * halt bulk endpoints correctly.  If one of them is present,
          * disable stalls.
          */
         common->can_stall = cfg->can_stall &&
                 !(gadget_is_at91(common->gadget));
 
-
         spin_lock_init(&common->lock);
         kref_init(&common->ref);
 
-
         /* Tell the thread to start working */
         common->thread_task =
                 kthread_create(fsg_main_thread, common,
-                               OR(cfg->thread_name, "file-storage"));
+                               cfg->thread_name ?: "file-storage");
         if (IS_ERR(common->thread_task)) {
                 rc = PTR_ERR(common->thread_task);
                 goto error_release;
         }
         init_completion(&common->thread_notifier);
         init_waitqueue_head(&common->fsg_wait);
-#undef OR
-
 
         /* Information */
         INFO(common, FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
@@ -2889,18 +2931,15 @@ buffhds_first_it:
 
         return common;
 
-
 error_luns:
         common->nluns = i + 1;
 error_release:
         common->state = FSG_STATE_TERMINATED;   /* The thread is dead */
-        /* Call fsg_common_release() directly, ref might be not
-         * initialised */
+        /* Call fsg_common_release() directly, ref might be not initialised. */
         fsg_common_release(&common->ref);
         return ERR_PTR(rc);
 }
 
-
 static void fsg_common_release(struct kref *ref)
 {
         struct fsg_common *common = container_of(ref, struct fsg_common, ref);
@@ -2909,9 +2948,6 @@ static void fsg_common_release(struct kref *ref)
         if (common->state != FSG_STATE_TERMINATED) {
                 raise_exception(common, FSG_STATE_EXIT);
                 wait_for_completion(&common->thread_notifier);
-
-                /* The cleanup routine waits for this completion also */
-                complete(&common->thread_notifier);
         }
 
         if (likely(common->luns)) {
@@ -2945,7 +2981,6 @@ static void fsg_common_release(struct kref *ref)
 
 /*-------------------------------------------------------------------------*/
 
-
 static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
@@ -2965,7 +3000,6 @@ static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
         kfree(fsg);
 }
 
-
 static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
@@ -3048,11 +3082,13 @@ static int fsg_bind_config(struct usb_composite_dev *cdev,
         fsg->function.disable     = fsg_disable;
 
         fsg->common               = common;
-        /* Our caller holds a reference to common structure so we
+        /*
+         * Our caller holds a reference to common structure so we
          * don't have to be worry about it being freed until we return
          * from this function.  So instead of incrementing counter now
          * and decrement in error recovery we increment it only when
-         * call to usb_add_function() was successful. */
+         * call to usb_add_function() was successful.
+         */
 
         rc = usb_add_function(c, &fsg->function);
         if (unlikely(rc))
@@ -3063,8 +3099,7 @@ static int fsg_bind_config(struct usb_composite_dev *cdev,
 }
 
 static inline int __deprecated __maybe_unused
-fsg_add(struct usb_composite_dev *cdev,
-        struct usb_configuration *c,
+fsg_add(struct usb_composite_dev *cdev, struct usb_configuration *c,
         struct fsg_common *common)
 {
         return fsg_bind_config(cdev, c, common);
@@ -3073,7 +3108,6 @@ fsg_add(struct usb_composite_dev *cdev,
 
 /************************* Module parameters *************************/
 
-
 struct fsg_module_parameters {
         char            *file[FSG_MAX_LUNS];
         int             ro[FSG_MAX_LUNS];
@@ -3087,7 +3121,6 @@ struct fsg_module_parameters {
         int             stall;  /* can_stall */
 };
 
-
 #define _FSG_MODULE_PARAM_ARRAY(prefix, params, name, type, desc)       \
         module_param_array_named(prefix ## name, params.name, type,     \
                                  &prefix ## params.name ## _count,      \
@@ -3115,7 +3148,6 @@ struct fsg_module_parameters {
         _FSG_MODULE_PARAM(prefix, params, stall, bool,                  \
                           "false to prevent bulk stalls")
 
-
 static void
 fsg_config_from_params(struct fsg_config *cfg,
                        const struct fsg_module_parameters *params)
diff --git a/drivers/usb/gadget/f_ncm.c b/drivers/usb/gadget/f_ncm.c
new file mode 100644
index 000000000000..130eee678c8b
--- /dev/null
+++ b/drivers/usb/gadget/f_ncm.c
@@ -0,0 +1,1407 @@
+/*
+ * f_ncm.c -- USB CDC Network (NCM) link function driver
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
+ *
+ * The driver borrows from f_ecm.c which is:
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/etherdevice.h>
+#include <linux/crc32.h>
+
+#include <linux/usb/cdc.h>
+
+#include "u_ether.h"
+
+/*
+ * This function is a "CDC Network Control Model" (CDC NCM) Ethernet link.
+ * NCM is intended to be used with high-speed network attachments.
+ *
+ * Note that NCM requires the use of "alternate settings" for its data
+ * interface.  This means that the set_alt() method has real work to do,
+ * and also means that a get_alt() method is required.
+ */
+
+/* to trigger crc/non-crc ndp signature */
+
+#define NCM_NDP_HDR_CRC_MASK    0x01000000
+#define NCM_NDP_HDR_CRC         0x01000000
+#define NCM_NDP_HDR_NOCRC       0x00000000
+
+struct ncm_ep_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+        struct usb_endpoint_descriptor  *notify;
+};
+
+enum ncm_notify_state {
+        NCM_NOTIFY_NONE,                /* don't notify */
+        NCM_NOTIFY_CONNECT,             /* issue CONNECT next */
+        NCM_NOTIFY_SPEED,               /* issue SPEED_CHANGE next */
+};
+
+struct f_ncm {
+        struct gether                   port;
+        u8                              ctrl_id, data_id;
+
+        char                            ethaddr[14];
+
+        struct ncm_ep_descs             fs;
+        struct ncm_ep_descs             hs;
+
+        struct usb_ep                   *notify;
+        struct usb_endpoint_descriptor  *notify_desc;
+        struct usb_request              *notify_req;
+        u8                              notify_state;
+        bool                            is_open;
+
+        struct ndp_parser_opts          *parser_opts;
+        bool                            is_crc;
+
+        /*
+         * for notification, it is accessed from both
+         * callback and ethernet open/close
+         */
+        spinlock_t                      lock;
+};
+
+static inline struct f_ncm *func_to_ncm(struct usb_function *f)
+{
+        return container_of(f, struct f_ncm, port.func);
+}
+
+/* peak (theoretical) bulk transfer rate in bits-per-second */
+static inline unsigned ncm_bitrate(struct usb_gadget *g)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return 13 * 512 * 8 * 1000 * 8;
+        else
+                return 19 *  64 * 1 * 1000 * 8;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * We cannot group frames so use just the minimal size which ok to put
+ * one max-size ethernet frame.
+ * If the host can group frames, allow it to do that, 16K is selected,
+ * because it's used by default by the current linux host driver
+ */
+#define NTB_DEFAULT_IN_SIZE     USB_CDC_NCM_NTB_MIN_IN_SIZE
+#define NTB_OUT_SIZE            16384
+
+/*
+ * skbs of size less than that will not be alligned
+ * to NCM's dwNtbInMaxSize to save bus bandwidth
+ */
+
+#define MAX_TX_NONFIXED         (512 * 3)
+
+#define FORMATS_SUPPORTED       (USB_CDC_NCM_NTB16_SUPPORTED |  \
+                                 USB_CDC_NCM_NTB32_SUPPORTED)
+
+static struct usb_cdc_ncm_ntb_parameters ntb_parameters = {
+        .wLength = sizeof ntb_parameters,
+        .bmNtbFormatsSupported = cpu_to_le16(FORMATS_SUPPORTED),
+        .dwNtbInMaxSize = cpu_to_le32(NTB_DEFAULT_IN_SIZE),
+        .wNdpInDivisor = cpu_to_le16(4),
+        .wNdpInPayloadRemainder = cpu_to_le16(0),
+        .wNdpInAlignment = cpu_to_le16(4),
+
+        .dwNtbOutMaxSize = cpu_to_le32(NTB_OUT_SIZE),
+        .wNdpOutDivisor = cpu_to_le16(4),
+        .wNdpOutPayloadRemainder = cpu_to_le16(0),
+        .wNdpOutAlignment = cpu_to_le16(4),
+};
+
+/*
+ * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
+ * packet, to simplify cancellation; and a big transfer interval, to
+ * waste less bandwidth.
+ */
+
+#define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
+#define NCM_STATUS_BYTECOUNT            16      /* 8 byte header + data */
+
+static struct usb_interface_assoc_descriptor ncm_iad_desc __initdata = {
+        .bLength =              sizeof ncm_iad_desc,
+        .bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
+
+        /* .bFirstInterface =   DYNAMIC, */
+        .bInterfaceCount =      2,      /* control + data */
+        .bFunctionClass =       USB_CLASS_COMM,
+        .bFunctionSubClass =    USB_CDC_SUBCLASS_NCM,
+        .bFunctionProtocol =    USB_CDC_PROTO_NONE,
+        /* .iFunction =         DYNAMIC */
+};
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor ncm_control_intf __initdata = {
+        .bLength =              sizeof ncm_control_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        .bNumEndpoints =        1,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_NCM,
+        .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_cdc_header_desc ncm_header_desc __initdata = {
+        .bLength =              sizeof ncm_header_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
+
+        .bcdCDC =               cpu_to_le16(0x0110),
+};
+
+static struct usb_cdc_union_desc ncm_union_desc __initdata = {
+        .bLength =              sizeof(ncm_union_desc),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
+        /* .bMasterInterface0 = DYNAMIC */
+        /* .bSlaveInterface0 =  DYNAMIC */
+};
+
+static struct usb_cdc_ether_desc ecm_desc __initdata = {
+        .bLength =              sizeof ecm_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
+
+        /* this descriptor actually adds value, surprise! */
+        /* .iMACAddress = DYNAMIC */
+        .bmEthernetStatistics = cpu_to_le32(0), /* no statistics */
+        .wMaxSegmentSize =      cpu_to_le16(ETH_FRAME_LEN),
+        .wNumberMCFilters =     cpu_to_le16(0),
+        .bNumberPowerFilters =  0,
+};
+
+#define NCAPS   (USB_CDC_NCM_NCAP_ETH_FILTER | USB_CDC_NCM_NCAP_CRC_MODE)
+
+static struct usb_cdc_ncm_desc ncm_desc __initdata = {
+        .bLength =              sizeof ncm_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_NCM_TYPE,
+
+        .bcdNcmVersion =        cpu_to_le16(0x0100),
+        /* can process SetEthernetPacketFilter */
+        .bmNetworkCapabilities = NCAPS,
+};
+
+/* the default data interface has no endpoints ... */
+
+static struct usb_interface_descriptor ncm_data_nop_intf __initdata = {
+        .bLength =              sizeof ncm_data_nop_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bInterfaceNumber =     1,
+        .bAlternateSetting =    0,
+        .bNumEndpoints =        0,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   USB_CDC_NCM_PROTO_NTB,
+        /* .iInterface = DYNAMIC */
+};
+
+/* ... but the "real" data interface has two bulk endpoints */
+
+static struct usb_interface_descriptor ncm_data_intf __initdata = {
+        .bLength =              sizeof ncm_data_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bInterfaceNumber =     1,
+        .bAlternateSetting =    1,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   USB_CDC_NCM_PROTO_NTB,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_ncm_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
+        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
+};
+
+static struct usb_endpoint_descriptor fs_ncm_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_ncm_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *ncm_fs_function[] __initdata = {
+        (struct usb_descriptor_header *) &ncm_iad_desc,
+        /* CDC NCM control descriptors */
+        (struct usb_descriptor_header *) &ncm_control_intf,
+        (struct usb_descriptor_header *) &ncm_header_desc,
+        (struct usb_descriptor_header *) &ncm_union_desc,
+        (struct usb_descriptor_header *) &ecm_desc,
+        (struct usb_descriptor_header *) &ncm_desc,
+        (struct usb_descriptor_header *) &fs_ncm_notify_desc,
+        /* data interface, altsettings 0 and 1 */
+        (struct usb_descriptor_header *) &ncm_data_nop_intf,
+        (struct usb_descriptor_header *) &ncm_data_intf,
+        (struct usb_descriptor_header *) &fs_ncm_in_desc,
+        (struct usb_descriptor_header *) &fs_ncm_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_ncm_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(NCM_STATUS_BYTECOUNT),
+        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
+};
+static struct usb_endpoint_descriptor hs_ncm_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_ncm_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *ncm_hs_function[] __initdata = {
+        (struct usb_descriptor_header *) &ncm_iad_desc,
+        /* CDC NCM control descriptors */
+        (struct usb_descriptor_header *) &ncm_control_intf,
+        (struct usb_descriptor_header *) &ncm_header_desc,
+        (struct usb_descriptor_header *) &ncm_union_desc,
+        (struct usb_descriptor_header *) &ecm_desc,
+        (struct usb_descriptor_header *) &ncm_desc,
+        (struct usb_descriptor_header *) &hs_ncm_notify_desc,
+        /* data interface, altsettings 0 and 1 */
+        (struct usb_descriptor_header *) &ncm_data_nop_intf,
+        (struct usb_descriptor_header *) &ncm_data_intf,
+        (struct usb_descriptor_header *) &hs_ncm_in_desc,
+        (struct usb_descriptor_header *) &hs_ncm_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+#define STRING_CTRL_IDX 0
+#define STRING_MAC_IDX  1
+#define STRING_DATA_IDX 2
+#define STRING_IAD_IDX  3
+
+static struct usb_string ncm_string_defs[] = {
+        [STRING_CTRL_IDX].s = "CDC Network Control Model (NCM)",
+        [STRING_MAC_IDX].s = NULL /* DYNAMIC */,
+        [STRING_DATA_IDX].s = "CDC Network Data",
+        [STRING_IAD_IDX].s = "CDC NCM",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings ncm_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              ncm_string_defs,
+};
+
+static struct usb_gadget_strings *ncm_strings[] = {
+        &ncm_string_table,
+        NULL,
+};
+
+/*
+ * Here are options for NCM Datagram Pointer table (NDP) parser.
+ * There are 2 different formats: NDP16 and NDP32 in the spec (ch. 3),
+ * in NDP16 offsets and sizes fields are 1 16bit word wide,
+ * in NDP32 -- 2 16bit words wide. Also signatures are different.
+ * To make the parser code the same, put the differences in the structure,
+ * and switch pointers to the structures when the format is changed.
+ */
+
+struct ndp_parser_opts {
+        u32             nth_sign;
+        u32             ndp_sign;
+        unsigned        nth_size;
+        unsigned        ndp_size;
+        unsigned        ndplen_align;
+        /* sizes in u16 units */
+        unsigned        dgram_item_len; /* index or length */
+        unsigned        block_length;
+        unsigned        fp_index;
+        unsigned        reserved1;
+        unsigned        reserved2;
+        unsigned        next_fp_index;
+};
+
+#define INIT_NDP16_OPTS {                                       \
+                .nth_sign = USB_CDC_NCM_NTH16_SIGN,             \
+                .ndp_sign = USB_CDC_NCM_NDP16_NOCRC_SIGN,       \
+                .nth_size = sizeof(struct usb_cdc_ncm_nth16),   \
+                .ndp_size = sizeof(struct usb_cdc_ncm_ndp16),   \
+                .ndplen_align = 4,                              \
+                .dgram_item_len = 1,                            \
+                .block_length = 1,                              \
+                .fp_index = 1,                                  \
+                .reserved1 = 0,                                 \
+                .reserved2 = 0,                                 \
+                .next_fp_index = 1,                             \
+        }
+
+
+#define INIT_NDP32_OPTS {                                       \
+                .nth_sign = USB_CDC_NCM_NTH32_SIGN,             \
+                .ndp_sign = USB_CDC_NCM_NDP32_NOCRC_SIGN,       \
+                .nth_size = sizeof(struct usb_cdc_ncm_nth32),   \
+                .ndp_size = sizeof(struct usb_cdc_ncm_ndp32),   \
+                .ndplen_align = 8,                              \
+                .dgram_item_len = 2,                            \
+                .block_length = 2,                              \
+                .fp_index = 2,                                  \
+                .reserved1 = 1,                                 \
+                .reserved2 = 2,                                 \
+                .next_fp_index = 2,                             \
+        }
+
+static struct ndp_parser_opts ndp16_opts = INIT_NDP16_OPTS;
+static struct ndp_parser_opts ndp32_opts = INIT_NDP32_OPTS;
+
+static inline void put_ncm(__le16 **p, unsigned size, unsigned val)
+{
+        switch (size) {
+        case 1:
+                put_unaligned_le16((u16)val, *p);
+                break;
+        case 2:
+                put_unaligned_le32((u32)val, *p);
+
+                break;
+        default:
+                BUG();
+        }
+
+        *p += size;
+}
+
+static inline unsigned get_ncm(__le16 **p, unsigned size)
+{
+        unsigned tmp;
+
+        switch (size) {
+        case 1:
+                tmp = get_unaligned_le16(*p);
+                break;
+        case 2:
+                tmp = get_unaligned_le32(*p);
+                break;
+        default:
+                BUG();
+        }
+
+        *p += size;
+        return tmp;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline void ncm_reset_values(struct f_ncm *ncm)
+{
+        ncm->parser_opts = &ndp16_opts;
+        ncm->is_crc = false;
+        ncm->port.cdc_filter = DEFAULT_FILTER;
+
+        /* doesn't make sense for ncm, fixed size used */
+        ncm->port.header_len = 0;
+
+        ncm->port.fixed_out_len = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
+        ncm->port.fixed_in_len = NTB_DEFAULT_IN_SIZE;
+}
+
+/*
+ * Context: ncm->lock held
+ */
+static void ncm_do_notify(struct f_ncm *ncm)
+{
+        struct usb_request              *req = ncm->notify_req;
+        struct usb_cdc_notification     *event;
+        struct usb_composite_dev        *cdev = ncm->port.func.config->cdev;
+        __le32                          *data;
+        int                             status;
+
+        /* notification already in flight? */
+        if (!req)
+                return;
+
+        event = req->buf;
+        switch (ncm->notify_state) {
+        case NCM_NOTIFY_NONE:
+                return;
+
+        case NCM_NOTIFY_CONNECT:
+                event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
+                if (ncm->is_open)
+                        event->wValue = cpu_to_le16(1);
+                else
+                        event->wValue = cpu_to_le16(0);
+                event->wLength = 0;
+                req->length = sizeof *event;
+
+                DBG(cdev, "notify connect %s\n",
+                                ncm->is_open ? "true" : "false");
+                ncm->notify_state = NCM_NOTIFY_NONE;
+                break;
+
+        case NCM_NOTIFY_SPEED:
+                event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
+                event->wValue = cpu_to_le16(0);
+                event->wLength = cpu_to_le16(8);
+                req->length = NCM_STATUS_BYTECOUNT;
+
+                /* SPEED_CHANGE data is up/down speeds in bits/sec */
+                data = req->buf + sizeof *event;
+                data[0] = cpu_to_le32(ncm_bitrate(cdev->gadget));
+                data[1] = data[0];
+
+                DBG(cdev, "notify speed %d\n", ncm_bitrate(cdev->gadget));
+                ncm->notify_state = NCM_NOTIFY_CONNECT;
+                break;
+        }
+        event->bmRequestType = 0xA1;
+        event->wIndex = cpu_to_le16(ncm->ctrl_id);
+
+        ncm->notify_req = NULL;
+        /*
+         * In double buffering if there is a space in FIFO,
+         * completion callback can be called right after the call,
+         * so unlocking
+         */
+        spin_unlock(&ncm->lock);
+        status = usb_ep_queue(ncm->notify, req, GFP_ATOMIC);
+        spin_lock(&ncm->lock);
+        if (status < 0) {
+                ncm->notify_req = req;
+                DBG(cdev, "notify --> %d\n", status);
+        }
+}
+
+/*
+ * Context: ncm->lock held
+ */
+static void ncm_notify(struct f_ncm *ncm)
+{
+        /*
+         * NOTE on most versions of Linux, host side cdc-ethernet
+         * won't listen for notifications until its netdevice opens.
+         * The first notification then sits in the FIFO for a long
+         * time, and the second one is queued.
+         *
+         * If ncm_notify() is called before the second (CONNECT)
+         * notification is sent, then it will reset to send the SPEED
+         * notificaion again (and again, and again), but it's not a problem
+         */
+        ncm->notify_state = NCM_NOTIFY_SPEED;
+        ncm_do_notify(ncm);
+}
+
+static void ncm_notify_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_ncm                    *ncm = req->context;
+        struct usb_composite_dev        *cdev = ncm->port.func.config->cdev;
+        struct usb_cdc_notification     *event = req->buf;
+
+        spin_lock(&ncm->lock);
+        switch (req->status) {
+        case 0:
+                VDBG(cdev, "Notification %02x sent\n",
+                     event->bNotificationType);
+                break;
+        case -ECONNRESET:
+        case -ESHUTDOWN:
+                ncm->notify_state = NCM_NOTIFY_NONE;
+                break;
+        default:
+                DBG(cdev, "event %02x --> %d\n",
+                        event->bNotificationType, req->status);
+                break;
+        }
+        ncm->notify_req = req;
+        ncm_do_notify(ncm);
+        spin_unlock(&ncm->lock);
+}
+
+static void ncm_ep0out_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        /* now for SET_NTB_INPUT_SIZE only */
+        unsigned                in_size;
+        struct usb_function     *f = req->context;
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = ep->driver_data;
+
+        req->context = NULL;
+        if (req->status || req->actual != req->length) {
+                DBG(cdev, "Bad control-OUT transfer\n");
+                goto invalid;
+        }
+
+        in_size = get_unaligned_le32(req->buf);
+        if (in_size < USB_CDC_NCM_NTB_MIN_IN_SIZE ||
+            in_size > le32_to_cpu(ntb_parameters.dwNtbInMaxSize)) {
+                DBG(cdev, "Got wrong INPUT SIZE (%d) from host\n", in_size);
+                goto invalid;
+        }
+
+        ncm->port.fixed_in_len = in_size;
+        VDBG(cdev, "Set NTB INPUT SIZE %d\n", in_size);
+        return;
+
+invalid:
+        usb_ep_set_halt(ep);
+        return;
+}
+
+static int ncm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct usb_request      *req = cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        /*
+         * composite driver infrastructure handles everything except
+         * CDC class messages; interface activation uses set_alt().
+         */
+        switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_SET_ETHERNET_PACKET_FILTER:
+                /*
+                 * see 6.2.30: no data, wIndex = interface,
+                 * wValue = packet filter bitmap
+                 */
+                if (w_length != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                DBG(cdev, "packet filter %02x\n", w_value);
+                /*
+                 * REVISIT locking of cdc_filter.  This assumes the UDC
+                 * driver won't have a concurrent packet TX irq running on
+                 * another CPU; or that if it does, this write is atomic...
+                 */
+                ncm->port.cdc_filter = w_value;
+                value = 0;
+                break;
+        /*
+         * and optionally:
+         * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
+         * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
+         * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
+         * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
+         * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
+         * case USB_CDC_GET_ETHERNET_STATISTIC:
+         */
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_NTB_PARAMETERS:
+
+                if (w_length == 0 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                value = w_length > sizeof ntb_parameters ?
+                        sizeof ntb_parameters : w_length;
+                memcpy(req->buf, &ntb_parameters, value);
+                VDBG(cdev, "Host asked NTB parameters\n");
+                break;
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_NTB_INPUT_SIZE:
+
+                if (w_length < 4 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                put_unaligned_le32(ncm->port.fixed_in_len, req->buf);
+                value = 4;
+                VDBG(cdev, "Host asked INPUT SIZE, sending %d\n",
+                     ncm->port.fixed_in_len);
+                break;
+
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_SET_NTB_INPUT_SIZE:
+        {
+                if (w_length != 4 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                req->complete = ncm_ep0out_complete;
+                req->length = w_length;
+                req->context = f;
+
+                value = req->length;
+                break;
+        }
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_NTB_FORMAT:
+        {
+                uint16_t format;
+
+                if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                format = (ncm->parser_opts == &ndp16_opts) ? 0x0000 : 0x0001;
+                put_unaligned_le16(format, req->buf);
+                value = 2;
+                VDBG(cdev, "Host asked NTB FORMAT, sending %d\n", format);
+                break;
+        }
+
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_SET_NTB_FORMAT:
+        {
+                if (w_length != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                switch (w_value) {
+                case 0x0000:
+                        ncm->parser_opts = &ndp16_opts;
+                        DBG(cdev, "NCM16 selected\n");
+                        break;
+                case 0x0001:
+                        ncm->parser_opts = &ndp32_opts;
+                        DBG(cdev, "NCM32 selected\n");
+                        break;
+                default:
+                        goto invalid;
+                }
+                value = 0;
+                break;
+        }
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_GET_CRC_MODE:
+        {
+                uint16_t is_crc;
+
+                if (w_length < 2 || w_value != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                is_crc = ncm->is_crc ? 0x0001 : 0x0000;
+                put_unaligned_le16(is_crc, req->buf);
+                value = 2;
+                VDBG(cdev, "Host asked CRC MODE, sending %d\n", is_crc);
+                break;
+        }
+
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                | USB_CDC_SET_CRC_MODE:
+        {
+                int ndp_hdr_crc = 0;
+
+                if (w_length != 0 || w_index != ncm->ctrl_id)
+                        goto invalid;
+                switch (w_value) {
+                case 0x0000:
+                        ncm->is_crc = false;
+                        ndp_hdr_crc = NCM_NDP_HDR_NOCRC;
+                        DBG(cdev, "non-CRC mode selected\n");
+                        break;
+                case 0x0001:
+                        ncm->is_crc = true;
+                        ndp_hdr_crc = NCM_NDP_HDR_CRC;
+                        DBG(cdev, "CRC mode selected\n");
+                        break;
+                default:
+                        goto invalid;
+                }
+                ncm->parser_opts->ndp_sign &= ~NCM_NDP_HDR_CRC_MASK;
+                ncm->parser_opts->ndp_sign |= ndp_hdr_crc;
+                value = 0;
+                break;
+        }
+
+        /* and disabled in ncm descriptor: */
+        /* case USB_CDC_GET_NET_ADDRESS: */
+        /* case USB_CDC_SET_NET_ADDRESS: */
+        /* case USB_CDC_GET_MAX_DATAGRAM_SIZE: */
+        /* case USB_CDC_SET_MAX_DATAGRAM_SIZE: */
+
+        default:
+invalid:
+                DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+        }
+
+        /* respond with data transfer or status phase? */
+        if (value >= 0) {
+                DBG(cdev, "ncm req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+                req->zero = 0;
+                req->length = value;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0)
+                        ERROR(cdev, "ncm req %02x.%02x response err %d\n",
+                                        ctrl->bRequestType, ctrl->bRequest,
+                                        value);
+        }
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+
+static int ncm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* Control interface has only altsetting 0 */
+        if (intf == ncm->ctrl_id) {
+                if (alt != 0)
+                        goto fail;
+
+                if (ncm->notify->driver_data) {
+                        DBG(cdev, "reset ncm control %d\n", intf);
+                        usb_ep_disable(ncm->notify);
+                } else {
+                        DBG(cdev, "init ncm ctrl %d\n", intf);
+                        ncm->notify_desc = ep_choose(cdev->gadget,
+                                        ncm->hs.notify,
+                                        ncm->fs.notify);
+                }
+                usb_ep_enable(ncm->notify, ncm->notify_desc);
+                ncm->notify->driver_data = ncm;
+
+        /* Data interface has two altsettings, 0 and 1 */
+        } else if (intf == ncm->data_id) {
+                if (alt > 1)
+                        goto fail;
+
+                if (ncm->port.in_ep->driver_data) {
+                        DBG(cdev, "reset ncm\n");
+                        gether_disconnect(&ncm->port);
+                        ncm_reset_values(ncm);
+                }
+
+                /*
+                 * CDC Network only sends data in non-default altsettings.
+                 * Changing altsettings resets filters, statistics, etc.
+                 */
+                if (alt == 1) {
+                        struct net_device       *net;
+
+                        if (!ncm->port.in) {
+                                DBG(cdev, "init ncm\n");
+                                ncm->port.in = ep_choose(cdev->gadget,
+                                                         ncm->hs.in,
+                                                         ncm->fs.in);
+                                ncm->port.out = ep_choose(cdev->gadget,
+                                                          ncm->hs.out,
+                                                          ncm->fs.out);
+                        }
+
+                        /* TODO */
+                        /* Enable zlps by default for NCM conformance;
+                         * override for musb_hdrc (avoids txdma ovhead)
+                         */
+                        ncm->port.is_zlp_ok = !(
+                                gadget_is_musbhdrc(cdev->gadget)
+                                );
+                        ncm->port.cdc_filter = DEFAULT_FILTER;
+                        DBG(cdev, "activate ncm\n");
+                        net = gether_connect(&ncm->port);
+                        if (IS_ERR(net))
+                                return PTR_ERR(net);
+                }
+
+                spin_lock(&ncm->lock);
+                ncm_notify(ncm);
+                spin_unlock(&ncm->lock);
+        } else
+                goto fail;
+
+        return 0;
+fail:
+        return -EINVAL;
+}
+
+/*
+ * Because the data interface supports multiple altsettings,
+ * this NCM function *MUST* implement a get_alt() method.
+ */
+static int ncm_get_alt(struct usb_function *f, unsigned intf)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+
+        if (intf == ncm->ctrl_id)
+                return 0;
+        return ncm->port.in_ep->driver_data ? 1 : 0;
+}
+
+static struct sk_buff *ncm_wrap_ntb(struct gether *port,
+                                    struct sk_buff *skb)
+{
+        struct f_ncm    *ncm = func_to_ncm(&port->func);
+        struct sk_buff  *skb2;
+        int             ncb_len = 0;
+        __le16          *tmp;
+        int             div = ntb_parameters.wNdpInDivisor;
+        int             rem = ntb_parameters.wNdpInPayloadRemainder;
+        int             pad;
+        int             ndp_align = ntb_parameters.wNdpInAlignment;
+        int             ndp_pad;
+        unsigned        max_size = ncm->port.fixed_in_len;
+        struct ndp_parser_opts *opts = ncm->parser_opts;
+        unsigned        crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
+
+        ncb_len += opts->nth_size;
+        ndp_pad = ALIGN(ncb_len, ndp_align) - ncb_len;
+        ncb_len += ndp_pad;
+        ncb_len += opts->ndp_size;
+        ncb_len += 2 * 2 * opts->dgram_item_len; /* Datagram entry */
+        ncb_len += 2 * 2 * opts->dgram_item_len; /* Zero datagram entry */
+        pad = ALIGN(ncb_len, div) + rem - ncb_len;
+        ncb_len += pad;
+
+        if (ncb_len + skb->len + crc_len > max_size) {
+                dev_kfree_skb_any(skb);
+                return NULL;
+        }
+
+        skb2 = skb_copy_expand(skb, ncb_len,
+                               max_size - skb->len - ncb_len - crc_len,
+                               GFP_ATOMIC);
+        dev_kfree_skb_any(skb);
+        if (!skb2)
+                return NULL;
+
+        skb = skb2;
+
+        tmp = (void *) skb_push(skb, ncb_len);
+        memset(tmp, 0, ncb_len);
+
+        put_unaligned_le32(opts->nth_sign, tmp); /* dwSignature */
+        tmp += 2;
+        /* wHeaderLength */
+        put_unaligned_le16(opts->nth_size, tmp++);
+        tmp++; /* skip wSequence */
+        put_ncm(&tmp, opts->block_length, skb->len); /* (d)wBlockLength */
+        /* (d)wFpIndex */
+        /* the first pointer is right after the NTH + align */
+        put_ncm(&tmp, opts->fp_index, opts->nth_size + ndp_pad);
+
+        tmp = (void *)tmp + ndp_pad;
+
+        /* NDP */
+        put_unaligned_le32(opts->ndp_sign, tmp); /* dwSignature */
+        tmp += 2;
+        /* wLength */
+        put_unaligned_le16(ncb_len - opts->nth_size - pad, tmp++);
+
+        tmp += opts->reserved1;
+        tmp += opts->next_fp_index; /* skip reserved (d)wNextFpIndex */
+        tmp += opts->reserved2;
+
+        if (ncm->is_crc) {
+                uint32_t crc;
+
+                crc = ~crc32_le(~0,
+                                skb->data + ncb_len,
+                                skb->len - ncb_len);
+                put_unaligned_le32(crc, skb->data + skb->len);
+                skb_put(skb, crc_len);
+        }
+
+        /* (d)wDatagramIndex[0] */
+        put_ncm(&tmp, opts->dgram_item_len, ncb_len);
+        /* (d)wDatagramLength[0] */
+        put_ncm(&tmp, opts->dgram_item_len, skb->len - ncb_len);
+        /* (d)wDatagramIndex[1] and  (d)wDatagramLength[1] already zeroed */
+
+        if (skb->len > MAX_TX_NONFIXED)
+                memset(skb_put(skb, max_size - skb->len),
+                       0, max_size - skb->len);
+
+        return skb;
+}
+
+static int ncm_unwrap_ntb(struct gether *port,
+                          struct sk_buff *skb,
+                          struct sk_buff_head *list)
+{
+        struct f_ncm    *ncm = func_to_ncm(&port->func);
+        __le16          *tmp = (void *) skb->data;
+        unsigned        index, index2;
+        unsigned        dg_len, dg_len2;
+        unsigned        ndp_len;
+        struct sk_buff  *skb2;
+        int             ret = -EINVAL;
+        unsigned        max_size = le32_to_cpu(ntb_parameters.dwNtbOutMaxSize);
+        struct ndp_parser_opts *opts = ncm->parser_opts;
+        unsigned        crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
+        int             dgram_counter;
+
+        /* dwSignature */
+        if (get_unaligned_le32(tmp) != opts->nth_sign) {
+                INFO(port->func.config->cdev, "Wrong NTH SIGN, skblen %d\n",
+                        skb->len);
+                print_hex_dump(KERN_INFO, "HEAD:", DUMP_PREFIX_ADDRESS, 32, 1,
+                               skb->data, 32, false);
+
+                goto err;
+        }
+        tmp += 2;
+        /* wHeaderLength */
+        if (get_unaligned_le16(tmp++) != opts->nth_size) {
+                INFO(port->func.config->cdev, "Wrong NTB headersize\n");
+                goto err;
+        }
+        tmp++; /* skip wSequence */
+
+        /* (d)wBlockLength */
+        if (get_ncm(&tmp, opts->block_length) > max_size) {
+                INFO(port->func.config->cdev, "OUT size exceeded\n");
+                goto err;
+        }
+
+        index = get_ncm(&tmp, opts->fp_index);
+        /* NCM 3.2 */
+        if (((index % 4) != 0) && (index < opts->nth_size)) {
+                INFO(port->func.config->cdev, "Bad index: %x\n",
+                        index);
+                goto err;
+        }
+
+        /* walk through NDP */
+        tmp = ((void *)skb->data) + index;
+        if (get_unaligned_le32(tmp) != opts->ndp_sign) {
+                INFO(port->func.config->cdev, "Wrong NDP SIGN\n");
+                goto err;
+        }
+        tmp += 2;
+
+        ndp_len = get_unaligned_le16(tmp++);
+        /*
+         * NCM 3.3.1
+         * entry is 2 items
+         * item size is 16/32 bits, opts->dgram_item_len * 2 bytes
+         * minimal: struct usb_cdc_ncm_ndpX + normal entry + zero entry
+         */
+        if ((ndp_len < opts->ndp_size + 2 * 2 * (opts->dgram_item_len * 2))
+            || (ndp_len % opts->ndplen_align != 0)) {
+                INFO(port->func.config->cdev, "Bad NDP length: %x\n", ndp_len);
+                goto err;
+        }
+        tmp += opts->reserved1;
+        tmp += opts->next_fp_index; /* skip reserved (d)wNextFpIndex */
+        tmp += opts->reserved2;
+
+        ndp_len -= opts->ndp_size;
+        index2 = get_ncm(&tmp, opts->dgram_item_len);
+        dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
+        dgram_counter = 0;
+
+        do {
+                index = index2;
+                dg_len = dg_len2;
+                if (dg_len < 14 + crc_len) { /* ethernet header + crc */
+                        INFO(port->func.config->cdev, "Bad dgram length: %x\n",
+                             dg_len);
+                        goto err;
+                }
+                if (ncm->is_crc) {
+                        uint32_t crc, crc2;
+
+                        crc = get_unaligned_le32(skb->data +
+                                                 index + dg_len - crc_len);
+                        crc2 = ~crc32_le(~0,
+                                         skb->data + index,
+                                         dg_len - crc_len);
+                        if (crc != crc2) {
+                                INFO(port->func.config->cdev, "Bad CRC\n");
+                                goto err;
+                        }
+                }
+
+                index2 = get_ncm(&tmp, opts->dgram_item_len);
+                dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
+
+                if (index2 == 0 || dg_len2 == 0) {
+                        skb2 = skb;
+                } else {
+                        skb2 = skb_clone(skb, GFP_ATOMIC);
+                        if (skb2 == NULL)
+                                goto err;
+                }
+
+                if (!skb_pull(skb2, index)) {
+                        ret = -EOVERFLOW;
+                        goto err;
+                }
+
+                skb_trim(skb2, dg_len - crc_len);
+                skb_queue_tail(list, skb2);
+
+                ndp_len -= 2 * (opts->dgram_item_len * 2);
+
+                dgram_counter++;
+
+                if (index2 == 0 || dg_len2 == 0)
+                        break;
+        } while (ndp_len > 2 * (opts->dgram_item_len * 2)); /* zero entry */
+
+        VDBG(port->func.config->cdev,
+             "Parsed NTB with %d frames\n", dgram_counter);
+        return 0;
+err:
+        skb_queue_purge(list);
+        dev_kfree_skb_any(skb);
+        return ret;
+}
+
+static void ncm_disable(struct usb_function *f)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "ncm deactivated\n");
+
+        if (ncm->port.in_ep->driver_data)
+                gether_disconnect(&ncm->port);
+
+        if (ncm->notify->driver_data) {
+                usb_ep_disable(ncm->notify);
+                ncm->notify->driver_data = NULL;
+                ncm->notify_desc = NULL;
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Callbacks let us notify the host about connect/disconnect when the
+ * net device is opened or closed.
+ *
+ * For testing, note that link states on this side include both opened
+ * and closed variants of:
+ *
+ *   - disconnected/unconfigured
+ *   - configured but inactive (data alt 0)
+ *   - configured and active (data alt 1)
+ *
+ * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
+ * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
+ * imply the host is actually polling the notification endpoint, and
+ * likewise that "active" doesn't imply it's actually using the data
+ * endpoints for traffic.
+ */
+
+static void ncm_open(struct gether *geth)
+{
+        struct f_ncm            *ncm = func_to_ncm(&geth->func);
+
+        DBG(ncm->port.func.config->cdev, "%s\n", __func__);
+
+        spin_lock(&ncm->lock);
+        ncm->is_open = true;
+        ncm_notify(ncm);
+        spin_unlock(&ncm->lock);
+}
+
+static void ncm_close(struct gether *geth)
+{
+        struct f_ncm            *ncm = func_to_ncm(&geth->func);
+
+        DBG(ncm->port.func.config->cdev, "%s\n", __func__);
+
+        spin_lock(&ncm->lock);
+        ncm->is_open = false;
+        ncm_notify(ncm);
+        spin_unlock(&ncm->lock);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* ethernet function driver setup/binding */
+
+static int __init
+ncm_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_ncm            *ncm = func_to_ncm(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        ncm->ctrl_id = status;
+        ncm_iad_desc.bFirstInterface = status;
+
+        ncm_control_intf.bInterfaceNumber = status;
+        ncm_union_desc.bMasterInterface0 = status;
+
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        ncm->data_id = status;
+
+        ncm_data_nop_intf.bInterfaceNumber = status;
+        ncm_data_intf.bInterfaceNumber = status;
+        ncm_union_desc.bSlaveInterface0 = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_in_desc);
+        if (!ep)
+                goto fail;
+        ncm->port.in_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_out_desc);
+        if (!ep)
+                goto fail;
+        ncm->port.out_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_ncm_notify_desc);
+        if (!ep)
+                goto fail;
+        ncm->notify = ep;
+        ep->driver_data = cdev; /* claim */
+
+        status = -ENOMEM;
+
+        /* allocate notification request and buffer */
+        ncm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
+        if (!ncm->notify_req)
+                goto fail;
+        ncm->notify_req->buf = kmalloc(NCM_STATUS_BYTECOUNT, GFP_KERNEL);
+        if (!ncm->notify_req->buf)
+                goto fail;
+        ncm->notify_req->context = ncm;
+        ncm->notify_req->complete = ncm_notify_complete;
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(ncm_fs_function);
+        if (!f->descriptors)
+                goto fail;
+
+        ncm->fs.in = usb_find_endpoint(ncm_fs_function,
+                        f->descriptors, &fs_ncm_in_desc);
+        ncm->fs.out = usb_find_endpoint(ncm_fs_function,
+                        f->descriptors, &fs_ncm_out_desc);
+        ncm->fs.notify = usb_find_endpoint(ncm_fs_function,
+                        f->descriptors, &fs_ncm_notify_desc);
+
+        /*
+         * support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_ncm_in_desc.bEndpointAddress =
+                                fs_ncm_in_desc.bEndpointAddress;
+                hs_ncm_out_desc.bEndpointAddress =
+                                fs_ncm_out_desc.bEndpointAddress;
+                hs_ncm_notify_desc.bEndpointAddress =
+                                fs_ncm_notify_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(ncm_hs_function);
+                if (!f->hs_descriptors)
+                        goto fail;
+
+                ncm->hs.in = usb_find_endpoint(ncm_hs_function,
+                                f->hs_descriptors, &hs_ncm_in_desc);
+                ncm->hs.out = usb_find_endpoint(ncm_hs_function,
+                                f->hs_descriptors, &hs_ncm_out_desc);
+                ncm->hs.notify = usb_find_endpoint(ncm_hs_function,
+                                f->hs_descriptors, &hs_ncm_notify_desc);
+        }
+
+        /*
+         * NOTE:  all that is done without knowing or caring about
+         * the network link ... which is unavailable to this code
+         * until we're activated via set_alt().
+         */
+
+        ncm->port.open = ncm_open;
+        ncm->port.close = ncm_close;
+
+        DBG(cdev, "CDC Network: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        ncm->port.in_ep->name, ncm->port.out_ep->name,
+                        ncm->notify->name);
+        return 0;
+
+fail:
+        if (f->descriptors)
+                usb_free_descriptors(f->descriptors);
+
+        if (ncm->notify_req) {
+                kfree(ncm->notify_req->buf);
+                usb_ep_free_request(ncm->notify, ncm->notify_req);
+        }
+
+        /* we might as well release our claims on endpoints */
+        if (ncm->notify)
+                ncm->notify->driver_data = NULL;
+        if (ncm->port.out)
+                ncm->port.out_ep->driver_data = NULL;
+        if (ncm->port.in)
+                ncm->port.in_ep->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+ncm_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct f_ncm            *ncm = func_to_ncm(f);
+
+        DBG(c->cdev, "ncm unbind\n");
+
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+
+        kfree(ncm->notify_req->buf);
+        usb_ep_free_request(ncm->notify, ncm->notify_req);
+
+        ncm_string_defs[1].s = NULL;
+        kfree(ncm);
+}
+
+/**
+ * ncm_bind_config - add CDC Network link to a configuration
+ * @c: the configuration to support the network link
+ * @ethaddr: a buffer in which the ethernet address of the host side
+ *      side of the link was recorded
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gether_setup().  Caller is also responsible
+ * for calling @gether_cleanup() before module unload.
+ */
+int __init ncm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+{
+        struct f_ncm    *ncm;
+        int             status;
+
+        if (!can_support_ecm(c->cdev->gadget) || !ethaddr)
+                return -EINVAL;
+
+        /* maybe allocate device-global string IDs */
+        if (ncm_string_defs[0].id == 0) {
+
+                /* control interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_CTRL_IDX].id = status;
+                ncm_control_intf.iInterface = status;
+
+                /* data interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_DATA_IDX].id = status;
+                ncm_data_nop_intf.iInterface = status;
+                ncm_data_intf.iInterface = status;
+
+                /* MAC address */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_MAC_IDX].id = status;
+                ecm_desc.iMACAddress = status;
+
+                /* IAD */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ncm_string_defs[STRING_IAD_IDX].id = status;
+                ncm_iad_desc.iFunction = status;
+        }
+
+        /* allocate and initialize one new instance */
+        ncm = kzalloc(sizeof *ncm, GFP_KERNEL);
+        if (!ncm)
+                return -ENOMEM;
+
+        /* export host's Ethernet address in CDC format */
+        snprintf(ncm->ethaddr, sizeof ncm->ethaddr,
+                "%02X%02X%02X%02X%02X%02X",
+                ethaddr[0], ethaddr[1], ethaddr[2],
+                ethaddr[3], ethaddr[4], ethaddr[5]);
+        ncm_string_defs[1].s = ncm->ethaddr;
+
+        spin_lock_init(&ncm->lock);
+        ncm_reset_values(ncm);
+        ncm->port.is_fixed = true;
+
+        ncm->port.func.name = "cdc_network";
+        ncm->port.func.strings = ncm_strings;
+        /* descriptors are per-instance copies */
+        ncm->port.func.bind = ncm_bind;
+        ncm->port.func.unbind = ncm_unbind;
+        ncm->port.func.set_alt = ncm_set_alt;
+        ncm->port.func.get_alt = ncm_get_alt;
+        ncm->port.func.setup = ncm_setup;
+        ncm->port.func.disable = ncm_disable;
+
+        ncm->port.wrap = ncm_wrap_ntb;
+        ncm->port.unwrap = ncm_unwrap_ntb;
+
+        status = usb_add_function(c, &ncm->port.func);
+        if (status) {
+                ncm_string_defs[1].s = NULL;
+                kfree(ncm);
+        }
+        return status;
+}
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index d4fdf65fb925..a6eacb59571b 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -3392,25 +3392,28 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                 dev_set_name(&curlun->dev,"%s-lun%d",
                              dev_name(&gadget->dev), i);
 
-                if ((rc = device_register(&curlun->dev)) != 0) {
+                kref_get(&fsg->ref);
+                rc = device_register(&curlun->dev);
+                if (rc) {
                         INFO(fsg, "failed to register LUN%d: %d\n", i, rc);
-                        goto out;
-                }
-                if ((rc = device_create_file(&curlun->dev,
-                                        &dev_attr_ro)) != 0 ||
-                                (rc = device_create_file(&curlun->dev,
-                                        &dev_attr_nofua)) != 0 ||
-                                (rc = device_create_file(&curlun->dev,
-                                        &dev_attr_file)) != 0) {
-                        device_unregister(&curlun->dev);
+                        put_device(&curlun->dev);
                         goto out;
                 }
                 curlun->registered = 1;
-                kref_get(&fsg->ref);
+
+                rc = device_create_file(&curlun->dev, &dev_attr_ro);
+                if (rc)
+                        goto out;
+                rc = device_create_file(&curlun->dev, &dev_attr_nofua);
+                if (rc)
+                        goto out;
+                rc = device_create_file(&curlun->dev, &dev_attr_file);
+                if (rc)
+                        goto out;
 
                 if (mod_data.file[i] && *mod_data.file[i]) {
-                        if ((rc = fsg_lun_open(curlun,
-                                        mod_data.file[i])) != 0)
+                        rc = fsg_lun_open(curlun, mod_data.file[i]);
+                        if (rc)
                                 goto out;
                 } else if (!mod_data.removable) {
                         ERROR(fsg, "no file given for LUN%d\n", i);
diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c
index af75e3620849..ebf6970a10bf 100644
--- a/drivers/usb/gadget/g_ffs.c
+++ b/drivers/usb/gadget/g_ffs.c
@@ -1,7 +1,29 @@
+/*
+ * g_ffs.c -- user mode file system API for USB composite function controllers
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) "g_ffs: " fmt
+
 #include <linux/module.h>
 #include <linux/utsname.h>
 
-
 /*
  * kbuild is not very cooperative with respect to linking separately
  * compiled library objects into one module.  So for now we won't use
@@ -43,7 +65,6 @@ static int eth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 
 #include "f_fs.c"
 
-
 #define DRIVER_NAME     "g_ffs"
 #define DRIVER_DESC     "USB Function Filesystem"
 #define DRIVER_VERSION  "24 Aug 2004"
@@ -73,8 +94,6 @@ MODULE_PARM_DESC(bDeviceSubClass, "USB Device subclass");
 module_param_named(bDeviceProtocol, gfs_dev_desc.bDeviceProtocol, byte,   0644);
 MODULE_PARM_DESC(bDeviceProtocol, "USB Device protocol");
 
-
-
 static const struct usb_descriptor_header *gfs_otg_desc[] = {
         (const struct usb_descriptor_header *)
         &(const struct usb_otg_descriptor) {
@@ -91,8 +110,7 @@ static const struct usb_descriptor_header *gfs_otg_desc[] = {
         NULL
 };
 
-/* string IDs are assigned dynamically */
-
+/* String IDs are assigned dynamically */
 static struct usb_string gfs_strings[] = {
 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
         { .s = "FunctionFS + RNDIS" },
@@ -114,8 +132,6 @@ static struct usb_gadget_strings *gfs_dev_strings[] = {
         NULL,
 };
 
-
-
 struct gfs_configuration {
         struct usb_configuration c;
         int (*eth)(struct usb_configuration *c, u8 *ethaddr);
@@ -138,7 +154,6 @@ struct gfs_configuration {
 #endif
 };
 
-
 static int gfs_bind(struct usb_composite_dev *cdev);
 static int gfs_unbind(struct usb_composite_dev *cdev);
 static int gfs_do_config(struct usb_configuration *c);
@@ -151,11 +166,9 @@ static struct usb_composite_driver gfs_driver = {
         .iProduct       = DRIVER_DESC,
 };
 
-
 static struct ffs_data *gfs_ffs_data;
 static unsigned long gfs_registered;
 
-
 static int  gfs_init(void)
 {
         ENTER();
@@ -175,7 +188,6 @@ static void  gfs_exit(void)
 }
 module_exit(gfs_exit);
 
-
 static int functionfs_ready_callback(struct ffs_data *ffs)
 {
         int ret;
@@ -200,14 +212,11 @@ static void functionfs_closed_callback(struct ffs_data *ffs)
                 usb_composite_unregister(&gfs_driver);
 }
 
-
 static int functionfs_check_dev_callback(const char *dev_name)
 {
         return 0;
 }
 
-
-
 static int gfs_bind(struct usb_composite_dev *cdev)
 {
         int ret, i;
@@ -274,7 +283,6 @@ static int gfs_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-
 static int gfs_do_config(struct usb_configuration *c)
 {
         struct gfs_configuration *gc =
@@ -315,7 +323,6 @@ static int gfs_do_config(struct usb_configuration *c)
         return 0;
 }
 
-
 #ifdef CONFIG_USB_FUNCTIONFS_ETH
 
 static int eth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index e511fec9f26d..5c2720d64ffa 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -96,7 +96,7 @@
 
 /* Mentor high speed "dual role" controller, in peripheral role */
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
-#define gadget_is_musbhdrc(g)   !strcmp("musb_hdrc", (g)->name)
+#define gadget_is_musbhdrc(g)   !strcmp("musb-hdrc", (g)->name)
 #else
 #define gadget_is_musbhdrc(g)   0
 #endif
@@ -120,10 +120,10 @@
 #define gadget_is_fsl_qe(g)     0
 #endif
 
-#ifdef CONFIG_USB_GADGET_CI13XXX
-#define gadget_is_ci13xxx(g)    (!strcmp("ci13xxx_udc", (g)->name))
+#ifdef CONFIG_USB_GADGET_CI13XXX_PCI
+#define gadget_is_ci13xxx_pci(g)        (!strcmp("ci13xxx_pci", (g)->name))
 #else
-#define gadget_is_ci13xxx(g)    0
+#define gadget_is_ci13xxx_pci(g)        0
 #endif
 
 // CONFIG_USB_GADGET_SX2
@@ -142,6 +142,17 @@
 #define gadget_is_s3c_hsotg(g)    0
 #endif
 
+#ifdef CONFIG_USB_GADGET_EG20T
+#define gadget_is_pch(g)        (!strcmp("pch_udc", (g)->name))
+#else
+#define gadget_is_pch(g)        0
+#endif
+
+#ifdef CONFIG_USB_GADGET_CI13XXX_MSM
+#define gadget_is_ci13xxx_msm(g)        (!strcmp("ci13xxx_msm", (g)->name))
+#else
+#define gadget_is_ci13xxx_msm(g)        0
+#endif
 
 /**
  * usb_gadget_controller_number - support bcdDevice id convention
@@ -192,7 +203,7 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x21;
         else if (gadget_is_fsl_qe(gadget))
                 return 0x22;
-        else if (gadget_is_ci13xxx(gadget))
+        else if (gadget_is_ci13xxx_pci(gadget))
                 return 0x23;
         else if (gadget_is_langwell(gadget))
                 return 0x24;
@@ -200,6 +211,10 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x25;
         else if (gadget_is_s3c_hsotg(gadget))
                 return 0x26;
+        else if (gadget_is_pch(gadget))
+                return 0x27;
+        else if (gadget_is_ci13xxx_msm(gadget))
+                return 0x28;
         return -ENOENT;
 }
 
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
index ed0266462c57..1210534822d6 100644
--- a/drivers/usb/gadget/imx_udc.c
+++ b/drivers/usb/gadget/imx_udc.c
@@ -1191,13 +1191,17 @@ static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
         return IRQ_HANDLED;
 }
 
+#ifndef MX1_INT_USBD0
+#define MX1_INT_USBD0 MX1_USBD_INT0
+#endif
+
 static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
 {
         struct imx_udc_struct *imx_usb = dev;
-        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - MX1_INT_USBD0];
         int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
 
-        dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
+        dump_ep_intr(__func__, irq - MX1_INT_USBD0, intr, imx_usb->dev);
 
         if (!imx_usb->driver) {
                 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
diff --git a/drivers/usb/gadget/imx_udc.h b/drivers/usb/gadget/imx_udc.h
index b48ad59603d1..7136c242b4ec 100644
--- a/drivers/usb/gadget/imx_udc.h
+++ b/drivers/usb/gadget/imx_udc.h
@@ -23,9 +23,6 @@
 /* Helper macros */
 #define EP_NO(ep)       ((ep->bEndpointAddress) & ~USB_DIR_IN) /* IN:1, OUT:0 */
 #define EP_DIR(ep)      ((ep->bEndpointAddress) & USB_DIR_IN ? 1 : 0)
-#define irq_to_ep(irq)  (((irq) >= USBD_INT0) || ((irq) <= USBD_INT6) \
-                ? ((irq) - USBD_INT0) : (USBD_INT6)) /*should not happen*/
-#define ep_to_irq(ep)   (EP_NO((ep)) + USBD_INT0)
 #define IMX_USB_NB_EP   6
 
 /* Driver structures */
diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c
index b8ec954c0692..777972454e3e 100644
--- a/drivers/usb/gadget/langwell_udc.c
+++ b/drivers/usb/gadget/langwell_udc.c
@@ -2225,6 +2225,7 @@ static void handle_setup_packet(struct langwell_udc *dev,
         u16     wValue = le16_to_cpu(setup->wValue);
         u16     wIndex = le16_to_cpu(setup->wIndex);
         u16     wLength = le16_to_cpu(setup->wLength);
+        u32     portsc1;
 
         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
@@ -2313,6 +2314,28 @@ static void handle_setup_packet(struct langwell_udc *dev,
                                         dev->dev_status &= ~(1 << wValue);
                                 }
                                 break;
+                        case USB_DEVICE_TEST_MODE:
+                                dev_dbg(&dev->pdev->dev, "SETUP: TEST MODE\n");
+                                if ((wIndex & 0xff) ||
+                                        (dev->gadget.speed != USB_SPEED_HIGH))
+                                        ep0_stall(dev);
+
+                                switch (wIndex >> 8) {
+                                case TEST_J:
+                                case TEST_K:
+                                case TEST_SE0_NAK:
+                                case TEST_PACKET:
+                                case TEST_FORCE_EN:
+                                        if (prime_status_phase(dev, EP_DIR_IN))
+                                                ep0_stall(dev);
+                                        portsc1 = readl(&dev->op_regs->portsc1);
+                                        portsc1 |= (wIndex & 0xf00) << 8;
+                                        writel(portsc1, &dev->op_regs->portsc1);
+                                        goto end;
+                                default:
+                                        rc = -EOPNOTSUPP;
+                                }
+                                break;
                         default:
                                 rc = -EOPNOTSUPP;
                                 break;
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
index 0769179dbdb0..01822422c3e8 100644
--- a/drivers/usb/gadget/mass_storage.c
+++ b/drivers/usb/gadget/mass_storage.c
@@ -102,7 +102,7 @@ static struct fsg_module_parameters mod_data = {
 };
 FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
 
-static unsigned long msg_registered = 0;
+static unsigned long msg_registered;
 static void msg_cleanup(void);
 
 static int msg_thread_exits(struct fsg_common *common)
diff --git a/drivers/usb/gadget/mv_udc.h b/drivers/usb/gadget/mv_udc.h
new file mode 100644
index 000000000000..65f1f7c3bd4e
--- /dev/null
+++ b/drivers/usb/gadget/mv_udc.h
@@ -0,0 +1,294 @@
+
+#ifndef __MV_UDC_H
+#define __MV_UDC_H
+
+#define VUSBHS_MAX_PORTS        8
+
+#define DQH_ALIGNMENT           2048
+#define DTD_ALIGNMENT           64
+#define DMA_BOUNDARY            4096
+
+#define EP_DIR_IN       1
+#define EP_DIR_OUT      0
+
+#define DMA_ADDR_INVALID        (~(dma_addr_t)0)
+
+#define EP0_MAX_PKT_SIZE        64
+/* ep0 transfer state */
+#define WAIT_FOR_SETUP          0
+#define DATA_STATE_XMIT         1
+#define DATA_STATE_NEED_ZLP     2
+#define WAIT_FOR_OUT_STATUS     3
+#define DATA_STATE_RECV         4
+
+#define CAPLENGTH_MASK          (0xff)
+#define DCCPARAMS_DEN_MASK      (0x1f)
+
+#define HCSPARAMS_PPC           (0x10)
+
+/* Frame Index Register Bit Masks */
+#define USB_FRINDEX_MASKS       0x3fff
+
+/* Command Register Bit Masks */
+#define USBCMD_RUN_STOP                         (0x00000001)
+#define USBCMD_CTRL_RESET                       (0x00000002)
+#define USBCMD_SETUP_TRIPWIRE_SET               (0x00002000)
+#define USBCMD_SETUP_TRIPWIRE_CLEAR             (~USBCMD_SETUP_TRIPWIRE_SET)
+
+#define USBCMD_ATDTW_TRIPWIRE_SET               (0x00004000)
+#define USBCMD_ATDTW_TRIPWIRE_CLEAR             (~USBCMD_ATDTW_TRIPWIRE_SET)
+
+/* bit 15,3,2 are for frame list size */
+#define USBCMD_FRAME_SIZE_1024                  (0x00000000) /* 000 */
+#define USBCMD_FRAME_SIZE_512                   (0x00000004) /* 001 */
+#define USBCMD_FRAME_SIZE_256                   (0x00000008) /* 010 */
+#define USBCMD_FRAME_SIZE_128                   (0x0000000C) /* 011 */
+#define USBCMD_FRAME_SIZE_64                    (0x00008000) /* 100 */
+#define USBCMD_FRAME_SIZE_32                    (0x00008004) /* 101 */
+#define USBCMD_FRAME_SIZE_16                    (0x00008008) /* 110 */
+#define USBCMD_FRAME_SIZE_8                     (0x0000800C) /* 111 */
+
+#define EPCTRL_TX_ALL_MASK                      (0xFFFF0000)
+#define EPCTRL_RX_ALL_MASK                      (0x0000FFFF)
+
+#define EPCTRL_TX_DATA_TOGGLE_RST               (0x00400000)
+#define EPCTRL_TX_EP_STALL                      (0x00010000)
+#define EPCTRL_RX_EP_STALL                      (0x00000001)
+#define EPCTRL_RX_DATA_TOGGLE_RST               (0x00000040)
+#define EPCTRL_RX_ENABLE                        (0x00000080)
+#define EPCTRL_TX_ENABLE                        (0x00800000)
+#define EPCTRL_CONTROL                          (0x00000000)
+#define EPCTRL_ISOCHRONOUS                      (0x00040000)
+#define EPCTRL_BULK                             (0x00080000)
+#define EPCTRL_INT                              (0x000C0000)
+#define EPCTRL_TX_TYPE                          (0x000C0000)
+#define EPCTRL_RX_TYPE                          (0x0000000C)
+#define EPCTRL_DATA_TOGGLE_INHIBIT              (0x00000020)
+#define EPCTRL_TX_EP_TYPE_SHIFT                 (18)
+#define EPCTRL_RX_EP_TYPE_SHIFT                 (2)
+
+#define EPCOMPLETE_MAX_ENDPOINTS                (16)
+
+/* endpoint list address bit masks */
+#define USB_EP_LIST_ADDRESS_MASK              0xfffff800
+
+#define PORTSCX_W1C_BITS                        0x2a
+#define PORTSCX_PORT_RESET                      0x00000100
+#define PORTSCX_PORT_POWER                      0x00001000
+#define PORTSCX_FORCE_FULL_SPEED_CONNECT        0x01000000
+#define PORTSCX_PAR_XCVR_SELECT                 0xC0000000
+#define PORTSCX_PORT_FORCE_RESUME               0x00000040
+#define PORTSCX_PORT_SUSPEND                    0x00000080
+#define PORTSCX_PORT_SPEED_FULL                 0x00000000
+#define PORTSCX_PORT_SPEED_LOW                  0x04000000
+#define PORTSCX_PORT_SPEED_HIGH                 0x08000000
+#define PORTSCX_PORT_SPEED_MASK                 0x0C000000
+
+/* USB MODE Register Bit Masks */
+#define USBMODE_CTRL_MODE_IDLE                  0x00000000
+#define USBMODE_CTRL_MODE_DEVICE                0x00000002
+#define USBMODE_CTRL_MODE_HOST                  0x00000003
+#define USBMODE_CTRL_MODE_RSV                   0x00000001
+#define USBMODE_SETUP_LOCK_OFF                  0x00000008
+#define USBMODE_STREAM_DISABLE                  0x00000010
+
+/* USB STS Register Bit Masks */
+#define USBSTS_INT                      0x00000001
+#define USBSTS_ERR                      0x00000002
+#define USBSTS_PORT_CHANGE              0x00000004
+#define USBSTS_FRM_LST_ROLL             0x00000008
+#define USBSTS_SYS_ERR                  0x00000010
+#define USBSTS_IAA                      0x00000020
+#define USBSTS_RESET                    0x00000040
+#define USBSTS_SOF                      0x00000080
+#define USBSTS_SUSPEND                  0x00000100
+#define USBSTS_HC_HALTED                0x00001000
+#define USBSTS_RCL                      0x00002000
+#define USBSTS_PERIODIC_SCHEDULE        0x00004000
+#define USBSTS_ASYNC_SCHEDULE           0x00008000
+
+
+/* Interrupt Enable Register Bit Masks */
+#define USBINTR_INT_EN                          (0x00000001)
+#define USBINTR_ERR_INT_EN                      (0x00000002)
+#define USBINTR_PORT_CHANGE_DETECT_EN           (0x00000004)
+
+#define USBINTR_ASYNC_ADV_AAE                   (0x00000020)
+#define USBINTR_ASYNC_ADV_AAE_ENABLE            (0x00000020)
+#define USBINTR_ASYNC_ADV_AAE_DISABLE           (0xFFFFFFDF)
+
+#define USBINTR_RESET_EN                        (0x00000040)
+#define USBINTR_SOF_UFRAME_EN                   (0x00000080)
+#define USBINTR_DEVICE_SUSPEND                  (0x00000100)
+
+#define USB_DEVICE_ADDRESS_MASK                 (0xfe000000)
+#define USB_DEVICE_ADDRESS_BIT_SHIFT            (25)
+
+struct mv_cap_regs {
+        u32     caplength_hciversion;
+        u32     hcsparams;      /* HC structural parameters */
+        u32     hccparams;      /* HC Capability Parameters*/
+        u32     reserved[5];
+        u32     dciversion;     /* DC version number and reserved 16 bits */
+        u32     dccparams;      /* DC Capability Parameters */
+};
+
+struct mv_op_regs {
+        u32     usbcmd;         /* Command register */
+        u32     usbsts;         /* Status register */
+        u32     usbintr;        /* Interrupt enable */
+        u32     frindex;        /* Frame index */
+        u32     reserved1[1];
+        u32     deviceaddr;     /* Device Address */
+        u32     eplistaddr;     /* Endpoint List Address */
+        u32     ttctrl;         /* HOST TT status and control */
+        u32     burstsize;      /* Programmable Burst Size */
+        u32     txfilltuning;   /* Host Transmit Pre-Buffer Packet Tuning */
+        u32     reserved[4];
+        u32     epnak;          /* Endpoint NAK */
+        u32     epnaken;        /* Endpoint NAK Enable */
+        u32     configflag;     /* Configured Flag register */
+        u32     portsc[VUSBHS_MAX_PORTS]; /* Port Status/Control x, x = 1..8 */
+        u32     otgsc;
+        u32     usbmode;        /* USB Host/Device mode */
+        u32     epsetupstat;    /* Endpoint Setup Status */
+        u32     epprime;        /* Endpoint Initialize */
+        u32     epflush;        /* Endpoint De-initialize */
+        u32     epstatus;       /* Endpoint Status */
+        u32     epcomplete;     /* Endpoint Interrupt On Complete */
+        u32     epctrlx[16];    /* Endpoint Control, where x = 0.. 15 */
+        u32     mcr;            /* Mux Control */
+        u32     isr;            /* Interrupt Status */
+        u32     ier;            /* Interrupt Enable */
+};
+
+struct mv_udc {
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+        spinlock_t                      lock;
+        struct completion               *done;
+        struct platform_device          *dev;
+        int                             irq;
+
+        struct mv_cap_regs __iomem      *cap_regs;
+        struct mv_op_regs __iomem       *op_regs;
+        unsigned int                    phy_regs;
+        unsigned int                    max_eps;
+        struct mv_dqh                   *ep_dqh;
+        size_t                          ep_dqh_size;
+        dma_addr_t                      ep_dqh_dma;
+
+        struct dma_pool                 *dtd_pool;
+        struct mv_ep                    *eps;
+
+        struct mv_dtd                   *dtd_head;
+        struct mv_dtd                   *dtd_tail;
+        unsigned int                    dtd_entries;
+
+        struct mv_req                   *status_req;
+        struct usb_ctrlrequest          local_setup_buff;
+
+        unsigned int            resume_state;   /* USB state to resume */
+        unsigned int            usb_state;      /* USB current state */
+        unsigned int            ep0_state;      /* Endpoint zero state */
+        unsigned int            ep0_dir;
+
+        unsigned int            dev_addr;
+
+        int                     errors;
+        unsigned                softconnect:1,
+                                vbus_active:1,
+                                remote_wakeup:1,
+                                softconnected:1,
+                                force_fs:1;
+        struct clk              *clk;
+};
+
+/* endpoint data structure */
+struct mv_ep {
+        struct usb_ep           ep;
+        struct mv_udc           *udc;
+        struct list_head        queue;
+        struct mv_dqh           *dqh;
+        const struct usb_endpoint_descriptor    *desc;
+        u32                     direction;
+        char                    name[14];
+        unsigned                stopped:1,
+                                wedge:1,
+                                ep_type:2,
+                                ep_num:8;
+};
+
+/* request data structure */
+struct mv_req {
+        struct usb_request      req;
+        struct mv_dtd           *dtd, *head, *tail;
+        struct mv_ep            *ep;
+        struct list_head        queue;
+        unsigned                dtd_count;
+        unsigned                mapped:1;
+};
+
+#define EP_QUEUE_HEAD_MULT_POS                  30
+#define EP_QUEUE_HEAD_ZLT_SEL                   0x20000000
+#define EP_QUEUE_HEAD_MAX_PKT_LEN_POS           16
+#define EP_QUEUE_HEAD_MAX_PKT_LEN(ep_info)      (((ep_info)>>16)&0x07ff)
+#define EP_QUEUE_HEAD_IOS                       0x00008000
+#define EP_QUEUE_HEAD_NEXT_TERMINATE            0x00000001
+#define EP_QUEUE_HEAD_IOC                       0x00008000
+#define EP_QUEUE_HEAD_MULTO                     0x00000C00
+#define EP_QUEUE_HEAD_STATUS_HALT               0x00000040
+#define EP_QUEUE_HEAD_STATUS_ACTIVE             0x00000080
+#define EP_QUEUE_CURRENT_OFFSET_MASK            0x00000FFF
+#define EP_QUEUE_HEAD_NEXT_POINTER_MASK         0xFFFFFFE0
+#define EP_QUEUE_FRINDEX_MASK                   0x000007FF
+#define EP_MAX_LENGTH_TRANSFER                  0x4000
+
+struct mv_dqh {
+        /* Bits 16..26 Bit 15 is Interrupt On Setup */
+        u32     max_packet_length;
+        u32     curr_dtd_ptr;           /* Current dTD Pointer */
+        u32     next_dtd_ptr;           /* Next dTD Pointer */
+        /* Total bytes (16..30), IOC (15), INT (8), STS (0-7) */
+        u32     size_ioc_int_sts;
+        u32     buff_ptr0;              /* Buffer pointer Page 0 (12-31) */
+        u32     buff_ptr1;              /* Buffer pointer Page 1 (12-31) */
+        u32     buff_ptr2;              /* Buffer pointer Page 2 (12-31) */
+        u32     buff_ptr3;              /* Buffer pointer Page 3 (12-31) */
+        u32     buff_ptr4;              /* Buffer pointer Page 4 (12-31) */
+        u32     reserved1;
+        /* 8 bytes of setup data that follows the Setup PID */
+        u8      setup_buffer[8];
+        u32     reserved2[4];
+};
+
+
+#define DTD_NEXT_TERMINATE              (0x00000001)
+#define DTD_IOC                         (0x00008000)
+#define DTD_STATUS_ACTIVE               (0x00000080)
+#define DTD_STATUS_HALTED               (0x00000040)
+#define DTD_STATUS_DATA_BUFF_ERR        (0x00000020)
+#define DTD_STATUS_TRANSACTION_ERR      (0x00000008)
+#define DTD_RESERVED_FIELDS             (0x00007F00)
+#define DTD_ERROR_MASK                  (0x68)
+#define DTD_ADDR_MASK                   (0xFFFFFFE0)
+#define DTD_PACKET_SIZE                 0x7FFF0000
+#define DTD_LENGTH_BIT_POS              (16)
+
+struct mv_dtd {
+        u32     dtd_next;
+        u32     size_ioc_sts;
+        u32     buff_ptr0;              /* Buffer pointer Page 0 */
+        u32     buff_ptr1;              /* Buffer pointer Page 1 */
+        u32     buff_ptr2;              /* Buffer pointer Page 2 */
+        u32     buff_ptr3;              /* Buffer pointer Page 3 */
+        u32     buff_ptr4;              /* Buffer pointer Page 4 */
+        u32     scratch_ptr;
+        /* 32 bytes */
+        dma_addr_t td_dma;              /* dma address for this td */
+        struct mv_dtd *next_dtd_virt;
+};
+
+extern int mv_udc_phy_init(unsigned int base);
+
+#endif
diff --git a/drivers/usb/gadget/mv_udc_core.c b/drivers/usb/gadget/mv_udc_core.c
new file mode 100644
index 000000000000..d5468a7f38e0
--- /dev/null
+++ b/drivers/usb/gadget/mv_udc_core.c
@@ -0,0 +1,2149 @@
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/timer.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
+#include <linux/pm.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <asm/system.h>
+#include <asm/unaligned.h>
+
+#include "mv_udc.h"
+
+#define DRIVER_DESC             "Marvell PXA USB Device Controller driver"
+#define DRIVER_VERSION          "8 Nov 2010"
+
+#define ep_dir(ep)      (((ep)->ep_num == 0) ? \
+                                ((ep)->udc->ep0_dir) : ((ep)->direction))
+
+/* timeout value -- usec */
+#define RESET_TIMEOUT           10000
+#define FLUSH_TIMEOUT           10000
+#define EPSTATUS_TIMEOUT        10000
+#define PRIME_TIMEOUT           10000
+#define READSAFE_TIMEOUT        1000
+#define DTD_TIMEOUT             1000
+
+#define LOOPS_USEC_SHIFT        4
+#define LOOPS_USEC              (1 << LOOPS_USEC_SHIFT)
+#define LOOPS(timeout)          ((timeout) >> LOOPS_USEC_SHIFT)
+
+static const char driver_name[] = "mv_udc";
+static const char driver_desc[] = DRIVER_DESC;
+
+/* controller device global variable */
+static struct mv_udc    *the_controller;
+int mv_usb_otgsc;
+
+static void nuke(struct mv_ep *ep, int status);
+
+/* for endpoint 0 operations */
+static const struct usb_endpoint_descriptor mv_ep0_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     0,
+        .bmAttributes =         USB_ENDPOINT_XFER_CONTROL,
+        .wMaxPacketSize =       EP0_MAX_PKT_SIZE,
+};
+
+static void ep0_reset(struct mv_udc *udc)
+{
+        struct mv_ep *ep;
+        u32 epctrlx;
+        int i = 0;
+
+        /* ep0 in and out */
+        for (i = 0; i < 2; i++) {
+                ep = &udc->eps[i];
+                ep->udc = udc;
+
+                /* ep0 dQH */
+                ep->dqh = &udc->ep_dqh[i];
+
+                /* configure ep0 endpoint capabilities in dQH */
+                ep->dqh->max_packet_length =
+                        (EP0_MAX_PKT_SIZE << EP_QUEUE_HEAD_MAX_PKT_LEN_POS)
+                        | EP_QUEUE_HEAD_IOS;
+
+                epctrlx = readl(&udc->op_regs->epctrlx[0]);
+                if (i) {        /* TX */
+                        epctrlx |= EPCTRL_TX_ENABLE | EPCTRL_TX_DATA_TOGGLE_RST
+                                | (USB_ENDPOINT_XFER_CONTROL
+                                        << EPCTRL_TX_EP_TYPE_SHIFT);
+
+                } else {        /* RX */
+                        epctrlx |= EPCTRL_RX_ENABLE | EPCTRL_RX_DATA_TOGGLE_RST
+                                | (USB_ENDPOINT_XFER_CONTROL
+                                        << EPCTRL_RX_EP_TYPE_SHIFT);
+                }
+
+                writel(epctrlx, &udc->op_regs->epctrlx[0]);
+        }
+}
+
+/* protocol ep0 stall, will automatically be cleared on new transaction */
+static void ep0_stall(struct mv_udc *udc)
+{
+        u32     epctrlx;
+
+        /* set TX and RX to stall */
+        epctrlx = readl(&udc->op_regs->epctrlx[0]);
+        epctrlx |= EPCTRL_RX_EP_STALL | EPCTRL_TX_EP_STALL;
+        writel(epctrlx, &udc->op_regs->epctrlx[0]);
+
+        /* update ep0 state */
+        udc->ep0_state = WAIT_FOR_SETUP;
+        udc->ep0_dir = EP_DIR_OUT;
+}
+
+static int process_ep_req(struct mv_udc *udc, int index,
+        struct mv_req *curr_req)
+{
+        struct mv_dtd   *curr_dtd;
+        struct mv_dqh   *curr_dqh;
+        int td_complete, actual, remaining_length;
+        int i, direction;
+        int retval = 0;
+        u32 errors;
+
+        curr_dqh = &udc->ep_dqh[index];
+        direction = index % 2;
+
+        curr_dtd = curr_req->head;
+        td_complete = 0;
+        actual = curr_req->req.length;
+
+        for (i = 0; i < curr_req->dtd_count; i++) {
+                if (curr_dtd->size_ioc_sts & DTD_STATUS_ACTIVE) {
+                        dev_dbg(&udc->dev->dev, "%s, dTD not completed\n",
+                                udc->eps[index].name);
+                        return 1;
+                }
+
+                errors = curr_dtd->size_ioc_sts & DTD_ERROR_MASK;
+                if (!errors) {
+                        remaining_length +=
+                                (curr_dtd->size_ioc_sts & DTD_PACKET_SIZE)
+                                        >> DTD_LENGTH_BIT_POS;
+                        actual -= remaining_length;
+                } else {
+                        dev_info(&udc->dev->dev,
+                                "complete_tr error: ep=%d %s: error = 0x%x\n",
+                                index >> 1, direction ? "SEND" : "RECV",
+                                errors);
+                        if (errors & DTD_STATUS_HALTED) {
+                                /* Clear the errors and Halt condition */
+                                curr_dqh->size_ioc_int_sts &= ~errors;
+                                retval = -EPIPE;
+                        } else if (errors & DTD_STATUS_DATA_BUFF_ERR) {
+                                retval = -EPROTO;
+                        } else if (errors & DTD_STATUS_TRANSACTION_ERR) {
+                                retval = -EILSEQ;
+                        }
+                }
+                if (i != curr_req->dtd_count - 1)
+                        curr_dtd = (struct mv_dtd *)curr_dtd->next_dtd_virt;
+        }
+        if (retval)
+                return retval;
+
+        curr_req->req.actual = actual;
+
+        return 0;
+}
+
+/*
+ * done() - retire a request; caller blocked irqs
+ * @status : request status to be set, only works when
+ * request is still in progress.
+ */
+static void done(struct mv_ep *ep, struct mv_req *req, int status)
+{
+        struct mv_udc *udc = NULL;
+        unsigned char stopped = ep->stopped;
+        struct mv_dtd *curr_td, *next_td;
+        int j;
+
+        udc = (struct mv_udc *)ep->udc;
+        /* Removed the req from fsl_ep->queue */
+        list_del_init(&req->queue);
+
+        /* req.status should be set as -EINPROGRESS in ep_queue() */
+        if (req->req.status == -EINPROGRESS)
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        /* Free dtd for the request */
+        next_td = req->head;
+        for (j = 0; j < req->dtd_count; j++) {
+                curr_td = next_td;
+                if (j != req->dtd_count - 1)
+                        next_td = curr_td->next_dtd_virt;
+                dma_pool_free(udc->dtd_pool, curr_td, curr_td->td_dma);
+        }
+
+        if (req->mapped) {
+                dma_unmap_single(ep->udc->gadget.dev.parent,
+                        req->req.dma, req->req.length,
+                        ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+                req->req.dma = DMA_ADDR_INVALID;
+                req->mapped = 0;
+        } else
+                dma_sync_single_for_cpu(ep->udc->gadget.dev.parent,
+                        req->req.dma, req->req.length,
+                        ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+
+        if (status && (status != -ESHUTDOWN))
+                dev_info(&udc->dev->dev, "complete %s req %p stat %d len %u/%u",
+                        ep->ep.name, &req->req, status,
+                        req->req.actual, req->req.length);
+
+        ep->stopped = 1;
+
+        spin_unlock(&ep->udc->lock);
+        /*
+         * complete() is from gadget layer,
+         * eg fsg->bulk_in_complete()
+         */
+        if (req->req.complete)
+                req->req.complete(&ep->ep, &req->req);
+
+        spin_lock(&ep->udc->lock);
+        ep->stopped = stopped;
+}
+
+static int queue_dtd(struct mv_ep *ep, struct mv_req *req)
+{
+        u32 tmp, epstatus, bit_pos, direction;
+        struct mv_udc *udc;
+        struct mv_dqh *dqh;
+        unsigned int loops;
+        int readsafe, retval = 0;
+
+        udc = ep->udc;
+        direction = ep_dir(ep);
+        dqh = &(udc->ep_dqh[ep->ep_num * 2 + direction]);
+        bit_pos = 1 << (((direction == EP_DIR_OUT) ? 0 : 16) + ep->ep_num);
+
+        /* check if the pipe is empty */
+        if (!(list_empty(&ep->queue))) {
+                struct mv_req *lastreq;
+                lastreq = list_entry(ep->queue.prev, struct mv_req, queue);
+                lastreq->tail->dtd_next =
+                        req->head->td_dma & EP_QUEUE_HEAD_NEXT_POINTER_MASK;
+                if (readl(&udc->op_regs->epprime) & bit_pos) {
+                        loops = LOOPS(PRIME_TIMEOUT);
+                        while (readl(&udc->op_regs->epprime) & bit_pos) {
+                                if (loops == 0) {
+                                        retval = -ETIME;
+                                        goto done;
+                                }
+                                udelay(LOOPS_USEC);
+                                loops--;
+                        }
+                        if (readl(&udc->op_regs->epstatus) & bit_pos)
+                                goto done;
+                }
+                readsafe = 0;
+                loops = LOOPS(READSAFE_TIMEOUT);
+                while (readsafe == 0) {
+                        if (loops == 0) {
+                                retval = -ETIME;
+                                goto done;
+                        }
+                        /* start with setting the semaphores */
+                        tmp = readl(&udc->op_regs->usbcmd);
+                        tmp |= USBCMD_ATDTW_TRIPWIRE_SET;
+                        writel(tmp, &udc->op_regs->usbcmd);
+
+                        /* read the endpoint status */
+                        epstatus = readl(&udc->op_regs->epstatus) & bit_pos;
+
+                        /*
+                         * Reread the ATDTW semaphore bit to check if it is
+                         * cleared. When hardware see a hazard, it will clear
+                         * the bit or else we remain set to 1 and we can
+                         * proceed with priming of endpoint if not already
+                         * primed.
+                         */
+                        if (readl(&udc->op_regs->usbcmd)
+                                & USBCMD_ATDTW_TRIPWIRE_SET) {
+                                readsafe = 1;
+                        }
+                        loops--;
+                        udelay(LOOPS_USEC);
+                }
+
+                /* Clear the semaphore */
+                tmp = readl(&udc->op_regs->usbcmd);
+                tmp &= USBCMD_ATDTW_TRIPWIRE_CLEAR;
+                writel(tmp, &udc->op_regs->usbcmd);
+
+                /* If endpoint is not active, we activate it now. */
+                if (!epstatus) {
+                        if (direction == EP_DIR_IN) {
+                                struct mv_dtd *curr_dtd = dma_to_virt(
+                                        &udc->dev->dev, dqh->curr_dtd_ptr);
+
+                                loops = LOOPS(DTD_TIMEOUT);
+                                while (curr_dtd->size_ioc_sts
+                                        & DTD_STATUS_ACTIVE) {
+                                        if (loops == 0) {
+                                                retval = -ETIME;
+                                                goto done;
+                                        }
+                                        loops--;
+                                        udelay(LOOPS_USEC);
+                                }
+                        }
+                        /* No other transfers on the queue */
+
+                        /* Write dQH next pointer and terminate bit to 0 */
+                        dqh->next_dtd_ptr = req->head->td_dma
+                                & EP_QUEUE_HEAD_NEXT_POINTER_MASK;
+                        dqh->size_ioc_int_sts = 0;
+
+                        /*
+                         * Ensure that updates to the QH will
+                         * occure before priming.
+                         */
+                        wmb();
+
+                        /* Prime the Endpoint */
+                        writel(bit_pos, &udc->op_regs->epprime);
+                }
+        } else {
+                /* Write dQH next pointer and terminate bit to 0 */
+                dqh->next_dtd_ptr = req->head->td_dma
+                        & EP_QUEUE_HEAD_NEXT_POINTER_MASK;;
+                dqh->size_ioc_int_sts = 0;
+
+                /* Ensure that updates to the QH will occure before priming. */
+                wmb();
+
+                /* Prime the Endpoint */
+                writel(bit_pos, &udc->op_regs->epprime);
+
+                if (direction == EP_DIR_IN) {
+                        /* FIXME add status check after prime the IN ep */
+                        int prime_again;
+                        u32 curr_dtd_ptr = dqh->curr_dtd_ptr;
+
+                        loops = LOOPS(DTD_TIMEOUT);
+                        prime_again = 0;
+                        while ((curr_dtd_ptr != req->head->td_dma)) {
+                                curr_dtd_ptr = dqh->curr_dtd_ptr;
+                                if (loops == 0) {
+                                        dev_err(&udc->dev->dev,
+                                                "failed to prime %s\n",
+                                                ep->name);
+                                        retval = -ETIME;
+                                        goto done;
+                                }
+                                loops--;
+                                udelay(LOOPS_USEC);
+
+                                if (loops == (LOOPS(DTD_TIMEOUT) >> 2)) {
+                                        if (prime_again)
+                                                goto done;
+                                        dev_info(&udc->dev->dev,
+                                                "prime again\n");
+                                        writel(bit_pos,
+                                                &udc->op_regs->epprime);
+                                        prime_again = 1;
+                                }
+                        }
+                }
+        }
+done:
+        return retval;;
+}
+
+static struct mv_dtd *build_dtd(struct mv_req *req, unsigned *length,
+                dma_addr_t *dma, int *is_last)
+{
+        u32 temp;
+        struct mv_dtd *dtd;
+        struct mv_udc *udc;
+
+        /* how big will this transfer be? */
+        *length = min(req->req.length - req->req.actual,
+                        (unsigned)EP_MAX_LENGTH_TRANSFER);
+
+        udc = req->ep->udc;
+
+        /*
+         * Be careful that no _GFP_HIGHMEM is set,
+         * or we can not use dma_to_virt
+         */
+        dtd = dma_pool_alloc(udc->dtd_pool, GFP_KERNEL, dma);
+        if (dtd == NULL)
+                return dtd;
+
+        dtd->td_dma = *dma;
+        /* initialize buffer page pointers */
+        temp = (u32)(req->req.dma + req->req.actual);
+        dtd->buff_ptr0 = cpu_to_le32(temp);
+        temp &= ~0xFFF;
+        dtd->buff_ptr1 = cpu_to_le32(temp + 0x1000);
+        dtd->buff_ptr2 = cpu_to_le32(temp + 0x2000);
+        dtd->buff_ptr3 = cpu_to_le32(temp + 0x3000);
+        dtd->buff_ptr4 = cpu_to_le32(temp + 0x4000);
+
+        req->req.actual += *length;
+
+        /* zlp is needed if req->req.zero is set */
+        if (req->req.zero) {
+                if (*length == 0 || (*length % req->ep->ep.maxpacket) != 0)
+                        *is_last = 1;
+                else
+                        *is_last = 0;
+        } else if (req->req.length == req->req.actual)
+                *is_last = 1;
+        else
+                *is_last = 0;
+
+        /* Fill in the transfer size; set active bit */
+        temp = ((*length << DTD_LENGTH_BIT_POS) | DTD_STATUS_ACTIVE);
+
+        /* Enable interrupt for the last dtd of a request */
+        if (*is_last && !req->req.no_interrupt)
+                temp |= DTD_IOC;
+
+        dtd->size_ioc_sts = temp;
+
+        mb();
+
+        return dtd;
+}
+
+/* generate dTD linked list for a request */
+static int req_to_dtd(struct mv_req *req)
+{
+        unsigned count;
+        int is_last, is_first = 1;
+        struct mv_dtd *dtd, *last_dtd = NULL;
+        struct mv_udc *udc;
+        dma_addr_t dma;
+
+        udc = req->ep->udc;
+
+        do {
+                dtd = build_dtd(req, &count, &dma, &is_last);
+                if (dtd == NULL)
+                        return -ENOMEM;
+
+                if (is_first) {
+                        is_first = 0;
+                        req->head = dtd;
+                } else {
+                        last_dtd->dtd_next = dma;
+                        last_dtd->next_dtd_virt = dtd;
+                }
+                last_dtd = dtd;
+                req->dtd_count++;
+        } while (!is_last);
+
+        /* set terminate bit to 1 for the last dTD */
+        dtd->dtd_next = DTD_NEXT_TERMINATE;
+
+        req->tail = dtd;
+
+        return 0;
+}
+
+static int mv_ep_enable(struct usb_ep *_ep,
+                const struct usb_endpoint_descriptor *desc)
+{
+        struct mv_udc *udc;
+        struct mv_ep *ep;
+        struct mv_dqh *dqh;
+        u16 max = 0;
+        u32 bit_pos, epctrlx, direction;
+        unsigned char zlt = 0, ios = 0, mult = 0;
+
+        ep = container_of(_ep, struct mv_ep, ep);
+        udc = ep->udc;
+
+        if (!_ep || !desc || ep->desc
+                        || desc->bDescriptorType != USB_DT_ENDPOINT)
+                return -EINVAL;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        direction = ep_dir(ep);
+        max = le16_to_cpu(desc->wMaxPacketSize);
+
+        /*
+         * disable HW zero length termination select
+         * driver handles zero length packet through req->req.zero
+         */
+        zlt = 1;
+
+        /* Get the endpoint queue head address */
+        dqh = (struct mv_dqh *)ep->dqh;
+
+        bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num);
+
+        /* Check if the Endpoint is Primed */
+        if ((readl(&udc->op_regs->epprime) & bit_pos)
+                || (readl(&udc->op_regs->epstatus) & bit_pos)) {
+                dev_info(&udc->dev->dev,
+                        "ep=%d %s: Init ERROR: ENDPTPRIME=0x%x,"
+                        " ENDPTSTATUS=0x%x, bit_pos=0x%x\n",
+                        (unsigned)ep->ep_num, direction ? "SEND" : "RECV",
+                        (unsigned)readl(&udc->op_regs->epprime),
+                        (unsigned)readl(&udc->op_regs->epstatus),
+                        (unsigned)bit_pos);
+                goto en_done;
+        }
+        /* Set the max packet length, interrupt on Setup and Mult fields */
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_BULK:
+                zlt = 1;
+                mult = 0;
+                break;
+        case USB_ENDPOINT_XFER_CONTROL:
+                ios = 1;
+        case USB_ENDPOINT_XFER_INT:
+                mult = 0;
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                /* Calculate transactions needed for high bandwidth iso */
+                mult = (unsigned char)(1 + ((max >> 11) & 0x03));
+                max = max & 0x8ff;      /* bit 0~10 */
+                /* 3 transactions at most */
+                if (mult > 3)
+                        goto en_done;
+                break;
+        default:
+                goto en_done;
+        }
+        dqh->max_packet_length = (max << EP_QUEUE_HEAD_MAX_PKT_LEN_POS)
+                | (mult << EP_QUEUE_HEAD_MULT_POS)
+                | (zlt ? EP_QUEUE_HEAD_ZLT_SEL : 0)
+                | (ios ? EP_QUEUE_HEAD_IOS : 0);
+        dqh->next_dtd_ptr = 1;
+        dqh->size_ioc_int_sts = 0;
+
+        ep->ep.maxpacket = max;
+        ep->desc = desc;
+        ep->stopped = 0;
+
+        /* Enable the endpoint for Rx or Tx and set the endpoint type */
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if (direction == EP_DIR_IN) {
+                epctrlx &= ~EPCTRL_TX_ALL_MASK;
+                epctrlx |= EPCTRL_TX_ENABLE | EPCTRL_TX_DATA_TOGGLE_RST
+                        | ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_TX_EP_TYPE_SHIFT);
+        } else {
+                epctrlx &= ~EPCTRL_RX_ALL_MASK;
+                epctrlx |= EPCTRL_RX_ENABLE | EPCTRL_RX_DATA_TOGGLE_RST
+                        | ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_RX_EP_TYPE_SHIFT);
+        }
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+
+        /*
+         * Implement Guideline (GL# USB-7) The unused endpoint type must
+         * be programmed to bulk.
+         */
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if ((epctrlx & EPCTRL_RX_ENABLE) == 0) {
+                epctrlx |= ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_RX_EP_TYPE_SHIFT);
+                writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+        }
+
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if ((epctrlx & EPCTRL_TX_ENABLE) == 0) {
+                epctrlx |= ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                << EPCTRL_TX_EP_TYPE_SHIFT);
+                writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+        }
+
+        return 0;
+en_done:
+        return -EINVAL;
+}
+
+static int  mv_ep_disable(struct usb_ep *_ep)
+{
+        struct mv_udc *udc;
+        struct mv_ep *ep;
+        struct mv_dqh *dqh;
+        u32 bit_pos, epctrlx, direction;
+
+        ep = container_of(_ep, struct mv_ep, ep);
+        if ((_ep == NULL) || !ep->desc)
+                return -EINVAL;
+
+        udc = ep->udc;
+
+        /* Get the endpoint queue head address */
+        dqh = ep->dqh;
+
+        direction = ep_dir(ep);
+        bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num);
+
+        /* Reset the max packet length and the interrupt on Setup */
+        dqh->max_packet_length = 0;
+
+        /* Disable the endpoint for Rx or Tx and reset the endpoint type */
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        epctrlx &= ~((direction == EP_DIR_IN)
+                        ? (EPCTRL_TX_ENABLE | EPCTRL_TX_TYPE)
+                        : (EPCTRL_RX_ENABLE | EPCTRL_RX_TYPE));
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+
+        /* nuke all pending requests (does flush) */
+        nuke(ep, -ESHUTDOWN);
+
+        ep->desc = NULL;
+        ep->stopped = 1;
+        return 0;
+}
+
+static struct usb_request *
+mv_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
+{
+        struct mv_req *req = NULL;
+
+        req = kzalloc(sizeof *req, gfp_flags);
+        if (!req)
+                return NULL;
+
+        req->req.dma = DMA_ADDR_INVALID;
+        INIT_LIST_HEAD(&req->queue);
+
+        return &req->req;
+}
+
+static void mv_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct mv_req *req = NULL;
+
+        req = container_of(_req, struct mv_req, req);
+
+        if (_req)
+                kfree(req);
+}
+
+static void mv_ep_fifo_flush(struct usb_ep *_ep)
+{
+        struct mv_udc *udc;
+        u32 bit_pos, direction;
+        struct mv_ep *ep = container_of(_ep, struct mv_ep, ep);
+        unsigned int loops;
+
+        udc = ep->udc;
+        direction = ep_dir(ep);
+        bit_pos = 1 << ((direction == EP_DIR_OUT ? 0 : 16) + ep->ep_num);
+        /*
+         * Flushing will halt the pipe
+         * Write 1 to the Flush register
+         */
+        writel(bit_pos, &udc->op_regs->epflush);
+
+        /* Wait until flushing completed */
+        loops = LOOPS(FLUSH_TIMEOUT);
+        while (readl(&udc->op_regs->epflush) & bit_pos) {
+                /*
+                 * ENDPTFLUSH bit should be cleared to indicate this
+                 * operation is complete
+                 */
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "TIMEOUT for ENDPTFLUSH=0x%x, bit_pos=0x%x\n",
+                                (unsigned)readl(&udc->op_regs->epflush),
+                                (unsigned)bit_pos);
+                        return;
+                }
+                loops--;
+                udelay(LOOPS_USEC);
+        }
+        loops = LOOPS(EPSTATUS_TIMEOUT);
+        while (readl(&udc->op_regs->epstatus) & bit_pos) {
+                unsigned int inter_loops;
+
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "TIMEOUT for ENDPTSTATUS=0x%x, bit_pos=0x%x\n",
+                                (unsigned)readl(&udc->op_regs->epstatus),
+                                (unsigned)bit_pos);
+                        return;
+                }
+                /* Write 1 to the Flush register */
+                writel(bit_pos, &udc->op_regs->epflush);
+
+                /* Wait until flushing completed */
+                inter_loops = LOOPS(FLUSH_TIMEOUT);
+                while (readl(&udc->op_regs->epflush) & bit_pos) {
+                        /*
+                         * ENDPTFLUSH bit should be cleared to indicate this
+                         * operation is complete
+                         */
+                        if (inter_loops == 0) {
+                                dev_err(&udc->dev->dev,
+                                        "TIMEOUT for ENDPTFLUSH=0x%x,"
+                                        "bit_pos=0x%x\n",
+                                        (unsigned)readl(&udc->op_regs->epflush),
+                                        (unsigned)bit_pos);
+                                return;
+                        }
+                        inter_loops--;
+                        udelay(LOOPS_USEC);
+                }
+                loops--;
+        }
+}
+
+/* queues (submits) an I/O request to an endpoint */
+static int
+mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+{
+        struct mv_ep *ep = container_of(_ep, struct mv_ep, ep);
+        struct mv_req *req = container_of(_req, struct mv_req, req);
+        struct mv_udc *udc = ep->udc;
+        unsigned long flags;
+
+        /* catch various bogus parameters */
+        if (!_req || !req->req.complete || !req->req.buf
+                        || !list_empty(&req->queue)) {
+                dev_err(&udc->dev->dev, "%s, bad params", __func__);
+                return -EINVAL;
+        }
+        if (unlikely(!_ep || !ep->desc)) {
+                dev_err(&udc->dev->dev, "%s, bad ep", __func__);
+                return -EINVAL;
+        }
+        if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+                if (req->req.length > ep->ep.maxpacket)
+                        return -EMSGSIZE;
+        }
+
+        udc = ep->udc;
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        req->ep = ep;
+
+        /* map virtual address to hardware */
+        if (req->req.dma == DMA_ADDR_INVALID) {
+                req->req.dma = dma_map_single(ep->udc->gadget.dev.parent,
+                                        req->req.buf,
+                                        req->req.length, ep_dir(ep)
+                                                ? DMA_TO_DEVICE
+                                                : DMA_FROM_DEVICE);
+                req->mapped = 1;
+        } else {
+                dma_sync_single_for_device(ep->udc->gadget.dev.parent,
+                                        req->req.dma, req->req.length,
+                                        ep_dir(ep)
+                                                ? DMA_TO_DEVICE
+                                                : DMA_FROM_DEVICE);
+                req->mapped = 0;
+        }
+
+        req->req.status = -EINPROGRESS;
+        req->req.actual = 0;
+        req->dtd_count = 0;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* build dtds and push them to device queue */
+        if (!req_to_dtd(req)) {
+                int retval;
+                retval = queue_dtd(ep, req);
+                if (retval) {
+                        spin_unlock_irqrestore(&udc->lock, flags);
+                        return retval;
+                }
+        } else {
+                spin_unlock_irqrestore(&udc->lock, flags);
+                return -ENOMEM;
+        }
+
+        /* Update ep0 state */
+        if (ep->ep_num == 0)
+                udc->ep0_state = DATA_STATE_XMIT;
+
+        /* irq handler advances the queue */
+        if (req != NULL)
+                list_add_tail(&req->queue, &ep->queue);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+/* dequeues (cancels, unlinks) an I/O request from an endpoint */
+static int mv_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct mv_ep *ep = container_of(_ep, struct mv_ep, ep);
+        struct mv_req *req;
+        struct mv_udc *udc = ep->udc;
+        unsigned long flags;
+        int stopped, ret = 0;
+        u32 epctrlx;
+
+        if (!_ep || !_req)
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->udc->lock, flags);
+        stopped = ep->stopped;
+
+        /* Stop the ep before we deal with the queue */
+        ep->stopped = 1;
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if (ep_dir(ep) == EP_DIR_IN)
+                epctrlx &= ~EPCTRL_TX_ENABLE;
+        else
+                epctrlx &= ~EPCTRL_RX_ENABLE;
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+
+        /* make sure it's actually queued on this endpoint */
+        list_for_each_entry(req, &ep->queue, queue) {
+                if (&req->req == _req)
+                        break;
+        }
+        if (&req->req != _req) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* The request is in progress, or completed but not dequeued */
+        if (ep->queue.next == &req->queue) {
+                _req->status = -ECONNRESET;
+                mv_ep_fifo_flush(_ep);  /* flush current transfer */
+
+                /* The request isn't the last request in this ep queue */
+                if (req->queue.next != &ep->queue) {
+                        struct mv_dqh *qh;
+                        struct mv_req *next_req;
+
+                        qh = ep->dqh;
+                        next_req = list_entry(req->queue.next, struct mv_req,
+                                        queue);
+
+                        /* Point the QH to the first TD of next request */
+                        writel((u32) next_req->head, &qh->curr_dtd_ptr);
+                } else {
+                        struct mv_dqh *qh;
+
+                        qh = ep->dqh;
+                        qh->next_dtd_ptr = 1;
+                        qh->size_ioc_int_sts = 0;
+                }
+
+                /* The request hasn't been processed, patch up the TD chain */
+        } else {
+                struct mv_req *prev_req;
+
+                prev_req = list_entry(req->queue.prev, struct mv_req, queue);
+                writel(readl(&req->tail->dtd_next),
+                                &prev_req->tail->dtd_next);
+
+        }
+
+        done(ep, req, -ECONNRESET);
+
+        /* Enable EP */
+out:
+        epctrlx = readl(&udc->op_regs->epctrlx[ep->ep_num]);
+        if (ep_dir(ep) == EP_DIR_IN)
+                epctrlx |= EPCTRL_TX_ENABLE;
+        else
+                epctrlx |= EPCTRL_RX_ENABLE;
+        writel(epctrlx, &udc->op_regs->epctrlx[ep->ep_num]);
+        ep->stopped = stopped;
+
+        spin_unlock_irqrestore(&ep->udc->lock, flags);
+        return ret;
+}
+
+static void ep_set_stall(struct mv_udc *udc, u8 ep_num, u8 direction, int stall)
+{
+        u32 epctrlx;
+
+        epctrlx = readl(&udc->op_regs->epctrlx[ep_num]);
+
+        if (stall) {
+                if (direction == EP_DIR_IN)
+                        epctrlx |= EPCTRL_TX_EP_STALL;
+                else
+                        epctrlx |= EPCTRL_RX_EP_STALL;
+        } else {
+                if (direction == EP_DIR_IN) {
+                        epctrlx &= ~EPCTRL_TX_EP_STALL;
+                        epctrlx |= EPCTRL_TX_DATA_TOGGLE_RST;
+                } else {
+                        epctrlx &= ~EPCTRL_RX_EP_STALL;
+                        epctrlx |= EPCTRL_RX_DATA_TOGGLE_RST;
+                }
+        }
+        writel(epctrlx, &udc->op_regs->epctrlx[ep_num]);
+}
+
+static int ep_is_stall(struct mv_udc *udc, u8 ep_num, u8 direction)
+{
+        u32 epctrlx;
+
+        epctrlx = readl(&udc->op_regs->epctrlx[ep_num]);
+
+        if (direction == EP_DIR_OUT)
+                return (epctrlx & EPCTRL_RX_EP_STALL) ? 1 : 0;
+        else
+                return (epctrlx & EPCTRL_TX_EP_STALL) ? 1 : 0;
+}
+
+static int mv_ep_set_halt_wedge(struct usb_ep *_ep, int halt, int wedge)
+{
+        struct mv_ep *ep;
+        unsigned long flags = 0;
+        int status = 0;
+        struct mv_udc *udc;
+
+        ep = container_of(_ep, struct mv_ep, ep);
+        udc = ep->udc;
+        if (!_ep || !ep->desc) {
+                status = -EINVAL;
+                goto out;
+        }
+
+        if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+                status = -EOPNOTSUPP;
+                goto out;
+        }
+
+        /*
+         * Attempt to halt IN ep will fail if any transfer requests
+         * are still queue
+         */
+        if (halt && (ep_dir(ep) == EP_DIR_IN) && !list_empty(&ep->queue)) {
+                status = -EAGAIN;
+                goto out;
+        }
+
+        spin_lock_irqsave(&ep->udc->lock, flags);
+        ep_set_stall(udc, ep->ep_num, ep_dir(ep), halt);
+        if (halt && wedge)
+                ep->wedge = 1;
+        else if (!halt)
+                ep->wedge = 0;
+        spin_unlock_irqrestore(&ep->udc->lock, flags);
+
+        if (ep->ep_num == 0) {
+                udc->ep0_state = WAIT_FOR_SETUP;
+                udc->ep0_dir = EP_DIR_OUT;
+        }
+out:
+        return status;
+}
+
+static int mv_ep_set_halt(struct usb_ep *_ep, int halt)
+{
+        return mv_ep_set_halt_wedge(_ep, halt, 0);
+}
+
+static int mv_ep_set_wedge(struct usb_ep *_ep)
+{
+        return mv_ep_set_halt_wedge(_ep, 1, 1);
+}
+
+static struct usb_ep_ops mv_ep_ops = {
+        .enable         = mv_ep_enable,
+        .disable        = mv_ep_disable,
+
+        .alloc_request  = mv_alloc_request,
+        .free_request   = mv_free_request,
+
+        .queue          = mv_ep_queue,
+        .dequeue        = mv_ep_dequeue,
+
+        .set_wedge      = mv_ep_set_wedge,
+        .set_halt       = mv_ep_set_halt,
+        .fifo_flush     = mv_ep_fifo_flush,     /* flush fifo */
+};
+
+static void udc_stop(struct mv_udc *udc)
+{
+        u32 tmp;
+
+        /* Disable interrupts */
+        tmp = readl(&udc->op_regs->usbintr);
+        tmp &= ~(USBINTR_INT_EN | USBINTR_ERR_INT_EN |
+                USBINTR_PORT_CHANGE_DETECT_EN | USBINTR_RESET_EN);
+        writel(tmp, &udc->op_regs->usbintr);
+
+        /* Reset the Run the bit in the command register to stop VUSB */
+        tmp = readl(&udc->op_regs->usbcmd);
+        tmp &= ~USBCMD_RUN_STOP;
+        writel(tmp, &udc->op_regs->usbcmd);
+}
+
+static void udc_start(struct mv_udc *udc)
+{
+        u32 usbintr;
+
+        usbintr = USBINTR_INT_EN | USBINTR_ERR_INT_EN
+                | USBINTR_PORT_CHANGE_DETECT_EN
+                | USBINTR_RESET_EN | USBINTR_DEVICE_SUSPEND;
+        /* Enable interrupts */
+        writel(usbintr, &udc->op_regs->usbintr);
+
+        /* Set the Run bit in the command register */
+        writel(USBCMD_RUN_STOP, &udc->op_regs->usbcmd);
+}
+
+static int udc_reset(struct mv_udc *udc)
+{
+        unsigned int loops;
+        u32 tmp, portsc;
+
+        /* Stop the controller */
+        tmp = readl(&udc->op_regs->usbcmd);
+        tmp &= ~USBCMD_RUN_STOP;
+        writel(tmp, &udc->op_regs->usbcmd);
+
+        /* Reset the controller to get default values */
+        writel(USBCMD_CTRL_RESET, &udc->op_regs->usbcmd);
+
+        /* wait for reset to complete */
+        loops = LOOPS(RESET_TIMEOUT);
+        while (readl(&udc->op_regs->usbcmd) & USBCMD_CTRL_RESET) {
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "Wait for RESET completed TIMEOUT\n");
+                        return -ETIMEDOUT;
+                }
+                loops--;
+                udelay(LOOPS_USEC);
+        }
+
+        /* set controller to device mode */
+        tmp = readl(&udc->op_regs->usbmode);
+        tmp |= USBMODE_CTRL_MODE_DEVICE;
+
+        /* turn setup lockout off, require setup tripwire in usbcmd */
+        tmp |= USBMODE_SETUP_LOCK_OFF | USBMODE_STREAM_DISABLE;
+
+        writel(tmp, &udc->op_regs->usbmode);
+
+        writel(0x0, &udc->op_regs->epsetupstat);
+
+        /* Configure the Endpoint List Address */
+        writel(udc->ep_dqh_dma & USB_EP_LIST_ADDRESS_MASK,
+                &udc->op_regs->eplistaddr);
+
+        portsc = readl(&udc->op_regs->portsc[0]);
+        if (readl(&udc->cap_regs->hcsparams) & HCSPARAMS_PPC)
+                portsc &= (~PORTSCX_W1C_BITS | ~PORTSCX_PORT_POWER);
+
+        if (udc->force_fs)
+                portsc |= PORTSCX_FORCE_FULL_SPEED_CONNECT;
+        else
+                portsc &= (~PORTSCX_FORCE_FULL_SPEED_CONNECT);
+
+        writel(portsc, &udc->op_regs->portsc[0]);
+
+        tmp = readl(&udc->op_regs->epctrlx[0]);
+        tmp &= ~(EPCTRL_TX_EP_STALL | EPCTRL_RX_EP_STALL);
+        writel(tmp, &udc->op_regs->epctrlx[0]);
+
+        return 0;
+}
+
+static int mv_udc_get_frame(struct usb_gadget *gadget)
+{
+        struct mv_udc *udc;
+        u16     retval;
+
+        if (!gadget)
+                return -ENODEV;
+
+        udc = container_of(gadget, struct mv_udc, gadget);
+
+        retval = readl(udc->op_regs->frindex) & USB_FRINDEX_MASKS;
+
+        return retval;
+}
+
+/* Tries to wake up the host connected to this gadget */
+static int mv_udc_wakeup(struct usb_gadget *gadget)
+{
+        struct mv_udc *udc = container_of(gadget, struct mv_udc, gadget);
+        u32 portsc;
+
+        /* Remote wakeup feature not enabled by host */
+        if (!udc->remote_wakeup)
+                return -ENOTSUPP;
+
+        portsc = readl(&udc->op_regs->portsc);
+        /* not suspended? */
+        if (!(portsc & PORTSCX_PORT_SUSPEND))
+                return 0;
+        /* trigger force resume */
+        portsc |= PORTSCX_PORT_FORCE_RESUME;
+        writel(portsc, &udc->op_regs->portsc[0]);
+        return 0;
+}
+
+static int mv_udc_pullup(struct usb_gadget *gadget, int is_on)
+{
+        struct mv_udc *udc;
+        unsigned long flags;
+
+        udc = container_of(gadget, struct mv_udc, gadget);
+        spin_lock_irqsave(&udc->lock, flags);
+
+        udc->softconnect = (is_on != 0);
+        if (udc->driver && udc->softconnect)
+                udc_start(udc);
+        else
+                udc_stop(udc);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/* device controller usb_gadget_ops structure */
+static const struct usb_gadget_ops mv_ops = {
+
+        /* returns the current frame number */
+        .get_frame      = mv_udc_get_frame,
+
+        /* tries to wake up the host connected to this gadget */
+        .wakeup         = mv_udc_wakeup,
+
+        /* D+ pullup, software-controlled connect/disconnect to USB host */
+        .pullup         = mv_udc_pullup,
+};
+
+static void mv_udc_testmode(struct mv_udc *udc, u16 index, bool enter)
+{
+        dev_info(&udc->dev->dev, "Test Mode is not support yet\n");
+}
+
+static int eps_init(struct mv_udc *udc)
+{
+        struct mv_ep    *ep;
+        char name[14];
+        int i;
+
+        /* initialize ep0 */
+        ep = &udc->eps[0];
+        ep->udc = udc;
+        strncpy(ep->name, "ep0", sizeof(ep->name));
+        ep->ep.name = ep->name;
+        ep->ep.ops = &mv_ep_ops;
+        ep->wedge = 0;
+        ep->stopped = 0;
+        ep->ep.maxpacket = EP0_MAX_PKT_SIZE;
+        ep->ep_num = 0;
+        ep->desc = &mv_ep0_desc;
+        INIT_LIST_HEAD(&ep->queue);
+
+        ep->ep_type = USB_ENDPOINT_XFER_CONTROL;
+
+        /* initialize other endpoints */
+        for (i = 2; i < udc->max_eps * 2; i++) {
+                ep = &udc->eps[i];
+                if (i % 2) {
+                        snprintf(name, sizeof(name), "ep%din", i / 2);
+                        ep->direction = EP_DIR_IN;
+                } else {
+                        snprintf(name, sizeof(name), "ep%dout", i / 2);
+                        ep->direction = EP_DIR_OUT;
+                }
+                ep->udc = udc;
+                strncpy(ep->name, name, sizeof(ep->name));
+                ep->ep.name = ep->name;
+
+                ep->ep.ops = &mv_ep_ops;
+                ep->stopped = 0;
+                ep->ep.maxpacket = (unsigned short) ~0;
+                ep->ep_num = i / 2;
+
+                INIT_LIST_HEAD(&ep->queue);
+                list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
+
+                ep->dqh = &udc->ep_dqh[i];
+        }
+
+        return 0;
+}
+
+/* delete all endpoint requests, called with spinlock held */
+static void nuke(struct mv_ep *ep, int status)
+{
+        /* called with spinlock held */
+        ep->stopped = 1;
+
+        /* endpoint fifo flush */
+        mv_ep_fifo_flush(&ep->ep);
+
+        while (!list_empty(&ep->queue)) {
+                struct mv_req *req = NULL;
+                req = list_entry(ep->queue.next, struct mv_req, queue);
+                done(ep, req, status);
+        }
+}
+
+/* stop all USB activities */
+static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver)
+{
+        struct mv_ep    *ep;
+
+        nuke(&udc->eps[0], -ESHUTDOWN);
+
+        list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
+                nuke(ep, -ESHUTDOWN);
+        }
+
+        /* report disconnect; the driver is already quiesced */
+        if (driver) {
+                spin_unlock(&udc->lock);
+                driver->disconnect(&udc->gadget);
+                spin_lock(&udc->lock);
+        }
+}
+
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+                int (*bind)(struct usb_gadget *))
+{
+        struct mv_udc *udc = the_controller;
+        int retval = 0;
+        unsigned long flags;
+
+        if (!udc)
+                return -ENODEV;
+
+        if (udc->driver)
+                return -EBUSY;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* hook up the driver ... */
+        driver->driver.bus = NULL;
+        udc->driver = driver;
+        udc->gadget.dev.driver = &driver->driver;
+
+        udc->usb_state = USB_STATE_ATTACHED;
+        udc->ep0_state = WAIT_FOR_SETUP;
+        udc->ep0_dir = USB_DIR_OUT;
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        retval = bind(&udc->gadget);
+        if (retval) {
+                dev_err(&udc->dev->dev, "bind to driver %s --> %d\n",
+                                driver->driver.name, retval);
+                udc->driver = NULL;
+                udc->gadget.dev.driver = NULL;
+                return retval;
+        }
+        udc_reset(udc);
+        ep0_reset(udc);
+        udc_start(udc);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct mv_udc *udc = the_controller;
+        unsigned long flags;
+
+        if (!udc)
+                return -ENODEV;
+
+        udc_stop(udc);
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* stop all usb activities */
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        stop_activity(udc, driver);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        /* unbind gadget driver */
+        driver->unbind(&udc->gadget);
+        udc->gadget.dev.driver = NULL;
+        udc->driver = NULL;
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+static int
+udc_prime_status(struct mv_udc *udc, u8 direction, u16 status, bool empty)
+{
+        int retval = 0;
+        struct mv_req *req;
+        struct mv_ep *ep;
+
+        ep = &udc->eps[0];
+        udc->ep0_dir = direction;
+
+        req = udc->status_req;
+
+        /* fill in the reqest structure */
+        if (empty == false) {
+                *((u16 *) req->req.buf) = cpu_to_le16(status);
+                req->req.length = 2;
+        } else
+                req->req.length = 0;
+
+        req->ep = ep;
+        req->req.status = -EINPROGRESS;
+        req->req.actual = 0;
+        req->req.complete = NULL;
+        req->dtd_count = 0;
+
+        /* prime the data phase */
+        if (!req_to_dtd(req))
+                retval = queue_dtd(ep, req);
+        else{   /* no mem */
+                retval = -ENOMEM;
+                goto out;
+        }
+
+        if (retval) {
+                dev_err(&udc->dev->dev, "response error on GET_STATUS request\n");
+                goto out;
+        }
+
+        list_add_tail(&req->queue, &ep->queue);
+
+        return 0;
+out:
+        return retval;
+}
+
+static void ch9setaddress(struct mv_udc *udc, struct usb_ctrlrequest *setup)
+{
+        udc->dev_addr = (u8)setup->wValue;
+
+        /* update usb state */
+        udc->usb_state = USB_STATE_ADDRESS;
+
+        if (udc_prime_status(udc, EP_DIR_IN, 0, true))
+                ep0_stall(udc);
+}
+
+static void ch9getstatus(struct mv_udc *udc, u8 ep_num,
+        struct usb_ctrlrequest *setup)
+{
+        u16 status;
+        int retval;
+
+        if ((setup->bRequestType & (USB_DIR_IN | USB_TYPE_MASK))
+                != (USB_DIR_IN | USB_TYPE_STANDARD))
+                return;
+
+        if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
+                status = 1 << USB_DEVICE_SELF_POWERED;
+                status |= udc->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP;
+        } else if ((setup->bRequestType & USB_RECIP_MASK)
+                        == USB_RECIP_INTERFACE) {
+                /* get interface status */
+                status = 0;
+        } else if ((setup->bRequestType & USB_RECIP_MASK)
+                        == USB_RECIP_ENDPOINT) {
+                u8 ep_num, direction;
+
+                ep_num = setup->wIndex & USB_ENDPOINT_NUMBER_MASK;
+                direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK)
+                                ? EP_DIR_IN : EP_DIR_OUT;
+                status = ep_is_stall(udc, ep_num, direction)
+                                << USB_ENDPOINT_HALT;
+        }
+
+        retval = udc_prime_status(udc, EP_DIR_IN, status, false);
+        if (retval)
+                ep0_stall(udc);
+}
+
+static void ch9clearfeature(struct mv_udc *udc, struct usb_ctrlrequest *setup)
+{
+        u8 ep_num;
+        u8 direction;
+        struct mv_ep *ep;
+
+        if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_DEVICE))) {
+                switch (setup->wValue) {
+                case USB_DEVICE_REMOTE_WAKEUP:
+                        udc->remote_wakeup = 0;
+                        break;
+                case USB_DEVICE_TEST_MODE:
+                        mv_udc_testmode(udc, 0, false);
+                        break;
+                default:
+                        goto out;
+                }
+        } else if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_ENDPOINT))) {
+                switch (setup->wValue) {
+                case USB_ENDPOINT_HALT:
+                        ep_num = setup->wIndex & USB_ENDPOINT_NUMBER_MASK;
+                        direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK)
+                                ? EP_DIR_IN : EP_DIR_OUT;
+                        if (setup->wValue != 0 || setup->wLength != 0
+                                || ep_num > udc->max_eps)
+                                goto out;
+                        ep = &udc->eps[ep_num * 2 + direction];
+                        if (ep->wedge == 1)
+                                break;
+                        spin_unlock(&udc->lock);
+                        ep_set_stall(udc, ep_num, direction, 0);
+                        spin_lock(&udc->lock);
+                        break;
+                default:
+                        goto out;
+                }
+        } else
+                goto out;
+
+        if (udc_prime_status(udc, EP_DIR_IN, 0, true))
+                ep0_stall(udc);
+        else
+                udc->ep0_state = DATA_STATE_XMIT;
+out:
+        return;
+}
+
+static void ch9setfeature(struct mv_udc *udc, struct usb_ctrlrequest *setup)
+{
+        u8 ep_num;
+        u8 direction;
+
+        if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_DEVICE))) {
+                switch (setup->wValue) {
+                case USB_DEVICE_REMOTE_WAKEUP:
+                        udc->remote_wakeup = 1;
+                        break;
+                case USB_DEVICE_TEST_MODE:
+                        if (setup->wIndex & 0xFF
+                                && udc->gadget.speed != USB_SPEED_HIGH)
+                                goto out;
+                        if (udc->usb_state == USB_STATE_CONFIGURED
+                                || udc->usb_state == USB_STATE_ADDRESS
+                                || udc->usb_state == USB_STATE_DEFAULT)
+                                mv_udc_testmode(udc,
+                                        setup->wIndex & 0xFF00, true);
+                        else
+                                goto out;
+                        break;
+                default:
+                        goto out;
+                }
+        } else if ((setup->bRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))
+                == ((USB_TYPE_STANDARD | USB_RECIP_ENDPOINT))) {
+                switch (setup->wValue) {
+                case USB_ENDPOINT_HALT:
+                        ep_num = setup->wIndex & USB_ENDPOINT_NUMBER_MASK;
+                        direction = (setup->wIndex & USB_ENDPOINT_DIR_MASK)
+                                ? EP_DIR_IN : EP_DIR_OUT;
+                        if (setup->wValue != 0 || setup->wLength != 0
+                                || ep_num > udc->max_eps)
+                                goto out;
+                        spin_unlock(&udc->lock);
+                        ep_set_stall(udc, ep_num, direction, 1);
+                        spin_lock(&udc->lock);
+                        break;
+                default:
+                        goto out;
+                }
+        } else
+                goto out;
+
+        if (udc_prime_status(udc, EP_DIR_IN, 0, true))
+                ep0_stall(udc);
+out:
+        return;
+}
+
+static void handle_setup_packet(struct mv_udc *udc, u8 ep_num,
+        struct usb_ctrlrequest *setup)
+{
+        bool delegate = false;
+
+        nuke(&udc->eps[ep_num * 2 + EP_DIR_OUT], -ESHUTDOWN);
+
+        dev_dbg(&udc->dev->dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
+                        setup->bRequestType, setup->bRequest,
+                        setup->wValue, setup->wIndex, setup->wLength);
+        /* We process some stardard setup requests here */
+        if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
+                switch (setup->bRequest) {
+                case USB_REQ_GET_STATUS:
+                        ch9getstatus(udc, ep_num, setup);
+                        break;
+
+                case USB_REQ_SET_ADDRESS:
+                        ch9setaddress(udc, setup);
+                        break;
+
+                case USB_REQ_CLEAR_FEATURE:
+                        ch9clearfeature(udc, setup);
+                        break;
+
+                case USB_REQ_SET_FEATURE:
+                        ch9setfeature(udc, setup);
+                        break;
+
+                default:
+                        delegate = true;
+                }
+        } else
+                delegate = true;
+
+        /* delegate USB standard requests to the gadget driver */
+        if (delegate == true) {
+                /* USB requests handled by gadget */
+                if (setup->wLength) {
+                        /* DATA phase from gadget, STATUS phase from udc */
+                        udc->ep0_dir = (setup->bRequestType & USB_DIR_IN)
+                                        ?  EP_DIR_IN : EP_DIR_OUT;
+                        spin_unlock(&udc->lock);
+                        if (udc->driver->setup(&udc->gadget,
+                                &udc->local_setup_buff) < 0)
+                                ep0_stall(udc);
+                        spin_lock(&udc->lock);
+                        udc->ep0_state = (setup->bRequestType & USB_DIR_IN)
+                                        ?  DATA_STATE_XMIT : DATA_STATE_RECV;
+                } else {
+                        /* no DATA phase, IN STATUS phase from gadget */
+                        udc->ep0_dir = EP_DIR_IN;
+                        spin_unlock(&udc->lock);
+                        if (udc->driver->setup(&udc->gadget,
+                                &udc->local_setup_buff) < 0)
+                                ep0_stall(udc);
+                        spin_lock(&udc->lock);
+                        udc->ep0_state = WAIT_FOR_OUT_STATUS;
+                }
+        }
+}
+
+/* complete DATA or STATUS phase of ep0 prime status phase if needed */
+static void ep0_req_complete(struct mv_udc *udc,
+        struct mv_ep *ep0, struct mv_req *req)
+{
+        u32 new_addr;
+
+        if (udc->usb_state == USB_STATE_ADDRESS) {
+                /* set the new address */
+                new_addr = (u32)udc->dev_addr;
+                writel(new_addr << USB_DEVICE_ADDRESS_BIT_SHIFT,
+                        &udc->op_regs->deviceaddr);
+        }
+
+        done(ep0, req, 0);
+
+        switch (udc->ep0_state) {
+        case DATA_STATE_XMIT:
+                /* receive status phase */
+                if (udc_prime_status(udc, EP_DIR_OUT, 0, true))
+                        ep0_stall(udc);
+                break;
+        case DATA_STATE_RECV:
+                /* send status phase */
+                if (udc_prime_status(udc, EP_DIR_IN, 0 , true))
+                        ep0_stall(udc);
+                break;
+        case WAIT_FOR_OUT_STATUS:
+                udc->ep0_state = WAIT_FOR_SETUP;
+                break;
+        case WAIT_FOR_SETUP:
+                dev_err(&udc->dev->dev, "unexpect ep0 packets\n");
+                break;
+        default:
+                ep0_stall(udc);
+                break;
+        }
+}
+
+static void get_setup_data(struct mv_udc *udc, u8 ep_num, u8 *buffer_ptr)
+{
+        u32 temp;
+        struct mv_dqh *dqh;
+
+        dqh = &udc->ep_dqh[ep_num * 2 + EP_DIR_OUT];
+
+        /* Clear bit in ENDPTSETUPSTAT */
+        temp = readl(&udc->op_regs->epsetupstat);
+        writel(temp | (1 << ep_num), &udc->op_regs->epsetupstat);
+
+        /* while a hazard exists when setup package arrives */
+        do {
+                /* Set Setup Tripwire */
+                temp = readl(&udc->op_regs->usbcmd);
+                writel(temp | USBCMD_SETUP_TRIPWIRE_SET, &udc->op_regs->usbcmd);
+
+                /* Copy the setup packet to local buffer */
+                memcpy(buffer_ptr, (u8 *) dqh->setup_buffer, 8);
+        } while (!(readl(&udc->op_regs->usbcmd) & USBCMD_SETUP_TRIPWIRE_SET));
+
+        /* Clear Setup Tripwire */
+        temp = readl(&udc->op_regs->usbcmd);
+        writel(temp & ~USBCMD_SETUP_TRIPWIRE_SET, &udc->op_regs->usbcmd);
+}
+
+static void irq_process_tr_complete(struct mv_udc *udc)
+{
+        u32 tmp, bit_pos;
+        int i, ep_num = 0, direction = 0;
+        struct mv_ep    *curr_ep;
+        struct mv_req *curr_req, *temp_req;
+        int status;
+
+        /*
+         * We use separate loops for ENDPTSETUPSTAT and ENDPTCOMPLETE
+         * because the setup packets are to be read ASAP
+         */
+
+        /* Process all Setup packet received interrupts */
+        tmp = readl(&udc->op_regs->epsetupstat);
+
+        if (tmp) {
+                for (i = 0; i < udc->max_eps; i++) {
+                        if (tmp & (1 << i)) {
+                                get_setup_data(udc, i,
+                                        (u8 *)(&udc->local_setup_buff));
+                                handle_setup_packet(udc, i,
+                                        &udc->local_setup_buff);
+                        }
+                }
+        }
+
+        /* Don't clear the endpoint setup status register here.
+         * It is cleared as a setup packet is read out of the buffer
+         */
+
+        /* Process non-setup transaction complete interrupts */
+        tmp = readl(&udc->op_regs->epcomplete);
+
+        if (!tmp)
+                return;
+
+        writel(tmp, &udc->op_regs->epcomplete);
+
+        for (i = 0; i < udc->max_eps * 2; i++) {
+                ep_num = i >> 1;
+                direction = i % 2;
+
+                bit_pos = 1 << (ep_num + 16 * direction);
+
+                if (!(bit_pos & tmp))
+                        continue;
+
+                if (i == 1)
+                        curr_ep = &udc->eps[0];
+                else
+                        curr_ep = &udc->eps[i];
+                /* process the req queue until an uncomplete request */
+                list_for_each_entry_safe(curr_req, temp_req,
+                        &curr_ep->queue, queue) {
+                        status = process_ep_req(udc, i, curr_req);
+                        if (status)
+                                break;
+
+                        /* write back status to req */
+                        curr_req->req.status = status;
+
+                        /* ep0 request completion */
+                        if (ep_num == 0) {
+                                ep0_req_complete(udc, curr_ep, curr_req);
+                                break;
+                        } else {
+                                done(curr_ep, curr_req, status);
+                        }
+                }
+        }
+}
+
+void irq_process_reset(struct mv_udc *udc)
+{
+        u32 tmp;
+        unsigned int loops;
+
+        udc->ep0_dir = EP_DIR_OUT;
+        udc->ep0_state = WAIT_FOR_SETUP;
+        udc->remote_wakeup = 0;         /* default to 0 on reset */
+
+        /* The address bits are past bit 25-31. Set the address */
+        tmp = readl(&udc->op_regs->deviceaddr);
+        tmp &= ~(USB_DEVICE_ADDRESS_MASK);
+        writel(tmp, &udc->op_regs->deviceaddr);
+
+        /* Clear all the setup token semaphores */
+        tmp = readl(&udc->op_regs->epsetupstat);
+        writel(tmp, &udc->op_regs->epsetupstat);
+
+        /* Clear all the endpoint complete status bits */
+        tmp = readl(&udc->op_regs->epcomplete);
+        writel(tmp, &udc->op_regs->epcomplete);
+
+        /* wait until all endptprime bits cleared */
+        loops = LOOPS(PRIME_TIMEOUT);
+        while (readl(&udc->op_regs->epprime) & 0xFFFFFFFF) {
+                if (loops == 0) {
+                        dev_err(&udc->dev->dev,
+                                "Timeout for ENDPTPRIME = 0x%x\n",
+                                readl(&udc->op_regs->epprime));
+                        break;
+                }
+                loops--;
+                udelay(LOOPS_USEC);
+        }
+
+        /* Write 1s to the Flush register */
+        writel((u32)~0, &udc->op_regs->epflush);
+
+        if (readl(&udc->op_regs->portsc[0]) & PORTSCX_PORT_RESET) {
+                dev_info(&udc->dev->dev, "usb bus reset\n");
+                udc->usb_state = USB_STATE_DEFAULT;
+                /* reset all the queues, stop all USB activities */
+                stop_activity(udc, udc->driver);
+        } else {
+                dev_info(&udc->dev->dev, "USB reset portsc 0x%x\n",
+                        readl(&udc->op_regs->portsc));
+
+                /*
+                 * re-initialize
+                 * controller reset
+                 */
+                udc_reset(udc);
+
+                /* reset all the queues, stop all USB activities */
+                stop_activity(udc, udc->driver);
+
+                /* reset ep0 dQH and endptctrl */
+                ep0_reset(udc);
+
+                /* enable interrupt and set controller to run state */
+                udc_start(udc);
+
+                udc->usb_state = USB_STATE_ATTACHED;
+        }
+}
+
+static void handle_bus_resume(struct mv_udc *udc)
+{
+        udc->usb_state = udc->resume_state;
+        udc->resume_state = 0;
+
+        /* report resume to the driver */
+        if (udc->driver) {
+                if (udc->driver->resume) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->resume(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+}
+
+static void irq_process_suspend(struct mv_udc *udc)
+{
+        udc->resume_state = udc->usb_state;
+        udc->usb_state = USB_STATE_SUSPENDED;
+
+        if (udc->driver->suspend) {
+                spin_unlock(&udc->lock);
+                udc->driver->suspend(&udc->gadget);
+                spin_lock(&udc->lock);
+        }
+}
+
+static void irq_process_port_change(struct mv_udc *udc)
+{
+        u32 portsc;
+
+        portsc = readl(&udc->op_regs->portsc[0]);
+        if (!(portsc & PORTSCX_PORT_RESET)) {
+                /* Get the speed */
+                u32 speed = portsc & PORTSCX_PORT_SPEED_MASK;
+                switch (speed) {
+                case PORTSCX_PORT_SPEED_HIGH:
+                        udc->gadget.speed = USB_SPEED_HIGH;
+                        break;
+                case PORTSCX_PORT_SPEED_FULL:
+                        udc->gadget.speed = USB_SPEED_FULL;
+                        break;
+                case PORTSCX_PORT_SPEED_LOW:
+                        udc->gadget.speed = USB_SPEED_LOW;
+                        break;
+                default:
+                        udc->gadget.speed = USB_SPEED_UNKNOWN;
+                        break;
+                }
+        }
+
+        if (portsc & PORTSCX_PORT_SUSPEND) {
+                udc->resume_state = udc->usb_state;
+                udc->usb_state = USB_STATE_SUSPENDED;
+                if (udc->driver->suspend) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->suspend(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+
+        if (!(portsc & PORTSCX_PORT_SUSPEND)
+                && udc->usb_state == USB_STATE_SUSPENDED) {
+                handle_bus_resume(udc);
+        }
+
+        if (!udc->resume_state)
+                udc->usb_state = USB_STATE_DEFAULT;
+}
+
+static void irq_process_error(struct mv_udc *udc)
+{
+        /* Increment the error count */
+        udc->errors++;
+}
+
+static irqreturn_t mv_udc_irq(int irq, void *dev)
+{
+        struct mv_udc *udc = (struct mv_udc *)dev;
+        u32 status, intr;
+
+        spin_lock(&udc->lock);
+
+        status = readl(&udc->op_regs->usbsts);
+        intr = readl(&udc->op_regs->usbintr);
+        status &= intr;
+
+        if (status == 0) {
+                spin_unlock(&udc->lock);
+                return IRQ_NONE;
+        }
+
+        /* Clear all the interrupts occured */
+        writel(status, &udc->op_regs->usbsts);
+
+        if (status & USBSTS_ERR)
+                irq_process_error(udc);
+
+        if (status & USBSTS_RESET)
+                irq_process_reset(udc);
+
+        if (status & USBSTS_PORT_CHANGE)
+                irq_process_port_change(udc);
+
+        if (status & USBSTS_INT)
+                irq_process_tr_complete(udc);
+
+        if (status & USBSTS_SUSPEND)
+                irq_process_suspend(udc);
+
+        spin_unlock(&udc->lock);
+
+        return IRQ_HANDLED;
+}
+
+/* release device structure */
+static void gadget_release(struct device *_dev)
+{
+        struct mv_udc *udc = the_controller;
+
+        complete(udc->done);
+        kfree(udc);
+}
+
+static int mv_udc_remove(struct platform_device *dev)
+{
+        struct mv_udc *udc = the_controller;
+
+        DECLARE_COMPLETION(done);
+
+        udc->done = &done;
+
+        /* free memory allocated in probe */
+        if (udc->dtd_pool)
+                dma_pool_destroy(udc->dtd_pool);
+
+        if (udc->ep_dqh)
+                dma_free_coherent(&dev->dev, udc->ep_dqh_size,
+                        udc->ep_dqh, udc->ep_dqh_dma);
+
+        kfree(udc->eps);
+
+        if (udc->irq)
+                free_irq(udc->irq, &dev->dev);
+
+        if (udc->cap_regs)
+                iounmap(udc->cap_regs);
+        udc->cap_regs = NULL;
+
+        if (udc->phy_regs)
+                iounmap((void *)udc->phy_regs);
+        udc->phy_regs = 0;
+
+        if (udc->status_req) {
+                kfree(udc->status_req->req.buf);
+                kfree(udc->status_req);
+        }
+
+        device_unregister(&udc->gadget.dev);
+
+        /* free dev, wait for the release() finished */
+        wait_for_completion(&done);
+
+        the_controller = NULL;
+
+        return 0;
+}
+
+int mv_udc_probe(struct platform_device *dev)
+{
+        struct mv_udc *udc;
+        int retval = 0;
+        struct resource *r;
+        size_t size;
+
+        udc = kzalloc(sizeof *udc, GFP_KERNEL);
+        if (udc == NULL) {
+                dev_err(&dev->dev, "failed to allocate memory for udc\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        spin_lock_init(&udc->lock);
+
+        udc->dev = dev;
+
+        udc->clk = clk_get(&dev->dev, "U2OCLK");
+        if (IS_ERR(udc->clk)) {
+                retval = PTR_ERR(udc->clk);
+                goto error;
+        }
+
+        r = platform_get_resource_byname(udc->dev, IORESOURCE_MEM, "u2o");
+        if (r == NULL) {
+                dev_err(&dev->dev, "no I/O memory resource defined\n");
+                retval = -ENODEV;
+                goto error;
+        }
+
+        udc->cap_regs = (struct mv_cap_regs __iomem *)
+                ioremap(r->start, resource_size(r));
+        if (udc->cap_regs == NULL) {
+                dev_err(&dev->dev, "failed to map I/O memory\n");
+                retval = -EBUSY;
+                goto error;
+        }
+
+        r = platform_get_resource_byname(udc->dev, IORESOURCE_MEM, "u2ophy");
+        if (r == NULL) {
+                dev_err(&dev->dev, "no phy I/O memory resource defined\n");
+                retval = -ENODEV;
+                goto error;
+        }
+
+        udc->phy_regs = (unsigned int)ioremap(r->start, resource_size(r));
+        if (udc->phy_regs == 0) {
+                dev_err(&dev->dev, "failed to map phy I/O memory\n");
+                retval = -EBUSY;
+                goto error;
+        }
+
+        /* we will acces controller register, so enable the clk */
+        clk_enable(udc->clk);
+        retval = mv_udc_phy_init(udc->phy_regs);
+        if (retval) {
+                dev_err(&dev->dev, "phy initialization error %d\n", retval);
+                goto error;
+        }
+
+        udc->op_regs = (struct mv_op_regs __iomem *)((u32)udc->cap_regs
+                + (readl(&udc->cap_regs->caplength_hciversion)
+                        & CAPLENGTH_MASK));
+        udc->max_eps = readl(&udc->cap_regs->dccparams) & DCCPARAMS_DEN_MASK;
+
+        size = udc->max_eps * sizeof(struct mv_dqh) *2;
+        size = (size + DQH_ALIGNMENT - 1) & ~(DQH_ALIGNMENT - 1);
+        udc->ep_dqh = dma_alloc_coherent(&dev->dev, size,
+                                        &udc->ep_dqh_dma, GFP_KERNEL);
+
+        if (udc->ep_dqh == NULL) {
+                dev_err(&dev->dev, "allocate dQH memory failed\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+        udc->ep_dqh_size = size;
+
+        /* create dTD dma_pool resource */
+        udc->dtd_pool = dma_pool_create("mv_dtd",
+                        &dev->dev,
+                        sizeof(struct mv_dtd),
+                        DTD_ALIGNMENT,
+                        DMA_BOUNDARY);
+
+        if (!udc->dtd_pool) {
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        size = udc->max_eps * sizeof(struct mv_ep) *2;
+        udc->eps = kzalloc(size, GFP_KERNEL);
+        if (udc->eps == NULL) {
+                dev_err(&dev->dev, "allocate ep memory failed\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+
+        /* initialize ep0 status request structure */
+        udc->status_req = kzalloc(sizeof(struct mv_req), GFP_KERNEL);
+        if (!udc->status_req) {
+                dev_err(&dev->dev, "allocate status_req memory failed\n");
+                retval = -ENOMEM;
+                goto error;
+        }
+        INIT_LIST_HEAD(&udc->status_req->queue);
+
+        /* allocate a small amount of memory to get valid address */
+        udc->status_req->req.buf = kzalloc(8, GFP_KERNEL);
+        udc->status_req->req.dma = virt_to_phys(udc->status_req->req.buf);
+
+        udc->resume_state = USB_STATE_NOTATTACHED;
+        udc->usb_state = USB_STATE_POWERED;
+        udc->ep0_dir = EP_DIR_OUT;
+        udc->remote_wakeup = 0;
+
+        r = platform_get_resource(udc->dev, IORESOURCE_IRQ, 0);
+        if (r == NULL) {
+                dev_err(&dev->dev, "no IRQ resource defined\n");
+                retval = -ENODEV;
+                goto error;
+        }
+        udc->irq = r->start;
+        if (request_irq(udc->irq, mv_udc_irq,
+                IRQF_DISABLED | IRQF_SHARED, driver_name, udc)) {
+                dev_err(&dev->dev, "Request irq %d for UDC failed\n",
+                        udc->irq);
+                retval = -ENODEV;
+                goto error;
+        }
+
+        /* initialize gadget structure */
+        udc->gadget.ops = &mv_ops;      /* usb_gadget_ops */
+        udc->gadget.ep0 = &udc->eps[0].ep;      /* gadget ep0 */
+        INIT_LIST_HEAD(&udc->gadget.ep_list);   /* ep_list */
+        udc->gadget.speed = USB_SPEED_UNKNOWN;  /* speed */
+        udc->gadget.is_dualspeed = 1;           /* support dual speed */
+
+        /* the "gadget" abstracts/virtualizes the controller */
+        dev_set_name(&udc->gadget.dev, "gadget");
+        udc->gadget.dev.parent = &dev->dev;
+        udc->gadget.dev.dma_mask = dev->dev.dma_mask;
+        udc->gadget.dev.release = gadget_release;
+        udc->gadget.name = driver_name;         /* gadget name */
+
+        retval = device_register(&udc->gadget.dev);
+        if (retval)
+                goto error;
+
+        eps_init(udc);
+
+        the_controller = udc;
+
+        goto out;
+error:
+        if (udc)
+                mv_udc_remove(udc->dev);
+out:
+        return retval;
+}
+
+#ifdef CONFIG_PM
+static int mv_udc_suspend(struct platform_device *_dev, pm_message_t state)
+{
+        struct mv_udc *udc = the_controller;
+
+        udc_stop(udc);
+
+        return 0;
+}
+
+static int mv_udc_resume(struct platform_device *_dev)
+{
+        struct mv_udc *udc = the_controller;
+        int retval;
+
+        retval = mv_udc_phy_init(udc->phy_regs);
+        if (retval) {
+                dev_err(_dev, "phy initialization error %d\n", retval);
+                goto error;
+        }
+        udc_reset(udc);
+        ep0_reset(udc);
+        udc_start(udc);
+
+        return 0;
+}
+
+static const struct dev_pm_ops mv_udc_pm_ops = {
+        .suspend        = mv_udc_suspend,
+        .resume         = mv_udc_resume,
+};
+#endif
+
+static struct platform_driver udc_driver = {
+        .probe          = mv_udc_probe,
+        .remove         = __exit_p(mv_udc_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "pxa-u2o",
+#ifdef CONFIG_PM
+                .pm     = mv_udc_pm_ops,
+#endif
+        },
+};
+
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Chao Xie <chao.xie@marvell.com>");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+
+
+static int __init init(void)
+{
+        return platform_driver_register(&udc_driver);
+}
+module_init(init);
+
+
+static void __exit cleanup(void)
+{
+        platform_driver_unregister(&udc_driver);
+}
+module_exit(cleanup);
+
diff --git a/drivers/usb/gadget/mv_udc_phy.c b/drivers/usb/gadget/mv_udc_phy.c
new file mode 100644
index 000000000000..d4dea97e38a5
--- /dev/null
+++ b/drivers/usb/gadget/mv_udc_phy.c
@@ -0,0 +1,214 @@
+#include <linux/delay.h>
+#include <linux/timer.h>
+#include <linux/io.h>
+#include <linux/errno.h>
+
+#include <mach/cputype.h>
+
+#ifdef CONFIG_ARCH_MMP
+
+#define UTMI_REVISION           0x0
+#define UTMI_CTRL               0x4
+#define UTMI_PLL                0x8
+#define UTMI_TX                 0xc
+#define UTMI_RX                 0x10
+#define UTMI_IVREF              0x14
+#define UTMI_T0                 0x18
+#define UTMI_T1                 0x1c
+#define UTMI_T2                 0x20
+#define UTMI_T3                 0x24
+#define UTMI_T4                 0x28
+#define UTMI_T5                 0x2c
+#define UTMI_RESERVE            0x30
+#define UTMI_USB_INT            0x34
+#define UTMI_DBG_CTL            0x38
+#define UTMI_OTG_ADDON          0x3c
+
+/* For UTMICTRL Register */
+#define UTMI_CTRL_USB_CLK_EN                    (1 << 31)
+/* pxa168 */
+#define UTMI_CTRL_SUSPEND_SET1                  (1 << 30)
+#define UTMI_CTRL_SUSPEND_SET2                  (1 << 29)
+#define UTMI_CTRL_RXBUF_PDWN                    (1 << 24)
+#define UTMI_CTRL_TXBUF_PDWN                    (1 << 11)
+
+#define UTMI_CTRL_INPKT_DELAY_SHIFT             30
+#define UTMI_CTRL_INPKT_DELAY_SOF_SHIFT         28
+#define UTMI_CTRL_PU_REF_SHIFT                  20
+#define UTMI_CTRL_ARC_PULLDN_SHIFT              12
+#define UTMI_CTRL_PLL_PWR_UP_SHIFT              1
+#define UTMI_CTRL_PWR_UP_SHIFT                  0
+/* For UTMI_PLL Register */
+#define UTMI_PLL_CLK_BLK_EN_SHIFT               24
+#define UTMI_PLL_FBDIV_SHIFT                    4
+#define UTMI_PLL_REFDIV_SHIFT                   0
+#define UTMI_PLL_FBDIV_MASK                     0x00000FF0
+#define UTMI_PLL_REFDIV_MASK                    0x0000000F
+#define UTMI_PLL_ICP_MASK                       0x00007000
+#define UTMI_PLL_KVCO_MASK                      0x00031000
+#define UTMI_PLL_PLLCALI12_SHIFT                29
+#define UTMI_PLL_PLLCALI12_MASK                 (0x3 << 29)
+#define UTMI_PLL_PLLVDD18_SHIFT                 27
+#define UTMI_PLL_PLLVDD18_MASK                  (0x3 << 27)
+#define UTMI_PLL_PLLVDD12_SHIFT                 25
+#define UTMI_PLL_PLLVDD12_MASK                  (0x3 << 25)
+#define UTMI_PLL_KVCO_SHIFT                     15
+#define UTMI_PLL_ICP_SHIFT                      12
+/* For UTMI_TX Register */
+#define UTMI_TX_REG_EXT_FS_RCAL_SHIFT           27
+#define UTMI_TX_REG_EXT_FS_RCAL_MASK            (0xf << 27)
+#define UTMI_TX_REG_EXT_FS_RCAL_EN_MASK         26
+#define UTMI_TX_REG_EXT_FS_RCAL_EN              (0x1 << 26)
+#define UTMI_TX_LOW_VDD_EN_SHIFT                11
+#define UTMI_TX_IMPCAL_VTH_SHIFT                14
+#define UTMI_TX_IMPCAL_VTH_MASK                 (0x7 << 14)
+#define UTMI_TX_CK60_PHSEL_SHIFT                17
+#define UTMI_TX_CK60_PHSEL_MASK                 (0xf << 17)
+#define UTMI_TX_TXVDD12_SHIFT                   22
+#define UTMI_TX_TXVDD12_MASK                    (0x3 << 22)
+#define UTMI_TX_AMP_SHIFT                       0
+#define UTMI_TX_AMP_MASK                        (0x7 << 0)
+/* For UTMI_RX Register */
+#define UTMI_RX_SQ_THRESH_SHIFT                 4
+#define UTMI_RX_SQ_THRESH_MASK                  (0xf << 4)
+#define UTMI_REG_SQ_LENGTH_SHIFT                15
+#define UTMI_REG_SQ_LENGTH_MASK                 (0x3 << 15)
+
+#define REG_RCAL_START                          0x00001000
+#define VCOCAL_START                            0x00200000
+#define KVCO_EXT                                0x00400000
+#define PLL_READY                               0x00800000
+#define CLK_BLK_EN                              0x01000000
+#endif
+
+static unsigned int u2o_read(unsigned int base, unsigned int offset)
+{
+        return readl(base + offset);
+}
+
+static void u2o_set(unsigned int base, unsigned int offset, unsigned int value)
+{
+        unsigned int reg;
+
+        reg = readl(base + offset);
+        reg |= value;
+        writel(reg, base + offset);
+        readl(base + offset);
+}
+
+static void u2o_clear(unsigned int base, unsigned int offset,
+        unsigned int value)
+{
+        unsigned int reg;
+
+        reg = readl(base + offset);
+        reg &= ~value;
+        writel(reg, base + offset);
+        readl(base + offset);
+}
+
+static void u2o_write(unsigned int base, unsigned int offset,
+        unsigned int value)
+{
+        writel(value, base + offset);
+        readl(base + offset);
+}
+
+#ifdef CONFIG_ARCH_MMP
+int mv_udc_phy_init(unsigned int base)
+{
+        unsigned long timeout;
+
+        /* Initialize the USB PHY power */
+        if (cpu_is_pxa910()) {
+                u2o_set(base, UTMI_CTRL, (1 << UTMI_CTRL_INPKT_DELAY_SOF_SHIFT)
+                        | (1 << UTMI_CTRL_PU_REF_SHIFT));
+        }
+
+        u2o_set(base, UTMI_CTRL, 1 << UTMI_CTRL_PLL_PWR_UP_SHIFT);
+        u2o_set(base, UTMI_CTRL, 1 << UTMI_CTRL_PWR_UP_SHIFT);
+
+        /* UTMI_PLL settings */
+        u2o_clear(base, UTMI_PLL, UTMI_PLL_PLLVDD18_MASK
+                | UTMI_PLL_PLLVDD12_MASK | UTMI_PLL_PLLCALI12_MASK
+                | UTMI_PLL_FBDIV_MASK | UTMI_PLL_REFDIV_MASK
+                | UTMI_PLL_ICP_MASK | UTMI_PLL_KVCO_MASK);
+
+        u2o_set(base, UTMI_PLL, (0xee << UTMI_PLL_FBDIV_SHIFT)
+                | (0xb << UTMI_PLL_REFDIV_SHIFT)
+                | (3 << UTMI_PLL_PLLVDD18_SHIFT)
+                | (3 << UTMI_PLL_PLLVDD12_SHIFT)
+                | (3 << UTMI_PLL_PLLCALI12_SHIFT)
+                | (1 << UTMI_PLL_ICP_SHIFT) | (3 << UTMI_PLL_KVCO_SHIFT));
+
+        /* UTMI_TX */
+        u2o_clear(base, UTMI_TX, UTMI_TX_REG_EXT_FS_RCAL_EN_MASK
+                | UTMI_TX_TXVDD12_MASK
+                | UTMI_TX_CK60_PHSEL_MASK | UTMI_TX_IMPCAL_VTH_MASK
+                | UTMI_TX_REG_EXT_FS_RCAL_MASK | UTMI_TX_AMP_MASK);
+        u2o_set(base, UTMI_TX, (3 << UTMI_TX_TXVDD12_SHIFT)
+                | (4 << UTMI_TX_CK60_PHSEL_SHIFT)
+                | (4 << UTMI_TX_IMPCAL_VTH_SHIFT)
+                | (8 << UTMI_TX_REG_EXT_FS_RCAL_SHIFT)
+                | (3 << UTMI_TX_AMP_SHIFT));
+
+        /* UTMI_RX */
+        u2o_clear(base, UTMI_RX, UTMI_RX_SQ_THRESH_MASK
+                | UTMI_REG_SQ_LENGTH_MASK);
+        if (cpu_is_pxa168())
+                u2o_set(base, UTMI_RX, (7 << UTMI_RX_SQ_THRESH_SHIFT)
+                        | (2 << UTMI_REG_SQ_LENGTH_SHIFT));
+        else
+                u2o_set(base, UTMI_RX, (0x7 << UTMI_RX_SQ_THRESH_SHIFT)
+                        | (2 << UTMI_REG_SQ_LENGTH_SHIFT));
+
+        /* UTMI_IVREF */
+        if (cpu_is_pxa168())
+                /*
+                 * fixing Microsoft Altair board interface with NEC hub issue -
+                 * Set UTMI_IVREF from 0x4a3 to 0x4bf
+                 */
+                u2o_write(base, UTMI_IVREF, 0x4bf);
+
+        /* calibrate */
+        timeout = jiffies + 100;
+        while ((u2o_read(base, UTMI_PLL) & PLL_READY) == 0) {
+                if (time_after(jiffies, timeout))
+                        return -ETIME;
+                cpu_relax();
+        }
+
+        /* toggle VCOCAL_START bit of UTMI_PLL */
+        udelay(200);
+        u2o_set(base, UTMI_PLL, VCOCAL_START);
+        udelay(40);
+        u2o_clear(base, UTMI_PLL, VCOCAL_START);
+
+        /* toggle REG_RCAL_START bit of UTMI_TX */
+        udelay(200);
+        u2o_set(base, UTMI_TX, REG_RCAL_START);
+        udelay(40);
+        u2o_clear(base, UTMI_TX, REG_RCAL_START);
+        udelay(200);
+
+        /* make sure phy is ready */
+        timeout = jiffies + 100;
+        while ((u2o_read(base, UTMI_PLL) & PLL_READY) == 0) {
+                if (time_after(jiffies, timeout))
+                        return -ETIME;
+                cpu_relax();
+        }
+
+        if (cpu_is_pxa168()) {
+                u2o_set(base, UTMI_RESERVE, 1 << 5);
+                /* Turn on UTMI PHY OTG extension */
+                u2o_write(base, UTMI_OTG_ADDON, 1);
+        }
+        return 0;
+}
+#else
+int mv_udc_phy_init(unsigned int base)
+{
+        return 0;
+}
+#endif
diff --git a/drivers/usb/gadget/ncm.c b/drivers/usb/gadget/ncm.c
new file mode 100644
index 000000000000..99c179ad729d
--- /dev/null
+++ b/drivers/usb/gadget/ncm.c
@@ -0,0 +1,248 @@
+/*
+ * ncm.c -- NCM gadget driver
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
+ *
+ * The driver borrows from ether.c which is:
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* #define DEBUG */
+/* #define VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+
+
+#include "u_ether.h"
+
+#define DRIVER_DESC             "NCM Gadget"
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Kbuild is not very cooperative with respect to linking separately
+ * compiled library objects into one module.  So for now we won't use
+ * separate compilation ... ensuring init/exit sections work to shrink
+ * the runtime footprint, and giving us at least some parts of what
+ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ */
+#include "composite.c"
+#include "usbstring.c"
+#include "config.c"
+#include "epautoconf.c"
+
+#include "f_ncm.c"
+#include "u_ether.c"
+
+/*-------------------------------------------------------------------------*/
+
+/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
+ * Instead:  allocate your own, using normal USB-IF procedures.
+ */
+
+/* Thanks to NetChip Technologies for donating this product ID.
+ * It's for devices with only CDC Ethernet configurations.
+ */
+#define CDC_VENDOR_NUM          0x0525  /* NetChip */
+#define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_device_descriptor device_desc = {
+        .bLength =              sizeof device_desc,
+        .bDescriptorType =      USB_DT_DEVICE,
+
+        .bcdUSB =               cpu_to_le16 (0x0200),
+
+        .bDeviceClass =         USB_CLASS_COMM,
+        .bDeviceSubClass =      0,
+        .bDeviceProtocol =      0,
+        /* .bMaxPacketSize0 = f(hardware) */
+
+        /* Vendor and product id defaults change according to what configs
+         * we support.  (As does bNumConfigurations.)  These values can
+         * also be overridden by module parameters.
+         */
+        .idVendor =             cpu_to_le16 (CDC_VENDOR_NUM),
+        .idProduct =            cpu_to_le16 (CDC_PRODUCT_NUM),
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        /* NO SERIAL NUMBER */
+        .bNumConfigurations =   1,
+};
+
+static struct usb_otg_descriptor otg_descriptor = {
+        .bLength =              sizeof otg_descriptor,
+        .bDescriptorType =      USB_DT_OTG,
+
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header *otg_desc[] = {
+        (struct usb_descriptor_header *) &otg_descriptor,
+        NULL,
+};
+
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+static u8 hostaddr[ETH_ALEN];
+
+/*-------------------------------------------------------------------------*/
+
+static int __init ncm_do_config(struct usb_configuration *c)
+{
+        /* FIXME alloc iConfiguration string, set it in c->strings */
+
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        return ncm_bind_config(c, hostaddr);
+}
+
+static struct usb_configuration ncm_config_driver = {
+        /* .label = f(hardware) */
+        .label                  = "CDC Ethernet (NCM)",
+        .bConfigurationValue    = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init gncm_bind(struct usb_composite_dev *cdev)
+{
+        int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     status;
+
+        /* set up network link layer */
+        status = gether_setup(cdev->gadget, hostaddr);
+        if (status < 0)
+                return status;
+
+        gcnum = usb_gadget_controller_number(gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
+        else {
+                /* We assume that can_support_ecm() tells the truth;
+                 * but if the controller isn't recognized at all then
+                 * that assumption is a bit more likely to be wrong.
+                 */
+                dev_warn(&gadget->dev,
+                         "controller '%s' not recognized; trying %s\n",
+                         gadget->name,
+                         ncm_config_driver.label);
+                device_desc.bcdDevice =
+                        cpu_to_le16(0x0300 | 0x0099);
+        }
+
+
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
+         */
+
+        /* device descriptor strings: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                init_utsname()->sysname, init_utsname()->release,
+                gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+        device_desc.iManufacturer = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+        device_desc.iProduct = status;
+
+        status = usb_add_config(cdev, &ncm_config_driver,
+                                ncm_do_config);
+        if (status < 0)
+                goto fail;
+
+        dev_info(&gadget->dev, "%s\n", DRIVER_DESC);
+
+        return 0;
+
+fail:
+        gether_cleanup();
+        return status;
+}
+
+static int __exit gncm_unbind(struct usb_composite_dev *cdev)
+{
+        gether_cleanup();
+        return 0;
+}
+
+static struct usb_composite_driver ncm_driver = {
+        .name           = "g_ncm",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
+        .unbind         = __exit_p(gncm_unbind),
+};
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Yauheni Kaliuta");
+MODULE_LICENSE("GPL");
+
+static int __init init(void)
+{
+        return usb_composite_probe(&ncm_driver, gncm_bind);
+}
+module_init(init);
+
+static void __exit cleanup(void)
+{
+        usb_composite_unregister(&ncm_driver);
+}
+module_exit(cleanup);
diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
new file mode 100644
index 000000000000..0c8dd81dddca
--- /dev/null
+++ b/drivers/usb/gadget/pch_udc.c
@@ -0,0 +1,2947 @@
+/*
+ * Copyright (C) 2010 OKI SEMICONDUCTOR CO., 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; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+/* Address offset of Registers */
+#define UDC_EP_REG_SHIFT        0x20    /* Offset to next EP */
+
+#define UDC_EPCTL_ADDR          0x00    /* Endpoint control */
+#define UDC_EPSTS_ADDR          0x04    /* Endpoint status */
+#define UDC_BUFIN_FRAMENUM_ADDR 0x08    /* buffer size in / frame number out */
+#define UDC_BUFOUT_MAXPKT_ADDR  0x0C    /* buffer size out / maxpkt in */
+#define UDC_SUBPTR_ADDR         0x10    /* setup buffer pointer */
+#define UDC_DESPTR_ADDR         0x14    /* Data descriptor pointer */
+#define UDC_CONFIRM_ADDR        0x18    /* Write/Read confirmation */
+
+#define UDC_DEVCFG_ADDR         0x400   /* Device configuration */
+#define UDC_DEVCTL_ADDR         0x404   /* Device control */
+#define UDC_DEVSTS_ADDR         0x408   /* Device status */
+#define UDC_DEVIRQSTS_ADDR      0x40C   /* Device irq status */
+#define UDC_DEVIRQMSK_ADDR      0x410   /* Device irq mask */
+#define UDC_EPIRQSTS_ADDR       0x414   /* Endpoint irq status */
+#define UDC_EPIRQMSK_ADDR       0x418   /* Endpoint irq mask */
+#define UDC_DEVLPM_ADDR         0x41C   /* LPM control / status */
+#define UDC_CSR_BUSY_ADDR       0x4f0   /* UDC_CSR_BUSY Status register */
+#define UDC_SRST_ADDR           0x4fc   /* SOFT RESET register */
+#define UDC_CSR_ADDR            0x500   /* USB_DEVICE endpoint register */
+
+/* Endpoint control register */
+/* Bit position */
+#define UDC_EPCTL_MRXFLUSH              (1 << 12)
+#define UDC_EPCTL_RRDY                  (1 << 9)
+#define UDC_EPCTL_CNAK                  (1 << 8)
+#define UDC_EPCTL_SNAK                  (1 << 7)
+#define UDC_EPCTL_NAK                   (1 << 6)
+#define UDC_EPCTL_P                     (1 << 3)
+#define UDC_EPCTL_F                     (1 << 1)
+#define UDC_EPCTL_S                     (1 << 0)
+#define UDC_EPCTL_ET_SHIFT              4
+/* Mask patern */
+#define UDC_EPCTL_ET_MASK               0x00000030
+/* Value for ET field */
+#define UDC_EPCTL_ET_CONTROL            0
+#define UDC_EPCTL_ET_ISO                1
+#define UDC_EPCTL_ET_BULK               2
+#define UDC_EPCTL_ET_INTERRUPT          3
+
+/* Endpoint status register */
+/* Bit position */
+#define UDC_EPSTS_XFERDONE              (1 << 27)
+#define UDC_EPSTS_RSS                   (1 << 26)
+#define UDC_EPSTS_RCS                   (1 << 25)
+#define UDC_EPSTS_TXEMPTY               (1 << 24)
+#define UDC_EPSTS_TDC                   (1 << 10)
+#define UDC_EPSTS_HE                    (1 << 9)
+#define UDC_EPSTS_MRXFIFO_EMP           (1 << 8)
+#define UDC_EPSTS_BNA                   (1 << 7)
+#define UDC_EPSTS_IN                    (1 << 6)
+#define UDC_EPSTS_OUT_SHIFT             4
+/* Mask patern */
+#define UDC_EPSTS_OUT_MASK              0x00000030
+#define UDC_EPSTS_ALL_CLR_MASK          0x1F0006F0
+/* Value for OUT field */
+#define UDC_EPSTS_OUT_SETUP             2
+#define UDC_EPSTS_OUT_DATA              1
+
+/* Device configuration register */
+/* Bit position */
+#define UDC_DEVCFG_CSR_PRG              (1 << 17)
+#define UDC_DEVCFG_SP                   (1 << 3)
+/* SPD Valee */
+#define UDC_DEVCFG_SPD_HS               0x0
+#define UDC_DEVCFG_SPD_FS               0x1
+#define UDC_DEVCFG_SPD_LS               0x2
+
+/* Device control register */
+/* Bit position */
+#define UDC_DEVCTL_THLEN_SHIFT          24
+#define UDC_DEVCTL_BRLEN_SHIFT          16
+#define UDC_DEVCTL_CSR_DONE             (1 << 13)
+#define UDC_DEVCTL_SD                   (1 << 10)
+#define UDC_DEVCTL_MODE                 (1 << 9)
+#define UDC_DEVCTL_BREN                 (1 << 8)
+#define UDC_DEVCTL_THE                  (1 << 7)
+#define UDC_DEVCTL_DU                   (1 << 4)
+#define UDC_DEVCTL_TDE                  (1 << 3)
+#define UDC_DEVCTL_RDE                  (1 << 2)
+#define UDC_DEVCTL_RES                  (1 << 0)
+
+/* Device status register */
+/* Bit position */
+#define UDC_DEVSTS_TS_SHIFT             18
+#define UDC_DEVSTS_ENUM_SPEED_SHIFT     13
+#define UDC_DEVSTS_ALT_SHIFT            8
+#define UDC_DEVSTS_INTF_SHIFT           4
+#define UDC_DEVSTS_CFG_SHIFT            0
+/* Mask patern */
+#define UDC_DEVSTS_TS_MASK              0xfffc0000
+#define UDC_DEVSTS_ENUM_SPEED_MASK      0x00006000
+#define UDC_DEVSTS_ALT_MASK             0x00000f00
+#define UDC_DEVSTS_INTF_MASK            0x000000f0
+#define UDC_DEVSTS_CFG_MASK             0x0000000f
+/* value for maximum speed for SPEED field */
+#define UDC_DEVSTS_ENUM_SPEED_FULL      1
+#define UDC_DEVSTS_ENUM_SPEED_HIGH      0
+#define UDC_DEVSTS_ENUM_SPEED_LOW       2
+#define UDC_DEVSTS_ENUM_SPEED_FULLX     3
+
+/* Device irq register */
+/* Bit position */
+#define UDC_DEVINT_RWKP                 (1 << 7)
+#define UDC_DEVINT_ENUM                 (1 << 6)
+#define UDC_DEVINT_SOF                  (1 << 5)
+#define UDC_DEVINT_US                   (1 << 4)
+#define UDC_DEVINT_UR                   (1 << 3)
+#define UDC_DEVINT_ES                   (1 << 2)
+#define UDC_DEVINT_SI                   (1 << 1)
+#define UDC_DEVINT_SC                   (1 << 0)
+/* Mask patern */
+#define UDC_DEVINT_MSK                  0x7f
+
+/* Endpoint irq register */
+/* Bit position */
+#define UDC_EPINT_IN_SHIFT              0
+#define UDC_EPINT_OUT_SHIFT             16
+#define UDC_EPINT_IN_EP0                (1 << 0)
+#define UDC_EPINT_OUT_EP0               (1 << 16)
+/* Mask patern */
+#define UDC_EPINT_MSK_DISABLE_ALL       0xffffffff
+
+/* UDC_CSR_BUSY Status register */
+/* Bit position */
+#define UDC_CSR_BUSY                    (1 << 0)
+
+/* SOFT RESET register */
+/* Bit position */
+#define UDC_PSRST                       (1 << 1)
+#define UDC_SRST                        (1 << 0)
+
+/* USB_DEVICE endpoint register */
+/* Bit position */
+#define UDC_CSR_NE_NUM_SHIFT            0
+#define UDC_CSR_NE_DIR_SHIFT            4
+#define UDC_CSR_NE_TYPE_SHIFT           5
+#define UDC_CSR_NE_CFG_SHIFT            7
+#define UDC_CSR_NE_INTF_SHIFT           11
+#define UDC_CSR_NE_ALT_SHIFT            15
+#define UDC_CSR_NE_MAX_PKT_SHIFT        19
+/* Mask patern */
+#define UDC_CSR_NE_NUM_MASK             0x0000000f
+#define UDC_CSR_NE_DIR_MASK             0x00000010
+#define UDC_CSR_NE_TYPE_MASK            0x00000060
+#define UDC_CSR_NE_CFG_MASK             0x00000780
+#define UDC_CSR_NE_INTF_MASK            0x00007800
+#define UDC_CSR_NE_ALT_MASK             0x00078000
+#define UDC_CSR_NE_MAX_PKT_MASK         0x3ff80000
+
+#define PCH_UDC_CSR(ep) (UDC_CSR_ADDR + ep*4)
+#define PCH_UDC_EPINT(in, num)\
+                (1 << (num + (in ? UDC_EPINT_IN_SHIFT : UDC_EPINT_OUT_SHIFT)))
+
+/* Index of endpoint */
+#define UDC_EP0IN_IDX           0
+#define UDC_EP0OUT_IDX          1
+#define UDC_EPIN_IDX(ep)        (ep * 2)
+#define UDC_EPOUT_IDX(ep)       (ep * 2 + 1)
+#define PCH_UDC_EP0             0
+#define PCH_UDC_EP1             1
+#define PCH_UDC_EP2             2
+#define PCH_UDC_EP3             3
+
+/* Number of endpoint */
+#define PCH_UDC_EP_NUM          32      /* Total number of EPs (16 IN,16 OUT) */
+#define PCH_UDC_USED_EP_NUM     4       /* EP number of EP's really used */
+/* Length Value */
+#define PCH_UDC_BRLEN           0x0F    /* Burst length */
+#define PCH_UDC_THLEN           0x1F    /* Threshold length */
+/* Value of EP Buffer Size */
+#define UDC_EP0IN_BUFF_SIZE     64
+#define UDC_EPIN_BUFF_SIZE      512
+#define UDC_EP0OUT_BUFF_SIZE    64
+#define UDC_EPOUT_BUFF_SIZE     512
+/* Value of EP maximum packet size */
+#define UDC_EP0IN_MAX_PKT_SIZE  64
+#define UDC_EP0OUT_MAX_PKT_SIZE 64
+#define UDC_BULK_MAX_PKT_SIZE   512
+
+/* DMA */
+#define DMA_DIR_RX              1       /* DMA for data receive */
+#define DMA_DIR_TX              2       /* DMA for data transmit */
+#define DMA_ADDR_INVALID        (~(dma_addr_t)0)
+#define UDC_DMA_MAXPACKET       65536   /* maximum packet size for DMA */
+
+/**
+ * struct pch_udc_data_dma_desc - Structure to hold DMA descriptor information
+ *                                for data
+ * @status:             Status quadlet
+ * @reserved:           Reserved
+ * @dataptr:            Buffer descriptor
+ * @next:               Next descriptor
+ */
+struct pch_udc_data_dma_desc {
+        u32 status;
+        u32 reserved;
+        u32 dataptr;
+        u32 next;
+};
+
+/**
+ * struct pch_udc_stp_dma_desc - Structure to hold DMA descriptor information
+ *                               for control data
+ * @status:     Status
+ * @reserved:   Reserved
+ * @data12:     First setup word
+ * @data34:     Second setup word
+ */
+struct pch_udc_stp_dma_desc {
+        u32 status;
+        u32 reserved;
+        struct usb_ctrlrequest request;
+} __attribute((packed));
+
+/* DMA status definitions */
+/* Buffer status */
+#define PCH_UDC_BUFF_STS        0xC0000000
+#define PCH_UDC_BS_HST_RDY      0x00000000
+#define PCH_UDC_BS_DMA_BSY      0x40000000
+#define PCH_UDC_BS_DMA_DONE     0x80000000
+#define PCH_UDC_BS_HST_BSY      0xC0000000
+/*  Rx/Tx Status */
+#define PCH_UDC_RXTX_STS        0x30000000
+#define PCH_UDC_RTS_SUCC        0x00000000
+#define PCH_UDC_RTS_DESERR      0x10000000
+#define PCH_UDC_RTS_BUFERR      0x30000000
+/* Last Descriptor Indication */
+#define PCH_UDC_DMA_LAST        0x08000000
+/* Number of Rx/Tx Bytes Mask */
+#define PCH_UDC_RXTX_BYTES      0x0000ffff
+
+/**
+ * struct pch_udc_cfg_data - Structure to hold current configuration
+ *                           and interface information
+ * @cur_cfg:    current configuration in use
+ * @cur_intf:   current interface in use
+ * @cur_alt:    current alt interface in use
+ */
+struct pch_udc_cfg_data {
+        u16 cur_cfg;
+        u16 cur_intf;
+        u16 cur_alt;
+};
+
+/**
+ * struct pch_udc_ep - Structure holding a PCH USB device Endpoint information
+ * @ep:                 embedded ep request
+ * @td_stp_phys:        for setup request
+ * @td_data_phys:       for data request
+ * @td_stp:             for setup request
+ * @td_data:            for data request
+ * @dev:                reference to device struct
+ * @offset_addr:        offset address of ep register
+ * @desc:               for this ep
+ * @queue:              queue for requests
+ * @num:                endpoint number
+ * @in:                 endpoint is IN
+ * @halted:             endpoint halted?
+ * @epsts:              Endpoint status
+ */
+struct pch_udc_ep {
+        struct usb_ep                   ep;
+        dma_addr_t                      td_stp_phys;
+        dma_addr_t                      td_data_phys;
+        struct pch_udc_stp_dma_desc     *td_stp;
+        struct pch_udc_data_dma_desc    *td_data;
+        struct pch_udc_dev              *dev;
+        unsigned long                   offset_addr;
+        const struct usb_endpoint_descriptor    *desc;
+        struct list_head                queue;
+        unsigned                        num:5,
+                                        in:1,
+                                        halted:1;
+        unsigned long                   epsts;
+};
+
+/**
+ * struct pch_udc_dev - Structure holding complete information
+ *                      of the PCH USB device
+ * @gadget:             gadget driver data
+ * @driver:             reference to gadget driver bound
+ * @pdev:               reference to the PCI device
+ * @ep:                 array of endpoints
+ * @lock:               protects all state
+ * @active:             enabled the PCI device
+ * @stall:              stall requested
+ * @prot_stall:         protcol stall requested
+ * @irq_registered:     irq registered with system
+ * @mem_region:         device memory mapped
+ * @registered:         driver regsitered with system
+ * @suspended:          driver in suspended state
+ * @connected:          gadget driver associated
+ * @set_cfg_not_acked:  pending acknowledgement 4 setup
+ * @waiting_zlp_ack:    pending acknowledgement 4 ZLP
+ * @data_requests:      DMA pool for data requests
+ * @stp_requests:       DMA pool for setup requests
+ * @dma_addr:           DMA pool for received
+ * @ep0out_buf:         Buffer for DMA
+ * @setup_data:         Received setup data
+ * @phys_addr:          of device memory
+ * @base_addr:          for mapped device memory
+ * @irq:                IRQ line for the device
+ * @cfg_data:           current cfg, intf, and alt in use
+ */
+struct pch_udc_dev {
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+        struct pci_dev                  *pdev;
+        struct pch_udc_ep               ep[PCH_UDC_EP_NUM];
+        spinlock_t                      lock; /* protects all state */
+        unsigned        active:1,
+                        stall:1,
+                        prot_stall:1,
+                        irq_registered:1,
+                        mem_region:1,
+                        registered:1,
+                        suspended:1,
+                        connected:1,
+                        set_cfg_not_acked:1,
+                        waiting_zlp_ack:1;
+        struct pci_pool         *data_requests;
+        struct pci_pool         *stp_requests;
+        dma_addr_t                      dma_addr;
+        unsigned long                   ep0out_buf[64];
+        struct usb_ctrlrequest          setup_data;
+        unsigned long                   phys_addr;
+        void __iomem                    *base_addr;
+        unsigned                        irq;
+        struct pch_udc_cfg_data cfg_data;
+};
+
+#define PCH_UDC_PCI_BAR                 1
+#define PCI_DEVICE_ID_INTEL_EG20T_UDC   0x8808
+
+static const char       ep0_string[] = "ep0in";
+static DEFINE_SPINLOCK(udc_stall_spinlock);     /* stall spin lock */
+struct pch_udc_dev *pch_udc;            /* pointer to device object */
+
+static int speed_fs;
+module_param_named(speed_fs, speed_fs, bool, S_IRUGO);
+MODULE_PARM_DESC(speed_fs, "true for Full speed operation");
+
+/**
+ * struct pch_udc_request - Structure holding a PCH USB device request packet
+ * @req:                embedded ep request
+ * @td_data_phys:       phys. address
+ * @td_data:            first dma desc. of chain
+ * @td_data_last:       last dma desc. of chain
+ * @queue:              associated queue
+ * @dma_going:          DMA in progress for request
+ * @dma_mapped:         DMA memory mapped for request
+ * @dma_done:           DMA completed for request
+ * @chain_len:          chain length
+ */
+struct pch_udc_request {
+        struct usb_request              req;
+        dma_addr_t                      td_data_phys;
+        struct pch_udc_data_dma_desc    *td_data;
+        struct pch_udc_data_dma_desc    *td_data_last;
+        struct list_head                queue;
+        unsigned                        dma_going:1,
+                                        dma_mapped:1,
+                                        dma_done:1;
+        unsigned                        chain_len;
+};
+
+static inline u32 pch_udc_readl(struct pch_udc_dev *dev, unsigned long reg)
+{
+        return ioread32(dev->base_addr + reg);
+}
+
+static inline void pch_udc_writel(struct pch_udc_dev *dev,
+                                    unsigned long val, unsigned long reg)
+{
+        iowrite32(val, dev->base_addr + reg);
+}
+
+static inline void pch_udc_bit_set(struct pch_udc_dev *dev,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_writel(dev, pch_udc_readl(dev, reg) | bitmask, reg);
+}
+
+static inline void pch_udc_bit_clr(struct pch_udc_dev *dev,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_writel(dev, pch_udc_readl(dev, reg) & ~(bitmask), reg);
+}
+
+static inline u32 pch_udc_ep_readl(struct pch_udc_ep *ep, unsigned long reg)
+{
+        return ioread32(ep->dev->base_addr + ep->offset_addr + reg);
+}
+
+static inline void pch_udc_ep_writel(struct pch_udc_ep *ep,
+                                    unsigned long val, unsigned long reg)
+{
+        iowrite32(val, ep->dev->base_addr + ep->offset_addr + reg);
+}
+
+static inline void pch_udc_ep_bit_set(struct pch_udc_ep *ep,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_ep_writel(ep, pch_udc_ep_readl(ep, reg) | bitmask, reg);
+}
+
+static inline void pch_udc_ep_bit_clr(struct pch_udc_ep *ep,
+                                     unsigned long reg,
+                                     unsigned long bitmask)
+{
+        pch_udc_ep_writel(ep, pch_udc_ep_readl(ep, reg) & ~(bitmask), reg);
+}
+
+/**
+ * pch_udc_csr_busy() - Wait till idle.
+ * @dev:        Reference to pch_udc_dev structure
+ */
+static void pch_udc_csr_busy(struct pch_udc_dev *dev)
+{
+        unsigned int count = 200;
+
+        /* Wait till idle */
+        while ((pch_udc_readl(dev, UDC_CSR_BUSY_ADDR) & UDC_CSR_BUSY)
+                && --count)
+                cpu_relax();
+        if (!count)
+                dev_err(&dev->pdev->dev, "%s: wait error\n", __func__);
+}
+
+/**
+ * pch_udc_write_csr() - Write the command and status registers.
+ * @dev:        Reference to pch_udc_dev structure
+ * @val:        value to be written to CSR register
+ * @addr:       address of CSR register
+ */
+static void pch_udc_write_csr(struct pch_udc_dev *dev, unsigned long val,
+                               unsigned int ep)
+{
+        unsigned long reg = PCH_UDC_CSR(ep);
+
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+        pch_udc_writel(dev, val, reg);
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+}
+
+/**
+ * pch_udc_read_csr() - Read the command and status registers.
+ * @dev:        Reference to pch_udc_dev structure
+ * @addr:       address of CSR register
+ *
+ * Return codes:        content of CSR register
+ */
+static u32 pch_udc_read_csr(struct pch_udc_dev *dev, unsigned int ep)
+{
+        unsigned long reg = PCH_UDC_CSR(ep);
+
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+        pch_udc_readl(dev, reg);        /* Dummy read */
+        pch_udc_csr_busy(dev);          /* Wait till idle */
+        return pch_udc_readl(dev, reg);
+}
+
+/**
+ * pch_udc_rmt_wakeup() - Initiate for remote wakeup
+ * @dev:        Reference to pch_udc_dev structure
+ */
+static inline void pch_udc_rmt_wakeup(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+        mdelay(1);
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+}
+
+/**
+ * pch_udc_get_frame() - Get the current frame from device status register
+ * @dev:        Reference to pch_udc_dev structure
+ * Retern       current frame
+ */
+static inline int pch_udc_get_frame(struct pch_udc_dev *dev)
+{
+        u32 frame = pch_udc_readl(dev, UDC_DEVSTS_ADDR);
+        return (frame & UDC_DEVSTS_TS_MASK) >> UDC_DEVSTS_TS_SHIFT;
+}
+
+/**
+ * pch_udc_clear_selfpowered() - Clear the self power control
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static inline void pch_udc_clear_selfpowered(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_clr(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_SP);
+}
+
+/**
+ * pch_udc_set_selfpowered() - Set the self power control
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static inline void pch_udc_set_selfpowered(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_SP);
+}
+
+/**
+ * pch_udc_set_disconnect() - Set the disconnect status.
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static inline void pch_udc_set_disconnect(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
+}
+
+/**
+ * pch_udc_clear_disconnect() - Clear the disconnect status.
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
+{
+        /* Clear the disconnect */
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
+        mdelay(1);
+        /* Resume USB signalling */
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+}
+
+/**
+ * pch_udc_vbus_session() - set or clearr the disconnect status.
+ * @dev:        Reference to pch_udc_regs structure
+ * @is_active:  Parameter specifying the action
+ *                0:   indicating VBUS power is ending
+ *                !0:  indicating VBUS power is starting
+ */
+static inline void pch_udc_vbus_session(struct pch_udc_dev *dev,
+                                          int is_active)
+{
+        if (is_active)
+                pch_udc_clear_disconnect(dev);
+        else
+                pch_udc_set_disconnect(dev);
+}
+
+/**
+ * pch_udc_ep_set_stall() - Set the stall of endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static void pch_udc_ep_set_stall(struct pch_udc_ep *ep)
+{
+        if (ep->in) {
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_F);
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
+        } else {
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
+        }
+}
+
+/**
+ * pch_udc_ep_clear_stall() - Clear the stall of endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_clear_stall(struct pch_udc_ep *ep)
+{
+        /* Clear the stall */
+        pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_S);
+        /* Clear NAK by writing CNAK */
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_CNAK);
+}
+
+/**
+ * pch_udc_ep_set_trfr_type() - Set the transfer type of endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @type:       Type of endpoint
+ */
+static inline void pch_udc_ep_set_trfr_type(struct pch_udc_ep *ep,
+                                        u8 type)
+{
+        pch_udc_ep_writel(ep, ((type << UDC_EPCTL_ET_SHIFT) &
+                                UDC_EPCTL_ET_MASK), UDC_EPCTL_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_bufsz() - Set the maximum packet size for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @buf_size:   The buffer size
+ */
+static void pch_udc_ep_set_bufsz(struct pch_udc_ep *ep,
+                                                 u32 buf_size, u32 ep_in)
+{
+        u32 data;
+        if (ep_in) {
+                data = pch_udc_ep_readl(ep, UDC_BUFIN_FRAMENUM_ADDR);
+                data = (data & 0xffff0000) | (buf_size & 0xffff);
+                pch_udc_ep_writel(ep, data, UDC_BUFIN_FRAMENUM_ADDR);
+        } else {
+                data = pch_udc_ep_readl(ep, UDC_BUFOUT_MAXPKT_ADDR);
+                data = (buf_size << 16) | (data & 0xffff);
+                pch_udc_ep_writel(ep, data, UDC_BUFOUT_MAXPKT_ADDR);
+        }
+}
+
+/**
+ * pch_udc_ep_set_maxpkt() - Set the Max packet size for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @pkt_size:   The packet size
+ */
+static void pch_udc_ep_set_maxpkt(struct pch_udc_ep *ep, u32 pkt_size)
+{
+        u32 data = pch_udc_ep_readl(ep, UDC_BUFOUT_MAXPKT_ADDR);
+        data = (data & 0xffff0000) | (pkt_size & 0xffff);
+        pch_udc_ep_writel(ep, data, UDC_BUFOUT_MAXPKT_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_subptr() - Set the Setup buffer pointer for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @addr:       Address of the register
+ */
+static inline void pch_udc_ep_set_subptr(struct pch_udc_ep *ep, u32 addr)
+{
+        pch_udc_ep_writel(ep, addr, UDC_SUBPTR_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_ddptr() - Set the Data descriptor pointer for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @addr:       Address of the register
+ */
+static inline void pch_udc_ep_set_ddptr(struct pch_udc_ep *ep, u32 addr)
+{
+        pch_udc_ep_writel(ep, addr, UDC_DESPTR_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_pd() - Set the poll demand bit for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_set_pd(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_P);
+}
+
+/**
+ * pch_udc_ep_set_rrdy() - Set the receive ready bit for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_set_rrdy(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_RRDY);
+}
+
+/**
+ * pch_udc_ep_clear_rrdy() - Clear the receive ready bit for the endpoint
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_clear_rrdy(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_RRDY);
+}
+
+/**
+ * pch_udc_set_dma() - Set the 'TDE' or RDE bit of device control
+ *                      register depending on the direction specified
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @dir:        whether Tx or Rx
+ *                DMA_DIR_RX: Receive
+ *                DMA_DIR_TX: Transmit
+ */
+static inline void pch_udc_set_dma(struct pch_udc_dev *dev, int dir)
+{
+        if (dir == DMA_DIR_RX)
+                pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RDE);
+        else if (dir == DMA_DIR_TX)
+                pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_TDE);
+}
+
+/**
+ * pch_udc_clear_dma() - Clear the 'TDE' or RDE bit of device control
+ *                               register depending on the direction specified
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @dir:        Whether Tx or Rx
+ *                DMA_DIR_RX: Receive
+ *                DMA_DIR_TX: Transmit
+ */
+static inline void pch_udc_clear_dma(struct pch_udc_dev *dev, int dir)
+{
+        if (dir == DMA_DIR_RX)
+                pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RDE);
+        else if (dir == DMA_DIR_TX)
+                pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_TDE);
+}
+
+/**
+ * pch_udc_set_csr_done() - Set the device control register
+ *                              CSR done field (bit 13)
+ * @dev:        reference to structure of type pch_udc_regs
+ */
+static inline void pch_udc_set_csr_done(struct pch_udc_dev *dev)
+{
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_CSR_DONE);
+}
+
+/**
+ * pch_udc_disable_interrupts() - Disables the specified interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to disable interrupts
+ */
+static inline void pch_udc_disable_interrupts(struct pch_udc_dev *dev,
+                                            u32 mask)
+{
+        pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_enable_interrupts() - Enable the specified interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to enable interrupts
+ */
+static inline void pch_udc_enable_interrupts(struct pch_udc_dev *dev,
+                                           u32 mask)
+{
+        pch_udc_bit_clr(dev, UDC_DEVIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_disable_ep_interrupts() - Disable endpoint interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to disable interrupts
+ */
+static inline void pch_udc_disable_ep_interrupts(struct pch_udc_dev *dev,
+                                                u32 mask)
+{
+        pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_enable_ep_interrupts() - Enable endpoint interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @mask:       Mask to enable interrupts
+ */
+static inline void pch_udc_enable_ep_interrupts(struct pch_udc_dev *dev,
+                                              u32 mask)
+{
+        pch_udc_bit_clr(dev, UDC_EPIRQMSK_ADDR, mask);
+}
+
+/**
+ * pch_udc_read_device_interrupts() - Read the device interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * Retern       The device interrupts
+ */
+static inline u32 pch_udc_read_device_interrupts(struct pch_udc_dev *dev)
+{
+        return pch_udc_readl(dev, UDC_DEVIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_write_device_interrupts() - Write device interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @val:        The value to be written to interrupt register
+ */
+static inline void pch_udc_write_device_interrupts(struct pch_udc_dev *dev,
+                                                     u32 val)
+{
+        pch_udc_writel(dev, val, UDC_DEVIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_read_ep_interrupts() - Read the endpoint interrupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * Retern       The endpoint interrupt
+ */
+static inline u32 pch_udc_read_ep_interrupts(struct pch_udc_dev *dev)
+{
+        return pch_udc_readl(dev, UDC_EPIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_write_ep_interrupts() - Clear endpoint interupts
+ * @dev:        Reference to structure of type pch_udc_regs
+ * @val:        The value to be written to interrupt register
+ */
+static inline void pch_udc_write_ep_interrupts(struct pch_udc_dev *dev,
+                                             u32 val)
+{
+        pch_udc_writel(dev, val, UDC_EPIRQSTS_ADDR);
+}
+
+/**
+ * pch_udc_read_device_status() - Read the device status
+ * @dev:        Reference to structure of type pch_udc_regs
+ * Retern       The device status
+ */
+static inline u32 pch_udc_read_device_status(struct pch_udc_dev *dev)
+{
+        return pch_udc_readl(dev, UDC_DEVSTS_ADDR);
+}
+
+/**
+ * pch_udc_read_ep_control() - Read the endpoint control
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * Retern       The endpoint control register value
+ */
+static inline u32 pch_udc_read_ep_control(struct pch_udc_ep *ep)
+{
+        return pch_udc_ep_readl(ep, UDC_EPCTL_ADDR);
+}
+
+/**
+ * pch_udc_clear_ep_control() - Clear the endpoint control register
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * Retern       The endpoint control register value
+ */
+static inline void pch_udc_clear_ep_control(struct pch_udc_ep *ep)
+{
+        return pch_udc_ep_writel(ep, 0, UDC_EPCTL_ADDR);
+}
+
+/**
+ * pch_udc_read_ep_status() - Read the endpoint status
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * Retern       The endpoint status
+ */
+static inline u32 pch_udc_read_ep_status(struct pch_udc_ep *ep)
+{
+        return pch_udc_ep_readl(ep, UDC_EPSTS_ADDR);
+}
+
+/**
+ * pch_udc_clear_ep_status() - Clear the endpoint status
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ * @stat:       Endpoint status
+ */
+static inline void pch_udc_clear_ep_status(struct pch_udc_ep *ep,
+                                         u32 stat)
+{
+        return pch_udc_ep_writel(ep, stat, UDC_EPSTS_ADDR);
+}
+
+/**
+ * pch_udc_ep_set_nak() - Set the bit 7 (SNAK field)
+ *                              of the endpoint control register
+ * @ep:         Reference to structure of type pch_udc_ep_regs
+ */
+static inline void pch_udc_ep_set_nak(struct pch_udc_ep *ep)
+{
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_SNAK);
+}
+
+/**
+ * pch_udc_ep_clear_nak() - Set the bit 8 (CNAK field)
+ *                              of the endpoint control register
+ * @ep:         reference to structure of type pch_udc_ep_regs
+ */
+static void pch_udc_ep_clear_nak(struct pch_udc_ep *ep)
+{
+        unsigned int loopcnt = 0;
+        struct pch_udc_dev *dev = ep->dev;
+
+        if (!(pch_udc_ep_readl(ep, UDC_EPCTL_ADDR) & UDC_EPCTL_NAK))
+                return;
+        if (!ep->in) {
+                loopcnt = 10000;
+                while (!(pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP) &&
+                        --loopcnt)
+                        udelay(5);
+                if (!loopcnt)
+                        dev_err(&dev->pdev->dev, "%s: RxFIFO not Empty\n",
+                                __func__);
+        }
+        loopcnt = 10000;
+        while ((pch_udc_read_ep_control(ep) & UDC_EPCTL_NAK) && --loopcnt) {
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_CNAK);
+                udelay(5);
+        }
+        if (!loopcnt)
+                dev_err(&dev->pdev->dev, "%s: Clear NAK not set for ep%d%s\n",
+                        __func__, ep->num, (ep->in ? "in" : "out"));
+}
+
+/**
+ * pch_udc_ep_fifo_flush() - Flush the endpoint fifo
+ * @ep: reference to structure of type pch_udc_ep_regs
+ * @dir:        direction of endpoint
+ *                0:  endpoint is OUT
+ *                !0: endpoint is IN
+ */
+static void pch_udc_ep_fifo_flush(struct pch_udc_ep *ep, int dir)
+{
+        unsigned int loopcnt = 0;
+        struct pch_udc_dev *dev = ep->dev;
+
+        if (dir) {      /* IN ep */
+                pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_F);
+                return;
+        }
+
+        if (pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP)
+                return;
+        pch_udc_ep_bit_set(ep, UDC_EPCTL_ADDR, UDC_EPCTL_MRXFLUSH);
+        /* Wait for RxFIFO Empty */
+        loopcnt = 10000;
+        while (!(pch_udc_read_ep_status(ep) & UDC_EPSTS_MRXFIFO_EMP) &&
+                --loopcnt)
+                udelay(5);
+        if (!loopcnt)
+                dev_err(&dev->pdev->dev, "RxFIFO not Empty\n");
+        pch_udc_ep_bit_clr(ep, UDC_EPCTL_ADDR, UDC_EPCTL_MRXFLUSH);
+}
+
+/**
+ * pch_udc_ep_enable() - This api enables endpoint
+ * @regs:       Reference to structure pch_udc_ep_regs
+ * @desc:       endpoint descriptor
+ */
+static void pch_udc_ep_enable(struct pch_udc_ep *ep,
+                               struct pch_udc_cfg_data *cfg,
+                               const struct usb_endpoint_descriptor *desc)
+{
+        u32 val = 0;
+        u32 buff_size = 0;
+
+        pch_udc_ep_set_trfr_type(ep, desc->bmAttributes);
+        if (ep->in)
+                buff_size = UDC_EPIN_BUFF_SIZE;
+        else
+                buff_size = UDC_EPOUT_BUFF_SIZE;
+        pch_udc_ep_set_bufsz(ep, buff_size, ep->in);
+        pch_udc_ep_set_maxpkt(ep, le16_to_cpu(desc->wMaxPacketSize));
+        pch_udc_ep_set_nak(ep);
+        pch_udc_ep_fifo_flush(ep, ep->in);
+        /* Configure the endpoint */
+        val = ep->num << UDC_CSR_NE_NUM_SHIFT | ep->in << UDC_CSR_NE_DIR_SHIFT |
+              ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) <<
+                UDC_CSR_NE_TYPE_SHIFT) |
+              (cfg->cur_cfg << UDC_CSR_NE_CFG_SHIFT) |
+              (cfg->cur_intf << UDC_CSR_NE_INTF_SHIFT) |
+              (cfg->cur_alt << UDC_CSR_NE_ALT_SHIFT) |
+              le16_to_cpu(desc->wMaxPacketSize) << UDC_CSR_NE_MAX_PKT_SHIFT;
+
+        if (ep->in)
+                pch_udc_write_csr(ep->dev, val, UDC_EPIN_IDX(ep->num));
+        else
+                pch_udc_write_csr(ep->dev, val, UDC_EPOUT_IDX(ep->num));
+}
+
+/**
+ * pch_udc_ep_disable() - This api disables endpoint
+ * @regs:       Reference to structure pch_udc_ep_regs
+ */
+static void pch_udc_ep_disable(struct pch_udc_ep *ep)
+{
+        if (ep->in) {
+                /* flush the fifo */
+                pch_udc_ep_writel(ep, UDC_EPCTL_F, UDC_EPCTL_ADDR);
+                /* set NAK */
+                pch_udc_ep_writel(ep, UDC_EPCTL_SNAK, UDC_EPCTL_ADDR);
+                pch_udc_ep_bit_set(ep, UDC_EPSTS_ADDR, UDC_EPSTS_IN);
+        } else {
+                /* set NAK */
+                pch_udc_ep_writel(ep, UDC_EPCTL_SNAK, UDC_EPCTL_ADDR);
+        }
+        /* reset desc pointer */
+        pch_udc_ep_writel(ep, 0, UDC_DESPTR_ADDR);
+}
+
+/**
+ * pch_udc_wait_ep_stall() - Wait EP stall.
+ * @dev:        Reference to pch_udc_dev structure
+ */
+static void pch_udc_wait_ep_stall(struct pch_udc_ep *ep)
+{
+        unsigned int count = 10000;
+
+        /* Wait till idle */
+        while ((pch_udc_read_ep_control(ep) & UDC_EPCTL_S) && --count)
+                udelay(5);
+        if (!count)
+                dev_err(&ep->dev->pdev->dev, "%s: wait error\n", __func__);
+}
+
+/**
+ * pch_udc_init() - This API initializes usb device controller
+ * @dev:        Rreference to pch_udc_regs structure
+ */
+static void pch_udc_init(struct pch_udc_dev *dev)
+{
+        if (NULL == dev) {
+                pr_err("%s: Invalid address\n", __func__);
+                return;
+        }
+        /* Soft Reset and Reset PHY */
+        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
+        pch_udc_writel(dev, UDC_SRST | UDC_PSRST, UDC_SRST_ADDR);
+        mdelay(1);
+        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
+        pch_udc_writel(dev, 0x00, UDC_SRST_ADDR);
+        mdelay(1);
+        /* mask and clear all device interrupts */
+        pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, UDC_DEVINT_MSK);
+        pch_udc_bit_set(dev, UDC_DEVIRQSTS_ADDR, UDC_DEVINT_MSK);
+
+        /* mask and clear all ep interrupts */
+        pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
+        pch_udc_bit_set(dev, UDC_EPIRQSTS_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
+
+        /* enable dynamic CSR programmingi, self powered and device speed */
+        if (speed_fs)
+                pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_CSR_PRG |
+                                UDC_DEVCFG_SP | UDC_DEVCFG_SPD_FS);
+        else /* defaul high speed */
+                pch_udc_bit_set(dev, UDC_DEVCFG_ADDR, UDC_DEVCFG_CSR_PRG |
+                                UDC_DEVCFG_SP | UDC_DEVCFG_SPD_HS);
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR,
+                        (PCH_UDC_THLEN << UDC_DEVCTL_THLEN_SHIFT) |
+                        (PCH_UDC_BRLEN << UDC_DEVCTL_BRLEN_SHIFT) |
+                        UDC_DEVCTL_MODE | UDC_DEVCTL_BREN |
+                        UDC_DEVCTL_THE);
+}
+
+/**
+ * pch_udc_exit() - This API exit usb device controller
+ * @dev:        Reference to pch_udc_regs structure
+ */
+static void pch_udc_exit(struct pch_udc_dev *dev)
+{
+        /* mask all device interrupts */
+        pch_udc_bit_set(dev, UDC_DEVIRQMSK_ADDR, UDC_DEVINT_MSK);
+        /* mask all ep interrupts */
+        pch_udc_bit_set(dev, UDC_EPIRQMSK_ADDR, UDC_EPINT_MSK_DISABLE_ALL);
+        /* put device in disconnected state */
+        pch_udc_set_disconnect(dev);
+}
+
+/**
+ * pch_udc_pcd_get_frame() - This API is invoked to get the current frame number
+ * @gadget:     Reference to the gadget driver
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_get_frame(struct usb_gadget *gadget)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        return pch_udc_get_frame(dev);
+}
+
+/**
+ * pch_udc_pcd_wakeup() - This API is invoked to initiate a remote wakeup
+ * @gadget:     Reference to the gadget driver
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_wakeup(struct usb_gadget *gadget)
+{
+        struct pch_udc_dev      *dev;
+        unsigned long           flags;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        spin_lock_irqsave(&dev->lock, flags);
+        pch_udc_rmt_wakeup(dev);
+        spin_unlock_irqrestore(&dev->lock, flags);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_selfpowered() - This API is invoked to specify whether the device
+ *                              is self powered or not
+ * @gadget:     Reference to the gadget driver
+ * @value:      Specifies self powered or not
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_selfpowered(struct usb_gadget *gadget, int value)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        if (value)
+                pch_udc_set_selfpowered(dev);
+        else
+                pch_udc_clear_selfpowered(dev);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_pullup() - This API is invoked to make the device
+ *                              visible/invisible to the host
+ * @gadget:     Reference to the gadget driver
+ * @is_on:      Specifies whether the pull up is made active or inactive
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_pullup(struct usb_gadget *gadget, int is_on)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        pch_udc_vbus_session(dev, is_on);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_vbus_session() - This API is used by a driver for an external
+ *                              transceiver (or GPIO) that
+ *                              detects a VBUS power session starting/ending
+ * @gadget:     Reference to the gadget driver
+ * @is_active:  specifies whether the session is starting or ending
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:        If the gadget passed is NULL
+ */
+static int pch_udc_pcd_vbus_session(struct usb_gadget *gadget, int is_active)
+{
+        struct pch_udc_dev      *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct pch_udc_dev, gadget);
+        pch_udc_vbus_session(dev, is_active);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_vbus_draw() - This API is used by gadget drivers during
+ *                              SET_CONFIGURATION calls to
+ *                              specify how much power the device can consume
+ * @gadget:     Reference to the gadget driver
+ * @mA:         specifies the current limit in 2mA unit
+ *
+ * Return codes:
+ *      -EINVAL:        If the gadget passed is NULL
+ *      -EOPNOTSUPP:
+ */
+static int pch_udc_pcd_vbus_draw(struct usb_gadget *gadget, unsigned int mA)
+{
+        return -EOPNOTSUPP;
+}
+
+static const struct usb_gadget_ops pch_udc_ops = {
+        .get_frame = pch_udc_pcd_get_frame,
+        .wakeup = pch_udc_pcd_wakeup,
+        .set_selfpowered = pch_udc_pcd_selfpowered,
+        .pullup = pch_udc_pcd_pullup,
+        .vbus_session = pch_udc_pcd_vbus_session,
+        .vbus_draw = pch_udc_pcd_vbus_draw,
+};
+
+/**
+ * complete_req() - This API is invoked from the driver when processing
+ *                      of a request is complete
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request structure
+ * @status:     Indicates the success/failure of completion
+ */
+static void complete_req(struct pch_udc_ep *ep, struct pch_udc_request *req,
+                                                                 int status)
+{
+        struct pch_udc_dev      *dev;
+        unsigned halted = ep->halted;
+
+        list_del_init(&req->queue);
+
+        /* set new status if pending */
+        if (req->req.status == -EINPROGRESS)
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        dev = ep->dev;
+        if (req->dma_mapped) {
+                if (ep->in)
+                        pci_unmap_single(dev->pdev, req->req.dma,
+                                         req->req.length, PCI_DMA_TODEVICE);
+                else
+                        pci_unmap_single(dev->pdev, req->req.dma,
+                                         req->req.length, PCI_DMA_FROMDEVICE);
+                req->dma_mapped = 0;
+                req->req.dma = DMA_ADDR_INVALID;
+        }
+        ep->halted = 1;
+        spin_unlock(&dev->lock);
+        if (!ep->in)
+                pch_udc_ep_clear_rrdy(ep);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&dev->lock);
+        ep->halted = halted;
+}
+
+/**
+ * empty_req_queue() - This API empties the request queue of an endpoint
+ * @ep:         Reference to the endpoint structure
+ */
+static void empty_req_queue(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request  *req;
+
+        ep->halted = 1;
+        while (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+                complete_req(ep, req, -ESHUTDOWN);      /* Remove from list */
+        }
+}
+
+/**
+ * pch_udc_free_dma_chain() - This function frees the DMA chain created
+ *                              for the request
+ * @dev         Reference to the driver structure
+ * @req         Reference to the request to be freed
+ *
+ * Return codes:
+ *      0: Success
+ */
+static void pch_udc_free_dma_chain(struct pch_udc_dev *dev,
+                                   struct pch_udc_request *req)
+{
+        struct pch_udc_data_dma_desc *td = req->td_data;
+        unsigned i = req->chain_len;
+
+        for (; i > 1; --i) {
+                dma_addr_t addr = (dma_addr_t)td->next;
+                /* do not free first desc., will be done by free for request */
+                td = phys_to_virt(addr);
+                pci_pool_free(dev->data_requests, td, addr);
+        }
+}
+
+/**
+ * pch_udc_create_dma_chain() - This function creates or reinitializes
+ *                              a DMA chain
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request
+ * @buf_len:    The buffer length
+ * @gfp_flags:  Flags to be used while mapping the data buffer
+ *
+ * Return codes:
+ *      0:              success,
+ *      -ENOMEM:        pci_pool_alloc invocation fails
+ */
+static int pch_udc_create_dma_chain(struct pch_udc_ep *ep,
+                                    struct pch_udc_request *req,
+                                    unsigned long buf_len,
+                                    gfp_t gfp_flags)
+{
+        struct pch_udc_data_dma_desc *td = req->td_data, *last;
+        unsigned long bytes = req->req.length, i = 0;
+        dma_addr_t dma_addr;
+        unsigned len = 1;
+
+        if (req->chain_len > 1)
+                pch_udc_free_dma_chain(ep->dev, req);
+
+        for (; ; bytes -= buf_len, ++len) {
+                if (ep->in)
+                        td->status = PCH_UDC_BS_HST_BSY | min(buf_len, bytes);
+                else
+                        td->status = PCH_UDC_BS_HST_BSY;
+
+                if (bytes <= buf_len)
+                        break;
+
+                last = td;
+                td = pci_pool_alloc(ep->dev->data_requests, gfp_flags,
+                                    &dma_addr);
+                if (!td)
+                        goto nomem;
+
+                i += buf_len;
+                td->dataptr = req->req.dma + i;
+                last->next = dma_addr;
+        }
+
+        req->td_data_last = td;
+        td->status |= PCH_UDC_DMA_LAST;
+        td->next = req->td_data_phys;
+        req->chain_len = len;
+        return 0;
+
+nomem:
+        if (len > 1) {
+                req->chain_len = len;
+                pch_udc_free_dma_chain(ep->dev, req);
+        }
+        req->chain_len = 1;
+        return -ENOMEM;
+}
+
+/**
+ * prepare_dma() - This function creates and initializes the DMA chain
+ *                      for the request
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request
+ * @gfp:        Flag to be used while mapping the data buffer
+ *
+ * Return codes:
+ *      0:              Success
+ *      Other 0:        linux error number on failure
+ */
+static int prepare_dma(struct pch_udc_ep *ep, struct pch_udc_request *req,
+                          gfp_t gfp)
+{
+        int     retval;
+
+        req->td_data->dataptr = req->req.dma;
+        req->td_data->status |= PCH_UDC_DMA_LAST;
+        /* Allocate and create a DMA chain */
+        retval = pch_udc_create_dma_chain(ep, req, ep->ep.maxpacket, gfp);
+        if (retval) {
+                pr_err("%s: could not create DMA chain: %d\n",
+                       __func__, retval);
+                return retval;
+        }
+        if (!ep->in)
+                return 0;
+        if (req->req.length <= ep->ep.maxpacket)
+                req->td_data->status = PCH_UDC_DMA_LAST | PCH_UDC_BS_HST_BSY |
+                                       req->req.length;
+        /* if bytes < max packet then tx bytes must
+         * be written in packet per buffer mode
+         */
+        if ((req->req.length < ep->ep.maxpacket) || !ep->num)
+                req->td_data->status = (req->td_data->status &
+                                        ~PCH_UDC_RXTX_BYTES) | req->req.length;
+        req->td_data->status = (req->td_data->status &
+                                ~PCH_UDC_BUFF_STS) | PCH_UDC_BS_HST_BSY;
+        return 0;
+}
+
+/**
+ * process_zlp() - This function process zero length packets
+ *                      from the gadget driver
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request
+ */
+static void process_zlp(struct pch_udc_ep *ep, struct pch_udc_request *req)
+{
+        struct pch_udc_dev      *dev = ep->dev;
+
+        /* IN zlp's are handled by hardware */
+        complete_req(ep, req, 0);
+
+        /* if set_config or set_intf is waiting for ack by zlp
+         * then set CSR_DONE
+         */
+        if (dev->set_cfg_not_acked) {
+                pch_udc_set_csr_done(dev);
+                dev->set_cfg_not_acked = 0;
+        }
+        /* setup command is ACK'ed now by zlp */
+        if (!dev->stall && dev->waiting_zlp_ack) {
+                pch_udc_ep_clear_nak(&(dev->ep[UDC_EP0IN_IDX]));
+                dev->waiting_zlp_ack = 0;
+        }
+}
+
+/**
+ * pch_udc_start_rxrequest() - This function starts the receive requirement.
+ * @ep:         Reference to the endpoint structure
+ * @req:        Reference to the request structure
+ */
+static void pch_udc_start_rxrequest(struct pch_udc_ep *ep,
+                                         struct pch_udc_request *req)
+{
+        struct pch_udc_data_dma_desc *td_data;
+
+        pch_udc_clear_dma(ep->dev, DMA_DIR_RX);
+        td_data = req->td_data;
+        ep->td_data = req->td_data;
+        /* Set the status bits for all descriptors */
+        while (1) {
+                td_data->status = (td_data->status & ~PCH_UDC_BUFF_STS) |
+                                    PCH_UDC_BS_HST_RDY;
+                if ((td_data->status & PCH_UDC_DMA_LAST) ==  PCH_UDC_DMA_LAST)
+                        break;
+                td_data = phys_to_virt(td_data->next);
+        }
+        /* Write the descriptor pointer */
+        pch_udc_ep_set_ddptr(ep, req->td_data_phys);
+        req->dma_going = 1;
+        pch_udc_enable_ep_interrupts(ep->dev, UDC_EPINT_OUT_EP0 << ep->num);
+        pch_udc_set_dma(ep->dev, DMA_DIR_RX);
+        pch_udc_ep_clear_nak(ep);
+        pch_udc_ep_set_rrdy(ep);
+}
+
+/**
+ * pch_udc_pcd_ep_enable() - This API enables the endpoint. It is called
+ *                              from gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @desc:       Reference to the USB endpoint descriptor structure
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:
+ *      -ESHUTDOWN:
+ */
+static int pch_udc_pcd_ep_enable(struct usb_ep *usbep,
+                                    const struct usb_endpoint_descriptor *desc)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long           iflags;
+
+        if (!usbep || (usbep->name == ep0_string) || !desc ||
+            (desc->bDescriptorType != USB_DT_ENDPOINT) || !desc->wMaxPacketSize)
+                return -EINVAL;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!dev->driver || (dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&dev->lock, iflags);
+        ep->desc = desc;
+        ep->halted = 0;
+        pch_udc_ep_enable(ep, &ep->dev->cfg_data, desc);
+        ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+        pch_udc_enable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
+        spin_unlock_irqrestore(&dev->lock, iflags);
+        return 0;
+}
+
+/**
+ * pch_udc_pcd_ep_disable() - This API disables endpoint and is called
+ *                              from gadget driver
+ * @usbep       Reference to the USB endpoint structure
+ *
+ * Return codes:
+ *      0:              Success
+ *      -EINVAL:
+ */
+static int pch_udc_pcd_ep_disable(struct usb_ep *usbep)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long   iflags;
+
+        if (!usbep)
+                return -EINVAL;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if ((usbep->name == ep0_string) || !ep->desc)
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->dev->lock, iflags);
+        empty_req_queue(ep);
+        ep->halted = 1;
+        pch_udc_ep_disable(ep);
+        pch_udc_disable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
+        ep->desc = NULL;
+        INIT_LIST_HEAD(&ep->queue);
+        spin_unlock_irqrestore(&ep->dev->lock, iflags);
+        return 0;
+}
+
+/**
+ * pch_udc_alloc_request() - This function allocates request structure.
+ *                              It is called by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @gfp:        Flag to be used while allocating memory
+ *
+ * Return codes:
+ *      NULL:                   Failure
+ *      Allocated address:      Success
+ */
+static struct usb_request *pch_udc_alloc_request(struct usb_ep *usbep,
+                                                  gfp_t gfp)
+{
+        struct pch_udc_request          *req;
+        struct pch_udc_ep               *ep;
+        struct pch_udc_data_dma_desc    *dma_desc;
+        struct pch_udc_dev              *dev;
+
+        if (!usbep)
+                return NULL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        req = kzalloc(sizeof *req, gfp);
+        if (!req)
+                return NULL;
+        req->req.dma = DMA_ADDR_INVALID;
+        INIT_LIST_HEAD(&req->queue);
+        if (!ep->dev->dma_addr)
+                return &req->req;
+        /* ep0 in requests are allocated from data pool here */
+        dma_desc = pci_pool_alloc(ep->dev->data_requests, gfp,
+                                  &req->td_data_phys);
+        if (NULL == dma_desc) {
+                kfree(req);
+                return NULL;
+        }
+        /* prevent from using desc. - set HOST BUSY */
+        dma_desc->status |= PCH_UDC_BS_HST_BSY;
+        dma_desc->dataptr = __constant_cpu_to_le32(DMA_ADDR_INVALID);
+        req->td_data = dma_desc;
+        req->td_data_last = dma_desc;
+        req->chain_len = 1;
+        return &req->req;
+}
+
+/**
+ * pch_udc_free_request() - This function frees request structure.
+ *                              It is called by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @usbreq:     Reference to the USB request
+ */
+static void pch_udc_free_request(struct usb_ep *usbep,
+                                  struct usb_request *usbreq)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_request  *req;
+        struct pch_udc_dev      *dev;
+
+        if (!usbep || !usbreq)
+                return;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        req = container_of(usbreq, struct pch_udc_request, req);
+        dev = ep->dev;
+        if (!list_empty(&req->queue))
+                dev_err(&dev->pdev->dev, "%s: %s req=0x%p queue not empty\n",
+                        __func__, usbep->name, req);
+        if (req->td_data != NULL) {
+                if (req->chain_len > 1)
+                        pch_udc_free_dma_chain(ep->dev, req);
+                pci_pool_free(ep->dev->data_requests, req->td_data,
+                              req->td_data_phys);
+        }
+        kfree(req);
+}
+
+/**
+ * pch_udc_pcd_queue() - This function queues a request packet. It is called
+ *                      by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @usbreq:     Reference to the USB request
+ * @gfp:        Flag to be used while mapping the data buffer
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_queue(struct usb_ep *usbep, struct usb_request *usbreq,
+                                                                 gfp_t gfp)
+{
+        int retval = 0;
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        struct pch_udc_request  *req;
+        unsigned long   iflags;
+
+        if (!usbep || !usbreq || !usbreq->complete || !usbreq->buf)
+                return -EINVAL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!ep->desc && ep->num)
+                return -EINVAL;
+        req = container_of(usbreq, struct pch_udc_request, req);
+        if (!list_empty(&req->queue))
+                return -EINVAL;
+        if (!dev->driver || (dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&ep->dev->lock, iflags);
+        /* map the buffer for dma */
+        if (usbreq->length &&
+            ((usbreq->dma == DMA_ADDR_INVALID) || !usbreq->dma)) {
+                if (ep->in)
+                        usbreq->dma = pci_map_single(dev->pdev, usbreq->buf,
+                                        usbreq->length, PCI_DMA_TODEVICE);
+                else
+                        usbreq->dma = pci_map_single(dev->pdev, usbreq->buf,
+                                        usbreq->length, PCI_DMA_FROMDEVICE);
+                req->dma_mapped = 1;
+        }
+        if (usbreq->length > 0) {
+                retval = prepare_dma(ep, req, gfp);
+                if (retval)
+                        goto probe_end;
+        }
+        usbreq->actual = 0;
+        usbreq->status = -EINPROGRESS;
+        req->dma_done = 0;
+        if (list_empty(&ep->queue) && !ep->halted) {
+                /* no pending transfer, so start this req */
+                if (!usbreq->length) {
+                        process_zlp(ep, req);
+                        retval = 0;
+                        goto probe_end;
+                }
+                if (!ep->in) {
+                        pch_udc_start_rxrequest(ep, req);
+                } else {
+                        /*
+                        * For IN trfr the descriptors will be programmed and
+                        * P bit will be set when
+                        * we get an IN token
+                        */
+                        pch_udc_wait_ep_stall(ep);
+                        pch_udc_ep_clear_nak(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev, (1 << ep->num));
+                        pch_udc_set_dma(dev, DMA_DIR_TX);
+                }
+        }
+        /* Now add this request to the ep's pending requests */
+        if (req != NULL)
+                list_add_tail(&req->queue, &ep->queue);
+
+probe_end:
+        spin_unlock_irqrestore(&dev->lock, iflags);
+        return retval;
+}
+
+/**
+ * pch_udc_pcd_dequeue() - This function de-queues a request packet.
+ *                              It is called by gadget driver
+ * @usbep:      Reference to the USB endpoint structure
+ * @usbreq:     Reference to the USB request
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_dequeue(struct usb_ep *usbep,
+                                struct usb_request *usbreq)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_request  *req;
+        struct pch_udc_dev      *dev;
+        unsigned long           flags;
+        int ret = -EINVAL;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!usbep || !usbreq || (!ep->desc && ep->num))
+                return ret;
+        req = container_of(usbreq, struct pch_udc_request, req);
+        spin_lock_irqsave(&ep->dev->lock, flags);
+        /* make sure it's still queued on this endpoint */
+        list_for_each_entry(req, &ep->queue, queue) {
+                if (&req->req == usbreq) {
+                        pch_udc_ep_set_nak(ep);
+                        if (!list_empty(&req->queue))
+                                complete_req(ep, req, -ECONNRESET);
+                        ret = 0;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&ep->dev->lock, flags);
+        return ret;
+}
+
+/**
+ * pch_udc_pcd_set_halt() - This function Sets or clear the endpoint halt
+ *                          feature
+ * @usbep:      Reference to the USB endpoint structure
+ * @halt:       Specifies whether to set or clear the feature
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_set_halt(struct usb_ep *usbep, int halt)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long iflags;
+        int ret;
+
+        if (!usbep)
+                return -EINVAL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!ep->desc && !ep->num)
+                return -EINVAL;
+        if (!ep->dev->driver || (ep->dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&udc_stall_spinlock, iflags);
+        if (list_empty(&ep->queue)) {
+                if (halt) {
+                        if (ep->num == PCH_UDC_EP0)
+                                ep->dev->stall = 1;
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                     PCH_UDC_EPINT(ep->in,
+                                                                   ep->num));
+                } else {
+                        pch_udc_ep_clear_stall(ep);
+                }
+                ret = 0;
+        } else {
+                ret = -EAGAIN;
+        }
+        spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
+        return ret;
+}
+
+/**
+ * pch_udc_pcd_set_wedge() - This function Sets or clear the endpoint
+ *                              halt feature
+ * @usbep:      Reference to the USB endpoint structure
+ * @halt:       Specifies whether to set or clear the feature
+ *
+ * Return codes:
+ *      0:                      Success
+ *      linux error number:     Failure
+ */
+static int pch_udc_pcd_set_wedge(struct usb_ep *usbep)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_dev      *dev;
+        unsigned long iflags;
+        int ret;
+
+        if (!usbep)
+                return -EINVAL;
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        dev = ep->dev;
+        if (!ep->desc && !ep->num)
+                return -EINVAL;
+        if (!ep->dev->driver || (ep->dev->gadget.speed == USB_SPEED_UNKNOWN))
+                return -ESHUTDOWN;
+        spin_lock_irqsave(&udc_stall_spinlock, iflags);
+        if (!list_empty(&ep->queue)) {
+                ret = -EAGAIN;
+        } else {
+                if (ep->num == PCH_UDC_EP0)
+                        ep->dev->stall = 1;
+                pch_udc_ep_set_stall(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+                ep->dev->prot_stall = 1;
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
+        return ret;
+}
+
+/**
+ * pch_udc_pcd_fifo_flush() - This function Flush the FIFO of specified endpoint
+ * @usbep:      Reference to the USB endpoint structure
+ */
+static void pch_udc_pcd_fifo_flush(struct usb_ep *usbep)
+{
+        struct pch_udc_ep  *ep;
+
+        if (!usbep)
+                return;
+
+        ep = container_of(usbep, struct pch_udc_ep, ep);
+        if (ep->desc || !ep->num)
+                pch_udc_ep_fifo_flush(ep, ep->in);
+}
+
+static const struct usb_ep_ops pch_udc_ep_ops = {
+        .enable         = pch_udc_pcd_ep_enable,
+        .disable        = pch_udc_pcd_ep_disable,
+        .alloc_request  = pch_udc_alloc_request,
+        .free_request   = pch_udc_free_request,
+        .queue          = pch_udc_pcd_queue,
+        .dequeue        = pch_udc_pcd_dequeue,
+        .set_halt       = pch_udc_pcd_set_halt,
+        .set_wedge      = pch_udc_pcd_set_wedge,
+        .fifo_status    = NULL,
+        .fifo_flush     = pch_udc_pcd_fifo_flush,
+};
+
+/**
+ * pch_udc_init_setup_buff() - This function initializes the SETUP buffer
+ * @td_stp:     Reference to the SETP buffer structure
+ */
+static void pch_udc_init_setup_buff(struct pch_udc_stp_dma_desc *td_stp)
+{
+        static u32      pky_marker;
+
+        if (!td_stp)
+                return;
+        td_stp->reserved = ++pky_marker;
+        memset(&td_stp->request, 0xFF, sizeof td_stp->request);
+        td_stp->status = PCH_UDC_BS_HST_RDY;
+}
+
+/**
+ * pch_udc_start_next_txrequest() - This function starts
+ *                                      the next transmission requirement
+ * @ep: Reference to the endpoint structure
+ */
+static void pch_udc_start_next_txrequest(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request *req;
+        struct pch_udc_data_dma_desc *td_data;
+
+        if (pch_udc_read_ep_control(ep) & UDC_EPCTL_P)
+                return;
+
+        if (list_empty(&ep->queue))
+                return;
+
+        /* next request */
+        req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+        if (req->dma_going)
+                return;
+        if (!req->td_data)
+                return;
+        pch_udc_wait_ep_stall(ep);
+        req->dma_going = 1;
+        pch_udc_ep_set_ddptr(ep, 0);
+        td_data = req->td_data;
+        while (1) {
+                td_data->status = (td_data->status & ~PCH_UDC_BUFF_STS) |
+                                   PCH_UDC_BS_HST_RDY;
+                if ((td_data->status & PCH_UDC_DMA_LAST) == PCH_UDC_DMA_LAST)
+                        break;
+                td_data = phys_to_virt(td_data->next);
+        }
+        pch_udc_ep_set_ddptr(ep, req->td_data_phys);
+        pch_udc_set_dma(ep->dev, DMA_DIR_TX);
+        pch_udc_ep_set_pd(ep);
+        pch_udc_enable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
+        pch_udc_ep_clear_nak(ep);
+}
+
+/**
+ * pch_udc_complete_transfer() - This function completes a transfer
+ * @ep:         Reference to the endpoint structure
+ */
+static void pch_udc_complete_transfer(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request *req;
+        struct pch_udc_dev *dev = ep->dev;
+
+        if (list_empty(&ep->queue))
+                return;
+        req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+        if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
+            PCH_UDC_BS_DMA_DONE)
+                return;
+        if ((req->td_data_last->status & PCH_UDC_RXTX_STS) !=
+             PCH_UDC_RTS_SUCC) {
+                dev_err(&dev->pdev->dev, "Invalid RXTX status (0x%08x) "
+                        "epstatus=0x%08x\n",
+                       (req->td_data_last->status & PCH_UDC_RXTX_STS),
+                       (int)(ep->epsts));
+                return;
+        }
+
+        req->req.actual = req->req.length;
+        req->td_data_last->status = PCH_UDC_BS_HST_BSY | PCH_UDC_DMA_LAST;
+        req->td_data->status = PCH_UDC_BS_HST_BSY | PCH_UDC_DMA_LAST;
+        complete_req(ep, req, 0);
+        req->dma_going = 0;
+        if (!list_empty(&ep->queue)) {
+                pch_udc_wait_ep_stall(ep);
+                pch_udc_ep_clear_nak(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+        } else {
+                pch_udc_disable_ep_interrupts(ep->dev,
+                                              PCH_UDC_EPINT(ep->in, ep->num));
+        }
+}
+
+/**
+ * pch_udc_complete_receiver() - This function completes a receiver
+ * @ep:         Reference to the endpoint structure
+ */
+static void pch_udc_complete_receiver(struct pch_udc_ep *ep)
+{
+        struct pch_udc_request *req;
+        struct pch_udc_dev *dev = ep->dev;
+        unsigned int count;
+
+        if (list_empty(&ep->queue))
+                return;
+
+        /* next request */
+        req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+        if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
+            PCH_UDC_BS_DMA_DONE)
+                return;
+        pch_udc_clear_dma(ep->dev, DMA_DIR_RX);
+        if ((req->td_data_last->status & PCH_UDC_RXTX_STS) !=
+            PCH_UDC_RTS_SUCC) {
+                dev_err(&dev->pdev->dev, "Invalid RXTX status (0x%08x) "
+                        "epstatus=0x%08x\n",
+                        (req->td_data_last->status & PCH_UDC_RXTX_STS),
+                        (int)(ep->epsts));
+                return;
+        }
+        count = req->td_data_last->status & PCH_UDC_RXTX_BYTES;
+
+        /* on 64k packets the RXBYTES field is zero */
+        if (!count && (req->req.length == UDC_DMA_MAXPACKET))
+                count = UDC_DMA_MAXPACKET;
+        req->td_data->status |= PCH_UDC_DMA_LAST;
+        req->td_data_last->status |= PCH_UDC_BS_HST_BSY;
+
+        req->dma_going = 0;
+        req->req.actual = count;
+        complete_req(ep, req, 0);
+        /* If there is a new/failed requests try that now */
+        if (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+                pch_udc_start_rxrequest(ep, req);
+        }
+}
+
+/**
+ * pch_udc_svc_data_in() - This function process endpoint interrupts
+ *                              for IN endpoints
+ * @dev:        Reference to the device structure
+ * @ep_num:     Endpoint that generated the interrupt
+ */
+static void pch_udc_svc_data_in(struct pch_udc_dev *dev, int ep_num)
+{
+        u32     epsts;
+        struct pch_udc_ep       *ep;
+
+        ep = &dev->ep[2*ep_num];
+        epsts = ep->epsts;
+        ep->epsts = 0;
+
+        if (!(epsts & (UDC_EPSTS_IN | UDC_EPSTS_BNA  | UDC_EPSTS_HE |
+                       UDC_EPSTS_TDC | UDC_EPSTS_RCS | UDC_EPSTS_TXEMPTY |
+                       UDC_EPSTS_RSS | UDC_EPSTS_XFERDONE)))
+                return;
+        if ((epsts & UDC_EPSTS_BNA))
+                return;
+        if (epsts & UDC_EPSTS_HE)
+                return;
+        if (epsts & UDC_EPSTS_RSS) {
+                pch_udc_ep_set_stall(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+        }
+        if (epsts & UDC_EPSTS_RCS) {
+                if (!dev->prot_stall) {
+                        pch_udc_ep_clear_stall(ep);
+                } else {
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                }
+        }
+        if (epsts & UDC_EPSTS_TDC)
+                pch_udc_complete_transfer(ep);
+        /* On IN interrupt, provide data if we have any */
+        if ((epsts & UDC_EPSTS_IN) && !(epsts & UDC_EPSTS_RSS) &&
+            !(epsts & UDC_EPSTS_TDC) && !(epsts & UDC_EPSTS_TXEMPTY))
+                pch_udc_start_next_txrequest(ep);
+}
+
+/**
+ * pch_udc_svc_data_out() - Handles interrupts from OUT endpoint
+ * @dev:        Reference to the device structure
+ * @ep_num:     Endpoint that generated the interrupt
+ */
+static void pch_udc_svc_data_out(struct pch_udc_dev *dev, int ep_num)
+{
+        u32                     epsts;
+        struct pch_udc_ep               *ep;
+        struct pch_udc_request          *req = NULL;
+
+        ep = &dev->ep[2*ep_num + 1];
+        epsts = ep->epsts;
+        ep->epsts = 0;
+
+        if ((epsts & UDC_EPSTS_BNA) && (!list_empty(&ep->queue))) {
+                /* next request */
+                req = list_entry(ep->queue.next, struct pch_udc_request,
+                                 queue);
+                if ((req->td_data_last->status & PCH_UDC_BUFF_STS) !=
+                     PCH_UDC_BS_DMA_DONE) {
+                        if (!req->dma_going)
+                                pch_udc_start_rxrequest(ep, req);
+                        return;
+                }
+        }
+        if (epsts & UDC_EPSTS_HE)
+                return;
+        if (epsts & UDC_EPSTS_RSS)
+                pch_udc_ep_set_stall(ep);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+        if (epsts & UDC_EPSTS_RCS) {
+                if (!dev->prot_stall) {
+                        pch_udc_ep_clear_stall(ep);
+                } else {
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                }
+        }
+        if (((epsts & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
+            UDC_EPSTS_OUT_DATA) {
+                if (ep->dev->prot_stall == 1) {
+                        pch_udc_ep_set_stall(ep);
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                } else {
+                        pch_udc_complete_receiver(ep);
+                }
+        }
+        if (list_empty(&ep->queue))
+                pch_udc_set_dma(dev, DMA_DIR_RX);
+}
+
+/**
+ * pch_udc_svc_control_in() - Handle Control IN endpoint interrupts
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_svc_control_in(struct pch_udc_dev *dev)
+{
+        u32     epsts;
+        struct pch_udc_ep       *ep;
+
+        ep = &dev->ep[UDC_EP0IN_IDX];
+        epsts = ep->epsts;
+        ep->epsts = 0;
+
+        if (!(epsts & (UDC_EPSTS_IN | UDC_EPSTS_BNA | UDC_EPSTS_HE |
+                       UDC_EPSTS_TDC | UDC_EPSTS_RCS | UDC_EPSTS_TXEMPTY |
+                       UDC_EPSTS_XFERDONE)))
+                return;
+        if ((epsts & UDC_EPSTS_BNA))
+                return;
+        if (epsts & UDC_EPSTS_HE)
+                return;
+        if ((epsts & UDC_EPSTS_TDC) && (!dev->stall))
+                pch_udc_complete_transfer(ep);
+        /* On IN interrupt, provide data if we have any */
+        if ((epsts & UDC_EPSTS_IN) && !(epsts & UDC_EPSTS_TDC) &&
+             !(epsts & UDC_EPSTS_TXEMPTY))
+                pch_udc_start_next_txrequest(ep);
+}
+
+/**
+ * pch_udc_svc_control_out() - Routine that handle Control
+ *                                      OUT endpoint interrupts
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_svc_control_out(struct pch_udc_dev *dev)
+{
+        u32     stat;
+        int setup_supported;
+        struct pch_udc_ep       *ep;
+
+        ep = &dev->ep[UDC_EP0OUT_IDX];
+        stat = ep->epsts;
+        ep->epsts = 0;
+
+        /* If setup data */
+        if (((stat & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
+            UDC_EPSTS_OUT_SETUP) {
+                dev->stall = 0;
+                dev->ep[UDC_EP0IN_IDX].halted = 0;
+                dev->ep[UDC_EP0OUT_IDX].halted = 0;
+                /* In data not ready */
+                pch_udc_ep_set_nak(&(dev->ep[UDC_EP0IN_IDX]));
+                dev->setup_data = ep->td_stp->request;
+                pch_udc_init_setup_buff(ep->td_stp);
+                pch_udc_clear_dma(dev, DMA_DIR_TX);
+                pch_udc_ep_fifo_flush(&(dev->ep[UDC_EP0IN_IDX]),
+                                      dev->ep[UDC_EP0IN_IDX].in);
+                if ((dev->setup_data.bRequestType & USB_DIR_IN))
+                        dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IDX].ep;
+                else /* OUT */
+                        dev->gadget.ep0 = &ep->ep;
+                spin_unlock(&dev->lock);
+                /* If Mass storage Reset */
+                if ((dev->setup_data.bRequestType == 0x21) &&
+                    (dev->setup_data.bRequest == 0xFF))
+                        dev->prot_stall = 0;
+                /* call gadget with setup data received */
+                setup_supported = dev->driver->setup(&dev->gadget,
+                                                     &dev->setup_data);
+                spin_lock(&dev->lock);
+                /* ep0 in returns data on IN phase */
+                if (setup_supported >= 0 && setup_supported <
+                                            UDC_EP0IN_MAX_PKT_SIZE) {
+                        pch_udc_ep_clear_nak(&(dev->ep[UDC_EP0IN_IDX]));
+                        /* Gadget would have queued a request when
+                         * we called the setup */
+                        pch_udc_set_dma(dev, DMA_DIR_RX);
+                        pch_udc_ep_clear_nak(ep);
+                } else if (setup_supported < 0) {
+                        /* if unsupported request, then stall */
+                        pch_udc_ep_set_stall(&(dev->ep[UDC_EP0IN_IDX]));
+                        pch_udc_enable_ep_interrupts(ep->dev,
+                                                PCH_UDC_EPINT(ep->in, ep->num));
+                        dev->stall = 0;
+                        pch_udc_set_dma(dev, DMA_DIR_RX);
+                } else {
+                        dev->waiting_zlp_ack = 1;
+                }
+        } else if ((((stat & UDC_EPSTS_OUT_MASK) >> UDC_EPSTS_OUT_SHIFT) ==
+                     UDC_EPSTS_OUT_DATA) && !dev->stall) {
+                if (list_empty(&ep->queue)) {
+                        dev_err(&dev->pdev->dev, "%s: No request\n", __func__);
+                        ep->td_data->status = (ep->td_data->status &
+                                               ~PCH_UDC_BUFF_STS) |
+                                               PCH_UDC_BS_HST_RDY;
+                        pch_udc_set_dma(dev, DMA_DIR_RX);
+                } else {
+                        /* control write */
+                        /* next function will pickuo an clear the status */
+                        ep->epsts = stat;
+
+                        pch_udc_svc_data_out(dev, 0);
+                        /* re-program desc. pointer for possible ZLPs */
+                        pch_udc_ep_set_ddptr(ep, ep->td_data_phys);
+                        pch_udc_set_dma(dev, DMA_DIR_RX);
+                }
+        }
+        pch_udc_ep_set_rrdy(ep);
+}
+
+
+/**
+ * pch_udc_postsvc_epinters() - This function enables end point interrupts
+ *                              and clears NAK status
+ * @dev:        Reference to the device structure
+ * @ep_num:     End point number
+ */
+static void pch_udc_postsvc_epinters(struct pch_udc_dev *dev, int ep_num)
+{
+        struct pch_udc_ep       *ep;
+        struct pch_udc_request *req;
+
+        ep = &dev->ep[2*ep_num];
+        if (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next, struct pch_udc_request, queue);
+                pch_udc_enable_ep_interrupts(ep->dev,
+                                             PCH_UDC_EPINT(ep->in, ep->num));
+                pch_udc_ep_clear_nak(ep);
+        }
+}
+
+/**
+ * pch_udc_read_all_epstatus() - This function read all endpoint status
+ * @dev:        Reference to the device structure
+ * @ep_intr:    Status of endpoint interrupt
+ */
+static void pch_udc_read_all_epstatus(struct pch_udc_dev *dev, u32 ep_intr)
+{
+        int i;
+        struct pch_udc_ep       *ep;
+
+        for (i = 0; i < PCH_UDC_USED_EP_NUM; i++) {
+                /* IN */
+                if (ep_intr & (0x1 << i)) {
+                        ep = &dev->ep[2*i];
+                        ep->epsts = pch_udc_read_ep_status(ep);
+                        pch_udc_clear_ep_status(ep, ep->epsts);
+                }
+                /* OUT */
+                if (ep_intr & (0x10000 << i)) {
+                        ep = &dev->ep[2*i+1];
+                        ep->epsts = pch_udc_read_ep_status(ep);
+                        pch_udc_clear_ep_status(ep, ep->epsts);
+                }
+        }
+}
+
+/**
+ * pch_udc_activate_control_ep() - This function enables the control endpoints
+ *                                      for traffic after a reset
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_activate_control_ep(struct pch_udc_dev *dev)
+{
+        struct pch_udc_ep       *ep;
+        u32 val;
+
+        /* Setup the IN endpoint */
+        ep = &dev->ep[UDC_EP0IN_IDX];
+        pch_udc_clear_ep_control(ep);
+        pch_udc_ep_fifo_flush(ep, ep->in);
+        pch_udc_ep_set_bufsz(ep, UDC_EP0IN_BUFF_SIZE, ep->in);
+        pch_udc_ep_set_maxpkt(ep, UDC_EP0IN_MAX_PKT_SIZE);
+        /* Initialize the IN EP Descriptor */
+        ep->td_data      = NULL;
+        ep->td_stp       = NULL;
+        ep->td_data_phys = 0;
+        ep->td_stp_phys  = 0;
+
+        /* Setup the OUT endpoint */
+        ep = &dev->ep[UDC_EP0OUT_IDX];
+        pch_udc_clear_ep_control(ep);
+        pch_udc_ep_fifo_flush(ep, ep->in);
+        pch_udc_ep_set_bufsz(ep, UDC_EP0OUT_BUFF_SIZE, ep->in);
+        pch_udc_ep_set_maxpkt(ep, UDC_EP0OUT_MAX_PKT_SIZE);
+        val = UDC_EP0OUT_MAX_PKT_SIZE << UDC_CSR_NE_MAX_PKT_SHIFT;
+        pch_udc_write_csr(ep->dev, val, UDC_EP0OUT_IDX);
+
+        /* Initialize the SETUP buffer */
+        pch_udc_init_setup_buff(ep->td_stp);
+        /* Write the pointer address of dma descriptor */
+        pch_udc_ep_set_subptr(ep, ep->td_stp_phys);
+        /* Write the pointer address of Setup descriptor */
+        pch_udc_ep_set_ddptr(ep, ep->td_data_phys);
+
+        /* Initialize the dma descriptor */
+        ep->td_data->status  = PCH_UDC_DMA_LAST;
+        ep->td_data->dataptr = dev->dma_addr;
+        ep->td_data->next    = ep->td_data_phys;
+
+        pch_udc_ep_clear_nak(ep);
+}
+
+
+/**
+ * pch_udc_svc_ur_interrupt() - This function handles a USB reset interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_ur_interrupt(struct pch_udc_dev *dev)
+{
+        struct pch_udc_ep       *ep;
+        int i;
+
+        pch_udc_clear_dma(dev, DMA_DIR_TX);
+        pch_udc_clear_dma(dev, DMA_DIR_RX);
+        /* Mask all endpoint interrupts */
+        pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+        /* clear all endpoint interrupts */
+        pch_udc_write_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+
+        for (i = 0; i < PCH_UDC_EP_NUM; i++) {
+                ep = &dev->ep[i];
+                pch_udc_clear_ep_status(ep, UDC_EPSTS_ALL_CLR_MASK);
+                pch_udc_clear_ep_control(ep);
+                pch_udc_ep_set_ddptr(ep, 0);
+                pch_udc_write_csr(ep->dev, 0x00, i);
+        }
+        dev->stall = 0;
+        dev->prot_stall = 0;
+        dev->waiting_zlp_ack = 0;
+        dev->set_cfg_not_acked = 0;
+
+        /* disable ep to empty req queue. Skip the control EP's */
+        for (i = 0; i < (PCH_UDC_USED_EP_NUM*2); i++) {
+                ep = &dev->ep[i];
+                pch_udc_ep_set_nak(ep);
+                pch_udc_ep_fifo_flush(ep, ep->in);
+                /* Complete request queue */
+                empty_req_queue(ep);
+        }
+        if (dev->driver && dev->driver->disconnect)
+                dev->driver->disconnect(&dev->gadget);
+}
+
+/**
+ * pch_udc_svc_enum_interrupt() - This function handles a USB speed enumeration
+ *                              done interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_enum_interrupt(struct pch_udc_dev *dev)
+{
+        u32 dev_stat, dev_speed;
+        u32 speed = USB_SPEED_FULL;
+
+        dev_stat = pch_udc_read_device_status(dev);
+        dev_speed = (dev_stat & UDC_DEVSTS_ENUM_SPEED_MASK) >>
+                                                 UDC_DEVSTS_ENUM_SPEED_SHIFT;
+        switch (dev_speed) {
+        case UDC_DEVSTS_ENUM_SPEED_HIGH:
+                speed = USB_SPEED_HIGH;
+                break;
+        case  UDC_DEVSTS_ENUM_SPEED_FULL:
+                speed = USB_SPEED_FULL;
+                break;
+        case  UDC_DEVSTS_ENUM_SPEED_LOW:
+                speed = USB_SPEED_LOW;
+                break;
+        default:
+                BUG();
+        }
+        dev->gadget.speed = speed;
+        pch_udc_activate_control_ep(dev);
+        pch_udc_enable_ep_interrupts(dev, UDC_EPINT_IN_EP0 | UDC_EPINT_OUT_EP0);
+        pch_udc_set_dma(dev, DMA_DIR_TX);
+        pch_udc_set_dma(dev, DMA_DIR_RX);
+        pch_udc_ep_set_rrdy(&(dev->ep[UDC_EP0OUT_IDX]));
+}
+
+/**
+ * pch_udc_svc_intf_interrupt() - This function handles a set interface
+ *                                interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_intf_interrupt(struct pch_udc_dev *dev)
+{
+        u32 reg, dev_stat = 0;
+        int i, ret;
+
+        dev_stat = pch_udc_read_device_status(dev);
+        dev->cfg_data.cur_intf = (dev_stat & UDC_DEVSTS_INTF_MASK) >>
+                                                         UDC_DEVSTS_INTF_SHIFT;
+        dev->cfg_data.cur_alt = (dev_stat & UDC_DEVSTS_ALT_MASK) >>
+                                                         UDC_DEVSTS_ALT_SHIFT;
+        dev->set_cfg_not_acked = 1;
+        /* Construct the usb request for gadget driver and inform it */
+        memset(&dev->setup_data, 0 , sizeof dev->setup_data);
+        dev->setup_data.bRequest = USB_REQ_SET_INTERFACE;
+        dev->setup_data.bRequestType = USB_RECIP_INTERFACE;
+        dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_alt);
+        dev->setup_data.wIndex = cpu_to_le16(dev->cfg_data.cur_intf);
+        /* programm the Endpoint Cfg registers */
+        /* Only one end point cfg register */
+        reg = pch_udc_read_csr(dev, UDC_EP0OUT_IDX);
+        reg = (reg & ~UDC_CSR_NE_INTF_MASK) |
+              (dev->cfg_data.cur_intf << UDC_CSR_NE_INTF_SHIFT);
+        reg = (reg & ~UDC_CSR_NE_ALT_MASK) |
+              (dev->cfg_data.cur_alt << UDC_CSR_NE_ALT_SHIFT);
+        pch_udc_write_csr(dev, reg, UDC_EP0OUT_IDX);
+        for (i = 0; i < PCH_UDC_USED_EP_NUM * 2; i++) {
+                /* clear stall bits */
+                pch_udc_ep_clear_stall(&(dev->ep[i]));
+                dev->ep[i].halted = 0;
+        }
+        dev->stall = 0;
+        spin_unlock(&dev->lock);
+        ret = dev->driver->setup(&dev->gadget, &dev->setup_data);
+        spin_lock(&dev->lock);
+}
+
+/**
+ * pch_udc_svc_cfg_interrupt() - This function handles a set configuration
+ *                              interrupt
+ * @dev:        Reference to driver structure
+ */
+static void pch_udc_svc_cfg_interrupt(struct pch_udc_dev *dev)
+{
+        int i, ret;
+        u32 reg, dev_stat = 0;
+
+        dev_stat = pch_udc_read_device_status(dev);
+        dev->set_cfg_not_acked = 1;
+        dev->cfg_data.cur_cfg = (dev_stat & UDC_DEVSTS_CFG_MASK) >>
+                                UDC_DEVSTS_CFG_SHIFT;
+        /* make usb request for gadget driver */
+        memset(&dev->setup_data, 0 , sizeof dev->setup_data);
+        dev->setup_data.bRequest = USB_REQ_SET_CONFIGURATION;
+        dev->setup_data.wValue = cpu_to_le16(dev->cfg_data.cur_cfg);
+        /* program the NE registers */
+        /* Only one end point cfg register */
+        reg = pch_udc_read_csr(dev, UDC_EP0OUT_IDX);
+        reg = (reg & ~UDC_CSR_NE_CFG_MASK) |
+              (dev->cfg_data.cur_cfg << UDC_CSR_NE_CFG_SHIFT);
+        pch_udc_write_csr(dev, reg, UDC_EP0OUT_IDX);
+        for (i = 0; i < PCH_UDC_USED_EP_NUM * 2; i++) {
+                /* clear stall bits */
+                pch_udc_ep_clear_stall(&(dev->ep[i]));
+                dev->ep[i].halted = 0;
+        }
+        dev->stall = 0;
+
+        /* call gadget zero with setup data received */
+        spin_unlock(&dev->lock);
+        ret = dev->driver->setup(&dev->gadget, &dev->setup_data);
+        spin_lock(&dev->lock);
+}
+
+/**
+ * pch_udc_dev_isr() - This function services device interrupts
+ *                      by invoking appropriate routines.
+ * @dev:        Reference to the device structure
+ * @dev_intr:   The Device interrupt status.
+ */
+static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
+{
+        /* USB Reset Interrupt */
+        if (dev_intr & UDC_DEVINT_UR)
+                pch_udc_svc_ur_interrupt(dev);
+        /* Enumeration Done Interrupt */
+        if (dev_intr & UDC_DEVINT_ENUM)
+                pch_udc_svc_enum_interrupt(dev);
+        /* Set Interface Interrupt */
+        if (dev_intr & UDC_DEVINT_SI)
+                pch_udc_svc_intf_interrupt(dev);
+        /* Set Config Interrupt */
+        if (dev_intr & UDC_DEVINT_SC)
+                pch_udc_svc_cfg_interrupt(dev);
+        /* USB Suspend interrupt */
+        if (dev_intr & UDC_DEVINT_US)
+                dev_dbg(&dev->pdev->dev, "USB_SUSPEND\n");
+        /* Clear the SOF interrupt, if enabled */
+        if (dev_intr & UDC_DEVINT_SOF)
+                dev_dbg(&dev->pdev->dev, "SOF\n");
+        /* ES interrupt, IDLE > 3ms on the USB */
+        if (dev_intr & UDC_DEVINT_ES)
+                dev_dbg(&dev->pdev->dev, "ES\n");
+        /* RWKP interrupt */
+        if (dev_intr & UDC_DEVINT_RWKP)
+                dev_dbg(&dev->pdev->dev, "RWKP\n");
+}
+
+/**
+ * pch_udc_isr() - This function handles interrupts from the PCH USB Device
+ * @irq:        Interrupt request number
+ * @dev:        Reference to the device structure
+ */
+static irqreturn_t pch_udc_isr(int irq, void *pdev)
+{
+        struct pch_udc_dev *dev = (struct pch_udc_dev *) pdev;
+        u32 dev_intr, ep_intr;
+        int i;
+
+        dev_intr = pch_udc_read_device_interrupts(dev);
+        ep_intr = pch_udc_read_ep_interrupts(dev);
+
+        if (dev_intr)
+                /* Clear device interrupts */
+                pch_udc_write_device_interrupts(dev, dev_intr);
+        if (ep_intr)
+                /* Clear ep interrupts */
+                pch_udc_write_ep_interrupts(dev, ep_intr);
+        if (!dev_intr && !ep_intr)
+                return IRQ_NONE;
+        spin_lock(&dev->lock);
+        if (dev_intr)
+                pch_udc_dev_isr(dev, dev_intr);
+        if (ep_intr) {
+                pch_udc_read_all_epstatus(dev, ep_intr);
+                /* Process Control In interrupts, if present */
+                if (ep_intr & UDC_EPINT_IN_EP0) {
+                        pch_udc_svc_control_in(dev);
+                        pch_udc_postsvc_epinters(dev, 0);
+                }
+                /* Process Control Out interrupts, if present */
+                if (ep_intr & UDC_EPINT_OUT_EP0)
+                        pch_udc_svc_control_out(dev);
+                /* Process data in end point interrupts */
+                for (i = 1; i < PCH_UDC_USED_EP_NUM; i++) {
+                        if (ep_intr & (1 <<  i)) {
+                                pch_udc_svc_data_in(dev, i);
+                                pch_udc_postsvc_epinters(dev, i);
+                        }
+                }
+                /* Process data out end point interrupts */
+                for (i = UDC_EPINT_OUT_SHIFT + 1; i < (UDC_EPINT_OUT_SHIFT +
+                                                 PCH_UDC_USED_EP_NUM); i++)
+                        if (ep_intr & (1 <<  i))
+                                pch_udc_svc_data_out(dev, i -
+                                                         UDC_EPINT_OUT_SHIFT);
+        }
+        spin_unlock(&dev->lock);
+        return IRQ_HANDLED;
+}
+
+/**
+ * pch_udc_setup_ep0() - This function enables control endpoint for traffic
+ * @dev:        Reference to the device structure
+ */
+static void pch_udc_setup_ep0(struct pch_udc_dev *dev)
+{
+        /* enable ep0 interrupts */
+        pch_udc_enable_ep_interrupts(dev, UDC_EPINT_IN_EP0 |
+                                                UDC_EPINT_OUT_EP0);
+        /* enable device interrupts */
+        pch_udc_enable_interrupts(dev, UDC_DEVINT_UR | UDC_DEVINT_US |
+                                       UDC_DEVINT_ES | UDC_DEVINT_ENUM |
+                                       UDC_DEVINT_SI | UDC_DEVINT_SC);
+}
+
+/**
+ * gadget_release() - Free the gadget driver private data
+ * @pdev        reference to struct pci_dev
+ */
+static void gadget_release(struct device *pdev)
+{
+        struct pch_udc_dev *dev = dev_get_drvdata(pdev);
+
+        kfree(dev);
+}
+
+/**
+ * pch_udc_pcd_reinit() - This API initializes the endpoint structures
+ * @dev:        Reference to the driver structure
+ */
+static void pch_udc_pcd_reinit(struct pch_udc_dev *dev)
+{
+        const char *const ep_string[] = {
+                ep0_string, "ep0out", "ep1in", "ep1out", "ep2in", "ep2out",
+                "ep3in", "ep3out", "ep4in", "ep4out", "ep5in", "ep5out",
+                "ep6in", "ep6out", "ep7in", "ep7out", "ep8in", "ep8out",
+                "ep9in", "ep9out", "ep10in", "ep10out", "ep11in", "ep11out",
+                "ep12in", "ep12out", "ep13in", "ep13out", "ep14in", "ep14out",
+                "ep15in", "ep15out",
+        };
+        int i;
+
+        dev->gadget.speed = USB_SPEED_UNKNOWN;
+        INIT_LIST_HEAD(&dev->gadget.ep_list);
+
+        /* Initialize the endpoints structures */
+        memset(dev->ep, 0, sizeof dev->ep);
+        for (i = 0; i < PCH_UDC_EP_NUM; i++) {
+                struct pch_udc_ep *ep = &dev->ep[i];
+                ep->dev = dev;
+                ep->halted = 1;
+                ep->num = i / 2;
+                ep->in = ~i & 1;
+                ep->ep.name = ep_string[i];
+                ep->ep.ops = &pch_udc_ep_ops;
+                if (ep->in)
+                        ep->offset_addr = ep->num * UDC_EP_REG_SHIFT;
+                else
+                        ep->offset_addr = (UDC_EPINT_OUT_SHIFT + ep->num) *
+                                          UDC_EP_REG_SHIFT;
+                /* need to set ep->ep.maxpacket and set Default Configuration?*/
+                ep->ep.maxpacket = UDC_BULK_MAX_PKT_SIZE;
+                list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
+                INIT_LIST_HEAD(&ep->queue);
+        }
+        dev->ep[UDC_EP0IN_IDX].ep.maxpacket = UDC_EP0IN_MAX_PKT_SIZE;
+        dev->ep[UDC_EP0OUT_IDX].ep.maxpacket = UDC_EP0OUT_MAX_PKT_SIZE;
+
+        dev->dma_addr = pci_map_single(dev->pdev, dev->ep0out_buf, 256,
+                                  PCI_DMA_FROMDEVICE);
+
+        /* remove ep0 in and out from the list.  They have own pointer */
+        list_del_init(&dev->ep[UDC_EP0IN_IDX].ep.ep_list);
+        list_del_init(&dev->ep[UDC_EP0OUT_IDX].ep.ep_list);
+
+        dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IDX].ep;
+        INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
+}
+
+/**
+ * pch_udc_pcd_init() - This API initializes the driver structure
+ * @dev:        Reference to the driver structure
+ *
+ * Return codes:
+ *      0: Success
+ */
+static int pch_udc_pcd_init(struct pch_udc_dev *dev)
+{
+        pch_udc_init(dev);
+        pch_udc_pcd_reinit(dev);
+        return 0;
+}
+
+/**
+ * init_dma_pools() - create dma pools during initialization
+ * @pdev:       reference to struct pci_dev
+ */
+static int init_dma_pools(struct pch_udc_dev *dev)
+{
+        struct pch_udc_stp_dma_desc     *td_stp;
+        struct pch_udc_data_dma_desc    *td_data;
+
+        /* DMA setup */
+        dev->data_requests = pci_pool_create("data_requests", dev->pdev,
+                sizeof(struct pch_udc_data_dma_desc), 0, 0);
+        if (!dev->data_requests) {
+                dev_err(&dev->pdev->dev, "%s: can't get request data pool\n",
+                        __func__);
+                return -ENOMEM;
+        }
+
+        /* dma desc for setup data */
+        dev->stp_requests = pci_pool_create("setup requests", dev->pdev,
+                sizeof(struct pch_udc_stp_dma_desc), 0, 0);
+        if (!dev->stp_requests) {
+                dev_err(&dev->pdev->dev, "%s: can't get setup request pool\n",
+                        __func__);
+                return -ENOMEM;
+        }
+        /* setup */
+        td_stp = pci_pool_alloc(dev->stp_requests, GFP_KERNEL,
+                                &dev->ep[UDC_EP0OUT_IDX].td_stp_phys);
+        if (!td_stp) {
+                dev_err(&dev->pdev->dev,
+                        "%s: can't allocate setup dma descriptor\n", __func__);
+                return -ENOMEM;
+        }
+        dev->ep[UDC_EP0OUT_IDX].td_stp = td_stp;
+
+        /* data: 0 packets !? */
+        td_data = pci_pool_alloc(dev->data_requests, GFP_KERNEL,
+                                &dev->ep[UDC_EP0OUT_IDX].td_data_phys);
+        if (!td_data) {
+                dev_err(&dev->pdev->dev,
+                        "%s: can't allocate data dma descriptor\n", __func__);
+                return -ENOMEM;
+        }
+        dev->ep[UDC_EP0OUT_IDX].td_data = td_data;
+        dev->ep[UDC_EP0IN_IDX].td_stp = NULL;
+        dev->ep[UDC_EP0IN_IDX].td_stp_phys = 0;
+        dev->ep[UDC_EP0IN_IDX].td_data = NULL;
+        dev->ep[UDC_EP0IN_IDX].td_data_phys = 0;
+        return 0;
+}
+
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
+        int (*bind)(struct usb_gadget *))
+{
+        struct pch_udc_dev      *dev = pch_udc;
+        int                     retval;
+
+        if (!driver || (driver->speed == USB_SPEED_UNKNOWN) || !bind ||
+            !driver->setup || !driver->unbind || !driver->disconnect) {
+                dev_err(&dev->pdev->dev,
+                        "%s: invalid driver parameter\n", __func__);
+                return -EINVAL;
+        }
+
+        if (!dev)
+                return -ENODEV;
+
+        if (dev->driver) {
+                dev_err(&dev->pdev->dev, "%s: already bound\n", __func__);
+                return -EBUSY;
+        }
+        driver->driver.bus = NULL;
+        dev->driver = driver;
+        dev->gadget.dev.driver = &driver->driver;
+
+        /* Invoke the bind routine of the gadget driver */
+        retval = bind(&dev->gadget);
+
+        if (retval) {
+                dev_err(&dev->pdev->dev, "%s: binding to %s returning %d\n",
+                       __func__, driver->driver.name, retval);
+                dev->driver = NULL;
+                dev->gadget.dev.driver = NULL;
+                return retval;
+        }
+        /* get ready for ep0 traffic */
+        pch_udc_setup_ep0(dev);
+
+        /* clear SD */
+        pch_udc_clear_disconnect(dev);
+
+        dev->connected = 1;
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_probe_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct pch_udc_dev      *dev = pch_udc;
+
+        if (!dev)
+                return -ENODEV;
+
+        if (!driver || (driver != dev->driver)) {
+                dev_err(&dev->pdev->dev,
+                        "%s: invalid driver parameter\n", __func__);
+                return -EINVAL;
+        }
+
+        pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
+
+        /* Assues that there are no pending requets with this driver */
+        driver->unbind(&dev->gadget);
+        dev->gadget.dev.driver = NULL;
+        dev->driver = NULL;
+        dev->connected = 0;
+
+        /* set SD */
+        pch_udc_set_disconnect(dev);
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+static void pch_udc_shutdown(struct pci_dev *pdev)
+{
+        struct pch_udc_dev *dev = pci_get_drvdata(pdev);
+
+        pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
+        pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+
+        /* disable the pullup so the host will think we're gone */
+        pch_udc_set_disconnect(dev);
+}
+
+static void pch_udc_remove(struct pci_dev *pdev)
+{
+        struct pch_udc_dev      *dev = pci_get_drvdata(pdev);
+
+        /* gadget driver must not be registered */
+        if (dev->driver)
+                dev_err(&pdev->dev,
+                        "%s: gadget driver still bound!!!\n", __func__);
+        /* dma pool cleanup */
+        if (dev->data_requests)
+                pci_pool_destroy(dev->data_requests);
+
+        if (dev->stp_requests) {
+                /* cleanup DMA desc's for ep0in */
+                if (dev->ep[UDC_EP0OUT_IDX].td_stp) {
+                        pci_pool_free(dev->stp_requests,
+                                dev->ep[UDC_EP0OUT_IDX].td_stp,
+                                dev->ep[UDC_EP0OUT_IDX].td_stp_phys);
+                }
+                if (dev->ep[UDC_EP0OUT_IDX].td_data) {
+                        pci_pool_free(dev->stp_requests,
+                                dev->ep[UDC_EP0OUT_IDX].td_data,
+                                dev->ep[UDC_EP0OUT_IDX].td_data_phys);
+                }
+                pci_pool_destroy(dev->stp_requests);
+        }
+
+        pch_udc_exit(dev);
+
+        if (dev->irq_registered)
+                free_irq(pdev->irq, dev);
+        if (dev->base_addr)
+                iounmap(dev->base_addr);
+        if (dev->mem_region)
+                release_mem_region(dev->phys_addr,
+                                   pci_resource_len(pdev, PCH_UDC_PCI_BAR));
+        if (dev->active)
+                pci_disable_device(pdev);
+        if (dev->registered)
+                device_unregister(&dev->gadget.dev);
+        kfree(dev);
+        pci_set_drvdata(pdev, NULL);
+}
+
+#ifdef CONFIG_PM
+static int pch_udc_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        struct pch_udc_dev *dev = pci_get_drvdata(pdev);
+
+        pch_udc_disable_interrupts(dev, UDC_DEVINT_MSK);
+        pch_udc_disable_ep_interrupts(dev, UDC_EPINT_MSK_DISABLE_ALL);
+
+        pci_disable_device(pdev);
+        pci_enable_wake(pdev, PCI_D3hot, 0);
+
+        if (pci_save_state(pdev)) {
+                dev_err(&pdev->dev,
+                        "%s: could not save PCI config state\n", __func__);
+                return -ENOMEM;
+        }
+        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+        return 0;
+}
+
+static int pch_udc_resume(struct pci_dev *pdev)
+{
+        int ret;
+
+        pci_set_power_state(pdev, PCI_D0);
+        ret = pci_restore_state(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "%s: pci_restore_state failed\n", __func__);
+                return ret;
+        }
+        ret = pci_enable_device(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "%s: pci_enable_device failed\n", __func__);
+                return ret;
+        }
+        pci_enable_wake(pdev, PCI_D3hot, 0);
+        return 0;
+}
+#else
+#define pch_udc_suspend NULL
+#define pch_udc_resume  NULL
+#endif /* CONFIG_PM */
+
+static int pch_udc_probe(struct pci_dev *pdev,
+                          const struct pci_device_id *id)
+{
+        unsigned long           resource;
+        unsigned long           len;
+        int                     retval;
+        struct pch_udc_dev      *dev;
+
+        /* one udc only */
+        if (pch_udc) {
+                pr_err("%s: already probed\n", __func__);
+                return -EBUSY;
+        }
+        /* init */
+        dev = kzalloc(sizeof *dev, GFP_KERNEL);
+        if (!dev) {
+                pr_err("%s: no memory for device structure\n", __func__);
+                return -ENOMEM;
+        }
+        /* pci setup */
+        if (pci_enable_device(pdev) < 0) {
+                kfree(dev);
+                pr_err("%s: pci_enable_device failed\n", __func__);
+                return -ENODEV;
+        }
+        dev->active = 1;
+        pci_set_drvdata(pdev, dev);
+
+        /* PCI resource allocation */
+        resource = pci_resource_start(pdev, 1);
+        len = pci_resource_len(pdev, 1);
+
+        if (!request_mem_region(resource, len, KBUILD_MODNAME)) {
+                dev_err(&pdev->dev, "%s: pci device used already\n", __func__);
+                retval = -EBUSY;
+                goto finished;
+        }
+        dev->phys_addr = resource;
+        dev->mem_region = 1;
+
+        dev->base_addr = ioremap_nocache(resource, len);
+        if (!dev->base_addr) {
+                pr_err("%s: device memory cannot be mapped\n", __func__);
+                retval = -ENOMEM;
+                goto finished;
+        }
+        if (!pdev->irq) {
+                dev_err(&pdev->dev, "%s: irq not set\n", __func__);
+                retval = -ENODEV;
+                goto finished;
+        }
+        pch_udc = dev;
+        /* initialize the hardware */
+        if (pch_udc_pcd_init(dev))
+                goto finished;
+        if (request_irq(pdev->irq, pch_udc_isr, IRQF_SHARED, KBUILD_MODNAME,
+                        dev)) {
+                dev_err(&pdev->dev, "%s: request_irq(%d) fail\n", __func__,
+                        pdev->irq);
+                retval = -ENODEV;
+                goto finished;
+        }
+        dev->irq = pdev->irq;
+        dev->irq_registered = 1;
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        /* device struct setup */
+        spin_lock_init(&dev->lock);
+        dev->pdev = pdev;
+        dev->gadget.ops = &pch_udc_ops;
+
+        retval = init_dma_pools(dev);
+        if (retval)
+                goto finished;
+
+        dev_set_name(&dev->gadget.dev, "gadget");
+        dev->gadget.dev.parent = &pdev->dev;
+        dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
+        dev->gadget.dev.release = gadget_release;
+        dev->gadget.name = KBUILD_MODNAME;
+        dev->gadget.is_dualspeed = 1;
+
+        retval = device_register(&dev->gadget.dev);
+        if (retval)
+                goto finished;
+        dev->registered = 1;
+
+        /* Put the device in disconnected state till a driver is bound */
+        pch_udc_set_disconnect(dev);
+        return 0;
+
+finished:
+        pch_udc_remove(pdev);
+        return retval;
+}
+
+static DEFINE_PCI_DEVICE_TABLE(pch_udc_pcidev_id) = {
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EG20T_UDC),
+                .class = (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
+                .class_mask = 0xffffffff,
+        },
+        { 0 },
+};
+
+MODULE_DEVICE_TABLE(pci, pch_udc_pcidev_id);
+
+
+static struct pci_driver pch_udc_driver = {
+        .name = KBUILD_MODNAME,
+        .id_table =     pch_udc_pcidev_id,
+        .probe =        pch_udc_probe,
+        .remove =       pch_udc_remove,
+        .suspend =      pch_udc_suspend,
+        .resume =       pch_udc_resume,
+        .shutdown =     pch_udc_shutdown,
+};
+
+static int __init pch_udc_pci_init(void)
+{
+        return pci_register_driver(&pch_udc_driver);
+}
+module_init(pch_udc_pci_init);
+
+static void __exit pch_udc_pci_exit(void)
+{
+        pci_unregister_driver(&pch_udc_driver);
+}
+module_exit(pch_udc_pci_exit);
+
+MODULE_DESCRIPTION("Intel EG20T USB Device Controller");
+MODULE_AUTHOR("OKI SEMICONDUCTOR, <toshiharu-linux@dsn.okisemi.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/u_audio.c b/drivers/usb/gadget/u_audio.c
index 7a86d2c9109c..59ffe1ecf1c9 100644
--- a/drivers/usb/gadget/u_audio.c
+++ b/drivers/usb/gadget/u_audio.c
@@ -255,6 +255,7 @@ static int gaudio_open_snd_dev(struct gaudio *card)
                 ERROR(card, "No such PCM capture device: %s\n", fn_cap);
                 snd->substream = NULL;
                 snd->card = NULL;
+                snd->filp = NULL;
         } else {
                 pcm_file = snd->filp->private_data;
                 snd->substream = pcm_file->substream;
@@ -273,17 +274,17 @@ static int gaudio_close_snd_dev(struct gaudio *gau)
 
         /* Close control device */
         snd = &gau->control;
-        if (!IS_ERR(snd->filp))
+        if (snd->filp)
                 filp_close(snd->filp, current->files);
 
         /* Close PCM playback device and setup substream */
         snd = &gau->playback;
-        if (!IS_ERR(snd->filp))
+        if (snd->filp)
                 filp_close(snd->filp, current->files);
 
         /* Close PCM capture device and setup substream */
         snd = &gau->capture;
-        if (!IS_ERR(snd->filp))
+        if (snd->filp)
                 filp_close(snd->filp, current->files);
 
         return 0;
@@ -304,8 +305,7 @@ int __init gaudio_setup(struct gaudio *card)
         ret = gaudio_open_snd_dev(card);
         if (ret)
                 ERROR(card, "we need at least one control device\n");
-
-        if (!the_card)
+        else if (!the_card)
                 the_card = card;
 
         return ret;
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index fbe86ca95802..e3454fe46b47 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -240,6 +240,9 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
         size += out->maxpacket - 1;
         size -= size % out->maxpacket;
 
+        if (dev->port_usb->is_fixed)
+                size = max(size, dev->port_usb->fixed_out_len);
+
         skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
         if (skb == NULL) {
                 DBG(dev, "no rx skb\n");
@@ -578,12 +581,19 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
         req->context = skb;
         req->complete = tx_complete;
 
+        /* NCM requires no zlp if transfer is dwNtbInMaxSize */
+        if (dev->port_usb->is_fixed &&
+            length == dev->port_usb->fixed_in_len &&
+            (length % in->maxpacket) == 0)
+                req->zero = 0;
+        else
+                req->zero = 1;
+
         /* use zlp framing on tx for strict CDC-Ether conformance,
          * though any robust network rx path ignores extra padding.
          * and some hardware doesn't like to write zlps.
          */
-        req->zero = 1;
-        if (!dev->zlp && (length % in->maxpacket) == 0)
+        if (req->zero && !dev->zlp && (length % in->maxpacket) == 0)
                 length++;
 
         req->length = length;
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
index 3c8c0c9f9d72..b56e1e7d423c 100644
--- a/drivers/usb/gadget/u_ether.h
+++ b/drivers/usb/gadget/u_ether.h
@@ -62,6 +62,10 @@ struct gether {
 
         /* hooks for added framing, as needed for RNDIS and EEM. */
         u32                             header_len;
+        /* NCM requires fixed size bundles */
+        bool                            is_fixed;
+        u32                             fixed_out_len;
+        u32                             fixed_in_len;
         struct sk_buff                  *(*wrap)(struct gether *port,
                                                 struct sk_buff *skb);
         int                             (*unwrap)(struct gether *port,
@@ -103,6 +107,7 @@ static inline bool can_support_ecm(struct usb_gadget *gadget)
 /* each configuration may bind one instance of an ethernet link */
 int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
+int ncm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
 int eem_bind_config(struct usb_configuration *c);
 
 #ifdef USB_ETH_RNDIS
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index f8970d151d2a..24046c0f5878 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -133,6 +133,25 @@ config USB_EHCI_MXC
         ---help---
           Variation of ARC USB block used in some Freescale chips.
 
+config USB_EHCI_HCD_OMAP
+        bool "EHCI support for OMAP3 and later chips"
+        depends on USB_EHCI_HCD && ARCH_OMAP
+        default y
+        --- help ---
+          Enables support for the on-chip EHCI controller on
+          OMAP3 and later chips.
+
+config USB_EHCI_MSM
+        bool "Support for MSM on-chip EHCI USB controller"
+        depends on USB_EHCI_HCD && ARCH_MSM
+        select USB_EHCI_ROOT_HUB_TT
+        select USB_MSM_OTG_72K
+        ---help---
+          Enables support for the USB Host controller present on the
+          Qualcomm chipsets. Root Hub has inbuilt TT.
+          This driver depends on OTG driver for PHY initialization,
+          clock management, powering up VBUS, and power management.
+
 config USB_EHCI_HCD_PPC_OF
         bool "EHCI support for PPC USB controller on OF platform bus"
         depends on USB_EHCI_HCD && PPC_OF
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 51bd0edf544f..d6a69d514a84 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -99,6 +99,7 @@ static const struct hc_driver ehci_atmel_hc_driver = {
         .urb_enqueue            = ehci_urb_enqueue,
         .urb_dequeue            = ehci_urb_dequeue,
         .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
 
         /* scheduling support */
         .get_frame_number       = ehci_get_frame,
@@ -110,6 +111,8 @@ static const struct hc_driver ehci_atmel_hc_driver = {
         .bus_resume             = ehci_bus_resume,
         .relinquish_port        = ehci_relinquish_port,
         .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 };
 
 static int __init ehci_atmel_drv_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 6e2599661b5b..3be238a24cc5 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -879,7 +879,7 @@ static int fill_buffer(struct debug_buffer *buf)
         int ret = 0;
 
         if (!buf->output_buf)
-                buf->output_buf = (char *)vmalloc(buf->alloc_size);
+                buf->output_buf = vmalloc(buf->alloc_size);
 
         if (!buf->output_buf) {
                 ret = -ENOMEM;
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index d0c8f7c03e05..6fee3cd58efe 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -114,6 +114,9 @@ MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us\n");
 
 #define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
 
+/* for ASPM quirk of ISOC on AMD SB800 */
+static struct pci_dev *amd_nb_dev;
+
 /*-------------------------------------------------------------------------*/
 
 #include "ehci.h"
@@ -529,6 +532,11 @@ static void ehci_stop (struct usb_hcd *hcd)
         spin_unlock_irq (&ehci->lock);
         ehci_mem_cleanup (ehci);
 
+        if (amd_nb_dev) {
+                pci_dev_put(amd_nb_dev);
+                amd_nb_dev = NULL;
+        }
+
 #ifdef  EHCI_STATS
         ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
                 ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
@@ -1166,12 +1174,17 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         ehci_mxc_driver
 #endif
 
+#ifdef CONFIG_CPU_SUBTYPE_SH7786
+#include "ehci-sh.c"
+#define PLATFORM_DRIVER         ehci_hcd_sh_driver
+#endif
+
 #ifdef CONFIG_SOC_AU1200
 #include "ehci-au1xxx.c"
 #define PLATFORM_DRIVER         ehci_hcd_au1xxx_driver
 #endif
 
-#ifdef CONFIG_ARCH_OMAP3
+#ifdef CONFIG_USB_EHCI_HCD_OMAP
 #include "ehci-omap.c"
 #define        PLATFORM_DRIVER         ehci_hcd_omap_driver
 #endif
@@ -1221,6 +1234,21 @@ MODULE_LICENSE ("GPL");
 #define PLATFORM_DRIVER         cns3xxx_ehci_driver
 #endif
 
+#ifdef CONFIG_ARCH_VT8500
+#include "ehci-vt8500.c"
+#define PLATFORM_DRIVER         vt8500_ehci_driver
+#endif
+
+#ifdef CONFIG_PLAT_SPEAR
+#include "ehci-spear.c"
+#define PLATFORM_DRIVER         spear_ehci_hcd_driver
+#endif
+
+#ifdef CONFIG_USB_EHCI_MSM
+#include "ehci-msm.c"
+#define PLATFORM_DRIVER         ehci_msm_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
     !defined(XILINX_OF_PLATFORM_DRIVER)
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
new file mode 100644
index 000000000000..413f4deca532
--- /dev/null
+++ b/drivers/usb/host/ehci-msm.c
@@ -0,0 +1,345 @@
+/* ehci-msm.c - HSUSB Host Controller Driver Implementation
+ *
+ * Copyright (c) 2008-2010, Code Aurora Forum. All rights reserved.
+ *
+ * Partly derived from ehci-fsl.c and ehci-hcd.c
+ * Copyright (c) 2000-2004 by David Brownell
+ * Copyright (c) 2005 MontaVista Software
+ *
+ * All source code in this file is licensed under the following license except
+ * where indicated.
+ *
+ * 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 program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you can find it at http://www.fsf.org
+ */
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/usb/otg.h>
+#include <linux/usb/msm_hsusb_hw.h>
+
+#define MSM_USB_BASE (hcd->regs)
+
+static struct otg_transceiver *otg;
+
+/*
+ * ehci_run defined in drivers/usb/host/ehci-hcd.c reset the controller and
+ * the configuration settings in ehci_msm_reset vanish after controller is
+ * reset. Resetting the controler in ehci_run seems to be un-necessary
+ * provided HCD reset the controller before calling ehci_run. Most of the HCD
+ * do but some are not. So this function is same as ehci_run but we don't
+ * reset the controller here.
+ */
+static int ehci_msm_run(struct usb_hcd *hcd)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
+        u32                     temp;
+        u32                     hcc_params;
+
+        hcd->uses_new_polling = 1;
+
+        ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
+        ehci_writel(ehci, (u32)ehci->async->qh_dma, &ehci->regs->async_next);
+
+        /*
+         * hcc_params controls whether ehci->regs->segment must (!!!)
+         * be used; it constrains QH/ITD/SITD and QTD locations.
+         * pci_pool consistent memory always uses segment zero.
+         * streaming mappings for I/O buffers, like pci_map_single(),
+         * can return segments above 4GB, if the device allows.
+         *
+         * NOTE:  the dma mask is visible through dma_supported(), so
+         * drivers can pass this info along ... like NETIF_F_HIGHDMA,
+         * Scsi_Host.highmem_io, and so forth.  It's readonly to all
+         * host side drivers though.
+         */
+        hcc_params = ehci_readl(ehci, &ehci->caps->hcc_params);
+        if (HCC_64BIT_ADDR(hcc_params))
+                ehci_writel(ehci, 0, &ehci->regs->segment);
+
+        /*
+         * Philips, Intel, and maybe others need CMD_RUN before the
+         * root hub will detect new devices (why?); NEC doesn't
+         */
+        ehci->command &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
+        ehci->command |= CMD_RUN;
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        dbg_cmd(ehci, "init", ehci->command);
+
+        /*
+         * Start, enabling full USB 2.0 functionality ... usb 1.1 devices
+         * are explicitly handed to companion controller(s), so no TT is
+         * involved with the root hub.  (Except where one is integrated,
+         * and there's no companion controller unless maybe for USB OTG.)
+         *
+         * Turning on the CF flag will transfer ownership of all ports
+         * from the companions to the EHCI controller.  If any of the
+         * companions are in the middle of a port reset at the time, it
+         * could cause trouble.  Write-locking ehci_cf_port_reset_rwsem
+         * guarantees that no resets are in progress.  After we set CF,
+         * a short delay lets the hardware catch up; new resets shouldn't
+         * be started before the port switching actions could complete.
+         */
+        down_write(&ehci_cf_port_reset_rwsem);
+        hcd->state = HC_STATE_RUNNING;
+        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+        ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
+        usleep_range(5000, 5500);
+        up_write(&ehci_cf_port_reset_rwsem);
+        ehci->last_periodic_enable = ktime_get_real();
+
+        temp = HC_VERSION(ehci_readl(ehci, &ehci->caps->hc_capbase));
+        ehci_info(ehci,
+                "USB %x.%x started, EHCI %x.%02x%s\n",
+                ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
+                temp >> 8, temp & 0xff,
+                ignore_oc ? ", overcurrent ignored" : "");
+
+        ehci_writel(ehci, INTR_MASK,
+                    &ehci->regs->intr_enable); /* Turn On Interrupts */
+
+        /* GRR this is run-once init(), being done every time the HC starts.
+         * So long as they're part of class devices, we can't do it init()
+         * since the class device isn't created that early.
+         */
+        create_debug_files(ehci);
+        create_companion_file(ehci);
+
+        return 0;
+}
+
+static int ehci_msm_reset(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        ehci->caps = USB_CAPLENGTH;
+        ehci->regs = USB_CAPLENGTH +
+                HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+
+        /* cache the data to minimize the chip reads*/
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        hcd->has_tt = 1;
+        ehci->sbrn = HCD_USB2;
+
+        /* data structure init */
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        retval = ehci_reset(ehci);
+        if (retval)
+                return retval;
+
+        /* bursts of unspecified length. */
+        writel(0, USB_AHBBURST);
+        /* Use the AHB transactor */
+        writel(0, USB_AHBMODE);
+        /* Disable streaming mode and select host mode */
+        writel(0x13, USB_USBMODE);
+
+        ehci_port_power(ehci, 1);
+        return 0;
+}
+
+static struct hc_driver msm_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Qualcomm On-Chip EHCI Host Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_USB2 | HCD_MEMORY,
+
+        .reset                  = ehci_msm_reset,
+        .start                  = ehci_msm_run,
+
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        /*
+         * PM support
+         */
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+};
+
+static int ehci_msm_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res;
+        int ret;
+
+        dev_dbg(&pdev->dev, "ehci_msm proble\n");
+
+        hcd = usb_create_hcd(&msm_hc_driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_err(&pdev->dev, "Unable to create HCD\n");
+                return  -ENOMEM;
+        }
+
+        hcd->irq = platform_get_irq(pdev, 0);
+        if (hcd->irq < 0) {
+                dev_err(&pdev->dev, "Unable to get IRQ resource\n");
+                ret = hcd->irq;
+                goto put_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Unable to get memory resource\n");
+                ret = -ENODEV;
+                goto put_hcd;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENOMEM;
+                goto put_hcd;
+        }
+
+        /*
+         * OTG driver takes care of PHY initialization, clock management,
+         * powering up VBUS, mapping of registers address space and power
+         * management.
+         */
+        otg = otg_get_transceiver();
+        if (!otg) {
+                dev_err(&pdev->dev, "unable to find transceiver\n");
+                ret = -ENODEV;
+                goto unmap;
+        }
+
+        ret = otg_set_host(otg, &hcd->self);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "unable to register with transceiver\n");
+                goto put_transceiver;
+        }
+
+        device_init_wakeup(&pdev->dev, 1);
+        /*
+         * OTG device parent of HCD takes care of putting
+         * hardware into low power mode.
+         */
+        pm_runtime_no_callbacks(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        return 0;
+
+put_transceiver:
+        otg_put_transceiver(otg);
+unmap:
+        iounmap(hcd->regs);
+put_hcd:
+        usb_put_hcd(hcd);
+
+        return ret;
+}
+
+static int __devexit ehci_msm_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        device_init_wakeup(&pdev->dev, 0);
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_set_suspended(&pdev->dev);
+
+        otg_set_host(otg, NULL);
+        otg_put_transceiver(otg);
+
+        usb_put_hcd(hcd);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ehci_msm_pm_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        bool wakeup = device_may_wakeup(dev);
+
+        dev_dbg(dev, "ehci-msm PM suspend\n");
+
+        /*
+         * EHCI helper function has also the same check before manipulating
+         * port wakeup flags.  We do check here the same condition before
+         * calling the same helper function to avoid bringing hardware
+         * from Low power mode when there is no need for adjusting port
+         * wakeup flags.
+         */
+        if (hcd->self.root_hub->do_remote_wakeup && !wakeup) {
+                pm_runtime_resume(dev);
+                ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd),
+                                wakeup);
+        }
+
+        return 0;
+}
+
+static int ehci_msm_pm_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "ehci-msm PM resume\n");
+        ehci_prepare_ports_for_controller_resume(hcd_to_ehci(hcd));
+
+        return 0;
+}
+#else
+#define ehci_msm_pm_suspend     NULL
+#define ehci_msm_pm_resume      NULL
+#endif
+
+static const struct dev_pm_ops ehci_msm_dev_pm_ops = {
+        .suspend         = ehci_msm_pm_suspend,
+        .resume          = ehci_msm_pm_resume,
+};
+
+static struct platform_driver ehci_msm_driver = {
+        .probe  = ehci_msm_probe,
+        .remove = __devexit_p(ehci_msm_remove),
+        .driver = {
+                   .name = "msm_hsusb_host",
+                   .pm = &ehci_msm_dev_pm_ops,
+        },
+};
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index a22d2df769a9..fa59b26fc5bc 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -36,14 +36,8 @@ struct ehci_mxc_priv {
 static int ehci_mxc_setup(struct usb_hcd *hcd)
 {
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
-        struct device *dev = hcd->self.controller;
-        struct mxc_usbh_platform_data *pdata = dev_get_platdata(dev);
         int retval;
 
-        /* EHCI registers start at offset 0x100 */
-        ehci->caps = hcd->regs + 0x100;
-        ehci->regs = hcd->regs + 0x100 +
-            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
         dbg_hcs_params(ehci, "reset");
         dbg_hcc_params(ehci, "reset");
 
@@ -65,12 +59,6 @@ static int ehci_mxc_setup(struct usb_hcd *hcd)
 
         ehci_reset(ehci);
 
-        /* set up the PORTSCx register */
-        ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
-
-        /* is this really needed? */
-        msleep(10);
-
         ehci_port_power(ehci, 0);
         return 0;
 }
@@ -100,6 +88,7 @@ static const struct hc_driver ehci_mxc_hc_driver = {
         .urb_enqueue = ehci_urb_enqueue,
         .urb_dequeue = ehci_urb_dequeue,
         .endpoint_disable = ehci_endpoint_disable,
+        .endpoint_reset = ehci_endpoint_reset,
 
         /*
          * scheduling support
@@ -115,6 +104,8 @@ static const struct hc_driver ehci_mxc_hc_driver = {
         .bus_resume = ehci_bus_resume,
         .relinquish_port = ehci_relinquish_port,
         .port_handed_over = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };
 
 static int ehci_mxc_drv_probe(struct platform_device *pdev)
@@ -125,6 +116,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         int irq, ret;
         struct ehci_mxc_priv *priv;
         struct device *dev = &pdev->dev;
+        struct ehci_hcd *ehci;
 
         dev_info(&pdev->dev, "initializing i.MX USB Controller\n");
 
@@ -212,6 +204,19 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto err_init;
 
+        ehci = hcd_to_ehci(hcd);
+
+        /* EHCI registers start at offset 0x100 */
+        ehci->caps = hcd->regs + 0x100;
+        ehci->regs = hcd->regs + 0x100 +
+            HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase));
+
+        /* set up the PORTSCx register */
+        ehci_writel(ehci, pdata->portsc, &ehci->regs->port_status[0]);
+
+        /* is this really needed? */
+        msleep(10);
+
         /* Initialize the transceiver */
         if (pdata->otg) {
                 pdata->otg->io_priv = hcd->regs + ULPI_VIEWPORT_OFFSET;
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 116ae280053a..680f2ef4e59f 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -1,11 +1,12 @@
 /*
- * ehci-omap.c - driver for USBHOST on OMAP 34xx processor
+ * ehci-omap.c - driver for USBHOST on OMAP3/4 processors
  *
- * Bus Glue for OMAP34xx USBHOST 3 port EHCI controller
- * Tested on OMAP3430 ES2.0 SDP
+ * Bus Glue for the EHCI controllers in OMAP3/4
+ * Tested on several OMAP3 boards, and OMAP4 Pandaboard
  *
- * Copyright (C) 2007-2008 Texas Instruments, Inc.
+ * Copyright (C) 2007-2010 Texas Instruments, Inc.
  *      Author: Vikram Pandita <vikram.pandita@ti.com>
+ *      Author: Anand Gadiyar <gadiyar@ti.com>
  *
  * Copyright (C) 2009 Nokia Corporation
  *      Contact: Felipe Balbi <felipe.balbi@nokia.com>
@@ -26,11 +27,14 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- * TODO (last updated Feb 12, 2010):
+ * TODO (last updated Nov 21, 2010):
  *      - add kernel-doc
  *      - enable AUTOIDLE
  *      - add suspend/resume
  *      - move workarounds to board-files
+ *      - factor out code common to OHCI
+ *      - add HSIC and TLL support
+ *      - convert to use hwmod and runtime PM
  */
 
 #include <linux/platform_device.h>
@@ -86,9 +90,9 @@
 #define OMAP_TLL_ULPI_SCRATCH_REGISTER(num)             (0x816 + 0x100 * num)
 
 #define OMAP_TLL_CHANNEL_COUNT                          3
-#define OMAP_TLL_CHANNEL_1_EN_MASK                      (1 << 1)
-#define OMAP_TLL_CHANNEL_2_EN_MASK                      (1 << 2)
-#define OMAP_TLL_CHANNEL_3_EN_MASK                      (1 << 4)
+#define OMAP_TLL_CHANNEL_1_EN_MASK                      (1 << 0)
+#define OMAP_TLL_CHANNEL_2_EN_MASK                      (1 << 1)
+#define OMAP_TLL_CHANNEL_3_EN_MASK                      (1 << 2)
 
 /* UHH Register Set */
 #define OMAP_UHH_REVISION                               (0x00)
@@ -114,6 +118,23 @@
 #define OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS           (1 << 9)
 #define OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS           (1 << 10)
 
+/* OMAP4-specific defines */
+#define OMAP4_UHH_SYSCONFIG_IDLEMODE_CLEAR              (3 << 2)
+#define OMAP4_UHH_SYSCONFIG_NOIDLE                      (1 << 2)
+
+#define OMAP4_UHH_SYSCONFIG_STDBYMODE_CLEAR             (3 << 4)
+#define OMAP4_UHH_SYSCONFIG_NOSTDBY                     (1 << 4)
+#define OMAP4_UHH_SYSCONFIG_SOFTRESET                   (1 << 0)
+
+#define OMAP4_P1_MODE_CLEAR                             (3 << 16)
+#define OMAP4_P1_MODE_TLL                               (1 << 16)
+#define OMAP4_P1_MODE_HSIC                              (3 << 16)
+#define OMAP4_P2_MODE_CLEAR                             (3 << 18)
+#define OMAP4_P2_MODE_TLL                               (1 << 18)
+#define OMAP4_P2_MODE_HSIC                              (3 << 18)
+
+#define OMAP_REV2_TLL_CHANNEL_COUNT                     2
+
 #define OMAP_UHH_DEBUG_CSR                              (0x44)
 
 /* EHCI Register Set */
@@ -127,6 +148,17 @@
 #define EHCI_INSNREG05_ULPI_EXTREGADD_SHIFT             8
 #define EHCI_INSNREG05_ULPI_WRDATA_SHIFT                0
 
+/* Values of UHH_REVISION - Note: these are not given in the TRM */
+#define OMAP_EHCI_REV1  0x00000010      /* OMAP3 */
+#define OMAP_EHCI_REV2  0x50700100      /* OMAP4 */
+
+#define is_omap_ehci_rev1(x)    (x->omap_ehci_rev == OMAP_EHCI_REV1)
+#define is_omap_ehci_rev2(x)    (x->omap_ehci_rev == OMAP_EHCI_REV2)
+
+#define is_ehci_phy_mode(x)     (x == EHCI_HCD_OMAP_MODE_PHY)
+#define is_ehci_tll_mode(x)     (x == EHCI_HCD_OMAP_MODE_TLL)
+#define is_ehci_hsic_mode(x)    (x == EHCI_HCD_OMAP_MODE_HSIC)
+
 /*-------------------------------------------------------------------------*/
 
 static inline void ehci_omap_writel(void __iomem *base, u32 reg, u32 val)
@@ -156,10 +188,14 @@ struct ehci_hcd_omap {
         struct device           *dev;
 
         struct clk              *usbhost_ick;
-        struct clk              *usbhost2_120m_fck;
-        struct clk              *usbhost1_48m_fck;
+        struct clk              *usbhost_hs_fck;
+        struct clk              *usbhost_fs_fck;
         struct clk              *usbtll_fck;
         struct clk              *usbtll_ick;
+        struct clk              *xclk60mhsp1_ck;
+        struct clk              *xclk60mhsp2_ck;
+        struct clk              *utmi_p1_fck;
+        struct clk              *utmi_p2_fck;
 
         /* FIXME the following two workarounds are
          * board specific not silicon-specific so these
@@ -176,6 +212,9 @@ struct ehci_hcd_omap {
         /* phy reset workaround */
         int                     phy_reset;
 
+        /* IP revision */
+        u32                     omap_ehci_rev;
+
         /* desired phy_mode: TLL, PHY */
         enum ehci_hcd_omap_mode port_mode[OMAP3_HS_USB_PORTS];
 
@@ -191,13 +230,14 @@ struct ehci_hcd_omap {
 
 /*-------------------------------------------------------------------------*/
 
-static void omap_usb_utmi_init(struct ehci_hcd_omap *omap, u8 tll_channel_mask)
+static void omap_usb_utmi_init(struct ehci_hcd_omap *omap, u8 tll_channel_mask,
+                                u8 tll_channel_count)
 {
         unsigned reg;
         int i;
 
         /* Program the 3 TLL channels upfront */
-        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
+        for (i = 0; i < tll_channel_count; i++) {
                 reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
 
                 /* Disable AutoIdle, BitStuffing and use SDR Mode */
@@ -217,7 +257,7 @@ static void omap_usb_utmi_init(struct ehci_hcd_omap *omap, u8 tll_channel_mask)
         ehci_omap_writel(omap->tll_base, OMAP_TLL_SHARED_CONF, reg);
 
         /* Enable channels now */
-        for (i = 0; i < OMAP_TLL_CHANNEL_COUNT; i++) {
+        for (i = 0; i < tll_channel_count; i++) {
                 reg = ehci_omap_readl(omap->tll_base, OMAP_TLL_CHANNEL_CONF(i));
 
                 /* Enable only the reg that is needed */
@@ -286,19 +326,19 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
         }
         clk_enable(omap->usbhost_ick);
 
-        omap->usbhost2_120m_fck = clk_get(omap->dev, "usbhost_120m_fck");
-        if (IS_ERR(omap->usbhost2_120m_fck)) {
-                ret = PTR_ERR(omap->usbhost2_120m_fck);
+        omap->usbhost_hs_fck = clk_get(omap->dev, "hs_fck");
+        if (IS_ERR(omap->usbhost_hs_fck)) {
+                ret = PTR_ERR(omap->usbhost_hs_fck);
                 goto err_host_120m_fck;
         }
-        clk_enable(omap->usbhost2_120m_fck);
+        clk_enable(omap->usbhost_hs_fck);
 
-        omap->usbhost1_48m_fck = clk_get(omap->dev, "usbhost_48m_fck");
-        if (IS_ERR(omap->usbhost1_48m_fck)) {
-                ret = PTR_ERR(omap->usbhost1_48m_fck);
+        omap->usbhost_fs_fck = clk_get(omap->dev, "fs_fck");
+        if (IS_ERR(omap->usbhost_fs_fck)) {
+                ret = PTR_ERR(omap->usbhost_fs_fck);
                 goto err_host_48m_fck;
         }
-        clk_enable(omap->usbhost1_48m_fck);
+        clk_enable(omap->usbhost_fs_fck);
 
         if (omap->phy_reset) {
                 /* Refer: ISSUE1 */
@@ -333,6 +373,80 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
         }
         clk_enable(omap->usbtll_ick);
 
+        omap->omap_ehci_rev = ehci_omap_readl(omap->uhh_base,
+                                                OMAP_UHH_REVISION);
+        dev_dbg(omap->dev, "OMAP UHH_REVISION 0x%x\n",
+                                        omap->omap_ehci_rev);
+
+        /*
+         * Enable per-port clocks as needed (newer controllers only).
+         * - External ULPI clock for PHY mode
+         * - Internal clocks for TLL and HSIC modes (TODO)
+         */
+        if (is_omap_ehci_rev2(omap)) {
+                switch (omap->port_mode[0]) {
+                case EHCI_HCD_OMAP_MODE_PHY:
+                        omap->xclk60mhsp1_ck = clk_get(omap->dev,
+                                                        "xclk60mhsp1_ck");
+                        if (IS_ERR(omap->xclk60mhsp1_ck)) {
+                                ret = PTR_ERR(omap->xclk60mhsp1_ck);
+                                dev_err(omap->dev,
+                                        "Unable to get Port1 ULPI clock\n");
+                        }
+
+                        omap->utmi_p1_fck = clk_get(omap->dev,
+                                                        "utmi_p1_gfclk");
+                        if (IS_ERR(omap->utmi_p1_fck)) {
+                                ret = PTR_ERR(omap->utmi_p1_fck);
+                                dev_err(omap->dev,
+                                        "Unable to get utmi_p1_fck\n");
+                        }
+
+                        ret = clk_set_parent(omap->utmi_p1_fck,
+                                                omap->xclk60mhsp1_ck);
+                        if (ret != 0) {
+                                dev_err(omap->dev,
+                                        "Unable to set P1 f-clock\n");
+                        }
+                        break;
+                case EHCI_HCD_OMAP_MODE_TLL:
+                        /* TODO */
+                default:
+                        break;
+                }
+                switch (omap->port_mode[1]) {
+                case EHCI_HCD_OMAP_MODE_PHY:
+                        omap->xclk60mhsp2_ck = clk_get(omap->dev,
+                                                        "xclk60mhsp2_ck");
+                        if (IS_ERR(omap->xclk60mhsp2_ck)) {
+                                ret = PTR_ERR(omap->xclk60mhsp2_ck);
+                                dev_err(omap->dev,
+                                        "Unable to get Port2 ULPI clock\n");
+                        }
+
+                        omap->utmi_p2_fck = clk_get(omap->dev,
+                                                        "utmi_p2_gfclk");
+                        if (IS_ERR(omap->utmi_p2_fck)) {
+                                ret = PTR_ERR(omap->utmi_p2_fck);
+                                dev_err(omap->dev,
+                                        "Unable to get utmi_p2_fck\n");
+                        }
+
+                        ret = clk_set_parent(omap->utmi_p2_fck,
+                                                omap->xclk60mhsp2_ck);
+                        if (ret != 0) {
+                                dev_err(omap->dev,
+                                        "Unable to set P2 f-clock\n");
+                        }
+                        break;
+                case EHCI_HCD_OMAP_MODE_TLL:
+                        /* TODO */
+                default:
+                        break;
+                }
+        }
+
+
         /* perform TLL soft reset, and wait until reset is complete */
         ehci_omap_writel(omap->tll_base, OMAP_USBTLL_SYSCONFIG,
                         OMAP_USBTLL_SYSCONFIG_SOFTRESET);
@@ -360,12 +474,20 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
 
         /* Put UHH in NoIdle/NoStandby mode */
         reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSCONFIG);
-        reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP
-                        | OMAP_UHH_SYSCONFIG_SIDLEMODE
-                        | OMAP_UHH_SYSCONFIG_CACTIVITY
-                        | OMAP_UHH_SYSCONFIG_MIDLEMODE);
-        reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE;
+        if (is_omap_ehci_rev1(omap)) {
+                reg |= (OMAP_UHH_SYSCONFIG_ENAWAKEUP
+                                | OMAP_UHH_SYSCONFIG_SIDLEMODE
+                                | OMAP_UHH_SYSCONFIG_CACTIVITY
+                                | OMAP_UHH_SYSCONFIG_MIDLEMODE);
+                reg &= ~OMAP_UHH_SYSCONFIG_AUTOIDLE;
+
 
+        } else if (is_omap_ehci_rev2(omap)) {
+                reg &= ~OMAP4_UHH_SYSCONFIG_IDLEMODE_CLEAR;
+                reg |= OMAP4_UHH_SYSCONFIG_NOIDLE;
+                reg &= ~OMAP4_UHH_SYSCONFIG_STDBYMODE_CLEAR;
+                reg |= OMAP4_UHH_SYSCONFIG_NOSTDBY;
+        }
         ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG, reg);
 
         reg = ehci_omap_readl(omap->uhh_base, OMAP_UHH_HOSTCONFIG);
@@ -376,40 +498,56 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
                         | OMAP_UHH_HOSTCONFIG_INCR16_BURST_EN);
         reg &= ~OMAP_UHH_HOSTCONFIG_INCRX_ALIGN_EN;
 
-        if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_UNKNOWN)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
-        if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_UNKNOWN)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
-        if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_UNKNOWN)
-                reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
-
-        /* Bypass the TLL module for PHY mode operation */
-        if (cpu_is_omap3430() && (omap_rev() <= OMAP3430_REV_ES2_1)) {
-                dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n");
-                if ((omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY) ||
-                        (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY) ||
-                                (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY))
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
-                else
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
-        } else {
-                dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n");
-                if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_PHY)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
-                else if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_TLL)
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
-
-                if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_PHY)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
-                else if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_TLL)
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
-
-                if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_PHY)
-                        reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
-                else if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_TLL)
-                        reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+        if (is_omap_ehci_rev1(omap)) {
+                if (omap->port_mode[0] == EHCI_HCD_OMAP_MODE_UNKNOWN)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_P1_CONNECT_STATUS;
+                if (omap->port_mode[1] == EHCI_HCD_OMAP_MODE_UNKNOWN)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_P2_CONNECT_STATUS;
+                if (omap->port_mode[2] == EHCI_HCD_OMAP_MODE_UNKNOWN)
+                        reg &= ~OMAP_UHH_HOSTCONFIG_P3_CONNECT_STATUS;
+
+                /* Bypass the TLL module for PHY mode operation */
+                if (cpu_is_omap3430() && (omap_rev() <= OMAP3430_REV_ES2_1)) {
+                        dev_dbg(omap->dev, "OMAP3 ES version <= ES2.1\n");
+                        if (is_ehci_phy_mode(omap->port_mode[0]) ||
+                                is_ehci_phy_mode(omap->port_mode[1]) ||
+                                        is_ehci_phy_mode(omap->port_mode[2]))
+                                reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
+                        else
+                                reg |= OMAP_UHH_HOSTCONFIG_ULPI_BYPASS;
+                } else {
+                        dev_dbg(omap->dev, "OMAP3 ES version > ES2.1\n");
+                        if (is_ehci_phy_mode(omap->port_mode[0]))
+                                reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
+                        else if (is_ehci_tll_mode(omap->port_mode[0]))
+                                reg |= OMAP_UHH_HOSTCONFIG_ULPI_P1_BYPASS;
+
+                        if (is_ehci_phy_mode(omap->port_mode[1]))
+                                reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
+                        else if (is_ehci_tll_mode(omap->port_mode[1]))
+                                reg |= OMAP_UHH_HOSTCONFIG_ULPI_P2_BYPASS;
+
+                        if (is_ehci_phy_mode(omap->port_mode[2]))
+                                reg &= ~OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+                        else if (is_ehci_tll_mode(omap->port_mode[2]))
+                                reg |= OMAP_UHH_HOSTCONFIG_ULPI_P3_BYPASS;
+                }
+        } else if (is_omap_ehci_rev2(omap)) {
+                /* Clear port mode fields for PHY mode*/
+                reg &= ~OMAP4_P1_MODE_CLEAR;
+                reg &= ~OMAP4_P2_MODE_CLEAR;
+
+                if (is_ehci_tll_mode(omap->port_mode[0]))
+                        reg |= OMAP4_P1_MODE_TLL;
+                else if (is_ehci_hsic_mode(omap->port_mode[0]))
+                        reg |= OMAP4_P1_MODE_HSIC;
 
+                if (is_ehci_tll_mode(omap->port_mode[1]))
+                        reg |= OMAP4_P2_MODE_TLL;
+                else if (is_ehci_hsic_mode(omap->port_mode[1]))
+                        reg |= OMAP4_P2_MODE_HSIC;
         }
+
         ehci_omap_writel(omap->uhh_base, OMAP_UHH_HOSTCONFIG, reg);
         dev_dbg(omap->dev, "UHH setup done, uhh_hostconfig=%x\n", reg);
 
@@ -438,7 +576,7 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
                         tll_ch_mask |= OMAP_TLL_CHANNEL_3_EN_MASK;
 
                 /* Enable UTMI mode for required TLL channels */
-                omap_usb_utmi_init(omap, tll_ch_mask);
+                omap_usb_utmi_init(omap, tll_ch_mask, OMAP_TLL_CHANNEL_COUNT);
         }
 
         if (omap->phy_reset) {
@@ -464,6 +602,14 @@ static int omap_start_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
         return 0;
 
 err_sys_status:
+        clk_disable(omap->utmi_p2_fck);
+        clk_put(omap->utmi_p2_fck);
+        clk_disable(omap->xclk60mhsp2_ck);
+        clk_put(omap->xclk60mhsp2_ck);
+        clk_disable(omap->utmi_p1_fck);
+        clk_put(omap->utmi_p1_fck);
+        clk_disable(omap->xclk60mhsp1_ck);
+        clk_put(omap->xclk60mhsp1_ck);
         clk_disable(omap->usbtll_ick);
         clk_put(omap->usbtll_ick);
 
@@ -472,8 +618,8 @@ err_tll_ick:
         clk_put(omap->usbtll_fck);
 
 err_tll_fck:
-        clk_disable(omap->usbhost1_48m_fck);
-        clk_put(omap->usbhost1_48m_fck);
+        clk_disable(omap->usbhost_fs_fck);
+        clk_put(omap->usbhost_fs_fck);
 
         if (omap->phy_reset) {
                 if (gpio_is_valid(omap->reset_gpio_port[0]))
@@ -484,8 +630,8 @@ err_tll_fck:
         }
 
 err_host_48m_fck:
-        clk_disable(omap->usbhost2_120m_fck);
-        clk_put(omap->usbhost2_120m_fck);
+        clk_disable(omap->usbhost_hs_fck);
+        clk_put(omap->usbhost_hs_fck);
 
 err_host_120m_fck:
         clk_disable(omap->usbhost_ick);
@@ -503,6 +649,8 @@ static void omap_stop_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
 
         /* Reset OMAP modules for insmod/rmmod to work */
         ehci_omap_writel(omap->uhh_base, OMAP_UHH_SYSCONFIG,
+                        is_omap_ehci_rev2(omap) ?
+                        OMAP4_UHH_SYSCONFIG_SOFTRESET :
                         OMAP_UHH_SYSCONFIG_SOFTRESET);
         while (!(ehci_omap_readl(omap->uhh_base, OMAP_UHH_SYSSTATUS)
                                 & (1 << 0))) {
@@ -550,16 +698,16 @@ static void omap_stop_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
                 omap->usbhost_ick = NULL;
         }
 
-        if (omap->usbhost1_48m_fck != NULL) {
-                clk_disable(omap->usbhost1_48m_fck);
-                clk_put(omap->usbhost1_48m_fck);
-                omap->usbhost1_48m_fck = NULL;
+        if (omap->usbhost_fs_fck != NULL) {
+                clk_disable(omap->usbhost_fs_fck);
+                clk_put(omap->usbhost_fs_fck);
+                omap->usbhost_fs_fck = NULL;
         }
 
-        if (omap->usbhost2_120m_fck != NULL) {
-                clk_disable(omap->usbhost2_120m_fck);
-                clk_put(omap->usbhost2_120m_fck);
-                omap->usbhost2_120m_fck = NULL;
+        if (omap->usbhost_hs_fck != NULL) {
+                clk_disable(omap->usbhost_hs_fck);
+                clk_put(omap->usbhost_hs_fck);
+                omap->usbhost_hs_fck = NULL;
         }
 
         if (omap->usbtll_ick != NULL) {
@@ -568,6 +716,32 @@ static void omap_stop_ehc(struct ehci_hcd_omap *omap, struct usb_hcd *hcd)
                 omap->usbtll_ick = NULL;
         }
 
+        if (is_omap_ehci_rev2(omap)) {
+                if (omap->xclk60mhsp1_ck != NULL) {
+                        clk_disable(omap->xclk60mhsp1_ck);
+                        clk_put(omap->xclk60mhsp1_ck);
+                        omap->xclk60mhsp1_ck = NULL;
+                }
+
+                if (omap->utmi_p1_fck != NULL) {
+                        clk_disable(omap->utmi_p1_fck);
+                        clk_put(omap->utmi_p1_fck);
+                        omap->utmi_p1_fck = NULL;
+                }
+
+                if (omap->xclk60mhsp2_ck != NULL) {
+                        clk_disable(omap->xclk60mhsp2_ck);
+                        clk_put(omap->xclk60mhsp2_ck);
+                        omap->xclk60mhsp2_ck = NULL;
+                }
+
+                if (omap->utmi_p2_fck != NULL) {
+                        clk_disable(omap->utmi_p2_fck);
+                        clk_put(omap->utmi_p2_fck);
+                        omap->utmi_p2_fck = NULL;
+                }
+        }
+
         if (omap->phy_reset) {
                 if (gpio_is_valid(omap->reset_gpio_port[0]))
                         gpio_free(omap->reset_gpio_port[0]);
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 655f3c9f88bf..76179c39c0e3 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -22,6 +22,9 @@
 #error "This file is PCI bus glue.  CONFIG_PCI must be defined."
 #endif
 
+/* defined here to avoid adding to pci_ids.h for single instance use */
+#define PCI_DEVICE_ID_INTEL_CE4100_USB  0x2e70
+
 /*-------------------------------------------------------------------------*/
 
 /* called after powerup, by probe or system-pm "wakeup" */
@@ -41,6 +44,35 @@ static int ehci_pci_reinit(struct ehci_hcd *ehci, struct pci_dev *pdev)
         return 0;
 }
 
+static int ehci_quirk_amd_SB800(struct ehci_hcd *ehci)
+{
+        struct pci_dev *amd_smbus_dev;
+        u8 rev = 0;
+
+        amd_smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI, 0x4385, NULL);
+        if (!amd_smbus_dev)
+                return 0;
+
+        pci_read_config_byte(amd_smbus_dev, PCI_REVISION_ID, &rev);
+        if (rev < 0x40) {
+                pci_dev_put(amd_smbus_dev);
+                amd_smbus_dev = NULL;
+                return 0;
+        }
+
+        if (!amd_nb_dev)
+                amd_nb_dev = pci_get_device(PCI_VENDOR_ID_AMD, 0x1510, NULL);
+        if (!amd_nb_dev)
+                ehci_err(ehci, "QUIRK: unable to get AMD NB device\n");
+
+        ehci_info(ehci, "QUIRK: Enable AMD SB800 L1 fix\n");
+
+        pci_dev_put(amd_smbus_dev);
+        amd_smbus_dev = NULL;
+
+        return 1;
+}
+
 /* called during probe() after chip reset completes */
 static int ehci_pci_setup(struct usb_hcd *hcd)
 {
@@ -99,6 +131,9 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
+        if (ehci_quirk_amd_SB800(ehci))
+                ehci->amd_l1_fix = 1;
+
         retval = ehci_halt(ehci);
         if (retval)
                 return retval;
@@ -137,6 +172,10 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                         ehci_info(ehci, "disable lpm for langwell/penwell\n");
                         ehci->has_lpm = 0;
                 }
+                if (pdev->device == PCI_DEVICE_ID_INTEL_CE4100_USB) {
+                        hcd->has_tt = 1;
+                        tdi_reset(ehci);
+                }
                 break;
         case PCI_VENDOR_ID_TDI:
                 if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index d9f78eb26572..aa46f57f9ec8 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -1590,6 +1590,63 @@ itd_link (struct ehci_hcd *ehci, unsigned frame, struct ehci_itd *itd)
         *hw_p = cpu_to_hc32(ehci, itd->itd_dma | Q_TYPE_ITD);
 }
 
+#define AB_REG_BAR_LOW 0xe0
+#define AB_REG_BAR_HIGH 0xe1
+#define AB_INDX(addr) ((addr) + 0x00)
+#define AB_DATA(addr) ((addr) + 0x04)
+#define NB_PCIE_INDX_ADDR 0xe0
+#define NB_PCIE_INDX_DATA 0xe4
+#define NB_PIF0_PWRDOWN_0 0x01100012
+#define NB_PIF0_PWRDOWN_1 0x01100013
+
+static void ehci_quirk_amd_L1(struct ehci_hcd *ehci, int disable)
+{
+        u32 addr, addr_low, addr_high, val;
+
+        outb_p(AB_REG_BAR_LOW, 0xcd6);
+        addr_low = inb_p(0xcd7);
+        outb_p(AB_REG_BAR_HIGH, 0xcd6);
+        addr_high = inb_p(0xcd7);
+        addr = addr_high << 8 | addr_low;
+        outl_p(0x30, AB_INDX(addr));
+        outl_p(0x40, AB_DATA(addr));
+        outl_p(0x34, AB_INDX(addr));
+        val = inl_p(AB_DATA(addr));
+
+        if (disable) {
+                val &= ~0x8;
+                val |= (1 << 4) | (1 << 9);
+        } else {
+                val |= 0x8;
+                val &= ~((1 << 4) | (1 << 9));
+        }
+        outl_p(val, AB_DATA(addr));
+
+        if (amd_nb_dev) {
+                addr = NB_PIF0_PWRDOWN_0;
+                pci_write_config_dword(amd_nb_dev, NB_PCIE_INDX_ADDR, addr);
+                pci_read_config_dword(amd_nb_dev, NB_PCIE_INDX_DATA, &val);
+                if (disable)
+                        val &= ~(0x3f << 7);
+                else
+                        val |= 0x3f << 7;
+
+                pci_write_config_dword(amd_nb_dev, NB_PCIE_INDX_DATA, val);
+
+                addr = NB_PIF0_PWRDOWN_1;
+                pci_write_config_dword(amd_nb_dev, NB_PCIE_INDX_ADDR, addr);
+                pci_read_config_dword(amd_nb_dev, NB_PCIE_INDX_DATA, &val);
+                if (disable)
+                        val &= ~(0x3f << 7);
+                else
+                        val |= 0x3f << 7;
+
+                pci_write_config_dword(amd_nb_dev, NB_PCIE_INDX_DATA, val);
+        }
+
+        return;
+}
+
 /* fit urb's itds into the selected schedule slot; activate as needed */
 static int
 itd_link_urb (
@@ -1616,6 +1673,12 @@ itd_link_urb (
                         urb->interval,
                         next_uframe >> 3, next_uframe & 0x7);
         }
+
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_l1_fix == 1)
+                        ehci_quirk_amd_L1(ehci, 1);
+        }
+
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill iTDs uframe by uframe */
@@ -1740,6 +1803,11 @@ itd_complete (
         (void) disable_periodic(ehci);
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs--;
 
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_l1_fix == 1)
+                        ehci_quirk_amd_L1(ehci, 0);
+        }
+
         if (unlikely(list_is_singular(&stream->td_list))) {
                 ehci_to_hcd(ehci)->self.bandwidth_allocated
                                 -= stream->bandwidth;
@@ -2025,6 +2093,12 @@ sitd_link_urb (
                         (next_uframe >> 3) & (ehci->periodic_size - 1),
                         stream->interval, hc32_to_cpu(ehci, stream->splits));
         }
+
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_l1_fix == 1)
+                        ehci_quirk_amd_L1(ehci, 1);
+        }
+
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill sITDs frame by frame */
@@ -2125,6 +2199,11 @@ sitd_complete (
         (void) disable_periodic(ehci);
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs--;
 
+        if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {
+                if (ehci->amd_l1_fix == 1)
+                        ehci_quirk_amd_L1(ehci, 0);
+        }
+
         if (list_is_singular(&stream->td_list)) {
                 ehci_to_hcd(ehci)->self.bandwidth_allocated
                                 -= stream->bandwidth;
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
new file mode 100644
index 000000000000..595f70f42b52
--- /dev/null
+++ b/drivers/usb/host/ehci-sh.c
@@ -0,0 +1,243 @@
+/*
+ * SuperH EHCI host controller driver
+ *
+ * Copyright (C) 2010  Paul Mundt
+ *
+ * Based on ohci-sh.c and ehci-atmel.c.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+struct ehci_sh_priv {
+        struct clk *iclk, *fclk;
+        struct usb_hcd *hcd;
+};
+
+static int ehci_sh_reset(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int ret;
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,
+                &ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+
+        ret = ehci_halt(ehci);
+        if (unlikely(ret))
+                return ret;
+
+        ret = ehci_init(hcd);
+        if (unlikely(ret))
+                return ret;
+
+        ehci->sbrn = 0x20;
+
+        ehci_reset(ehci);
+        ehci_port_power(ehci, 0);
+
+        return ret;
+}
+
+static const struct hc_driver ehci_sh_hc_driver = {
+        .description                    = hcd_name,
+        .product_desc                   = "SuperH EHCI",
+        .hcd_priv_size                  = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                            = ehci_irq,
+        .flags                          = HCD_USB2 | HCD_MEMORY,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                          = ehci_sh_reset,
+        .start                          = ehci_run,
+        .stop                           = ehci_stop,
+        .shutdown                       = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue                    = ehci_urb_enqueue,
+        .urb_dequeue                    = ehci_urb_dequeue,
+        .endpoint_disable               = ehci_endpoint_disable,
+        .endpoint_reset                 = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number               = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data                = ehci_hub_status_data,
+        .hub_control                    = ehci_hub_control,
+
+#ifdef CONFIG_PM
+        .bus_suspend                    = ehci_bus_suspend,
+        .bus_resume                     = ehci_bus_resume,
+#endif
+
+        .relinquish_port                = ehci_relinquish_port,
+        .port_handed_over               = ehci_port_handed_over,
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int ehci_hcd_sh_probe(struct platform_device *pdev)
+{
+        const struct hc_driver *driver = &ehci_sh_hc_driver;
+        struct resource *res;
+        struct ehci_sh_priv *priv;
+        struct usb_hcd *hcd;
+        int irq, ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "Found HC with no register addr. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                ret = -ENODEV;
+                goto fail_create_hcd;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                dev_err(&pdev->dev,
+                        "Found HC with no IRQ. Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                ret = -ENODEV;
+                goto fail_create_hcd;
+        }
+
+        /* initialize hcd */
+        hcd = usb_create_hcd(&ehci_sh_hc_driver, &pdev->dev,
+                             dev_name(&pdev->dev));
+        if (!hcd) {
+                ret = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                dev_dbg(&pdev->dev, "controller already in use\n");
+                ret = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -ENXIO;
+                goto fail_ioremap;
+        }
+
+        priv = kmalloc(sizeof(struct ehci_sh_priv), GFP_KERNEL);
+        if (!priv) {
+                dev_dbg(&pdev->dev, "error allocating priv data\n");
+                ret = -ENOMEM;
+                goto fail_alloc;
+        }
+
+        /* These are optional, we don't care if they fail */
+        priv->fclk = clk_get(&pdev->dev, "usb_fck");
+        if (IS_ERR(priv->fclk))
+                priv->fclk = NULL;
+
+        priv->iclk = clk_get(&pdev->dev, "usb_ick");
+        if (IS_ERR(priv->iclk))
+                priv->iclk = NULL;
+
+        clk_enable(priv->fclk);
+        clk_enable(priv->iclk);
+
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to add hcd");
+                goto fail_add_hcd;
+        }
+
+        priv->hcd = hcd;
+        platform_set_drvdata(pdev, priv);
+
+        return ret;
+
+fail_add_hcd:
+        clk_disable(priv->iclk);
+        clk_disable(priv->fclk);
+
+        clk_put(priv->iclk);
+        clk_put(priv->fclk);
+
+        kfree(priv);
+fail_alloc:
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), ret);
+
+        return ret;
+}
+
+static int __exit ehci_hcd_sh_remove(struct platform_device *pdev)
+{
+        struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = priv->hcd;
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        clk_disable(priv->fclk);
+        clk_disable(priv->iclk);
+
+        clk_put(priv->fclk);
+        clk_put(priv->iclk);
+
+        kfree(priv);
+
+        return 0;
+}
+
+static void ehci_hcd_sh_shutdown(struct platform_device *pdev)
+{
+        struct ehci_sh_priv *priv = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = priv->hcd;
+
+        if (hcd->driver->shutdown)
+                hcd->driver->shutdown(hcd);
+}
+
+static struct platform_driver ehci_hcd_sh_driver = {
+        .probe          = ehci_hcd_sh_probe,
+        .remove         = __exit_p(ehci_hcd_sh_remove),
+        .shutdown       = ehci_hcd_sh_shutdown,
+        .driver         = {
+                .name   = "sh_ehci",
+                .owner  = THIS_MODULE,
+        },
+};
+
+MODULE_ALIAS("platform:sh_ehci");
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
new file mode 100644
index 000000000000..75c00873443d
--- /dev/null
+++ b/drivers/usb/host/ehci-spear.c
@@ -0,0 +1,212 @@
+/*
+* Driver for EHCI HCD on SPEAR SOC
+*
+* Copyright (C) 2010 ST Micro Electronics,
+* Deepak Sikri <deepak.sikri@st.com>
+*
+* Based on various ehci-*.c drivers
+*
+* This file is subject to the terms and conditions of the GNU General Public
+* License. See the file COPYING in the main directory of this archive for
+* more details.
+*/
+
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+struct spear_ehci {
+        struct ehci_hcd ehci;
+        struct clk *clk;
+};
+
+#define to_spear_ehci(hcd)      (struct spear_ehci *)hcd_to_ehci(hcd)
+
+static void spear_start_ehci(struct spear_ehci *ehci)
+{
+        clk_enable(ehci->clk);
+}
+
+static void spear_stop_ehci(struct spear_ehci *ehci)
+{
+        clk_disable(ehci->clk);
+}
+
+static int ehci_spear_setup(struct usb_hcd *hcd)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval = 0;
+
+        /* registers start at offset 0x0 */
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs + HC_LENGTH(ehci_readl(ehci,
+                                &ehci->caps->hc_capbase));
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
+        retval = ehci_halt(ehci);
+        if (retval)
+                return retval;
+
+        retval = ehci_init(hcd);
+        if (retval)
+                return retval;
+
+        ehci_reset(ehci);
+        ehci_port_power(ehci, 0);
+
+        return retval;
+}
+
+static const struct hc_driver ehci_spear_hc_driver = {
+        .description                    = hcd_name,
+        .product_desc                   = "SPEAr EHCI",
+        .hcd_priv_size                  = sizeof(struct spear_ehci),
+
+        /* generic hardware linkage */
+        .irq                            = ehci_irq,
+        .flags                          = HCD_MEMORY | HCD_USB2,
+
+        /* basic lifecycle operations */
+        .reset                          = ehci_spear_setup,
+        .start                          = ehci_run,
+        .stop                           = ehci_stop,
+        .shutdown                       = ehci_shutdown,
+
+        /* managing i/o requests and associated device resources */
+        .urb_enqueue                    = ehci_urb_enqueue,
+        .urb_dequeue                    = ehci_urb_dequeue,
+        .endpoint_disable               = ehci_endpoint_disable,
+        .endpoint_reset                 = ehci_endpoint_reset,
+
+        /* scheduling support */
+        .get_frame_number               = ehci_get_frame,
+
+        /* root hub support */
+        .hub_status_data                = ehci_hub_status_data,
+        .hub_control                    = ehci_hub_control,
+        .bus_suspend                    = ehci_bus_suspend,
+        .bus_resume                     = ehci_bus_resume,
+        .relinquish_port                = ehci_relinquish_port,
+        .port_handed_over               = ehci_port_handed_over,
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd ;
+        struct spear_ehci *ehci;
+        struct resource *res;
+        struct clk *usbh_clk;
+        const struct hc_driver *driver = &ehci_spear_hc_driver;
+        int *pdata = pdev->dev.platform_data;
+        int irq, retval;
+        char clk_name[20] = "usbh_clk";
+
+        if (pdata == NULL)
+                return -EFAULT;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                retval = irq;
+                goto fail_irq_get;
+        }
+
+        if (*pdata >= 0)
+                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+
+        usbh_clk = clk_get(NULL, clk_name);
+        if (IS_ERR(usbh_clk)) {
+                dev_err(&pdev->dev, "Error getting interface clock\n");
+                retval = PTR_ERR(usbh_clk);
+                goto fail_get_usbh_clk;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                retval = -ENODEV;
+                goto fail_request_resource;
+        }
+
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
+                                driver->description)) {
+                retval = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (hcd->regs == NULL) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                retval = -ENOMEM;
+                goto fail_ioremap;
+        }
+
+        ehci = (struct spear_ehci *)hcd_to_ehci(hcd);
+        ehci->clk = usbh_clk;
+
+        spear_start_ehci(ehci);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+        if (retval)
+                goto fail_add_hcd;
+
+        return retval;
+
+fail_add_hcd:
+        spear_stop_ehci(ehci);
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        clk_put(usbh_clk);
+fail_get_usbh_clk:
+fail_irq_get:
+        dev_err(&pdev->dev, "init fail, %d\n", retval);
+
+        return retval ;
+}
+
+static int spear_ehci_hcd_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct spear_ehci *ehci_p = to_spear_ehci(hcd);
+
+        if (!hcd)
+                return 0;
+        if (in_interrupt())
+                BUG();
+        usb_remove_hcd(hcd);
+
+        if (ehci_p->clk)
+                spear_stop_ehci(ehci_p);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        if (ehci_p->clk)
+                clk_put(ehci_p->clk);
+
+        return 0;
+}
+
+static struct platform_driver spear_ehci_hcd_driver = {
+        .probe          = spear_ehci_hcd_drv_probe,
+        .remove         = spear_ehci_hcd_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name = "spear-ehci",
+                .bus = &platform_bus_type
+        }
+};
+
+MODULE_ALIAS("platform:spear-ehci");
diff --git a/drivers/usb/host/ehci-vt8500.c b/drivers/usb/host/ehci-vt8500.c
new file mode 100644
index 000000000000..20168062035a
--- /dev/null
+++ b/drivers/usb/host/ehci-vt8500.c
@@ -0,0 +1,172 @@
+/*
+ * drivers/usb/host/ehci-vt8500.c
+ *
+ * Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
+ *
+ * Based on ehci-au1xxx.c
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/platform_device.h>
+
+static int ehci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int rc = 0;
+
+        if (!udev->parent) /* udev is root hub itself, impossible */
+                rc = -1;
+        /* we only support lpm device connected to root hub yet */
+        if (ehci->has_lpm && !udev->parent->parent) {
+                rc = ehci_lpm_set_da(ehci, udev->devnum, udev->portnum);
+                if (!rc)
+                        rc = ehci_lpm_check(ehci, udev->portnum);
+        }
+        return rc;
+}
+
+static const struct hc_driver vt8500_ehci_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "VT8500 EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset                  = ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        /*
+         * call back when device connected and addressed
+         */
+        .update_device =        ehci_update_device,
+
+        .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
+};
+
+static int vt8500_ehci_drv_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct ehci_hcd *ehci;
+        struct resource *res;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
+                pr_debug("resource[1] is not IORESOURCE_IRQ");
+                return -ENOMEM;
+        }
+        hcd = usb_create_hcd(&vt8500_ehci_hc_driver, &pdev->dev, "VT8500");
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_debug("request_mem_region failed");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_debug("ioremap failed");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        ehci = hcd_to_ehci(hcd);
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs + HC_LENGTH(readl(&ehci->caps->hc_capbase));
+
+        dbg_hcs_params(ehci, "reset");
+        dbg_hcc_params(ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = readl(&ehci->caps->hcs_params);
+
+        ehci_port_power(ehci, 1);
+
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_DISABLED | IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
+
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
+        return ret;
+}
+
+static int vt8500_ehci_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver vt8500_ehci_driver = {
+        .probe          = vt8500_ehci_drv_probe,
+        .remove         = vt8500_ehci_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver = {
+                .name   = "vt8500-ehci",
+                .owner  = THIS_MODULE,
+        }
+};
+
+MODULE_ALIAS("platform:vt8500-ehci");
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index cfa21ea20f82..6bc35809a5c6 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -130,6 +130,7 @@ static const struct hc_driver ehci_w90x900_hc_driver = {
         .urb_enqueue = ehci_urb_enqueue,
         .urb_dequeue = ehci_urb_dequeue,
         .endpoint_disable = ehci_endpoint_disable,
+        .endpoint_reset = ehci_endpoint_reset,
 
         /*
          * scheduling support
@@ -147,6 +148,8 @@ static const struct hc_driver ehci_w90x900_hc_driver = {
 #endif
         .relinquish_port        = ehci_relinquish_port,
         .port_handed_over       = ehci_port_handed_over,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };
 
 static int __devinit ehci_w90x900_probe(struct platform_device *pdev)
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index 6c8076ad821d..e8f4f36fdf0b 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -117,6 +117,7 @@ static const struct hc_driver ehci_xilinx_of_hc_driver = {
         .urb_enqueue            = ehci_urb_enqueue,
         .urb_dequeue            = ehci_urb_dequeue,
         .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
 
         /*
          * scheduling support
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index ba8eab366b82..799ac16a54b4 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -131,6 +131,7 @@ struct ehci_hcd {			/* one per controller */
         unsigned                has_amcc_usb23:1;
         unsigned                need_io_watchdog:1;
         unsigned                broken_periodic:1;
+        unsigned                amd_l1_fix:1;
         unsigned                fs_i_thresh:1;  /* Intel iso scheduling */
         unsigned                use_dummy_qh:1; /* AMD Frame List table quirk*/
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 5cb6731ba443..9751647665df 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1081,6 +1081,11 @@ MODULE_LICENSE ("GPL");
 #define OF_PLATFORM_DRIVER      ohci_hcd_ppc_of_driver
 #endif
 
+#ifdef CONFIG_PLAT_SPEAR
+#include "ohci-spear.c"
+#define PLATFORM_DRIVER         spear_ohci_hcd_driver
+#endif
+
 #ifdef CONFIG_PPC_PS3
 #include "ohci-ps3.c"
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ohci_driver
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
index 2cc8a504b18c..a37d5993e4e3 100644
--- a/drivers/usb/host/ohci-omap3.c
+++ b/drivers/usb/host/ohci-omap3.c
@@ -648,7 +648,7 @@ static int __devinit ohci_hcd_omap3_probe(struct platform_device *pdev)
 
         ret = omap3_start_ohci(omap, hcd);
         if (ret) {
-                dev_dbg(&pdev->dev, "failed to start ehci\n");
+                dev_dbg(&pdev->dev, "failed to start ohci\n");
                 goto err_start;
         }
 
diff --git a/drivers/usb/host/ohci-sh.c b/drivers/usb/host/ohci-sh.c
index 0b35d22cc70e..f47867ff78c7 100644
--- a/drivers/usb/host/ohci-sh.c
+++ b/drivers/usb/host/ohci-sh.c
@@ -109,7 +109,7 @@ static int ohci_hcd_sh_probe(struct platform_device *pdev)
         hcd->regs = (void __iomem *)res->start;
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
         if (ret != 0) {
                 err("Failed to add hcd");
                 usb_put_hcd(hcd);
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
new file mode 100644
index 000000000000..4fd4bea9ac7a
--- /dev/null
+++ b/drivers/usb/host/ohci-spear.c
@@ -0,0 +1,240 @@
+/*
+* OHCI HCD (Host Controller Driver) for USB.
+*
+* Copyright (C) 2010 ST Microelectronics.
+* Deepak Sikri<deepak.sikri@st.com>
+*
+* Based on various ohci-*.c drivers
+*
+* This file is licensed under the terms of the GNU General Public
+* License version 2. This program is licensed "as is" without any
+* warranty of any kind, whether express or implied.
+*/
+
+#include <linux/signal.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+struct spear_ohci {
+        struct ohci_hcd ohci;
+        struct clk *clk;
+};
+
+#define to_spear_ohci(hcd)      (struct spear_ohci *)hcd_to_ohci(hcd)
+
+static void spear_start_ohci(struct spear_ohci *ohci)
+{
+        clk_enable(ohci->clk);
+}
+
+static void spear_stop_ohci(struct spear_ohci *ohci)
+{
+        clk_disable(ohci->clk);
+}
+
+static int __devinit ohci_spear_start(struct usb_hcd *hcd)
+{
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
+
+        ret = ohci_init(ohci);
+        if (ret < 0)
+                return ret;
+        ohci->regs = hcd->regs;
+
+        ret = ohci_run(ohci);
+        if (ret < 0) {
+                dev_err(hcd->self.controller, "can't start\n");
+                ohci_stop(hcd);
+                return ret;
+        }
+
+        create_debug_files(ohci);
+
+#ifdef DEBUG
+        ohci_dump(ohci, 1);
+#endif
+        return 0;
+}
+
+static const struct hc_driver ohci_spear_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "SPEAr OHCI",
+        .hcd_priv_size          = sizeof(struct spear_ohci),
+
+        /* generic hardware linkage */
+        .irq                    = ohci_irq,
+        .flags                  = HCD_USB11 | HCD_MEMORY,
+
+        /* basic lifecycle operations */
+        .start                  = ohci_spear_start,
+        .stop                   = ohci_stop,
+        .shutdown               = ohci_shutdown,
+#ifdef  CONFIG_PM
+        .bus_suspend            = ohci_bus_suspend,
+        .bus_resume             = ohci_bus_resume,
+#endif
+
+        /* managing i/o requests and associated device resources */
+        .urb_enqueue            = ohci_urb_enqueue,
+        .urb_dequeue            = ohci_urb_dequeue,
+        .endpoint_disable       = ohci_endpoint_disable,
+
+        /* scheduling support */
+        .get_frame_number       = ohci_get_frame,
+
+        /* root hub support */
+        .hub_status_data        = ohci_hub_status_data,
+        .hub_control            = ohci_hub_control,
+
+        .start_port_reset       = ohci_start_port_reset,
+};
+
+static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
+{
+        const struct hc_driver *driver = &ohci_spear_hc_driver;
+        struct usb_hcd *hcd = NULL;
+        struct clk *usbh_clk;
+        struct spear_ohci *ohci_p;
+        struct resource *res;
+        int retval, irq;
+        int *pdata = pdev->dev.platform_data;
+        char clk_name[20] = "usbh_clk";
+
+        if (pdata == NULL)
+                return -EFAULT;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                retval = irq;
+                goto fail_irq_get;
+        }
+
+        if (*pdata >= 0)
+                sprintf(clk_name, "usbh.%01d_clk", *pdata);
+
+        usbh_clk = clk_get(NULL, clk_name);
+        if (IS_ERR(usbh_clk)) {
+                dev_err(&pdev->dev, "Error getting interface clock\n");
+                retval = PTR_ERR(usbh_clk);
+                goto fail_get_usbh_clk;
+        }
+
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                retval = -ENOMEM;
+                goto fail_create_hcd;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                retval = -ENODEV;
+                goto fail_request_resource;
+        }
+
+        hcd->rsrc_start = pdev->resource[0].start;
+        hcd->rsrc_len = resource_size(res);
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                dev_dbg(&pdev->dev, "request_mem_region failed\n");
+                retval = -EBUSY;
+                goto fail_request_resource;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                dev_dbg(&pdev->dev, "ioremap failed\n");
+                retval = -ENOMEM;
+                goto fail_ioremap;
+        }
+
+        ohci_p = (struct spear_ohci *)hcd_to_ohci(hcd);
+        ohci_p->clk = usbh_clk;
+        spear_start_ohci(ohci_p);
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), IRQF_DISABLED);
+        if (retval == 0)
+                return retval;
+
+        spear_stop_ohci(ohci_p);
+        iounmap(hcd->regs);
+fail_ioremap:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+fail_request_resource:
+        usb_put_hcd(hcd);
+fail_create_hcd:
+        clk_put(usbh_clk);
+fail_get_usbh_clk:
+fail_irq_get:
+        dev_err(&pdev->dev, "init fail, %d\n", retval);
+
+        return retval;
+}
+
+static int spear_ohci_hcd_drv_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+
+        usb_remove_hcd(hcd);
+        if (ohci_p->clk)
+                spear_stop_ohci(ohci_p);
+
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+
+        if (ohci_p->clk)
+                clk_put(ohci_p->clk);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+#if defined(CONFIG_PM)
+static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
+                pm_message_t message)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        spear_stop_ohci(ohci_p);
+        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
+        return 0;
+}
+
+static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        spear_start_ohci(ohci_p);
+        ohci_finish_controller_resume(hcd);
+        return 0;
+}
+#endif
+
+/* Driver definition to register with the platform bus */
+static struct platform_driver spear_ohci_hcd_driver = {
+        .probe =        spear_ohci_hcd_drv_probe,
+        .remove =       spear_ohci_hcd_drv_remove,
+#ifdef CONFIG_PM
+        .suspend =      spear_ohci_hcd_drv_suspend,
+        .resume =       spear_ohci_hcd_drv_resume,
+#endif
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "spear-ohci",
+        },
+};
+
+MODULE_ALIAS("platform:spear-ohci");
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index f52d04db28f4..cee867829ec9 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -569,7 +569,7 @@ static int uhci_init(struct usb_hcd *hcd)
  */
 static void uhci_shutdown(struct pci_dev *pdev)
 {
-        struct usb_hcd *hcd = (struct usb_hcd *) pci_get_drvdata(pdev);
+        struct usb_hcd *hcd = pci_get_drvdata(pdev);
 
         uhci_hc_died(hcd_to_uhci(hcd));
 }
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 2090b45eb606..af77abb5c68b 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -29,7 +29,7 @@ static void uhci_set_next_interrupt(struct uhci_hcd *uhci)
 {
         if (uhci->is_stopped)
                 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
-        uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC); 
+        uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC);
 }
 
 static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci)
@@ -195,7 +195,9 @@ static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci,
                 } else {
                         struct uhci_td *ntd;
 
-                        ntd = list_entry(td->fl_list.next, struct uhci_td, fl_list);
+                        ntd = list_entry(td->fl_list.next,
+                                         struct uhci_td,
+                                         fl_list);
                         uhci->frame[td->frame] = LINK_TO_TD(ntd);
                         uhci->frame_cpu[td->frame] = ntd;
                 }
@@ -728,7 +730,7 @@ static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci,
 
         urbp->urb = urb;
         urb->hcpriv = urbp;
-        
+
         INIT_LIST_HEAD(&urbp->node);
         INIT_LIST_HEAD(&urbp->td_list);
 
@@ -846,7 +848,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
 
                 /* Alternate Data0/1 (start with Data1) */
                 destination ^= TD_TOKEN_TOGGLE;
-        
+
                 uhci_add_td_to_urbp(td, urbp);
                 uhci_fill_td(td, status, destination | uhci_explen(pktsze),
                                 data);
@@ -857,7 +859,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
         }
 
         /*
-         * Build the final TD for control status 
+         * Build the final TD for control status
          */
         td = uhci_alloc_td(uhci);
         if (!td)
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index 72b6892fda67..9546f6cd01f0 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -356,7 +356,7 @@ static void __exit whci_hc_driver_exit(void)
 module_exit(whci_hc_driver_exit);
 
 /* PCI device ID's that we handle (so it gets loaded) */
-static struct pci_device_id whci_hcd_id_table[] = {
+static struct pci_device_id __used whci_hcd_id_table[] = {
         { PCI_DEVICE_CLASS(PCI_CLASS_WIRELESS_WHCI, ~0) },
         { /* empty last entry */ }
 };
diff --git a/drivers/usb/misc/usbled.c b/drivers/usb/misc/usbled.c
index c96f51de1696..1732d9bc097e 100644
--- a/drivers/usb/misc/usbled.c
+++ b/drivers/usb/misc/usbled.c
@@ -1,5 +1,5 @@
 /*
- * USB LED driver - 1.1
+ * USB LED driver
  *
  * Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com)
  *
@@ -20,12 +20,17 @@
 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com"
 #define DRIVER_DESC "USB LED Driver"
 
-#define VENDOR_ID       0x0fc5
-#define PRODUCT_ID      0x1223
+enum led_type {
+        DELCOM_VISUAL_SIGNAL_INDICATOR,
+        DREAM_CHEEKY_WEBMAIL_NOTIFIER,
+};
 
 /* table of devices that work with this driver */
 static const struct usb_device_id id_table[] = {
-        { USB_DEVICE(VENDOR_ID, PRODUCT_ID) },
+        { USB_DEVICE(0x0fc5, 0x1223),
+                        .driver_info = DELCOM_VISUAL_SIGNAL_INDICATOR },
+        { USB_DEVICE(0x1d34, 0x0004),
+                        .driver_info = DREAM_CHEEKY_WEBMAIL_NOTIFIER },
         { },
 };
 MODULE_DEVICE_TABLE (usb, id_table);
@@ -35,15 +40,12 @@ struct usb_led {
         unsigned char           blue;
         unsigned char           red;
         unsigned char           green;
+        enum led_type           type;
 };
 
-#define BLUE    0x04
-#define RED     0x02
-#define GREEN   0x01
 static void change_color(struct usb_led *led)
 {
         int retval;
-        unsigned char color = 0x07;
         unsigned char *buffer;
 
         buffer = kmalloc(8, GFP_KERNEL);
@@ -52,25 +54,59 @@ static void change_color(struct usb_led *led)
                 return;
         }
 
-        if (led->blue)
-                color &= ~(BLUE);
-        if (led->red)
-                color &= ~(RED);
-        if (led->green)
-                color &= ~(GREEN);
-        dev_dbg(&led->udev->dev,
-                "blue = %d, red = %d, green = %d, color = %.2x\n",
-                led->blue, led->red, led->green, color);
-
-        retval = usb_control_msg(led->udev,
-                                usb_sndctrlpipe(led->udev, 0),
-                                0x12,
-                                0xc8,
-                                (0x02 * 0x100) + 0x0a,
-                                (0x00 * 0x100) + color,
-                                buffer, 
-                                8,
-                                2000);
+        switch (led->type) {
+        case DELCOM_VISUAL_SIGNAL_INDICATOR: {
+                unsigned char color = 0x07;
+
+                if (led->blue)
+                        color &= ~0x04;
+                if (led->red)
+                        color &= ~0x02;
+                if (led->green)
+                        color &= ~0x01;
+                dev_dbg(&led->udev->dev,
+                        "blue = %d, red = %d, green = %d, color = %.2x\n",
+                        led->blue, led->red, led->green, color);
+
+                retval = usb_control_msg(led->udev,
+                                        usb_sndctrlpipe(led->udev, 0),
+                                        0x12,
+                                        0xc8,
+                                        (0x02 * 0x100) + 0x0a,
+                                        (0x00 * 0x100) + color,
+                                        buffer,
+                                        8,
+                                        2000);
+                break;
+        }
+
+        case DREAM_CHEEKY_WEBMAIL_NOTIFIER:
+                dev_dbg(&led->udev->dev,
+                        "red = %d, green = %d, blue = %d\n",
+                        led->red, led->green, led->blue);
+
+                buffer[0] = led->red;
+                buffer[1] = led->green;
+                buffer[2] = led->blue;
+                buffer[3] = buffer[4] = buffer[5] = 0;
+                buffer[6] = 0x1a;
+                buffer[7] = 0x05;
+
+                retval = usb_control_msg(led->udev,
+                                        usb_sndctrlpipe(led->udev, 0),
+                                        0x09,
+                                        0x21,
+                                        0x200,
+                                        0,
+                                        buffer,
+                                        8,
+                                        2000);
+                break;
+
+        default:
+                dev_err(&led->udev->dev, "unknown device type %d\n", led->type);
+        }
+
         if (retval)
                 dev_dbg(&led->udev->dev, "retval = %d\n", retval);
         kfree(buffer);
@@ -107,11 +143,12 @@ static int led_probe(struct usb_interface *interface, const struct usb_device_id
 
         dev = kzalloc(sizeof(struct usb_led), GFP_KERNEL);
         if (dev == NULL) {
-                dev_err(&interface->dev, "Out of memory\n");
+                dev_err(&interface->dev, "out of memory\n");
                 goto error_mem;
         }
 
         dev->udev = usb_get_dev(udev);
+        dev->type = id->driver_info;
 
         usb_set_intfdata (interface, dev);
 
@@ -125,6 +162,31 @@ static int led_probe(struct usb_interface *interface, const struct usb_device_id
         if (retval)
                 goto error;
 
+        if (dev->type == DREAM_CHEEKY_WEBMAIL_NOTIFIER) {
+                unsigned char *enable;
+
+                enable = kmemdup("\x1f\x02\0\x5f\0\0\x1a\x03", 8, GFP_KERNEL);
+                if (!enable) {
+                        dev_err(&interface->dev, "out of memory\n");
+                        retval = -ENOMEM;
+                        goto error;
+                }
+
+                retval = usb_control_msg(udev,
+                                        usb_sndctrlpipe(udev, 0),
+                                        0x09,
+                                        0x21,
+                                        0x200,
+                                        0,
+                                        enable,
+                                        8,
+                                        2000);
+
+                kfree(enable);
+                if (retval != 8)
+                        goto error;
+        }
+
         dev_info(&interface->dev, "USB LED device now attached\n");
         return 0;
 
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index c436e1e2c3b6..a09dbd243eb3 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -436,6 +436,28 @@ static unsigned int mon_bin_get_data(const struct mon_reader_bin *rp,
         return length;
 }
 
+/*
+ * This is the look-ahead pass in case of 'C Zi', when actual_length cannot
+ * be used to determine the length of the whole contiguous buffer.
+ */
+static unsigned int mon_bin_collate_isodesc(const struct mon_reader_bin *rp,
+    struct urb *urb, unsigned int ndesc)
+{
+        struct usb_iso_packet_descriptor *fp;
+        unsigned int length;
+
+        length = 0;
+        fp = urb->iso_frame_desc;
+        while (ndesc-- != 0) {
+                if (fp->actual_length != 0) {
+                        if (fp->offset + fp->actual_length > length)
+                                length = fp->offset + fp->actual_length;
+                }
+                fp++;
+        }
+        return length;
+}
+
 static void mon_bin_get_isodesc(const struct mon_reader_bin *rp,
     unsigned int offset, struct urb *urb, char ev_type, unsigned int ndesc)
 {
@@ -478,6 +500,10 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
         /*
          * Find the maximum allowable length, then allocate space.
          */
+        urb_length = (ev_type == 'S') ?
+            urb->transfer_buffer_length : urb->actual_length;
+        length = urb_length;
+
         if (usb_endpoint_xfer_isoc(epd)) {
                 if (urb->number_of_packets < 0) {
                         ndesc = 0;
@@ -486,14 +512,16 @@ static void mon_bin_event(struct mon_reader_bin *rp, struct urb *urb,
                 } else {
                         ndesc = urb->number_of_packets;
                 }
+                if (ev_type == 'C' && usb_urb_dir_in(urb))
+                        length = mon_bin_collate_isodesc(rp, urb, ndesc);
         } else {
                 ndesc = 0;
         }
         lendesc = ndesc*sizeof(struct mon_bin_isodesc);
 
-        urb_length = (ev_type == 'S') ?
-            urb->transfer_buffer_length : urb->actual_length;
-        length = urb_length;
+        /* not an issue unless there's a subtle bug in a HCD somewhere */
+        if (length >= urb->transfer_buffer_length)
+                length = urb->transfer_buffer_length;
 
         if (length >= rp->b_size/5)
                 length = rp->b_size/5;
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 341a37a469bd..4cbb7e4b368d 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -12,6 +12,7 @@ config USB_MUSB_HDRC
         depends on (ARM || (BF54x && !BF544) || (BF52x && !BF522 && !BF523))
         select NOP_USB_XCEIV if (ARCH_DAVINCI || MACH_OMAP3EVM || BLACKFIN)
         select TWL4030_USB if MACH_OMAP_3430SDP
+        select TWL6030_USB if MACH_OMAP_4430SDP || MACH_OMAP4_PANDA
         select USB_OTG_UTILS
         tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
         help
@@ -30,57 +31,41 @@ config USB_MUSB_HDRC
           If you do not know what this is, please say N.
 
           To compile this driver as a module, choose M here; the
-          module will be called "musb_hdrc".
+          module will be called "musb-hdrc".
 
-config USB_MUSB_SOC
-        boolean
+choice
+        prompt "Platform Glue Layer"
         depends on USB_MUSB_HDRC
-        default y if ARCH_DAVINCI
-        default y if ARCH_OMAP2430
-        default y if ARCH_OMAP3
-        default y if ARCH_OMAP4
-        default y if (BF54x && !BF544)
-        default y if (BF52x && !BF522 && !BF523)
 
-comment "DaVinci 35x and 644x USB support"
-        depends on USB_MUSB_HDRC && ARCH_DAVINCI_DMx
+config USB_MUSB_DAVINCI
+        bool "DaVinci"
+        depends on ARCH_DAVINCI_DMx
 
-comment "DA8xx/OMAP-L1x USB support"
-        depends on USB_MUSB_HDRC && ARCH_DAVINCI_DA8XX
+config USB_MUSB_DA8XX
+        bool "DA8xx/OMAP-L1x"
+        depends on ARCH_DAVINCI_DA8XX
 
-comment "OMAP 243x high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP2430
+config USB_MUSB_TUSB6010
+        bool "TUSB6010"
+        depends on ARCH_OMAP
 
-comment "OMAP 343x high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP3
+config USB_MUSB_OMAP2PLUS
+        bool "OMAP2430 and onwards"
+        depends on ARCH_OMAP2PLUS
 
-comment "OMAP 44xx high speed USB support"
-        depends on USB_MUSB_HDRC && ARCH_OMAP4
+config USB_MUSB_AM35X
+        bool "AM35x"
+        depends on ARCH_OMAP
 
-comment "Blackfin high speed USB Support"
-        depends on USB_MUSB_HDRC && ((BF54x && !BF544) || (BF52x && !BF522 && !BF523))
+config USB_MUSB_BLACKFIN
+        bool "Blackfin"
+        depends on (BF54x && !BF544) || (BF52x && ! BF522 && !BF523)
 
-config USB_MUSB_AM35X
-        bool
-        depends on USB_MUSB_HDRC && !ARCH_OMAP2430 && !ARCH_OMAP4
-        select NOP_USB_XCEIV
-        default MACH_OMAP3517EVM
-        help
-          Select this option if your platform is based on AM35x. As
-          AM35x has an updated MUSB with CPPI4.1 DMA so this config
-          is introduced to differentiate musb ip between OMAP3x and
-          AM35x platforms.
-
-config USB_TUSB6010
-        boolean "TUSB 6010 support"
-        depends on USB_MUSB_HDRC && !USB_MUSB_SOC
-        select NOP_USB_XCEIV
-        default y
-        help
-          The TUSB 6010 chip, from Texas Instruments, connects a discrete
-          HDRC core using a 16-bit parallel bus (NOR flash style) or VLYNQ
-          (a high speed serial link).  It can use system-specific external
-          DMA controllers.
+config USB_MUSB_UX500
+        bool "U8500 and U5500"
+        depends on (ARCH_U8500 && AB8500_USB) || (ARCH_U5500)
+
+endchoice
 
 choice
         prompt "Driver Mode"
@@ -158,7 +143,7 @@ config USB_MUSB_HDRC_HCD
 config MUSB_PIO_ONLY
         bool 'Disable DMA (always use PIO)'
         depends on USB_MUSB_HDRC
-        default USB_TUSB6010 || ARCH_DAVINCI_DA8XX || USB_MUSB_AM35X
+        default USB_MUSB_TUSB6010 || USB_MUSB_DA8XX || USB_MUSB_AM35X
         help
           All data is copied between memory and FIFO by the CPU.
           DMA controllers are ignored.
@@ -171,21 +156,21 @@ config MUSB_PIO_ONLY
 config USB_INVENTRA_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        default ARCH_OMAP2430 || ARCH_OMAP3 || BLACKFIN || ARCH_OMAP4
+        default USB_MUSB_OMAP2PLUS || USB_MUSB_BLACKFIN
         help
           Enable DMA transfers using Mentor's engine.
 
 config USB_TI_CPPI_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        default ARCH_DAVINCI
+        default USB_MUSB_DAVINCI
         help
           Enable DMA transfers when TI CPPI DMA is available.
 
 config USB_TUSB_OMAP_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        depends on USB_TUSB6010
+        depends on USB_MUSB_TUSB6010
         depends on ARCH_OMAP
         default y
         help
diff --git a/drivers/usb/musb/Makefile b/drivers/usb/musb/Makefile
index ce164e8998d8..74df5284894f 100644
--- a/drivers/usb/musb/Makefile
+++ b/drivers/usb/musb/Makefile
@@ -8,22 +8,19 @@ obj-$(CONFIG_USB_MUSB_HDRC) += musb_hdrc.o
 
 musb_hdrc-y := musb_core.o
 
-musb_hdrc-$(CONFIG_ARCH_DAVINCI_DMx)            += davinci.o
-musb_hdrc-$(CONFIG_ARCH_DAVINCI_DA8XX)          += da8xx.o
-musb_hdrc-$(CONFIG_USB_TUSB6010)                += tusb6010.o
-musb_hdrc-$(CONFIG_ARCH_OMAP2430)               += omap2430.o
-ifeq ($(CONFIG_USB_MUSB_AM35X),y)
-        musb_hdrc-$(CONFIG_ARCH_OMAP3430)       += am35x.o
-else
-        musb_hdrc-$(CONFIG_ARCH_OMAP3430)       += omap2430.o
-endif
-musb_hdrc-$(CONFIG_ARCH_OMAP4)                  += omap2430.o
-musb_hdrc-$(CONFIG_BF54x)                       += blackfin.o
-musb_hdrc-$(CONFIG_BF52x)                       += blackfin.o
 musb_hdrc-$(CONFIG_USB_GADGET_MUSB_HDRC)        += musb_gadget_ep0.o musb_gadget.o
 musb_hdrc-$(CONFIG_USB_MUSB_HDRC_HCD)           += musb_virthub.o musb_host.o
 musb_hdrc-$(CONFIG_DEBUG_FS)                    += musb_debugfs.o
 
+# Hardware Glue Layer
+obj-$(CONFIG_USB_MUSB_OMAP2PLUS)                += omap2430.o
+obj-$(CONFIG_USB_MUSB_AM35X)                    += am35x.o
+obj-$(CONFIG_USB_MUSB_TUSB6010)                 += tusb6010.o
+obj-$(CONFIG_USB_MUSB_DAVINCI)                  += davinci.o
+obj-$(CONFIG_USB_MUSB_DA8XX)                    += da8xx.o
+obj-$(CONFIG_USB_MUSB_BLACKFIN)                 += blackfin.o
+obj-$(CONFIG_USB_MUSB_UX500)                    += ux500.o
+
 # the kconfig must guarantee that only one of the
 # possible I/O schemes will be enabled at a time ...
 # PIO only, or DMA (several potential schemes).
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index b0aabf3a606f..d5a3da37c90c 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -29,8 +29,9 @@
 #include <linux/init.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
-#include <plat/control.h>
 #include <plat/usb.h>
 
 #include "musb_core.h"
@@ -80,51 +81,18 @@
 
 #define USB_MENTOR_CORE_OFFSET  0x400
 
-static inline void phy_on(void)
-{
-        unsigned long timeout = jiffies + msecs_to_jiffies(100);
-        u32 devconf2;
-
-        /*
-         * Start the on-chip PHY and its PLL.
-         */
-        devconf2 = omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2);
-
-        devconf2 &= ~(CONF2_RESET | CONF2_PHYPWRDN | CONF2_OTGPWRDN);
-        devconf2 |= CONF2_PHY_PLLON;
-
-        omap_ctrl_writel(devconf2, AM35XX_CONTROL_DEVCONF2);
-
-        DBG(1, "Waiting for PHY clock good...\n");
-        while (!(omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2)
-                        & CONF2_PHYCLKGD)) {
-                cpu_relax();
-
-                if (time_after(jiffies, timeout)) {
-                        DBG(1, "musb PHY clock good timed out\n");
-                        break;
-                }
-        }
-}
-
-static inline void phy_off(void)
-{
-        u32 devconf2;
-
-        /*
-         * Power down the on-chip PHY.
-         */
-        devconf2 = omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2);
-
-        devconf2 &= ~CONF2_PHY_PLLON;
-        devconf2 |=  CONF2_PHYPWRDN | CONF2_OTGPWRDN;
-        omap_ctrl_writel(devconf2, AM35XX_CONTROL_DEVCONF2);
-}
+struct am35x_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *phy_clk;
+        struct clk              *clk;
+};
+#define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
 /*
- * musb_platform_enable - enable interrupts
+ * am35x_musb_enable - enable interrupts
  */
-void musb_platform_enable(struct musb *musb)
+static void am35x_musb_enable(struct musb *musb)
 {
         void __iomem *reg_base = musb->ctrl_base;
         u32 epmask;
@@ -143,9 +111,9 @@ void musb_platform_enable(struct musb *musb)
 }
 
 /*
- * musb_platform_disable - disable HDRC and flush interrupts
+ * am35x_musb_disable - disable HDRC and flush interrupts
  */
-void musb_platform_disable(struct musb *musb)
+static void am35x_musb_disable(struct musb *musb)
 {
         void __iomem *reg_base = musb->ctrl_base;
 
@@ -162,7 +130,7 @@ void musb_platform_disable(struct musb *musb)
 #define portstate(stmt)
 #endif
 
-static void am35x_set_vbus(struct musb *musb, int is_on)
+static void am35x_musb_set_vbus(struct musb *musb, int is_on)
 {
         WARN_ON(is_on && is_peripheral_active(musb));
 }
@@ -221,7 +189,7 @@ static void otg_timer(unsigned long _musb)
         spin_unlock_irqrestore(&musb->lock, flags);
 }
 
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         static unsigned long last_timer;
 
@@ -251,13 +219,16 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
         mod_timer(&otg_workaround, timeout);
 }
 
-static irqreturn_t am35x_interrupt(int irq, void *hci)
+static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
 {
         struct musb  *musb = hci;
         void __iomem *reg_base = musb->ctrl_base;
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
         unsigned long flags;
         irqreturn_t ret = IRQ_NONE;
-        u32 epintr, usbintr, lvl_intr;
+        u32 epintr, usbintr;
 
         spin_lock_irqsave(&musb->lock, flags);
 
@@ -346,9 +317,8 @@ eoi:
         /* EOI needs to be written for the IRQ to be re-asserted. */
         if (ret == IRQ_HANDLED || epintr || usbintr) {
                 /* clear level interrupt */
-                lvl_intr = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
-                lvl_intr |= AM35XX_USBOTGSS_INT_CLR;
-                omap_ctrl_writel(lvl_intr, AM35XX_CONTROL_LVL_INTR_CLEAR);
+                if (data->clear_irq)
+                        data->clear_irq();
                 /* write EOI */
                 musb_writel(reg_base, USB_END_OF_INTR_REG, 0);
         }
@@ -362,137 +332,85 @@ eoi:
         return ret;
 }
 
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int am35x_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
-        u32 devconf2 = omap_ctrl_readl(AM35XX_CONTROL_DEVCONF2);
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+        int     retval = 0;
 
-        devconf2 &= ~CONF2_OTGMODE;
-        switch (musb_mode) {
-#ifdef  CONFIG_USB_MUSB_HDRC_HCD
-        case MUSB_HOST:         /* Force VBUS valid, ID = 0 */
-                devconf2 |= CONF2_FORCE_HOST;
-                break;
-#endif
-#ifdef  CONFIG_USB_GADGET_MUSB_HDRC
-        case MUSB_PERIPHERAL:   /* Force VBUS valid, ID = 1 */
-                devconf2 |= CONF2_FORCE_DEVICE;
-                break;
-#endif
-#ifdef  CONFIG_USB_MUSB_OTG
-        case MUSB_OTG:          /* Don't override the VBUS/ID comparators */
-                devconf2 |= CONF2_NO_OVERRIDE;
-                break;
-#endif
-        default:
-                DBG(2, "Trying to set unsupported mode %u\n", musb_mode);
-        }
+        if (data->set_mode)
+                data->set_mode(musb_mode);
+        else
+                retval = -EIO;
 
-        omap_ctrl_writel(devconf2, AM35XX_CONTROL_DEVCONF2);
-        return 0;
+        return retval;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int am35x_musb_init(struct musb *musb)
 {
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
         void __iomem *reg_base = musb->ctrl_base;
-        u32 rev, lvl_intr, sw_reset;
-        int status;
+        u32 rev;
 
         musb->mregs += USB_MENTOR_CORE_OFFSET;
 
-        clk_enable(musb->clock);
-        DBG(2, "musb->clock=%lud\n", clk_get_rate(musb->clock));
-
-        musb->phy_clock = clk_get(musb->controller, "fck");
-        if (IS_ERR(musb->phy_clock)) {
-                status = PTR_ERR(musb->phy_clock);
-                goto exit0;
-        }
-        clk_enable(musb->phy_clock);
-        DBG(2, "musb->phy_clock=%lud\n", clk_get_rate(musb->phy_clock));
-
         /* Returns zero if e.g. not clocked */
         rev = musb_readl(reg_base, USB_REVISION_REG);
-        if (!rev) {
-                status = -ENODEV;
-                goto exit1;
-        }
+        if (!rev)
+                return -ENODEV;
 
         usb_nop_xceiv_register();
         musb->xceiv = otg_get_transceiver();
-        if (!musb->xceiv) {
-                status = -ENODEV;
-                goto exit1;
-        }
+        if (!musb->xceiv)
+                return -ENODEV;
 
         if (is_host_enabled(musb))
                 setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
-        musb->board_set_vbus = am35x_set_vbus;
-
-        /* Global reset */
-        sw_reset = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
-
-        sw_reset |= AM35XX_USBOTGSS_SW_RST;
-        omap_ctrl_writel(sw_reset, AM35XX_CONTROL_IP_SW_RESET);
-
-        sw_reset &= ~AM35XX_USBOTGSS_SW_RST;
-        omap_ctrl_writel(sw_reset, AM35XX_CONTROL_IP_SW_RESET);
+        /* Reset the musb */
+        if (data->reset)
+                data->reset();
 
         /* Reset the controller */
         musb_writel(reg_base, USB_CTRL_REG, AM35X_SOFT_RESET_MASK);
 
         /* Start the on-chip PHY and its PLL. */
-        phy_on();
+        if (data->set_phy_power)
+                data->set_phy_power(1);
 
         msleep(5);
 
-        musb->isr = am35x_interrupt;
+        musb->isr = am35x_musb_interrupt;
 
         /* clear level interrupt */
-        lvl_intr = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
-        lvl_intr |= AM35XX_USBOTGSS_INT_CLR;
-        omap_ctrl_writel(lvl_intr, AM35XX_CONTROL_LVL_INTR_CLEAR);
+        if (data->clear_irq)
+                data->clear_irq();
+
         return 0;
-exit1:
-        clk_disable(musb->phy_clock);
-        clk_put(musb->phy_clock);
-exit0:
-        clk_disable(musb->clock);
-        return status;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int am35x_musb_exit(struct musb *musb)
 {
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+
         if (is_host_enabled(musb))
                 del_timer_sync(&otg_workaround);
 
-        phy_off();
+        /* Shutdown the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(0);
 
         otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
 
-        clk_disable(musb->clock);
-
-        clk_disable(musb->phy_clock);
-        clk_put(musb->phy_clock);
-
         return 0;
 }
 
-#ifdef CONFIG_PM
-void musb_platform_save_context(struct musb *musb,
-        struct musb_context_registers *musb_context)
-{
-        phy_off();
-}
-
-void musb_platform_restore_context(struct musb *musb,
-        struct musb_context_registers *musb_context)
-{
-        phy_on();
-}
-#endif
-
 /* AM35x supports only 32bit read operation */
 void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 {
@@ -522,3 +440,215 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
                 memcpy(dst, &val, len);
         }
 }
+
+static const struct musb_platform_ops am35x_ops = {
+        .init           = am35x_musb_init,
+        .exit           = am35x_musb_exit,
+
+        .enable         = am35x_musb_enable,
+        .disable        = am35x_musb_disable,
+
+        .set_mode       = am35x_musb_set_mode,
+        .try_idle       = am35x_musb_try_idle,
+
+        .set_vbus       = am35x_musb_set_vbus,
+};
+
+static u64 am35x_dmamask = DMA_BIT_MASK(32);
+
+static int __init am35x_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct am35x_glue               *glue;
+
+        struct clk                      *phy_clk;
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        phy_clk = clk_get(&pdev->dev, "fck");
+        if (IS_ERR(phy_clk)) {
+                dev_err(&pdev->dev, "failed to get PHY clock\n");
+                ret = PTR_ERR(phy_clk);
+                goto err2;
+        }
+
+        clk = clk_get(&pdev->dev, "ick");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err3;
+        }
+
+        ret = clk_enable(phy_clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable PHY clock\n");
+                goto err4;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err5;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &am35x_dmamask;
+        musb->dev.coherent_dma_mask     = am35x_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->phy_clk                   = phy_clk;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &am35x_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err6;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err6;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err6;
+        }
+
+        return 0;
+
+err6:
+        clk_disable(clk);
+
+err5:
+        clk_disable(phy_clk);
+
+err4:
+        clk_put(clk);
+
+err3:
+        clk_put(phy_clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit am35x_remove(struct platform_device *pdev)
+{
+        struct am35x_glue       *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_disable(glue->phy_clk);
+        clk_put(glue->clk);
+        clk_put(glue->phy_clk);
+        kfree(glue);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int am35x_suspend(struct device *dev)
+{
+        struct am35x_glue       *glue = dev_get_drvdata(dev);
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+
+        /* Shutdown the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(0);
+
+        clk_disable(glue->phy_clk);
+        clk_disable(glue->clk);
+
+        return 0;
+}
+
+static int am35x_resume(struct device *dev)
+{
+        struct am35x_glue       *glue = dev_get_drvdata(dev);
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
+        int                     ret;
+
+        /* Start the on-chip PHY and its PLL. */
+        if (data->set_phy_power)
+                data->set_phy_power(1);
+
+        ret = clk_enable(glue->phy_clk);
+        if (ret) {
+                dev_err(dev, "failed to enable PHY clock\n");
+                return ret;
+        }
+
+        ret = clk_enable(glue->clk);
+        if (ret) {
+                dev_err(dev, "failed to enable clock\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static struct dev_pm_ops am35x_pm_ops = {
+        .suspend        = am35x_suspend,
+        .resume         = am35x_resume,
+};
+
+#define DEV_PM_OPS      &am35x_pm_ops
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver am35x_driver = {
+        .remove         = __exit_p(am35x_remove),
+        .driver         = {
+                .name   = "musb-am35x",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("AM35x MUSB Glue Layer");
+MODULE_AUTHOR("Ajay Kumar Gupta <ajay.gupta@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init am35x_init(void)
+{
+        return platform_driver_probe(&am35x_driver, am35x_probe);
+}
+subsys_initcall(am35x_init);
+
+static void __exit am35x_exit(void)
+{
+        platform_driver_unregister(&am35x_driver);
+}
+module_exit(am35x_exit);
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index fcb5206a65bd..eeba228eb2af 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -15,12 +15,20 @@
 #include <linux/list.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/cacheflush.h>
 
 #include "musb_core.h"
 #include "blackfin.h"
 
+struct bfin_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+};
+#define glue_to_musb(g)         platform_get_drvdata(g->musb)
+
 /*
  * Load an endpoint's FIFO
  */
@@ -278,7 +286,7 @@ static void musb_conn_timer_handler(unsigned long _musb)
         DBG(4, "state is %s\n", otg_state_string(musb));
 }
 
-void musb_platform_enable(struct musb *musb)
+static void bfin_musb_enable(struct musb *musb)
 {
         if (!is_otg_enabled(musb) && is_host_enabled(musb)) {
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
@@ -286,11 +294,11 @@ void musb_platform_enable(struct musb *musb)
         }
 }
 
-void musb_platform_disable(struct musb *musb)
+static void bfin_musb_disable(struct musb *musb)
 {
 }
 
-static void bfin_set_vbus(struct musb *musb, int is_on)
+static void bfin_musb_set_vbus(struct musb *musb, int is_on)
 {
         int value = musb->config->gpio_vrsel_active;
         if (!is_on)
@@ -303,28 +311,28 @@ static void bfin_set_vbus(struct musb *musb, int is_on)
                 musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
-static int bfin_set_power(struct otg_transceiver *x, unsigned mA)
+static int bfin_musb_set_power(struct otg_transceiver *x, unsigned mA)
 {
         return 0;
 }
 
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void bfin_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         if (!is_otg_enabled(musb) && is_host_enabled(musb))
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
 }
 
-int musb_platform_get_vbus_status(struct musb *musb)
+static int bfin_musb_get_vbus_status(struct musb *musb)
 {
         return 0;
 }
 
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int bfin_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         return -EIO;
 }
 
-static void musb_platform_reg_init(struct musb *musb)
+static void bfin_musb_reg_init(struct musb *musb)
 {
         if (ANOMALY_05000346) {
                 bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value);
@@ -362,7 +370,7 @@ static void musb_platform_reg_init(struct musb *musb)
         SSYNC();
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int bfin_musb_init(struct musb *musb)
 {
 
         /*
@@ -386,25 +394,124 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                 return -ENODEV;
         }
 
-        musb_platform_reg_init(musb);
+        bfin_musb_reg_init(musb);
 
         if (is_host_enabled(musb)) {
-                musb->board_set_vbus = bfin_set_vbus;
                 setup_timer(&musb_conn_timer,
                         musb_conn_timer_handler, (unsigned long) musb);
         }
         if (is_peripheral_enabled(musb))
-                musb->xceiv->set_power = bfin_set_power;
+                musb->xceiv->set_power = bfin_musb_set_power;
 
         musb->isr = blackfin_interrupt;
 
         return 0;
 }
 
+static int bfin_musb_exit(struct musb *musb)
+{
+        gpio_free(musb->config->gpio_vrsel);
+
+        otg_put_transceiver(musb->xceiv);
+        usb_nop_xceiv_unregister();
+        return 0;
+}
+
+static const struct musb_platform_ops bfin_ops = {
+        .init           = bfin_musb_init,
+        .exit           = bfin_musb_exit,
+
+        .enable         = bfin_musb_enable,
+        .disable        = bfin_musb_disable,
+
+        .set_mode       = bfin_musb_set_mode,
+        .try_idle       = bfin_musb_try_idle,
+
+        .vbus_status    = bfin_musb_vbus_status,
+        .set_vbus       = bfin_musb_set_vbus,
+};
+
+static u64 bfin_dmamask = DMA_BIT_MASK(32);
+
+static int __init bfin_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct bfin_glue                *glue;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &bfin_dmamask;
+        musb->dev.coherent_dma_mask     = bfin_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+
+        pdata->platform_ops             = &bfin_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err2;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err2;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err2;
+        }
+
+        return 0;
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit bfin_remove(struct platform_device *pdev)
+{
+        struct bfin_glue                *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        kfree(glue);
+
+        return 0;
+}
+
 #ifdef CONFIG_PM
-void musb_platform_save_context(struct musb *musb,
-                        struct musb_context_registers *musb_context)
+static int bfin_suspend(struct device *dev)
 {
+        struct bfin_glue        *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+
         if (is_host_active(musb))
                 /*
                  * During hibernate gpio_vrsel will change from high to low
@@ -413,20 +520,50 @@ void musb_platform_save_context(struct musb *musb,
                  * wakeup event.
                  */
                 gpio_set_value(musb->config->gpio_vrsel, 0);
+
+        return 0;
 }
 
-void musb_platform_restore_context(struct musb *musb,
-                        struct musb_context_registers *musb_context)
+static int bfin_resume(struct device *dev)
 {
-        musb_platform_reg_init(musb);
+        struct bfin_glue        *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+
+        bfin_musb_reg_init(musb);
+
+        return 0;
 }
+
+static struct dev_pm_ops bfin_pm_ops = {
+        .suspend        = bfin_suspend,
+        .resume         = bfin_resume,
+};
+
+#define DEV_PM_OPS      &bfin_pm_op,
+#else
+#define DEV_PM_OPS      NULL
 #endif
 
-int musb_platform_exit(struct musb *musb)
+static struct platform_driver bfin_driver = {
+        .remove         = __exit_p(bfin_remove),
+        .driver         = {
+                .name   = "musb-bfin",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("Blackfin MUSB Glue Layer");
+MODULE_AUTHOR("Bryan Wy <cooloney@kernel.org>");
+MODULE_LICENSE("GPL v2");
+
+static int __init bfin_init(void)
 {
-        gpio_free(musb->config->gpio_vrsel);
+        return platform_driver_probe(&bfin_driver, bfin_probe);
+}
+subsys_initcall(bfin_init);
 
-        otg_put_transceiver(musb->xceiv);
-        usb_nop_xceiv_unregister();
-        return 0;
+static void __exit bfin_exit(void)
+{
+        platform_driver_unregister(&bfin_driver);
 }
+module_exit(bfin_exit);
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index f5a65ff0ac2b..de55a3c3259a 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -1308,7 +1308,7 @@ dma_controller_create(struct musb *musb, void __iomem *mregs)
         struct cppi             *controller;
         struct device           *dev = musb->controller;
         struct platform_device  *pdev = to_platform_device(dev);
-        int                     irq = platform_get_irq(pdev, 1);
+        int                     irq = platform_get_irq_byname(pdev, "dma");
 
         controller = kzalloc(sizeof *controller, GFP_KERNEL);
         if (!controller)
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 84427bebbf62..69a0da3c8f09 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -29,6 +29,8 @@
 #include <linux/init.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include <mach/da8xx.h>
 #include <mach/usb.h>
@@ -78,6 +80,12 @@
 
 #define CFGCHIP2        IO_ADDRESS(DA8XX_SYSCFG0_BASE + DA8XX_CFGCHIP2_REG)
 
+struct da8xx_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+
 /*
  * REVISIT (PM): we should be able to keep the PHY in low power mode most
  * of the time (24 MHz oscillator and PLL off, etc.) by setting POWER.D0
@@ -131,9 +139,9 @@ static inline void phy_off(void)
  */
 
 /**
- * musb_platform_enable - enable interrupts
+ * da8xx_musb_enable - enable interrupts
  */
-void musb_platform_enable(struct musb *musb)
+static void da8xx_musb_enable(struct musb *musb)
 {
         void __iomem *reg_base = musb->ctrl_base;
         u32 mask;
@@ -151,9 +159,9 @@ void musb_platform_enable(struct musb *musb)
 }
 
 /**
- * musb_platform_disable - disable HDRC and flush interrupts
+ * da8xx_musb_disable - disable HDRC and flush interrupts
  */
-void musb_platform_disable(struct musb *musb)
+static void da8xx_musb_disable(struct musb *musb)
 {
         void __iomem *reg_base = musb->ctrl_base;
 
@@ -170,7 +178,7 @@ void musb_platform_disable(struct musb *musb)
 #define portstate(stmt)
 #endif
 
-static void da8xx_set_vbus(struct musb *musb, int is_on)
+static void da8xx_musb_set_vbus(struct musb *musb, int is_on)
 {
         WARN_ON(is_on && is_peripheral_active(musb));
 }
@@ -252,7 +260,7 @@ static void otg_timer(unsigned long _musb)
         spin_unlock_irqrestore(&musb->lock, flags);
 }
 
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         static unsigned long last_timer;
 
@@ -282,7 +290,7 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
         mod_timer(&otg_workaround, timeout);
 }
 
-static irqreturn_t da8xx_interrupt(int irq, void *hci)
+static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
 {
         struct musb             *musb = hci;
         void __iomem            *reg_base = musb->ctrl_base;
@@ -380,7 +388,7 @@ static irqreturn_t da8xx_interrupt(int irq, void *hci)
         return ret;
 }
 
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int da8xx_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         u32 cfgchip2 = __raw_readl(CFGCHIP2);
 
@@ -409,15 +417,13 @@ int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
         return 0;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int da8xx_musb_init(struct musb *musb)
 {
         void __iomem *reg_base = musb->ctrl_base;
         u32 rev;
 
         musb->mregs += DA8XX_MENTOR_CORE_OFFSET;
 
-        clk_enable(musb->clock);
-
         /* Returns zero if e.g. not clocked */
         rev = musb_readl(reg_base, DA8XX_USB_REVISION_REG);
         if (!rev)
@@ -431,8 +437,6 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
         if (is_host_enabled(musb))
                 setup_timer(&otg_workaround, otg_timer, (unsigned long)musb);
 
-        musb->board_set_vbus = da8xx_set_vbus;
-
         /* Reset the controller */
         musb_writel(reg_base, DA8XX_USB_CTRL_REG, DA8XX_SOFT_RESET_MASK);
 
@@ -446,14 +450,13 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                  rev, __raw_readl(CFGCHIP2),
                  musb_readb(reg_base, DA8XX_USB_CTRL_REG));
 
-        musb->isr = da8xx_interrupt;
+        musb->isr = da8xx_musb_interrupt;
         return 0;
 fail:
-        clk_disable(musb->clock);
         return -ENODEV;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int da8xx_musb_exit(struct musb *musb)
 {
         if (is_host_enabled(musb))
                 del_timer_sync(&otg_workaround);
@@ -463,7 +466,140 @@ int musb_platform_exit(struct musb *musb)
         otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
 
-        clk_disable(musb->clock);
+        return 0;
+}
+
+static const struct musb_platform_ops da8xx_ops = {
+        .init           = da8xx_musb_init,
+        .exit           = da8xx_musb_exit,
+
+        .enable         = da8xx_musb_enable,
+        .disable        = da8xx_musb_disable,
+
+        .set_mode       = da8xx_musb_set_mode,
+        .try_idle       = da8xx_musb_try_idle,
+
+        .set_vbus       = da8xx_musb_set_vbus,
+};
+
+static u64 da8xx_dmamask = DMA_BIT_MASK(32);
+
+static int __init da8xx_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct da8xx_glue               *glue;
+
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        clk = clk_get(&pdev->dev, "usb20");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &da8xx_dmamask;
+        musb->dev.coherent_dma_mask     = da8xx_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &da8xx_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
+
+        return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit da8xx_remove(struct platform_device *pdev)
+{
+        struct da8xx_glue               *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
 
         return 0;
 }
+
+static struct platform_driver da8xx_driver = {
+        .remove         = __exit_p(da8xx_remove),
+        .driver         = {
+                .name   = "musb-da8xx",
+        },
+};
+
+MODULE_DESCRIPTION("DA8xx/OMAP-L1x MUSB Glue Layer");
+MODULE_AUTHOR("Sergei Shtylyov <sshtylyov@ru.mvista.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init da8xx_init(void)
+{
+        return platform_driver_probe(&da8xx_driver, da8xx_probe);
+}
+subsys_initcall(da8xx_init);
+
+static void __exit da8xx_exit(void)
+{
+        platform_driver_unregister(&da8xx_driver);
+}
+module_exit(da8xx_exit);
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 6e67629f50cc..e6de097fb7e8 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -30,6 +30,8 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include <mach/hardware.h>
 #include <mach/memory.h>
@@ -51,6 +53,12 @@
 #define USB_PHY_CTRL    IO_ADDRESS(USBPHY_CTL_PADDR)
 #define DM355_DEEPSLEEP IO_ADDRESS(DM355_DEEPSLEEP_PADDR)
 
+struct davinci_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+
 /* REVISIT (PM) we should be able to keep the PHY in low power mode most
  * of the time (24 MHZ oscillator and PLL off, etc) by setting POWER.D0
  * and, when in host mode, autosuspending idle root ports... PHYPLLON
@@ -83,7 +91,7 @@ static inline void phy_off(void)
 
 static int dma_off = 1;
 
-void musb_platform_enable(struct musb *musb)
+static void davinci_musb_enable(struct musb *musb)
 {
         u32     tmp, old, val;
 
@@ -116,7 +124,7 @@ void musb_platform_enable(struct musb *musb)
 /*
  * Disable the HDRC and flush interrupts
  */
-void musb_platform_disable(struct musb *musb)
+static void davinci_musb_disable(struct musb *musb)
 {
         /* because we don't set CTRLR.UINT, "important" to:
          *  - not read/write INTRUSB/INTRUSBE
@@ -167,7 +175,7 @@ static void evm_deferred_drvvbus(struct work_struct *ignored)
 
 #endif  /* EVM */
 
-static void davinci_source_power(struct musb *musb, int is_on, int immediate)
+static void davinci_musb_source_power(struct musb *musb, int is_on, int immediate)
 {
 #ifdef CONFIG_MACH_DAVINCI_EVM
         if (is_on)
@@ -190,10 +198,10 @@ static void davinci_source_power(struct musb *musb, int is_on, int immediate)
 #endif
 }
 
-static void davinci_set_vbus(struct musb *musb, int is_on)
+static void davinci_musb_set_vbus(struct musb *musb, int is_on)
 {
         WARN_ON(is_on && is_peripheral_active(musb));
-        davinci_source_power(musb, is_on, 0);
+        davinci_musb_source_power(musb, is_on, 0);
 }
 
 
@@ -259,7 +267,7 @@ static void otg_timer(unsigned long _musb)
         spin_unlock_irqrestore(&musb->lock, flags);
 }
 
-static irqreturn_t davinci_interrupt(int irq, void *__hci)
+static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
 {
         unsigned long   flags;
         irqreturn_t     retval = IRQ_NONE;
@@ -345,7 +353,7 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
                 /* NOTE:  this must complete poweron within 100 msec
                  * (OTG_TIME_A_WAIT_VRISE) but we don't check for that.
                  */
-                davinci_source_power(musb, drvvbus, 0);
+                davinci_musb_source_power(musb, drvvbus, 0);
                 DBG(2, "VBUS %s (%s)%s, devctl %02x\n",
                                 drvvbus ? "on" : "off",
                                 otg_state_string(musb),
@@ -370,13 +378,13 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
         return retval;
 }
 
-int musb_platform_set_mode(struct musb *musb, u8 mode)
+static int davinci_musb_set_mode(struct musb *musb, u8 mode)
 {
         /* EVM can't do this (right?) */
         return -EIO;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int davinci_musb_init(struct musb *musb)
 {
         void __iomem    *tibase = musb->ctrl_base;
         u32             revision;
@@ -388,8 +396,6 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
 
         musb->mregs += DAVINCI_BASE_OFFSET;
 
-        clk_enable(musb->clock);
-
         /* returns zero if e.g. not clocked */
         revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG);
         if (revision == 0)
@@ -398,8 +404,7 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
         if (is_host_enabled(musb))
                 setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
-        musb->board_set_vbus = davinci_set_vbus;
-        davinci_source_power(musb, 0, 1);
+        davinci_musb_source_power(musb, 0, 1);
 
         /* dm355 EVM swaps D+/D- for signal integrity, and
          * is clocked from the main 24 MHz crystal.
@@ -440,18 +445,16 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                 revision, __raw_readl(USB_PHY_CTRL),
                 musb_readb(tibase, DAVINCI_USB_CTRL_REG));
 
-        musb->isr = davinci_interrupt;
+        musb->isr = davinci_musb_interrupt;
         return 0;
 
 fail:
-        clk_disable(musb->clock);
-
         otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
         return -ENODEV;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int davinci_musb_exit(struct musb *musb)
 {
         if (is_host_enabled(musb))
                 del_timer_sync(&otg_workaround);
@@ -465,7 +468,7 @@ int musb_platform_exit(struct musb *musb)
                 __raw_writel(deepsleep, DM355_DEEPSLEEP);
         }
 
-        davinci_source_power(musb, 0 /*off*/, 1);
+        davinci_musb_source_power(musb, 0 /*off*/, 1);
 
         /* delay, to avoid problems with module reload */
         if (is_host_enabled(musb) && musb->xceiv->default_a) {
@@ -495,10 +498,141 @@ int musb_platform_exit(struct musb *musb)
 
         phy_off();
 
-        clk_disable(musb->clock);
-
         otg_put_transceiver(musb->xceiv);
         usb_nop_xceiv_unregister();
 
         return 0;
 }
+
+static const struct musb_platform_ops davinci_ops = {
+        .init           = davinci_musb_init,
+        .exit           = davinci_musb_exit,
+
+        .enable         = davinci_musb_enable,
+        .disable        = davinci_musb_disable,
+
+        .set_mode       = davinci_musb_set_mode,
+
+        .set_vbus       = davinci_musb_set_vbus,
+};
+
+static u64 davinci_dmamask = DMA_BIT_MASK(32);
+
+static int __init davinci_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct davinci_glue             *glue;
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        clk = clk_get(&pdev->dev, "usb");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &davinci_dmamask;
+        musb->dev.coherent_dma_mask     = davinci_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &davinci_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
+
+        return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit davinci_remove(struct platform_device *pdev)
+{
+        struct davinci_glue             *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
+
+        return 0;
+}
+
+static struct platform_driver davinci_driver = {
+        .remove         = __exit_p(davinci_remove),
+        .driver         = {
+                .name   = "musb-davinci",
+        },
+};
+
+MODULE_DESCRIPTION("DaVinci MUSB Glue Layer");
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init davinci_init(void)
+{
+        return platform_driver_probe(&davinci_driver, davinci_probe);
+}
+subsys_initcall(davinci_init);
+
+static void __exit davinci_exit(void)
+{
+        platform_driver_unregister(&davinci_driver);
+}
+module_exit(davinci_exit);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 99beebce8550..07cf394e491b 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -99,19 +99,8 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 
-#ifdef  CONFIG_ARM
-#include <mach/hardware.h>
-#include <mach/memory.h>
-#include <asm/mach-types.h>
-#endif
-
 #include "musb_core.h"
 
-
-#ifdef CONFIG_ARCH_DAVINCI
-#include "davinci.h"
-#endif
-
 #define TA_WAIT_BCON(m) max_t(int, (m)->a_wait_bcon, OTG_TIME_A_WAIT_BCON)
 
 
@@ -126,7 +115,7 @@ MODULE_PARM_DESC(debug, "Debug message level. Default = 0");
 
 #define DRIVER_INFO DRIVER_DESC ", v" MUSB_VERSION
 
-#define MUSB_DRIVER_NAME "musb_hdrc"
+#define MUSB_DRIVER_NAME "musb-hdrc"
 const char musb_driver_name[] = MUSB_DRIVER_NAME;
 
 MODULE_DESCRIPTION(DRIVER_INFO);
@@ -230,7 +219,7 @@ static struct otg_io_access_ops musb_ulpi_access = {
 
 /*-------------------------------------------------------------------------*/
 
-#if !defined(CONFIG_USB_TUSB6010) && !defined(CONFIG_BLACKFIN)
+#if !defined(CONFIG_USB_MUSB_TUSB6010) && !defined(CONFIG_USB_MUSB_BLACKFIN)
 
 /*
  * Load an endpoint's FIFO
@@ -390,7 +379,7 @@ void musb_otg_timer_func(unsigned long data)
         case OTG_STATE_A_SUSPEND:
         case OTG_STATE_A_WAIT_BCON:
                 DBG(1, "HNP: %s timeout\n", otg_state_string(musb));
-                musb_set_vbus(musb, 0);
+                musb_platform_set_vbus(musb, 0);
                 musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                 break;
         default:
@@ -571,7 +560,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                 musb->ep0_stage = MUSB_EP0_START;
                 musb->xceiv->state = OTG_STATE_A_IDLE;
                 MUSB_HST_MODE(musb);
-                musb_set_vbus(musb, 1);
+                musb_platform_set_vbus(musb, 1);
 
                 handled = IRQ_HANDLED;
         }
@@ -642,7 +631,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
                 /* go through A_WAIT_VFALL then start a new session */
                 if (!ignore)
-                        musb_set_vbus(musb, 0);
+                        musb_platform_set_vbus(musb, 0);
                 handled = IRQ_HANDLED;
         }
 
@@ -1049,8 +1038,6 @@ static void musb_shutdown(struct platform_device *pdev)
         spin_lock_irqsave(&musb->lock, flags);
         musb_platform_disable(musb);
         musb_generic_disable(musb);
-        if (musb->clock)
-                clk_put(musb->clock);
         spin_unlock_irqrestore(&musb->lock, flags);
 
         if (!is_otg_enabled(musb) && is_host_enabled(musb))
@@ -1074,10 +1061,11 @@ static void musb_shutdown(struct platform_device *pdev)
  * We don't currently use dynamic fifo setup capability to do anything
  * more than selecting one of a bunch of predefined configurations.
  */
-#if defined(CONFIG_USB_TUSB6010) || \
-        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) \
-        || defined(CONFIG_ARCH_OMAP4)
+#if defined(CONFIG_USB_MUSB_TUSB6010) || defined(CONFIG_USB_MUSB_OMAP2PLUS) \
+        || defined(CONFIG_USB_MUSB_AM35X)
 static ushort __initdata fifo_mode = 4;
+#elif defined(CONFIG_USB_MUSB_UX500)
+static ushort __initdata fifo_mode = 5;
 #else
 static ushort __initdata fifo_mode = 2;
 #endif
@@ -1501,7 +1489,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
                 struct musb_hw_ep       *hw_ep = musb->endpoints + i;
 
                 hw_ep->fifo = MUSB_FIFO_OFFSET(i) + mbase;
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
                 hw_ep->fifo_async = musb->async + 0x400 + MUSB_FIFO_OFFSET(i);
                 hw_ep->fifo_sync = musb->sync + 0x400 + MUSB_FIFO_OFFSET(i);
                 hw_ep->fifo_sync_va =
@@ -1548,7 +1536,8 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 /*-------------------------------------------------------------------------*/
 
 #if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430) || \
-        defined(CONFIG_ARCH_OMAP4)
+        defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_ARCH_U8500) || \
+        defined(CONFIG_ARCH_U5500)
 
 static irqreturn_t generic_interrupt(int irq, void *__hci)
 {
@@ -1904,6 +1893,7 @@ allocate_instance(struct device *dev,
         }
 
         musb->controller = dev;
+
         return musb;
 }
 
@@ -2000,30 +1990,14 @@ bad_config:
         spin_lock_init(&musb->lock);
         musb->board_mode = plat->mode;
         musb->board_set_power = plat->set_power;
-        musb->set_clock = plat->set_clock;
         musb->min_power = plat->min_power;
-
-        /* Clock usage is chip-specific ... functional clock (DaVinci,
-         * OMAP2430), or PHY ref (some TUSB6010 boards).  All this core
-         * code does is make sure a clock handle is available; platform
-         * code manages it during start/stop and suspend/resume.
-         */
-        if (plat->clock) {
-                musb->clock = clk_get(dev, plat->clock);
-                if (IS_ERR(musb->clock)) {
-                        status = PTR_ERR(musb->clock);
-                        musb->clock = NULL;
-                        goto fail1;
-                }
-        }
+        musb->ops = plat->platform_ops;
 
         /* The musb_platform_init() call:
          *   - adjusts musb->mregs and musb->isr if needed,
          *   - may initialize an integrated tranceiver
          *   - initializes musb->xceiv, usually by otg_get_transceiver()
-         *   - activates clocks.
          *   - stops powering VBUS
-         *   - assigns musb->board_set_vbus if host mode is enabled
          *
          * There are various transciever configurations.  Blackfin,
          * DaVinci, TUSB60x0, and others integrate them.  OMAP3 uses
@@ -2031,9 +2005,9 @@ bad_config:
          * isp1504, non-OTG, etc) mostly hooking up through ULPI.
          */
         musb->isr = generic_interrupt;
-        status = musb_platform_init(musb, plat->board_data);
+        status = musb_platform_init(musb);
         if (status < 0)
-                goto fail2;
+                goto fail1;
 
         if (!musb->isr) {
                 status = -ENODEV;
@@ -2186,10 +2160,6 @@ fail3:
                 device_init_wakeup(dev, 0);
         musb_platform_exit(musb);
 
-fail2:
-        if (musb->clock)
-                clk_put(musb->clock);
-
 fail1:
         dev_err(musb->controller,
                 "musb_init_controller failed with status %d\n", status);
@@ -2215,7 +2185,7 @@ static u64	*orig_dma_mask;
 static int __init musb_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
-        int             irq = platform_get_irq(pdev, 0);
+        int             irq = platform_get_irq_byname(pdev, "mc");
         int             status;
         struct resource *iomem;
         void __iomem    *base;
@@ -2265,144 +2235,138 @@ static int __exit musb_remove(struct platform_device *pdev)
 
 #ifdef  CONFIG_PM
 
-static struct musb_context_registers musb_context;
-
-void musb_save_context(struct musb *musb)
+static void musb_save_context(struct musb *musb)
 {
         int i;
         void __iomem *musb_base = musb->mregs;
         void __iomem *epio;
 
         if (is_host_enabled(musb)) {
-                musb_context.frame = musb_readw(musb_base, MUSB_FRAME);
-                musb_context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
-                musb_context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
+                musb->context.frame = musb_readw(musb_base, MUSB_FRAME);
+                musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
+                musb->context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
         }
-        musb_context.power = musb_readb(musb_base, MUSB_POWER);
-        musb_context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
-        musb_context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
-        musb_context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);
-        musb_context.index = musb_readb(musb_base, MUSB_INDEX);
-        musb_context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
+        musb->context.power = musb_readb(musb_base, MUSB_POWER);
+        musb->context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
+        musb->context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
+        musb->context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);
+        musb->context.index = musb_readb(musb_base, MUSB_INDEX);
+        musb->context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
 
         for (i = 0; i < musb->config->num_eps; ++i) {
                 epio = musb->endpoints[i].regs;
-                musb_context.index_regs[i].txmaxp =
+                musb->context.index_regs[i].txmaxp =
                         musb_readw(epio, MUSB_TXMAXP);
-                musb_context.index_regs[i].txcsr =
+                musb->context.index_regs[i].txcsr =
                         musb_readw(epio, MUSB_TXCSR);
-                musb_context.index_regs[i].rxmaxp =
+                musb->context.index_regs[i].rxmaxp =
                         musb_readw(epio, MUSB_RXMAXP);
-                musb_context.index_regs[i].rxcsr =
+                musb->context.index_regs[i].rxcsr =
                         musb_readw(epio, MUSB_RXCSR);
 
                 if (musb->dyn_fifo) {
-                        musb_context.index_regs[i].txfifoadd =
+                        musb->context.index_regs[i].txfifoadd =
                                         musb_read_txfifoadd(musb_base);
-                        musb_context.index_regs[i].rxfifoadd =
+                        musb->context.index_regs[i].rxfifoadd =
                                         musb_read_rxfifoadd(musb_base);
-                        musb_context.index_regs[i].txfifosz =
+                        musb->context.index_regs[i].txfifosz =
                                         musb_read_txfifosz(musb_base);
-                        musb_context.index_regs[i].rxfifosz =
+                        musb->context.index_regs[i].rxfifosz =
                                         musb_read_rxfifosz(musb_base);
                 }
                 if (is_host_enabled(musb)) {
-                        musb_context.index_regs[i].txtype =
+                        musb->context.index_regs[i].txtype =
                                 musb_readb(epio, MUSB_TXTYPE);
-                        musb_context.index_regs[i].txinterval =
+                        musb->context.index_regs[i].txinterval =
                                 musb_readb(epio, MUSB_TXINTERVAL);
-                        musb_context.index_regs[i].rxtype =
+                        musb->context.index_regs[i].rxtype =
                                 musb_readb(epio, MUSB_RXTYPE);
-                        musb_context.index_regs[i].rxinterval =
+                        musb->context.index_regs[i].rxinterval =
                                 musb_readb(epio, MUSB_RXINTERVAL);
 
-                        musb_context.index_regs[i].txfunaddr =
+                        musb->context.index_regs[i].txfunaddr =
                                 musb_read_txfunaddr(musb_base, i);
-                        musb_context.index_regs[i].txhubaddr =
+                        musb->context.index_regs[i].txhubaddr =
                                 musb_read_txhubaddr(musb_base, i);
-                        musb_context.index_regs[i].txhubport =
+                        musb->context.index_regs[i].txhubport =
                                 musb_read_txhubport(musb_base, i);
 
-                        musb_context.index_regs[i].rxfunaddr =
+                        musb->context.index_regs[i].rxfunaddr =
                                 musb_read_rxfunaddr(musb_base, i);
-                        musb_context.index_regs[i].rxhubaddr =
+                        musb->context.index_regs[i].rxhubaddr =
                                 musb_read_rxhubaddr(musb_base, i);
-                        musb_context.index_regs[i].rxhubport =
+                        musb->context.index_regs[i].rxhubport =
                                 musb_read_rxhubport(musb_base, i);
                 }
         }
-
-        musb_platform_save_context(musb, &musb_context);
 }
 
-void musb_restore_context(struct musb *musb)
+static void musb_restore_context(struct musb *musb)
 {
         int i;
         void __iomem *musb_base = musb->mregs;
         void __iomem *ep_target_regs;
         void __iomem *epio;
 
-        musb_platform_restore_context(musb, &musb_context);
-
         if (is_host_enabled(musb)) {
-                musb_writew(musb_base, MUSB_FRAME, musb_context.frame);
-                musb_writeb(musb_base, MUSB_TESTMODE, musb_context.testmode);
-                musb_write_ulpi_buscontrol(musb->mregs, musb_context.busctl);
+                musb_writew(musb_base, MUSB_FRAME, musb->context.frame);
+                musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);
+                musb_write_ulpi_buscontrol(musb->mregs, musb->context.busctl);
         }
-        musb_writeb(musb_base, MUSB_POWER, musb_context.power);
-        musb_writew(musb_base, MUSB_INTRTXE, musb_context.intrtxe);
-        musb_writew(musb_base, MUSB_INTRRXE, musb_context.intrrxe);
-        musb_writeb(musb_base, MUSB_INTRUSBE, musb_context.intrusbe);
-        musb_writeb(musb_base, MUSB_DEVCTL, musb_context.devctl);
+        musb_writeb(musb_base, MUSB_POWER, musb->context.power);
+        musb_writew(musb_base, MUSB_INTRTXE, musb->context.intrtxe);
+        musb_writew(musb_base, MUSB_INTRRXE, musb->context.intrrxe);
+        musb_writeb(musb_base, MUSB_INTRUSBE, musb->context.intrusbe);
+        musb_writeb(musb_base, MUSB_DEVCTL, musb->context.devctl);
 
         for (i = 0; i < musb->config->num_eps; ++i) {
                 epio = musb->endpoints[i].regs;
                 musb_writew(epio, MUSB_TXMAXP,
-                        musb_context.index_regs[i].txmaxp);
+                        musb->context.index_regs[i].txmaxp);
                 musb_writew(epio, MUSB_TXCSR,
-                        musb_context.index_regs[i].txcsr);
+                        musb->context.index_regs[i].txcsr);
                 musb_writew(epio, MUSB_RXMAXP,
-                        musb_context.index_regs[i].rxmaxp);
+                        musb->context.index_regs[i].rxmaxp);
                 musb_writew(epio, MUSB_RXCSR,
-                        musb_context.index_regs[i].rxcsr);
+                        musb->context.index_regs[i].rxcsr);
 
                 if (musb->dyn_fifo) {
                         musb_write_txfifosz(musb_base,
-                                musb_context.index_regs[i].txfifosz);
+                                musb->context.index_regs[i].txfifosz);
                         musb_write_rxfifosz(musb_base,
-                                musb_context.index_regs[i].rxfifosz);
+                                musb->context.index_regs[i].rxfifosz);
                         musb_write_txfifoadd(musb_base,
-                                musb_context.index_regs[i].txfifoadd);
+                                musb->context.index_regs[i].txfifoadd);
                         musb_write_rxfifoadd(musb_base,
-                                musb_context.index_regs[i].rxfifoadd);
+                                musb->context.index_regs[i].rxfifoadd);
                 }
 
                 if (is_host_enabled(musb)) {
                         musb_writeb(epio, MUSB_TXTYPE,
-                                musb_context.index_regs[i].txtype);
+                                musb->context.index_regs[i].txtype);
                         musb_writeb(epio, MUSB_TXINTERVAL,
-                                musb_context.index_regs[i].txinterval);
+                                musb->context.index_regs[i].txinterval);
                         musb_writeb(epio, MUSB_RXTYPE,
-                                musb_context.index_regs[i].rxtype);
+                                musb->context.index_regs[i].rxtype);
                         musb_writeb(epio, MUSB_RXINTERVAL,
 
-                        musb_context.index_regs[i].rxinterval);
+                        musb->context.index_regs[i].rxinterval);
                         musb_write_txfunaddr(musb_base, i,
-                                musb_context.index_regs[i].txfunaddr);
+                                musb->context.index_regs[i].txfunaddr);
                         musb_write_txhubaddr(musb_base, i,
-                                musb_context.index_regs[i].txhubaddr);
+                                musb->context.index_regs[i].txhubaddr);
                         musb_write_txhubport(musb_base, i,
-                                musb_context.index_regs[i].txhubport);
+                                musb->context.index_regs[i].txhubport);
 
                         ep_target_regs =
                                 musb_read_target_reg_base(i, musb_base);
 
                         musb_write_rxfunaddr(ep_target_regs,
-                                musb_context.index_regs[i].rxfunaddr);
+                                musb->context.index_regs[i].rxfunaddr);
                         musb_write_rxhubaddr(ep_target_regs,
-                                musb_context.index_regs[i].rxhubaddr);
+                                musb->context.index_regs[i].rxhubaddr);
                         musb_write_rxhubport(ep_target_regs,
-                                musb_context.index_regs[i].rxhubport);
+                                musb->context.index_regs[i].rxhubport);
                 }
         }
 }
@@ -2427,12 +2391,6 @@ static int musb_suspend(struct device *dev)
 
         musb_save_context(musb);
 
-        if (musb->clock) {
-                if (musb->set_clock)
-                        musb->set_clock(musb->clock, 0);
-                else
-                        clk_disable(musb->clock);
-        }
         spin_unlock_irqrestore(&musb->lock, flags);
         return 0;
 }
@@ -2442,13 +2400,6 @@ static int musb_resume_noirq(struct device *dev)
         struct platform_device *pdev = to_platform_device(dev);
         struct musb     *musb = dev_to_musb(&pdev->dev);
 
-        if (musb->clock) {
-                if (musb->set_clock)
-                        musb->set_clock(musb->clock, 1);
-                else
-                        clk_enable(musb->clock);
-        }
-
         musb_restore_context(musb);
 
         /* for static cmos like DaVinci, register values were preserved
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index febaabcc2b35..d0c236f8e191 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -222,7 +222,7 @@ enum musb_g_ep0_state {
 #endif
 
 /* TUSB mapping: "flat" plus ep0 special cases */
-#if     defined(CONFIG_USB_TUSB6010)
+#if     defined(CONFIG_USB_MUSB_TUSB6010)
 #define musb_ep_select(_mbase, _epnum) \
         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 #define MUSB_EP_OFFSET                  MUSB_TUSB_OFFSET
@@ -253,6 +253,29 @@ enum musb_g_ep0_state {
 
 /******************************** TYPES *************************************/
 
+/**
+ * struct musb_platform_ops - Operations passed to musb_core by HW glue layer
+ * @init:       turns on clocks, sets up platform-specific registers, etc
+ * @exit:       undoes @init
+ * @set_mode:   forcefully changes operating mode
+ * @try_ilde:   tries to idle the IP
+ * @vbus_status: returns vbus status if possible
+ * @set_vbus:   forces vbus status
+ */
+struct musb_platform_ops {
+        int     (*init)(struct musb *musb);
+        int     (*exit)(struct musb *musb);
+
+        void    (*enable)(struct musb *musb);
+        void    (*disable)(struct musb *musb);
+
+        int     (*set_mode)(struct musb *musb, u8 mode);
+        void    (*try_idle)(struct musb *musb, unsigned long timeout);
+
+        int     (*vbus_status)(struct musb *musb);
+        void    (*set_vbus)(struct musb *musb, int on);
+};
+
 /*
  * struct musb_hw_ep - endpoint hardware (bidirectional)
  *
@@ -263,7 +286,7 @@ struct musb_hw_ep {
         void __iomem            *fifo;
         void __iomem            *regs;
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
         void __iomem            *conf;
 #endif
 
@@ -280,7 +303,7 @@ struct musb_hw_ep {
         struct dma_channel      *tx_channel;
         struct dma_channel      *rx_channel;
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
         /* TUSB has "asynchronous" and "synchronous" dma modes */
         dma_addr_t              fifo_async;
         dma_addr_t              fifo_sync;
@@ -323,14 +346,43 @@ static inline struct usb_request *next_out_request(struct musb_hw_ep *hw_ep)
 #endif
 }
 
+struct musb_csr_regs {
+        /* FIFO registers */
+        u16 txmaxp, txcsr, rxmaxp, rxcsr;
+        u16 rxfifoadd, txfifoadd;
+        u8 txtype, txinterval, rxtype, rxinterval;
+        u8 rxfifosz, txfifosz;
+        u8 txfunaddr, txhubaddr, txhubport;
+        u8 rxfunaddr, rxhubaddr, rxhubport;
+};
+
+struct musb_context_registers {
+
+#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
+    defined(CONFIG_ARCH_OMAP4)
+        u32 otg_sysconfig, otg_forcestandby;
+#endif
+        u8 power;
+        u16 intrtxe, intrrxe;
+        u8 intrusbe;
+        u16 frame;
+        u8 index, testmode;
+
+        u8 devctl, busctl, misc;
+
+        struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
+};
+
 /*
  * struct musb - Driver instance data.
  */
 struct musb {
         /* device lock */
         spinlock_t              lock;
-        struct clk              *clock;
-        struct clk              *phy_clock;
+
+        const struct musb_platform_ops *ops;
+        struct musb_context_registers context;
+
         irqreturn_t             (*isr)(int, void *);
         struct work_struct      irq_work;
         u16                     hwvers;
@@ -359,11 +411,7 @@ struct musb {
 
         struct timer_list       otg_timer;
 #endif
-
-        /* called with IRQs blocked; ON/nonzero implies starting a session,
-         * and waiting at least a_wait_vrise_tmout.
-         */
-        void                    (*board_set_vbus)(struct musb *, int is_on);
+        struct notifier_block   nb;
 
         struct dma_controller   *dma_controller;
 
@@ -371,7 +419,7 @@ struct musb {
         void __iomem            *ctrl_base;
         void __iomem            *mregs;
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
@@ -398,8 +446,6 @@ struct musb {
         u8 board_mode;          /* enum musb_mode */
         int                     (*board_set_power)(int state);
 
-        int                     (*set_clock)(struct clk *clk, int is_active);
-
         u8                      min_power;      /* vbus for periph, in mA/2 */
 
         bool                    is_host;
@@ -458,52 +504,6 @@ struct musb {
 #endif
 };
 
-#ifdef CONFIG_PM
-struct musb_csr_regs {
-        /* FIFO registers */
-        u16 txmaxp, txcsr, rxmaxp, rxcsr;
-        u16 rxfifoadd, txfifoadd;
-        u8 txtype, txinterval, rxtype, rxinterval;
-        u8 rxfifosz, txfifosz;
-        u8 txfunaddr, txhubaddr, txhubport;
-        u8 rxfunaddr, rxhubaddr, rxhubport;
-};
-
-struct musb_context_registers {
-
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-    defined(CONFIG_ARCH_OMAP4)
-        u32 otg_sysconfig, otg_forcestandby;
-#endif
-        u8 power;
-        u16 intrtxe, intrrxe;
-        u8 intrusbe;
-        u16 frame;
-        u8 index, testmode;
-
-        u8 devctl, busctl, misc;
-
-        struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
-};
-
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-    defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_BLACKFIN)
-extern void musb_platform_save_context(struct musb *musb,
-                struct musb_context_registers *musb_context);
-extern void musb_platform_restore_context(struct musb *musb,
-                struct musb_context_registers *musb_context);
-#else
-#define musb_platform_save_context(m, x)        do {} while (0)
-#define musb_platform_restore_context(m, x)     do {} while (0)
-#endif
-
-#endif
-
-static inline void musb_set_vbus(struct musb *musb, int is_on)
-{
-        musb->board_set_vbus(musb, is_on);
-}
-
 #ifdef CONFIG_USB_GADGET_MUSB_HDRC
 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 {
@@ -592,29 +592,63 @@ extern void musb_load_testpacket(struct musb *);
 
 extern irqreturn_t musb_interrupt(struct musb *);
 
-extern void musb_platform_enable(struct musb *musb);
-extern void musb_platform_disable(struct musb *musb);
-
 extern void musb_hnp_stop(struct musb *musb);
 
-extern int musb_platform_set_mode(struct musb *musb, u8 musb_mode);
+static inline void musb_platform_set_vbus(struct musb *musb, int is_on)
+{
+        if (musb->ops->set_vbus)
+                musb->ops->set_vbus(musb, is_on);
+}
 
-#if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN) || \
-        defined(CONFIG_ARCH_DAVINCI_DA8XX) || \
-        defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) || \
-        defined(CONFIG_ARCH_OMAP4)
-extern void musb_platform_try_idle(struct musb *musb, unsigned long timeout);
-#else
-#define musb_platform_try_idle(x, y)            do {} while (0)
-#endif
+static inline void musb_platform_enable(struct musb *musb)
+{
+        if (musb->ops->enable)
+                musb->ops->enable(musb);
+}
 
-#if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN)
-extern int musb_platform_get_vbus_status(struct musb *musb);
-#else
-#define musb_platform_get_vbus_status(x)        0
-#endif
+static inline void musb_platform_disable(struct musb *musb)
+{
+        if (musb->ops->disable)
+                musb->ops->disable(musb);
+}
+
+static inline int musb_platform_set_mode(struct musb *musb, u8 mode)
+{
+        if (!musb->ops->set_mode)
+                return 0;
+
+        return musb->ops->set_mode(musb, mode);
+}
+
+static inline void musb_platform_try_idle(struct musb *musb,
+                unsigned long timeout)
+{
+        if (musb->ops->try_idle)
+                musb->ops->try_idle(musb, timeout);
+}
+
+static inline int musb_platform_get_vbus_status(struct musb *musb)
+{
+        if (!musb->ops->vbus_status)
+                return 0;
 
-extern int __init musb_platform_init(struct musb *musb, void *board_data);
-extern int musb_platform_exit(struct musb *musb);
+        return musb->ops->vbus_status(musb);
+}
+
+static inline int musb_platform_init(struct musb *musb)
+{
+        if (!musb->ops->init)
+                return -EINVAL;
+
+        return musb->ops->init(musb);
+}
+
+static inline int musb_platform_exit(struct musb *musb)
+{
+        if (!musb->ops->exit)
+                return -EINVAL;
+
+        return musb->ops->exit(musb);
+}
 
 #endif  /* __MUSB_CORE_H__ */
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 9d6ade82b9f2..9b162dfaa4fb 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1136,13 +1136,16 @@ struct usb_request *musb_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
         struct musb_request     *request = NULL;
 
         request = kzalloc(sizeof *request, gfp_flags);
-        if (request) {
-                INIT_LIST_HEAD(&request->request.list);
-                request->request.dma = DMA_ADDR_INVALID;
-                request->epnum = musb_ep->current_epnum;
-                request->ep = musb_ep;
+        if (!request) {
+                DBG(4, "not enough memory\n");
+                return NULL;
         }
 
+        INIT_LIST_HEAD(&request->request.list);
+        request->request.dma = DMA_ADDR_INVALID;
+        request->epnum = musb_ep->current_epnum;
+        request->ep = musb_ep;
+
         return &request->request;
 }
 
diff --git a/drivers/usb/musb/musb_io.h b/drivers/usb/musb/musb_io.h
index b06e9ef00cfc..03c6ccdbb3be 100644
--- a/drivers/usb/musb/musb_io.h
+++ b/drivers/usb/musb/musb_io.h
@@ -74,7 +74,7 @@ static inline void musb_writel(void __iomem *addr, unsigned offset, u32 data)
         { __raw_writel(data, addr + offset); }
 
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
 
 /*
  * TUSB6010 doesn't allow 8-bit access; 16-bit access is the minimum.
@@ -114,7 +114,7 @@ static inline u8 musb_readb(const void __iomem *addr, unsigned offset)
 static inline void musb_writeb(void __iomem *addr, unsigned offset, u8 data)
         { __raw_writeb(data, addr + offset); }
 
-#endif  /* CONFIG_USB_TUSB6010 */
+#endif  /* CONFIG_USB_MUSB_TUSB6010 */
 
 #else
 
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 5a727c5b8676..82410703dcd3 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -234,7 +234,7 @@
 #define MUSB_TESTMODE           0x0F    /* 8 bit */
 
 /* Get offset for a given FIFO from musb->mregs */
-#ifdef  CONFIG_USB_TUSB6010
+#ifdef  CONFIG_USB_MUSB_TUSB6010
 #define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
 #else
 #define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
@@ -295,7 +295,7 @@
 #define MUSB_FLAT_OFFSET(_epnum, _offset)       \
         (0x100 + (0x10*(_epnum)) + (_offset))
 
-#ifdef CONFIG_USB_TUSB6010
+#ifdef CONFIG_USB_MUSB_TUSB6010
 /* TUSB6010 EP0 configuration register is special */
 #define MUSB_TUSB_OFFSET(_epnum, _offset)       \
         (0x10 + _offset)
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 43233c397b6e..b46d1877e28e 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -276,7 +276,7 @@ int musb_hub_control(
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
-                                musb_set_vbus(musb, 0);
+                                musb_platform_set_vbus(musb, 0);
                         break;
                 case USB_PORT_FEAT_C_CONNECTION:
                 case USB_PORT_FEAT_C_ENABLE:
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index 563114d613d6..0144a2d481fd 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -377,7 +377,7 @@ dma_controller_create(struct musb *musb, void __iomem *base)
         struct musb_dma_controller *controller;
         struct device *dev = musb->controller;
         struct platform_device *pdev = to_platform_device(dev);
-        int irq = platform_get_irq(pdev, 1);
+        int irq = platform_get_irq_byname(pdev, "dma");
 
         if (irq == 0) {
                 dev_err(dev, "No DMA interrupt line!\n");
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index ed618bde1eec..a3f12333fc41 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -31,10 +31,18 @@
 #include <linux/list.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include "musb_core.h"
 #include "omap2430.h"
 
+struct omap2430_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+#define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
 static struct timer_list musb_idle_timer;
 
@@ -49,12 +57,8 @@ static void musb_do_idle(unsigned long _musb)
 
         spin_lock_irqsave(&musb->lock, flags);
 
-        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
-
         switch (musb->xceiv->state) {
         case OTG_STATE_A_WAIT_BCON:
-                devctl &= ~MUSB_DEVCTL_SESSION;
-                musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
                 if (devctl & MUSB_DEVCTL_BDEVICE) {
@@ -98,7 +102,7 @@ static void musb_do_idle(unsigned long _musb)
 }
 
 
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         unsigned long           default_timeout = jiffies + msecs_to_jiffies(3);
         static unsigned long    last_timer;
@@ -131,15 +135,11 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
         mod_timer(&musb_idle_timer, timeout);
 }
 
-void musb_platform_enable(struct musb *musb)
-{
-}
-void musb_platform_disable(struct musb *musb)
-{
-}
-static void omap_set_vbus(struct musb *musb, int is_on)
+static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 {
         u8              devctl;
+        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
+        int ret = 1;
         /* HDRC controls CPEN, but beware current surges during device
          * connect.  They can trigger transient overcurrent conditions
          * that must be ignored.
@@ -148,12 +148,35 @@ static void omap_set_vbus(struct musb *musb, int is_on)
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
         if (is_on) {
-                musb->is_active = 1;
-                musb->xceiv->default_a = 1;
-                musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
-                devctl |= MUSB_DEVCTL_SESSION;
-
-                MUSB_HST_MODE(musb);
+                if (musb->xceiv->state == OTG_STATE_A_IDLE) {
+                        /* start the session */
+                        devctl |= MUSB_DEVCTL_SESSION;
+                        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
+                        /*
+                         * Wait for the musb to set as A device to enable the
+                         * VBUS
+                         */
+                        while (musb_readb(musb->mregs, MUSB_DEVCTL) & 0x80) {
+
+                                cpu_relax();
+
+                                if (time_after(jiffies, timeout)) {
+                                        dev_err(musb->controller,
+                                        "configured as A device timeout");
+                                        ret = -EINVAL;
+                                        break;
+                                }
+                        }
+
+                        if (ret && musb->xceiv->set_vbus)
+                                otg_set_vbus(musb->xceiv, 1);
+                } else {
+                        musb->is_active = 1;
+                        musb->xceiv->default_a = 1;
+                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+                        devctl |= MUSB_DEVCTL_SESSION;
+                        MUSB_HST_MODE(musb);
+                }
         } else {
                 musb->is_active = 0;
 
@@ -175,9 +198,7 @@ static void omap_set_vbus(struct musb *musb, int is_on)
                 musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
-static int musb_platform_resume(struct musb *musb);
-
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int omap2430_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         u8      devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
@@ -187,10 +208,94 @@ int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
         return 0;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static inline void omap2430_low_level_exit(struct musb *musb)
 {
         u32 l;
-        struct omap_musb_board_data *data = board_data;
+
+        /* in any role */
+        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
+        l |= ENABLEFORCE;       /* enable MSTANDBY */
+        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+
+        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
+        l |= ENABLEWAKEUP;      /* enable wakeup */
+        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+}
+
+static inline void omap2430_low_level_init(struct musb *musb)
+{
+        u32 l;
+
+        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
+        l &= ~ENABLEWAKEUP;     /* disable wakeup */
+        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+
+        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
+        l &= ~ENABLEFORCE;      /* disable MSTANDBY */
+        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+}
+
+/* blocking notifier support */
+static int musb_otg_notifications(struct notifier_block *nb,
+                unsigned long event, void *unused)
+{
+        struct musb     *musb = container_of(nb, struct musb, nb);
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *pdata = dev->platform_data;
+        struct omap_musb_board_data *data = pdata->board_data;
+
+        switch (event) {
+        case USB_EVENT_ID:
+                DBG(4, "ID GND\n");
+
+                if (is_otg_enabled(musb)) {
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+                        if (musb->gadget_driver) {
+                                otg_init(musb->xceiv);
+
+                                if (data->interface_type ==
+                                                MUSB_INTERFACE_UTMI)
+                                        omap2430_musb_set_vbus(musb, 1);
+
+                        }
+#endif
+                } else {
+                        otg_init(musb->xceiv);
+                        if (data->interface_type ==
+                                        MUSB_INTERFACE_UTMI)
+                                omap2430_musb_set_vbus(musb, 1);
+                }
+                break;
+
+        case USB_EVENT_VBUS:
+                DBG(4, "VBUS Connect\n");
+
+                otg_init(musb->xceiv);
+                break;
+
+        case USB_EVENT_NONE:
+                DBG(4, "VBUS Disconnect\n");
+
+                if (data->interface_type == MUSB_INTERFACE_UTMI) {
+                        if (musb->xceiv->set_vbus)
+                                otg_set_vbus(musb->xceiv, 0);
+                }
+                otg_shutdown(musb->xceiv);
+                break;
+        default:
+                DBG(4, "ID float\n");
+                return NOTIFY_DONE;
+        }
+
+        return NOTIFY_OK;
+}
+
+static int omap2430_musb_init(struct musb *musb)
+{
+        u32 l, status = 0;
+        struct device *dev = musb->controller;
+        struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct omap_musb_board_data *data = plat->board_data;
 
         /* We require some kind of external transceiver, hooked
          * up through ULPI.  TWL4030-family PMICs include one,
@@ -202,7 +307,7 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                 return -ENODEV;
         }
 
-        musb_platform_resume(musb);
+        omap2430_low_level_init(musb);
 
         l = musb_readl(musb->mregs, OTG_SYSCONFIG);
         l &= ~ENABLEWAKEUP;     /* disable wakeup */
@@ -239,87 +344,214 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
                         musb_readl(musb->mregs, OTG_INTERFSEL),
                         musb_readl(musb->mregs, OTG_SIMENABLE));
 
-        if (is_host_enabled(musb))
-                musb->board_set_vbus = omap_set_vbus;
+        musb->nb.notifier_call = musb_otg_notifications;
+        status = otg_register_notifier(musb->xceiv, &musb->nb);
+
+        if (status)
+                DBG(1, "notification register failed\n");
+
+        /* check whether cable is already connected */
+        if (musb->xceiv->state ==OTG_STATE_B_IDLE)
+                musb_otg_notifications(&musb->nb, 1,
+                                        musb->xceiv->gadget);
 
         setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb);
 
         return 0;
 }
 
-#ifdef CONFIG_PM
-void musb_platform_save_context(struct musb *musb,
-                struct musb_context_registers *musb_context)
+static int omap2430_musb_exit(struct musb *musb)
 {
-        musb_context->otg_sysconfig = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        musb_context->otg_forcestandby = musb_readl(musb->mregs, OTG_FORCESTDBY);
-}
 
-void musb_platform_restore_context(struct musb *musb,
-                struct musb_context_registers *musb_context)
-{
-        musb_writel(musb->mregs, OTG_SYSCONFIG, musb_context->otg_sysconfig);
-        musb_writel(musb->mregs, OTG_FORCESTDBY, musb_context->otg_forcestandby);
+        omap2430_low_level_exit(musb);
+        otg_put_transceiver(musb->xceiv);
+
+        return 0;
 }
-#endif
 
-static int musb_platform_suspend(struct musb *musb)
+static const struct musb_platform_ops omap2430_ops = {
+        .init           = omap2430_musb_init,
+        .exit           = omap2430_musb_exit,
+
+        .set_mode       = omap2430_musb_set_mode,
+        .try_idle       = omap2430_musb_try_idle,
+
+        .set_vbus       = omap2430_musb_set_vbus,
+};
+
+static u64 omap2430_dmamask = DMA_BIT_MASK(32);
+
+static int __init omap2430_probe(struct platform_device *pdev)
 {
-        u32 l;
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct omap2430_glue            *glue;
+        struct clk                      *clk;
 
-        if (!musb->clock)
-                return 0;
+        int                             ret = -ENOMEM;
 
-        /* in any role */
-        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
-        l |= ENABLEFORCE;       /* enable MSTANDBY */
-        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
 
-        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        l |= ENABLEWAKEUP;      /* enable wakeup */
-        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
 
-        otg_set_suspend(musb->xceiv, 1);
+        clk = clk_get(&pdev->dev, "ick");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
 
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 0);
-        else
-                clk_disable(musb->clock);
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &omap2430_dmamask;
+        musb->dev.coherent_dma_mask     = omap2430_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &omap2430_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
 
         return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
 }
 
-static int musb_platform_resume(struct musb *musb)
+static int __exit omap2430_remove(struct platform_device *pdev)
 {
-        u32 l;
+        struct omap2430_glue            *glue = platform_get_drvdata(pdev);
 
-        if (!musb->clock)
-                return 0;
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
 
-        otg_set_suspend(musb->xceiv, 0);
+        return 0;
+}
 
-        if (musb->set_clock)
-                musb->set_clock(musb->clock, 1);
-        else
-                clk_enable(musb->clock);
+#ifdef CONFIG_PM
+static void omap2430_save_context(struct musb *musb)
+{
+        musb->context.otg_sysconfig = musb_readl(musb->mregs, OTG_SYSCONFIG);
+        musb->context.otg_forcestandby = musb_readl(musb->mregs, OTG_FORCESTDBY);
+}
 
-        l = musb_readl(musb->mregs, OTG_SYSCONFIG);
-        l &= ~ENABLEWAKEUP;     /* disable wakeup */
-        musb_writel(musb->mregs, OTG_SYSCONFIG, l);
+static void omap2430_restore_context(struct musb *musb)
+{
+        musb_writel(musb->mregs, OTG_SYSCONFIG, musb->context.otg_sysconfig);
+        musb_writel(musb->mregs, OTG_FORCESTDBY, musb->context.otg_forcestandby);
+}
 
-        l = musb_readl(musb->mregs, OTG_FORCESTDBY);
-        l &= ~ENABLEFORCE;      /* disable MSTANDBY */
-        musb_writel(musb->mregs, OTG_FORCESTDBY, l);
+static int omap2430_suspend(struct device *dev)
+{
+        struct omap2430_glue            *glue = dev_get_drvdata(dev);
+        struct musb                     *musb = glue_to_musb(glue);
+
+        omap2430_low_level_exit(musb);
+        otg_set_suspend(musb->xceiv, 1);
+        omap2430_save_context(musb);
+        clk_disable(glue->clk);
 
         return 0;
 }
 
-
-int musb_platform_exit(struct musb *musb)
+static int omap2430_resume(struct device *dev)
 {
+        struct omap2430_glue            *glue = dev_get_drvdata(dev);
+        struct musb                     *musb = glue_to_musb(glue);
+        int                             ret;
+
+        ret = clk_enable(glue->clk);
+        if (ret) {
+                dev_err(dev, "faled to enable clock\n");
+                return ret;
+        }
 
-        musb_platform_suspend(musb);
+        omap2430_low_level_init(musb);
+        omap2430_restore_context(musb);
+        otg_set_suspend(musb->xceiv, 0);
 
-        otg_put_transceiver(musb->xceiv);
         return 0;
 }
+
+static struct dev_pm_ops omap2430_pm_ops = {
+        .suspend        = omap2430_suspend,
+        .resume         = omap2430_resume,
+};
+
+#define DEV_PM_OPS      (&omap2430_pm_ops)
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver omap2430_driver = {
+        .remove         = __exit_p(omap2430_remove),
+        .driver         = {
+                .name   = "musb-omap2430",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init omap2430_init(void)
+{
+        return platform_driver_probe(&omap2430_driver, omap2430_probe);
+}
+subsys_initcall(omap2430_init);
+
+static void __exit omap2430_exit(void)
+{
+        platform_driver_unregister(&omap2430_driver);
+}
+module_exit(omap2430_exit);
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index bde40efc7046..2ba3b070ed0b 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -21,10 +21,16 @@
 #include <linux/usb.h>
 #include <linux/irq.h>
 #include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 
 #include "musb_core.h"
 
-static void tusb_source_power(struct musb *musb, int is_on);
+struct tusb6010_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+};
+
+static void tusb_musb_set_vbus(struct musb *musb, int is_on);
 
 #define TUSB_REV_MAJOR(reg_val)         ((reg_val >> 4) & 0xf)
 #define TUSB_REV_MINOR(reg_val)         (reg_val & 0xf)
@@ -50,7 +56,7 @@ u8 tusb_get_revision(struct musb *musb)
         return rev;
 }
 
-static int __init tusb_print_revision(struct musb *musb)
+static int tusb_print_revision(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u8              rev;
@@ -275,17 +281,6 @@ static int tusb_draw_power(struct otg_transceiver *x, unsigned mA)
         void __iomem    *tbase = musb->ctrl_base;
         u32             reg;
 
-        /*
-         * Keep clock active when enabled. Note that this is not tied to
-         * drawing VBUS, as with OTG mA can be less than musb->min_power.
-         */
-        if (musb->set_clock) {
-                if (mA)
-                        musb->set_clock(musb->clock, 1);
-                else
-                        musb->set_clock(musb->clock, 0);
-        }
-
         /* tps65030 seems to consume max 100mA, with maybe 60mA available
          * (measured on one board) for things other than tps and tusb.
          *
@@ -348,7 +343,7 @@ static void tusb_set_clock_source(struct musb *musb, unsigned mode)
  * USB link is not suspended ... and tells us the relevant wakeup
  * events.  SW_EN for voltage is handled separately.
  */
-void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
+static void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             reg;
@@ -385,7 +380,7 @@ void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
 /*
  * Updates cable VBUS status. Caller must take care of locking.
  */
-int musb_platform_get_vbus_status(struct musb *musb)
+static int tusb_musb_vbus_status(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             otg_stat, prcm_mngmt;
@@ -431,7 +426,7 @@ static void musb_do_idle(unsigned long _musb)
                 }
                 /* FALLTHROUGH */
         case OTG_STATE_A_IDLE:
-                tusb_source_power(musb, 0);
+                tusb_musb_set_vbus(musb, 0);
         default:
                 break;
         }
@@ -475,7 +470,7 @@ done:
  * we don't want to treat that full speed J as a wakeup event.
  * ... peripherals must draw only suspend current after 10 msec.
  */
-void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         unsigned long           default_timeout = jiffies + msecs_to_jiffies(3);
         static unsigned long    last_timer;
@@ -515,7 +510,7 @@ void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
                                 | TUSB_DEV_OTG_TIMER_ENABLE) \
                 : 0)
 
-static void tusb_source_power(struct musb *musb, int is_on)
+static void tusb_musb_set_vbus(struct musb *musb, int is_on)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             conf, prcm, timer;
@@ -531,8 +526,6 @@ static void tusb_source_power(struct musb *musb, int is_on)
         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
         if (is_on) {
-                if (musb->set_clock)
-                        musb->set_clock(musb->clock, 1);
                 timer = OTG_TIMER_MS(OTG_TIME_A_WAIT_VRISE);
                 musb->xceiv->default_a = 1;
                 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -571,8 +564,6 @@ static void tusb_source_power(struct musb *musb, int is_on)
 
                 devctl &= ~MUSB_DEVCTL_SESSION;
                 conf &= ~TUSB_DEV_CONF_USB_HOST_MODE;
-                if (musb->set_clock)
-                        musb->set_clock(musb->clock, 0);
         }
         prcm &= ~(TUSB_PRCM_MNGMT_15_SW_EN | TUSB_PRCM_MNGMT_33_SW_EN);
 
@@ -599,7 +590,7 @@ static void tusb_source_power(struct musb *musb, int is_on)
  * and peripheral modes in non-OTG configurations by reconfiguring hardware
  * and then setting musb->board_mode. For now, only support OTG mode.
  */
-int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             otg_stat, phy_otg_ctrl, phy_otg_ena, dev_conf;
@@ -677,7 +668,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         default_a = is_host_enabled(musb);
                 DBG(2, "Default-%c\n", default_a ? 'A' : 'B');
                 musb->xceiv->default_a = default_a;
-                tusb_source_power(musb, default_a);
+                tusb_musb_set_vbus(musb, default_a);
 
                 /* Don't allow idling immediately */
                 if (default_a)
@@ -722,7 +713,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         switch (musb->xceiv->state) {
                         case OTG_STATE_A_IDLE:
                                 DBG(2, "Got SRP, turning on VBUS\n");
-                                musb_set_vbus(musb, 1);
+                                musb_platform_set_vbus(musb, 1);
 
                                 /* CONNECT can wake if a_wait_bcon is set */
                                 if (musb->a_wait_bcon != 0)
@@ -748,11 +739,11 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                                  */
                                 if (musb->vbuserr_retry) {
                                         musb->vbuserr_retry--;
-                                        tusb_source_power(musb, 1);
+                                        tusb_musb_set_vbus(musb, 1);
                                 } else {
                                         musb->vbuserr_retry
                                                 = VBUSERR_RETRY_COUNT;
-                                        tusb_source_power(musb, 0);
+                                        tusb_musb_set_vbus(musb, 0);
                                 }
                                 break;
                         default:
@@ -786,7 +777,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
                         } else {
                                 /* REVISIT report overcurrent to hub? */
                                 ERR("vbus too slow, devctl %02x\n", devctl);
-                                tusb_source_power(musb, 0);
+                                tusb_musb_set_vbus(musb, 0);
                         }
                         break;
                 case OTG_STATE_A_WAIT_BCON:
@@ -807,7 +798,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
         return idle_timeout;
 }
 
-static irqreturn_t tusb_interrupt(int irq, void *__hci)
+static irqreturn_t tusb_musb_interrupt(int irq, void *__hci)
 {
         struct musb     *musb = __hci;
         void __iomem    *tbase = musb->ctrl_base;
@@ -911,7 +902,7 @@ static irqreturn_t tusb_interrupt(int irq, void *__hci)
         musb_writel(tbase, TUSB_INT_SRC_CLEAR,
                 int_src & ~TUSB_INT_MASK_RESERVED_BITS);
 
-        musb_platform_try_idle(musb, idle_timeout);
+        tusb_musb_try_idle(musb, idle_timeout);
 
         musb_writel(tbase, TUSB_INT_MASK, int_mask);
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -926,7 +917,7 @@ static int dma_off;
  * REVISIT:
  * - Check what is unnecessary in MGC_HdrcStart()
  */
-void musb_platform_enable(struct musb *musb)
+static void tusb_musb_enable(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
 
@@ -970,7 +961,7 @@ void musb_platform_enable(struct musb *musb)
 /*
  * Disables TUSB6010. Caller must take care of locking.
  */
-void musb_platform_disable(struct musb *musb)
+static void tusb_musb_disable(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
 
@@ -995,7 +986,7 @@ void musb_platform_disable(struct musb *musb)
  * Sets up TUSB6010 CPU interface specific signals and registers
  * Note: Settings optimized for OMAP24xx
  */
-static void __init tusb_setup_cpu_interface(struct musb *musb)
+static void tusb_setup_cpu_interface(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
 
@@ -1022,7 +1013,7 @@ static void __init tusb_setup_cpu_interface(struct musb *musb)
         musb_writel(tbase, TUSB_WAIT_COUNT, 1);
 }
 
-static int __init tusb_start(struct musb *musb)
+static int tusb_musb_start(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         int             ret = 0;
@@ -1091,7 +1082,7 @@ err:
         return -ENODEV;
 }
 
-int __init musb_platform_init(struct musb *musb, void *board_data)
+static int tusb_musb_init(struct musb *musb)
 {
         struct platform_device  *pdev;
         struct resource         *mem;
@@ -1131,16 +1122,14 @@ int __init musb_platform_init(struct musb *musb, void *board_data)
          */
         musb->mregs += TUSB_BASE_OFFSET;
 
-        ret = tusb_start(musb);
+        ret = tusb_musb_start(musb);
         if (ret) {
                 printk(KERN_ERR "Could not start tusb6010 (%d)\n",
                                 ret);
                 goto done;
         }
-        musb->isr = tusb_interrupt;
+        musb->isr = tusb_musb_interrupt;
 
-        if (is_host_enabled(musb))
-                musb->board_set_vbus = tusb_source_power;
         if (is_peripheral_enabled(musb)) {
                 musb->xceiv->set_power = tusb_draw_power;
                 the_musb = musb;
@@ -1159,7 +1148,7 @@ done:
         return ret;
 }
 
-int musb_platform_exit(struct musb *musb)
+static int tusb_musb_exit(struct musb *musb)
 {
         del_timer_sync(&musb_idle_timer);
         the_musb = NULL;
@@ -1173,3 +1162,115 @@ int musb_platform_exit(struct musb *musb)
         usb_nop_xceiv_unregister();
         return 0;
 }
+
+static const struct musb_platform_ops tusb_ops = {
+        .init           = tusb_musb_init,
+        .exit           = tusb_musb_exit,
+
+        .enable         = tusb_musb_enable,
+        .disable        = tusb_musb_disable,
+
+        .set_mode       = tusb_musb_set_mode,
+        .try_idle       = tusb_musb_try_idle,
+
+        .vbus_status    = tusb_musb_vbus_status,
+        .set_vbus       = tusb_musb_set_vbus,
+};
+
+static u64 tusb_dmamask = DMA_BIT_MASK(32);
+
+static int __init tusb_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct tusb6010_glue            *glue;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+        musb->dev.dma_mask              = &tusb_dmamask;
+        musb->dev.coherent_dma_mask     = tusb_dmamask;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+
+        pdata->platform_ops             = &tusb_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err2;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err2;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err1;
+        }
+
+        return 0;
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit tusb_remove(struct platform_device *pdev)
+{
+        struct tusb6010_glue            *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        kfree(glue);
+
+        return 0;
+}
+
+static struct platform_driver tusb_driver = {
+        .remove         = __exit_p(tusb_remove),
+        .driver         = {
+                .name   = "musb-tusb",
+        },
+};
+
+MODULE_DESCRIPTION("TUSB6010 MUSB Glue Layer");
+MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init tusb_init(void)
+{
+        return platform_driver_probe(&tusb_driver, tusb_probe);
+}
+subsys_initcall(tusb_init);
+
+static void __exit tusb_exit(void)
+{
+        platform_driver_unregister(&tusb_driver);
+}
+module_exit(tusb_exit);
diff --git a/drivers/usb/musb/ux500.c b/drivers/usb/musb/ux500.c
new file mode 100644
index 000000000000..d6384e4aeef9
--- /dev/null
+++ b/drivers/usb/musb/ux500.c
@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2010 ST-Ericsson AB
+ * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
+ *
+ * Based on omap2430.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+
+#include "musb_core.h"
+
+struct ux500_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+#define glue_to_musb(g) platform_get_drvdata(g->musb)
+
+static int ux500_musb_init(struct musb *musb)
+{
+        musb->xceiv = otg_get_transceiver();
+        if (!musb->xceiv) {
+                pr_err("HS USB OTG: no transceiver configured\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int ux500_musb_exit(struct musb *musb)
+{
+        otg_put_transceiver(musb->xceiv);
+
+        return 0;
+}
+
+static const struct musb_platform_ops ux500_ops = {
+        .init           = ux500_musb_init,
+        .exit           = ux500_musb_exit,
+};
+
+static int __init ux500_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct platform_device          *musb;
+        struct ux500_glue               *glue;
+        struct clk                      *clk;
+
+        int                             ret = -ENOMEM;
+
+        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
+        if (!glue) {
+                dev_err(&pdev->dev, "failed to allocate glue context\n");
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", -1);
+        if (!musb) {
+                dev_err(&pdev->dev, "failed to allocate musb device\n");
+                goto err1;
+        }
+
+        clk = clk_get(&pdev->dev, "usb");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err2;
+        }
+
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to enable clock\n");
+                goto err3;
+        }
+
+        musb->dev.parent                = &pdev->dev;
+
+        glue->dev                       = &pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        pdata->platform_ops             = &ux500_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                        pdev->num_resources);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add resources\n");
+                goto err4;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&pdev->dev, "failed to add platform_data\n");
+                goto err4;
+        }
+
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register musb device\n");
+                goto err4;
+        }
+
+        return 0;
+
+err4:
+        clk_disable(clk);
+
+err3:
+        clk_put(clk);
+
+err2:
+        platform_device_put(musb);
+
+err1:
+        kfree(glue);
+
+err0:
+        return ret;
+}
+
+static int __exit ux500_remove(struct platform_device *pdev)
+{
+        struct ux500_glue       *glue = platform_get_drvdata(pdev);
+
+        platform_device_del(glue->musb);
+        platform_device_put(glue->musb);
+        clk_disable(glue->clk);
+        clk_put(glue->clk);
+        kfree(glue);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ux500_suspend(struct device *dev)
+{
+        struct ux500_glue       *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+
+        otg_set_suspend(musb->xceiv, 1);
+        clk_disable(glue->clk);
+
+        return 0;
+}
+
+static int ux500_resume(struct device *dev)
+{
+        struct ux500_glue       *glue = dev_get_drvdata(dev);
+        struct musb             *musb = glue_to_musb(glue);
+        int                     ret;
+
+        ret = clk_enable(glue->clk);
+        if (ret) {
+                dev_err(dev, "failed to enable clock\n");
+                return ret;
+        }
+
+        otg_set_suspend(musb->xceiv, 0);
+
+        return 0;
+}
+
+static const struct dev_pm_ops ux500_pm_ops = {
+        .suspend        = ux500_suspend,
+        .resume         = ux500_resume,
+};
+
+#define DEV_PM_OPS      (&ux500_pm_ops)
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver ux500_driver = {
+        .remove         = __exit_p(ux500_remove),
+        .driver         = {
+                .name   = "musb-ux500",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+MODULE_DESCRIPTION("UX500 MUSB Glue Layer");
+MODULE_AUTHOR("Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>");
+MODULE_LICENSE("GPL v2");
+
+static int __init ux500_init(void)
+{
+        return platform_driver_probe(&ux500_driver, ux500_probe);
+}
+subsys_initcall(ux500_init);
+
+static void __exit ux500_exit(void)
+{
+        platform_driver_unregister(&ux500_driver);
+}
+module_exit(ux500_exit);
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index 5ce07528cd0c..9fb875d5f09c 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -59,6 +59,18 @@ config TWL4030_USB
           This transceiver supports high and full speed devices plus,
           in host mode, low speed.
 
+config TWL6030_USB
+        tristate "TWL6030 USB Transceiver Driver"
+        depends on TWL4030_CORE
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver on TWL6030
+          family chips. This TWL6030 transceiver has the VBUS and ID GND
+          and OTG SRP events capabilities. For all other transceiver functionality
+          UTMI PHY is embedded in OMAP4430. The internal PHY configurations APIs
+          are hooked to this driver through platform_data structure.
+          The definition of internal PHY APIs are in the mach-omap2 layer.
+
 config NOP_USB_XCEIV
         tristate "NOP USB Transceiver Driver"
         select USB_OTG_UTILS
@@ -81,4 +93,24 @@ config USB_LANGWELL_OTG
           To compile this driver as a module, choose M here: the
           module will be called langwell_otg.
 
+config USB_MSM_OTG_72K
+        tristate "OTG support for Qualcomm on-chip USB controller"
+        depends on (USB || USB_GADGET) && ARCH_MSM
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver on MSM chips. It
+          handles PHY initialization, clock management, and workarounds
+          required after resetting the hardware and power management.
+          This driver is required even for peripheral only or host only
+          mode configurations.
+
+config AB8500_USB
+        tristate "AB8500 USB Transceiver Driver"
+        depends on AB8500_CORE
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver in AB8500 chip.
+          This transceiver supports high and full speed devices plus,
+          in host mode, low speed.
+
 endif # USB || OTG
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile
index 66f1b83e4fa7..a520e715cfd6 100644
--- a/drivers/usb/otg/Makefile
+++ b/drivers/usb/otg/Makefile
@@ -12,6 +12,9 @@ obj-$(CONFIG_USB_OTG_UTILS)	+= otg.o
 obj-$(CONFIG_USB_GPIO_VBUS)     += gpio_vbus.o
 obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
 obj-$(CONFIG_TWL4030_USB)       += twl4030-usb.o
+obj-$(CONFIG_TWL6030_USB)       += twl6030-usb.o
 obj-$(CONFIG_USB_LANGWELL_OTG)  += langwell_otg.o
 obj-$(CONFIG_NOP_USB_XCEIV)     += nop-usb-xceiv.o
 obj-$(CONFIG_USB_ULPI)          += ulpi.o
+obj-$(CONFIG_USB_MSM_OTG_72K)   += msm72k_otg.o
+obj-$(CONFIG_AB8500_USB)        += ab8500-usb.o
diff --git a/drivers/usb/otg/ab8500-usb.c b/drivers/usb/otg/ab8500-usb.c
new file mode 100644
index 000000000000..d14736b3107b
--- /dev/null
+++ b/drivers/usb/otg/ab8500-usb.c
@@ -0,0 +1,585 @@
+/*
+ * drivers/usb/otg/ab8500_usb.c
+ *
+ * USB transceiver driver for AB8500 chip
+ *
+ * Copyright (C) 2010 ST-Ericsson AB
+ * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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/usb/otg.h>
+#include <linux/slab.h>
+#include <linux/notifier.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/mfd/abx500.h>
+#include <linux/mfd/ab8500.h>
+
+#define AB8500_MAIN_WD_CTRL_REG 0x01
+#define AB8500_USB_LINE_STAT_REG 0x80
+#define AB8500_USB_PHY_CTRL_REG 0x8A
+
+#define AB8500_BIT_OTG_STAT_ID (1 << 0)
+#define AB8500_BIT_PHY_CTRL_HOST_EN (1 << 0)
+#define AB8500_BIT_PHY_CTRL_DEVICE_EN (1 << 1)
+#define AB8500_BIT_WD_CTRL_ENABLE (1 << 0)
+#define AB8500_BIT_WD_CTRL_KICK (1 << 1)
+
+#define AB8500_V1x_LINK_STAT_WAIT (HZ/10)
+#define AB8500_WD_KICK_DELAY_US 100 /* usec */
+#define AB8500_WD_V11_DISABLE_DELAY_US 100 /* usec */
+#define AB8500_WD_V10_DISABLE_DELAY_MS 100 /* ms */
+
+/* Usb line status register */
+enum ab8500_usb_link_status {
+        USB_LINK_NOT_CONFIGURED = 0,
+        USB_LINK_STD_HOST_NC,
+        USB_LINK_STD_HOST_C_NS,
+        USB_LINK_STD_HOST_C_S,
+        USB_LINK_HOST_CHG_NM,
+        USB_LINK_HOST_CHG_HS,
+        USB_LINK_HOST_CHG_HS_CHIRP,
+        USB_LINK_DEDICATED_CHG,
+        USB_LINK_ACA_RID_A,
+        USB_LINK_ACA_RID_B,
+        USB_LINK_ACA_RID_C_NM,
+        USB_LINK_ACA_RID_C_HS,
+        USB_LINK_ACA_RID_C_HS_CHIRP,
+        USB_LINK_HM_IDGND,
+        USB_LINK_RESERVED,
+        USB_LINK_NOT_VALID_LINK
+};
+
+struct ab8500_usb {
+        struct otg_transceiver otg;
+        struct device *dev;
+        int irq_num_id_rise;
+        int irq_num_id_fall;
+        int irq_num_vbus_rise;
+        int irq_num_vbus_fall;
+        int irq_num_link_status;
+        unsigned vbus_draw;
+        struct delayed_work dwork;
+        struct work_struct phy_dis_work;
+        unsigned long link_status_wait;
+        int rev;
+};
+
+static inline struct ab8500_usb *xceiv_to_ab(struct otg_transceiver *x)
+{
+        return container_of(x, struct ab8500_usb, otg);
+}
+
+static void ab8500_usb_wd_workaround(struct ab8500_usb *ab)
+{
+        abx500_set_register_interruptible(ab->dev,
+                AB8500_SYS_CTRL2_BLOCK,
+                AB8500_MAIN_WD_CTRL_REG,
+                AB8500_BIT_WD_CTRL_ENABLE);
+
+        udelay(AB8500_WD_KICK_DELAY_US);
+
+        abx500_set_register_interruptible(ab->dev,
+                AB8500_SYS_CTRL2_BLOCK,
+                AB8500_MAIN_WD_CTRL_REG,
+                (AB8500_BIT_WD_CTRL_ENABLE
+                | AB8500_BIT_WD_CTRL_KICK));
+
+        if (ab->rev > 0x10) /* v1.1 v2.0 */
+                udelay(AB8500_WD_V11_DISABLE_DELAY_US);
+        else /* v1.0 */
+                msleep(AB8500_WD_V10_DISABLE_DELAY_MS);
+
+        abx500_set_register_interruptible(ab->dev,
+                AB8500_SYS_CTRL2_BLOCK,
+                AB8500_MAIN_WD_CTRL_REG,
+                0);
+}
+
+static void ab8500_usb_phy_ctrl(struct ab8500_usb *ab, bool sel_host,
+                                        bool enable)
+{
+        u8 ctrl_reg;
+        abx500_get_register_interruptible(ab->dev,
+                                AB8500_USB,
+                                AB8500_USB_PHY_CTRL_REG,
+                                &ctrl_reg);
+        if (sel_host) {
+                if (enable)
+                        ctrl_reg |= AB8500_BIT_PHY_CTRL_HOST_EN;
+                else
+                        ctrl_reg &= ~AB8500_BIT_PHY_CTRL_HOST_EN;
+        } else {
+                if (enable)
+                        ctrl_reg |= AB8500_BIT_PHY_CTRL_DEVICE_EN;
+                else
+                        ctrl_reg &= ~AB8500_BIT_PHY_CTRL_DEVICE_EN;
+        }
+
+        abx500_set_register_interruptible(ab->dev,
+                                AB8500_USB,
+                                AB8500_USB_PHY_CTRL_REG,
+                                ctrl_reg);
+
+        /* Needed to enable the phy.*/
+        if (enable)
+                ab8500_usb_wd_workaround(ab);
+}
+
+#define ab8500_usb_host_phy_en(ab)      ab8500_usb_phy_ctrl(ab, true, true)
+#define ab8500_usb_host_phy_dis(ab)     ab8500_usb_phy_ctrl(ab, true, false)
+#define ab8500_usb_peri_phy_en(ab)      ab8500_usb_phy_ctrl(ab, false, true)
+#define ab8500_usb_peri_phy_dis(ab)     ab8500_usb_phy_ctrl(ab, false, false)
+
+static int ab8500_usb_link_status_update(struct ab8500_usb *ab)
+{
+        u8 reg;
+        enum ab8500_usb_link_status lsts;
+        void *v = NULL;
+        enum usb_xceiv_events event;
+
+        abx500_get_register_interruptible(ab->dev,
+                        AB8500_USB,
+                        AB8500_USB_LINE_STAT_REG,
+                        &reg);
+
+        lsts = (reg >> 3) & 0x0F;
+
+        switch (lsts) {
+        case USB_LINK_NOT_CONFIGURED:
+        case USB_LINK_RESERVED:
+        case USB_LINK_NOT_VALID_LINK:
+                /* TODO: Disable regulators. */
+                ab8500_usb_host_phy_dis(ab);
+                ab8500_usb_peri_phy_dis(ab);
+                ab->otg.state = OTG_STATE_B_IDLE;
+                ab->otg.default_a = false;
+                ab->vbus_draw = 0;
+                event = USB_EVENT_NONE;
+                break;
+
+        case USB_LINK_STD_HOST_NC:
+        case USB_LINK_STD_HOST_C_NS:
+        case USB_LINK_STD_HOST_C_S:
+        case USB_LINK_HOST_CHG_NM:
+        case USB_LINK_HOST_CHG_HS:
+        case USB_LINK_HOST_CHG_HS_CHIRP:
+                if (ab->otg.gadget) {
+                        /* TODO: Enable regulators. */
+                        ab8500_usb_peri_phy_en(ab);
+                        v = ab->otg.gadget;
+                }
+                event = USB_EVENT_VBUS;
+                break;
+
+        case USB_LINK_HM_IDGND:
+                if (ab->otg.host) {
+                        /* TODO: Enable regulators. */
+                        ab8500_usb_host_phy_en(ab);
+                        v = ab->otg.host;
+                }
+                ab->otg.state = OTG_STATE_A_IDLE;
+                ab->otg.default_a = true;
+                event = USB_EVENT_ID;
+                break;
+
+        case USB_LINK_ACA_RID_A:
+        case USB_LINK_ACA_RID_B:
+                /* TODO */
+        case USB_LINK_ACA_RID_C_NM:
+        case USB_LINK_ACA_RID_C_HS:
+        case USB_LINK_ACA_RID_C_HS_CHIRP:
+        case USB_LINK_DEDICATED_CHG:
+                /* TODO: vbus_draw */
+                event = USB_EVENT_CHARGER;
+                break;
+        }
+
+        blocking_notifier_call_chain(&ab->otg.notifier, event, v);
+
+        return 0;
+}
+
+static void ab8500_usb_delayed_work(struct work_struct *work)
+{
+        struct ab8500_usb *ab = container_of(work, struct ab8500_usb,
+                                                dwork.work);
+
+        ab8500_usb_link_status_update(ab);
+}
+
+static irqreturn_t ab8500_usb_v1x_common_irq(int irq, void *data)
+{
+        struct ab8500_usb *ab = (struct ab8500_usb *) data;
+
+        /* Wait for link status to become stable. */
+        schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t ab8500_usb_v1x_vbus_fall_irq(int irq, void *data)
+{
+        struct ab8500_usb *ab = (struct ab8500_usb *) data;
+
+        /* Link status will not be updated till phy is disabled. */
+        ab8500_usb_peri_phy_dis(ab);
+
+        /* Wait for link status to become stable. */
+        schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t ab8500_usb_v20_irq(int irq, void *data)
+{
+        struct ab8500_usb *ab = (struct ab8500_usb *) data;
+
+        ab8500_usb_link_status_update(ab);
+
+        return IRQ_HANDLED;
+}
+
+static void ab8500_usb_phy_disable_work(struct work_struct *work)
+{
+        struct ab8500_usb *ab = container_of(work, struct ab8500_usb,
+                                                phy_dis_work);
+
+        if (!ab->otg.host)
+                ab8500_usb_host_phy_dis(ab);
+
+        if (!ab->otg.gadget)
+                ab8500_usb_peri_phy_dis(ab);
+}
+
+static int ab8500_usb_set_power(struct otg_transceiver *otg, unsigned mA)
+{
+        struct ab8500_usb *ab;
+
+        if (!otg)
+                return -ENODEV;
+
+        ab = xceiv_to_ab(otg);
+
+        ab->vbus_draw = mA;
+
+        if (mA)
+                blocking_notifier_call_chain(&ab->otg.notifier,
+                                USB_EVENT_ENUMERATED, ab->otg.gadget);
+        return 0;
+}
+
+/* TODO: Implement some way for charging or other drivers to read
+ * ab->vbus_draw.
+ */
+
+static int ab8500_usb_set_suspend(struct otg_transceiver *x, int suspend)
+{
+        /* TODO */
+        return 0;
+}
+
+static int ab8500_usb_set_peripheral(struct otg_transceiver *otg,
+                struct usb_gadget *gadget)
+{
+        struct ab8500_usb *ab;
+
+        if (!otg)
+                return -ENODEV;
+
+        ab = xceiv_to_ab(otg);
+
+        /* Some drivers call this function in atomic context.
+         * Do not update ab8500 registers directly till this
+         * is fixed.
+         */
+
+        if (!gadget) {
+                /* TODO: Disable regulators. */
+                ab->otg.gadget = NULL;
+                schedule_work(&ab->phy_dis_work);
+        } else {
+                ab->otg.gadget = gadget;
+                ab->otg.state = OTG_STATE_B_IDLE;
+
+                /* Phy will not be enabled if cable is already
+                 * plugged-in. Schedule to enable phy.
+                 * Use same delay to avoid any race condition.
+                 */
+                schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+        }
+
+        return 0;
+}
+
+static int ab8500_usb_set_host(struct otg_transceiver *otg,
+                                        struct usb_bus *host)
+{
+        struct ab8500_usb *ab;
+
+        if (!otg)
+                return -ENODEV;
+
+        ab = xceiv_to_ab(otg);
+
+        /* Some drivers call this function in atomic context.
+         * Do not update ab8500 registers directly till this
+         * is fixed.
+         */
+
+        if (!host) {
+                /* TODO: Disable regulators. */
+                ab->otg.host = NULL;
+                schedule_work(&ab->phy_dis_work);
+        } else {
+                ab->otg.host = host;
+                /* Phy will not be enabled if cable is already
+                 * plugged-in. Schedule to enable phy.
+                 * Use same delay to avoid any race condition.
+                 */
+                schedule_delayed_work(&ab->dwork, ab->link_status_wait);
+        }
+
+        return 0;
+}
+
+static void ab8500_usb_irq_free(struct ab8500_usb *ab)
+{
+        if (ab->rev < 0x20) {
+                free_irq(ab->irq_num_id_rise, ab);
+                free_irq(ab->irq_num_id_fall, ab);
+                free_irq(ab->irq_num_vbus_rise, ab);
+                free_irq(ab->irq_num_vbus_fall, ab);
+        } else {
+                free_irq(ab->irq_num_link_status, ab);
+        }
+}
+
+static int ab8500_usb_v1x_res_setup(struct platform_device *pdev,
+                                struct ab8500_usb *ab)
+{
+        int err;
+
+        ab->irq_num_id_rise = platform_get_irq_byname(pdev, "ID_WAKEUP_R");
+        if (ab->irq_num_id_rise < 0) {
+                dev_err(&pdev->dev, "ID rise irq not found\n");
+                return ab->irq_num_id_rise;
+        }
+        err = request_threaded_irq(ab->irq_num_id_rise, NULL,
+                ab8500_usb_v1x_common_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-id-rise", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for ID rise irq\n");
+                goto fail0;
+        }
+
+        ab->irq_num_id_fall = platform_get_irq_byname(pdev, "ID_WAKEUP_F");
+        if (ab->irq_num_id_fall < 0) {
+                dev_err(&pdev->dev, "ID fall irq not found\n");
+                return ab->irq_num_id_fall;
+        }
+        err = request_threaded_irq(ab->irq_num_id_fall, NULL,
+                ab8500_usb_v1x_common_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-id-fall", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for ID fall irq\n");
+                goto fail1;
+        }
+
+        ab->irq_num_vbus_rise = platform_get_irq_byname(pdev, "VBUS_DET_R");
+        if (ab->irq_num_vbus_rise < 0) {
+                dev_err(&pdev->dev, "VBUS rise irq not found\n");
+                return ab->irq_num_vbus_rise;
+        }
+        err = request_threaded_irq(ab->irq_num_vbus_rise, NULL,
+                ab8500_usb_v1x_common_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-vbus-rise", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for Vbus rise irq\n");
+                goto fail2;
+        }
+
+        ab->irq_num_vbus_fall = platform_get_irq_byname(pdev, "VBUS_DET_F");
+        if (ab->irq_num_vbus_fall < 0) {
+                dev_err(&pdev->dev, "VBUS fall irq not found\n");
+                return ab->irq_num_vbus_fall;
+        }
+        err = request_threaded_irq(ab->irq_num_vbus_fall, NULL,
+                ab8500_usb_v1x_vbus_fall_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-vbus-fall", ab);
+        if (err < 0) {
+                dev_err(ab->dev, "request_irq failed for Vbus fall irq\n");
+                goto fail3;
+        }
+
+        return 0;
+fail3:
+        free_irq(ab->irq_num_vbus_rise, ab);
+fail2:
+        free_irq(ab->irq_num_id_fall, ab);
+fail1:
+        free_irq(ab->irq_num_id_rise, ab);
+fail0:
+        return err;
+}
+
+static int ab8500_usb_v2_res_setup(struct platform_device *pdev,
+                                struct ab8500_usb *ab)
+{
+        int err;
+
+        ab->irq_num_link_status = platform_get_irq_byname(pdev,
+                                                "USB_LINK_STATUS");
+        if (ab->irq_num_link_status < 0) {
+                dev_err(&pdev->dev, "Link status irq not found\n");
+                return ab->irq_num_link_status;
+        }
+
+        err = request_threaded_irq(ab->irq_num_link_status, NULL,
+                ab8500_usb_v20_irq,
+                IRQF_NO_SUSPEND | IRQF_SHARED,
+                "usb-link-status", ab);
+        if (err < 0) {
+                dev_err(ab->dev,
+                        "request_irq failed for link status irq\n");
+                return err;
+        }
+
+        return 0;
+}
+
+static int __devinit ab8500_usb_probe(struct platform_device *pdev)
+{
+        struct ab8500_usb       *ab;
+        int err;
+        int rev;
+
+        rev = abx500_get_chip_id(&pdev->dev);
+        if (rev < 0) {
+                dev_err(&pdev->dev, "Chip id read failed\n");
+                return rev;
+        } else if (rev < 0x10) {
+                dev_err(&pdev->dev, "Unsupported AB8500 chip\n");
+                return -ENODEV;
+        }
+
+        ab = kzalloc(sizeof *ab, GFP_KERNEL);
+        if (!ab)
+                return -ENOMEM;
+
+        ab->dev                 = &pdev->dev;
+        ab->rev                 = rev;
+        ab->otg.dev             = ab->dev;
+        ab->otg.label           = "ab8500";
+        ab->otg.state           = OTG_STATE_UNDEFINED;
+        ab->otg.set_host        = ab8500_usb_set_host;
+        ab->otg.set_peripheral  = ab8500_usb_set_peripheral;
+        ab->otg.set_suspend     = ab8500_usb_set_suspend;
+        ab->otg.set_power       = ab8500_usb_set_power;
+
+        platform_set_drvdata(pdev, ab);
+
+        BLOCKING_INIT_NOTIFIER_HEAD(&ab->otg.notifier);
+
+        /* v1: Wait for link status to become stable.
+         * all: Updates form set_host and set_peripheral as they are atomic.
+         */
+        INIT_DELAYED_WORK(&ab->dwork, ab8500_usb_delayed_work);
+
+        /* all: Disable phy when called from set_host and set_peripheral */
+        INIT_WORK(&ab->phy_dis_work, ab8500_usb_phy_disable_work);
+
+        if (ab->rev < 0x20) {
+                err = ab8500_usb_v1x_res_setup(pdev, ab);
+                ab->link_status_wait = AB8500_V1x_LINK_STAT_WAIT;
+        } else {
+                err = ab8500_usb_v2_res_setup(pdev, ab);
+        }
+
+        if (err < 0)
+                goto fail0;
+
+        err = otg_set_transceiver(&ab->otg);
+        if (err) {
+                dev_err(&pdev->dev, "Can't register transceiver\n");
+                goto fail1;
+        }
+
+        dev_info(&pdev->dev, "AB8500 usb driver initialized\n");
+
+        return 0;
+fail1:
+        ab8500_usb_irq_free(ab);
+fail0:
+        kfree(ab);
+        return err;
+}
+
+static int __devexit ab8500_usb_remove(struct platform_device *pdev)
+{
+        struct ab8500_usb *ab = platform_get_drvdata(pdev);
+
+        ab8500_usb_irq_free(ab);
+
+        cancel_delayed_work_sync(&ab->dwork);
+
+        cancel_work_sync(&ab->phy_dis_work);
+
+        otg_set_transceiver(NULL);
+
+        ab8500_usb_host_phy_dis(ab);
+        ab8500_usb_peri_phy_dis(ab);
+
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(ab);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_usb_driver = {
+        .probe          = ab8500_usb_probe,
+        .remove         = __devexit_p(ab8500_usb_remove),
+        .driver         = {
+                .name   = "ab8500-usb",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init ab8500_usb_init(void)
+{
+        return platform_driver_register(&ab8500_usb_driver);
+}
+subsys_initcall(ab8500_usb_init);
+
+static void __exit ab8500_usb_exit(void)
+{
+        platform_driver_unregister(&ab8500_usb_driver);
+}
+module_exit(ab8500_usb_exit);
+
+MODULE_ALIAS("platform:ab8500_usb");
+MODULE_AUTHOR("ST-Ericsson AB");
+MODULE_DESCRIPTION("AB8500 usb transceiver driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/msm72k_otg.c b/drivers/usb/otg/msm72k_otg.c
new file mode 100644
index 000000000000..1cd52edcd0c2
--- /dev/null
+++ b/drivers/usb/otg/msm72k_otg.c
@@ -0,0 +1,1125 @@
+/* Copyright (c) 2009-2010, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/usb.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/ulpi.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/msm_hsusb.h>
+#include <linux/usb/msm_hsusb_hw.h>
+
+#include <mach/clk.h>
+
+#define MSM_USB_BASE    (motg->regs)
+#define DRIVER_NAME     "msm_otg"
+
+#define ULPI_IO_TIMEOUT_USEC    (10 * 1000)
+static int ulpi_read(struct otg_transceiver *otg, u32 reg)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        int cnt = 0;
+
+        /* initiate read operation */
+        writel(ULPI_RUN | ULPI_READ | ULPI_ADDR(reg),
+               USB_ULPI_VIEWPORT);
+
+        /* wait for completion */
+        while (cnt < ULPI_IO_TIMEOUT_USEC) {
+                if (!(readl(USB_ULPI_VIEWPORT) & ULPI_RUN))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= ULPI_IO_TIMEOUT_USEC) {
+                dev_err(otg->dev, "ulpi_read: timeout %08x\n",
+                        readl(USB_ULPI_VIEWPORT));
+                return -ETIMEDOUT;
+        }
+        return ULPI_DATA_READ(readl(USB_ULPI_VIEWPORT));
+}
+
+static int ulpi_write(struct otg_transceiver *otg, u32 val, u32 reg)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        int cnt = 0;
+
+        /* initiate write operation */
+        writel(ULPI_RUN | ULPI_WRITE |
+               ULPI_ADDR(reg) | ULPI_DATA(val),
+               USB_ULPI_VIEWPORT);
+
+        /* wait for completion */
+        while (cnt < ULPI_IO_TIMEOUT_USEC) {
+                if (!(readl(USB_ULPI_VIEWPORT) & ULPI_RUN))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= ULPI_IO_TIMEOUT_USEC) {
+                dev_err(otg->dev, "ulpi_write: timeout\n");
+                return -ETIMEDOUT;
+        }
+        return 0;
+}
+
+static struct otg_io_access_ops msm_otg_io_ops = {
+        .read = ulpi_read,
+        .write = ulpi_write,
+};
+
+static void ulpi_init(struct msm_otg *motg)
+{
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        int *seq = pdata->phy_init_seq;
+
+        if (!seq)
+                return;
+
+        while (seq[0] >= 0) {
+                dev_vdbg(motg->otg.dev, "ulpi: write 0x%02x to 0x%02x\n",
+                                seq[0], seq[1]);
+                ulpi_write(&motg->otg, seq[0], seq[1]);
+                seq += 2;
+        }
+}
+
+static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
+{
+        int ret;
+
+        if (assert) {
+                ret = clk_reset(motg->clk, CLK_RESET_ASSERT);
+                if (ret)
+                        dev_err(motg->otg.dev, "usb hs_clk assert failed\n");
+        } else {
+                ret = clk_reset(motg->clk, CLK_RESET_DEASSERT);
+                if (ret)
+                        dev_err(motg->otg.dev, "usb hs_clk deassert failed\n");
+        }
+        return ret;
+}
+
+static int msm_otg_phy_clk_reset(struct msm_otg *motg)
+{
+        int ret;
+
+        ret = clk_reset(motg->phy_reset_clk, CLK_RESET_ASSERT);
+        if (ret) {
+                dev_err(motg->otg.dev, "usb phy clk assert failed\n");
+                return ret;
+        }
+        usleep_range(10000, 12000);
+        ret = clk_reset(motg->phy_reset_clk, CLK_RESET_DEASSERT);
+        if (ret)
+                dev_err(motg->otg.dev, "usb phy clk deassert failed\n");
+        return ret;
+}
+
+static int msm_otg_phy_reset(struct msm_otg *motg)
+{
+        u32 val;
+        int ret;
+        int retries;
+
+        ret = msm_otg_link_clk_reset(motg, 1);
+        if (ret)
+                return ret;
+        ret = msm_otg_phy_clk_reset(motg);
+        if (ret)
+                return ret;
+        ret = msm_otg_link_clk_reset(motg, 0);
+        if (ret)
+                return ret;
+
+        val = readl(USB_PORTSC) & ~PORTSC_PTS_MASK;
+        writel(val | PORTSC_PTS_ULPI, USB_PORTSC);
+
+        for (retries = 3; retries > 0; retries--) {
+                ret = ulpi_write(&motg->otg, ULPI_FUNC_CTRL_SUSPENDM,
+                                ULPI_CLR(ULPI_FUNC_CTRL));
+                if (!ret)
+                        break;
+                ret = msm_otg_phy_clk_reset(motg);
+                if (ret)
+                        return ret;
+        }
+        if (!retries)
+                return -ETIMEDOUT;
+
+        /* This reset calibrates the phy, if the above write succeeded */
+        ret = msm_otg_phy_clk_reset(motg);
+        if (ret)
+                return ret;
+
+        for (retries = 3; retries > 0; retries--) {
+                ret = ulpi_read(&motg->otg, ULPI_DEBUG);
+                if (ret != -ETIMEDOUT)
+                        break;
+                ret = msm_otg_phy_clk_reset(motg);
+                if (ret)
+                        return ret;
+        }
+        if (!retries)
+                return -ETIMEDOUT;
+
+        dev_info(motg->otg.dev, "phy_reset: success\n");
+        return 0;
+}
+
+#define LINK_RESET_TIMEOUT_USEC         (250 * 1000)
+static int msm_otg_reset(struct otg_transceiver *otg)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        int cnt = 0;
+        int ret;
+        u32 val = 0;
+        u32 ulpi_val = 0;
+
+        ret = msm_otg_phy_reset(motg);
+        if (ret) {
+                dev_err(otg->dev, "phy_reset failed\n");
+                return ret;
+        }
+
+        ulpi_init(motg);
+
+        writel(USBCMD_RESET, USB_USBCMD);
+        while (cnt < LINK_RESET_TIMEOUT_USEC) {
+                if (!(readl(USB_USBCMD) & USBCMD_RESET))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+        if (cnt >= LINK_RESET_TIMEOUT_USEC)
+                return -ETIMEDOUT;
+
+        /* select ULPI phy */
+        writel(0x80000000, USB_PORTSC);
+
+        msleep(100);
+
+        writel(0x0, USB_AHBBURST);
+        writel(0x00, USB_AHBMODE);
+
+        if (pdata->otg_control == OTG_PHY_CONTROL) {
+                val = readl(USB_OTGSC);
+                if (pdata->mode == USB_OTG) {
+                        ulpi_val = ULPI_INT_IDGRD | ULPI_INT_SESS_VALID;
+                        val |= OTGSC_IDIE | OTGSC_BSVIE;
+                } else if (pdata->mode == USB_PERIPHERAL) {
+                        ulpi_val = ULPI_INT_SESS_VALID;
+                        val |= OTGSC_BSVIE;
+                }
+                writel(val, USB_OTGSC);
+                ulpi_write(otg, ulpi_val, ULPI_USB_INT_EN_RISE);
+                ulpi_write(otg, ulpi_val, ULPI_USB_INT_EN_FALL);
+        }
+
+        return 0;
+}
+
+#define PHY_SUSPEND_TIMEOUT_USEC        (500 * 1000)
+static int msm_otg_suspend(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        struct usb_bus *bus = otg->host;
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        int cnt = 0;
+
+        if (atomic_read(&motg->in_lpm))
+                return 0;
+
+        disable_irq(motg->irq);
+        /*
+         * Interrupt Latch Register auto-clear feature is not present
+         * in all PHY versions. Latch register is clear on read type.
+         * Clear latch register to avoid spurious wakeup from
+         * low power mode (LPM).
+         */
+        ulpi_read(otg, 0x14);
+
+        /*
+         * PHY comparators are disabled when PHY enters into low power
+         * mode (LPM). Keep PHY comparators ON in LPM only when we expect
+         * VBUS/Id notifications from USB PHY. Otherwise turn off USB
+         * PHY comparators. This save significant amount of power.
+         */
+        if (pdata->otg_control == OTG_PHY_CONTROL)
+                ulpi_write(otg, 0x01, 0x30);
+
+        /*
+         * PLL is not turned off when PHY enters into low power mode (LPM).
+         * Disable PLL for maximum power savings.
+         */
+        ulpi_write(otg, 0x08, 0x09);
+
+        /*
+         * PHY may take some time or even fail to enter into low power
+         * mode (LPM). Hence poll for 500 msec and reset the PHY and link
+         * in failure case.
+         */
+        writel(readl(USB_PORTSC) | PORTSC_PHCD, USB_PORTSC);
+        while (cnt < PHY_SUSPEND_TIMEOUT_USEC) {
+                if (readl(USB_PORTSC) & PORTSC_PHCD)
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= PHY_SUSPEND_TIMEOUT_USEC) {
+                dev_err(otg->dev, "Unable to suspend PHY\n");
+                msm_otg_reset(otg);
+                enable_irq(motg->irq);
+                return -ETIMEDOUT;
+        }
+
+        /*
+         * PHY has capability to generate interrupt asynchronously in low
+         * power mode (LPM). This interrupt is level triggered. So USB IRQ
+         * line must be disabled till async interrupt enable bit is cleared
+         * in USBCMD register. Assert STP (ULPI interface STOP signal) to
+         * block data communication from PHY.
+         */
+        writel(readl(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD);
+
+        clk_disable(motg->pclk);
+        clk_disable(motg->clk);
+        if (motg->core_clk)
+                clk_disable(motg->core_clk);
+
+        if (device_may_wakeup(otg->dev))
+                enable_irq_wake(motg->irq);
+        if (bus)
+                clear_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
+
+        atomic_set(&motg->in_lpm, 1);
+        enable_irq(motg->irq);
+
+        dev_info(otg->dev, "USB in low power mode\n");
+
+        return 0;
+}
+
+#define PHY_RESUME_TIMEOUT_USEC (100 * 1000)
+static int msm_otg_resume(struct msm_otg *motg)
+{
+        struct otg_transceiver *otg = &motg->otg;
+        struct usb_bus *bus = otg->host;
+        int cnt = 0;
+        unsigned temp;
+
+        if (!atomic_read(&motg->in_lpm))
+                return 0;
+
+        clk_enable(motg->pclk);
+        clk_enable(motg->clk);
+        if (motg->core_clk)
+                clk_enable(motg->core_clk);
+
+        temp = readl(USB_USBCMD);
+        temp &= ~ASYNC_INTR_CTRL;
+        temp &= ~ULPI_STP_CTRL;
+        writel(temp, USB_USBCMD);
+
+        /*
+         * PHY comes out of low power mode (LPM) in case of wakeup
+         * from asynchronous interrupt.
+         */
+        if (!(readl(USB_PORTSC) & PORTSC_PHCD))
+                goto skip_phy_resume;
+
+        writel(readl(USB_PORTSC) & ~PORTSC_PHCD, USB_PORTSC);
+        while (cnt < PHY_RESUME_TIMEOUT_USEC) {
+                if (!(readl(USB_PORTSC) & PORTSC_PHCD))
+                        break;
+                udelay(1);
+                cnt++;
+        }
+
+        if (cnt >= PHY_RESUME_TIMEOUT_USEC) {
+                /*
+                 * This is a fatal error. Reset the link and
+                 * PHY. USB state can not be restored. Re-insertion
+                 * of USB cable is the only way to get USB working.
+                 */
+                dev_err(otg->dev, "Unable to resume USB."
+                                "Re-plugin the cable\n");
+                msm_otg_reset(otg);
+        }
+
+skip_phy_resume:
+        if (device_may_wakeup(otg->dev))
+                disable_irq_wake(motg->irq);
+        if (bus)
+                set_bit(HCD_FLAG_HW_ACCESSIBLE, &(bus_to_hcd(bus))->flags);
+
+        if (motg->async_int) {
+                motg->async_int = 0;
+                pm_runtime_put(otg->dev);
+                enable_irq(motg->irq);
+        }
+
+        atomic_set(&motg->in_lpm, 0);
+
+        dev_info(otg->dev, "USB exited from low power mode\n");
+
+        return 0;
+}
+
+static void msm_otg_start_host(struct otg_transceiver *otg, int on)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        struct usb_hcd *hcd;
+
+        if (!otg->host)
+                return;
+
+        hcd = bus_to_hcd(otg->host);
+
+        if (on) {
+                dev_dbg(otg->dev, "host on\n");
+
+                if (pdata->vbus_power)
+                        pdata->vbus_power(1);
+                /*
+                 * Some boards have a switch cotrolled by gpio
+                 * to enable/disable internal HUB. Enable internal
+                 * HUB before kicking the host.
+                 */
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_A_HOST);
+#ifdef CONFIG_USB
+                usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
+#endif
+        } else {
+                dev_dbg(otg->dev, "host off\n");
+
+#ifdef CONFIG_USB
+                usb_remove_hcd(hcd);
+#endif
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_UNDEFINED);
+                if (pdata->vbus_power)
+                        pdata->vbus_power(0);
+        }
+}
+
+static int msm_otg_set_host(struct otg_transceiver *otg, struct usb_bus *host)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct usb_hcd *hcd;
+
+        /*
+         * Fail host registration if this board can support
+         * only peripheral configuration.
+         */
+        if (motg->pdata->mode == USB_PERIPHERAL) {
+                dev_info(otg->dev, "Host mode is not supported\n");
+                return -ENODEV;
+        }
+
+        if (!host) {
+                if (otg->state == OTG_STATE_A_HOST) {
+                        pm_runtime_get_sync(otg->dev);
+                        msm_otg_start_host(otg, 0);
+                        otg->host = NULL;
+                        otg->state = OTG_STATE_UNDEFINED;
+                        schedule_work(&motg->sm_work);
+                } else {
+                        otg->host = NULL;
+                }
+
+                return 0;
+        }
+
+        hcd = bus_to_hcd(host);
+        hcd->power_budget = motg->pdata->power_budget;
+
+        otg->host = host;
+        dev_dbg(otg->dev, "host driver registered w/ tranceiver\n");
+
+        /*
+         * Kick the state machine work, if peripheral is not supported
+         * or peripheral is already registered with us.
+         */
+        if (motg->pdata->mode == USB_HOST || otg->gadget) {
+                pm_runtime_get_sync(otg->dev);
+                schedule_work(&motg->sm_work);
+        }
+
+        return 0;
+}
+
+static void msm_otg_start_peripheral(struct otg_transceiver *otg, int on)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+
+        if (!otg->gadget)
+                return;
+
+        if (on) {
+                dev_dbg(otg->dev, "gadget on\n");
+                /*
+                 * Some boards have a switch cotrolled by gpio
+                 * to enable/disable internal HUB. Disable internal
+                 * HUB before kicking the gadget.
+                 */
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_B_PERIPHERAL);
+                usb_gadget_vbus_connect(otg->gadget);
+        } else {
+                dev_dbg(otg->dev, "gadget off\n");
+                usb_gadget_vbus_disconnect(otg->gadget);
+                if (pdata->setup_gpio)
+                        pdata->setup_gpio(OTG_STATE_UNDEFINED);
+        }
+
+}
+
+static int msm_otg_set_peripheral(struct otg_transceiver *otg,
+                        struct usb_gadget *gadget)
+{
+        struct msm_otg *motg = container_of(otg, struct msm_otg, otg);
+
+        /*
+         * Fail peripheral registration if this board can support
+         * only host configuration.
+         */
+        if (motg->pdata->mode == USB_HOST) {
+                dev_info(otg->dev, "Peripheral mode is not supported\n");
+                return -ENODEV;
+        }
+
+        if (!gadget) {
+                if (otg->state == OTG_STATE_B_PERIPHERAL) {
+                        pm_runtime_get_sync(otg->dev);
+                        msm_otg_start_peripheral(otg, 0);
+                        otg->gadget = NULL;
+                        otg->state = OTG_STATE_UNDEFINED;
+                        schedule_work(&motg->sm_work);
+                } else {
+                        otg->gadget = NULL;
+                }
+
+                return 0;
+        }
+        otg->gadget = gadget;
+        dev_dbg(otg->dev, "peripheral driver registered w/ tranceiver\n");
+
+        /*
+         * Kick the state machine work, if host is not supported
+         * or host is already registered with us.
+         */
+        if (motg->pdata->mode == USB_PERIPHERAL || otg->host) {
+                pm_runtime_get_sync(otg->dev);
+                schedule_work(&motg->sm_work);
+        }
+
+        return 0;
+}
+
+/*
+ * We support OTG, Peripheral only and Host only configurations. In case
+ * of OTG, mode switch (host-->peripheral/peripheral-->host) can happen
+ * via Id pin status or user request (debugfs). Id/BSV interrupts are not
+ * enabled when switch is controlled by user and default mode is supplied
+ * by board file, which can be changed by userspace later.
+ */
+static void msm_otg_init_sm(struct msm_otg *motg)
+{
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        u32 otgsc = readl(USB_OTGSC);
+
+        switch (pdata->mode) {
+        case USB_OTG:
+                if (pdata->otg_control == OTG_PHY_CONTROL) {
+                        if (otgsc & OTGSC_ID)
+                                set_bit(ID, &motg->inputs);
+                        else
+                                clear_bit(ID, &motg->inputs);
+
+                        if (otgsc & OTGSC_BSV)
+                                set_bit(B_SESS_VLD, &motg->inputs);
+                        else
+                                clear_bit(B_SESS_VLD, &motg->inputs);
+                } else if (pdata->otg_control == OTG_USER_CONTROL) {
+                        if (pdata->default_mode == USB_HOST) {
+                                clear_bit(ID, &motg->inputs);
+                        } else if (pdata->default_mode == USB_PERIPHERAL) {
+                                set_bit(ID, &motg->inputs);
+                                set_bit(B_SESS_VLD, &motg->inputs);
+                        } else {
+                                set_bit(ID, &motg->inputs);
+                                clear_bit(B_SESS_VLD, &motg->inputs);
+                        }
+                }
+                break;
+        case USB_HOST:
+                clear_bit(ID, &motg->inputs);
+                break;
+        case USB_PERIPHERAL:
+                set_bit(ID, &motg->inputs);
+                if (otgsc & OTGSC_BSV)
+                        set_bit(B_SESS_VLD, &motg->inputs);
+                else
+                        clear_bit(B_SESS_VLD, &motg->inputs);
+                break;
+        default:
+                break;
+        }
+}
+
+static void msm_otg_sm_work(struct work_struct *w)
+{
+        struct msm_otg *motg = container_of(w, struct msm_otg, sm_work);
+        struct otg_transceiver *otg = &motg->otg;
+
+        switch (otg->state) {
+        case OTG_STATE_UNDEFINED:
+                dev_dbg(otg->dev, "OTG_STATE_UNDEFINED state\n");
+                msm_otg_reset(otg);
+                msm_otg_init_sm(motg);
+                otg->state = OTG_STATE_B_IDLE;
+                /* FALL THROUGH */
+        case OTG_STATE_B_IDLE:
+                dev_dbg(otg->dev, "OTG_STATE_B_IDLE state\n");
+                if (!test_bit(ID, &motg->inputs) && otg->host) {
+                        /* disable BSV bit */
+                        writel(readl(USB_OTGSC) & ~OTGSC_BSVIE, USB_OTGSC);
+                        msm_otg_start_host(otg, 1);
+                        otg->state = OTG_STATE_A_HOST;
+                } else if (test_bit(B_SESS_VLD, &motg->inputs) && otg->gadget) {
+                        msm_otg_start_peripheral(otg, 1);
+                        otg->state = OTG_STATE_B_PERIPHERAL;
+                }
+                pm_runtime_put_sync(otg->dev);
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                dev_dbg(otg->dev, "OTG_STATE_B_PERIPHERAL state\n");
+                if (!test_bit(B_SESS_VLD, &motg->inputs) ||
+                                !test_bit(ID, &motg->inputs)) {
+                        msm_otg_start_peripheral(otg, 0);
+                        otg->state = OTG_STATE_B_IDLE;
+                        msm_otg_reset(otg);
+                        schedule_work(w);
+                }
+                break;
+        case OTG_STATE_A_HOST:
+                dev_dbg(otg->dev, "OTG_STATE_A_HOST state\n");
+                if (test_bit(ID, &motg->inputs)) {
+                        msm_otg_start_host(otg, 0);
+                        otg->state = OTG_STATE_B_IDLE;
+                        msm_otg_reset(otg);
+                        schedule_work(w);
+                }
+                break;
+        default:
+                break;
+        }
+}
+
+static irqreturn_t msm_otg_irq(int irq, void *data)
+{
+        struct msm_otg *motg = data;
+        struct otg_transceiver *otg = &motg->otg;
+        u32 otgsc = 0;
+
+        if (atomic_read(&motg->in_lpm)) {
+                disable_irq_nosync(irq);
+                motg->async_int = 1;
+                pm_runtime_get(otg->dev);
+                return IRQ_HANDLED;
+        }
+
+        otgsc = readl(USB_OTGSC);
+        if (!(otgsc & (OTGSC_IDIS | OTGSC_BSVIS)))
+                return IRQ_NONE;
+
+        if ((otgsc & OTGSC_IDIS) && (otgsc & OTGSC_IDIE)) {
+                if (otgsc & OTGSC_ID)
+                        set_bit(ID, &motg->inputs);
+                else
+                        clear_bit(ID, &motg->inputs);
+                dev_dbg(otg->dev, "ID set/clear\n");
+                pm_runtime_get_noresume(otg->dev);
+        } else if ((otgsc & OTGSC_BSVIS) && (otgsc & OTGSC_BSVIE)) {
+                if (otgsc & OTGSC_BSV)
+                        set_bit(B_SESS_VLD, &motg->inputs);
+                else
+                        clear_bit(B_SESS_VLD, &motg->inputs);
+                dev_dbg(otg->dev, "BSV set/clear\n");
+                pm_runtime_get_noresume(otg->dev);
+        }
+
+        writel(otgsc, USB_OTGSC);
+        schedule_work(&motg->sm_work);
+        return IRQ_HANDLED;
+}
+
+static int msm_otg_mode_show(struct seq_file *s, void *unused)
+{
+        struct msm_otg *motg = s->private;
+        struct otg_transceiver *otg = &motg->otg;
+
+        switch (otg->state) {
+        case OTG_STATE_A_HOST:
+                seq_printf(s, "host\n");
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                seq_printf(s, "peripheral\n");
+                break;
+        default:
+                seq_printf(s, "none\n");
+                break;
+        }
+
+        return 0;
+}
+
+static int msm_otg_mode_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, msm_otg_mode_show, inode->i_private);
+}
+
+static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
+                                size_t count, loff_t *ppos)
+{
+        struct msm_otg *motg = file->private_data;
+        char buf[16];
+        struct otg_transceiver *otg = &motg->otg;
+        int status = count;
+        enum usb_mode_type req_mode;
+
+        memset(buf, 0x00, sizeof(buf));
+
+        if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) {
+                status = -EFAULT;
+                goto out;
+        }
+
+        if (!strncmp(buf, "host", 4)) {
+                req_mode = USB_HOST;
+        } else if (!strncmp(buf, "peripheral", 10)) {
+                req_mode = USB_PERIPHERAL;
+        } else if (!strncmp(buf, "none", 4)) {
+                req_mode = USB_NONE;
+        } else {
+                status = -EINVAL;
+                goto out;
+        }
+
+        switch (req_mode) {
+        case USB_NONE:
+                switch (otg->state) {
+                case OTG_STATE_A_HOST:
+                case OTG_STATE_B_PERIPHERAL:
+                        set_bit(ID, &motg->inputs);
+                        clear_bit(B_SESS_VLD, &motg->inputs);
+                        break;
+                default:
+                        goto out;
+                }
+                break;
+        case USB_PERIPHERAL:
+                switch (otg->state) {
+                case OTG_STATE_B_IDLE:
+                case OTG_STATE_A_HOST:
+                        set_bit(ID, &motg->inputs);
+                        set_bit(B_SESS_VLD, &motg->inputs);
+                        break;
+                default:
+                        goto out;
+                }
+                break;
+        case USB_HOST:
+                switch (otg->state) {
+                case OTG_STATE_B_IDLE:
+                case OTG_STATE_B_PERIPHERAL:
+                        clear_bit(ID, &motg->inputs);
+                        break;
+                default:
+                        goto out;
+                }
+                break;
+        default:
+                goto out;
+        }
+
+        pm_runtime_get_sync(otg->dev);
+        schedule_work(&motg->sm_work);
+out:
+        return status;
+}
+
+const struct file_operations msm_otg_mode_fops = {
+        .open = msm_otg_mode_open,
+        .read = seq_read,
+        .write = msm_otg_mode_write,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static struct dentry *msm_otg_dbg_root;
+static struct dentry *msm_otg_dbg_mode;
+
+static int msm_otg_debugfs_init(struct msm_otg *motg)
+{
+        msm_otg_dbg_root = debugfs_create_dir("msm_otg", NULL);
+
+        if (!msm_otg_dbg_root || IS_ERR(msm_otg_dbg_root))
+                return -ENODEV;
+
+        msm_otg_dbg_mode = debugfs_create_file("mode", S_IRUGO | S_IWUSR,
+                                msm_otg_dbg_root, motg, &msm_otg_mode_fops);
+        if (!msm_otg_dbg_mode) {
+                debugfs_remove(msm_otg_dbg_root);
+                msm_otg_dbg_root = NULL;
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void msm_otg_debugfs_cleanup(void)
+{
+        debugfs_remove(msm_otg_dbg_mode);
+        debugfs_remove(msm_otg_dbg_root);
+}
+
+static int __init msm_otg_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        struct resource *res;
+        struct msm_otg *motg;
+        struct otg_transceiver *otg;
+
+        dev_info(&pdev->dev, "msm_otg probe\n");
+        if (!pdev->dev.platform_data) {
+                dev_err(&pdev->dev, "No platform data given. Bailing out\n");
+                return -ENODEV;
+        }
+
+        motg = kzalloc(sizeof(struct msm_otg), GFP_KERNEL);
+        if (!motg) {
+                dev_err(&pdev->dev, "unable to allocate msm_otg\n");
+                return -ENOMEM;
+        }
+
+        motg->pdata = pdev->dev.platform_data;
+        otg = &motg->otg;
+        otg->dev = &pdev->dev;
+
+        motg->phy_reset_clk = clk_get(&pdev->dev, "usb_phy_clk");
+        if (IS_ERR(motg->phy_reset_clk)) {
+                dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
+                ret = PTR_ERR(motg->phy_reset_clk);
+                goto free_motg;
+        }
+
+        motg->clk = clk_get(&pdev->dev, "usb_hs_clk");
+        if (IS_ERR(motg->clk)) {
+                dev_err(&pdev->dev, "failed to get usb_hs_clk\n");
+                ret = PTR_ERR(motg->clk);
+                goto put_phy_reset_clk;
+        }
+
+        motg->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
+        if (IS_ERR(motg->pclk)) {
+                dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
+                ret = PTR_ERR(motg->pclk);
+                goto put_clk;
+        }
+
+        /*
+         * USB core clock is not present on all MSM chips. This
+         * clock is introduced to remove the dependency on AXI
+         * bus frequency.
+         */
+        motg->core_clk = clk_get(&pdev->dev, "usb_hs_core_clk");
+        if (IS_ERR(motg->core_clk))
+                motg->core_clk = NULL;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get platform resource mem\n");
+                ret = -ENODEV;
+                goto put_core_clk;
+        }
+
+        motg->regs = ioremap(res->start, resource_size(res));
+        if (!motg->regs) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -ENOMEM;
+                goto put_core_clk;
+        }
+        dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);
+
+        motg->irq = platform_get_irq(pdev, 0);
+        if (!motg->irq) {
+                dev_err(&pdev->dev, "platform_get_irq failed\n");
+                ret = -ENODEV;
+                goto free_regs;
+        }
+
+        clk_enable(motg->clk);
+        clk_enable(motg->pclk);
+        if (motg->core_clk)
+                clk_enable(motg->core_clk);
+
+        writel(0, USB_USBINTR);
+        writel(0, USB_OTGSC);
+
+        INIT_WORK(&motg->sm_work, msm_otg_sm_work);
+        ret = request_irq(motg->irq, msm_otg_irq, IRQF_SHARED,
+                                        "msm_otg", motg);
+        if (ret) {
+                dev_err(&pdev->dev, "request irq failed\n");
+                goto disable_clks;
+        }
+
+        otg->init = msm_otg_reset;
+        otg->set_host = msm_otg_set_host;
+        otg->set_peripheral = msm_otg_set_peripheral;
+
+        otg->io_ops = &msm_otg_io_ops;
+
+        ret = otg_set_transceiver(&motg->otg);
+        if (ret) {
+                dev_err(&pdev->dev, "otg_set_transceiver failed\n");
+                goto free_irq;
+        }
+
+        platform_set_drvdata(pdev, motg);
+        device_init_wakeup(&pdev->dev, 1);
+
+        if (motg->pdata->mode == USB_OTG &&
+                        motg->pdata->otg_control == OTG_USER_CONTROL) {
+                ret = msm_otg_debugfs_init(motg);
+                if (ret)
+                        dev_dbg(&pdev->dev, "mode debugfs file is"
+                                        "not available\n");
+        }
+
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        return 0;
+free_irq:
+        free_irq(motg->irq, motg);
+disable_clks:
+        clk_disable(motg->pclk);
+        clk_disable(motg->clk);
+free_regs:
+        iounmap(motg->regs);
+put_core_clk:
+        if (motg->core_clk)
+                clk_put(motg->core_clk);
+        clk_put(motg->pclk);
+put_clk:
+        clk_put(motg->clk);
+put_phy_reset_clk:
+        clk_put(motg->phy_reset_clk);
+free_motg:
+        kfree(motg);
+        return ret;
+}
+
+static int __devexit msm_otg_remove(struct platform_device *pdev)
+{
+        struct msm_otg *motg = platform_get_drvdata(pdev);
+        struct otg_transceiver *otg = &motg->otg;
+        int cnt = 0;
+
+        if (otg->host || otg->gadget)
+                return -EBUSY;
+
+        msm_otg_debugfs_cleanup();
+        cancel_work_sync(&motg->sm_work);
+
+        msm_otg_resume(motg);
+
+        device_init_wakeup(&pdev->dev, 0);
+        pm_runtime_disable(&pdev->dev);
+
+        otg_set_transceiver(NULL);
+        free_irq(motg->irq, motg);
+
+        /*
+         * Put PHY in low power mode.
+         */
+        ulpi_read(otg, 0x14);
+        ulpi_write(otg, 0x08, 0x09);
+
+        writel(readl(USB_PORTSC) | PORTSC_PHCD, USB_PORTSC);
+        while (cnt < PHY_SUSPEND_TIMEOUT_USEC) {
+                if (readl(USB_PORTSC) & PORTSC_PHCD)
+                        break;
+                udelay(1);
+                cnt++;
+        }
+        if (cnt >= PHY_SUSPEND_TIMEOUT_USEC)
+                dev_err(otg->dev, "Unable to suspend PHY\n");
+
+        clk_disable(motg->pclk);
+        clk_disable(motg->clk);
+        if (motg->core_clk)
+                clk_disable(motg->core_clk);
+
+        iounmap(motg->regs);
+        pm_runtime_set_suspended(&pdev->dev);
+
+        clk_put(motg->phy_reset_clk);
+        clk_put(motg->pclk);
+        clk_put(motg->clk);
+        if (motg->core_clk)
+                clk_put(motg->core_clk);
+
+        kfree(motg);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_RUNTIME
+static int msm_otg_runtime_idle(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+        struct otg_transceiver *otg = &motg->otg;
+
+        dev_dbg(dev, "OTG runtime idle\n");
+
+        /*
+         * It is observed some times that a spurious interrupt
+         * comes when PHY is put into LPM immediately after PHY reset.
+         * This 1 sec delay also prevents entering into LPM immediately
+         * after asynchronous interrupt.
+         */
+        if (otg->state != OTG_STATE_UNDEFINED)
+                pm_schedule_suspend(dev, 1000);
+
+        return -EAGAIN;
+}
+
+static int msm_otg_runtime_suspend(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "OTG runtime suspend\n");
+        return msm_otg_suspend(motg);
+}
+
+static int msm_otg_runtime_resume(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "OTG runtime resume\n");
+        return msm_otg_resume(motg);
+}
+#else
+#define msm_otg_runtime_idle    NULL
+#define msm_otg_runtime_suspend NULL
+#define msm_otg_runtime_resume  NULL
+#endif
+
+#ifdef CONFIG_PM
+static int msm_otg_pm_suspend(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "OTG PM suspend\n");
+        return msm_otg_suspend(motg);
+}
+
+static int msm_otg_pm_resume(struct device *dev)
+{
+        struct msm_otg *motg = dev_get_drvdata(dev);
+        int ret;
+
+        dev_dbg(dev, "OTG PM resume\n");
+
+        ret = msm_otg_resume(motg);
+        if (ret)
+                return ret;
+
+        /*
+         * Runtime PM Documentation recommends bringing the
+         * device to full powered state upon resume.
+         */
+        pm_runtime_disable(dev);
+        pm_runtime_set_active(dev);
+        pm_runtime_enable(dev);
+
+        return 0;
+}
+#else
+#define msm_otg_pm_suspend      NULL
+#define msm_otg_pm_resume       NULL
+#endif
+
+static const struct dev_pm_ops msm_otg_dev_pm_ops = {
+        .runtime_suspend = msm_otg_runtime_suspend,
+        .runtime_resume  = msm_otg_runtime_resume,
+        .runtime_idle    = msm_otg_runtime_idle,
+        .suspend         = msm_otg_pm_suspend,
+        .resume          = msm_otg_pm_resume,
+};
+
+static struct platform_driver msm_otg_driver = {
+        .remove = __devexit_p(msm_otg_remove),
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+                .pm = &msm_otg_dev_pm_ops,
+        },
+};
+
+static int __init msm_otg_init(void)
+{
+        return platform_driver_probe(&msm_otg_driver, msm_otg_probe);
+}
+
+static void __exit msm_otg_exit(void)
+{
+        platform_driver_unregister(&msm_otg_driver);
+}
+
+module_init(msm_otg_init);
+module_exit(msm_otg_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("MSM USB transceiver driver");
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index d335f484fcd8..6ca505f333e4 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -678,7 +678,8 @@ static int __exit twl4030_usb_remove(struct platform_device *pdev)
         /* disable complete OTG block */
         twl4030_usb_clear_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
 
-        twl4030_phy_power(twl, 0);
+        if (!twl->asleep)
+                twl4030_phy_power(twl, 0);
         regulator_put(twl->usb1v5);
         regulator_put(twl->usb1v8);
         regulator_put(twl->usb3v1);
diff --git a/drivers/usb/otg/twl6030-usb.c b/drivers/usb/otg/twl6030-usb.c
new file mode 100644
index 000000000000..28f770103640
--- /dev/null
+++ b/drivers/usb/otg/twl6030-usb.c
@@ -0,0 +1,493 @@
+/*
+ * twl6030_usb - TWL6030 USB transceiver, talking to OMAP OTG driver.
+ *
+ * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Author: Hema HK <hemahk@ti.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/usb/otg.h>
+#include <linux/i2c/twl.h>
+#include <linux/regulator/consumer.h>
+#include <linux/err.h>
+#include <linux/notifier.h>
+#include <linux/slab.h>
+
+/* usb register definitions */
+#define USB_VENDOR_ID_LSB               0x00
+#define USB_VENDOR_ID_MSB               0x01
+#define USB_PRODUCT_ID_LSB              0x02
+#define USB_PRODUCT_ID_MSB              0x03
+#define USB_VBUS_CTRL_SET               0x04
+#define USB_VBUS_CTRL_CLR               0x05
+#define USB_ID_CTRL_SET                 0x06
+#define USB_ID_CTRL_CLR                 0x07
+#define USB_VBUS_INT_SRC                0x08
+#define USB_VBUS_INT_LATCH_SET          0x09
+#define USB_VBUS_INT_LATCH_CLR          0x0A
+#define USB_VBUS_INT_EN_LO_SET          0x0B
+#define USB_VBUS_INT_EN_LO_CLR          0x0C
+#define USB_VBUS_INT_EN_HI_SET          0x0D
+#define USB_VBUS_INT_EN_HI_CLR          0x0E
+#define USB_ID_INT_SRC                  0x0F
+#define USB_ID_INT_LATCH_SET            0x10
+#define USB_ID_INT_LATCH_CLR            0x11
+
+#define USB_ID_INT_EN_LO_SET            0x12
+#define USB_ID_INT_EN_LO_CLR            0x13
+#define USB_ID_INT_EN_HI_SET            0x14
+#define USB_ID_INT_EN_HI_CLR            0x15
+#define USB_OTG_ADP_CTRL                0x16
+#define USB_OTG_ADP_HIGH                0x17
+#define USB_OTG_ADP_LOW                 0x18
+#define USB_OTG_ADP_RISE                0x19
+#define USB_OTG_REVISION                0x1A
+
+/* to be moved to LDO */
+#define TWL6030_MISC2                   0xE5
+#define TWL6030_CFG_LDO_PD2             0xF5
+#define TWL6030_BACKUP_REG              0xFA
+
+#define STS_HW_CONDITIONS               0x21
+
+/* In module TWL6030_MODULE_PM_MASTER */
+#define STS_HW_CONDITIONS               0x21
+#define STS_USB_ID                      BIT(2)
+
+/* In module TWL6030_MODULE_PM_RECEIVER */
+#define VUSB_CFG_TRANS                  0x71
+#define VUSB_CFG_STATE                  0x72
+#define VUSB_CFG_VOLTAGE                0x73
+
+/* in module TWL6030_MODULE_MAIN_CHARGE */
+
+#define CHARGERUSB_CTRL1                0x8
+
+#define CONTROLLER_STAT1                0x03
+#define VBUS_DET                        BIT(2)
+
+struct twl6030_usb {
+        struct otg_transceiver  otg;
+        struct device           *dev;
+
+        /* for vbus reporting with irqs disabled */
+        spinlock_t              lock;
+
+        struct regulator                *usb3v3;
+
+        int                     irq1;
+        int                     irq2;
+        u8                      linkstat;
+        u8                      asleep;
+        bool                    irq_enabled;
+};
+
+#define xceiv_to_twl(x)         container_of((x), struct twl6030_usb, otg);
+
+/*-------------------------------------------------------------------------*/
+
+static inline int twl6030_writeb(struct twl6030_usb *twl, u8 module,
+                                                u8 data, u8 address)
+{
+        int ret = 0;
+
+        ret = twl_i2c_write_u8(module, data, address);
+        if (ret < 0)
+                dev_err(twl->dev,
+                        "Write[0x%x] Error %d\n", address, ret);
+        return ret;
+}
+
+static inline u8 twl6030_readb(struct twl6030_usb *twl, u8 module, u8 address)
+{
+        u8 data, ret = 0;
+
+        ret = twl_i2c_read_u8(module, &data, address);
+        if (ret >= 0)
+                ret = data;
+        else
+                dev_err(twl->dev,
+                        "readb[0x%x,0x%x] Error %d\n",
+                                        module, address, ret);
+        return ret;
+}
+
+/*-------------------------------------------------------------------------*/
+static int twl6030_set_phy_clk(struct otg_transceiver *x, int on)
+{
+        struct twl6030_usb *twl;
+        struct device *dev;
+        struct twl4030_usb_data *pdata;
+
+        twl = xceiv_to_twl(x);
+        dev  = twl->dev;
+        pdata = dev->platform_data;
+
+        pdata->phy_set_clock(twl->dev, on);
+
+        return 0;
+}
+
+static int twl6030_phy_init(struct otg_transceiver *x)
+{
+        u8 hw_state;
+        struct twl6030_usb *twl;
+        struct device *dev;
+        struct twl4030_usb_data *pdata;
+
+        twl = xceiv_to_twl(x);
+        dev  = twl->dev;
+        pdata = dev->platform_data;
+
+        regulator_enable(twl->usb3v3);
+
+        hw_state = twl6030_readb(twl, TWL6030_MODULE_ID0, STS_HW_CONDITIONS);
+
+        if (hw_state & STS_USB_ID)
+                pdata->phy_power(twl->dev, 1, 1);
+        else
+                pdata->phy_power(twl->dev, 0, 1);
+
+        return 0;
+}
+
+static void twl6030_phy_shutdown(struct otg_transceiver *x)
+{
+        struct twl6030_usb *twl;
+        struct device *dev;
+        struct twl4030_usb_data *pdata;
+
+        twl = xceiv_to_twl(x);
+        dev  = twl->dev;
+        pdata = dev->platform_data;
+        pdata->phy_power(twl->dev, 0, 0);
+        regulator_disable(twl->usb3v3);
+}
+
+static int twl6030_usb_ldo_init(struct twl6030_usb *twl)
+{
+
+        /* Set to OTG_REV 1.3 and turn on the ID_WAKEUP_COMP */
+        twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x1, TWL6030_BACKUP_REG);
+
+        /* Program CFG_LDO_PD2 register and set VUSB bit */
+        twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x1, TWL6030_CFG_LDO_PD2);
+
+        /* Program MISC2 register and set bit VUSB_IN_VBAT */
+        twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x10, TWL6030_MISC2);
+
+        twl->usb3v3 = regulator_get(twl->dev, "vusb");
+        if (IS_ERR(twl->usb3v3))
+                return -ENODEV;
+
+        regulator_enable(twl->usb3v3);
+
+        /* Program the VUSB_CFG_TRANS for ACTIVE state. */
+        twl6030_writeb(twl, TWL_MODULE_PM_RECEIVER, 0x3F,
+                                                VUSB_CFG_TRANS);
+
+        /* Program the VUSB_CFG_STATE register to ON on all groups. */
+        twl6030_writeb(twl, TWL_MODULE_PM_RECEIVER, 0xE1,
+                                                VUSB_CFG_STATE);
+
+        /* Program the USB_VBUS_CTRL_SET and set VBUS_ACT_COMP bit */
+        twl6030_writeb(twl, TWL_MODULE_USB, 0x4, USB_VBUS_CTRL_SET);
+
+        /*
+         * Program the USB_ID_CTRL_SET register to enable GND drive
+         * and the ID comparators
+         */
+        twl6030_writeb(twl, TWL_MODULE_USB, 0x14, USB_ID_CTRL_SET);
+
+        return 0;
+}
+
+static ssize_t twl6030_usb_vbus_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct twl6030_usb *twl = dev_get_drvdata(dev);
+        unsigned long flags;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&twl->lock, flags);
+
+        switch (twl->linkstat) {
+        case USB_EVENT_VBUS:
+               ret = snprintf(buf, PAGE_SIZE, "vbus\n");
+               break;
+        case USB_EVENT_ID:
+               ret = snprintf(buf, PAGE_SIZE, "id\n");
+               break;
+        case USB_EVENT_NONE:
+               ret = snprintf(buf, PAGE_SIZE, "none\n");
+               break;
+        default:
+               ret = snprintf(buf, PAGE_SIZE, "UNKNOWN\n");
+        }
+        spin_unlock_irqrestore(&twl->lock, flags);
+
+        return ret;
+}
+static DEVICE_ATTR(vbus, 0444, twl6030_usb_vbus_show, NULL);
+
+static irqreturn_t twl6030_usb_irq(int irq, void *_twl)
+{
+        struct twl6030_usb *twl = _twl;
+        int status;
+        u8 vbus_state, hw_state;
+
+        hw_state = twl6030_readb(twl, TWL6030_MODULE_ID0, STS_HW_CONDITIONS);
+
+        vbus_state = twl6030_readb(twl, TWL_MODULE_MAIN_CHARGE,
+                                                CONTROLLER_STAT1);
+        if (!(hw_state & STS_USB_ID)) {
+                if (vbus_state & VBUS_DET) {
+                        status = USB_EVENT_VBUS;
+                        twl->otg.default_a = false;
+                        twl->otg.state = OTG_STATE_B_IDLE;
+                } else {
+                        status = USB_EVENT_NONE;
+                }
+                if (status >= 0) {
+                        twl->linkstat = status;
+                        blocking_notifier_call_chain(&twl->otg.notifier,
+                                                status, twl->otg.gadget);
+                }
+        }
+        sysfs_notify(&twl->dev->kobj, NULL, "vbus");
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t twl6030_usbotg_irq(int irq, void *_twl)
+{
+        struct twl6030_usb *twl = _twl;
+        int status = USB_EVENT_NONE;
+        u8 hw_state;
+
+        hw_state = twl6030_readb(twl, TWL6030_MODULE_ID0, STS_HW_CONDITIONS);
+
+        if (hw_state & STS_USB_ID) {
+
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_CLR, 0x1);
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_SET,
+                                                                0x10);
+                status = USB_EVENT_ID;
+                twl->otg.default_a = true;
+                twl->otg.state = OTG_STATE_A_IDLE;
+                blocking_notifier_call_chain(&twl->otg.notifier, status,
+                                                        twl->otg.gadget);
+        } else  {
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_CLR,
+                                                                0x10);
+                twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_SET,
+                                                                0x1);
+        }
+        twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_LATCH_CLR, status);
+        twl->linkstat = status;
+
+        return IRQ_HANDLED;
+}
+
+static int twl6030_set_peripheral(struct otg_transceiver *x,
+                struct usb_gadget *gadget)
+{
+        struct twl6030_usb *twl;
+
+        if (!x)
+                return -ENODEV;
+
+        twl = xceiv_to_twl(x);
+        twl->otg.gadget = gadget;
+        if (!gadget)
+                twl->otg.state = OTG_STATE_UNDEFINED;
+
+        return 0;
+}
+
+static int twl6030_enable_irq(struct otg_transceiver *x)
+{
+        struct twl6030_usb *twl = xceiv_to_twl(x);
+
+        twl6030_writeb(twl, TWL_MODULE_USB, USB_ID_INT_EN_HI_SET, 0x1);
+        twl6030_interrupt_unmask(0x05, REG_INT_MSK_LINE_C);
+        twl6030_interrupt_unmask(0x05, REG_INT_MSK_STS_C);
+
+        twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
+                                REG_INT_MSK_LINE_C);
+        twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
+                                REG_INT_MSK_STS_C);
+        twl6030_usb_irq(twl->irq2, twl);
+        twl6030_usbotg_irq(twl->irq1, twl);
+
+        return 0;
+}
+
+static int twl6030_set_vbus(struct otg_transceiver *x, bool enabled)
+{
+        struct twl6030_usb *twl = xceiv_to_twl(x);
+
+        /*
+         * Start driving VBUS. Set OPA_MODE bit in CHARGERUSB_CTRL1
+         * register. This enables boost mode.
+         */
+        if (enabled)
+                twl6030_writeb(twl, TWL_MODULE_MAIN_CHARGE , 0x40,
+                                                CHARGERUSB_CTRL1);
+         else
+                twl6030_writeb(twl, TWL_MODULE_MAIN_CHARGE , 0x00,
+                                                CHARGERUSB_CTRL1);
+        return 0;
+}
+
+static int twl6030_set_host(struct otg_transceiver *x, struct usb_bus *host)
+{
+        struct twl6030_usb *twl;
+
+        if (!x)
+                return -ENODEV;
+
+        twl = xceiv_to_twl(x);
+        twl->otg.host = host;
+        if (!host)
+                twl->otg.state = OTG_STATE_UNDEFINED;
+        return 0;
+}
+
+static int __devinit twl6030_usb_probe(struct platform_device *pdev)
+{
+        struct twl6030_usb      *twl;
+        int                     status, err;
+        struct twl4030_usb_data *pdata;
+        struct device *dev = &pdev->dev;
+        pdata = dev->platform_data;
+
+        twl = kzalloc(sizeof *twl, GFP_KERNEL);
+        if (!twl)
+                return -ENOMEM;
+
+        twl->dev                = &pdev->dev;
+        twl->irq1               = platform_get_irq(pdev, 0);
+        twl->irq2               = platform_get_irq(pdev, 1);
+        twl->otg.dev            = twl->dev;
+        twl->otg.label          = "twl6030";
+        twl->otg.set_host       = twl6030_set_host;
+        twl->otg.set_peripheral = twl6030_set_peripheral;
+        twl->otg.set_vbus       = twl6030_set_vbus;
+        twl->otg.init           = twl6030_phy_init;
+        twl->otg.shutdown       = twl6030_phy_shutdown;
+
+        /* init spinlock for workqueue */
+        spin_lock_init(&twl->lock);
+
+        err = twl6030_usb_ldo_init(twl);
+        if (err) {
+                dev_err(&pdev->dev, "ldo init failed\n");
+                kfree(twl);
+                return err;
+        }
+        otg_set_transceiver(&twl->otg);
+
+        platform_set_drvdata(pdev, twl);
+        if (device_create_file(&pdev->dev, &dev_attr_vbus))
+                dev_warn(&pdev->dev, "could not create sysfs file\n");
+
+        BLOCKING_INIT_NOTIFIER_HEAD(&twl->otg.notifier);
+
+        twl->irq_enabled = true;
+        status = request_threaded_irq(twl->irq1, NULL, twl6030_usbotg_irq,
+                        IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+                        "twl6030_usb", twl);
+        if (status < 0) {
+                dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
+                        twl->irq1, status);
+                device_remove_file(twl->dev, &dev_attr_vbus);
+                kfree(twl);
+                return status;
+        }
+
+        status = request_threaded_irq(twl->irq2, NULL, twl6030_usb_irq,
+                        IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+                        "twl6030_usb", twl);
+        if (status < 0) {
+                dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
+                        twl->irq2, status);
+                free_irq(twl->irq1, twl);
+                device_remove_file(twl->dev, &dev_attr_vbus);
+                kfree(twl);
+                return status;
+        }
+
+        pdata->phy_init(dev);
+        twl6030_enable_irq(&twl->otg);
+        dev_info(&pdev->dev, "Initialized TWL6030 USB module\n");
+
+        return 0;
+}
+
+static int __exit twl6030_usb_remove(struct platform_device *pdev)
+{
+        struct twl6030_usb *twl = platform_get_drvdata(pdev);
+
+        struct twl4030_usb_data *pdata;
+        struct device *dev = &pdev->dev;
+        pdata = dev->platform_data;
+
+        twl6030_interrupt_mask(TWL6030_USBOTG_INT_MASK,
+                REG_INT_MSK_LINE_C);
+        twl6030_interrupt_mask(TWL6030_USBOTG_INT_MASK,
+                        REG_INT_MSK_STS_C);
+        free_irq(twl->irq1, twl);
+        free_irq(twl->irq2, twl);
+        regulator_put(twl->usb3v3);
+        pdata->phy_exit(twl->dev);
+        device_remove_file(twl->dev, &dev_attr_vbus);
+        kfree(twl);
+
+        return 0;
+}
+
+static struct platform_driver twl6030_usb_driver = {
+        .probe          = twl6030_usb_probe,
+        .remove         = __exit_p(twl6030_usb_remove),
+        .driver         = {
+                .name   = "twl6030_usb",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init twl6030_usb_init(void)
+{
+        return platform_driver_register(&twl6030_usb_driver);
+}
+subsys_initcall(twl6030_usb_init);
+
+static void __exit twl6030_usb_exit(void)
+{
+        platform_driver_unregister(&twl6030_usb_driver);
+}
+module_exit(twl6030_usb_exit);
+
+MODULE_ALIAS("platform:twl6030_usb");
+MODULE_AUTHOR("Hema HK <hemahk@ti.com>");
+MODULE_DESCRIPTION("TWL6030 USB transceiver driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 2dec50013528..a2668d089260 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -75,6 +75,7 @@ struct ftdi_private {
         unsigned long last_dtr_rts;     /* saved modem control outputs */
         wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
         char prev_status, diff_status;        /* Used for TIOCMIWAIT */
+        char transmit_empty;    /* If transmitter is empty or not */
         struct usb_serial_port *port;
         __u16 interface;        /* FT2232C, FT2232H or FT4232H port interface
                                    (0 for FT232/245) */
@@ -1323,6 +1324,23 @@ check_and_exit:
         return 0;
 }
 
+static int get_lsr_info(struct usb_serial_port *port,
+                        struct serial_struct __user *retinfo)
+{
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        unsigned int result = 0;
+
+        if (!retinfo)
+                return -EFAULT;
+
+        if (priv->transmit_empty)
+                result = TIOCSER_TEMT;
+
+        if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
+                return -EFAULT;
+        return 0;
+}
+
 
 /* Determine type of FTDI chip based on USB config and descriptor. */
 static void ftdi_determine_type(struct usb_serial_port *port)
@@ -1872,6 +1890,12 @@ static int ftdi_process_packet(struct tty_struct *tty,
                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
         }
 
+        /* save if the transmitter is empty or not */
+        if (packet[1] & FTDI_RS_TEMT)
+                priv->transmit_empty = 1;
+        else
+                priv->transmit_empty = 0;
+
         len -= 2;
         if (!len)
                 return 0;       /* status only */
@@ -2235,6 +2259,9 @@ static int ftdi_ioctl(struct tty_struct *tty, struct file *file,
                         }
                 }
                 return 0;
+        case TIOCSERGETLSR:
+                return get_lsr_info(port, (struct serial_struct __user *)arg);
+                break;
         default:
                 break;
         }
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index ef2977d3a613..cdfb1868caef 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -989,6 +989,7 @@ static struct usb_serial_driver option_1port_device = {
         .set_termios       = usb_wwan_set_termios,
         .tiocmget          = usb_wwan_tiocmget,
         .tiocmset          = usb_wwan_tiocmset,
+        .ioctl             = usb_wwan_ioctl,
         .attach            = usb_wwan_startup,
         .disconnect        = usb_wwan_disconnect,
         .release           = usb_wwan_release,
diff --git a/drivers/usb/serial/ssu100.c b/drivers/usb/serial/ssu100.c
index f5312dd3331b..8359ec798959 100644
--- a/drivers/usb/serial/ssu100.c
+++ b/drivers/usb/serial/ssu100.c
@@ -79,7 +79,6 @@ struct ssu100_port_private {
         u8 shadowLSR;
         u8 shadowMSR;
         wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
-        unsigned short max_packet_size;
         struct async_icount icount;
 };
 
@@ -464,36 +463,6 @@ static int ssu100_ioctl(struct tty_struct *tty, struct file *file,
         return -ENOIOCTLCMD;
 }
 
-static void ssu100_set_max_packet_size(struct usb_serial_port *port)
-{
-        struct ssu100_port_private *priv = usb_get_serial_port_data(port);
-        struct usb_serial *serial = port->serial;
-        struct usb_device *udev = serial->dev;
-
-        struct usb_interface *interface = serial->interface;
-        struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
-
-        unsigned num_endpoints;
-        int i;
-        unsigned long flags;
-
-        num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
-        dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
-
-        for (i = 0; i < num_endpoints; i++) {
-                dev_info(&udev->dev, "Endpoint %d MaxPacketSize %d\n", i+1,
-                        interface->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
-                ep_desc = &interface->cur_altsetting->endpoint[i].desc;
-        }
-
-        /* set max packet size based on descriptor */
-        spin_lock_irqsave(&priv->status_lock, flags);
-        priv->max_packet_size = ep_desc->wMaxPacketSize;
-        spin_unlock_irqrestore(&priv->status_lock, flags);
-
-        dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size);
-}
-
 static int ssu100_attach(struct usb_serial *serial)
 {
         struct ssu100_port_private *priv;
@@ -511,7 +480,6 @@ static int ssu100_attach(struct usb_serial *serial)
         spin_lock_init(&priv->status_lock);
         init_waitqueue_head(&priv->delta_msr_wait);
         usb_set_serial_port_data(port, priv);
-        ssu100_set_max_packet_size(port);
 
         return ssu100_initdevice(serial->dev);
 }
@@ -641,13 +609,14 @@ static void ssu100_update_lsr(struct usb_serial_port *port, u8 lsr,
 
 }
 
-static int ssu100_process_packet(struct tty_struct *tty,
-                                 struct usb_serial_port *port,
-                                 struct ssu100_port_private *priv,
-                                 char *packet, int len)
+static int ssu100_process_packet(struct urb *urb,
+                                 struct tty_struct *tty)
 {
-        int i;
+        struct usb_serial_port *port = urb->context;
+        char *packet = (char *)urb->transfer_buffer;
         char flag = TTY_NORMAL;
+        u32 len = urb->actual_length;
+        int i;
         char *ch;
 
         dbg("%s - port %d", __func__, port->number);
@@ -685,12 +654,8 @@ static int ssu100_process_packet(struct tty_struct *tty,
 static void ssu100_process_read_urb(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
-        struct ssu100_port_private *priv = usb_get_serial_port_data(port);
-        char *data = (char *)urb->transfer_buffer;
         struct tty_struct *tty;
-        int count = 0;
-        int i;
-        int len;
+        int count;
 
         dbg("%s", __func__);
 
@@ -698,10 +663,7 @@ static void ssu100_process_read_urb(struct urb *urb)
         if (!tty)
                 return;
 
-        for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
-                len = min_t(int, urb->actual_length - i, priv->max_packet_size);
-                count += ssu100_process_packet(tty, port, priv, &data[i], len);
-        }
+        count = ssu100_process_packet(urb, tty);
 
         if (count)
                 tty_flip_buffer_push(tty);
@@ -717,8 +679,6 @@ static struct usb_serial_driver ssu100_device = {
         .id_table            = id_table,
         .usb_driver          = &ssu100_driver,
         .num_ports           = 1,
-        .bulk_in_size        = 256,
-        .bulk_out_size       = 256,
         .open                = ssu100_open,
         .close               = ssu100_close,
         .attach              = ssu100_attach,
diff --git a/drivers/usb/serial/usb-wwan.h b/drivers/usb/serial/usb-wwan.h
index 2be298a1305b..3ab77c5d9819 100644
--- a/drivers/usb/serial/usb-wwan.h
+++ b/drivers/usb/serial/usb-wwan.h
@@ -18,6 +18,8 @@ extern void usb_wwan_set_termios(struct tty_struct *tty,
 extern int usb_wwan_tiocmget(struct tty_struct *tty, struct file *file);
 extern int usb_wwan_tiocmset(struct tty_struct *tty, struct file *file,
                              unsigned int set, unsigned int clear);
+extern int usb_wwan_ioctl(struct tty_struct *tty, struct file *file,
+                          unsigned int cmd, unsigned long arg);
 extern int usb_wwan_send_setup(struct usb_serial_port *port);
 extern int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                           const unsigned char *buf, int count);
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index fbc946797801..b004b2a485c3 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -31,8 +31,10 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/serial.h>
 #include "usb-wwan.h"
 
 static int debug;
@@ -123,6 +125,83 @@ int usb_wwan_tiocmset(struct tty_struct *tty, struct file *file,
 }
 EXPORT_SYMBOL(usb_wwan_tiocmset);
 
+static int get_serial_info(struct usb_serial_port *port,
+                           struct serial_struct __user *retinfo)
+{
+        struct serial_struct tmp;
+
+        if (!retinfo)
+                return -EFAULT;
+
+        memset(&tmp, 0, sizeof(tmp));
+        tmp.line            = port->serial->minor;
+        tmp.port            = port->number;
+        tmp.baud_base       = tty_get_baud_rate(port->port.tty);
+        tmp.close_delay     = port->port.close_delay / 10;
+        tmp.closing_wait    = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
+                                 ASYNC_CLOSING_WAIT_NONE :
+                                 port->port.closing_wait / 10;
+
+        if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
+                return -EFAULT;
+        return 0;
+}
+
+static int set_serial_info(struct usb_serial_port *port,
+                           struct serial_struct __user *newinfo)
+{
+        struct serial_struct new_serial;
+        unsigned int closing_wait, close_delay;
+        int retval = 0;
+
+        if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
+                return -EFAULT;
+
+        close_delay = new_serial.close_delay * 10;
+        closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
+                        ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
+
+        mutex_lock(&port->port.mutex);
+
+        if (!capable(CAP_SYS_ADMIN)) {
+                if ((close_delay != port->port.close_delay) ||
+                    (closing_wait != port->port.closing_wait))
+                        retval = -EPERM;
+                else
+                        retval = -EOPNOTSUPP;
+        } else {
+                port->port.close_delay  = close_delay;
+                port->port.closing_wait = closing_wait;
+        }
+
+        mutex_unlock(&port->port.mutex);
+        return retval;
+}
+
+int usb_wwan_ioctl(struct tty_struct *tty, struct file *file,
+                   unsigned int cmd, unsigned long arg)
+{
+        struct usb_serial_port *port = tty->driver_data;
+
+        dbg("%s cmd 0x%04x", __func__, cmd);
+
+        switch (cmd) {
+        case TIOCGSERIAL:
+                return get_serial_info(port,
+                                       (struct serial_struct __user *) arg);
+        case TIOCSSERIAL:
+                return set_serial_info(port,
+                                       (struct serial_struct __user *) arg);
+        default:
+                break;
+        }
+
+        dbg("%s arg not supported", __func__);
+
+        return -ENOIOCTLCMD;
+}
+EXPORT_SYMBOL(usb_wwan_ioctl);
+
 /* Write */
 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                    const unsigned char *buf, int count)
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index 339fac3949df..23f0dd9c36d4 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -49,14 +49,17 @@ struct command_iu {
         __u8 cdb[16];   /* XXX: Overflow-checking tools may misunderstand */
 };
 
+/*
+ * Also used for the Read Ready and Write Ready IUs since they have the
+ * same first four bytes
+ */
 struct sense_iu {
         __u8 iu_id;
         __u8 rsvd1;
         __be16 tag;
         __be16 status_qual;
         __u8 status;
-        __u8 service_response;
-        __u8 rsvd8[6];
+        __u8 rsvd7[7];
         __be16 len;
         __u8 sense[SCSI_SENSE_BUFFERSIZE];
 };
@@ -97,8 +100,8 @@ struct uas_dev_info {
 };
 
 enum {
-        ALLOC_SENSE_URB         = (1 << 0),
-        SUBMIT_SENSE_URB        = (1 << 1),
+        ALLOC_STATUS_URB        = (1 << 0),
+        SUBMIT_STATUS_URB       = (1 << 1),
         ALLOC_DATA_IN_URB       = (1 << 2),
         SUBMIT_DATA_IN_URB      = (1 << 3),
         ALLOC_DATA_OUT_URB      = (1 << 4),
@@ -112,7 +115,7 @@ struct uas_cmd_info {
         unsigned int state;
         unsigned int stream;
         struct urb *cmd_urb;
-        struct urb *sense_urb;
+        struct urb *status_urb;
         struct urb *data_in_urb;
         struct urb *data_out_urb;
         struct list_head list;
@@ -138,7 +141,7 @@ static void uas_do_work(struct work_struct *work)
                 struct scsi_pointer *scp = (void *)cmdinfo;
                 struct scsi_cmnd *cmnd = container_of(scp,
                                                         struct scsi_cmnd, SCp);
-                uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_KERNEL);
+                uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO);
         }
 }
 
@@ -204,7 +207,7 @@ static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
         int err;
 
-        cmdinfo->state = direction | SUBMIT_SENSE_URB;
+        cmdinfo->state = direction | SUBMIT_STATUS_URB;
         err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
         if (err) {
                 spin_lock(&uas_work_lock);
@@ -294,7 +297,7 @@ static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
         if (!urb)
                 goto out;
 
-        iu = kmalloc(sizeof(*iu), gfp);
+        iu = kzalloc(sizeof(*iu), gfp);
         if (!iu)
                 goto free;
 
@@ -325,7 +328,7 @@ static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
         if (len < 0)
                 len = 0;
         len = ALIGN(len, 4);
-        iu = kmalloc(sizeof(*iu) + len, gfp);
+        iu = kzalloc(sizeof(*iu) + len, gfp);
         if (!iu)
                 goto free;
 
@@ -357,21 +360,21 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 {
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
 
-        if (cmdinfo->state & ALLOC_SENSE_URB) {
-                cmdinfo->sense_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
-                                                        cmdinfo->stream);
-                if (!cmdinfo->sense_urb)
+        if (cmdinfo->state & ALLOC_STATUS_URB) {
+                cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
+                                                          cmdinfo->stream);
+                if (!cmdinfo->status_urb)
                         return SCSI_MLQUEUE_DEVICE_BUSY;
-                cmdinfo->state &= ~ALLOC_SENSE_URB;
+                cmdinfo->state &= ~ALLOC_STATUS_URB;
         }
 
-        if (cmdinfo->state & SUBMIT_SENSE_URB) {
-                if (usb_submit_urb(cmdinfo->sense_urb, gfp)) {
+        if (cmdinfo->state & SUBMIT_STATUS_URB) {
+                if (usb_submit_urb(cmdinfo->status_urb, gfp)) {
                         scmd_printk(KERN_INFO, cmnd,
                                         "sense urb submission failure\n");
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
-                cmdinfo->state &= ~SUBMIT_SENSE_URB;
+                cmdinfo->state &= ~SUBMIT_STATUS_URB;
         }
 
         if (cmdinfo->state & ALLOC_DATA_IN_URB) {
@@ -440,7 +443,7 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
 
         BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
 
-        if (!cmdinfo->sense_urb && sdev->current_cmnd)
+        if (!cmdinfo->status_urb && sdev->current_cmnd)
                 return SCSI_MLQUEUE_DEVICE_BUSY;
 
         if (blk_rq_tagged(cmnd->request)) {
@@ -452,7 +455,7 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
 
         cmnd->scsi_done = done;
 
-        cmdinfo->state = ALLOC_SENSE_URB | SUBMIT_SENSE_URB |
+        cmdinfo->state = ALLOC_STATUS_URB | SUBMIT_STATUS_URB |
                         ALLOC_CMD_URB | SUBMIT_CMD_URB;
 
         switch (cmnd->sc_data_direction) {
@@ -475,8 +478,8 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
         err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
         if (err) {
                 /* If we did nothing, give up now */
-                if (cmdinfo->state & SUBMIT_SENSE_URB) {
-                        usb_free_urb(cmdinfo->sense_urb);
+                if (cmdinfo->state & SUBMIT_STATUS_URB) {
+                        usb_free_urb(cmdinfo->status_urb);
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
                 spin_lock(&uas_work_lock);
@@ -578,6 +581,34 @@ static struct usb_device_id uas_usb_ids[] = {
 };
 MODULE_DEVICE_TABLE(usb, uas_usb_ids);
 
+static int uas_is_interface(struct usb_host_interface *intf)
+{
+        return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE &&
+                intf->desc.bInterfaceSubClass == USB_SC_SCSI &&
+                intf->desc.bInterfaceProtocol == USB_PR_UAS);
+}
+
+static int uas_switch_interface(struct usb_device *udev,
+                                                struct usb_interface *intf)
+{
+        int i;
+
+        if (uas_is_interface(intf->cur_altsetting))
+                return 0;
+
+        for (i = 0; i < intf->num_altsetting; i++) {
+                struct usb_host_interface *alt = &intf->altsetting[i];
+                if (alt == intf->cur_altsetting)
+                        continue;
+                if (uas_is_interface(alt))
+                        return usb_set_interface(udev,
+                                                alt->desc.bInterfaceNumber,
+                                                alt->desc.bAlternateSetting);
+        }
+
+        return -ENODEV;
+}
+
 static void uas_configure_endpoints(struct uas_dev_info *devinfo)
 {
         struct usb_host_endpoint *eps[4] = { };
@@ -651,13 +682,8 @@ static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
         struct uas_dev_info *devinfo;
         struct usb_device *udev = interface_to_usbdev(intf);
 
-        if (id->bInterfaceProtocol == 0x50) {
-                int ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
-/* XXX: Shouldn't assume that 1 is the alternative we want */
-                int ret = usb_set_interface(udev, ifnum, 1);
-                if (ret)
-                        return -ENODEV;
-        }
+        if (uas_switch_interface(udev, intf))
+                return -ENODEV;
 
         devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
         if (!devinfo)
diff --git a/drivers/uwb/i1480/i1480-est.c b/drivers/uwb/i1480/i1480-est.c
index f2eb4d8b76c9..d5de5e131d47 100644
--- a/drivers/uwb/i1480/i1480-est.c
+++ b/drivers/uwb/i1480/i1480-est.c
@@ -91,7 +91,7 @@ MODULE_LICENSE("GPL");
  *
  * [so we are loaded when this kind device is connected]
  */
-static struct usb_device_id i1480_est_id_table[] = {
+static struct usb_device_id __used i1480_est_id_table[] = {
         { USB_DEVICE(0x8086, 0xdf3b), },
         { USB_DEVICE(0x8086, 0x0c3b), },
         { },
diff --git a/drivers/uwb/umc-dev.c b/drivers/uwb/umc-dev.c
index 43ea9982e687..ccd2184e05d2 100644
--- a/drivers/uwb/umc-dev.c
+++ b/drivers/uwb/umc-dev.c
@@ -54,11 +54,8 @@ int umc_device_register(struct umc_dev *umc)
 
         err = request_resource(umc->resource.parent, &umc->resource);
         if (err < 0) {
-                dev_err(&umc->dev, "can't allocate resource range "
-                        "%016Lx to %016Lx: %d\n",
-                        (unsigned long long)umc->resource.start,
-                        (unsigned long long)umc->resource.end,
-                        err);
+                dev_err(&umc->dev, "can't allocate resource range %pR: %d\n",
+                        &umc->resource, err);
                 goto error_request_resource;
         }
 
diff --git a/drivers/uwb/whc-rc.c b/drivers/uwb/whc-rc.c
index 73495583c444..70a004aa19db 100644
--- a/drivers/uwb/whc-rc.c
+++ b/drivers/uwb/whc-rc.c
@@ -449,7 +449,7 @@ static int whcrc_post_reset(struct umc_dev *umc)
 }
 
 /* PCI device ID's that we handle [so it gets loaded] */
-static struct pci_device_id whcrc_id_table[] = {
+static struct pci_device_id __used whcrc_id_table[] = {
         { PCI_DEVICE_CLASS(PCI_CLASS_WIRELESS_WHCI, ~0) },
         { /* empty last entry */ }
 };
diff --git a/fs/9p/acl.c b/fs/9p/acl.c
index 12d602351dbe..6e58c4ca1e6e 100644
--- a/fs/9p/acl.c
+++ b/fs/9p/acl.c
@@ -91,11 +91,14 @@ static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type)
         return acl;
 }
 
-int v9fs_check_acl(struct inode *inode, int mask)
+int v9fs_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
         struct posix_acl *acl;
         struct v9fs_session_info *v9ses;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         v9ses = v9fs_inode2v9ses(inode);
         if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) {
                 /*
diff --git a/fs/9p/acl.h b/fs/9p/acl.h
index 59e18c2e8c7e..7ef3ac9f6d95 100644
--- a/fs/9p/acl.h
+++ b/fs/9p/acl.h
@@ -16,7 +16,7 @@
 
 #ifdef CONFIG_9P_FS_POSIX_ACL
 extern int v9fs_get_acl(struct inode *, struct p9_fid *);
-extern int v9fs_check_acl(struct inode *inode, int mask);
+extern int v9fs_check_acl(struct inode *inode, int mask, unsigned int flags);
 extern int v9fs_acl_chmod(struct dentry *);
 extern int v9fs_set_create_acl(struct dentry *,
                                struct posix_acl *, struct posix_acl *);
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index cbf4e50f3933..466d2a4fc5cb 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -51,7 +51,7 @@
  *
  */
 
-static int v9fs_dentry_delete(struct dentry *dentry)
+static int v9fs_dentry_delete(const struct dentry *dentry)
 {
         P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_name.name,
                                                                         dentry);
@@ -68,7 +68,7 @@ static int v9fs_dentry_delete(struct dentry *dentry)
  *
  */
 
-static int v9fs_cached_dentry_delete(struct dentry *dentry)
+static int v9fs_cached_dentry_delete(const struct dentry *dentry)
 {
         struct inode *inode = dentry->d_inode;
         P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_name.name,
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 34bf71b56542..59782981b225 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -237,10 +237,17 @@ struct inode *v9fs_alloc_inode(struct super_block *sb)
  *
  */
 
-void v9fs_destroy_inode(struct inode *inode)
+static void v9fs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(vcookie_cache, v9fs_inode2cookie(inode));
 }
+
+void v9fs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, v9fs_i_callback);
+}
 #endif
 
 /**
@@ -270,11 +277,11 @@ static struct dentry *v9fs_dentry_from_dir_inode(struct inode *inode)
 {
         struct dentry *dentry;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&inode->i_lock);
         /* Directory should have only one entry. */
         BUG_ON(S_ISDIR(inode->i_mode) && !list_is_singular(&inode->i_dentry));
         dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
         return dentry;
 }
 
@@ -628,9 +635,9 @@ v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
         }
 
         if (v9ses->cache)
-                dentry->d_op = &v9fs_cached_dentry_operations;
+                d_set_d_op(dentry, &v9fs_cached_dentry_operations);
         else
-                dentry->d_op = &v9fs_dentry_operations;
+                d_set_d_op(dentry, &v9fs_dentry_operations);
 
         d_instantiate(dentry, inode);
         err = v9fs_fid_add(dentry, fid);
@@ -742,7 +749,7 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int omode,
                                 err);
                         goto error;
                 }
-                dentry->d_op = &v9fs_cached_dentry_operations;
+                d_set_d_op(dentry, &v9fs_cached_dentry_operations);
                 d_instantiate(dentry, inode);
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
@@ -760,7 +767,7 @@ v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int omode,
                         err = PTR_ERR(inode);
                         goto error;
                 }
-                dentry->d_op = &v9fs_dentry_operations;
+                d_set_d_op(dentry, &v9fs_dentry_operations);
                 d_instantiate(dentry, inode);
         }
         /* Now set the ACL based on the default value */
@@ -949,7 +956,7 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                                 err);
                         goto error;
                 }
-                dentry->d_op = &v9fs_cached_dentry_operations;
+                d_set_d_op(dentry, &v9fs_cached_dentry_operations);
                 d_instantiate(dentry, inode);
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
@@ -966,7 +973,7 @@ static int v9fs_vfs_mkdir_dotl(struct inode *dir,
                         err = PTR_ERR(inode);
                         goto error;
                 }
-                dentry->d_op = &v9fs_dentry_operations;
+                d_set_d_op(dentry, &v9fs_dentry_operations);
                 d_instantiate(dentry, inode);
         }
         /* Now set the ACL based on the default value */
@@ -1034,9 +1041,9 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 
 inst_out:
         if (v9ses->cache)
-                dentry->d_op = &v9fs_cached_dentry_operations;
+                d_set_d_op(dentry, &v9fs_cached_dentry_operations);
         else
-                dentry->d_op = &v9fs_dentry_operations;
+                d_set_d_op(dentry, &v9fs_dentry_operations);
 
         d_add(dentry, inode);
         return NULL;
@@ -1702,7 +1709,7 @@ v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
                                         err);
                         goto error;
                 }
-                dentry->d_op = &v9fs_cached_dentry_operations;
+                d_set_d_op(dentry, &v9fs_cached_dentry_operations);
                 d_instantiate(dentry, inode);
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
@@ -1715,7 +1722,7 @@ v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
                         err = PTR_ERR(inode);
                         goto error;
                 }
-                dentry->d_op = &v9fs_dentry_operations;
+                d_set_d_op(dentry, &v9fs_dentry_operations);
                 d_instantiate(dentry, inode);
         }
 
@@ -1849,7 +1856,7 @@ v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
                 ihold(old_dentry->d_inode);
         }
 
-        dentry->d_op = old_dentry->d_op;
+        d_set_d_op(dentry, old_dentry->d_op);
         d_instantiate(dentry, old_dentry->d_inode);
 
         return err;
@@ -1973,7 +1980,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
                                 err);
                         goto error;
                 }
-                dentry->d_op = &v9fs_cached_dentry_operations;
+                d_set_d_op(dentry, &v9fs_cached_dentry_operations);
                 d_instantiate(dentry, inode);
                 err = v9fs_fid_add(dentry, fid);
                 if (err < 0)
@@ -1989,7 +1996,7 @@ v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int omode,
                         err = PTR_ERR(inode);
                         goto error;
                 }
-                dentry->d_op = &v9fs_dentry_operations;
+                d_set_d_op(dentry, &v9fs_dentry_operations);
                 d_instantiate(dentry, inode);
         }
         /* Now set the ACL based on the default value */
diff --git a/fs/adfs/dir.c b/fs/adfs/dir.c
index f4287e4de744..bf7693c384f9 100644
--- a/fs/adfs/dir.c
+++ b/fs/adfs/dir.c
@@ -201,7 +201,8 @@ const struct file_operations adfs_dir_operations = {
 };
 
 static int
-adfs_hash(struct dentry *parent, struct qstr *qstr)
+adfs_hash(const struct dentry *parent, const struct inode *inode,
+                struct qstr *qstr)
 {
         const unsigned int name_len = ADFS_SB(parent->d_sb)->s_namelen;
         const unsigned char *name;
@@ -237,17 +238,19 @@ adfs_hash(struct dentry *parent, struct qstr *qstr)
  * requirements of the underlying filesystem.
  */
 static int
-adfs_compare(struct dentry *parent, struct qstr *entry, struct qstr *name)
+adfs_compare(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
         int i;
 
-        if (entry->len != name->len)
+        if (len != name->len)
                 return 1;
 
         for (i = 0; i < name->len; i++) {
                 char a, b;
 
-                a = entry->name[i];
+                a = str[i];
                 b = name->name[i];
 
                 if (a >= 'A' && a <= 'Z')
@@ -273,7 +276,7 @@ adfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         struct object_info obj;
         int error;
 
-        dentry->d_op = &adfs_dentry_operations; 
+        d_set_d_op(dentry, &adfs_dentry_operations);
         lock_kernel();
         error = adfs_dir_lookup_byname(dir, &dentry->d_name, &obj);
         if (error == 0) {
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 959dbff2d42d..a4041b52fbca 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -240,11 +240,18 @@ static struct inode *adfs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void adfs_destroy_inode(struct inode *inode)
+static void adfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(adfs_inode_cachep, ADFS_I(inode));
 }
 
+static void adfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, adfs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct adfs_inode_info *ei = (struct adfs_inode_info *) foo;
@@ -477,7 +484,7 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
                 adfs_error(sb, "get root inode failed\n");
                 goto error;
         } else
-                sb->s_root->d_op = &adfs_dentry_operations;
+                d_set_d_op(sb->s_root, &adfs_dentry_operations);
         unlock_kernel();
         return 0;
 
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 7d0f0a30f7a3..3a4557e8325c 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -128,7 +128,7 @@ affs_fix_dcache(struct dentry *dentry, u32 entry_ino)
         void *data = dentry->d_fsdata;
         struct list_head *head, *next;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&inode->i_lock);
         head = &inode->i_dentry;
         next = head->next;
         while (next != head) {
@@ -139,7 +139,7 @@ affs_fix_dcache(struct dentry *dentry, u32 entry_ino)
                 }
                 next = next->next;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
 }
 
 
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 914d1c0bc07a..944a4042fb65 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -13,11 +13,19 @@
 typedef int (*toupper_t)(int);
 
 static int       affs_toupper(int ch);
-static int       affs_hash_dentry(struct dentry *, struct qstr *);
-static int       affs_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
+static int       affs_hash_dentry(const struct dentry *,
+                const struct inode *, struct qstr *);
+static int       affs_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
 static int       affs_intl_toupper(int ch);
-static int       affs_intl_hash_dentry(struct dentry *, struct qstr *);
-static int       affs_intl_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
+static int       affs_intl_hash_dentry(const struct dentry *,
+                const struct inode *, struct qstr *);
+static int       affs_intl_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
 
 const struct dentry_operations affs_dentry_operations = {
         .d_hash         = affs_hash_dentry,
@@ -58,13 +66,13 @@ affs_get_toupper(struct super_block *sb)
  * Note: the dentry argument is the parent dentry.
  */
 static inline int
-__affs_hash_dentry(struct dentry *dentry, struct qstr *qstr, toupper_t toupper)
+__affs_hash_dentry(struct qstr *qstr, toupper_t toupper)
 {
         const u8 *name = qstr->name;
         unsigned long hash;
         int i;
 
-        i = affs_check_name(qstr->name,qstr->len);
+        i = affs_check_name(qstr->name, qstr->len);
         if (i)
                 return i;
 
@@ -78,39 +86,41 @@ __affs_hash_dentry(struct dentry *dentry, struct qstr *qstr, toupper_t toupper)
 }
 
 static int
-affs_hash_dentry(struct dentry *dentry, struct qstr *qstr)
+affs_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
-        return __affs_hash_dentry(dentry, qstr, affs_toupper);
+        return __affs_hash_dentry(qstr, affs_toupper);
 }
 static int
-affs_intl_hash_dentry(struct dentry *dentry, struct qstr *qstr)
+affs_intl_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
-        return __affs_hash_dentry(dentry, qstr, affs_intl_toupper);
+        return __affs_hash_dentry(qstr, affs_intl_toupper);
 }
 
-static inline int
-__affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b, toupper_t toupper)
+static inline int __affs_compare_dentry(unsigned int len,
+                const char *str, const struct qstr *name, toupper_t toupper)
 {
-        const u8 *aname = a->name;
-        const u8 *bname = b->name;
-        int len;
+        const u8 *aname = str;
+        const u8 *bname = name->name;
 
-        /* 'a' is the qstr of an already existing dentry, so the name
-         * must be valid. 'b' must be validated first.
+        /*
+         * 'str' is the name of an already existing dentry, so the name
+         * must be valid. 'name' must be validated first.
          */
 
-        if (affs_check_name(b->name,b->len))
+        if (affs_check_name(name->name, name->len))
                 return 1;
 
-        /* If the names are longer than the allowed 30 chars,
+        /*
+         * If the names are longer than the allowed 30 chars,
          * the excess is ignored, so their length may differ.
          */
-        len = a->len;
         if (len >= 30) {
-                if (b->len < 30)
+                if (name->len < 30)
                         return 1;
                 len = 30;
-        } else if (len != b->len)
+        } else if (len != name->len)
                 return 1;
 
         for (; len > 0; len--)
@@ -121,14 +131,18 @@ __affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b, tou
 }
 
 static int
-affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
+affs_compare_dentry(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        return __affs_compare_dentry(dentry, a, b, affs_toupper);
+        return __affs_compare_dentry(len, str, name, affs_toupper);
 }
 static int
-affs_intl_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
+affs_intl_compare_dentry(const struct dentry *parent,const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        return __affs_compare_dentry(dentry, a, b, affs_intl_toupper);
+        return __affs_compare_dentry(len, str, name, affs_intl_toupper);
 }
 
 /*
@@ -226,7 +240,7 @@ affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
                 if (IS_ERR(inode))
                         return ERR_CAST(inode);
         }
-        dentry->d_op = AFFS_SB(sb)->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;
+        d_set_d_op(dentry, AFFS_SB(sb)->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations);
         d_add(dentry, inode);
         return NULL;
 }
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 0cf7f4384cbd..d39081bbe7ce 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -95,11 +95,18 @@ static struct inode *affs_alloc_inode(struct super_block *sb)
         return &i->vfs_inode;
 }
 
-static void affs_destroy_inode(struct inode *inode)
+static void affs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(affs_inode_cachep, AFFS_I(inode));
 }
 
+static void affs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, affs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct affs_inode_info *ei = (struct affs_inode_info *) foo;
@@ -475,7 +482,7 @@ got_root:
                 printk(KERN_ERR "AFFS: Get root inode failed\n");
                 goto out_error;
         }
-        sb->s_root->d_op = &affs_dentry_operations;
+        d_set_d_op(sb->s_root, &affs_dentry_operations);
 
         pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
         return 0;
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 5439e1bc9a86..34a3263d60a4 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/fs.h>
+#include <linux/namei.h>
 #include <linux/pagemap.h>
 #include <linux/ctype.h>
 #include <linux/sched.h>
@@ -23,7 +24,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
 static int afs_dir_open(struct inode *inode, struct file *file);
 static int afs_readdir(struct file *file, void *dirent, filldir_t filldir);
 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
-static int afs_d_delete(struct dentry *dentry);
+static int afs_d_delete(const struct dentry *dentry);
 static void afs_d_release(struct dentry *dentry);
 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
                                   loff_t fpos, u64 ino, unsigned dtype);
@@ -581,7 +582,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
         }
 
 success:
-        dentry->d_op = &afs_fs_dentry_operations;
+        d_set_d_op(dentry, &afs_fs_dentry_operations);
 
         d_add(dentry, inode);
         _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%llu }",
@@ -607,6 +608,9 @@ static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
         void *dir_version;
         int ret;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
         vnode = AFS_FS_I(dentry->d_inode);
 
         if (dentry->d_inode)
@@ -730,7 +734,7 @@ out_bad:
  * - called from dput() when d_count is going to 0.
  * - return 1 to request dentry be unhashed, 0 otherwise
  */
-static int afs_d_delete(struct dentry *dentry)
+static int afs_d_delete(const struct dentry *dentry)
 {
         _enter("%s", dentry->d_name.name);
 
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index cca8eef736fc..6d4bc1c8ff60 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -624,7 +624,7 @@ extern void afs_clear_permits(struct afs_vnode *);
 extern void afs_cache_permit(struct afs_vnode *, struct key *, long);
 extern void afs_zap_permits(struct rcu_head *);
 extern struct key *afs_request_key(struct afs_cell *);
-extern int afs_permission(struct inode *, int);
+extern int afs_permission(struct inode *, int, unsigned int);
 
 /*
  * server.c
diff --git a/fs/afs/security.c b/fs/afs/security.c
index bb4ed144d0e4..f44b9d355377 100644
--- a/fs/afs/security.c
+++ b/fs/afs/security.c
@@ -285,13 +285,16 @@ static int afs_check_permit(struct afs_vnode *vnode, struct key *key,
  * - AFS ACLs are attached to directories only, and a file is controlled by its
  *   parent directory's ACL
  */
-int afs_permission(struct inode *inode, int mask)
+int afs_permission(struct inode *inode, int mask, unsigned int flags)
 {
         struct afs_vnode *vnode = AFS_FS_I(inode);
         afs_access_t uninitialized_var(access);
         struct key *key;
         int ret;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         _enter("{{%x:%u},%lx},%x,",
                vnode->fid.vid, vnode->fid.vnode, vnode->flags, mask);
 
@@ -347,7 +350,7 @@ int afs_permission(struct inode *inode, int mask)
         }
 
         key_put(key);
-        ret = generic_permission(inode, mask, NULL);
+        ret = generic_permission(inode, mask, flags, NULL);
         _leave(" = %d", ret);
         return ret;
 
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 27201cffece4..f901a9d7c111 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -498,6 +498,14 @@ static struct inode *afs_alloc_inode(struct super_block *sb)
         return &vnode->vfs_inode;
 }
 
+static void afs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        struct afs_vnode *vnode = AFS_FS_I(inode);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(afs_inode_cachep, vnode);
+}
+
 /*
  * destroy an AFS inode struct
  */
@@ -511,7 +519,7 @@ static void afs_destroy_inode(struct inode *inode)
 
         ASSERTCMP(vnode->server, ==, NULL);
 
-        kmem_cache_free(afs_inode_cachep, vnode);
+        call_rcu(&inode->i_rcu, afs_i_callback);
         atomic_dec(&afs_count_active_inodes);
 }
 
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 57ce55b2564c..5fd38112a6ca 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -102,7 +102,7 @@ struct file *anon_inode_getfile(const char *name,
         this.name = name;
         this.len = strlen(name);
         this.hash = 0;
-        path.dentry = d_alloc(anon_inode_mnt->mnt_sb->s_root, &this);
+        path.dentry = d_alloc_pseudo(anon_inode_mnt->mnt_sb, &this);
         if (!path.dentry)
                 goto err_module;
 
@@ -113,7 +113,7 @@ struct file *anon_inode_getfile(const char *name,
          */
         ihold(anon_inode_inode);
 
-        path.dentry->d_op = &anon_inodefs_dentry_operations;
+        d_set_d_op(path.dentry, &anon_inodefs_dentry_operations);
         d_instantiate(path.dentry, anon_inode_inode);
 
         error = -ENFILE;
@@ -232,7 +232,7 @@ static int __init anon_inode_init(void)
         return 0;
 
 err_mntput:
-        mntput(anon_inode_mnt);
+        mntput_long(anon_inode_mnt);
 err_unregister_filesystem:
         unregister_filesystem(&anon_inode_fs_type);
 err_exit:
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index 3d283abf67d7..0fffe1c24cec 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -16,6 +16,7 @@
 #include <linux/auto_fs4.h>
 #include <linux/auto_dev-ioctl.h>
 #include <linux/mutex.h>
+#include <linux/spinlock.h>
 #include <linux/list.h>
 
 /* This is the range of ioctl() numbers we claim as ours */
@@ -60,6 +61,8 @@ do {							\
                 current->pid, __func__, ##args);        \
 } while (0)
 
+extern spinlock_t autofs4_lock;
+
 /* 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
@@ -254,17 +257,15 @@ static inline int simple_positive(struct dentry *dentry)
         return dentry->d_inode && !d_unhashed(dentry);
 }
 
-static inline int __simple_empty(struct dentry *dentry)
+static inline void __autofs4_add_expiring(struct dentry *dentry)
 {
-        struct dentry *child;
-        int ret = 0;
-
-        list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
-                if (simple_positive(child))
-                        goto out;
-        ret = 1;
-out:
-        return ret;
+        struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
+        struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        if (ino) {
+                if (list_empty(&ino->expiring))
+                        list_add(&ino->expiring, &sbi->expiring_list);
+        }
+        return;
 }
 
 static inline void autofs4_add_expiring(struct dentry *dentry)
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index a796c9417fb1..cc1d01365905 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -91,24 +91,64 @@ done:
 }
 
 /*
- * Calculate next entry in top down tree traversal.
- * From next_mnt in namespace.c - elegant.
+ * Calculate and dget next entry in top down tree traversal.
  */
-static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
+static struct dentry *get_next_positive_dentry(struct dentry *prev,
+                                                struct dentry *root)
 {
-        struct list_head *next = p->d_subdirs.next;
+        struct list_head *next;
+        struct dentry *p, *ret;
+
+        if (prev == NULL)
+                return dget(prev);
 
+        spin_lock(&autofs4_lock);
+relock:
+        p = prev;
+        spin_lock(&p->d_lock);
+again:
+        next = p->d_subdirs.next;
         if (next == &p->d_subdirs) {
                 while (1) {
-                        if (p == root)
+                        struct dentry *parent;
+
+                        if (p == root) {
+                                spin_unlock(&p->d_lock);
+                                spin_unlock(&autofs4_lock);
+                                dput(prev);
                                 return NULL;
+                        }
+
+                        parent = p->d_parent;
+                        if (!spin_trylock(&parent->d_lock)) {
+                                spin_unlock(&p->d_lock);
+                                cpu_relax();
+                                goto relock;
+                        }
+                        spin_unlock(&p->d_lock);
                         next = p->d_u.d_child.next;
-                        if (next != &p->d_parent->d_subdirs)
+                        p = parent;
+                        if (next != &parent->d_subdirs)
                                 break;
-                        p = p->d_parent;
                 }
         }
-        return list_entry(next, struct dentry, d_u.d_child);
+        ret = list_entry(next, struct dentry, d_u.d_child);
+
+        spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
+        /* Negative dentry - try next */
+        if (!simple_positive(ret)) {
+                spin_unlock(&ret->d_lock);
+                p = ret;
+                goto again;
+        }
+        dget_dlock(ret);
+        spin_unlock(&ret->d_lock);
+        spin_unlock(&p->d_lock);
+        spin_unlock(&autofs4_lock);
+
+        dput(prev);
+
+        return ret;
 }
 
 /*
@@ -158,18 +198,11 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
         if (!simple_positive(top))
                 return 1;
 
-        spin_lock(&dcache_lock);
-        for (p = top; p; p = next_dentry(p, top)) {
-                /* Negative dentry - give up */
-                if (!simple_positive(p))
-                        continue;
-
+        p = NULL;
+        while ((p = get_next_positive_dentry(p, top))) {
                 DPRINTK("dentry %p %.*s",
                         p, (int) p->d_name.len, p->d_name.name);
 
-                p = dget(p);
-                spin_unlock(&dcache_lock);
-
                 /*
                  * Is someone visiting anywhere in the subtree ?
                  * If there's no mount we need to check the usage
@@ -198,16 +231,13 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
                         else
                                 ino_count++;
 
-                        if (atomic_read(&p->d_count) > ino_count) {
+                        if (p->d_count > ino_count) {
                                 top_ino->last_used = jiffies;
                                 dput(p);
                                 return 1;
                         }
                 }
-                dput(p);
-                spin_lock(&dcache_lock);
         }
-        spin_unlock(&dcache_lock);
 
         /* Timeout of a tree mount is ultimately determined by its top dentry */
         if (!autofs4_can_expire(top, timeout, do_now))
@@ -226,32 +256,21 @@ static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
         DPRINTK("parent %p %.*s",
                 parent, (int)parent->d_name.len, parent->d_name.name);
 
-        spin_lock(&dcache_lock);
-        for (p = parent; p; p = next_dentry(p, parent)) {
-                /* Negative dentry - give up */
-                if (!simple_positive(p))
-                        continue;
-
+        p = NULL;
+        while ((p = get_next_positive_dentry(p, parent))) {
                 DPRINTK("dentry %p %.*s",
                         p, (int) p->d_name.len, p->d_name.name);
 
-                p = dget(p);
-                spin_unlock(&dcache_lock);
-
                 if (d_mountpoint(p)) {
                         /* Can we umount this guy */
                         if (autofs4_mount_busy(mnt, p))
-                                goto cont;
+                                continue;
 
                         /* Can we expire this guy */
                         if (autofs4_can_expire(p, timeout, do_now))
                                 return p;
                 }
-cont:
-                dput(p);
-                spin_lock(&dcache_lock);
         }
-        spin_unlock(&dcache_lock);
         return NULL;
 }
 
@@ -276,7 +295,9 @@ struct dentry *autofs4_expire_direct(struct super_block *sb,
                 struct autofs_info *ino = autofs4_dentry_ino(root);
                 if (d_mountpoint(root)) {
                         ino->flags |= AUTOFS_INF_MOUNTPOINT;
-                        root->d_mounted--;
+                        spin_lock(&root->d_lock);
+                        root->d_flags &= ~DCACHE_MOUNTED;
+                        spin_unlock(&root->d_lock);
                 }
                 ino->flags |= AUTOFS_INF_EXPIRING;
                 init_completion(&ino->expire_complete);
@@ -302,8 +323,8 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
 {
         unsigned long timeout;
         struct dentry *root = sb->s_root;
+        struct dentry *dentry;
         struct dentry *expired = NULL;
-        struct list_head *next;
         int do_now = how & AUTOFS_EXP_IMMEDIATE;
         int exp_leaves = how & AUTOFS_EXP_LEAVES;
         struct autofs_info *ino;
@@ -315,23 +336,8 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
         now = jiffies;
         timeout = sbi->exp_timeout;
 
-        spin_lock(&dcache_lock);
-        next = root->d_subdirs.next;
-
-        /* On exit from the loop expire is set to a dgot dentry
-         * to expire or it's NULL */
-        while ( next != &root->d_subdirs ) {
-                struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
-
-                /* Negative dentry - give up */
-                if (!simple_positive(dentry)) {
-                        next = next->next;
-                        continue;
-                }
-
-                dentry = dget(dentry);
-                spin_unlock(&dcache_lock);
-
+        dentry = NULL;
+        while ((dentry = get_next_positive_dentry(dentry, root))) {
                 spin_lock(&sbi->fs_lock);
                 ino = autofs4_dentry_ino(dentry);
 
@@ -347,7 +353,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
 
                         /* Path walk currently on this dentry? */
                         ino_count = atomic_read(&ino->count) + 2;
-                        if (atomic_read(&dentry->d_count) > ino_count)
+                        if (dentry->d_count > ino_count)
                                 goto next;
 
                         /* Can we umount this guy */
@@ -369,7 +375,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
                 if (!exp_leaves) {
                         /* Path walk currently on this dentry? */
                         ino_count = atomic_read(&ino->count) + 1;
-                        if (atomic_read(&dentry->d_count) > ino_count)
+                        if (dentry->d_count > ino_count)
                                 goto next;
 
                         if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
@@ -383,7 +389,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
                 } else {
                         /* Path walk currently on this dentry? */
                         ino_count = atomic_read(&ino->count) + 1;
-                        if (atomic_read(&dentry->d_count) > ino_count)
+                        if (dentry->d_count > ino_count)
                                 goto next;
 
                         expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
@@ -394,11 +400,7 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
                 }
 next:
                 spin_unlock(&sbi->fs_lock);
-                dput(dentry);
-                spin_lock(&dcache_lock);
-                next = next->next;
         }
-        spin_unlock(&dcache_lock);
         return NULL;
 
 found:
@@ -408,9 +410,13 @@ found:
         ino->flags |= AUTOFS_INF_EXPIRING;
         init_completion(&ino->expire_complete);
         spin_unlock(&sbi->fs_lock);
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&expired->d_parent->d_lock);
+        spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
         list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&expired->d_lock);
+        spin_unlock(&expired->d_parent->d_lock);
+        spin_unlock(&autofs4_lock);
         return expired;
 }
 
@@ -499,7 +505,14 @@ int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
 
                 spin_lock(&sbi->fs_lock);
                 if (ino->flags & AUTOFS_INF_MOUNTPOINT) {
-                        sb->s_root->d_mounted++;
+                        spin_lock(&sb->s_root->d_lock);
+                        /*
+                         * If we haven't been expired away, then reset
+                         * mounted status.
+                         */
+                        if (mnt->mnt_parent != mnt)
+                                sb->s_root->d_flags |= DCACHE_MOUNTED;
+                        spin_unlock(&sb->s_root->d_lock);
                         ino->flags &= ~AUTOFS_INF_MOUNTPOINT;
                 }
                 ino->flags &= ~AUTOFS_INF_EXPIRING;
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index ac87e49fa706..a7bdb9dcac84 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -309,7 +309,7 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
                 goto fail_iput;
         pipe = NULL;
 
-        root->d_op = &autofs4_sb_dentry_operations;
+        d_set_d_op(root, &autofs4_sb_dentry_operations);
         root->d_fsdata = ino;
 
         /* Can this call block? */
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index d34896cfb19f..651e4ef563b1 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -23,6 +23,8 @@
 
 #include "autofs_i.h"
 
+DEFINE_SPINLOCK(autofs4_lock);
+
 static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
 static int autofs4_dir_unlink(struct inode *,struct dentry *);
 static int autofs4_dir_rmdir(struct inode *,struct dentry *);
@@ -142,12 +144,15 @@ static int autofs4_dir_open(struct inode *inode, struct file *file)
          * autofs file system so just let the libfs routines handle
          * it.
          */
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&dentry->d_lock);
         if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&autofs4_lock);
                 return -ENOENT;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&autofs4_lock);
 
 out:
         return dcache_dir_open(inode, file);
@@ -252,9 +257,11 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
         /* We trigger a mount for almost all flags */
         lookup_type = autofs4_need_mount(nd->flags);
         spin_lock(&sbi->fs_lock);
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&dentry->d_lock);
         if (!(lookup_type || ino->flags & AUTOFS_INF_PENDING)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&autofs4_lock);
                 spin_unlock(&sbi->fs_lock);
                 goto follow;
         }
@@ -266,7 +273,8 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
          */
         if (ino->flags & AUTOFS_INF_PENDING ||
             (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs))) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&autofs4_lock);
                 spin_unlock(&sbi->fs_lock);
 
                 status = try_to_fill_dentry(dentry, nd->flags);
@@ -275,7 +283,8 @@ static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
 
                 goto follow;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&autofs4_lock);
         spin_unlock(&sbi->fs_lock);
 follow:
         /*
@@ -306,12 +315,19 @@ out_error:
  */
 static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        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);
+        struct inode *dir;
+        struct autofs_sb_info *sbi;
+        int oz_mode;
         int flags = nd ? nd->flags : 0;
         int status = 1;
 
+        if (flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        dir = dentry->d_parent->d_inode;
+        sbi = autofs4_sbi(dir->i_sb);
+        oz_mode = autofs4_oz_mode(sbi);
+
         /* Pending dentry */
         spin_lock(&sbi->fs_lock);
         if (autofs4_ispending(dentry)) {
@@ -346,12 +362,14 @@ static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
                 return 0;
 
         /* Check for a non-mountpoint directory with no contents */
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&dentry->d_lock);
         if (S_ISDIR(dentry->d_inode->i_mode) &&
             !d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
                 DPRINTK("dentry=%p %.*s, emptydir",
                          dentry, dentry->d_name.len, dentry->d_name.name);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&autofs4_lock);
 
                 /* The daemon never causes a mount to trigger */
                 if (oz_mode)
@@ -367,7 +385,8 @@ static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
 
                 return status;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&autofs4_lock);
 
         return 1;
 }
@@ -422,7 +441,7 @@ static struct dentry *autofs4_lookup_active(struct dentry *dentry)
         const unsigned char *str = name->name;
         struct list_head *p, *head;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         spin_lock(&sbi->lookup_lock);
         head = &sbi->active_list;
         list_for_each(p, head) {
@@ -436,7 +455,7 @@ static struct dentry *autofs4_lookup_active(struct dentry *dentry)
                 spin_lock(&active->d_lock);
 
                 /* Already gone? */
-                if (atomic_read(&active->d_count) == 0)
+                if (active->d_count == 0)
                         goto next;
 
                 qstr = &active->d_name;
@@ -452,17 +471,17 @@ static struct dentry *autofs4_lookup_active(struct dentry *dentry)
                         goto next;
 
                 if (d_unhashed(active)) {
-                        dget(active);
+                        dget_dlock(active);
                         spin_unlock(&active->d_lock);
                         spin_unlock(&sbi->lookup_lock);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&autofs4_lock);
                         return active;
                 }
 next:
                 spin_unlock(&active->d_lock);
         }
         spin_unlock(&sbi->lookup_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         return NULL;
 }
@@ -477,7 +496,7 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
         const unsigned char *str = name->name;
         struct list_head *p, *head;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         spin_lock(&sbi->lookup_lock);
         head = &sbi->expiring_list;
         list_for_each(p, head) {
@@ -507,17 +526,17 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
                         goto next;
 
                 if (d_unhashed(expiring)) {
-                        dget(expiring);
+                        dget_dlock(expiring);
                         spin_unlock(&expiring->d_lock);
                         spin_unlock(&sbi->lookup_lock);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&autofs4_lock);
                         return expiring;
                 }
 next:
                 spin_unlock(&expiring->d_lock);
         }
         spin_unlock(&sbi->lookup_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         return NULL;
 }
@@ -559,7 +578,7 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s
                  * we check for the hashed dentry and return the newly
                  * hashed dentry.
                  */
-                dentry->d_op = &autofs4_root_dentry_operations;
+                d_set_d_op(dentry, &autofs4_root_dentry_operations);
 
                 /*
                  * And we need to ensure that the same dentry is used for
@@ -698,9 +717,9 @@ static int autofs4_dir_symlink(struct inode *dir,
         d_add(dentry, inode);
 
         if (dir == dir->i_sb->s_root->d_inode)
-                dentry->d_op = &autofs4_root_dentry_operations;
+                d_set_d_op(dentry, &autofs4_root_dentry_operations);
         else
-                dentry->d_op = &autofs4_dentry_operations;
+                d_set_d_op(dentry, &autofs4_dentry_operations);
 
         dentry->d_fsdata = ino;
         ino->dentry = dget(dentry);
@@ -753,12 +772,12 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
 
         dir->i_mtime = CURRENT_TIME;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
         autofs4_add_expiring(dentry);
         spin_lock(&dentry->d_lock);
         __d_drop(dentry);
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         return 0;
 }
@@ -775,16 +794,20 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
         if (!autofs4_oz_mode(sbi))
                 return -EACCES;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&autofs4_lock);
+        spin_lock(&sbi->lookup_lock);
+        spin_lock(&dentry->d_lock);
         if (!list_empty(&dentry->d_subdirs)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
+                spin_unlock(&sbi->lookup_lock);
+                spin_unlock(&autofs4_lock);
                 return -ENOTEMPTY;
         }
-        autofs4_add_expiring(dentry);
-        spin_lock(&dentry->d_lock);
+        __autofs4_add_expiring(dentry);
+        spin_unlock(&sbi->lookup_lock);
         __d_drop(dentry);
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
 
         if (atomic_dec_and_test(&ino->count)) {
                 p_ino = autofs4_dentry_ino(dentry->d_parent);
@@ -829,9 +852,9 @@ static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         d_add(dentry, inode);
 
         if (dir == dir->i_sb->s_root->d_inode)
-                dentry->d_op = &autofs4_root_dentry_operations;
+                d_set_d_op(dentry, &autofs4_root_dentry_operations);
         else
-                dentry->d_op = &autofs4_dentry_operations;
+                d_set_d_op(dentry, &autofs4_dentry_operations);
 
         dentry->d_fsdata = ino;
         ino->dentry = dget(dentry);
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index 2341375386f8..c5f8459c905e 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -186,16 +186,26 @@ static int autofs4_getpath(struct autofs_sb_info *sbi,
 {
         struct dentry *root = sbi->sb->s_root;
         struct dentry *tmp;
-        char *buf = *name;
+        char *buf;
         char *p;
-        int len = 0;
+        int len;
+        unsigned seq;
 
-        spin_lock(&dcache_lock);
+rename_retry:
+        buf = *name;
+        len = 0;
+
+        seq = read_seqbegin(&rename_lock);
+        rcu_read_lock();
+        spin_lock(&autofs4_lock);
         for (tmp = dentry ; tmp != root ; tmp = tmp->d_parent)
                 len += tmp->d_name.len + 1;
 
         if (!len || --len > NAME_MAX) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&autofs4_lock);
+                rcu_read_unlock();
+                if (read_seqretry(&rename_lock, seq))
+                        goto rename_retry;
                 return 0;
         }
 
@@ -208,7 +218,10 @@ static int autofs4_getpath(struct autofs_sb_info *sbi,
                 p -= tmp->d_name.len;
                 strncpy(p, tmp->d_name.name, tmp->d_name.len);
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&autofs4_lock);
+        rcu_read_unlock();
+        if (read_seqretry(&rename_lock, seq))
+                goto rename_retry;
 
         return len;
 }
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index f024d8aaddef..9ad2369d9e35 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -229,8 +229,11 @@ static int bad_inode_readlink(struct dentry *dentry, char __user *buffer,
         return -EIO;
 }
 
-static int bad_inode_permission(struct inode *inode, int mask)
+static int bad_inode_permission(struct inode *inode, int mask, unsigned int flags)
 {
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         return -EIO;
 }
 
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index aa4e7c7ae3c6..de93581b79a2 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -284,12 +284,18 @@ befs_alloc_inode(struct super_block *sb)
         return &bi->vfs_inode;
 }
 
-static void
-befs_destroy_inode(struct inode *inode)
+static void befs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(befs_inode_cachep, BEFS_I(inode));
 }
 
+static void befs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, befs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct befs_inode_info *bi = (struct befs_inode_info *) foo;
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index 76db6d7d49bb..a8e37f81d097 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -248,11 +248,18 @@ static struct inode *bfs_alloc_inode(struct super_block *sb)
         return &bi->vfs_inode;
 }
 
-static void bfs_destroy_inode(struct inode *inode)
+static void bfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(bfs_inode_cachep, BFS_I(inode));
 }
 
+static void bfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, bfs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct bfs_inode_info *bi = foo;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 4230252fd689..771f23527010 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -409,13 +409,20 @@ static struct inode *bdev_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void bdev_destroy_inode(struct inode *inode)
+static void bdev_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
         struct bdev_inode *bdi = BDEV_I(inode);
 
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(bdev_cachep, bdi);
 }
 
+static void bdev_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, bdev_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct bdev_inode *ei = (struct bdev_inode *) foo;
diff --git a/fs/btrfs/acl.c b/fs/btrfs/acl.c
index 2222d161c7b6..6ae2c8cac9d5 100644
--- a/fs/btrfs/acl.c
+++ b/fs/btrfs/acl.c
@@ -185,18 +185,23 @@ static int btrfs_xattr_acl_set(struct dentry *dentry, const char *name,
         return ret;
 }
 
-int btrfs_check_acl(struct inode *inode, int mask)
+int btrfs_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct posix_acl *acl;
         int error = -EAGAIN;
 
-        acl = btrfs_get_acl(inode, ACL_TYPE_ACCESS);
+        if (flags & IPERM_FLAG_RCU) {
+                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                        error = -ECHILD;
 
-        if (IS_ERR(acl))
-                return PTR_ERR(acl);
-        if (acl) {
-                error = posix_acl_permission(inode, acl, mask);
-                posix_acl_release(acl);
+        } else {
+                struct posix_acl *acl;
+                acl = btrfs_get_acl(inode, ACL_TYPE_ACCESS);
+                if (IS_ERR(acl))
+                        return PTR_ERR(acl);
+                if (acl) {
+                        error = posix_acl_permission(inode, acl, mask);
+                        posix_acl_release(acl);
+                }
         }
 
         return error;
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index af52f6d7a4d8..a142d204b526 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2544,7 +2544,7 @@ int btrfs_sync_fs(struct super_block *sb, int wait);
 
 /* acl.c */
 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
-int btrfs_check_acl(struct inode *inode, int mask);
+int btrfs_check_acl(struct inode *inode, int mask, unsigned int flags);
 #else
 #define btrfs_check_acl NULL
 #endif
diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index 659f532d26a0..0ccf9a8afcdf 100644
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -110,7 +110,7 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
 
         dentry = d_obtain_alias(inode);
         if (!IS_ERR(dentry))
-                dentry->d_op = &btrfs_dentry_operations;
+                d_set_d_op(dentry, &btrfs_dentry_operations);
         return dentry;
 fail:
         srcu_read_unlock(&fs_info->subvol_srcu, index);
@@ -225,7 +225,7 @@ static struct dentry *btrfs_get_parent(struct dentry *child)
         key.offset = 0;
         dentry = d_obtain_alias(btrfs_iget(root->fs_info->sb, &key, root, NULL));
         if (!IS_ERR(dentry))
-                dentry->d_op = &btrfs_dentry_operations;
+                d_set_d_op(dentry, &btrfs_dentry_operations);
         return dentry;
 fail:
         btrfs_free_path(path);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 72f31ecb5c90..a0ff46a47895 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4084,7 +4084,7 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
         int index;
         int ret;
 
-        dentry->d_op = &btrfs_dentry_operations;
+        d_set_d_op(dentry, &btrfs_dentry_operations);
 
         if (dentry->d_name.len > BTRFS_NAME_LEN)
                 return ERR_PTR(-ENAMETOOLONG);
@@ -4127,7 +4127,7 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
         return inode;
 }
 
-static int btrfs_dentry_delete(struct dentry *dentry)
+static int btrfs_dentry_delete(const struct dentry *dentry)
 {
         struct btrfs_root *root;
 
@@ -6495,6 +6495,13 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         return inode;
 }
 
+static void btrfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
+}
+
 void btrfs_destroy_inode(struct inode *inode)
 {
         struct btrfs_ordered_extent *ordered;
@@ -6564,7 +6571,7 @@ void btrfs_destroy_inode(struct inode *inode)
         inode_tree_del(inode);
         btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
 free:
-        kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
+        call_rcu(&inode->i_rcu, btrfs_i_callback);
 }
 
 int btrfs_drop_inode(struct inode *inode)
@@ -7204,11 +7211,11 @@ static int btrfs_set_page_dirty(struct page *page)
         return __set_page_dirty_nobuffers(page);
 }
 
-static int btrfs_permission(struct inode *inode, int mask)
+static int btrfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
         if ((BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) && (mask & MAY_WRITE))
                 return -EACCES;
-        return generic_permission(inode, mask, btrfs_check_acl);
+        return generic_permission(inode, mask, flags, btrfs_check_acl);
 }
 
 static const struct inode_operations btrfs_dir_inode_operations = {
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index d902948a90d8..fa7ca04ee816 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -42,11 +42,11 @@ int ceph_init_dentry(struct dentry *dentry)
 
         if (dentry->d_parent == NULL ||   /* nfs fh_to_dentry */
             ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP)
-                dentry->d_op = &ceph_dentry_ops;
+                d_set_d_op(dentry, &ceph_dentry_ops);
         else if (ceph_snap(dentry->d_parent->d_inode) == CEPH_SNAPDIR)
-                dentry->d_op = &ceph_snapdir_dentry_ops;
+                d_set_d_op(dentry, &ceph_snapdir_dentry_ops);
         else
-                dentry->d_op = &ceph_snap_dentry_ops;
+                d_set_d_op(dentry, &ceph_snap_dentry_ops);
 
         di = kmem_cache_alloc(ceph_dentry_cachep, GFP_NOFS | __GFP_ZERO);
         if (!di)
@@ -112,7 +112,7 @@ static int __dcache_readdir(struct file *filp,
         dout("__dcache_readdir %p at %llu (last %p)\n", dir, filp->f_pos,
              last);
 
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
 
         /* start at beginning? */
         if (filp->f_pos == 2 || last == NULL ||
@@ -136,6 +136,7 @@ more:
                         fi->at_end = 1;
                         goto out_unlock;
                 }
+                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
                 if (!d_unhashed(dentry) && dentry->d_inode &&
                     ceph_snap(dentry->d_inode) != CEPH_SNAPDIR &&
                     ceph_ino(dentry->d_inode) != CEPH_INO_CEPH &&
@@ -145,13 +146,15 @@ more:
                      dentry->d_name.len, dentry->d_name.name, di->offset,
                      filp->f_pos, d_unhashed(dentry) ? " unhashed" : "",
                      !dentry->d_inode ? " null" : "");
+                spin_unlock(&dentry->d_lock);
                 p = p->prev;
                 dentry = list_entry(p, struct dentry, d_u.d_child);
                 di = ceph_dentry(dentry);
         }
 
-        atomic_inc(&dentry->d_count);
-        spin_unlock(&dcache_lock);
+        dget_dlock(dentry);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&parent->d_lock);
 
         dout(" %llu (%llu) dentry %p %.*s %p\n", di->offset, filp->f_pos,
              dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
@@ -177,19 +180,19 @@ more:
 
         filp->f_pos++;
 
-        /* make sure a dentry wasn't dropped while we didn't have dcache_lock */
+        /* make sure a dentry wasn't dropped while we didn't have parent lock */
         if (!ceph_i_test(dir, CEPH_I_COMPLETE)) {
                 dout(" lost I_COMPLETE on %p; falling back to mds\n", dir);
                 err = -EAGAIN;
                 goto out;
         }
 
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         p = p->prev;    /* advance to next dentry */
         goto more;
 
 out_unlock:
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
 out:
         if (last)
                 dput(last);
@@ -987,7 +990,12 @@ static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry)
  */
 static int ceph_d_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *dir = dentry->d_parent->d_inode;
+        struct inode *dir;
+
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        dir = dentry->d_parent->d_inode;
 
         dout("d_revalidate %p '%.*s' inode %p offset %lld\n", dentry,
              dentry->d_name.len, dentry->d_name.name, dentry->d_inode,
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index bf1286588f26..e61de4f7b99d 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -368,6 +368,15 @@ struct inode *ceph_alloc_inode(struct super_block *sb)
         return &ci->vfs_inode;
 }
 
+static void ceph_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        struct ceph_inode_info *ci = ceph_inode(inode);
+
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(ceph_inode_cachep, ci);
+}
+
 void ceph_destroy_inode(struct inode *inode)
 {
         struct ceph_inode_info *ci = ceph_inode(inode);
@@ -407,7 +416,7 @@ void ceph_destroy_inode(struct inode *inode)
         if (ci->i_xattrs.prealloc_blob)
                 ceph_buffer_put(ci->i_xattrs.prealloc_blob);
 
-        kmem_cache_free(ceph_inode_cachep, ci);
+        call_rcu(&inode->i_rcu, ceph_i_callback);
 }
 
 
@@ -841,13 +850,13 @@ static void ceph_set_dentry_offset(struct dentry *dn)
         di->offset = ceph_inode(inode)->i_max_offset++;
         spin_unlock(&inode->i_lock);
 
-        spin_lock(&dcache_lock);
-        spin_lock(&dn->d_lock);
+        spin_lock(&dir->d_lock);
+        spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
         list_move(&dn->d_u.d_child, &dir->d_subdirs);
         dout("set_dentry_offset %p %lld (%p %p)\n", dn, di->offset,
              dn->d_u.d_child.prev, dn->d_u.d_child.next);
         spin_unlock(&dn->d_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dir->d_lock);
 }
 
 /*
@@ -879,8 +888,8 @@ static struct dentry *splice_dentry(struct dentry *dn, struct inode *in,
         } else if (realdn) {
                 dout("dn %p (%d) spliced with %p (%d) "
                      "inode %p ino %llx.%llx\n",
-                     dn, atomic_read(&dn->d_count),
-                     realdn, atomic_read(&realdn->d_count),
+                     dn, dn->d_count,
+                     realdn, realdn->d_count,
                      realdn->d_inode, ceph_vinop(realdn->d_inode));
                 dput(dn);
                 dn = realdn;
@@ -1231,11 +1240,11 @@ retry_lookup:
                         goto retry_lookup;
                 } else {
                         /* reorder parent's d_subdirs */
-                        spin_lock(&dcache_lock);
-                        spin_lock(&dn->d_lock);
+                        spin_lock(&parent->d_lock);
+                        spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
                         list_move(&dn->d_u.d_child, &parent->d_subdirs);
                         spin_unlock(&dn->d_lock);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&parent->d_lock);
                 }
 
                 di = dn->d_fsdata;
@@ -1772,12 +1781,17 @@ int ceph_do_getattr(struct inode *inode, int mask)
  * Check inode permissions.  We verify we have a valid value for
  * the AUTH cap, then call the generic handler.
  */
-int ceph_permission(struct inode *inode, int mask)
+int ceph_permission(struct inode *inode, int mask, unsigned int flags)
 {
-        int err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED);
+        int err;
+
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
+        err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED);
 
         if (!err)
-                err = generic_permission(inode, mask, NULL);
+                err = generic_permission(inode, mask, flags, NULL);
         return err;
 }
 
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 38800eaa81d0..a50fca1e03be 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -1486,7 +1486,7 @@ retry:
         *base = ceph_ino(temp->d_inode);
         *plen = len;
         dout("build_path on %p %d built %llx '%.*s'\n",
-             dentry, atomic_read(&dentry->d_count), *base, len, path);
+             dentry, dentry->d_count, *base, len, path);
         return path;
 }
 
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index 7f01728a4657..4553d8829edb 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -665,7 +665,7 @@ extern void ceph_queue_invalidate(struct inode *inode);
 extern void ceph_queue_writeback(struct inode *inode);
 
 extern int ceph_do_getattr(struct inode *inode, int mask);
-extern int ceph_permission(struct inode *inode, int mask);
+extern int ceph_permission(struct inode *inode, int mask, unsigned int flags);
 extern int ceph_setattr(struct dentry *dentry, struct iattr *attr);
 extern int ceph_getattr(struct vfsmount *mnt, struct dentry *dentry,
                         struct kstat *stat);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 3936aa7f2c22..8e21e0fe65d5 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -283,10 +283,13 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
         return 0;
 }
 
-static int cifs_permission(struct inode *inode, int mask)
+static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
 {
         struct cifs_sb_info *cifs_sb;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         cifs_sb = CIFS_SB(inode->i_sb);
 
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
@@ -298,7 +301,7 @@ static int cifs_permission(struct inode *inode, int mask)
                 on the client (above and beyond ACL on servers) for
                 servers which do not support setting and viewing mode bits,
                 so allowing client to check permissions is useful */
-                return generic_permission(inode, mask, NULL);
+                return generic_permission(inode, mask, flags, NULL);
 }
 
 static struct kmem_cache *cifs_inode_cachep;
@@ -334,10 +337,17 @@ cifs_alloc_inode(struct super_block *sb)
         return &cifs_inode->vfs_inode;
 }
 
+static void cifs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
+}
+
 static void
 cifs_destroy_inode(struct inode *inode)
 {
-        kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
+        call_rcu(&inode->i_rcu, cifs_i_callback);
 }
 
 static void
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 3840eddbfb7a..db2a58c00f7b 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -135,9 +135,9 @@ static void setup_cifs_dentry(struct cifsTconInfo *tcon,
                               struct inode *newinode)
 {
         if (tcon->nocase)
-                direntry->d_op = &cifs_ci_dentry_ops;
+                d_set_d_op(direntry, &cifs_ci_dentry_ops);
         else
-                direntry->d_op = &cifs_dentry_ops;
+                d_set_d_op(direntry, &cifs_dentry_ops);
         d_instantiate(direntry, newinode);
 }
 
@@ -421,9 +421,9 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
                 rc = cifs_get_inode_info_unix(&newinode, full_path,
                                                 inode->i_sb, xid);
                 if (pTcon->nocase)
-                        direntry->d_op = &cifs_ci_dentry_ops;
+                        d_set_d_op(direntry, &cifs_ci_dentry_ops);
                 else
-                        direntry->d_op = &cifs_dentry_ops;
+                        d_set_d_op(direntry, &cifs_dentry_ops);
 
                 if (rc == 0)
                         d_instantiate(direntry, newinode);
@@ -604,9 +604,9 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 
         if ((rc == 0) && (newInode != NULL)) {
                 if (pTcon->nocase)
-                        direntry->d_op = &cifs_ci_dentry_ops;
+                        d_set_d_op(direntry, &cifs_ci_dentry_ops);
                 else
-                        direntry->d_op = &cifs_dentry_ops;
+                        d_set_d_op(direntry, &cifs_dentry_ops);
                 d_add(direntry, newInode);
                 if (posix_open) {
                         filp = lookup_instantiate_filp(nd, direntry,
@@ -634,9 +634,9 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
                 rc = 0;
                 direntry->d_time = jiffies;
                 if (pTcon->nocase)
-                        direntry->d_op = &cifs_ci_dentry_ops;
+                        d_set_d_op(direntry, &cifs_ci_dentry_ops);
                 else
-                        direntry->d_op = &cifs_dentry_ops;
+                        d_set_d_op(direntry, &cifs_dentry_ops);
                 d_add(direntry, NULL);
         /*      if it was once a directory (but how can we tell?) we could do
                 shrink_dcache_parent(direntry); */
@@ -656,22 +656,37 @@ lookup_out:
 static int
 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
 {
-        int isValid = 1;
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
 
         if (direntry->d_inode) {
                 if (cifs_revalidate_dentry(direntry))
                         return 0;
-        } else {
-                cFYI(1, "neg dentry 0x%p name = %s",
-                         direntry, direntry->d_name.name);
-                if (time_after(jiffies, direntry->d_time + HZ) ||
-                        !lookupCacheEnabled) {
-                        d_drop(direntry);
-                        isValid = 0;
-                }
+                else
+                        return 1;
         }
 
-        return isValid;
+        /*
+         * This may be nfsd (or something), anyway, we can't see the
+         * intent of this. So, since this can be for creation, drop it.
+         */
+        if (!nd)
+                return 0;
+
+        /*
+         * Drop the negative dentry, in order to make sure to use the
+         * case sensitive name which is specified by user if this is
+         * for creation.
+         */
+        if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
+                if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+                        return 0;
+        }
+
+        if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
+                return 0;
+
+        return 1;
 }
 
 /* static int cifs_d_delete(struct dentry *direntry)
@@ -688,9 +703,10 @@ const struct dentry_operations cifs_dentry_ops = {
 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
 };
 
-static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
+static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *q)
 {
-        struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
+        struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
         unsigned long hash;
         int i;
 
@@ -703,21 +719,16 @@ static int cifs_ci_hash(struct dentry *dentry, struct qstr *q)
         return 0;
 }
 
-static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
-                           struct qstr *b)
+static int cifs_ci_compare(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        struct nls_table *codepage = CIFS_SB(dentry->d_inode->i_sb)->local_nls;
-
-        if ((a->len == b->len) &&
-            (nls_strnicmp(codepage, a->name, b->name, a->len) == 0)) {
-                /*
-                 * To preserve case, don't let an existing negative dentry's
-                 * case take precedence.  If a is not a negative dentry, this
-                 * should have no side effects
-                 */
-                memcpy((void *)a->name, b->name, a->len);
+        struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
+
+        if ((name->len == len) &&
+            (nls_strnicmp(codepage, name->name, str, len) == 0))
                 return 0;
-        }
         return 1;
 }
 
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 589f3e3f6e00..a853a89857a5 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -809,14 +809,14 @@ inode_has_hashed_dentries(struct inode *inode)
 {
         struct dentry *dentry;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&inode->i_lock);
         list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&inode->i_lock);
                         return true;
                 }
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
         return false;
 }
 
@@ -1319,9 +1319,9 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
         to set uid/gid */
                         inc_nlink(inode);
                         if (pTcon->nocase)
-                                direntry->d_op = &cifs_ci_dentry_ops;
+                                d_set_d_op(direntry, &cifs_ci_dentry_ops);
                         else
-                                direntry->d_op = &cifs_dentry_ops;
+                                d_set_d_op(direntry, &cifs_dentry_ops);
 
                         cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
                         cifs_fill_uniqueid(inode->i_sb, &fattr);
@@ -1363,9 +1363,9 @@ mkdir_get_info:
                                                  inode->i_sb, xid, NULL);
 
                 if (pTcon->nocase)
-                        direntry->d_op = &cifs_ci_dentry_ops;
+                        d_set_d_op(direntry, &cifs_ci_dentry_ops);
                 else
-                        direntry->d_op = &cifs_dentry_ops;
+                        d_set_d_op(direntry, &cifs_dentry_ops);
                 d_instantiate(direntry, newinode);
                  /* setting nlink not necessary except in cases where we
                   * failed to get it from the server or was set bogus */
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 85cdbf831e7b..fe2f6a93c49e 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -525,9 +525,9 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
                               rc);
                 } else {
                         if (pTcon->nocase)
-                                direntry->d_op = &cifs_ci_dentry_ops;
+                                d_set_d_op(direntry, &cifs_ci_dentry_ops);
                         else
-                                direntry->d_op = &cifs_dentry_ops;
+                                d_set_d_op(direntry, &cifs_dentry_ops);
                         d_instantiate(direntry, newinode);
                 }
         }
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index a73eb9f4bdaf..ec5b68e3b928 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -79,7 +79,7 @@ cifs_readdir_lookup(struct dentry *parent, struct qstr *name,
         cFYI(1, "For %s", name->name);
 
         if (parent->d_op && parent->d_op->d_hash)
-                parent->d_op->d_hash(parent, name);
+                parent->d_op->d_hash(parent, parent->d_inode, name);
         else
                 name->hash = full_name_hash(name->name, name->len);
 
@@ -103,9 +103,9 @@ cifs_readdir_lookup(struct dentry *parent, struct qstr *name,
         }
 
         if (cifs_sb_master_tcon(CIFS_SB(sb))->nocase)
-                dentry->d_op = &cifs_ci_dentry_ops;
+                d_set_d_op(dentry, &cifs_ci_dentry_ops);
         else
-                dentry->d_op = &cifs_dentry_ops;
+                d_set_d_op(dentry, &cifs_dentry_ops);
 
         alias = d_materialise_unique(dentry, inode);
         if (alias != NULL) {
diff --git a/fs/coda/cache.c b/fs/coda/cache.c
index 9060f08e70cf..5525e1c660fd 100644
--- a/fs/coda/cache.c
+++ b/fs/coda/cache.c
@@ -93,7 +93,7 @@ static void coda_flag_children(struct dentry *parent, int flag)
         struct list_head *child;
         struct dentry *de;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         list_for_each(child, &parent->d_subdirs)
         {
                 de = list_entry(child, struct dentry, d_u.d_child);
@@ -102,7 +102,7 @@ static void coda_flag_children(struct dentry *parent, int flag)
                         continue;
                 coda_flag_inode(de->d_inode, flag);
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
         return; 
 }
 
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 5d8b35539601..29badd91360f 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -18,6 +18,7 @@
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/spinlock.h>
+#include <linux/namei.h>
 
 #include <asm/uaccess.h>
 
@@ -47,7 +48,7 @@ static int coda_readdir(struct file *file, void *buf, filldir_t filldir);
 
 /* dentry ops */
 static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd);
-static int coda_dentry_delete(struct dentry *);
+static int coda_dentry_delete(const struct dentry *);
 
 /* support routines */
 static int coda_venus_readdir(struct file *coda_file, void *buf,
@@ -125,7 +126,7 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struc
                 return ERR_PTR(error);
 
 exit:
-        entry->d_op = &coda_dentry_operations;
+        d_set_d_op(entry, &coda_dentry_operations);
 
         if (inode && (type & CODA_NOCACHE))
                 coda_flag_inode(inode, C_VATTR | C_PURGE);
@@ -134,10 +135,13 @@ exit:
 }
 
 
-int coda_permission(struct inode *inode, int mask)
+int coda_permission(struct inode *inode, int mask, unsigned int flags)
 {
         int error;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
  
         if (!mask)
@@ -541,9 +545,13 @@ out:
 /* called when a cache lookup succeeds */
 static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd)
 {
-        struct inode *inode = de->d_inode;
+        struct inode *inode;
         struct coda_inode_info *cii;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = de->d_inode;
         if (!inode || coda_isroot(inode))
                 goto out;
         if (is_bad_inode(inode))
@@ -559,7 +567,7 @@ static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd)
         if (cii->c_flags & C_FLUSH) 
                 coda_flag_inode_children(inode, C_FLUSH);
 
-        if (atomic_read(&de->d_count) > 1)
+        if (de->d_count > 1)
                 /* pretend it's valid, but don't change the flags */
                 goto out;
 
@@ -577,7 +585,7 @@ out:
  * This is the callback from dput() when d_count is going to 0.
  * We use this to unhash dentries with bad inodes.
  */
-static int coda_dentry_delete(struct dentry * dentry)
+static int coda_dentry_delete(const struct dentry * dentry)
 {
         int flags;
 
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 5ea57c8c7f97..50dc7d189f56 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -56,11 +56,18 @@ static struct inode *coda_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void coda_destroy_inode(struct inode *inode)
+static void coda_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(coda_inode_cachep, ITOC(inode));
 }
 
+static void coda_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, coda_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct coda_inode_info *ei = (struct coda_inode_info *) foo;
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index 2fd89b5c5c7b..741f0bd03918 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -24,7 +24,7 @@
 #include <linux/coda_psdev.h>
 
 /* pioctl ops */
-static int coda_ioctl_permission(struct inode *inode, int mask);
+static int coda_ioctl_permission(struct inode *inode, int mask, unsigned int flags);
 static long coda_pioctl(struct file *filp, unsigned int cmd,
                         unsigned long user_data);
 
@@ -41,8 +41,10 @@ const struct file_operations coda_ioctl_operations = {
 };
 
 /* the coda pioctl inode ops */
-static int coda_ioctl_permission(struct inode *inode, int mask)
+static int coda_ioctl_permission(struct inode *inode, int mask, unsigned int flags)
 {
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
         return (mask & MAY_EXEC) ? -EACCES : 0;
 }
 
diff --git a/fs/configfs/configfs_internal.h b/fs/configfs/configfs_internal.h
index da6061a6df40..026cf68553a4 100644
--- a/fs/configfs/configfs_internal.h
+++ b/fs/configfs/configfs_internal.h
@@ -120,7 +120,7 @@ static inline struct config_item *configfs_get_config_item(struct dentry *dentry
 {
         struct config_item * item = NULL;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&dentry->d_lock);
         if (!d_unhashed(dentry)) {
                 struct configfs_dirent * sd = dentry->d_fsdata;
                 if (sd->s_type & CONFIGFS_ITEM_LINK) {
@@ -129,7 +129,7 @@ static inline struct config_item *configfs_get_config_item(struct dentry *dentry
                 } else
                         item = config_item_get(sd->s_element);
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
 
         return item;
 }
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 0b502f80c691..36637a8c1ed3 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -67,7 +67,7 @@ static void configfs_d_iput(struct dentry * dentry,
  * We _must_ delete our dentries on last dput, as the chain-to-parent
  * behavior is required to clear the parents of default_groups.
  */
-static int configfs_d_delete(struct dentry *dentry)
+static int configfs_d_delete(const struct dentry *dentry)
 {
         return 1;
 }
@@ -232,10 +232,8 @@ int configfs_make_dirent(struct configfs_dirent * parent_sd,
 
         sd->s_mode = mode;
         sd->s_dentry = dentry;
-        if (dentry) {
+        if (dentry)
                 dentry->d_fsdata = configfs_get(sd);
-                dentry->d_op = &configfs_dentry_ops;
-        }
 
         return 0;
 }
@@ -278,7 +276,6 @@ static int create_dir(struct config_item * k, struct dentry * p,
                 error = configfs_create(d, mode, init_dir);
                 if (!error) {
                         inc_nlink(p->d_inode);
-                        (d)->d_op = &configfs_dentry_ops;
                 } else {
                         struct configfs_dirent *sd = d->d_fsdata;
                         if (sd) {
@@ -371,9 +368,7 @@ int configfs_create_link(struct configfs_symlink *sl,
                                    CONFIGFS_ITEM_LINK);
         if (!err) {
                 err = configfs_create(dentry, mode, init_symlink);
-                if (!err)
-                        dentry->d_op = &configfs_dentry_ops;
-                else {
+                if (err) {
                         struct configfs_dirent *sd = dentry->d_fsdata;
                         if (sd) {
                                 spin_lock(&configfs_dirent_lock);
@@ -399,8 +394,7 @@ static void remove_dir(struct dentry * d)
         if (d->d_inode)
                 simple_rmdir(parent->d_inode,d);
 
-        pr_debug(" o %s removing done (%d)\n",d->d_name.name,
-                 atomic_read(&d->d_count));
+        pr_debug(" o %s removing done (%d)\n",d->d_name.name, d->d_count);
 
         dput(parent);
 }
@@ -448,7 +442,7 @@ static int configfs_attach_attr(struct configfs_dirent * sd, struct dentry * den
                 return error;
         }
 
-        dentry->d_op = &configfs_dentry_ops;
+        d_set_d_op(dentry, &configfs_dentry_ops);
         d_rehash(dentry);
 
         return 0;
@@ -493,7 +487,11 @@ static struct dentry * configfs_lookup(struct inode *dir,
                  * If it doesn't exist and it isn't a NOT_PINNED item,
                  * it must be negative.
                  */
-                return simple_lookup(dir, dentry, nd);
+                if (dentry->d_name.len > NAME_MAX)
+                        return ERR_PTR(-ENAMETOOLONG);
+                d_set_d_op(dentry, &configfs_dentry_ops);
+                d_add(dentry, NULL);
+                return NULL;
         }
 
 out:
@@ -685,6 +683,7 @@ static int create_default_group(struct config_group *parent_group,
         ret = -ENOMEM;
         child = d_alloc(parent, &name);
         if (child) {
+                d_set_d_op(child, &configfs_dentry_ops);
                 d_add(child, NULL);
 
                 ret = configfs_attach_group(&parent_group->cg_item,
@@ -1682,6 +1681,7 @@ int configfs_register_subsystem(struct configfs_subsystem *subsys)
         err = -ENOMEM;
         dentry = d_alloc(configfs_sb->s_root, &name);
         if (dentry) {
+                d_set_d_op(dentry, &configfs_dentry_ops);
                 d_add(dentry, NULL);
 
                 err = configfs_attach_group(sd->s_element, &group->cg_item,
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index 253476d78ed8..c83f4768eeaa 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -250,18 +250,14 @@ void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent)
         struct dentry * dentry = sd->s_dentry;
 
         if (dentry) {
-                spin_lock(&dcache_lock);
                 spin_lock(&dentry->d_lock);
                 if (!(d_unhashed(dentry) && dentry->d_inode)) {
-                        dget_locked(dentry);
+                        dget_dlock(dentry);
                         __d_drop(dentry);
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
                         simple_unlink(parent->d_inode, dentry);
-                } else {
+                } else
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
-                }
         }
 }
 
diff --git a/fs/dcache.c b/fs/dcache.c
index 23702a9d4e6d..5699d4c027cb 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -33,20 +33,58 @@
 #include <linux/bootmem.h>
 #include <linux/fs_struct.h>
 #include <linux/hardirq.h>
+#include <linux/bit_spinlock.h>
+#include <linux/rculist_bl.h>
 #include "internal.h"
 
+/*
+ * Usage:
+ * dcache->d_inode->i_lock protects:
+ *   - i_dentry, d_alias, d_inode of aliases
+ * dcache_hash_bucket lock protects:
+ *   - the dcache hash table
+ * s_anon bl list spinlock protects:
+ *   - the s_anon list (see __d_drop)
+ * dcache_lru_lock protects:
+ *   - the dcache lru lists and counters
+ * d_lock protects:
+ *   - d_flags
+ *   - d_name
+ *   - d_lru
+ *   - d_count
+ *   - d_unhashed()
+ *   - d_parent and d_subdirs
+ *   - childrens' d_child and d_parent
+ *   - d_alias, d_inode
+ *
+ * Ordering:
+ * dentry->d_inode->i_lock
+ *   dentry->d_lock
+ *     dcache_lru_lock
+ *     dcache_hash_bucket lock
+ *     s_anon lock
+ *
+ * If there is an ancestor relationship:
+ * dentry->d_parent->...->d_parent->d_lock
+ *   ...
+ *     dentry->d_parent->d_lock
+ *       dentry->d_lock
+ *
+ * If no ancestor relationship:
+ * if (dentry1 < dentry2)
+ *   dentry1->d_lock
+ *     dentry2->d_lock
+ */
 int sysctl_vfs_cache_pressure __read_mostly = 100;
 EXPORT_SYMBOL_GPL(sysctl_vfs_cache_pressure);
 
- __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lock);
+static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lru_lock);
 __cacheline_aligned_in_smp DEFINE_SEQLOCK(rename_lock);
 
-EXPORT_SYMBOL(dcache_lock);
+EXPORT_SYMBOL(rename_lock);
 
 static struct kmem_cache *dentry_cache __read_mostly;
 
-#define DNAME_INLINE_LEN (sizeof(struct dentry)-offsetof(struct dentry,d_iname))
-
 /*
  * This is the single most critical data structure when it comes
  * to the dcache: the hashtable for lookups. Somebody should try
@@ -60,22 +98,51 @@ static struct kmem_cache *dentry_cache __read_mostly;
 
 static unsigned int d_hash_mask __read_mostly;
 static unsigned int d_hash_shift __read_mostly;
-static struct hlist_head *dentry_hashtable __read_mostly;
+
+struct dcache_hash_bucket {
+        struct hlist_bl_head head;
+};
+static struct dcache_hash_bucket *dentry_hashtable __read_mostly;
+
+static inline struct dcache_hash_bucket *d_hash(struct dentry *parent,
+                                        unsigned long hash)
+{
+        hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES;
+        hash = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS);
+        return dentry_hashtable + (hash & D_HASHMASK);
+}
+
+static inline void spin_lock_bucket(struct dcache_hash_bucket *b)
+{
+        bit_spin_lock(0, (unsigned long *)&b->head.first);
+}
+
+static inline void spin_unlock_bucket(struct dcache_hash_bucket *b)
+{
+        __bit_spin_unlock(0, (unsigned long *)&b->head.first);
+}
 
 /* Statistics gathering. */
 struct dentry_stat_t dentry_stat = {
         .age_limit = 45,
 };
 
-static struct percpu_counter nr_dentry __cacheline_aligned_in_smp;
-static struct percpu_counter nr_dentry_unused __cacheline_aligned_in_smp;
+static DEFINE_PER_CPU(unsigned int, nr_dentry);
 
 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
+static int get_nr_dentry(void)
+{
+        int i;
+        int sum = 0;
+        for_each_possible_cpu(i)
+                sum += per_cpu(nr_dentry, i);
+        return sum < 0 ? 0 : sum;
+}
+
 int proc_nr_dentry(ctl_table *table, int write, void __user *buffer,
                    size_t *lenp, loff_t *ppos)
 {
-        dentry_stat.nr_dentry = percpu_counter_sum_positive(&nr_dentry);
-        dentry_stat.nr_unused = percpu_counter_sum_positive(&nr_dentry_unused);
+        dentry_stat.nr_dentry = get_nr_dentry();
         return proc_dointvec(table, write, buffer, lenp, ppos);
 }
 #endif
@@ -91,35 +158,50 @@ static void __d_free(struct rcu_head *head)
 }
 
 /*
- * no dcache_lock, please.
+ * no locks, please.
  */
 static void d_free(struct dentry *dentry)
 {
-        percpu_counter_dec(&nr_dentry);
+        BUG_ON(dentry->d_count);
+        this_cpu_dec(nr_dentry);
         if (dentry->d_op && dentry->d_op->d_release)
                 dentry->d_op->d_release(dentry);
 
         /* if dentry was never inserted into hash, immediate free is OK */
-        if (hlist_unhashed(&dentry->d_hash))
+        if (hlist_bl_unhashed(&dentry->d_hash))
                 __d_free(&dentry->d_u.d_rcu);
         else
                 call_rcu(&dentry->d_u.d_rcu, __d_free);
 }
 
+/**
+ * dentry_rcuwalk_barrier - invalidate in-progress rcu-walk lookups
+ * After this call, in-progress rcu-walk path lookup will fail. This
+ * should be called after unhashing, and after changing d_inode (if
+ * the dentry has not already been unhashed).
+ */
+static inline void dentry_rcuwalk_barrier(struct dentry *dentry)
+{
+        assert_spin_locked(&dentry->d_lock);
+        /* Go through a barrier */
+        write_seqcount_barrier(&dentry->d_seq);
+}
+
 /*
  * Release the dentry's inode, using the filesystem
- * d_iput() operation if defined.
+ * d_iput() operation if defined. Dentry has no refcount
+ * and is unhashed.
  */
 static void dentry_iput(struct dentry * dentry)
         __releases(dentry->d_lock)
-        __releases(dcache_lock)
+        __releases(dentry->d_inode->i_lock)
 {
         struct inode *inode = dentry->d_inode;
         if (inode) {
                 dentry->d_inode = NULL;
                 list_del_init(&dentry->d_alias);
                 spin_unlock(&dentry->d_lock);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&inode->i_lock);
                 if (!inode->i_nlink)
                         fsnotify_inoderemove(inode);
                 if (dentry->d_op && dentry->d_op->d_iput)
@@ -128,40 +210,72 @@ static void dentry_iput(struct dentry * dentry)
                         iput(inode);
         } else {
                 spin_unlock(&dentry->d_lock);
-                spin_unlock(&dcache_lock);
         }
 }
 
 /*
- * dentry_lru_(add|del|move_tail) must be called with dcache_lock held.
+ * Release the dentry's inode, using the filesystem
+ * d_iput() operation if defined. dentry remains in-use.
+ */
+static void dentry_unlink_inode(struct dentry * dentry)
+        __releases(dentry->d_lock)
+        __releases(dentry->d_inode->i_lock)
+{
+        struct inode *inode = dentry->d_inode;
+        dentry->d_inode = NULL;
+        list_del_init(&dentry->d_alias);
+        dentry_rcuwalk_barrier(dentry);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&inode->i_lock);
+        if (!inode->i_nlink)
+                fsnotify_inoderemove(inode);
+        if (dentry->d_op && dentry->d_op->d_iput)
+                dentry->d_op->d_iput(dentry, inode);
+        else
+                iput(inode);
+}
+
+/*
+ * dentry_lru_(add|del|move_tail) must be called with d_lock held.
  */
 static void dentry_lru_add(struct dentry *dentry)
 {
         if (list_empty(&dentry->d_lru)) {
+                spin_lock(&dcache_lru_lock);
                 list_add(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
                 dentry->d_sb->s_nr_dentry_unused++;
-                percpu_counter_inc(&nr_dentry_unused);
+                dentry_stat.nr_unused++;
+                spin_unlock(&dcache_lru_lock);
         }
 }
 
+static void __dentry_lru_del(struct dentry *dentry)
+{
+        list_del_init(&dentry->d_lru);
+        dentry->d_sb->s_nr_dentry_unused--;
+        dentry_stat.nr_unused--;
+}
+
 static void dentry_lru_del(struct dentry *dentry)
 {
         if (!list_empty(&dentry->d_lru)) {
-                list_del_init(&dentry->d_lru);
-                dentry->d_sb->s_nr_dentry_unused--;
-                percpu_counter_dec(&nr_dentry_unused);
+                spin_lock(&dcache_lru_lock);
+                __dentry_lru_del(dentry);
+                spin_unlock(&dcache_lru_lock);
         }
 }
 
 static void dentry_lru_move_tail(struct dentry *dentry)
 {
+        spin_lock(&dcache_lru_lock);
         if (list_empty(&dentry->d_lru)) {
                 list_add_tail(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
                 dentry->d_sb->s_nr_dentry_unused++;
-                percpu_counter_inc(&nr_dentry_unused);
+                dentry_stat.nr_unused++;
         } else {
                 list_move_tail(&dentry->d_lru, &dentry->d_sb->s_dentry_lru);
         }
+        spin_unlock(&dcache_lru_lock);
 }
 
 /**
@@ -171,22 +285,115 @@ static void dentry_lru_move_tail(struct dentry *dentry)
  * The dentry must already be unhashed and removed from the LRU.
  *
  * If this is the root of the dentry tree, return NULL.
+ *
+ * dentry->d_lock and parent->d_lock must be held by caller, and are dropped by
+ * d_kill.
  */
-static struct dentry *d_kill(struct dentry *dentry)
+static struct dentry *d_kill(struct dentry *dentry, struct dentry *parent)
         __releases(dentry->d_lock)
-        __releases(dcache_lock)
+        __releases(parent->d_lock)
+        __releases(dentry->d_inode->i_lock)
 {
-        struct dentry *parent;
-
+        dentry->d_parent = NULL;
         list_del(&dentry->d_u.d_child);
-        /*drops the locks, at that point nobody can reach this dentry */
+        if (parent)
+                spin_unlock(&parent->d_lock);
         dentry_iput(dentry);
+        /*
+         * dentry_iput drops the locks, at which point nobody (except
+         * transient RCU lookups) can reach this dentry.
+         */
+        d_free(dentry);
+        return parent;
+}
+
+/**
+ * d_drop - drop a dentry
+ * @dentry: dentry to drop
+ *
+ * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
+ * be found through a VFS lookup any more. Note that this is different from
+ * deleting the dentry - d_delete will try to mark the dentry negative if
+ * possible, giving a successful _negative_ lookup, while d_drop will
+ * just make the cache lookup fail.
+ *
+ * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
+ * reason (NFS timeouts or autofs deletes).
+ *
+ * __d_drop requires dentry->d_lock.
+ */
+void __d_drop(struct dentry *dentry)
+{
+        if (!(dentry->d_flags & DCACHE_UNHASHED)) {
+                if (unlikely(dentry->d_flags & DCACHE_DISCONNECTED)) {
+                        bit_spin_lock(0,
+                                (unsigned long *)&dentry->d_sb->s_anon.first);
+                        dentry->d_flags |= DCACHE_UNHASHED;
+                        hlist_bl_del_init(&dentry->d_hash);
+                        __bit_spin_unlock(0,
+                                (unsigned long *)&dentry->d_sb->s_anon.first);
+                } else {
+                        struct dcache_hash_bucket *b;
+                        b = d_hash(dentry->d_parent, dentry->d_name.hash);
+                        spin_lock_bucket(b);
+                        /*
+                         * We may not actually need to put DCACHE_UNHASHED
+                         * manipulations under the hash lock, but follow
+                         * the principle of least surprise.
+                         */
+                        dentry->d_flags |= DCACHE_UNHASHED;
+                        hlist_bl_del_rcu(&dentry->d_hash);
+                        spin_unlock_bucket(b);
+                        dentry_rcuwalk_barrier(dentry);
+                }
+        }
+}
+EXPORT_SYMBOL(__d_drop);
+
+void d_drop(struct dentry *dentry)
+{
+        spin_lock(&dentry->d_lock);
+        __d_drop(dentry);
+        spin_unlock(&dentry->d_lock);
+}
+EXPORT_SYMBOL(d_drop);
+
+/*
+ * Finish off a dentry we've decided to kill.
+ * dentry->d_lock must be held, returns with it unlocked.
+ * If ref is non-zero, then decrement the refcount too.
+ * Returns dentry requiring refcount drop, or NULL if we're done.
+ */
+static inline struct dentry *dentry_kill(struct dentry *dentry, int ref)
+        __releases(dentry->d_lock)
+{
+        struct inode *inode;
+        struct dentry *parent;
+
+        inode = dentry->d_inode;
+        if (inode && !spin_trylock(&inode->i_lock)) {
+relock:
+                spin_unlock(&dentry->d_lock);
+                cpu_relax();
+                return dentry; /* try again with same dentry */
+        }
         if (IS_ROOT(dentry))
                 parent = NULL;
         else
                 parent = dentry->d_parent;
-        d_free(dentry);
-        return parent;
+        if (parent && !spin_trylock(&parent->d_lock)) {
+                if (inode)
+                        spin_unlock(&inode->i_lock);
+                goto relock;
+        }
+
+        if (ref)
+                dentry->d_count--;
+        /* if dentry was on the d_lru list delete it from there */
+        dentry_lru_del(dentry);
+        /* if it was on the hash then remove it */
+        __d_drop(dentry);
+        return d_kill(dentry, parent);
 }
 
 /* 
@@ -214,34 +421,26 @@ static struct dentry *d_kill(struct dentry *dentry)
  * call the dentry unlink method as well as removing it from the queues and
  * releasing its resources. If the parent dentries were scheduled for release
  * they too may now get deleted.
- *
- * no dcache lock, please.
  */
-
 void dput(struct dentry *dentry)
 {
         if (!dentry)
                 return;
 
 repeat:
-        if (atomic_read(&dentry->d_count) == 1)
+        if (dentry->d_count == 1)
                 might_sleep();
-        if (!atomic_dec_and_lock(&dentry->d_count, &dcache_lock))
-                return;
-
         spin_lock(&dentry->d_lock);
-        if (atomic_read(&dentry->d_count)) {
+        BUG_ON(!dentry->d_count);
+        if (dentry->d_count > 1) {
+                dentry->d_count--;
                 spin_unlock(&dentry->d_lock);
-                spin_unlock(&dcache_lock);
                 return;
         }
 
-        /*
-         * AV: ->d_delete() is _NOT_ allowed to block now.
-         */
-        if (dentry->d_op && dentry->d_op->d_delete) {
+        if (dentry->d_flags & DCACHE_OP_DELETE) {
                 if (dentry->d_op->d_delete(dentry))
-                        goto unhash_it;
+                        goto kill_it;
         }
 
         /* Unreachable? Get rid of it */
@@ -252,16 +451,12 @@ repeat:
         dentry->d_flags |= DCACHE_REFERENCED;
         dentry_lru_add(dentry);
 
-        spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
+        dentry->d_count--;
+        spin_unlock(&dentry->d_lock);
         return;
 
-unhash_it:
-        __d_drop(dentry);
 kill_it:
-        /* if dentry was on the d_lru list delete it from there */
-        dentry_lru_del(dentry);
-        dentry = d_kill(dentry);
+        dentry = dentry_kill(dentry, 1);
         if (dentry)
                 goto repeat;
 }
@@ -284,9 +479,9 @@ int d_invalidate(struct dentry * dentry)
         /*
          * If it's already been dropped, return OK.
          */
-        spin_lock(&dcache_lock);
+        spin_lock(&dentry->d_lock);
         if (d_unhashed(dentry)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
                 return 0;
         }
         /*
@@ -294,9 +489,9 @@ int d_invalidate(struct dentry * dentry)
          * to get rid of unused child entries.
          */
         if (!list_empty(&dentry->d_subdirs)) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&dentry->d_lock);
                 shrink_dcache_parent(dentry);
-                spin_lock(&dcache_lock);
+                spin_lock(&dentry->d_lock);
         }
 
         /*
@@ -309,35 +504,61 @@ int d_invalidate(struct dentry * dentry)
          * we might still populate it if it was a
          * working directory or similar).
          */
-        spin_lock(&dentry->d_lock);
-        if (atomic_read(&dentry->d_count) > 1) {
+        if (dentry->d_count > 1) {
                 if (dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)) {
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
                         return -EBUSY;
                 }
         }
 
         __d_drop(dentry);
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
         return 0;
 }
 EXPORT_SYMBOL(d_invalidate);
 
-/* This should be called _only_ with dcache_lock held */
-static inline struct dentry * __dget_locked(struct dentry *dentry)
+/* This must be called with d_lock held */
+static inline void __dget_dlock(struct dentry *dentry)
 {
-        atomic_inc(&dentry->d_count);
-        dentry_lru_del(dentry);
-        return dentry;
+        dentry->d_count++;
 }
 
-struct dentry * dget_locked(struct dentry *dentry)
+static inline void __dget(struct dentry *dentry)
 {
-        return __dget_locked(dentry);
+        spin_lock(&dentry->d_lock);
+        __dget_dlock(dentry);
+        spin_unlock(&dentry->d_lock);
+}
+
+struct dentry *dget_parent(struct dentry *dentry)
+{
+        struct dentry *ret;
+
+repeat:
+        /*
+         * Don't need rcu_dereference because we re-check it was correct under
+         * the lock.
+         */
+        rcu_read_lock();
+        ret = dentry->d_parent;
+        if (!ret) {
+                rcu_read_unlock();
+                goto out;
+        }
+        spin_lock(&ret->d_lock);
+        if (unlikely(ret != dentry->d_parent)) {
+                spin_unlock(&ret->d_lock);
+                rcu_read_unlock();
+                goto repeat;
+        }
+        rcu_read_unlock();
+        BUG_ON(!ret->d_count);
+        ret->d_count++;
+        spin_unlock(&ret->d_lock);
+out:
+        return ret;
 }
-EXPORT_SYMBOL(dget_locked);
+EXPORT_SYMBOL(dget_parent);
 
 /**
  * d_find_alias - grab a hashed alias of inode
@@ -355,42 +576,51 @@ EXPORT_SYMBOL(dget_locked);
  * any other hashed alias over that one unless @want_discon is set,
  * in which case only return an IS_ROOT, DCACHE_DISCONNECTED alias.
  */
-
-static struct dentry * __d_find_alias(struct inode *inode, int want_discon)
+static struct dentry *__d_find_alias(struct inode *inode, int want_discon)
 {
-        struct list_head *head, *next, *tmp;
-        struct dentry *alias, *discon_alias=NULL;
+        struct dentry *alias, *discon_alias;
 
-        head = &inode->i_dentry;
-        next = inode->i_dentry.next;
-        while (next != head) {
-                tmp = next;
-                next = tmp->next;
-                prefetch(next);
-                alias = list_entry(tmp, struct dentry, d_alias);
+again:
+        discon_alias = NULL;
+        list_for_each_entry(alias, &inode->i_dentry, d_alias) {
+                spin_lock(&alias->d_lock);
                 if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
                         if (IS_ROOT(alias) &&
-                            (alias->d_flags & DCACHE_DISCONNECTED))
+                            (alias->d_flags & DCACHE_DISCONNECTED)) {
                                 discon_alias = alias;
-                        else if (!want_discon) {
-                                __dget_locked(alias);
+                        } else if (!want_discon) {
+                                __dget_dlock(alias);
+                                spin_unlock(&alias->d_lock);
+                                return alias;
+                        }
+                }
+                spin_unlock(&alias->d_lock);
+        }
+        if (discon_alias) {
+                alias = discon_alias;
+                spin_lock(&alias->d_lock);
+                if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
+                        if (IS_ROOT(alias) &&
+                            (alias->d_flags & DCACHE_DISCONNECTED)) {
+                                __dget_dlock(alias);
+                                spin_unlock(&alias->d_lock);
                                 return alias;
                         }
                 }
+                spin_unlock(&alias->d_lock);
+                goto again;
         }
-        if (discon_alias)
-                __dget_locked(discon_alias);
-        return discon_alias;
+        return NULL;
 }
 
-struct dentry * d_find_alias(struct inode *inode)
+struct dentry *d_find_alias(struct inode *inode)
 {
         struct dentry *de = NULL;
 
         if (!list_empty(&inode->i_dentry)) {
-                spin_lock(&dcache_lock);
+                spin_lock(&inode->i_lock);
                 de = __d_find_alias(inode, 0);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&inode->i_lock);
         }
         return de;
 }
@@ -404,54 +634,61 @@ void d_prune_aliases(struct inode *inode)
 {
         struct dentry *dentry;
 restart:
-        spin_lock(&dcache_lock);
+        spin_lock(&inode->i_lock);
         list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
                 spin_lock(&dentry->d_lock);
-                if (!atomic_read(&dentry->d_count)) {
-                        __dget_locked(dentry);
+                if (!dentry->d_count) {
+                        __dget_dlock(dentry);
                         __d_drop(dentry);
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&inode->i_lock);
                         dput(dentry);
                         goto restart;
                 }
                 spin_unlock(&dentry->d_lock);
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
 }
 EXPORT_SYMBOL(d_prune_aliases);
 
 /*
- * Throw away a dentry - free the inode, dput the parent.  This requires that
- * the LRU list has already been removed.
+ * Try to throw away a dentry - free the inode, dput the parent.
+ * Requires dentry->d_lock is held, and dentry->d_count == 0.
+ * Releases dentry->d_lock.
  *
- * Try to prune ancestors as well.  This is necessary to prevent
- * quadratic behavior of shrink_dcache_parent(), but is also expected
- * to be beneficial in reducing dentry cache fragmentation.
+ * This may fail if locks cannot be acquired no problem, just try again.
  */
-static void prune_one_dentry(struct dentry * dentry)
+static void try_prune_one_dentry(struct dentry *dentry)
         __releases(dentry->d_lock)
-        __releases(dcache_lock)
-        __acquires(dcache_lock)
 {
-        __d_drop(dentry);
-        dentry = d_kill(dentry);
+        struct dentry *parent;
 
+        parent = dentry_kill(dentry, 0);
         /*
-         * Prune ancestors.  Locking is simpler than in dput(),
-         * because dcache_lock needs to be taken anyway.
+         * If dentry_kill returns NULL, we have nothing more to do.
+         * if it returns the same dentry, trylocks failed. In either
+         * case, just loop again.
+         *
+         * Otherwise, we need to prune ancestors too. This is necessary
+         * to prevent quadratic behavior of shrink_dcache_parent(), but
+         * is also expected to be beneficial in reducing dentry cache
+         * fragmentation.
          */
-        spin_lock(&dcache_lock);
+        if (!parent)
+                return;
+        if (parent == dentry)
+                return;
+
+        /* Prune ancestors. */
+        dentry = parent;
         while (dentry) {
-                if (!atomic_dec_and_lock(&dentry->d_count, &dentry->d_lock))
+                spin_lock(&dentry->d_lock);
+                if (dentry->d_count > 1) {
+                        dentry->d_count--;
+                        spin_unlock(&dentry->d_lock);
                         return;
-
-                if (dentry->d_op && dentry->d_op->d_delete)
-                        dentry->d_op->d_delete(dentry);
-                dentry_lru_del(dentry);
-                __d_drop(dentry);
-                dentry = d_kill(dentry);
-                spin_lock(&dcache_lock);
+                }
+                dentry = dentry_kill(dentry, 1);
         }
 }
 
@@ -459,24 +696,35 @@ static void shrink_dentry_list(struct list_head *list)
 {
         struct dentry *dentry;
 
-        while (!list_empty(list)) {
-                dentry = list_entry(list->prev, struct dentry, d_lru);
-                dentry_lru_del(dentry);
+        rcu_read_lock();
+        for (;;) {
+                dentry = list_entry_rcu(list->prev, struct dentry, d_lru);
+                if (&dentry->d_lru == list)
+                        break; /* empty */
+                spin_lock(&dentry->d_lock);
+                if (dentry != list_entry(list->prev, struct dentry, d_lru)) {
+                        spin_unlock(&dentry->d_lock);
+                        continue;
+                }
 
                 /*
                  * We found an inuse dentry which was not removed from
                  * the LRU because of laziness during lookup.  Do not free
                  * it - just keep it off the LRU list.
                  */
-                spin_lock(&dentry->d_lock);
-                if (atomic_read(&dentry->d_count)) {
+                if (dentry->d_count) {
+                        dentry_lru_del(dentry);
                         spin_unlock(&dentry->d_lock);
                         continue;
                 }
-                prune_one_dentry(dentry);
-                /* dentry->d_lock was dropped in prune_one_dentry() */
-                cond_resched_lock(&dcache_lock);
+
+                rcu_read_unlock();
+
+                try_prune_one_dentry(dentry);
+
+                rcu_read_lock();
         }
+        rcu_read_unlock();
 }
 
 /**
@@ -495,42 +743,44 @@ static void __shrink_dcache_sb(struct super_block *sb, int *count, int flags)
         LIST_HEAD(tmp);
         int cnt = *count;
 
-        spin_lock(&dcache_lock);
+relock:
+        spin_lock(&dcache_lru_lock);
         while (!list_empty(&sb->s_dentry_lru)) {
                 dentry = list_entry(sb->s_dentry_lru.prev,
                                 struct dentry, d_lru);
                 BUG_ON(dentry->d_sb != sb);
 
+                if (!spin_trylock(&dentry->d_lock)) {
+                        spin_unlock(&dcache_lru_lock);
+                        cpu_relax();
+                        goto relock;
+                }
+
                 /*
                  * If we are honouring the DCACHE_REFERENCED flag and the
                  * dentry has this flag set, don't free it.  Clear the flag
                  * and put it back on the LRU.
                  */
-                if (flags & DCACHE_REFERENCED) {
-                        spin_lock(&dentry->d_lock);
-                        if (dentry->d_flags & DCACHE_REFERENCED) {
-                                dentry->d_flags &= ~DCACHE_REFERENCED;
-                                list_move(&dentry->d_lru, &referenced);
-                                spin_unlock(&dentry->d_lock);
-                                cond_resched_lock(&dcache_lock);
-                                continue;
-                        }
+                if (flags & DCACHE_REFERENCED &&
+                                dentry->d_flags & DCACHE_REFERENCED) {
+                        dentry->d_flags &= ~DCACHE_REFERENCED;
+                        list_move(&dentry->d_lru, &referenced);
                         spin_unlock(&dentry->d_lock);
+                } else {
+                        list_move_tail(&dentry->d_lru, &tmp);
+                        spin_unlock(&dentry->d_lock);
+                        if (!--cnt)
+                                break;
                 }
-
-                list_move_tail(&dentry->d_lru, &tmp);
-                if (!--cnt)
-                        break;
-                cond_resched_lock(&dcache_lock);
+                cond_resched_lock(&dcache_lru_lock);
         }
-
-        *count = cnt;
-        shrink_dentry_list(&tmp);
-
         if (!list_empty(&referenced))
                 list_splice(&referenced, &sb->s_dentry_lru);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dcache_lru_lock);
 
+        shrink_dentry_list(&tmp);
+
+        *count = cnt;
 }
 
 /**
@@ -546,13 +796,12 @@ static void prune_dcache(int count)
 {
         struct super_block *sb, *p = NULL;
         int w_count;
-        int unused = percpu_counter_sum_positive(&nr_dentry_unused);
+        int unused = dentry_stat.nr_unused;
         int prune_ratio;
         int pruned;
 
         if (unused == 0 || count == 0)
                 return;
-        spin_lock(&dcache_lock);
         if (count >= unused)
                 prune_ratio = 1;
         else
@@ -589,11 +838,9 @@ static void prune_dcache(int count)
                 if (down_read_trylock(&sb->s_umount)) {
                         if ((sb->s_root != NULL) &&
                             (!list_empty(&sb->s_dentry_lru))) {
-                                spin_unlock(&dcache_lock);
                                 __shrink_dcache_sb(sb, &w_count,
                                                 DCACHE_REFERENCED);
                                 pruned -= w_count;
-                                spin_lock(&dcache_lock);
                         }
                         up_read(&sb->s_umount);
                 }
@@ -609,7 +856,6 @@ static void prune_dcache(int count)
         if (p)
                 __put_super(p);
         spin_unlock(&sb_lock);
-        spin_unlock(&dcache_lock);
 }
 
 /**
@@ -623,12 +869,14 @@ void shrink_dcache_sb(struct super_block *sb)
 {
         LIST_HEAD(tmp);
 
-        spin_lock(&dcache_lock);
+        spin_lock(&dcache_lru_lock);
         while (!list_empty(&sb->s_dentry_lru)) {
                 list_splice_init(&sb->s_dentry_lru, &tmp);
+                spin_unlock(&dcache_lru_lock);
                 shrink_dentry_list(&tmp);
+                spin_lock(&dcache_lru_lock);
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dcache_lru_lock);
 }
 EXPORT_SYMBOL(shrink_dcache_sb);
 
@@ -645,10 +893,10 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
         BUG_ON(!IS_ROOT(dentry));
 
         /* detach this root from the system */
-        spin_lock(&dcache_lock);
+        spin_lock(&dentry->d_lock);
         dentry_lru_del(dentry);
         __d_drop(dentry);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
 
         for (;;) {
                 /* descend to the first leaf in the current subtree */
@@ -657,14 +905,16 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
 
                         /* this is a branch with children - detach all of them
                          * from the system in one go */
-                        spin_lock(&dcache_lock);
+                        spin_lock(&dentry->d_lock);
                         list_for_each_entry(loop, &dentry->d_subdirs,
                                             d_u.d_child) {
+                                spin_lock_nested(&loop->d_lock,
+                                                DENTRY_D_LOCK_NESTED);
                                 dentry_lru_del(loop);
                                 __d_drop(loop);
-                                cond_resched_lock(&dcache_lock);
+                                spin_unlock(&loop->d_lock);
                         }
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&dentry->d_lock);
 
                         /* move to the first child */
                         dentry = list_entry(dentry->d_subdirs.next,
@@ -676,7 +926,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
                 do {
                         struct inode *inode;
 
-                        if (atomic_read(&dentry->d_count) != 0) {
+                        if (dentry->d_count != 0) {
                                 printk(KERN_ERR
                                        "BUG: Dentry %p{i=%lx,n=%s}"
                                        " still in use (%d)"
@@ -685,20 +935,23 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
                                        dentry->d_inode ?
                                        dentry->d_inode->i_ino : 0UL,
                                        dentry->d_name.name,
-                                       atomic_read(&dentry->d_count),
+                                       dentry->d_count,
                                        dentry->d_sb->s_type->name,
                                        dentry->d_sb->s_id);
                                 BUG();
                         }
 
-                        if (IS_ROOT(dentry))
+                        if (IS_ROOT(dentry)) {
                                 parent = NULL;
-                        else {
+                                list_del(&dentry->d_u.d_child);
+                        } else {
                                 parent = dentry->d_parent;
-                                atomic_dec(&parent->d_count);
+                                spin_lock(&parent->d_lock);
+                                parent->d_count--;
+                                list_del(&dentry->d_u.d_child);
+                                spin_unlock(&parent->d_lock);
                         }
 
-                        list_del(&dentry->d_u.d_child);
                         detached++;
 
                         inode = dentry->d_inode;
@@ -728,8 +981,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
 
 /*
  * destroy the dentries attached to a superblock on unmounting
- * - we don't need to use dentry->d_lock, and only need dcache_lock when
- *   removing the dentry from the system lists and hashes because:
+ * - we don't need to use dentry->d_lock because:
  *   - the superblock is detached from all mountings and open files, so the
  *     dentry trees will not be rearranged by the VFS
  *   - s_umount is write-locked, so the memory pressure shrinker will ignore
@@ -746,11 +998,13 @@ void shrink_dcache_for_umount(struct super_block *sb)
 
         dentry = sb->s_root;
         sb->s_root = NULL;
-        atomic_dec(&dentry->d_count);
+        spin_lock(&dentry->d_lock);
+        dentry->d_count--;
+        spin_unlock(&dentry->d_lock);
         shrink_dcache_for_umount_subtree(dentry);
 
-        while (!hlist_empty(&sb->s_anon)) {
-                dentry = hlist_entry(sb->s_anon.first, struct dentry, d_hash);
+        while (!hlist_bl_empty(&sb->s_anon)) {
+                dentry = hlist_bl_entry(hlist_bl_first(&sb->s_anon), struct dentry, d_hash);
                 shrink_dcache_for_umount_subtree(dentry);
         }
 }
@@ -768,15 +1022,20 @@ void shrink_dcache_for_umount(struct super_block *sb)
  * Return true if the parent or its subdirectories contain
  * a mount point
  */
- 
 int have_submounts(struct dentry *parent)
 {
-        struct dentry *this_parent = parent;
+        struct dentry *this_parent;
         struct list_head *next;
+        unsigned seq;
+        int locked = 0;
+
+        seq = read_seqbegin(&rename_lock);
+again:
+        this_parent = parent;
 
-        spin_lock(&dcache_lock);
         if (d_mountpoint(parent))
                 goto positive;
+        spin_lock(&this_parent->d_lock);
 repeat:
         next = this_parent->d_subdirs.next;
 resume:
@@ -784,27 +1043,65 @@ resume:
                 struct list_head *tmp = next;
                 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
                 next = tmp->next;
+
+                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
                 /* Have we found a mount point ? */
-                if (d_mountpoint(dentry))
+                if (d_mountpoint(dentry)) {
+                        spin_unlock(&dentry->d_lock);
+                        spin_unlock(&this_parent->d_lock);
                         goto positive;
+                }
                 if (!list_empty(&dentry->d_subdirs)) {
+                        spin_unlock(&this_parent->d_lock);
+                        spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
                         this_parent = dentry;
+                        spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
                         goto repeat;
                 }
+                spin_unlock(&dentry->d_lock);
         }
         /*
          * All done at this level ... ascend and resume the search.
          */
         if (this_parent != parent) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
+                struct dentry *tmp;
+                struct dentry *child;
+
+                tmp = this_parent->d_parent;
+                rcu_read_lock();
+                spin_unlock(&this_parent->d_lock);
+                child = this_parent;
+                this_parent = tmp;
+                spin_lock(&this_parent->d_lock);
+                /* might go back up the wrong parent if we have had a rename
+                 * or deletion */
+                if (this_parent != child->d_parent ||
+                         (!locked && read_seqretry(&rename_lock, seq))) {
+                        spin_unlock(&this_parent->d_lock);
+                        rcu_read_unlock();
+                        goto rename_retry;
+                }
+                rcu_read_unlock();
+                next = child->d_u.d_child.next;
                 goto resume;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&this_parent->d_lock);
+        if (!locked && read_seqretry(&rename_lock, seq))
+                goto rename_retry;
+        if (locked)
+                write_sequnlock(&rename_lock);
         return 0; /* No mount points found in tree */
 positive:
-        spin_unlock(&dcache_lock);
+        if (!locked && read_seqretry(&rename_lock, seq))
+                goto rename_retry;
+        if (locked)
+                write_sequnlock(&rename_lock);
         return 1;
+
+rename_retry:
+        locked = 1;
+        write_seqlock(&rename_lock);
+        goto again;
 }
 EXPORT_SYMBOL(have_submounts);
 
@@ -824,11 +1121,16 @@ EXPORT_SYMBOL(have_submounts);
  */
 static int select_parent(struct dentry * parent)
 {
-        struct dentry *this_parent = parent;
+        struct dentry *this_parent;
         struct list_head *next;
+        unsigned seq;
         int found = 0;
+        int locked = 0;
 
-        spin_lock(&dcache_lock);
+        seq = read_seqbegin(&rename_lock);
+again:
+        this_parent = parent;
+        spin_lock(&this_parent->d_lock);
 repeat:
         next = this_parent->d_subdirs.next;
 resume:
@@ -837,11 +1139,13 @@ resume:
                 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
                 next = tmp->next;
 
+                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
+
                 /* 
                  * move only zero ref count dentries to the end 
                  * of the unused list for prune_dcache
                  */
-                if (!atomic_read(&dentry->d_count)) {
+                if (!dentry->d_count) {
                         dentry_lru_move_tail(dentry);
                         found++;
                 } else {
@@ -853,28 +1157,63 @@ resume:
                  * ensures forward progress). We'll be coming back to find
                  * the rest.
                  */
-                if (found && need_resched())
+                if (found && need_resched()) {
+                        spin_unlock(&dentry->d_lock);
                         goto out;
+                }
 
                 /*
                  * Descend a level if the d_subdirs list is non-empty.
                  */
                 if (!list_empty(&dentry->d_subdirs)) {
+                        spin_unlock(&this_parent->d_lock);
+                        spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
                         this_parent = dentry;
+                        spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
                         goto repeat;
                 }
+
+                spin_unlock(&dentry->d_lock);
         }
         /*
          * All done at this level ... ascend and resume the search.
          */
         if (this_parent != parent) {
-                next = this_parent->d_u.d_child.next;
-                this_parent = this_parent->d_parent;
+                struct dentry *tmp;
+                struct dentry *child;
+
+                tmp = this_parent->d_parent;
+                rcu_read_lock();
+                spin_unlock(&this_parent->d_lock);
+                child = this_parent;
+                this_parent = tmp;
+                spin_lock(&this_parent->d_lock);
+                /* might go back up the wrong parent if we have had a rename
+                 * or deletion */
+                if (this_parent != child->d_parent ||
+                        (!locked && read_seqretry(&rename_lock, seq))) {
+                        spin_unlock(&this_parent->d_lock);
+                        rcu_read_unlock();
+                        goto rename_retry;
+                }
+                rcu_read_unlock();
+                next = child->d_u.d_child.next;
                 goto resume;
         }
 out:
-        spin_unlock(&dcache_lock);
+        spin_unlock(&this_parent->d_lock);
+        if (!locked && read_seqretry(&rename_lock, seq))
+                goto rename_retry;
+        if (locked)
+                write_sequnlock(&rename_lock);
         return found;
+
+rename_retry:
+        if (found)
+                return found;
+        locked = 1;
+        write_seqlock(&rename_lock);
+        goto again;
 }
 
 /**
@@ -908,16 +1247,13 @@ EXPORT_SYMBOL(shrink_dcache_parent);
  */
 static int shrink_dcache_memory(struct shrinker *shrink, int nr, gfp_t gfp_mask)
 {
-        int nr_unused;
-
         if (nr) {
                 if (!(gfp_mask & __GFP_FS))
                         return -1;
                 prune_dcache(nr);
         }
 
-        nr_unused = percpu_counter_sum_positive(&nr_dentry_unused);
-        return (nr_unused / 100) * sysctl_vfs_cache_pressure;
+        return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
 }
 
 static struct shrinker dcache_shrinker = {
@@ -960,38 +1296,52 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
         memcpy(dname, name->name, name->len);
         dname[name->len] = 0;
 
-        atomic_set(&dentry->d_count, 1);
+        dentry->d_count = 1;
         dentry->d_flags = DCACHE_UNHASHED;
         spin_lock_init(&dentry->d_lock);
+        seqcount_init(&dentry->d_seq);
         dentry->d_inode = NULL;
         dentry->d_parent = NULL;
         dentry->d_sb = NULL;
         dentry->d_op = NULL;
         dentry->d_fsdata = NULL;
-        dentry->d_mounted = 0;
-        INIT_HLIST_NODE(&dentry->d_hash);
+        INIT_HLIST_BL_NODE(&dentry->d_hash);
         INIT_LIST_HEAD(&dentry->d_lru);
         INIT_LIST_HEAD(&dentry->d_subdirs);
         INIT_LIST_HEAD(&dentry->d_alias);
+        INIT_LIST_HEAD(&dentry->d_u.d_child);
 
         if (parent) {
-                dentry->d_parent = dget(parent);
+                spin_lock(&parent->d_lock);
+                /*
+                 * don't need child lock because it is not subject
+                 * to concurrency here
+                 */
+                __dget_dlock(parent);
+                dentry->d_parent = parent;
                 dentry->d_sb = parent->d_sb;
-        } else {
-                INIT_LIST_HEAD(&dentry->d_u.d_child);
-        }
-
-        spin_lock(&dcache_lock);
-        if (parent)
                 list_add(&dentry->d_u.d_child, &parent->d_subdirs);
-        spin_unlock(&dcache_lock);
+                spin_unlock(&parent->d_lock);
+        }
 
-        percpu_counter_inc(&nr_dentry);
+        this_cpu_inc(nr_dentry);
 
         return dentry;
 }
 EXPORT_SYMBOL(d_alloc);
 
+struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name)
+{
+        struct dentry *dentry = d_alloc(NULL, name);
+        if (dentry) {
+                dentry->d_sb = sb;
+                dentry->d_parent = dentry;
+                dentry->d_flags |= DCACHE_DISCONNECTED;
+        }
+        return dentry;
+}
+EXPORT_SYMBOL(d_alloc_pseudo);
+
 struct dentry *d_alloc_name(struct dentry *parent, const char *name)
 {
         struct qstr q;
@@ -1003,12 +1353,36 @@ struct dentry *d_alloc_name(struct dentry *parent, const char *name)
 }
 EXPORT_SYMBOL(d_alloc_name);
 
-/* the caller must hold dcache_lock */
+void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
+{
+        BUG_ON(dentry->d_op);
+        BUG_ON(dentry->d_flags & (DCACHE_OP_HASH        |
+                                DCACHE_OP_COMPARE       |
+                                DCACHE_OP_REVALIDATE    |
+                                DCACHE_OP_DELETE ));
+        dentry->d_op = op;
+        if (!op)
+                return;
+        if (op->d_hash)
+                dentry->d_flags |= DCACHE_OP_HASH;
+        if (op->d_compare)
+                dentry->d_flags |= DCACHE_OP_COMPARE;
+        if (op->d_revalidate)
+                dentry->d_flags |= DCACHE_OP_REVALIDATE;
+        if (op->d_delete)
+                dentry->d_flags |= DCACHE_OP_DELETE;
+
+}
+EXPORT_SYMBOL(d_set_d_op);
+
 static void __d_instantiate(struct dentry *dentry, struct inode *inode)
 {
+        spin_lock(&dentry->d_lock);
         if (inode)
                 list_add(&dentry->d_alias, &inode->i_dentry);
         dentry->d_inode = inode;
+        dentry_rcuwalk_barrier(dentry);
+        spin_unlock(&dentry->d_lock);
         fsnotify_d_instantiate(dentry, inode);
 }
 
@@ -1030,9 +1404,11 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
 void d_instantiate(struct dentry *entry, struct inode * inode)
 {
         BUG_ON(!list_empty(&entry->d_alias));
-        spin_lock(&dcache_lock);
+        if (inode)
+                spin_lock(&inode->i_lock);
         __d_instantiate(entry, inode);
-        spin_unlock(&dcache_lock);
+        if (inode)
+                spin_unlock(&inode->i_lock);
         security_d_instantiate(entry, inode);
 }
 EXPORT_SYMBOL(d_instantiate);
@@ -1069,15 +1445,18 @@ static struct dentry *__d_instantiate_unique(struct dentry *entry,
         list_for_each_entry(alias, &inode->i_dentry, d_alias) {
                 struct qstr *qstr = &alias->d_name;
 
+                /*
+                 * Don't need alias->d_lock here, because aliases with
+                 * d_parent == entry->d_parent are not subject to name or
+                 * parent changes, because the parent inode i_mutex is held.
+                 */
                 if (qstr->hash != hash)
                         continue;
                 if (alias->d_parent != entry->d_parent)
                         continue;
-                if (qstr->len != len)
+                if (dentry_cmp(qstr->name, qstr->len, name, len))
                         continue;
-                if (memcmp(qstr->name, name, len))
-                        continue;
-                dget_locked(alias);
+                __dget(alias);
                 return alias;
         }
 
@@ -1091,9 +1470,11 @@ struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
 
         BUG_ON(!list_empty(&entry->d_alias));
 
-        spin_lock(&dcache_lock);
+        if (inode)
+                spin_lock(&inode->i_lock);
         result = __d_instantiate_unique(entry, inode);
-        spin_unlock(&dcache_lock);
+        if (inode)
+                spin_unlock(&inode->i_lock);
 
         if (!result) {
                 security_d_instantiate(entry, inode);
@@ -1134,14 +1515,6 @@ struct dentry * d_alloc_root(struct inode * root_inode)
 }
 EXPORT_SYMBOL(d_alloc_root);
 
-static inline struct hlist_head *d_hash(struct dentry *parent,
-                                        unsigned long hash)
-{
-        hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES;
-        hash = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS);
-        return dentry_hashtable + (hash & D_HASHMASK);
-}
-
 /**
  * d_obtain_alias - find or allocate a dentry for a given inode
  * @inode: inode to allocate the dentry for
@@ -1182,10 +1555,11 @@ struct dentry *d_obtain_alias(struct inode *inode)
         }
         tmp->d_parent = tmp; /* make sure dput doesn't croak */
 
-        spin_lock(&dcache_lock);
+
+        spin_lock(&inode->i_lock);
         res = __d_find_alias(inode, 0);
         if (res) {
-                spin_unlock(&dcache_lock);
+                spin_unlock(&inode->i_lock);
                 dput(tmp);
                 goto out_iput;
         }
@@ -1195,12 +1569,14 @@ struct dentry *d_obtain_alias(struct inode *inode)
         tmp->d_sb = inode->i_sb;
         tmp->d_inode = inode;
         tmp->d_flags |= DCACHE_DISCONNECTED;
-        tmp->d_flags &= ~DCACHE_UNHASHED;
         list_add(&tmp->d_alias, &inode->i_dentry);
-        hlist_add_head(&tmp->d_hash, &inode->i_sb->s_anon);
+        bit_spin_lock(0, (unsigned long *)&tmp->d_sb->s_anon.first);
+        tmp->d_flags &= ~DCACHE_UNHASHED;
+        hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon);
+        __bit_spin_unlock(0, (unsigned long *)&tmp->d_sb->s_anon.first);
         spin_unlock(&tmp->d_lock);
+        spin_unlock(&inode->i_lock);
 
-        spin_unlock(&dcache_lock);
         return tmp;
 
  out_iput:
@@ -1230,18 +1606,18 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
         struct dentry *new = NULL;
 
         if (inode && S_ISDIR(inode->i_mode)) {
-                spin_lock(&dcache_lock);
+                spin_lock(&inode->i_lock);
                 new = __d_find_alias(inode, 1);
                 if (new) {
                         BUG_ON(!(new->d_flags & DCACHE_DISCONNECTED));
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&inode->i_lock);
                         security_d_instantiate(new, inode);
                         d_move(new, dentry);
                         iput(inode);
                 } else {
-                        /* already taking dcache_lock, so d_add() by hand */
+                        /* already taking inode->i_lock, so d_add() by hand */
                         __d_instantiate(dentry, inode);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&inode->i_lock);
                         security_d_instantiate(dentry, inode);
                         d_rehash(dentry);
                 }
@@ -1314,10 +1690,10 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
          * Negative dentry: instantiate it unless the inode is a directory and
          * already has a dentry.
          */
-        spin_lock(&dcache_lock);
+        spin_lock(&inode->i_lock);
         if (!S_ISDIR(inode->i_mode) || list_empty(&inode->i_dentry)) {
                 __d_instantiate(found, inode);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&inode->i_lock);
                 security_d_instantiate(found, inode);
                 return found;
         }
@@ -1327,8 +1703,8 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
          * reference to it, move it in place and use it.
          */
         new = list_entry(inode->i_dentry.next, struct dentry, d_alias);
-        dget_locked(new);
-        spin_unlock(&dcache_lock);
+        __dget(new);
+        spin_unlock(&inode->i_lock);
         security_d_instantiate(found, inode);
         d_move(new, found);
         iput(inode);
@@ -1342,6 +1718,112 @@ err_out:
 EXPORT_SYMBOL(d_add_ci);
 
 /**
+ * __d_lookup_rcu - search for a dentry (racy, store-free)
+ * @parent: parent dentry
+ * @name: qstr of name we wish to find
+ * @seq: returns d_seq value at the point where the dentry was found
+ * @inode: returns dentry->d_inode when the inode was found valid.
+ * Returns: dentry, or NULL
+ *
+ * __d_lookup_rcu is the dcache lookup function for rcu-walk name
+ * resolution (store-free path walking) design described in
+ * Documentation/filesystems/path-lookup.txt.
+ *
+ * This is not to be used outside core vfs.
+ *
+ * __d_lookup_rcu must only be used in rcu-walk mode, ie. with vfsmount lock
+ * held, and rcu_read_lock held. The returned dentry must not be stored into
+ * without taking d_lock and checking d_seq sequence count against @seq
+ * returned here.
+ *
+ * A refcount may be taken on the found dentry with the __d_rcu_to_refcount
+ * function.
+ *
+ * Alternatively, __d_lookup_rcu may be called again to look up the child of
+ * the returned dentry, so long as its parent's seqlock is checked after the
+ * child is looked up. Thus, an interlocking stepping of sequence lock checks
+ * is formed, giving integrity down the path walk.
+ */
+struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name,
+                                unsigned *seq, struct inode **inode)
+{
+        unsigned int len = name->len;
+        unsigned int hash = name->hash;
+        const unsigned char *str = name->name;
+        struct dcache_hash_bucket *b = d_hash(parent, hash);
+        struct hlist_bl_node *node;
+        struct dentry *dentry;
+
+        /*
+         * Note: There is significant duplication with __d_lookup_rcu which is
+         * required to prevent single threaded performance regressions
+         * especially on architectures where smp_rmb (in seqcounts) are costly.
+         * Keep the two functions in sync.
+         */
+
+        /*
+         * The hash list is protected using RCU.
+         *
+         * Carefully use d_seq when comparing a candidate dentry, to avoid
+         * races with d_move().
+         *
+         * It is possible that concurrent renames can mess up our list
+         * walk here and result in missing our dentry, resulting in the
+         * false-negative result. d_lookup() protects against concurrent
+         * renames using rename_lock seqlock.
+         *
+         * See Documentation/vfs/dcache-locking.txt for more details.
+         */
+        hlist_bl_for_each_entry_rcu(dentry, node, &b->head, d_hash) {
+                struct inode *i;
+                const char *tname;
+                int tlen;
+
+                if (dentry->d_name.hash != hash)
+                        continue;
+
+seqretry:
+                *seq = read_seqcount_begin(&dentry->d_seq);
+                if (dentry->d_parent != parent)
+                        continue;
+                if (d_unhashed(dentry))
+                        continue;
+                tlen = dentry->d_name.len;
+                tname = dentry->d_name.name;
+                i = dentry->d_inode;
+                prefetch(tname);
+                if (i)
+                        prefetch(i);
+                /*
+                 * This seqcount check is required to ensure name and
+                 * len are loaded atomically, so as not to walk off the
+                 * edge of memory when walking. If we could load this
+                 * atomically some other way, we could drop this check.
+                 */
+                if (read_seqcount_retry(&dentry->d_seq, *seq))
+                        goto seqretry;
+                if (parent->d_flags & DCACHE_OP_COMPARE) {
+                        if (parent->d_op->d_compare(parent, *inode,
+                                                dentry, i,
+                                                tlen, tname, name))
+                                continue;
+                } else {
+                        if (dentry_cmp(tname, tlen, str, len))
+                                continue;
+                }
+                /*
+                 * No extra seqcount check is required after the name
+                 * compare. The caller must perform a seqcount check in
+                 * order to do anything useful with the returned dentry
+                 * anyway.
+                 */
+                *inode = i;
+                return dentry;
+        }
+        return NULL;
+}
+
+/**
  * d_lookup - search for a dentry
  * @parent: parent dentry
  * @name: qstr of name we wish to find
@@ -1352,10 +1834,10 @@ EXPORT_SYMBOL(d_add_ci);
  * dentry is returned. The caller must use dput to free the entry when it has
  * finished using it. %NULL is returned if the dentry does not exist.
  */
-struct dentry * d_lookup(struct dentry * parent, struct qstr * name)
+struct dentry *d_lookup(struct dentry *parent, struct qstr *name)
 {
-        struct dentry * dentry = NULL;
-        unsigned long seq;
+        struct dentry *dentry;
+        unsigned seq;
 
         do {
                 seq = read_seqbegin(&rename_lock);
@@ -1367,7 +1849,7 @@ struct dentry * d_lookup(struct dentry * parent, struct qstr * name)
 }
 EXPORT_SYMBOL(d_lookup);
 
-/*
+/**
  * __d_lookup - search for a dentry (racy)
  * @parent: parent dentry
  * @name: qstr of name we wish to find
@@ -1382,17 +1864,24 @@ EXPORT_SYMBOL(d_lookup);
  *
  * __d_lookup callers must be commented.
  */
-struct dentry * __d_lookup(struct dentry * parent, struct qstr * name)
+struct dentry *__d_lookup(struct dentry *parent, struct qstr *name)
 {
         unsigned int len = name->len;
         unsigned int hash = name->hash;
         const unsigned char *str = name->name;
-        struct hlist_head *head = d_hash(parent,hash);
+        struct dcache_hash_bucket *b = d_hash(parent, hash);
+        struct hlist_bl_node *node;
         struct dentry *found = NULL;
-        struct hlist_node *node;
         struct dentry *dentry;
 
         /*
+         * Note: There is significant duplication with __d_lookup_rcu which is
+         * required to prevent single threaded performance regressions
+         * especially on architectures where smp_rmb (in seqcounts) are costly.
+         * Keep the two functions in sync.
+         */
+
+        /*
          * The hash list is protected using RCU.
          *
          * Take d_lock when comparing a candidate dentry, to avoid races
@@ -1407,25 +1896,16 @@ struct dentry * __d_lookup(struct dentry * parent, struct qstr * name)
          */
         rcu_read_lock();
         
-        hlist_for_each_entry_rcu(dentry, node, head, d_hash) {
-                struct qstr *qstr;
+        hlist_bl_for_each_entry_rcu(dentry, node, &b->head, d_hash) {
+                const char *tname;
+                int tlen;
 
                 if (dentry->d_name.hash != hash)
                         continue;
-                if (dentry->d_parent != parent)
-                        continue;
 
                 spin_lock(&dentry->d_lock);
-
-                /*
-                 * Recheck the dentry after taking the lock - d_move may have
-                 * changed things. Don't bother checking the hash because
-                 * we're about to compare the whole name anyway.
-                 */
                 if (dentry->d_parent != parent)
                         goto next;
-
-                /* non-existing due to RCU? */
                 if (d_unhashed(dentry))
                         goto next;
 
@@ -1433,18 +1913,19 @@ struct dentry * __d_lookup(struct dentry * parent, struct qstr * name)
                  * It is safe to compare names since d_move() cannot
                  * change the qstr (protected by d_lock).
                  */
-                qstr = &dentry->d_name;
-                if (parent->d_op && parent->d_op->d_compare) {
-                        if (parent->d_op->d_compare(parent, qstr, name))
+                tlen = dentry->d_name.len;
+                tname = dentry->d_name.name;
+                if (parent->d_flags & DCACHE_OP_COMPARE) {
+                        if (parent->d_op->d_compare(parent, parent->d_inode,
+                                                dentry, dentry->d_inode,
+                                                tlen, tname, name))
                                 goto next;
                 } else {
-                        if (qstr->len != len)
-                                goto next;
-                        if (memcmp(qstr->name, str, len))
+                        if (dentry_cmp(tname, tlen, str, len))
                                 goto next;
                 }
 
-                atomic_inc(&dentry->d_count);
+                dentry->d_count++;
                 found = dentry;
                 spin_unlock(&dentry->d_lock);
                 break;
@@ -1473,8 +1954,8 @@ struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name)
          * routine may choose to leave the hash value unchanged.
          */
         name->hash = full_name_hash(name->name, name->len);
-        if (dir->d_op && dir->d_op->d_hash) {
-                if (dir->d_op->d_hash(dir, name) < 0)
+        if (dir->d_flags & DCACHE_OP_HASH) {
+                if (dir->d_op->d_hash(dir, dir->d_inode, name) < 0)
                         goto out;
         }
         dentry = d_lookup(dir, name);
@@ -1483,34 +1964,32 @@ out:
 }
 
 /**
- * d_validate - verify dentry provided from insecure source
+ * d_validate - verify dentry provided from insecure source (deprecated)
  * @dentry: The dentry alleged to be valid child of @dparent
  * @dparent: The parent dentry (known to be valid)
  *
  * An insecure source has sent us a dentry, here we verify it and dget() it.
  * This is used by ncpfs in its readdir implementation.
  * Zero is returned in the dentry is invalid.
+ *
+ * This function is slow for big directories, and deprecated, do not use it.
  */
-int d_validate(struct dentry *dentry, struct dentry *parent)
+int d_validate(struct dentry *dentry, struct dentry *dparent)
 {
-        struct hlist_head *head = d_hash(parent, dentry->d_name.hash);
-        struct hlist_node *node;
-        struct dentry *d;
-
-        /* Check whether the ptr might be valid at all.. */
-        if (!kmem_ptr_validate(dentry_cache, dentry))
-                return 0;
-        if (dentry->d_parent != parent)
-                return 0;
+        struct dentry *child;
 
-        rcu_read_lock();
-        hlist_for_each_entry_rcu(d, node, head, d_hash) {
-                if (d == dentry) {
-                        dget(dentry);
+        spin_lock(&dparent->d_lock);
+        list_for_each_entry(child, &dparent->d_subdirs, d_u.d_child) {
+                if (dentry == child) {
+                        spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
+                        __dget_dlock(dentry);
+                        spin_unlock(&dentry->d_lock);
+                        spin_unlock(&dparent->d_lock);
                         return 1;
                 }
         }
-        rcu_read_unlock();
+        spin_unlock(&dparent->d_lock);
+
         return 0;
 }
 EXPORT_SYMBOL(d_validate);
@@ -1538,16 +2017,23 @@ EXPORT_SYMBOL(d_validate);
  
 void d_delete(struct dentry * dentry)
 {
+        struct inode *inode;
         int isdir = 0;
         /*
          * Are we the only user?
          */
-        spin_lock(&dcache_lock);
+again:
         spin_lock(&dentry->d_lock);
-        isdir = S_ISDIR(dentry->d_inode->i_mode);
-        if (atomic_read(&dentry->d_count) == 1) {
+        inode = dentry->d_inode;
+        isdir = S_ISDIR(inode->i_mode);
+        if (dentry->d_count == 1) {
+                if (inode && !spin_trylock(&inode->i_lock)) {
+                        spin_unlock(&dentry->d_lock);
+                        cpu_relax();
+                        goto again;
+                }
                 dentry->d_flags &= ~DCACHE_CANT_MOUNT;
-                dentry_iput(dentry);
+                dentry_unlink_inode(dentry);
                 fsnotify_nameremove(dentry, isdir);
                 return;
         }
@@ -1556,17 +2042,18 @@ void d_delete(struct dentry * dentry)
                 __d_drop(dentry);
 
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
 
         fsnotify_nameremove(dentry, isdir);
 }
 EXPORT_SYMBOL(d_delete);
 
-static void __d_rehash(struct dentry * entry, struct hlist_head *list)
+static void __d_rehash(struct dentry * entry, struct dcache_hash_bucket *b)
 {
-
+        BUG_ON(!d_unhashed(entry));
+        spin_lock_bucket(b);
         entry->d_flags &= ~DCACHE_UNHASHED;
-        hlist_add_head_rcu(&entry->d_hash, list);
+        hlist_bl_add_head_rcu(&entry->d_hash, &b->head);
+        spin_unlock_bucket(b);
 }
 
 static void _d_rehash(struct dentry * entry)
@@ -1583,25 +2070,39 @@ static void _d_rehash(struct dentry * entry)
  
 void d_rehash(struct dentry * entry)
 {
-        spin_lock(&dcache_lock);
         spin_lock(&entry->d_lock);
         _d_rehash(entry);
         spin_unlock(&entry->d_lock);
-        spin_unlock(&dcache_lock);
 }
 EXPORT_SYMBOL(d_rehash);
 
-/*
- * When switching names, the actual string doesn't strictly have to
- * be preserved in the target - because we're dropping the target
- * anyway. As such, we can just do a simple memcpy() to copy over
- * the new name before we switch.
+/**
+ * dentry_update_name_case - update case insensitive dentry with a new name
+ * @dentry: dentry to be updated
+ * @name: new name
  *
- * Note that we have to be a lot more careful about getting the hash
- * switched - we have to switch the hash value properly even if it
- * then no longer matches the actual (corrupted) string of the target.
- * The hash value has to match the hash queue that the dentry is on..
+ * Update a case insensitive dentry with new case of name.
+ *
+ * dentry must have been returned by d_lookup with name @name. Old and new
+ * name lengths must match (ie. no d_compare which allows mismatched name
+ * lengths).
+ *
+ * Parent inode i_mutex must be held over d_lookup and into this call (to
+ * keep renames and concurrent inserts, and readdir(2) away).
  */
+void dentry_update_name_case(struct dentry *dentry, struct qstr *name)
+{
+        BUG_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
+        BUG_ON(dentry->d_name.len != name->len); /* d_lookup gives this */
+
+        spin_lock(&dentry->d_lock);
+        write_seqcount_begin(&dentry->d_seq);
+        memcpy((unsigned char *)dentry->d_name.name, name->name, name->len);
+        write_seqcount_end(&dentry->d_seq);
+        spin_unlock(&dentry->d_lock);
+}
+EXPORT_SYMBOL(dentry_update_name_case);
+
 static void switch_names(struct dentry *dentry, struct dentry *target)
 {
         if (dname_external(target)) {
@@ -1643,54 +2144,84 @@ static void switch_names(struct dentry *dentry, struct dentry *target)
         swap(dentry->d_name.len, target->d_name.len);
 }
 
+static void dentry_lock_for_move(struct dentry *dentry, struct dentry *target)
+{
+        /*
+         * XXXX: do we really need to take target->d_lock?
+         */
+        if (IS_ROOT(dentry) || dentry->d_parent == target->d_parent)
+                spin_lock(&target->d_parent->d_lock);
+        else {
+                if (d_ancestor(dentry->d_parent, target->d_parent)) {
+                        spin_lock(&dentry->d_parent->d_lock);
+                        spin_lock_nested(&target->d_parent->d_lock,
+                                                DENTRY_D_LOCK_NESTED);
+                } else {
+                        spin_lock(&target->d_parent->d_lock);
+                        spin_lock_nested(&dentry->d_parent->d_lock,
+                                                DENTRY_D_LOCK_NESTED);
+                }
+        }
+        if (target < dentry) {
+                spin_lock_nested(&target->d_lock, 2);
+                spin_lock_nested(&dentry->d_lock, 3);
+        } else {
+                spin_lock_nested(&dentry->d_lock, 2);
+                spin_lock_nested(&target->d_lock, 3);
+        }
+}
+
+static void dentry_unlock_parents_for_move(struct dentry *dentry,
+                                        struct dentry *target)
+{
+        if (target->d_parent != dentry->d_parent)
+                spin_unlock(&dentry->d_parent->d_lock);
+        if (target->d_parent != target)
+                spin_unlock(&target->d_parent->d_lock);
+}
+
 /*
- * We cannibalize "target" when moving dentry on top of it,
- * because it's going to be thrown away anyway. We could be more
- * polite about it, though.
- *
- * This forceful removal will result in ugly /proc output if
- * somebody holds a file open that got deleted due to a rename.
- * We could be nicer about the deleted file, and let it show
- * up under the name it had before it was deleted rather than
- * under the original name of the file that was moved on top of it.
+ * When switching names, the actual string doesn't strictly have to
+ * be preserved in the target - because we're dropping the target
+ * anyway. As such, we can just do a simple memcpy() to copy over
+ * the new name before we switch.
+ *
+ * Note that we have to be a lot more careful about getting the hash
+ * switched - we have to switch the hash value properly even if it
+ * then no longer matches the actual (corrupted) string of the target.
+ * The hash value has to match the hash queue that the dentry is on..
  */
- 
 /*
- * d_move_locked - move a dentry
+ * d_move - move a dentry
  * @dentry: entry to move
  * @target: new dentry
  *
  * Update the dcache to reflect the move of a file name. Negative
  * dcache entries should not be moved in this way.
  */
-static void d_move_locked(struct dentry * dentry, struct dentry * target)
+void d_move(struct dentry * dentry, struct dentry * target)
 {
-        struct hlist_head *list;
-
         if (!dentry->d_inode)
                 printk(KERN_WARNING "VFS: moving negative dcache entry\n");
 
+        BUG_ON(d_ancestor(dentry, target));
+        BUG_ON(d_ancestor(target, dentry));
+
         write_seqlock(&rename_lock);
-        /*
-         * XXXX: do we really need to take target->d_lock?
-         */
-        if (target < dentry) {
-                spin_lock(&target->d_lock);
-                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
-        } else {
-                spin_lock(&dentry->d_lock);
-                spin_lock_nested(&target->d_lock, DENTRY_D_LOCK_NESTED);
-        }
 
-        /* Move the dentry to the target hash queue, if on different bucket */
-        if (d_unhashed(dentry))
-                goto already_unhashed;
+        dentry_lock_for_move(dentry, target);
 
-        hlist_del_rcu(&dentry->d_hash);
+        write_seqcount_begin(&dentry->d_seq);
+        write_seqcount_begin(&target->d_seq);
 
-already_unhashed:
-        list = d_hash(target->d_parent, target->d_name.hash);
-        __d_rehash(dentry, list);
+        /* __d_drop does write_seqcount_barrier, but they're OK to nest. */
+
+        /*
+         * Move the dentry to the target hash queue. Don't bother checking
+         * for the same hash queue because of how unlikely it is.
+         */
+        __d_drop(dentry);
+        __d_rehash(dentry, d_hash(target->d_parent, target->d_name.hash));
 
         /* Unhash the target: dput() will then get rid of it */
         __d_drop(target);
@@ -1715,27 +2246,16 @@ already_unhashed:
         }
 
         list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs);
+
+        write_seqcount_end(&target->d_seq);
+        write_seqcount_end(&dentry->d_seq);
+
+        dentry_unlock_parents_for_move(dentry, target);
         spin_unlock(&target->d_lock);
         fsnotify_d_move(dentry);
         spin_unlock(&dentry->d_lock);
         write_sequnlock(&rename_lock);
 }
-
-/**
- * d_move - move a dentry
- * @dentry: entry to move
- * @target: new dentry
- *
- * Update the dcache to reflect the move of a file name. Negative
- * dcache entries should not be moved in this way.
- */
-
-void d_move(struct dentry * dentry, struct dentry * target)
-{
-        spin_lock(&dcache_lock);
-        d_move_locked(dentry, target);
-        spin_unlock(&dcache_lock);
-}
 EXPORT_SYMBOL(d_move);
 
 /**
@@ -1761,13 +2281,13 @@ struct dentry *d_ancestor(struct dentry *p1, struct dentry *p2)
  * This helper attempts to cope with remotely renamed directories
  *
  * It assumes that the caller is already holding
- * dentry->d_parent->d_inode->i_mutex and the dcache_lock
+ * dentry->d_parent->d_inode->i_mutex and the inode->i_lock
  *
  * Note: If ever the locking in lock_rename() changes, then please
  * remember to update this too...
  */
-static struct dentry *__d_unalias(struct dentry *dentry, struct dentry *alias)
-        __releases(dcache_lock)
+static struct dentry *__d_unalias(struct inode *inode,
+                struct dentry *dentry, struct dentry *alias)
 {
         struct mutex *m1 = NULL, *m2 = NULL;
         struct dentry *ret;
@@ -1790,10 +2310,10 @@ static struct dentry *__d_unalias(struct dentry *dentry, struct dentry *alias)
                 goto out_err;
         m2 = &alias->d_parent->d_inode->i_mutex;
 out_unalias:
-        d_move_locked(alias, dentry);
+        d_move(alias, dentry);
         ret = alias;
 out_err:
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
         if (m2)
                 mutex_unlock(m2);
         if (m1)
@@ -1804,17 +2324,23 @@ out_err:
 /*
  * Prepare an anonymous dentry for life in the superblock's dentry tree as a
  * named dentry in place of the dentry to be replaced.
+ * returns with anon->d_lock held!
  */
 static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
 {
         struct dentry *dparent, *aparent;
 
-        switch_names(dentry, anon);
-        swap(dentry->d_name.hash, anon->d_name.hash);
+        dentry_lock_for_move(anon, dentry);
+
+        write_seqcount_begin(&dentry->d_seq);
+        write_seqcount_begin(&anon->d_seq);
 
         dparent = dentry->d_parent;
         aparent = anon->d_parent;
 
+        switch_names(dentry, anon);
+        swap(dentry->d_name.hash, anon->d_name.hash);
+
         dentry->d_parent = (aparent == anon) ? dentry : aparent;
         list_del(&dentry->d_u.d_child);
         if (!IS_ROOT(dentry))
@@ -1829,6 +2355,13 @@ static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
         else
                 INIT_LIST_HEAD(&anon->d_u.d_child);
 
+        write_seqcount_end(&dentry->d_seq);
+        write_seqcount_end(&anon->d_seq);
+
+        dentry_unlock_parents_for_move(anon, dentry);
+        spin_unlock(&dentry->d_lock);
+
+        /* anon->d_lock still locked, returns locked */
         anon->d_flags &= ~DCACHE_DISCONNECTED;
 }
 
@@ -1846,14 +2379,15 @@ struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
 
         BUG_ON(!d_unhashed(dentry));
 
-        spin_lock(&dcache_lock);
-
         if (!inode) {
                 actual = dentry;
                 __d_instantiate(dentry, NULL);
-                goto found_lock;
+                d_rehash(actual);
+                goto out_nolock;
         }
 
+        spin_lock(&inode->i_lock);
+
         if (S_ISDIR(inode->i_mode)) {
                 struct dentry *alias;
 
@@ -1864,13 +2398,12 @@ struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
                         /* Is this an anonymous mountpoint that we could splice
                          * into our tree? */
                         if (IS_ROOT(alias)) {
-                                spin_lock(&alias->d_lock);
                                 __d_materialise_dentry(dentry, alias);
                                 __d_drop(alias);
                                 goto found;
                         }
                         /* Nope, but we must(!) avoid directory aliasing */
-                        actual = __d_unalias(dentry, alias);
+                        actual = __d_unalias(inode, dentry, alias);
                         if (IS_ERR(actual))
                                 dput(alias);
                         goto out_nolock;
@@ -1881,15 +2414,14 @@ struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode)
         actual = __d_instantiate_unique(dentry, inode);
         if (!actual)
                 actual = dentry;
-        else if (unlikely(!d_unhashed(actual)))
-                goto shouldnt_be_hashed;
+        else
+                BUG_ON(!d_unhashed(actual));
 
-found_lock:
         spin_lock(&actual->d_lock);
 found:
         _d_rehash(actual);
         spin_unlock(&actual->d_lock);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
 out_nolock:
         if (actual == dentry) {
                 security_d_instantiate(dentry, inode);
@@ -1898,10 +2430,6 @@ out_nolock:
 
         iput(inode);
         return actual;
-
-shouldnt_be_hashed:
-        spin_unlock(&dcache_lock);
-        BUG();
 }
 EXPORT_SYMBOL_GPL(d_materialise_unique);
 
@@ -1928,7 +2456,7 @@ static int prepend_name(char **buffer, int *buflen, struct qstr *name)
  * @buffer: pointer to the end of the buffer
  * @buflen: pointer to buffer length
  *
- * Caller holds the dcache_lock.
+ * Caller holds the rename_lock.
  *
  * If path is not reachable from the supplied root, then the value of
  * root is changed (without modifying refcounts).
@@ -1956,7 +2484,9 @@ static int prepend_path(const struct path *path, struct path *root,
                 }
                 parent = dentry->d_parent;
                 prefetch(parent);
+                spin_lock(&dentry->d_lock);
                 error = prepend_name(buffer, buflen, &dentry->d_name);
+                spin_unlock(&dentry->d_lock);
                 if (!error)
                         error = prepend(buffer, buflen, "/", 1);
                 if (error)
@@ -2012,9 +2542,9 @@ char *__d_path(const struct path *path, struct path *root,
         int error;
 
         prepend(&res, &buflen, "\0", 1);
-        spin_lock(&dcache_lock);
+        write_seqlock(&rename_lock);
         error = prepend_path(path, root, &res, &buflen);
-        spin_unlock(&dcache_lock);
+        write_sequnlock(&rename_lock);
 
         if (error)
                 return ERR_PTR(error);
@@ -2076,12 +2606,12 @@ char *d_path(const struct path *path, char *buf, int buflen)
                 return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
 
         get_fs_root(current->fs, &root);
-        spin_lock(&dcache_lock);
+        write_seqlock(&rename_lock);
         tmp = root;
         error = path_with_deleted(path, &tmp, &res, &buflen);
         if (error)
                 res = ERR_PTR(error);
-        spin_unlock(&dcache_lock);
+        write_sequnlock(&rename_lock);
         path_put(&root);
         return res;
 }
@@ -2107,12 +2637,12 @@ char *d_path_with_unreachable(const struct path *path, char *buf, int buflen)
                 return path->dentry->d_op->d_dname(path->dentry, buf, buflen);
 
         get_fs_root(current->fs, &root);
-        spin_lock(&dcache_lock);
+        write_seqlock(&rename_lock);
         tmp = root;
         error = path_with_deleted(path, &tmp, &res, &buflen);
         if (!error && !path_equal(&tmp, &root))
                 error = prepend_unreachable(&res, &buflen);
-        spin_unlock(&dcache_lock);
+        write_sequnlock(&rename_lock);
         path_put(&root);
         if (error)
                 res =  ERR_PTR(error);
@@ -2144,7 +2674,7 @@ char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
 /*
  * Write full pathname from the root of the filesystem into the buffer.
  */
-char *__dentry_path(struct dentry *dentry, char *buf, int buflen)
+static char *__dentry_path(struct dentry *dentry, char *buf, int buflen)
 {
         char *end = buf + buflen;
         char *retval;
@@ -2158,10 +2688,13 @@ char *__dentry_path(struct dentry *dentry, char *buf, int buflen)
 
         while (!IS_ROOT(dentry)) {
                 struct dentry *parent = dentry->d_parent;
+                int error;
 
                 prefetch(parent);
-                if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
-                    (prepend(&end, &buflen, "/", 1) != 0))
+                spin_lock(&dentry->d_lock);
+                error = prepend_name(&end, &buflen, &dentry->d_name);
+                spin_unlock(&dentry->d_lock);
+                if (error != 0 || prepend(&end, &buflen, "/", 1) != 0)
                         goto Elong;
 
                 retval = end;
@@ -2171,14 +2704,25 @@ char *__dentry_path(struct dentry *dentry, char *buf, int buflen)
 Elong:
         return ERR_PTR(-ENAMETOOLONG);
 }
-EXPORT_SYMBOL(__dentry_path);
+
+char *dentry_path_raw(struct dentry *dentry, char *buf, int buflen)
+{
+        char *retval;
+
+        write_seqlock(&rename_lock);
+        retval = __dentry_path(dentry, buf, buflen);
+        write_sequnlock(&rename_lock);
+
+        return retval;
+}
+EXPORT_SYMBOL(dentry_path_raw);
 
 char *dentry_path(struct dentry *dentry, char *buf, int buflen)
 {
         char *p = NULL;
         char *retval;
 
-        spin_lock(&dcache_lock);
+        write_seqlock(&rename_lock);
         if (d_unlinked(dentry)) {
                 p = buf + buflen;
                 if (prepend(&p, &buflen, "//deleted", 10) != 0)
@@ -2186,12 +2730,11 @@ char *dentry_path(struct dentry *dentry, char *buf, int buflen)
                 buflen++;
         }
         retval = __dentry_path(dentry, buf, buflen);
-        spin_unlock(&dcache_lock);
+        write_sequnlock(&rename_lock);
         if (!IS_ERR(retval) && p)
                 *p = '/';       /* restore '/' overriden with '\0' */
         return retval;
 Elong:
-        spin_unlock(&dcache_lock);
         return ERR_PTR(-ENAMETOOLONG);
 }
 
@@ -2225,7 +2768,7 @@ SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
         get_fs_root_and_pwd(current->fs, &root, &pwd);
 
         error = -ENOENT;
-        spin_lock(&dcache_lock);
+        write_seqlock(&rename_lock);
         if (!d_unlinked(pwd.dentry)) {
                 unsigned long len;
                 struct path tmp = root;
@@ -2234,7 +2777,7 @@ SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
 
                 prepend(&cwd, &buflen, "\0", 1);
                 error = prepend_path(&pwd, &tmp, &cwd, &buflen);
-                spin_unlock(&dcache_lock);
+                write_sequnlock(&rename_lock);
 
                 if (error)
                         goto out;
@@ -2253,8 +2796,9 @@ SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
                         if (copy_to_user(buf, cwd, len))
                                 error = -EFAULT;
                 }
-        } else
-                spin_unlock(&dcache_lock);
+        } else {
+                write_sequnlock(&rename_lock);
+        }
 
 out:
         path_put(&pwd);
@@ -2282,25 +2826,25 @@ out:
 int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
 {
         int result;
-        unsigned long seq;
+        unsigned seq;
 
         if (new_dentry == old_dentry)
                 return 1;
 
-        /*
-         * Need rcu_readlock to protect against the d_parent trashing
-         * due to d_move
-         */
-        rcu_read_lock();
         do {
                 /* for restarting inner loop in case of seq retry */
                 seq = read_seqbegin(&rename_lock);
+                /*
+                 * Need rcu_readlock to protect against the d_parent trashing
+                 * due to d_move
+                 */
+                rcu_read_lock();
                 if (d_ancestor(old_dentry, new_dentry))
                         result = 1;
                 else
                         result = 0;
+                rcu_read_unlock();
         } while (read_seqretry(&rename_lock, seq));
-        rcu_read_unlock();
 
         return result;
 }
@@ -2332,10 +2876,15 @@ EXPORT_SYMBOL(path_is_under);
 
 void d_genocide(struct dentry *root)
 {
-        struct dentry *this_parent = root;
+        struct dentry *this_parent;
         struct list_head *next;
+        unsigned seq;
+        int locked = 0;
 
-        spin_lock(&dcache_lock);
+        seq = read_seqbegin(&rename_lock);
+again:
+        this_parent = root;
+        spin_lock(&this_parent->d_lock);
 repeat:
         next = this_parent->d_subdirs.next;
 resume:
@@ -2343,21 +2892,62 @@ resume:
                 struct list_head *tmp = next;
                 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
                 next = tmp->next;
-                if (d_unhashed(dentry)||!dentry->d_inode)
+
+                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
+                if (d_unhashed(dentry) || !dentry->d_inode) {
+                        spin_unlock(&dentry->d_lock);
                         continue;
+                }
                 if (!list_empty(&dentry->d_subdirs)) {
+                        spin_unlock(&this_parent->d_lock);
+                        spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
                         this_parent = dentry;
+                        spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
                         goto repeat;
                 }
-                atomic_dec(&dentry->d_count);
+                if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
+                        dentry->d_flags |= DCACHE_GENOCIDE;
+                        dentry->d_count--;
+                }
+                spin_unlock(&dentry->d_lock);
         }
         if (this_parent != root) {
-                next = this_parent->d_u.d_child.next;
-                atomic_dec(&this_parent->d_count);
-                this_parent = this_parent->d_parent;
+                struct dentry *tmp;
+                struct dentry *child;
+
+                tmp = this_parent->d_parent;
+                if (!(this_parent->d_flags & DCACHE_GENOCIDE)) {
+                        this_parent->d_flags |= DCACHE_GENOCIDE;
+                        this_parent->d_count--;
+                }
+                rcu_read_lock();
+                spin_unlock(&this_parent->d_lock);
+                child = this_parent;
+                this_parent = tmp;
+                spin_lock(&this_parent->d_lock);
+                /* might go back up the wrong parent if we have had a rename
+                 * or deletion */
+                if (this_parent != child->d_parent ||
+                         (!locked && read_seqretry(&rename_lock, seq))) {
+                        spin_unlock(&this_parent->d_lock);
+                        rcu_read_unlock();
+                        goto rename_retry;
+                }
+                rcu_read_unlock();
+                next = child->d_u.d_child.next;
                 goto resume;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&this_parent->d_lock);
+        if (!locked && read_seqretry(&rename_lock, seq))
+                goto rename_retry;
+        if (locked)
+                write_sequnlock(&rename_lock);
+        return;
+
+rename_retry:
+        locked = 1;
+        write_seqlock(&rename_lock);
+        goto again;
 }
 
 /**
@@ -2411,7 +3001,7 @@ static void __init dcache_init_early(void)
 
         dentry_hashtable =
                 alloc_large_system_hash("Dentry cache",
-                                        sizeof(struct hlist_head),
+                                        sizeof(struct dcache_hash_bucket),
                                         dhash_entries,
                                         13,
                                         HASH_EARLY,
@@ -2420,16 +3010,13 @@ static void __init dcache_init_early(void)
                                         0);
 
         for (loop = 0; loop < (1 << d_hash_shift); loop++)
-                INIT_HLIST_HEAD(&dentry_hashtable[loop]);
+                INIT_HLIST_BL_HEAD(&dentry_hashtable[loop].head);
 }
 
 static void __init dcache_init(void)
 {
         int loop;
 
-        percpu_counter_init(&nr_dentry, 0);
-        percpu_counter_init(&nr_dentry_unused, 0);
-
         /* 
          * A constructor could be added for stable state like the lists,
          * but it is probably not worth it because of the cache nature
@@ -2446,7 +3033,7 @@ static void __init dcache_init(void)
 
         dentry_hashtable =
                 alloc_large_system_hash("Dentry cache",
-                                        sizeof(struct hlist_head),
+                                        sizeof(struct dcache_hash_bucket),
                                         dhash_entries,
                                         13,
                                         0,
@@ -2455,7 +3042,7 @@ static void __init dcache_init(void)
                                         0);
 
         for (loop = 0; loop < (1 << d_hash_shift); loop++)
-                INIT_HLIST_HEAD(&dentry_hashtable[loop]);
+                INIT_HLIST_BL_HEAD(&dentry_hashtable[loop].head);
 }
 
 /* SLAB cache for __getname() consumers */
diff --git a/fs/ecryptfs/dentry.c b/fs/ecryptfs/dentry.c
index 906e803f7f79..6fc4f319b550 100644
--- a/fs/ecryptfs/dentry.c
+++ b/fs/ecryptfs/dentry.c
@@ -44,12 +44,17 @@
  */
 static int ecryptfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
-        struct vfsmount *lower_mnt = ecryptfs_dentry_to_lower_mnt(dentry);
+        struct dentry *lower_dentry;
+        struct vfsmount *lower_mnt;
         struct dentry *dentry_save;
         struct vfsmount *vfsmount_save;
         int rc = 1;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        lower_dentry = ecryptfs_dentry_to_lower(dentry);
+        lower_mnt = ecryptfs_dentry_to_lower_mnt(dentry);
         if (!lower_dentry->d_op || !lower_dentry->d_op->d_revalidate)
                 goto out;
         dentry_save = nd->path.dentry;
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 9d1a22d62765..337352a94751 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -260,7 +260,7 @@ int ecryptfs_lookup_and_interpose_lower(struct dentry *ecryptfs_dentry,
                                    ecryptfs_dentry->d_parent));
         lower_inode = lower_dentry->d_inode;
         fsstack_copy_attr_atime(ecryptfs_dir_inode, lower_dir_dentry->d_inode);
-        BUG_ON(!atomic_read(&lower_dentry->d_count));
+        BUG_ON(!lower_dentry->d_count);
         ecryptfs_set_dentry_private(ecryptfs_dentry,
                                     kmem_cache_alloc(ecryptfs_dentry_info_cache,
                                                      GFP_KERNEL));
@@ -441,7 +441,7 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
         struct qstr lower_name;
         int rc = 0;
 
-        ecryptfs_dentry->d_op = &ecryptfs_dops;
+        d_set_d_op(ecryptfs_dentry, &ecryptfs_dops);
         if ((ecryptfs_dentry->d_name.len == 1
              && !strcmp(ecryptfs_dentry->d_name.name, "."))
             || (ecryptfs_dentry->d_name.len == 2
@@ -454,7 +454,7 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
         lower_name.hash = ecryptfs_dentry->d_name.hash;
         if (lower_dir_dentry->d_op && lower_dir_dentry->d_op->d_hash) {
                 rc = lower_dir_dentry->d_op->d_hash(lower_dir_dentry,
-                                                    &lower_name);
+                                lower_dir_dentry->d_inode, &lower_name);
                 if (rc < 0)
                         goto out_d_drop;
         }
@@ -489,7 +489,7 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
         lower_name.hash = full_name_hash(lower_name.name, lower_name.len);
         if (lower_dir_dentry->d_op && lower_dir_dentry->d_op->d_hash) {
                 rc = lower_dir_dentry->d_op->d_hash(lower_dir_dentry,
-                                                    &lower_name);
+                                lower_dir_dentry->d_inode, &lower_name);
                 if (rc < 0)
                         goto out_d_drop;
         }
@@ -980,8 +980,10 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
 }
 
 static int
-ecryptfs_permission(struct inode *inode, int mask)
+ecryptfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
         return inode_permission(ecryptfs_inode_to_lower(inode), mask);
 }
 
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index a9dbd62518e6..351038675376 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -189,7 +189,7 @@ int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
         if (special_file(lower_inode->i_mode))
                 init_special_inode(inode, lower_inode->i_mode,
                                    lower_inode->i_rdev);
-        dentry->d_op = &ecryptfs_dops;
+        d_set_d_op(dentry, &ecryptfs_dops);
         fsstack_copy_attr_all(inode, lower_inode);
         /* This size will be overwritten for real files w/ headers and
          * other metadata */
@@ -594,7 +594,7 @@ static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags
                 deactivate_locked_super(s);
                 goto out;
         }
-        s->s_root->d_op = &ecryptfs_dops;
+        d_set_d_op(s->s_root, &ecryptfs_dops);
         s->s_root->d_sb = s;
         s->s_root->d_parent = s->s_root;
 
diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c
index 2720178b7718..3042fe123a34 100644
--- a/fs/ecryptfs/super.c
+++ b/fs/ecryptfs/super.c
@@ -62,6 +62,16 @@ out:
         return inode;
 }
 
+static void ecryptfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        struct ecryptfs_inode_info *inode_info;
+        inode_info = ecryptfs_inode_to_private(inode);
+
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(ecryptfs_inode_info_cache, inode_info);
+}
+
 /**
  * ecryptfs_destroy_inode
  * @inode: The ecryptfs inode
@@ -88,7 +98,7 @@ static void ecryptfs_destroy_inode(struct inode *inode)
                 }
         }
         ecryptfs_destroy_crypt_stat(&inode_info->crypt_stat);
-        kmem_cache_free(ecryptfs_inode_info_cache, inode_info);
+        call_rcu(&inode->i_rcu, ecryptfs_i_callback);
 }
 
 /**
diff --git a/fs/efs/super.c b/fs/efs/super.c
index 5073a07652cc..0f31acb0131c 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -65,11 +65,18 @@ static struct inode *efs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void efs_destroy_inode(struct inode *inode)
+static void efs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(efs_inode_cachep, INODE_INFO(inode));
 }
 
+static void efs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, efs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct efs_inode_info *ei = (struct efs_inode_info *) foo;
diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index 79c3ae6e0456..8c6c4669b381 100644
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -150,12 +150,19 @@ static struct inode *exofs_alloc_inode(struct super_block *sb)
         return &oi->vfs_inode;
 }
 
+static void exofs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(exofs_inode_cachep, exofs_i(inode));
+}
+
 /*
  * Remove an inode from the cache
  */
 static void exofs_destroy_inode(struct inode *inode)
 {
-        kmem_cache_free(exofs_inode_cachep, exofs_i(inode));
+        call_rcu(&inode->i_rcu, exofs_i_callback);
 }
 
 /*
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 51b304056f10..4b6825740dd5 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -43,24 +43,26 @@ find_acceptable_alias(struct dentry *result,
                 void *context)
 {
         struct dentry *dentry, *toput = NULL;
+        struct inode *inode;
 
         if (acceptable(context, result))
                 return result;
 
-        spin_lock(&dcache_lock);
-        list_for_each_entry(dentry, &result->d_inode->i_dentry, d_alias) {
-                dget_locked(dentry);
-                spin_unlock(&dcache_lock);
+        inode = result->d_inode;
+        spin_lock(&inode->i_lock);
+        list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+                dget(dentry);
+                spin_unlock(&inode->i_lock);
                 if (toput)
                         dput(toput);
                 if (dentry != result && acceptable(context, dentry)) {
                         dput(result);
                         return dentry;
                 }
-                spin_lock(&dcache_lock);
+                spin_lock(&inode->i_lock);
                 toput = dentry;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
 
         if (toput)
                 dput(toput);
diff --git a/fs/ext2/acl.c b/fs/ext2/acl.c
index 2bcc0431bada..7b4180554a62 100644
--- a/fs/ext2/acl.c
+++ b/fs/ext2/acl.c
@@ -232,10 +232,17 @@ ext2_set_acl(struct inode *inode, int type, struct posix_acl *acl)
 }
 
 int
-ext2_check_acl(struct inode *inode, int mask)
+ext2_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct posix_acl *acl = ext2_get_acl(inode, ACL_TYPE_ACCESS);
+        struct posix_acl *acl;
+
+        if (flags & IPERM_FLAG_RCU) {
+                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                        return -ECHILD;
+                return -EAGAIN;
+        }
 
+        acl = ext2_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl) {
diff --git a/fs/ext2/acl.h b/fs/ext2/acl.h
index 3ff6cbb9ac44..c939b7b12099 100644
--- a/fs/ext2/acl.h
+++ b/fs/ext2/acl.h
@@ -54,7 +54,7 @@ static inline int ext2_acl_count(size_t size)
 #ifdef CONFIG_EXT2_FS_POSIX_ACL
 
 /* acl.c */
-extern int ext2_check_acl (struct inode *, int);
+extern int ext2_check_acl (struct inode *, int, unsigned int);
 extern int ext2_acl_chmod (struct inode *);
 extern int ext2_init_acl (struct inode *, struct inode *);
 
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index d89e0b6a2d78..e0c6380ff992 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -161,11 +161,18 @@ static struct inode *ext2_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void ext2_destroy_inode(struct inode *inode)
+static void ext2_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
 }
 
+static void ext2_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, ext2_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
diff --git a/fs/ext3/acl.c b/fs/ext3/acl.c
index 8a11fe212183..e4fa49e6c539 100644
--- a/fs/ext3/acl.c
+++ b/fs/ext3/acl.c
@@ -240,10 +240,17 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
 }
 
 int
-ext3_check_acl(struct inode *inode, int mask)
+ext3_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct posix_acl *acl = ext3_get_acl(inode, ACL_TYPE_ACCESS);
+        struct posix_acl *acl;
+
+        if (flags & IPERM_FLAG_RCU) {
+                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                        return -ECHILD;
+                return -EAGAIN;
+        }
 
+        acl = ext3_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl) {
diff --git a/fs/ext3/acl.h b/fs/ext3/acl.h
index 597334626de9..5faf8048e906 100644
--- a/fs/ext3/acl.h
+++ b/fs/ext3/acl.h
@@ -54,7 +54,7 @@ static inline int ext3_acl_count(size_t size)
 #ifdef CONFIG_EXT3_FS_POSIX_ACL
 
 /* acl.c */
-extern int ext3_check_acl (struct inode *, int);
+extern int ext3_check_acl (struct inode *, int, unsigned int);
 extern int ext3_acl_chmod (struct inode *);
 extern int ext3_init_acl (handle_t *, struct inode *, struct inode *);
 
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index acf8695fa8f0..77ce1616f725 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -479,6 +479,13 @@ static struct inode *ext3_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
+static void ext3_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
+}
+
 static void ext3_destroy_inode(struct inode *inode)
 {
         if (!list_empty(&(EXT3_I(inode)->i_orphan))) {
@@ -489,7 +496,7 @@ static void ext3_destroy_inode(struct inode *inode)
                                 false);
                 dump_stack();
         }
-        kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
+        call_rcu(&inode->i_rcu, ext3_i_callback);
 }
 
 static void init_once(void *foo)
diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index 5e2ed4504ead..e0270d1f8d82 100644
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -238,10 +238,17 @@ ext4_set_acl(handle_t *handle, struct inode *inode, int type,
 }
 
 int
-ext4_check_acl(struct inode *inode, int mask)
+ext4_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct posix_acl *acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
+        struct posix_acl *acl;
+
+        if (flags & IPERM_FLAG_RCU) {
+                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                        return -ECHILD;
+                return -EAGAIN;
+        }
 
+        acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl) {
diff --git a/fs/ext4/acl.h b/fs/ext4/acl.h
index 9d843d5deac4..dec821168fd4 100644
--- a/fs/ext4/acl.h
+++ b/fs/ext4/acl.h
@@ -54,7 +54,7 @@ static inline int ext4_acl_count(size_t size)
 #ifdef CONFIG_EXT4_FS_POSIX_ACL
 
 /* acl.c */
-extern int ext4_check_acl(struct inode *, int);
+extern int ext4_check_acl(struct inode *, int, unsigned int);
 extern int ext4_acl_chmod(struct inode *);
 extern int ext4_init_acl(handle_t *, struct inode *, struct inode *);
 
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index fb15c9c0be74..cd37f9d5e447 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -841,6 +841,13 @@ static int ext4_drop_inode(struct inode *inode)
         return drop;
 }
 
+static void ext4_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
+}
+
 static void ext4_destroy_inode(struct inode *inode)
 {
         ext4_ioend_wait(inode);
@@ -853,7 +860,7 @@ static void ext4_destroy_inode(struct inode *inode)
                                 true);
                 dump_stack();
         }
-        kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
+        call_rcu(&inode->i_rcu, ext4_i_callback);
 }
 
 static void init_once(void *foo)
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index ad6998a92c30..206351af7c58 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -514,11 +514,18 @@ static struct inode *fat_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void fat_destroy_inode(struct inode *inode)
+static void fat_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(fat_inode_cachep, MSDOS_I(inode));
 }
 
+static void fat_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, fat_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct msdos_inode_info *ei = (struct msdos_inode_info *)foo;
@@ -743,7 +750,7 @@ static struct dentry *fat_fh_to_dentry(struct super_block *sb,
          */
         result = d_obtain_alias(inode);
         if (!IS_ERR(result))
-                result->d_op = sb->s_root->d_op;
+                d_set_d_op(result, sb->s_root->d_op);
         return result;
 }
 
@@ -793,7 +800,7 @@ static struct dentry *fat_get_parent(struct dentry *child)
 
         parent = d_obtain_alias(inode);
         if (!IS_ERR(parent))
-                parent->d_op = sb->s_root->d_op;
+                d_set_d_op(parent, sb->s_root->d_op);
 out:
         unlock_super(sb);
 
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index 3345aabd1dd7..35ffe43afa4b 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -148,7 +148,8 @@ static int msdos_find(struct inode *dir, const unsigned char *name, int len,
  * that the existing dentry can be used. The msdos fs routines will
  * return ENOENT or EINVAL as appropriate.
  */
-static int msdos_hash(struct dentry *dentry, struct qstr *qstr)
+static int msdos_hash(const struct dentry *dentry, const struct inode *inode,
+               struct qstr *qstr)
 {
         struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options;
         unsigned char msdos_name[MSDOS_NAME];
@@ -164,16 +165,18 @@ static int msdos_hash(struct dentry *dentry, struct qstr *qstr)
  * Compare two msdos names. If either of the names are invalid,
  * we fall back to doing the standard name comparison.
  */
-static int msdos_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b)
+static int msdos_cmp(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        struct fat_mount_options *options = &MSDOS_SB(dentry->d_sb)->options;
+        struct fat_mount_options *options = &MSDOS_SB(parent->d_sb)->options;
         unsigned char a_msdos_name[MSDOS_NAME], b_msdos_name[MSDOS_NAME];
         int error;
 
-        error = msdos_format_name(a->name, a->len, a_msdos_name, options);
+        error = msdos_format_name(name->name, name->len, a_msdos_name, options);
         if (error)
                 goto old_compare;
-        error = msdos_format_name(b->name, b->len, b_msdos_name, options);
+        error = msdos_format_name(str, len, b_msdos_name, options);
         if (error)
                 goto old_compare;
         error = memcmp(a_msdos_name, b_msdos_name, MSDOS_NAME);
@@ -182,8 +185,8 @@ out:
 
 old_compare:
         error = 1;
-        if (a->len == b->len)
-                error = memcmp(a->name, b->name, a->len);
+        if (name->len == len)
+                error = memcmp(name->name, str, len);
         goto out;
 }
 
@@ -224,10 +227,10 @@ static struct dentry *msdos_lookup(struct inode *dir, struct dentry *dentry,
         }
 out:
         unlock_super(sb);
-        dentry->d_op = &msdos_dentry_operations;
+        d_set_d_op(dentry, &msdos_dentry_operations);
         dentry = d_splice_alias(inode, dentry);
         if (dentry)
-                dentry->d_op = &msdos_dentry_operations;
+                d_set_d_op(dentry, &msdos_dentry_operations);
         return dentry;
 
 error:
@@ -670,7 +673,7 @@ static int msdos_fill_super(struct super_block *sb, void *data, int silent)
         }
 
         sb->s_flags |= MS_NOATIME;
-        sb->s_root->d_op = &msdos_dentry_operations;
+        d_set_d_op(sb->s_root, &msdos_dentry_operations);
         unlock_super(sb);
         return 0;
 }
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index b936703b8924..e3ffc5e12332 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -43,6 +43,9 @@ static int vfat_revalidate_shortname(struct dentry *dentry)
 
 static int vfat_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
         /* This is not negative dentry. Always valid. */
         if (dentry->d_inode)
                 return 1;
@@ -51,6 +54,9 @@ static int vfat_revalidate(struct dentry *dentry, struct nameidata *nd)
 
 static int vfat_revalidate_ci(struct dentry *dentry, struct nameidata *nd)
 {
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
         /*
          * This is not negative dentry. Always valid.
          *
@@ -85,22 +91,26 @@ static int vfat_revalidate_ci(struct dentry *dentry, struct nameidata *nd)
 }
 
 /* returns the length of a struct qstr, ignoring trailing dots */
-static unsigned int vfat_striptail_len(struct qstr *qstr)
+static unsigned int __vfat_striptail_len(unsigned int len, const char *name)
 {
-        unsigned int len = qstr->len;
-
-        while (len && qstr->name[len - 1] == '.')
+        while (len && name[len - 1] == '.')
                 len--;
         return len;
 }
 
+static unsigned int vfat_striptail_len(const struct qstr *qstr)
+{
+        return __vfat_striptail_len(qstr->len, qstr->name);
+}
+
 /*
  * Compute the hash for the vfat name corresponding to the dentry.
  * Note: if the name is invalid, we leave the hash code unchanged so
  * that the existing dentry can be used. The vfat fs routines will
  * return ENOENT or EINVAL as appropriate.
  */
-static int vfat_hash(struct dentry *dentry, struct qstr *qstr)
+static int vfat_hash(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         qstr->hash = full_name_hash(qstr->name, vfat_striptail_len(qstr));
         return 0;
@@ -112,9 +122,10 @@ static int vfat_hash(struct dentry *dentry, struct qstr *qstr)
  * that the existing dentry can be used. The vfat fs routines will
  * return ENOENT or EINVAL as appropriate.
  */
-static int vfat_hashi(struct dentry *dentry, struct qstr *qstr)
+static int vfat_hashi(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
-        struct nls_table *t = MSDOS_SB(dentry->d_inode->i_sb)->nls_io;
+        struct nls_table *t = MSDOS_SB(dentry->d_sb)->nls_io;
         const unsigned char *name;
         unsigned int len;
         unsigned long hash;
@@ -133,16 +144,18 @@ static int vfat_hashi(struct dentry *dentry, struct qstr *qstr)
 /*
  * Case insensitive compare of two vfat names.
  */
-static int vfat_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b)
+static int vfat_cmpi(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        struct nls_table *t = MSDOS_SB(dentry->d_inode->i_sb)->nls_io;
+        struct nls_table *t = MSDOS_SB(parent->d_sb)->nls_io;
         unsigned int alen, blen;
 
         /* A filename cannot end in '.' or we treat it like it has none */
-        alen = vfat_striptail_len(a);
-        blen = vfat_striptail_len(b);
+        alen = vfat_striptail_len(name);
+        blen = __vfat_striptail_len(len, str);
         if (alen == blen) {
-                if (nls_strnicmp(t, a->name, b->name, alen) == 0)
+                if (nls_strnicmp(t, name->name, str, alen) == 0)
                         return 0;
         }
         return 1;
@@ -151,15 +164,17 @@ static int vfat_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b)
 /*
  * Case sensitive compare of two vfat names.
  */
-static int vfat_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b)
+static int vfat_cmp(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
         unsigned int alen, blen;
 
         /* A filename cannot end in '.' or we treat it like it has none */
-        alen = vfat_striptail_len(a);
-        blen = vfat_striptail_len(b);
+        alen = vfat_striptail_len(name);
+        blen = __vfat_striptail_len(len, str);
         if (alen == blen) {
-                if (strncmp(a->name, b->name, alen) == 0)
+                if (strncmp(name->name, str, alen) == 0)
                         return 0;
         }
         return 1;
@@ -757,11 +772,11 @@ static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
 
 out:
         unlock_super(sb);
-        dentry->d_op = sb->s_root->d_op;
+        d_set_d_op(dentry, sb->s_root->d_op);
         dentry->d_time = dentry->d_parent->d_inode->i_version;
         dentry = d_splice_alias(inode, dentry);
         if (dentry) {
-                dentry->d_op = sb->s_root->d_op;
+                d_set_d_op(dentry, sb->s_root->d_op);
                 dentry->d_time = dentry->d_parent->d_inode->i_version;
         }
         return dentry;
@@ -1063,9 +1078,9 @@ static int vfat_fill_super(struct super_block *sb, void *data, int silent)
         }
 
         if (MSDOS_SB(sb)->options.name_check != 's')
-                sb->s_root->d_op = &vfat_ci_dentry_ops;
+                d_set_d_op(sb->s_root, &vfat_ci_dentry_ops);
         else
-                sb->s_root->d_op = &vfat_dentry_ops;
+                d_set_d_op(sb->s_root, &vfat_dentry_ops);
 
         unlock_super(sb);
         return 0;
diff --git a/fs/filesystems.c b/fs/filesystems.c
index 68ba492d8eef..751d6b255a12 100644
--- a/fs/filesystems.c
+++ b/fs/filesystems.c
@@ -115,6 +115,9 @@ int unregister_filesystem(struct file_system_type * fs)
                 tmp = &(*tmp)->next;
         }
         write_unlock(&file_systems_lock);
+
+        synchronize_rcu();
+
         return -EINVAL;
 }
 
diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c
index 8c04eac5079d..2ba6719ac612 100644
--- a/fs/freevxfs/vxfs_inode.c
+++ b/fs/freevxfs/vxfs_inode.c
@@ -337,6 +337,13 @@ vxfs_iget(struct super_block *sbp, ino_t ino)
         return ip;
 }
 
+static void vxfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(vxfs_inode_cachep, inode->i_private);
+}
+
 /**
  * vxfs_evict_inode - remove inode from main memory
  * @ip:         inode to discard.
@@ -350,5 +357,5 @@ vxfs_evict_inode(struct inode *ip)
 {
         truncate_inode_pages(&ip->i_data, 0);
         end_writeback(ip);
-        kmem_cache_free(vxfs_inode_cachep, ip->i_private);
+        call_rcu(&ip->i_rcu, vxfs_i_callback);
 }
diff --git a/fs/fs_struct.c b/fs/fs_struct.c
index ed45a9cf5f3d..68ca487bedb1 100644
--- a/fs/fs_struct.c
+++ b/fs/fs_struct.c
@@ -14,12 +14,14 @@ void set_fs_root(struct fs_struct *fs, struct path *path)
         struct path old_root;
 
         spin_lock(&fs->lock);
+        write_seqcount_begin(&fs->seq);
         old_root = fs->root;
         fs->root = *path;
-        path_get(path);
+        path_get_long(path);
+        write_seqcount_end(&fs->seq);
         spin_unlock(&fs->lock);
         if (old_root.dentry)
-                path_put(&old_root);
+                path_put_long(&old_root);
 }
 
 /*
@@ -31,13 +33,15 @@ void set_fs_pwd(struct fs_struct *fs, struct path *path)
         struct path old_pwd;
 
         spin_lock(&fs->lock);
+        write_seqcount_begin(&fs->seq);
         old_pwd = fs->pwd;
         fs->pwd = *path;
-        path_get(path);
+        path_get_long(path);
+        write_seqcount_end(&fs->seq);
         spin_unlock(&fs->lock);
 
         if (old_pwd.dentry)
-                path_put(&old_pwd);
+                path_put_long(&old_pwd);
 }
 
 void chroot_fs_refs(struct path *old_root, struct path *new_root)
@@ -52,31 +56,33 @@ void chroot_fs_refs(struct path *old_root, struct path *new_root)
                 fs = p->fs;
                 if (fs) {
                         spin_lock(&fs->lock);
+                        write_seqcount_begin(&fs->seq);
                         if (fs->root.dentry == old_root->dentry
                             && fs->root.mnt == old_root->mnt) {
-                                path_get(new_root);
+                                path_get_long(new_root);
                                 fs->root = *new_root;
                                 count++;
                         }
                         if (fs->pwd.dentry == old_root->dentry
                             && fs->pwd.mnt == old_root->mnt) {
-                                path_get(new_root);
+                                path_get_long(new_root);
                                 fs->pwd = *new_root;
                                 count++;
                         }
+                        write_seqcount_end(&fs->seq);
                         spin_unlock(&fs->lock);
                 }
                 task_unlock(p);
         } while_each_thread(g, p);
         read_unlock(&tasklist_lock);
         while (count--)
-                path_put(old_root);
+                path_put_long(old_root);
 }
 
 void free_fs_struct(struct fs_struct *fs)
 {
-        path_put(&fs->root);
-        path_put(&fs->pwd);
+        path_put_long(&fs->root);
+        path_put_long(&fs->pwd);
         kmem_cache_free(fs_cachep, fs);
 }
 
@@ -88,8 +94,10 @@ void exit_fs(struct task_struct *tsk)
                 int kill;
                 task_lock(tsk);
                 spin_lock(&fs->lock);
+                write_seqcount_begin(&fs->seq);
                 tsk->fs = NULL;
                 kill = !--fs->users;
+                write_seqcount_end(&fs->seq);
                 spin_unlock(&fs->lock);
                 task_unlock(tsk);
                 if (kill)
@@ -105,8 +113,15 @@ struct fs_struct *copy_fs_struct(struct fs_struct *old)
                 fs->users = 1;
                 fs->in_exec = 0;
                 spin_lock_init(&fs->lock);
+                seqcount_init(&fs->seq);
                 fs->umask = old->umask;
-                get_fs_root_and_pwd(old, &fs->root, &fs->pwd);
+
+                spin_lock(&old->lock);
+                fs->root = old->root;
+                path_get_long(&fs->root);
+                fs->pwd = old->pwd;
+                path_get_long(&fs->pwd);
+                spin_unlock(&old->lock);
         }
         return fs;
 }
@@ -144,6 +159,7 @@ EXPORT_SYMBOL(current_umask);
 struct fs_struct init_fs = {
         .users          = 1,
         .lock           = __SPIN_LOCK_UNLOCKED(init_fs.lock),
+        .seq            = SEQCNT_ZERO,
         .umask          = 0022,
 };
 
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index c9627c95482d..f738599fd8cd 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -156,8 +156,12 @@ u64 fuse_get_attr_version(struct fuse_conn *fc)
  */
 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
 {
-        struct inode *inode = entry->d_inode;
+        struct inode *inode;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = entry->d_inode;
         if (inode && is_bad_inode(inode))
                 return 0;
         else if (fuse_dentry_time(entry) < get_jiffies_64()) {
@@ -347,7 +351,7 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
         }
 
         entry = newent ? newent : entry;
-        entry->d_op = &fuse_dentry_operations;
+        d_set_d_op(entry, &fuse_dentry_operations);
         if (outarg_valid)
                 fuse_change_entry_timeout(entry, &outarg);
         else
@@ -981,12 +985,15 @@ static int fuse_access(struct inode *inode, int mask)
  * access request is sent.  Execute permission is still checked
  * locally based on file mode.
  */
-static int fuse_permission(struct inode *inode, int mask)
+static int fuse_permission(struct inode *inode, int mask, unsigned int flags)
 {
         struct fuse_conn *fc = get_fuse_conn(inode);
         bool refreshed = false;
         int err = 0;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         if (!fuse_allow_task(fc, current))
                 return -EACCES;
 
@@ -1001,7 +1008,7 @@ static int fuse_permission(struct inode *inode, int mask)
         }
 
         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
-                err = generic_permission(inode, mask, NULL);
+                err = generic_permission(inode, mask, flags, NULL);
 
                 /* If permission is denied, try to refresh file
                    attributes.  This is also needed, because the root
@@ -1009,7 +1016,8 @@ static int fuse_permission(struct inode *inode, int mask)
                 if (err == -EACCES && !refreshed) {
                         err = fuse_do_getattr(inode, NULL, NULL);
                         if (!err)
-                                err = generic_permission(inode, mask, NULL);
+                                err = generic_permission(inode, mask,
+                                                        flags, NULL);
                 }
 
                 /* Note: the opposite of the above test does not
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index cfce3ad86a92..a8b31da19b93 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -99,6 +99,13 @@ static struct inode *fuse_alloc_inode(struct super_block *sb)
         return inode;
 }
 
+static void fuse_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(fuse_inode_cachep, inode);
+}
+
 static void fuse_destroy_inode(struct inode *inode)
 {
         struct fuse_inode *fi = get_fuse_inode(inode);
@@ -106,7 +113,7 @@ static void fuse_destroy_inode(struct inode *inode)
         BUG_ON(!list_empty(&fi->queued_writes));
         if (fi->forget_req)
                 fuse_request_free(fi->forget_req);
-        kmem_cache_free(fuse_inode_cachep, inode);
+        call_rcu(&inode->i_rcu, fuse_i_callback);
 }
 
 void fuse_send_forget(struct fuse_conn *fc, struct fuse_req *req,
@@ -619,7 +626,7 @@ static struct dentry *fuse_get_dentry(struct super_block *sb,
 
         entry = d_obtain_alias(inode);
         if (!IS_ERR(entry) && get_node_id(inode) != FUSE_ROOT_ID) {
-                entry->d_op = &fuse_dentry_operations;
+                d_set_d_op(entry, &fuse_dentry_operations);
                 fuse_invalidate_entry_cache(entry);
         }
 
@@ -721,7 +728,7 @@ static struct dentry *fuse_get_parent(struct dentry *child)
 
         parent = d_obtain_alias(inode);
         if (!IS_ERR(parent) && get_node_id(inode) != FUSE_ROOT_ID) {
-                parent->d_op = &fuse_dentry_operations;
+                d_set_d_op(parent, &fuse_dentry_operations);
                 fuse_invalidate_entry_cache(parent);
         }
 
diff --git a/fs/generic_acl.c b/fs/generic_acl.c
index 6bc9e3a5a693..06c48a891832 100644
--- a/fs/generic_acl.c
+++ b/fs/generic_acl.c
@@ -190,14 +190,20 @@ generic_acl_chmod(struct inode *inode)
 }
 
 int
-generic_check_acl(struct inode *inode, int mask)
+generic_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct posix_acl *acl = get_cached_acl(inode, ACL_TYPE_ACCESS);
-
-        if (acl) {
-                int error = posix_acl_permission(inode, acl, mask);
-                posix_acl_release(acl);
-                return error;
+        if (flags & IPERM_FLAG_RCU) {
+                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                        return -ECHILD;
+        } else {
+                struct posix_acl *acl;
+
+                acl = get_cached_acl(inode, ACL_TYPE_ACCESS);
+                if (acl) {
+                        int error = posix_acl_permission(inode, acl, mask);
+                        posix_acl_release(acl);
+                        return error;
+                }
         }
         return -EAGAIN;
 }
diff --git a/fs/gfs2/acl.c b/fs/gfs2/acl.c
index 48171f4c943d..7118f1a780a9 100644
--- a/fs/gfs2/acl.c
+++ b/fs/gfs2/acl.c
@@ -75,11 +75,14 @@ static struct posix_acl *gfs2_acl_get(struct gfs2_inode *ip, int type)
  * Returns: errno
  */
 
-int gfs2_check_acl(struct inode *inode, int mask)
+int gfs2_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
         struct posix_acl *acl;
         int error;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         acl = gfs2_acl_get(GFS2_I(inode), ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
diff --git a/fs/gfs2/acl.h b/fs/gfs2/acl.h
index b522b0cb39ea..a93907c8159b 100644
--- a/fs/gfs2/acl.h
+++ b/fs/gfs2/acl.h
@@ -16,7 +16,7 @@
 #define GFS2_POSIX_ACL_DEFAULT          "posix_acl_default"
 #define GFS2_ACL_MAX_ENTRIES            25
 
-extern int gfs2_check_acl(struct inode *inode, int mask);
+extern int gfs2_check_acl(struct inode *inode, int mask, unsigned int);
 extern int gfs2_acl_create(struct gfs2_inode *dip, struct inode *inode);
 extern int gfs2_acl_chmod(struct gfs2_inode *ip, struct iattr *attr);
 extern const struct xattr_handler gfs2_xattr_system_handler;
diff --git a/fs/gfs2/dentry.c b/fs/gfs2/dentry.c
index 6798755b3858..4a456338b873 100644
--- a/fs/gfs2/dentry.c
+++ b/fs/gfs2/dentry.c
@@ -11,6 +11,7 @@
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/gfs2_ondisk.h>
+#include <linux/namei.h>
 #include <linux/crc32.h>
 
 #include "gfs2.h"
@@ -34,15 +35,23 @@
 
 static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct dentry *parent = dget_parent(dentry);
-        struct gfs2_sbd *sdp = GFS2_SB(parent->d_inode);
-        struct gfs2_inode *dip = GFS2_I(parent->d_inode);
-        struct inode *inode = dentry->d_inode;
+        struct dentry *parent;
+        struct gfs2_sbd *sdp;
+        struct gfs2_inode *dip;
+        struct inode *inode;
         struct gfs2_holder d_gh;
         struct gfs2_inode *ip = NULL;
         int error;
         int had_lock = 0;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        parent = dget_parent(dentry);
+        sdp = GFS2_SB(parent->d_inode);
+        dip = GFS2_I(parent->d_inode);
+        inode = dentry->d_inode;
+
         if (inode) {
                 if (is_bad_inode(inode))
                         goto invalid;
@@ -100,13 +109,14 @@ fail:
         return 0;
 }
 
-static int gfs2_dhash(struct dentry *dentry, struct qstr *str)
+static int gfs2_dhash(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *str)
 {
         str->hash = gfs2_disk_hash(str->name, str->len);
         return 0;
 }
 
-static int gfs2_dentry_delete(struct dentry *dentry)
+static int gfs2_dentry_delete(const struct dentry *dentry)
 {
         struct gfs2_inode *ginode;
 
diff --git a/fs/gfs2/export.c b/fs/gfs2/export.c
index 5ab3839dfcb9..97012ecff560 100644
--- a/fs/gfs2/export.c
+++ b/fs/gfs2/export.c
@@ -130,7 +130,7 @@ static struct dentry *gfs2_get_parent(struct dentry *child)
 
         dentry = d_obtain_alias(gfs2_lookupi(child->d_inode, &gfs2_qdotdot, 1));
         if (!IS_ERR(dentry))
-                dentry->d_op = &gfs2_dops;
+                d_set_d_op(dentry, &gfs2_dops);
         return dentry;
 }
 
@@ -158,7 +158,7 @@ static struct dentry *gfs2_get_dentry(struct super_block *sb,
 out_inode:
         dentry = d_obtain_alias(inode);
         if (!IS_ERR(dentry))
-                dentry->d_op = &gfs2_dops;
+                d_set_d_op(dentry, &gfs2_dops);
         return dentry;
 }
 
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index aa996471ec5c..fca6689e12e6 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -241,7 +241,7 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
             !capable(CAP_LINUX_IMMUTABLE))
                 goto out;
         if (!IS_IMMUTABLE(inode)) {
-                error = gfs2_permission(inode, MAY_WRITE);
+                error = gfs2_permission(inode, MAY_WRITE, 0);
                 if (error)
                         goto out;
         }
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 14e682dbe8bf..2232b3c780bd 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -509,7 +509,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
         }
 
         if (!is_root) {
-                error = gfs2_permission(dir, MAY_EXEC);
+                error = gfs2_permission(dir, MAY_EXEC, 0);
                 if (error)
                         goto out;
         }
@@ -539,7 +539,7 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 {
         int error;
 
-        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
+        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
         if (error)
                 return error;
 
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index d8499fadcc53..732a183efdb3 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -113,7 +113,7 @@ extern struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 extern struct inode *gfs2_createi(struct gfs2_holder *ghs,
                                   const struct qstr *name,
                                   unsigned int mode, dev_t dev);
-extern int gfs2_permission(struct inode *inode, int mask);
+extern int gfs2_permission(struct inode *inode, int mask, unsigned int flags);
 extern int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
 extern struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
 extern void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 3eb1393f7b81..2aeabd4218cc 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -440,7 +440,7 @@ static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
                 iput(inode);
                 return -ENOMEM;
         }
-        dentry->d_op = &gfs2_dops;
+        d_set_d_op(dentry, &gfs2_dops);
         *dptr = dentry;
         return 0;
 }
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index 1db6b7343229..1501db4f0e6d 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -106,7 +106,7 @@ static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 {
         struct inode *inode = NULL;
 
-        dentry->d_op = &gfs2_dops;
+        d_set_d_op(dentry, &gfs2_dops);
 
         inode = gfs2_lookupi(dir, &dentry->d_name, 0);
         if (inode && IS_ERR(inode))
@@ -166,7 +166,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
         if (error)
                 goto out_child;
 
-        error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
+        error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC, 0);
         if (error)
                 goto out_gunlock;
 
@@ -289,7 +289,7 @@ static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
         if (IS_APPEND(&dip->i_inode))
                 return -EPERM;
 
-        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
+        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
         if (error)
                 return error;
 
@@ -822,7 +822,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
                         }
                 }
         } else {
-                error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
+                error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC, 0);
                 if (error)
                         goto out_gunlock;
 
@@ -857,7 +857,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
         /* Check out the dir to be renamed */
 
         if (dir_rename) {
-                error = gfs2_permission(odentry->d_inode, MAY_WRITE);
+                error = gfs2_permission(odentry->d_inode, MAY_WRITE, 0);
                 if (error)
                         goto out_gunlock;
         }
@@ -1041,13 +1041,17 @@ static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
  * Returns: errno
  */
 
-int gfs2_permission(struct inode *inode, int mask)
+int gfs2_permission(struct inode *inode, int mask, unsigned int flags)
 {
-        struct gfs2_inode *ip = GFS2_I(inode);
+        struct gfs2_inode *ip;
         struct gfs2_holder i_gh;
         int error;
         int unlock = 0;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
+        ip = GFS2_I(inode);
         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
                 if (error)
@@ -1058,7 +1062,7 @@ int gfs2_permission(struct inode *inode, int mask)
         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
                 error = -EACCES;
         else
-                error = generic_permission(inode, mask, gfs2_check_acl);
+                error = generic_permission(inode, mask, flags, gfs2_check_acl);
         if (unlock)
                 gfs2_glock_dq_uninit(&i_gh);
 
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index 2b2c4997430b..16c2ecac7eb7 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -1405,11 +1405,18 @@ static struct inode *gfs2_alloc_inode(struct super_block *sb)
         return &ip->i_inode;
 }
 
-static void gfs2_destroy_inode(struct inode *inode)
+static void gfs2_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(gfs2_inode_cachep, inode);
 }
 
+static void gfs2_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, gfs2_i_callback);
+}
+
 const struct super_operations gfs2_super_ops = {
         .alloc_inode            = gfs2_alloc_inode,
         .destroy_inode          = gfs2_destroy_inode,
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 2b3b8611b41b..ea4aefe7c652 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -25,7 +25,7 @@ static struct dentry *hfs_lookup(struct inode *dir, struct dentry *dentry,
         struct inode *inode = NULL;
         int res;
 
-        dentry->d_op = &hfs_dentry_operations;
+        d_set_d_op(dentry, &hfs_dentry_operations);
 
         hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd);
         hfs_cat_build_key(dir->i_sb, fd.search_key, dir->i_ino, &dentry->d_name);
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index c8cffb81e849..ad97c2d58287 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -213,10 +213,14 @@ extern int hfs_part_find(struct super_block *, sector_t *, sector_t *);
 /* string.c */
 extern const struct dentry_operations hfs_dentry_operations;
 
-extern int hfs_hash_dentry(struct dentry *, struct qstr *);
+extern int hfs_hash_dentry(const struct dentry *, const struct inode *,
+                struct qstr *);
 extern int hfs_strcmp(const unsigned char *, unsigned int,
                       const unsigned char *, unsigned int);
-extern int hfs_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
+extern int hfs_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
 
 /* trans.c */
 extern void hfs_asc2mac(struct super_block *, struct hfs_name *, struct qstr *);
diff --git a/fs/hfs/string.c b/fs/hfs/string.c
index 927a5af79428..495a976a3cc9 100644
--- a/fs/hfs/string.c
+++ b/fs/hfs/string.c
@@ -51,7 +51,8 @@ static unsigned char caseorder[256] = {
 /*
  * Hash a string to an integer in a case-independent way
  */
-int hfs_hash_dentry(struct dentry *dentry, struct qstr *this)
+int hfs_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *this)
 {
         const unsigned char *name = this->name;
         unsigned int hash, len = this->len;
@@ -92,21 +93,21 @@ int hfs_strcmp(const unsigned char *s1, unsigned int len1,
  * Test for equality of two strings in the HFS filename character ordering.
  * return 1 on failure and 0 on success
  */
-int hfs_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2)
+int hfs_compare_dentry(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
         const unsigned char *n1, *n2;
-        int len;
 
-        len = s1->len;
         if (len >= HFS_NAMELEN) {
-                if (s2->len < HFS_NAMELEN)
+                if (name->len < HFS_NAMELEN)
                         return 1;
                 len = HFS_NAMELEN;
-        } else if (len != s2->len)
+        } else if (len != name->len)
                 return 1;
 
-        n1 = s1->name;
-        n2 = s2->name;
+        n1 = str;
+        n2 = name->name;
         while (len--) {
                 if (caseorder[*n1++] != caseorder[*n2++])
                         return 1;
diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 4824c27cebb8..0bef62aa4f42 100644
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -167,11 +167,18 @@ static struct inode *hfs_alloc_inode(struct super_block *sb)
         return i ? &i->vfs_inode : NULL;
 }
 
-static void hfs_destroy_inode(struct inode *inode)
+static void hfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(hfs_inode_cachep, HFS_I(inode));
 }
 
+static void hfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, hfs_i_callback);
+}
+
 static const struct super_operations hfs_super_operations = {
         .alloc_inode    = hfs_alloc_inode,
         .destroy_inode  = hfs_destroy_inode,
@@ -427,7 +434,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
         if (!sb->s_root)
                 goto bail_iput;
 
-        sb->s_root->d_op = &hfs_dentry_operations;
+        d_set_d_op(sb->s_root, &hfs_dentry_operations);
 
         /* everything's okay */
         return 0;
diff --git a/fs/hfs/sysdep.c b/fs/hfs/sysdep.c
index 7478f5c219aa..19cf291eb91f 100644
--- a/fs/hfs/sysdep.c
+++ b/fs/hfs/sysdep.c
@@ -8,15 +8,20 @@
  * This file contains the code to do various system dependent things.
  */
 
+#include <linux/namei.h>
 #include "hfs_fs.h"
 
 /* dentry case-handling: just lowercase everything */
 
 static int hfs_revalidate_dentry(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode;
         int diff;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = dentry->d_inode;
         if(!inode)
                 return 1;
 
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 9d59c0571f59..ccab87145f7a 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -37,7 +37,7 @@ static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
 
         sb = dir->i_sb;
 
-        dentry->d_op = &hfsplus_dentry_operations;
+        d_set_d_op(dentry, &hfsplus_dentry_operations);
         dentry->d_fsdata = NULL;
         hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd);
         hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index cb3653efb57a..a5308f491e3e 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -379,8 +379,12 @@ int hfsplus_strcasecmp(const struct hfsplus_unistr *, const struct hfsplus_unist
 int hfsplus_strcmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *);
 int hfsplus_uni2asc(struct super_block *, const struct hfsplus_unistr *, char *, int *);
 int hfsplus_asc2uni(struct super_block *, struct hfsplus_unistr *, const char *, int);
-int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str);
-int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2);
+int hfsplus_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *str);
+int hfsplus_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
 
 /* wrapper.c */
 int hfsplus_read_wrapper(struct super_block *);
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index 52cc746d3ba3..ddf712e4700e 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -419,7 +419,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                 err = -ENOMEM;
                 goto cleanup;
         }
-        sb->s_root->d_op = &hfsplus_dentry_operations;
+        d_set_d_op(sb->s_root, &hfsplus_dentry_operations);
 
         str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
         str.name = HFSP_HIDDENDIR_NAME;
@@ -488,11 +488,19 @@ static struct inode *hfsplus_alloc_inode(struct super_block *sb)
         return i ? &i->vfs_inode : NULL;
 }
 
-static void hfsplus_destroy_inode(struct inode *inode)
+static void hfsplus_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(hfsplus_inode_cachep, HFSPLUS_I(inode));
 }
 
+static void hfsplus_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, hfsplus_i_callback);
+}
+
 #define HFSPLUS_INODE_SIZE      sizeof(struct hfsplus_inode_info)
 
 static struct dentry *hfsplus_mount(struct file_system_type *fs_type,
diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index b66d67de882c..d800aa0f2c80 100644
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -320,7 +320,8 @@ int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
  * Composed unicode characters are decomposed and case-folding is performed
  * if the appropriate bits are (un)set on the superblock.
  */
-int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
+int hfsplus_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *str)
 {
         struct super_block *sb = dentry->d_sb;
         const char *astr;
@@ -363,9 +364,12 @@ int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
  * Composed unicode characters are decomposed and case-folding is performed
  * if the appropriate bits are (un)set on the superblock.
  */
-int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2)
+int hfsplus_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        struct super_block *sb = dentry->d_sb;
+        struct super_block *sb = parent->d_sb;
         int casefold, decompose, size;
         int dsize1, dsize2, len1, len2;
         const u16 *dstr1, *dstr2;
@@ -375,10 +379,10 @@ int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *
 
         casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
         decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
-        astr1 = s1->name;
-        len1 = s1->len;
-        astr2 = s2->name;
-        len2 = s2->len;
+        astr1 = str;
+        len1 = len;
+        astr2 = name->name;
+        len2 = name->len;
         dsize1 = dsize2 = 0;
         dstr1 = dstr2 = NULL;
 
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 2c0f148a49e6..d3244d949a4e 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -32,7 +32,7 @@ static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode)
 
 #define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_path.dentry->d_inode)
 
-static int hostfs_d_delete(struct dentry *dentry)
+static int hostfs_d_delete(const struct dentry *dentry)
 {
         return 1;
 }
@@ -92,12 +92,10 @@ __uml_setup("hostfs=", hostfs_args,
 
 static char *__dentry_name(struct dentry *dentry, char *name)
 {
-        char *p = __dentry_path(dentry, name, PATH_MAX);
+        char *p = dentry_path_raw(dentry, name, PATH_MAX);
         char *root;
         size_t len;
 
-        spin_unlock(&dcache_lock);
-
         root = dentry->d_sb->s_fs_info;
         len = strlen(root);
         if (IS_ERR(p)) {
@@ -123,25 +121,23 @@ static char *dentry_name(struct dentry *dentry)
         if (!name)
                 return NULL;
 
-        spin_lock(&dcache_lock);
         return __dentry_name(dentry, name); /* will unlock */
 }
 
 static char *inode_name(struct inode *ino)
 {
         struct dentry *dentry;
-        char *name = __getname();
-        if (!name)
-                return NULL;
+        char *name;
 
-        spin_lock(&dcache_lock);
-        if (list_empty(&ino->i_dentry)) {
-                spin_unlock(&dcache_lock);
-                __putname(name);
+        dentry = d_find_alias(ino);
+        if (!dentry)
                 return NULL;
-        }
-        dentry = list_first_entry(&ino->i_dentry, struct dentry, d_alias);
-        return __dentry_name(dentry, name); /* will unlock */
+
+        name = dentry_name(dentry);
+
+        dput(dentry);
+
+        return name;
 }
 
 static char *follow_link(char *link)
@@ -251,11 +247,18 @@ static void hostfs_evict_inode(struct inode *inode)
         }
 }
 
-static void hostfs_destroy_inode(struct inode *inode)
+static void hostfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kfree(HOSTFS_I(inode));
 }
 
+static void hostfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, hostfs_i_callback);
+}
+
 static int hostfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
 {
         const char *root_path = vfs->mnt_sb->s_fs_info;
@@ -609,7 +612,7 @@ struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
                 goto out_put;
 
         d_add(dentry, inode);
-        dentry->d_op = &hostfs_dentry_ops;
+        d_set_d_op(dentry, &hostfs_dentry_ops);
         return NULL;
 
  out_put:
@@ -746,11 +749,14 @@ int hostfs_rename(struct inode *from_ino, struct dentry *from,
         return err;
 }
 
-int hostfs_permission(struct inode *ino, int desired)
+int hostfs_permission(struct inode *ino, int desired, unsigned int flags)
 {
         char *name;
         int r = 0, w = 0, x = 0, err;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         if (desired & MAY_READ) r = 1;
         if (desired & MAY_WRITE) w = 1;
         if (desired & MAY_EXEC) x = 1;
@@ -765,7 +771,7 @@ int hostfs_permission(struct inode *ino, int desired)
                 err = access_file(name, r, w, x);
         __putname(name);
         if (!err)
-                err = generic_permission(ino, desired, NULL);
+                err = generic_permission(ino, desired, flags, NULL);
         return err;
 }
 
diff --git a/fs/hpfs/dentry.c b/fs/hpfs/dentry.c
index 67d9d36b3d5f..32c13a94e1e9 100644
--- a/fs/hpfs/dentry.c
+++ b/fs/hpfs/dentry.c
@@ -12,7 +12,8 @@
  * Note: the dentry argument is the parent dentry.
  */
 
-static int hpfs_hash_dentry(struct dentry *dentry, struct qstr *qstr)
+static int hpfs_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         unsigned long    hash;
         int              i;
@@ -34,19 +35,25 @@ static int hpfs_hash_dentry(struct dentry *dentry, struct qstr *qstr)
         return 0;
 }
 
-static int hpfs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
+static int hpfs_compare_dentry(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        unsigned al=a->len;
-        unsigned bl=b->len;
-        hpfs_adjust_length(a->name, &al);
+        unsigned al = len;
+        unsigned bl = name->len;
+
+        hpfs_adjust_length(str, &al);
         /*hpfs_adjust_length(b->name, &bl);*/
-        /* 'a' is the qstr of an already existing dentry, so the name
-         * must be valid. 'b' must be validated first.
+
+        /*
+         * 'str' is the nane of an already existing dentry, so the name
+         * must be valid. 'name' must be validated first.
          */
 
-        if (hpfs_chk_name(b->name, &bl))
+        if (hpfs_chk_name(name->name, &bl))
                 return 1;
-        if (hpfs_compare_names(dentry->d_sb, a->name, al, b->name, bl, 0))
+        if (hpfs_compare_names(parent->d_sb, str, al, name->name, bl, 0))
                 return 1;
         return 0;
 }
@@ -58,5 +65,5 @@ static const struct dentry_operations hpfs_dentry_operations = {
 
 void hpfs_set_dentry_operations(struct dentry *dentry)
 {
-        dentry->d_op = &hpfs_dentry_operations;
+        d_set_d_op(dentry, &hpfs_dentry_operations);
 }
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index 11c2b4080f65..f4ad9e31ddc4 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -419,7 +419,7 @@ again:
                         unlock_kernel();
                         return -ENOSPC;
                 }
-                if (generic_permission(inode, MAY_WRITE, NULL) ||
+                if (generic_permission(inode, MAY_WRITE, 0, NULL) ||
                     !S_ISREG(inode->i_mode) ||
                     get_write_access(inode)) {
                         d_rehash(dentry);
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 6c5f01597c3a..49935ba78db8 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -177,11 +177,18 @@ static struct inode *hpfs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void hpfs_destroy_inode(struct inode *inode)
+static void hpfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(hpfs_inode_cachep, hpfs_i(inode));
 }
 
+static void hpfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, hpfs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct hpfs_inode_info *ei = (struct hpfs_inode_info *) foo;
diff --git a/fs/hppfs/hppfs.c b/fs/hppfs/hppfs.c
index f702b5f713fc..87ed48e0343d 100644
--- a/fs/hppfs/hppfs.c
+++ b/fs/hppfs/hppfs.c
@@ -632,11 +632,18 @@ void hppfs_evict_inode(struct inode *ino)
         mntput(ino->i_sb->s_fs_info);
 }
 
-static void hppfs_destroy_inode(struct inode *inode)
+static void hppfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kfree(HPPFS_I(inode));
 }
 
+static void hppfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, hppfs_i_callback);
+}
+
 static const struct super_operations hppfs_sbops = {
         .alloc_inode    = hppfs_alloc_inode,
         .destroy_inode  = hppfs_destroy_inode,
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index a5fe68189eed..9885082b470f 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -663,11 +663,18 @@ static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
         return &p->vfs_inode;
 }
 
+static void hugetlbfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode));
+}
+
 static void hugetlbfs_destroy_inode(struct inode *inode)
 {
         hugetlbfs_inc_free_inodes(HUGETLBFS_SB(inode->i_sb));
         mpol_free_shared_policy(&HUGETLBFS_I(inode)->policy);
-        kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode));
+        call_rcu(&inode->i_rcu, hugetlbfs_i_callback);
 }
 
 static const struct address_space_operations hugetlbfs_aops = {
diff --git a/fs/inode.c b/fs/inode.c
index ae2727ab0c3a..da85e56378f3 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -102,26 +102,29 @@ static DECLARE_RWSEM(iprune_sem);
  */
 struct inodes_stat_t inodes_stat;
 
-static struct percpu_counter nr_inodes __cacheline_aligned_in_smp;
-static struct percpu_counter nr_inodes_unused __cacheline_aligned_in_smp;
+static DEFINE_PER_CPU(unsigned int, nr_inodes);
 
 static struct kmem_cache *inode_cachep __read_mostly;
 
-static inline int get_nr_inodes(void)
+static int get_nr_inodes(void)
 {
-        return percpu_counter_sum_positive(&nr_inodes);
+        int i;
+        int sum = 0;
+        for_each_possible_cpu(i)
+                sum += per_cpu(nr_inodes, i);
+        return sum < 0 ? 0 : sum;
 }
 
 static inline int get_nr_inodes_unused(void)
 {
-        return percpu_counter_sum_positive(&nr_inodes_unused);
+        return inodes_stat.nr_unused;
 }
 
 int get_nr_dirty_inodes(void)
 {
+        /* not actually dirty inodes, but a wild approximation */
         int nr_dirty = get_nr_inodes() - get_nr_inodes_unused();
         return nr_dirty > 0 ? nr_dirty : 0;
-
 }
 
 /*
@@ -132,7 +135,6 @@ int proc_nr_inodes(ctl_table *table, int write,
                    void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         inodes_stat.nr_inodes = get_nr_inodes();
-        inodes_stat.nr_unused = get_nr_inodes_unused();
         return proc_dointvec(table, write, buffer, lenp, ppos);
 }
 #endif
@@ -224,7 +226,7 @@ int inode_init_always(struct super_block *sb, struct inode *inode)
         inode->i_fsnotify_mask = 0;
 #endif
 
-        percpu_counter_inc(&nr_inodes);
+        this_cpu_inc(nr_inodes);
 
         return 0;
 out:
@@ -255,6 +257,12 @@ static struct inode *alloc_inode(struct super_block *sb)
         return inode;
 }
 
+void free_inode_nonrcu(struct inode *inode)
+{
+        kmem_cache_free(inode_cachep, inode);
+}
+EXPORT_SYMBOL(free_inode_nonrcu);
+
 void __destroy_inode(struct inode *inode)
 {
         BUG_ON(inode_has_buffers(inode));
@@ -266,10 +274,17 @@ void __destroy_inode(struct inode *inode)
         if (inode->i_default_acl && inode->i_default_acl != ACL_NOT_CACHED)
                 posix_acl_release(inode->i_default_acl);
 #endif
-        percpu_counter_dec(&nr_inodes);
+        this_cpu_dec(nr_inodes);
 }
 EXPORT_SYMBOL(__destroy_inode);
 
+static void i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(inode_cachep, inode);
+}
+
 static void destroy_inode(struct inode *inode)
 {
         BUG_ON(!list_empty(&inode->i_lru));
@@ -277,7 +292,7 @@ static void destroy_inode(struct inode *inode)
         if (inode->i_sb->s_op->destroy_inode)
                 inode->i_sb->s_op->destroy_inode(inode);
         else
-                kmem_cache_free(inode_cachep, (inode));
+                call_rcu(&inode->i_rcu, i_callback);
 }
 
 /*
@@ -335,7 +350,7 @@ static void inode_lru_list_add(struct inode *inode)
 {
         if (list_empty(&inode->i_lru)) {
                 list_add(&inode->i_lru, &inode_lru);
-                percpu_counter_inc(&nr_inodes_unused);
+                inodes_stat.nr_unused++;
         }
 }
 
@@ -343,7 +358,7 @@ static void inode_lru_list_del(struct inode *inode)
 {
         if (!list_empty(&inode->i_lru)) {
                 list_del_init(&inode->i_lru);
-                percpu_counter_dec(&nr_inodes_unused);
+                inodes_stat.nr_unused--;
         }
 }
 
@@ -430,6 +445,7 @@ void end_writeback(struct inode *inode)
         BUG_ON(!(inode->i_state & I_FREEING));
         BUG_ON(inode->i_state & I_CLEAR);
         inode_sync_wait(inode);
+        /* don't need i_lock here, no concurrent mods to i_state */
         inode->i_state = I_FREEING | I_CLEAR;
 }
 EXPORT_SYMBOL(end_writeback);
@@ -513,7 +529,7 @@ void evict_inodes(struct super_block *sb)
                 list_move(&inode->i_lru, &dispose);
                 list_del_init(&inode->i_wb_list);
                 if (!(inode->i_state & (I_DIRTY | I_SYNC)))
-                        percpu_counter_dec(&nr_inodes_unused);
+                        inodes_stat.nr_unused--;
         }
         spin_unlock(&inode_lock);
 
@@ -554,7 +570,7 @@ int invalidate_inodes(struct super_block *sb)
                 list_move(&inode->i_lru, &dispose);
                 list_del_init(&inode->i_wb_list);
                 if (!(inode->i_state & (I_DIRTY | I_SYNC)))
-                        percpu_counter_dec(&nr_inodes_unused);
+                        inodes_stat.nr_unused--;
         }
         spin_unlock(&inode_lock);
 
@@ -616,7 +632,7 @@ static void prune_icache(int nr_to_scan)
                 if (atomic_read(&inode->i_count) ||
                     (inode->i_state & ~I_REFERENCED)) {
                         list_del_init(&inode->i_lru);
-                        percpu_counter_dec(&nr_inodes_unused);
+                        inodes_stat.nr_unused--;
                         continue;
                 }
 
@@ -650,7 +666,7 @@ static void prune_icache(int nr_to_scan)
                  */
                 list_move(&inode->i_lru, &freeable);
                 list_del_init(&inode->i_wb_list);
-                percpu_counter_dec(&nr_inodes_unused);
+                inodes_stat.nr_unused--;
         }
         if (current_is_kswapd())
                 __count_vm_events(KSWAPD_INODESTEAL, reap);
@@ -1648,8 +1664,6 @@ void __init inode_init(void)
                                          SLAB_MEM_SPREAD),
                                          init_once);
         register_shrinker(&icache_shrinker);
-        percpu_counter_init(&nr_inodes, 0);
-        percpu_counter_init(&nr_inodes_unused, 0);
 
         /* Hash may have been set up in inode_init_early */
         if (!hashdist)
diff --git a/fs/internal.h b/fs/internal.h
index e43b9a4dbf4e..9687c2ee2735 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -63,6 +63,7 @@ extern int copy_mount_string(const void __user *, char **);
 
 extern void free_vfsmnt(struct vfsmount *);
 extern struct vfsmount *alloc_vfsmnt(const char *);
+extern unsigned int mnt_get_count(struct vfsmount *mnt);
 extern struct vfsmount *__lookup_mnt(struct vfsmount *, struct dentry *, int);
 extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
                                 struct vfsmount *);
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index bfdeb82a53be..844a7903c72f 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -26,16 +26,32 @@
 
 #define BEQUIET
 
-static int isofs_hashi(struct dentry *parent, struct qstr *qstr);
-static int isofs_hash(struct dentry *parent, struct qstr *qstr);
-static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
-static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
+static int isofs_hashi(const struct dentry *parent, const struct inode *inode,
+                struct qstr *qstr);
+static int isofs_hash(const struct dentry *parent, const struct inode *inode,
+                struct qstr *qstr);
+static int isofs_dentry_cmpi(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
+static int isofs_dentry_cmp(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
 
 #ifdef CONFIG_JOLIET
-static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr);
-static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr);
-static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
-static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
+static int isofs_hashi_ms(const struct dentry *parent, const struct inode *inode,
+                struct qstr *qstr);
+static int isofs_hash_ms(const struct dentry *parent, const struct inode *inode,
+                struct qstr *qstr);
+static int isofs_dentry_cmpi_ms(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
+static int isofs_dentry_cmp_ms(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name);
 #endif
 
 static void isofs_put_super(struct super_block *sb)
@@ -65,11 +81,18 @@ static struct inode *isofs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void isofs_destroy_inode(struct inode *inode)
+static void isofs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
 }
 
+static void isofs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, isofs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct iso_inode_info *ei = foo;
@@ -160,7 +183,7 @@ struct iso9660_options{
  * Compute the hash for the isofs name corresponding to the dentry.
  */
 static int
-isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
+isofs_hash_common(const struct dentry *dentry, struct qstr *qstr, int ms)
 {
         const char *name;
         int len;
@@ -181,7 +204,7 @@ isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
  * Compute the hash for the isofs name corresponding to the dentry.
  */
 static int
-isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
+isofs_hashi_common(const struct dentry *dentry, struct qstr *qstr, int ms)
 {
         const char *name;
         int len;
@@ -206,100 +229,94 @@ isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
 }
 
 /*
- * Case insensitive compare of two isofs names.
- */
-static int isofs_dentry_cmpi_common(struct dentry *dentry, struct qstr *a,
-                                struct qstr *b, int ms)
-{
-        int alen, blen;
-
-        /* A filename cannot end in '.' or we treat it like it has none */
-        alen = a->len;
-        blen = b->len;
-        if (ms) {
-                while (alen && a->name[alen-1] == '.')
-                        alen--;
-                while (blen && b->name[blen-1] == '.')
-                        blen--;
-        }
-        if (alen == blen) {
-                if (strnicmp(a->name, b->name, alen) == 0)
-                        return 0;
-        }
-        return 1;
-}
-
-/*
- * Case sensitive compare of two isofs names.
+ * Compare of two isofs names.
  */
-static int isofs_dentry_cmp_common(struct dentry *dentry, struct qstr *a,
-                                        struct qstr *b, int ms)
+static int isofs_dentry_cmp_common(
+                unsigned int len, const char *str,
+                const struct qstr *name, int ms, int ci)
 {
         int alen, blen;
 
         /* A filename cannot end in '.' or we treat it like it has none */
-        alen = a->len;
-        blen = b->len;
+        alen = name->len;
+        blen = len;
         if (ms) {
-                while (alen && a->name[alen-1] == '.')
+                while (alen && name->name[alen-1] == '.')
                         alen--;
-                while (blen && b->name[blen-1] == '.')
+                while (blen && str[blen-1] == '.')
                         blen--;
         }
         if (alen == blen) {
-                if (strncmp(a->name, b->name, alen) == 0)
-                        return 0;
+                if (ci) {
+                        if (strnicmp(name->name, str, alen) == 0)
+                                return 0;
+                } else {
+                        if (strncmp(name->name, str, alen) == 0)
+                                return 0;
+                }
         }
         return 1;
 }
 
 static int
-isofs_hash(struct dentry *dentry, struct qstr *qstr)
+isofs_hash(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         return isofs_hash_common(dentry, qstr, 0);
 }
 
 static int
-isofs_hashi(struct dentry *dentry, struct qstr *qstr)
+isofs_hashi(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         return isofs_hashi_common(dentry, qstr, 0);
 }
 
 static int
-isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b)
+isofs_dentry_cmp(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        return isofs_dentry_cmp_common(dentry, a, b, 0);
+        return isofs_dentry_cmp_common(len, str, name, 0, 0);
 }
 
 static int
-isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b)
+isofs_dentry_cmpi(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        return isofs_dentry_cmpi_common(dentry, a, b, 0);
+        return isofs_dentry_cmp_common(len, str, name, 0, 1);
 }
 
 #ifdef CONFIG_JOLIET
 static int
-isofs_hash_ms(struct dentry *dentry, struct qstr *qstr)
+isofs_hash_ms(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         return isofs_hash_common(dentry, qstr, 1);
 }
 
 static int
-isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr)
+isofs_hashi_ms(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         return isofs_hashi_common(dentry, qstr, 1);
 }
 
 static int
-isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
+isofs_dentry_cmp_ms(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        return isofs_dentry_cmp_common(dentry, a, b, 1);
+        return isofs_dentry_cmp_common(len, str, name, 1, 0);
 }
 
 static int
-isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
+isofs_dentry_cmpi_ms(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        return isofs_dentry_cmpi_common(dentry, a, b, 1);
+        return isofs_dentry_cmp_common(len, str, name, 1, 1);
 }
 #endif
 
@@ -932,7 +949,7 @@ root_found:
                 table += 2;
         if (opt.check == 'r')
                 table++;
-        s->s_root->d_op = &isofs_dentry_ops[table];
+        d_set_d_op(s->s_root, &isofs_dentry_ops[table]);
 
         kfree(opt.iocharset);
 
diff --git a/fs/isofs/namei.c b/fs/isofs/namei.c
index 0d23abfd4280..679a849c3b27 100644
--- a/fs/isofs/namei.c
+++ b/fs/isofs/namei.c
@@ -37,7 +37,8 @@ isofs_cmp(struct dentry *dentry, const char *compare, int dlen)
 
         qstr.name = compare;
         qstr.len = dlen;
-        return dentry->d_op->d_compare(dentry, &dentry->d_name, &qstr);
+        return dentry->d_op->d_compare(NULL, NULL, NULL, NULL,
+                        dentry->d_name.len, dentry->d_name.name, &qstr);
 }
 
 /*
@@ -171,7 +172,7 @@ struct dentry *isofs_lookup(struct inode *dir, struct dentry *dentry, struct nam
         struct inode *inode;
         struct page *page;
 
-        dentry->d_op = dir->i_sb->s_root->d_op;
+        d_set_d_op(dentry, dir->i_sb->s_root->d_op);
 
         page = alloc_page(GFP_USER);
         if (!page)
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index 54a92fd02bbd..95b79672150a 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -259,11 +259,14 @@ static int jffs2_set_acl(struct inode *inode, int type, struct posix_acl *acl)
         return rc;
 }
 
-int jffs2_check_acl(struct inode *inode, int mask)
+int jffs2_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
         struct posix_acl *acl;
         int rc;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         acl = jffs2_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
diff --git a/fs/jffs2/acl.h b/fs/jffs2/acl.h
index 5e42de8d9541..3119f59253d3 100644
--- a/fs/jffs2/acl.h
+++ b/fs/jffs2/acl.h
@@ -26,7 +26,7 @@ struct jffs2_acl_header {
 
 #ifdef CONFIG_JFFS2_FS_POSIX_ACL
 
-extern int jffs2_check_acl(struct inode *, int);
+extern int jffs2_check_acl(struct inode *, int, unsigned int);
 extern int jffs2_acl_chmod(struct inode *);
 extern int jffs2_init_acl_pre(struct inode *, struct inode *, int *);
 extern int jffs2_init_acl_post(struct inode *);
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index c86041b866a4..853b8e300084 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -40,11 +40,18 @@ static struct inode *jffs2_alloc_inode(struct super_block *sb)
         return &f->vfs_inode;
 }
 
-static void jffs2_destroy_inode(struct inode *inode)
+static void jffs2_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
 }
 
+static void jffs2_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, jffs2_i_callback);
+}
+
 static void jffs2_i_init_once(void *foo)
 {
         struct jffs2_inode_info *f = foo;
diff --git a/fs/jfs/acl.c b/fs/jfs/acl.c
index 1057a4998e4e..e5de9422fa32 100644
--- a/fs/jfs/acl.c
+++ b/fs/jfs/acl.c
@@ -114,10 +114,14 @@ out:
         return rc;
 }
 
-int jfs_check_acl(struct inode *inode, int mask)
+int jfs_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct posix_acl *acl = jfs_get_acl(inode, ACL_TYPE_ACCESS);
+        struct posix_acl *acl;
+
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
 
+        acl = jfs_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl) {
diff --git a/fs/jfs/jfs_acl.h b/fs/jfs/jfs_acl.h
index 54e07559878d..f9285c4900fa 100644
--- a/fs/jfs/jfs_acl.h
+++ b/fs/jfs/jfs_acl.h
@@ -20,7 +20,7 @@
 
 #ifdef CONFIG_JFS_POSIX_ACL
 
-int jfs_check_acl(struct inode *, int);
+int jfs_check_acl(struct inode *, int, unsigned int flags);
 int jfs_init_acl(tid_t, struct inode *, struct inode *);
 int jfs_acl_chmod(struct inode *inode);
 
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 231ca4af9bce..4414e3a42264 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/fs.h>
+#include <linux/namei.h>
 #include <linux/ctype.h>
 #include <linux/quotaops.h>
 #include <linux/exportfs.h>
@@ -1465,7 +1466,7 @@ static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struc
         jfs_info("jfs_lookup: name = %s", name);
 
         if (JFS_SBI(dip->i_sb)->mntflag & JFS_OS2)
-                dentry->d_op = &jfs_ci_dentry_operations;
+                d_set_d_op(dentry, &jfs_ci_dentry_operations);
 
         if ((name[0] == '.') && (len == 1))
                 inum = dip->i_ino;
@@ -1494,7 +1495,7 @@ static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struc
         dentry = d_splice_alias(ip, dentry);
 
         if (dentry && (JFS_SBI(dip->i_sb)->mntflag & JFS_OS2))
-                dentry->d_op = &jfs_ci_dentry_operations;
+                d_set_d_op(dentry, &jfs_ci_dentry_operations);
 
         return dentry;
 }
@@ -1573,7 +1574,8 @@ const struct file_operations jfs_dir_operations = {
         .llseek         = generic_file_llseek,
 };
 
-static int jfs_ci_hash(struct dentry *dir, struct qstr *this)
+static int jfs_ci_hash(const struct dentry *dir, const struct inode *inode,
+                struct qstr *this)
 {
         unsigned long hash;
         int i;
@@ -1586,32 +1588,63 @@ static int jfs_ci_hash(struct dentry *dir, struct qstr *this)
         return 0;
 }
 
-static int jfs_ci_compare(struct dentry *dir, struct qstr *a, struct qstr *b)
+static int jfs_ci_compare(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
         int i, result = 1;
 
-        if (a->len != b->len)
+        if (len != name->len)
                 goto out;
-        for (i=0; i < a->len; i++) {
-                if (tolower(a->name[i]) != tolower(b->name[i]))
+        for (i=0; i < len; i++) {
+                if (tolower(str[i]) != tolower(name->name[i]))
                         goto out;
         }
         result = 0;
+out:
+        return result;
+}
 
+static int jfs_ci_revalidate(struct dentry *dentry, struct nameidata *nd)
+{
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
         /*
-         * We want creates to preserve case.  A negative dentry, a, that
-         * has a different case than b may cause a new entry to be created
-         * with the wrong case.  Since we can't tell if a comes from a negative
-         * dentry, we blindly replace it with b.  This should be harmless if
-         * a is not a negative dentry.
+         * This is not negative dentry. Always valid.
+         *
+         * Note, rename() to existing directory entry will have ->d_inode,
+         * and will use existing name which isn't specified name by user.
+         *
+         * We may be able to drop this positive dentry here. But dropping
+         * positive dentry isn't good idea. So it's unsupported like
+         * rename("filename", "FILENAME") for now.
          */
-        memcpy((unsigned char *)a->name, b->name, a->len);
-out:
-        return result;
+        if (dentry->d_inode)
+                return 1;
+
+        /*
+         * This may be nfsd (or something), anyway, we can't see the
+         * intent of this. So, since this can be for creation, drop it.
+         */
+        if (!nd)
+                return 0;
+
+        /*
+         * Drop the negative dentry, in order to make sure to use the
+         * case sensitive name which is specified by user if this is
+         * for creation.
+         */
+        if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
+                if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+                        return 0;
+        }
+        return 1;
 }
 
 const struct dentry_operations jfs_ci_dentry_operations =
 {
         .d_hash = jfs_ci_hash,
         .d_compare = jfs_ci_compare,
+        .d_revalidate = jfs_ci_revalidate,
 };
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 0669fc1cc3bf..3150d766e0d4 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -115,6 +115,14 @@ static struct inode *jfs_alloc_inode(struct super_block *sb)
         return &jfs_inode->vfs_inode;
 }
 
+static void jfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        struct jfs_inode_info *ji = JFS_IP(inode);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(jfs_inode_cachep, ji);
+}
+
 static void jfs_destroy_inode(struct inode *inode)
 {
         struct jfs_inode_info *ji = JFS_IP(inode);
@@ -128,7 +136,7 @@ static void jfs_destroy_inode(struct inode *inode)
                 ji->active_ag = -1;
         }
         spin_unlock_irq(&ji->ag_lock);
-        kmem_cache_free(jfs_inode_cachep, ji);
+        call_rcu(&inode->i_rcu, jfs_i_callback);
 }
 
 static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
@@ -517,7 +525,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
                 goto out_no_root;
 
         if (sbi->mntflag & JFS_OS2)
-                sb->s_root->d_op = &jfs_ci_dentry_operations;
+                d_set_d_op(sb->s_root, &jfs_ci_dentry_operations);
 
         /* logical blocks are represented by 40 bits in pxd_t, etc. */
         sb->s_maxbytes = ((u64) sb->s_blocksize) << 40;
diff --git a/fs/libfs.c b/fs/libfs.c
index a3accdf528ad..889311e3d06b 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -16,6 +16,11 @@
 
 #include <asm/uaccess.h>
 
+static inline int simple_positive(struct dentry *dentry)
+{
+        return dentry->d_inode && !d_unhashed(dentry);
+}
+
 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
                    struct kstat *stat)
 {
@@ -37,7 +42,7 @@ int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
  * Retaining negative dentries for an in-memory filesystem just wastes
  * memory and lookup time: arrange for them to be deleted immediately.
  */
-static int simple_delete_dentry(struct dentry *dentry)
+static int simple_delete_dentry(const struct dentry *dentry)
 {
         return 1;
 }
@@ -54,7 +59,7 @@ struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct na
 
         if (dentry->d_name.len > NAME_MAX)
                 return ERR_PTR(-ENAMETOOLONG);
-        dentry->d_op = &simple_dentry_operations;
+        d_set_d_op(dentry, &simple_dentry_operations);
         d_add(dentry, NULL);
         return NULL;
 }
@@ -76,7 +81,8 @@ int dcache_dir_close(struct inode *inode, struct file *file)
 
 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
 {
-        mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
+        struct dentry *dentry = file->f_path.dentry;
+        mutex_lock(&dentry->d_inode->i_mutex);
         switch (origin) {
                 case 1:
                         offset += file->f_pos;
@@ -84,7 +90,7 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
+                        mutex_unlock(&dentry->d_inode->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
@@ -94,21 +100,24 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
                         struct dentry *cursor = file->private_data;
                         loff_t n = file->f_pos - 2;
 
-                        spin_lock(&dcache_lock);
+                        spin_lock(&dentry->d_lock);
+                        /* d_lock not required for cursor */
                         list_del(&cursor->d_u.d_child);
-                        p = file->f_path.dentry->d_subdirs.next;
-                        while (n && p != &file->f_path.dentry->d_subdirs) {
+                        p = dentry->d_subdirs.next;
+                        while (n && p != &dentry->d_subdirs) {
                                 struct dentry *next;
                                 next = list_entry(p, struct dentry, d_u.d_child);
-                                if (!d_unhashed(next) && next->d_inode)
+                                spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
+                                if (simple_positive(next))
                                         n--;
+                                spin_unlock(&next->d_lock);
                                 p = p->next;
                         }
                         list_add_tail(&cursor->d_u.d_child, p);
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&dentry->d_lock);
                 }
         }
-        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
+        mutex_unlock(&dentry->d_inode->i_mutex);
         return offset;
 }
 
@@ -148,29 +157,35 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
                         i++;
                         /* fallthrough */
                 default:
-                        spin_lock(&dcache_lock);
+                        spin_lock(&dentry->d_lock);
                         if (filp->f_pos == 2)
                                 list_move(q, &dentry->d_subdirs);
 
                         for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
                                 struct dentry *next;
                                 next = list_entry(p, struct dentry, d_u.d_child);
-                                if (d_unhashed(next) || !next->d_inode)
+                                spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
+                                if (!simple_positive(next)) {
+                                        spin_unlock(&next->d_lock);
                                         continue;
+                                }
 
-                                spin_unlock(&dcache_lock);
+                                spin_unlock(&next->d_lock);
+                                spin_unlock(&dentry->d_lock);
                                 if (filldir(dirent, next->d_name.name, 
                                             next->d_name.len, filp->f_pos, 
                                             next->d_inode->i_ino, 
                                             dt_type(next->d_inode)) < 0)
                                         return 0;
-                                spin_lock(&dcache_lock);
+                                spin_lock(&dentry->d_lock);
+                                spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
                                 /* next is still alive */
                                 list_move(q, p);
+                                spin_unlock(&next->d_lock);
                                 p = q;
                                 filp->f_pos++;
                         }
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&dentry->d_lock);
         }
         return 0;
 }
@@ -259,23 +274,23 @@ int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *den
         return 0;
 }
 
-static inline int simple_positive(struct dentry *dentry)
-{
-        return dentry->d_inode && !d_unhashed(dentry);
-}
-
 int simple_empty(struct dentry *dentry)
 {
         struct dentry *child;
         int ret = 0;
 
-        spin_lock(&dcache_lock);
-        list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
-                if (simple_positive(child))
+        spin_lock(&dentry->d_lock);
+        list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
+                spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
+                if (simple_positive(child)) {
+                        spin_unlock(&child->d_lock);
                         goto out;
+                }
+                spin_unlock(&child->d_lock);
+        }
         ret = 1;
 out:
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
         return ret;
 }
 
diff --git a/fs/locks.c b/fs/locks.c
index 8729347bcd1a..08415b2a6d36 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1389,7 +1389,7 @@ int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
                 if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
                         goto out;
                 if ((arg == F_WRLCK)
-                    && ((atomic_read(&dentry->d_count) > 1)
+                    && ((dentry->d_count > 1)
                         || (atomic_read(&inode->i_count) > 1)))
                         goto out;
         }
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index 409dfd65e9a1..f9ddf0c388c8 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -555,9 +555,11 @@ static int logfs_symlink(struct inode *dir, struct dentry *dentry,
         return __logfs_create(dir, dentry, inode, target, destlen);
 }
 
-static int logfs_permission(struct inode *inode, int mask)
+static int logfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
-        return generic_permission(inode, mask, NULL);
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+        return generic_permission(inode, mask, flags, NULL);
 }
 
 static int logfs_link(struct dentry *old_dentry, struct inode *dir,
diff --git a/fs/logfs/inode.c b/fs/logfs/inode.c
index d8c71ece098f..03b8c240aeda 100644
--- a/fs/logfs/inode.c
+++ b/fs/logfs/inode.c
@@ -141,13 +141,20 @@ struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *is_cached)
         return __logfs_iget(sb, ino);
 }
 
+static void logfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(logfs_inode_cache, logfs_inode(inode));
+}
+
 static void __logfs_destroy_inode(struct inode *inode)
 {
         struct logfs_inode *li = logfs_inode(inode);
 
         BUG_ON(li->li_block);
         list_del(&li->li_freeing_list);
-        kmem_cache_free(logfs_inode_cache, li);
+        call_rcu(&inode->i_rcu, logfs_i_callback);
 }
 
 static void logfs_destroy_inode(struct inode *inode)
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index fb2020858a34..ae0b83f476a6 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -68,11 +68,18 @@ static struct inode *minix_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void minix_destroy_inode(struct inode *inode)
+static void minix_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(minix_inode_cachep, minix_i(inode));
 }
 
+static void minix_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, minix_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct minix_inode_info *ei = (struct minix_inode_info *) foo;
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index c0d35a3accef..1b9e07728a9f 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -23,7 +23,7 @@ static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, st
         struct inode * inode = NULL;
         ino_t ino;
 
-        dentry->d_op = dir->i_sb->s_root->d_op;
+        d_set_d_op(dentry, dir->i_sb->s_root->d_op);
 
         if (dentry->d_name.len > minix_sb(dir->i_sb)->s_namelen)
                 return ERR_PTR(-ENAMETOOLONG);
diff --git a/fs/namei.c b/fs/namei.c
index 4ff7ca530533..19433cdba011 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -169,8 +169,8 @@ EXPORT_SYMBOL(putname);
 /*
  * This does basic POSIX ACL permission checking
  */
-static int acl_permission_check(struct inode *inode, int mask,
-                int (*check_acl)(struct inode *inode, int mask))
+static int acl_permission_check(struct inode *inode, int mask, unsigned int flags,
+                int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
 {
         umode_t                 mode = inode->i_mode;
 
@@ -180,7 +180,7 @@ static int acl_permission_check(struct inode *inode, int mask,
                 mode >>= 6;
         else {
                 if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
-                        int error = check_acl(inode, mask);
+                        int error = check_acl(inode, mask, flags);
                         if (error != -EAGAIN)
                                 return error;
                 }
@@ -198,25 +198,30 @@ static int acl_permission_check(struct inode *inode, int mask,
 }
 
 /**
- * generic_permission  -  check for access rights on a Posix-like filesystem
+ * generic_permission -  check for access rights on a Posix-like filesystem
  * @inode:      inode to check access rights for
  * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
  * @check_acl:  optional callback to check for Posix ACLs
+ * @flags       IPERM_FLAG_ flags.
  *
  * Used to check for read/write/execute permissions on a file.
  * We use "fsuid" for this, letting us set arbitrary permissions
  * for filesystem access without changing the "normal" uids which
- * are used for other things..
+ * are used for other things.
+ *
+ * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
+ * request cannot be satisfied (eg. requires blocking or too much complexity).
+ * It would then be called again in ref-walk mode.
  */
-int generic_permission(struct inode *inode, int mask,
-                int (*check_acl)(struct inode *inode, int mask))
+int generic_permission(struct inode *inode, int mask, unsigned int flags,
+        int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
 {
         int ret;
 
         /*
          * Do the basic POSIX ACL permission checks.
          */
-        ret = acl_permission_check(inode, mask, check_acl);
+        ret = acl_permission_check(inode, mask, flags, check_acl);
         if (ret != -EACCES)
                 return ret;
 
@@ -271,9 +276,10 @@ int inode_permission(struct inode *inode, int mask)
         }
 
         if (inode->i_op->permission)
-                retval = inode->i_op->permission(inode, mask);
+                retval = inode->i_op->permission(inode, mask, 0);
         else
-                retval = generic_permission(inode, mask, inode->i_op->check_acl);
+                retval = generic_permission(inode, mask, 0,
+                                inode->i_op->check_acl);
 
         if (retval)
                 return retval;
@@ -362,6 +368,18 @@ void path_get(struct path *path)
 EXPORT_SYMBOL(path_get);
 
 /**
+ * path_get_long - get a long reference to a path
+ * @path: path to get the reference to
+ *
+ * Given a path increment the reference count to the dentry and the vfsmount.
+ */
+void path_get_long(struct path *path)
+{
+        mntget_long(path->mnt);
+        dget(path->dentry);
+}
+
+/**
  * path_put - put a reference to a path
  * @path: path to put the reference to
  *
@@ -375,6 +393,185 @@ void path_put(struct path *path)
 EXPORT_SYMBOL(path_put);
 
 /**
+ * path_put_long - put a long reference to a path
+ * @path: path to put the reference to
+ *
+ * Given a path decrement the reference count to the dentry and the vfsmount.
+ */
+void path_put_long(struct path *path)
+{
+        dput(path->dentry);
+        mntput_long(path->mnt);
+}
+
+/**
+ * nameidata_drop_rcu - drop this nameidata out of rcu-walk
+ * @nd: nameidata pathwalk data to drop
+ * @Returns: 0 on success, -ECHLID on failure
+ *
+ * Path walking has 2 modes, rcu-walk and ref-walk (see
+ * Documentation/filesystems/path-lookup.txt). __drop_rcu* functions attempt
+ * to drop out of rcu-walk mode and take normal reference counts on dentries
+ * and vfsmounts to transition to rcu-walk mode. __drop_rcu* functions take
+ * refcounts at the last known good point before rcu-walk got stuck, so
+ * ref-walk may continue from there. If this is not successful (eg. a seqcount
+ * has changed), then failure is returned and path walk restarts from the
+ * beginning in ref-walk mode.
+ *
+ * nameidata_drop_rcu attempts to drop the current nd->path and nd->root into
+ * ref-walk. Must be called from rcu-walk context.
+ */
+static int nameidata_drop_rcu(struct nameidata *nd)
+{
+        struct fs_struct *fs = current->fs;
+        struct dentry *dentry = nd->path.dentry;
+
+        BUG_ON(!(nd->flags & LOOKUP_RCU));
+        if (nd->root.mnt) {
+                spin_lock(&fs->lock);
+                if (nd->root.mnt != fs->root.mnt ||
+                                nd->root.dentry != fs->root.dentry)
+                        goto err_root;
+        }
+        spin_lock(&dentry->d_lock);
+        if (!__d_rcu_to_refcount(dentry, nd->seq))
+                goto err;
+        BUG_ON(nd->inode != dentry->d_inode);
+        spin_unlock(&dentry->d_lock);
+        if (nd->root.mnt) {
+                path_get(&nd->root);
+                spin_unlock(&fs->lock);
+        }
+        mntget(nd->path.mnt);
+
+        rcu_read_unlock();
+        br_read_unlock(vfsmount_lock);
+        nd->flags &= ~LOOKUP_RCU;
+        return 0;
+err:
+        spin_unlock(&dentry->d_lock);
+err_root:
+        if (nd->root.mnt)
+                spin_unlock(&fs->lock);
+        return -ECHILD;
+}
+
+/* Try to drop out of rcu-walk mode if we were in it, otherwise do nothing.  */
+static inline int nameidata_drop_rcu_maybe(struct nameidata *nd)
+{
+        if (nd->flags & LOOKUP_RCU)
+                return nameidata_drop_rcu(nd);
+        return 0;
+}
+
+/**
+ * nameidata_dentry_drop_rcu - drop nameidata and dentry out of rcu-walk
+ * @nd: nameidata pathwalk data to drop
+ * @dentry: dentry to drop
+ * @Returns: 0 on success, -ECHLID on failure
+ *
+ * nameidata_dentry_drop_rcu attempts to drop the current nd->path and nd->root,
+ * and dentry into ref-walk. @dentry must be a path found by a do_lookup call on
+ * @nd. Must be called from rcu-walk context.
+ */
+static int nameidata_dentry_drop_rcu(struct nameidata *nd, struct dentry *dentry)
+{
+        struct fs_struct *fs = current->fs;
+        struct dentry *parent = nd->path.dentry;
+
+        BUG_ON(!(nd->flags & LOOKUP_RCU));
+        if (nd->root.mnt) {
+                spin_lock(&fs->lock);
+                if (nd->root.mnt != fs->root.mnt ||
+                                nd->root.dentry != fs->root.dentry)
+                        goto err_root;
+        }
+        spin_lock(&parent->d_lock);
+        spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
+        if (!__d_rcu_to_refcount(dentry, nd->seq))
+                goto err;
+        /*
+         * If the sequence check on the child dentry passed, then the child has
+         * not been removed from its parent. This means the parent dentry must
+         * be valid and able to take a reference at this point.
+         */
+        BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
+        BUG_ON(!parent->d_count);
+        parent->d_count++;
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&parent->d_lock);
+        if (nd->root.mnt) {
+                path_get(&nd->root);
+                spin_unlock(&fs->lock);
+        }
+        mntget(nd->path.mnt);
+
+        rcu_read_unlock();
+        br_read_unlock(vfsmount_lock);
+        nd->flags &= ~LOOKUP_RCU;
+        return 0;
+err:
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&parent->d_lock);
+err_root:
+        if (nd->root.mnt)
+                spin_unlock(&fs->lock);
+        return -ECHILD;
+}
+
+/* Try to drop out of rcu-walk mode if we were in it, otherwise do nothing.  */
+static inline int nameidata_dentry_drop_rcu_maybe(struct nameidata *nd, struct dentry *dentry)
+{
+        if (nd->flags & LOOKUP_RCU)
+                return nameidata_dentry_drop_rcu(nd, dentry);
+        return 0;
+}
+
+/**
+ * nameidata_drop_rcu_last - drop nameidata ending path walk out of rcu-walk
+ * @nd: nameidata pathwalk data to drop
+ * @Returns: 0 on success, -ECHLID on failure
+ *
+ * nameidata_drop_rcu_last attempts to drop the current nd->path into ref-walk.
+ * nd->path should be the final element of the lookup, so nd->root is discarded.
+ * Must be called from rcu-walk context.
+ */
+static int nameidata_drop_rcu_last(struct nameidata *nd)
+{
+        struct dentry *dentry = nd->path.dentry;
+
+        BUG_ON(!(nd->flags & LOOKUP_RCU));
+        nd->flags &= ~LOOKUP_RCU;
+        nd->root.mnt = NULL;
+        spin_lock(&dentry->d_lock);
+        if (!__d_rcu_to_refcount(dentry, nd->seq))
+                goto err_unlock;
+        BUG_ON(nd->inode != dentry->d_inode);
+        spin_unlock(&dentry->d_lock);
+
+        mntget(nd->path.mnt);
+
+        rcu_read_unlock();
+        br_read_unlock(vfsmount_lock);
+
+        return 0;
+
+err_unlock:
+        spin_unlock(&dentry->d_lock);
+        rcu_read_unlock();
+        br_read_unlock(vfsmount_lock);
+        return -ECHILD;
+}
+
+/* Try to drop out of rcu-walk mode if we were in it, otherwise do nothing.  */
+static inline int nameidata_drop_rcu_last_maybe(struct nameidata *nd)
+{
+        if (likely(nd->flags & LOOKUP_RCU))
+                return nameidata_drop_rcu_last(nd);
+        return 0;
+}
+
+/**
  * release_open_intent - free up open intent resources
  * @nd: pointer to nameidata
  */
@@ -386,10 +583,26 @@ void release_open_intent(struct nameidata *nd)
                 fput(nd->intent.open.file);
 }
 
+static int d_revalidate(struct dentry *dentry, struct nameidata *nd)
+{
+        int status;
+
+        status = dentry->d_op->d_revalidate(dentry, nd);
+        if (status == -ECHILD) {
+                if (nameidata_dentry_drop_rcu(nd, dentry))
+                        return status;
+                status = dentry->d_op->d_revalidate(dentry, nd);
+        }
+
+        return status;
+}
+
 static inline struct dentry *
 do_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        int status = dentry->d_op->d_revalidate(dentry, nd);
+        int status;
+
+        status = d_revalidate(dentry, nd);
         if (unlikely(status <= 0)) {
                 /*
                  * The dentry failed validation.
@@ -397,19 +610,36 @@ do_revalidate(struct dentry *dentry, struct nameidata *nd)
                  * the dentry otherwise d_revalidate is asking us
                  * to return a fail status.
                  */
-                if (!status) {
+                if (status < 0) {
+                        /* If we're in rcu-walk, we don't have a ref */
+                        if (!(nd->flags & LOOKUP_RCU))
+                                dput(dentry);
+                        dentry = ERR_PTR(status);
+
+                } else {
+                        /* Don't d_invalidate in rcu-walk mode */
+                        if (nameidata_dentry_drop_rcu_maybe(nd, dentry))
+                                return ERR_PTR(-ECHILD);
                         if (!d_invalidate(dentry)) {
                                 dput(dentry);
                                 dentry = NULL;
                         }
-                } else {
-                        dput(dentry);
-                        dentry = ERR_PTR(status);
                 }
         }
         return dentry;
 }
 
+static inline int need_reval_dot(struct dentry *dentry)
+{
+        if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
+                return 0;
+
+        if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
+                return 0;
+
+        return 1;
+}
+
 /*
  * force_reval_path - force revalidation of a dentry
  *
@@ -433,13 +663,12 @@ force_reval_path(struct path *path, struct nameidata *nd)
 
         /*
          * only check on filesystems where it's possible for the dentry to
-         * become stale. It's assumed that if this flag is set then the
-         * d_revalidate op will also be defined.
+         * become stale.
          */
-        if (!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT))
+        if (!need_reval_dot(dentry))
                 return 0;
 
-        status = dentry->d_op->d_revalidate(dentry, nd);
+        status = d_revalidate(dentry, nd);
         if (status > 0)
                 return 0;
 
@@ -459,26 +688,27 @@ force_reval_path(struct path *path, struct nameidata *nd)
  * short-cut DAC fails, then call ->permission() to do more
  * complete permission check.
  */
-static int exec_permission(struct inode *inode)
+static inline int exec_permission(struct inode *inode, unsigned int flags)
 {
         int ret;
 
         if (inode->i_op->permission) {
-                ret = inode->i_op->permission(inode, MAY_EXEC);
-                if (!ret)
-                        goto ok;
-                return ret;
+                ret = inode->i_op->permission(inode, MAY_EXEC, flags);
+        } else {
+                ret = acl_permission_check(inode, MAY_EXEC, flags,
+                                inode->i_op->check_acl);
         }
-        ret = acl_permission_check(inode, MAY_EXEC, inode->i_op->check_acl);
-        if (!ret)
+        if (likely(!ret))
                 goto ok;
+        if (ret == -ECHILD)
+                return ret;
 
         if (capable(CAP_DAC_OVERRIDE) || capable(CAP_DAC_READ_SEARCH))
                 goto ok;
 
         return ret;
 ok:
-        return security_inode_permission(inode, MAY_EXEC);
+        return security_inode_exec_permission(inode, flags);
 }
 
 static __always_inline void set_root(struct nameidata *nd)
@@ -489,8 +719,23 @@ static __always_inline void set_root(struct nameidata *nd)
 
 static int link_path_walk(const char *, struct nameidata *);
 
+static __always_inline void set_root_rcu(struct nameidata *nd)
+{
+        if (!nd->root.mnt) {
+                struct fs_struct *fs = current->fs;
+                unsigned seq;
+
+                do {
+                        seq = read_seqcount_begin(&fs->seq);
+                        nd->root = fs->root;
+                } while (read_seqcount_retry(&fs->seq, seq));
+        }
+}
+
 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
 {
+        int ret;
+
         if (IS_ERR(link))
                 goto fail;
 
@@ -500,8 +745,10 @@ static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *l
                 nd->path = nd->root;
                 path_get(&nd->root);
         }
+        nd->inode = nd->path.dentry->d_inode;
 
-        return link_path_walk(link, nd);
+        ret = link_path_walk(link, nd);
+        return ret;
 fail:
         path_put(&nd->path);
         return PTR_ERR(link);
@@ -516,11 +763,12 @@ static void path_put_conditional(struct path *path, struct nameidata *nd)
 
 static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
 {
-        dput(nd->path.dentry);
-        if (nd->path.mnt != path->mnt) {
-                mntput(nd->path.mnt);
-                nd->path.mnt = path->mnt;
+        if (!(nd->flags & LOOKUP_RCU)) {
+                dput(nd->path.dentry);
+                if (nd->path.mnt != path->mnt)
+                        mntput(nd->path.mnt);
         }
+        nd->path.mnt = path->mnt;
         nd->path.dentry = path->dentry;
 }
 
@@ -535,9 +783,11 @@ __do_follow_link(struct path *path, struct nameidata *nd, void **p)
 
         if (path->mnt != nd->path.mnt) {
                 path_to_nameidata(path, nd);
+                nd->inode = nd->path.dentry->d_inode;
                 dget(dentry);
         }
         mntget(path->mnt);
+
         nd->last_type = LAST_BIND;
         *p = dentry->d_inode->i_op->follow_link(dentry, nd);
         error = PTR_ERR(*p);
@@ -591,6 +841,20 @@ loop:
         return err;
 }
 
+static int follow_up_rcu(struct path *path)
+{
+        struct vfsmount *parent;
+        struct dentry *mountpoint;
+
+        parent = path->mnt->mnt_parent;
+        if (parent == path->mnt)
+                return 0;
+        mountpoint = path->mnt->mnt_mountpoint;
+        path->dentry = mountpoint;
+        path->mnt = parent;
+        return 1;
+}
+
 int follow_up(struct path *path)
 {
         struct vfsmount *parent;
@@ -612,9 +876,24 @@ int follow_up(struct path *path)
         return 1;
 }
 
-/* no need for dcache_lock, as serialization is taken care in
- * namespace.c
+/*
+ * serialization is taken care of in namespace.c
  */
+static void __follow_mount_rcu(struct nameidata *nd, struct path *path,
+                                struct inode **inode)
+{
+        while (d_mountpoint(path->dentry)) {
+                struct vfsmount *mounted;
+                mounted = __lookup_mnt(path->mnt, path->dentry, 1);
+                if (!mounted)
+                        return;
+                path->mnt = mounted;
+                path->dentry = mounted->mnt_root;
+                nd->seq = read_seqcount_begin(&path->dentry->d_seq);
+                *inode = path->dentry->d_inode;
+        }
+}
+
 static int __follow_mount(struct path *path)
 {
         int res = 0;
@@ -645,9 +924,6 @@ static void follow_mount(struct path *path)
         }
 }
 
-/* no need for dcache_lock, as serialization is taken care in
- * namespace.c
- */
 int follow_down(struct path *path)
 {
         struct vfsmount *mounted;
@@ -663,7 +939,42 @@ int follow_down(struct path *path)
         return 0;
 }
 
-static __always_inline void follow_dotdot(struct nameidata *nd)
+static int follow_dotdot_rcu(struct nameidata *nd)
+{
+        struct inode *inode = nd->inode;
+
+        set_root_rcu(nd);
+
+        while(1) {
+                if (nd->path.dentry == nd->root.dentry &&
+                    nd->path.mnt == nd->root.mnt) {
+                        break;
+                }
+                if (nd->path.dentry != nd->path.mnt->mnt_root) {
+                        struct dentry *old = nd->path.dentry;
+                        struct dentry *parent = old->d_parent;
+                        unsigned seq;
+
+                        seq = read_seqcount_begin(&parent->d_seq);
+                        if (read_seqcount_retry(&old->d_seq, nd->seq))
+                                return -ECHILD;
+                        inode = parent->d_inode;
+                        nd->path.dentry = parent;
+                        nd->seq = seq;
+                        break;
+                }
+                if (!follow_up_rcu(&nd->path))
+                        break;
+                nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
+                inode = nd->path.dentry->d_inode;
+        }
+        __follow_mount_rcu(nd, &nd->path, &inode);
+        nd->inode = inode;
+
+        return 0;
+}
+
+static void follow_dotdot(struct nameidata *nd)
 {
         set_root(nd);
 
@@ -684,6 +995,7 @@ static __always_inline void follow_dotdot(struct nameidata *nd)
                         break;
         }
         follow_mount(&nd->path);
+        nd->inode = nd->path.dentry->d_inode;
 }
 
 /*
@@ -721,17 +1033,17 @@ static struct dentry *d_alloc_and_lookup(struct dentry *parent,
  *  It _is_ time-critical.
  */
 static int do_lookup(struct nameidata *nd, struct qstr *name,
-                     struct path *path)
+                        struct path *path, struct inode **inode)
 {
         struct vfsmount *mnt = nd->path.mnt;
-        struct dentry *dentry, *parent;
+        struct dentry *dentry, *parent = nd->path.dentry;
         struct inode *dir;
         /*
          * See if the low-level filesystem might want
          * to use its own hash..
          */
-        if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
-                int err = nd->path.dentry->d_op->d_hash(nd->path.dentry, name);
+        if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
+                int err = parent->d_op->d_hash(parent, nd->inode, name);
                 if (err < 0)
                         return err;
         }
@@ -741,21 +1053,44 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
          * of a false negative due to a concurrent rename, we're going to
          * do the non-racy lookup, below.
          */
-        dentry = __d_lookup(nd->path.dentry, name);
-        if (!dentry)
-                goto need_lookup;
+        if (nd->flags & LOOKUP_RCU) {
+                unsigned seq;
+
+                *inode = nd->inode;
+                dentry = __d_lookup_rcu(parent, name, &seq, inode);
+                if (!dentry) {
+                        if (nameidata_drop_rcu(nd))
+                                return -ECHILD;
+                        goto need_lookup;
+                }
+                /* Memory barrier in read_seqcount_begin of child is enough */
+                if (__read_seqcount_retry(&parent->d_seq, nd->seq))
+                        return -ECHILD;
+
+                nd->seq = seq;
+                if (dentry->d_flags & DCACHE_OP_REVALIDATE)
+                        goto need_revalidate;
+                path->mnt = mnt;
+                path->dentry = dentry;
+                __follow_mount_rcu(nd, path, inode);
+        } else {
+                dentry = __d_lookup(parent, name);
+                if (!dentry)
+                        goto need_lookup;
 found:
-        if (dentry->d_op && dentry->d_op->d_revalidate)
-                goto need_revalidate;
+                if (dentry->d_flags & DCACHE_OP_REVALIDATE)
+                        goto need_revalidate;
 done:
-        path->mnt = mnt;
-        path->dentry = dentry;
-        __follow_mount(path);
+                path->mnt = mnt;
+                path->dentry = dentry;
+                __follow_mount(path);
+                *inode = path->dentry->d_inode;
+        }
         return 0;
 
 need_lookup:
-        parent = nd->path.dentry;
         dir = parent->d_inode;
+        BUG_ON(nd->inode != dir);
 
         mutex_lock(&dir->i_mutex);
         /*
@@ -817,7 +1152,6 @@ static inline int follow_on_final(struct inode *inode, unsigned lookup_flags)
 static int link_path_walk(const char *name, struct nameidata *nd)
 {
         struct path next;
-        struct inode *inode;
         int err;
         unsigned int lookup_flags = nd->flags;
         
@@ -826,18 +1160,28 @@ static int link_path_walk(const char *name, struct nameidata *nd)
         if (!*name)
                 goto return_reval;
 
-        inode = nd->path.dentry->d_inode;
         if (nd->depth)
                 lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
 
         /* At this point we know we have a real path component. */
         for(;;) {
+                struct inode *inode;
                 unsigned long hash;
                 struct qstr this;
                 unsigned int c;
 
                 nd->flags |= LOOKUP_CONTINUE;
-                err = exec_permission(inode);
+                if (nd->flags & LOOKUP_RCU) {
+                        err = exec_permission(nd->inode, IPERM_FLAG_RCU);
+                        if (err == -ECHILD) {
+                                if (nameidata_drop_rcu(nd))
+                                        return -ECHILD;
+                                goto exec_again;
+                        }
+                } else {
+exec_again:
+                        err = exec_permission(nd->inode, 0);
+                }
                 if (err)
                         break;
 
@@ -868,37 +1212,44 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                 if (this.name[0] == '.') switch (this.len) {
                         default:
                                 break;
-                        case 2: 
+                        case 2:
                                 if (this.name[1] != '.')
                                         break;
-                                follow_dotdot(nd);
-                                inode = nd->path.dentry->d_inode;
+                                if (nd->flags & LOOKUP_RCU) {
+                                        if (follow_dotdot_rcu(nd))
+                                                return -ECHILD;
+                                } else
+                                        follow_dotdot(nd);
                                 /* fallthrough */
                         case 1:
                                 continue;
                 }
                 /* This does the actual lookups.. */
-                err = do_lookup(nd, &this, &next);
+                err = do_lookup(nd, &this, &next, &inode);
                 if (err)
                         break;
-
                 err = -ENOENT;
-                inode = next.dentry->d_inode;
                 if (!inode)
                         goto out_dput;
 
                 if (inode->i_op->follow_link) {
+                        /* We commonly drop rcu-walk here */
+                        if (nameidata_dentry_drop_rcu_maybe(nd, next.dentry))
+                                return -ECHILD;
+                        BUG_ON(inode != next.dentry->d_inode);
                         err = do_follow_link(&next, nd);
                         if (err)
                                 goto return_err;
+                        nd->inode = nd->path.dentry->d_inode;
                         err = -ENOENT;
-                        inode = nd->path.dentry->d_inode;
-                        if (!inode)
+                        if (!nd->inode)
                                 break;
-                } else
+                } else {
                         path_to_nameidata(&next, nd);
+                        nd->inode = inode;
+                }
                 err = -ENOTDIR; 
-                if (!inode->i_op->lookup)
+                if (!nd->inode->i_op->lookup)
                         break;
                 continue;
                 /* here ends the main loop */
@@ -913,32 +1264,39 @@ last_component:
                 if (this.name[0] == '.') switch (this.len) {
                         default:
                                 break;
-                        case 2: 
+                        case 2:
                                 if (this.name[1] != '.')
                                         break;
-                                follow_dotdot(nd);
-                                inode = nd->path.dentry->d_inode;
+                                if (nd->flags & LOOKUP_RCU) {
+                                        if (follow_dotdot_rcu(nd))
+                                                return -ECHILD;
+                                } else
+                                        follow_dotdot(nd);
                                 /* fallthrough */
                         case 1:
                                 goto return_reval;
                 }
-                err = do_lookup(nd, &this, &next);
+                err = do_lookup(nd, &this, &next, &inode);
                 if (err)
                         break;
-                inode = next.dentry->d_inode;
                 if (follow_on_final(inode, lookup_flags)) {
+                        if (nameidata_dentry_drop_rcu_maybe(nd, next.dentry))
+                                return -ECHILD;
+                        BUG_ON(inode != next.dentry->d_inode);
                         err = do_follow_link(&next, nd);
                         if (err)
                                 goto return_err;
-                        inode = nd->path.dentry->d_inode;
-                } else
+                        nd->inode = nd->path.dentry->d_inode;
+                } else {
                         path_to_nameidata(&next, nd);
+                        nd->inode = inode;
+                }
                 err = -ENOENT;
-                if (!inode)
+                if (!nd->inode)
                         break;
                 if (lookup_flags & LOOKUP_DIRECTORY) {
                         err = -ENOTDIR; 
-                        if (!inode->i_op->lookup)
+                        if (!nd->inode->i_op->lookup)
                                 break;
                 }
                 goto return_base;
@@ -958,25 +1316,43 @@ return_reval:
                  * We bypassed the ordinary revalidation routines.
                  * We may need to check the cached dentry for staleness.
                  */
-                if (nd->path.dentry && nd->path.dentry->d_sb &&
-                    (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
-                        err = -ESTALE;
+                if (need_reval_dot(nd->path.dentry)) {
                         /* Note: we do not d_invalidate() */
-                        if (!nd->path.dentry->d_op->d_revalidate(
-                                        nd->path.dentry, nd))
+                        err = d_revalidate(nd->path.dentry, nd);
+                        if (!err)
+                                err = -ESTALE;
+                        if (err < 0)
                                 break;
                 }
 return_base:
+                if (nameidata_drop_rcu_last_maybe(nd))
+                        return -ECHILD;
                 return 0;
 out_dput:
-                path_put_conditional(&next, nd);
+                if (!(nd->flags & LOOKUP_RCU))
+                        path_put_conditional(&next, nd);
                 break;
         }
-        path_put(&nd->path);
+        if (!(nd->flags & LOOKUP_RCU))
+                path_put(&nd->path);
 return_err:
         return err;
 }
 
+static inline int path_walk_rcu(const char *name, struct nameidata *nd)
+{
+        current->total_link_count = 0;
+
+        return link_path_walk(name, nd);
+}
+
+static inline int path_walk_simple(const char *name, struct nameidata *nd)
+{
+        current->total_link_count = 0;
+
+        return link_path_walk(name, nd);
+}
+
 static int path_walk(const char *name, struct nameidata *nd)
 {
         struct path save = nd->path;
@@ -1002,6 +1378,93 @@ static int path_walk(const char *name, struct nameidata *nd)
         return result;
 }
 
+static void path_finish_rcu(struct nameidata *nd)
+{
+        if (nd->flags & LOOKUP_RCU) {
+                /* RCU dangling. Cancel it. */
+                nd->flags &= ~LOOKUP_RCU;
+                nd->root.mnt = NULL;
+                rcu_read_unlock();
+                br_read_unlock(vfsmount_lock);
+        }
+        if (nd->file)
+                fput(nd->file);
+}
+
+static int path_init_rcu(int dfd, const char *name, unsigned int flags, struct nameidata *nd)
+{
+        int retval = 0;
+        int fput_needed;
+        struct file *file;
+
+        nd->last_type = LAST_ROOT; /* if there are only slashes... */
+        nd->flags = flags | LOOKUP_RCU;
+        nd->depth = 0;
+        nd->root.mnt = NULL;
+        nd->file = NULL;
+
+        if (*name=='/') {
+                struct fs_struct *fs = current->fs;
+                unsigned seq;
+
+                br_read_lock(vfsmount_lock);
+                rcu_read_lock();
+
+                do {
+                        seq = read_seqcount_begin(&fs->seq);
+                        nd->root = fs->root;
+                        nd->path = nd->root;
+                        nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
+                } while (read_seqcount_retry(&fs->seq, seq));
+
+        } else if (dfd == AT_FDCWD) {
+                struct fs_struct *fs = current->fs;
+                unsigned seq;
+
+                br_read_lock(vfsmount_lock);
+                rcu_read_lock();
+
+                do {
+                        seq = read_seqcount_begin(&fs->seq);
+                        nd->path = fs->pwd;
+                        nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
+                } while (read_seqcount_retry(&fs->seq, seq));
+
+        } else {
+                struct dentry *dentry;
+
+                file = fget_light(dfd, &fput_needed);
+                retval = -EBADF;
+                if (!file)
+                        goto out_fail;
+
+                dentry = file->f_path.dentry;
+
+                retval = -ENOTDIR;
+                if (!S_ISDIR(dentry->d_inode->i_mode))
+                        goto fput_fail;
+
+                retval = file_permission(file, MAY_EXEC);
+                if (retval)
+                        goto fput_fail;
+
+                nd->path = file->f_path;
+                if (fput_needed)
+                        nd->file = file;
+
+                nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
+                br_read_lock(vfsmount_lock);
+                rcu_read_lock();
+        }
+        nd->inode = nd->path.dentry->d_inode;
+        return 0;
+
+fput_fail:
+        fput_light(file, fput_needed);
+out_fail:
+        return retval;
+}
+
 static int path_init(int dfd, const char *name, unsigned int flags, struct nameidata *nd)
 {
         int retval = 0;
@@ -1042,6 +1505,7 @@ static int path_init(int dfd, const char *name, unsigned int flags, struct namei
 
                 fput_light(file, fput_needed);
         }
+        nd->inode = nd->path.dentry->d_inode;
         return 0;
 
 fput_fail:
@@ -1054,16 +1518,53 @@ out_fail:
 static int do_path_lookup(int dfd, const char *name,
                                 unsigned int flags, struct nameidata *nd)
 {
-        int retval = path_init(dfd, name, flags, nd);
-        if (!retval)
-                retval = path_walk(name, nd);
-        if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
-                                nd->path.dentry->d_inode))
-                audit_inode(name, nd->path.dentry);
+        int retval;
+
+        /*
+         * Path walking is largely split up into 2 different synchronisation
+         * schemes, rcu-walk and ref-walk (explained in
+         * Documentation/filesystems/path-lookup.txt). These share much of the
+         * path walk code, but some things particularly setup, cleanup, and
+         * following mounts are sufficiently divergent that functions are
+         * duplicated. Typically there is a function foo(), and its RCU
+         * analogue, foo_rcu().
+         *
+         * -ECHILD is the error number of choice (just to avoid clashes) that
+         * is returned if some aspect of an rcu-walk fails. Such an error must
+         * be handled by restarting a traditional ref-walk (which will always
+         * be able to complete).
+         */
+        retval = path_init_rcu(dfd, name, flags, nd);
+        if (unlikely(retval))
+                return retval;
+        retval = path_walk_rcu(name, nd);
+        path_finish_rcu(nd);
         if (nd->root.mnt) {
                 path_put(&nd->root);
                 nd->root.mnt = NULL;
         }
+
+        if (unlikely(retval == -ECHILD || retval == -ESTALE)) {
+                /* slower, locked walk */
+                if (retval == -ESTALE)
+                        flags |= LOOKUP_REVAL;
+                retval = path_init(dfd, name, flags, nd);
+                if (unlikely(retval))
+                        return retval;
+                retval = path_walk(name, nd);
+                if (nd->root.mnt) {
+                        path_put(&nd->root);
+                        nd->root.mnt = NULL;
+                }
+        }
+
+        if (likely(!retval)) {
+                if (unlikely(!audit_dummy_context())) {
+                        if (nd->path.dentry && nd->inode)
+                                audit_inode(name, nd->path.dentry);
+                }
+        }
+
         return retval;
 }
 
@@ -1106,10 +1607,11 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
         path_get(&nd->path);
         nd->root = nd->path;
         path_get(&nd->root);
+        nd->inode = nd->path.dentry->d_inode;
 
         retval = path_walk(name, nd);
         if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
-                                nd->path.dentry->d_inode))
+                                nd->inode))
                 audit_inode(name, nd->path.dentry);
 
         path_put(&nd->root);
@@ -1125,7 +1627,7 @@ static struct dentry *__lookup_hash(struct qstr *name,
         struct dentry *dentry;
         int err;
 
-        err = exec_permission(inode);
+        err = exec_permission(inode, 0);
         if (err)
                 return ERR_PTR(err);
 
@@ -1133,8 +1635,8 @@ static struct dentry *__lookup_hash(struct qstr *name,
          * See if the low-level filesystem might want
          * to use its own hash..
          */
-        if (base->d_op && base->d_op->d_hash) {
-                err = base->d_op->d_hash(base, name);
+        if (base->d_flags & DCACHE_OP_HASH) {
+                err = base->d_op->d_hash(base, inode, name);
                 dentry = ERR_PTR(err);
                 if (err < 0)
                         goto out;
@@ -1147,7 +1649,7 @@ static struct dentry *__lookup_hash(struct qstr *name,
          */
         dentry = d_lookup(base, name);
 
-        if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
+        if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE))
                 dentry = do_revalidate(dentry, nd);
 
         if (!dentry)
@@ -1490,6 +1992,7 @@ out_unlock:
         mutex_unlock(&dir->d_inode->i_mutex);
         dput(nd->path.dentry);
         nd->path.dentry = path->dentry;
+
         if (error)
                 return error;
         /* Don't check for write permission, don't truncate */
@@ -1584,6 +2087,9 @@ exit:
         return ERR_PTR(error);
 }
 
+/*
+ * Handle O_CREAT case for do_filp_open
+ */
 static struct file *do_last(struct nameidata *nd, struct path *path,
                             int open_flag, int acc_mode,
                             int mode, const char *pathname)
@@ -1597,50 +2103,25 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
                 follow_dotdot(nd);
                 dir = nd->path.dentry;
         case LAST_DOT:
-                if (nd->path.mnt->mnt_sb->s_type->fs_flags & FS_REVAL_DOT) {
-                        if (!dir->d_op->d_revalidate(dir, nd)) {
+                if (need_reval_dot(dir)) {
+                        error = d_revalidate(nd->path.dentry, nd);
+                        if (!error)
                                 error = -ESTALE;
+                        if (error < 0)
                                 goto exit;
-                        }
                 }
                 /* fallthrough */
         case LAST_ROOT:
-                if (open_flag & O_CREAT)
-                        goto exit;
-                /* fallthrough */
+                goto exit;
         case LAST_BIND:
                 audit_inode(pathname, dir);
                 goto ok;
         }
 
         /* trailing slashes? */
-        if (nd->last.name[nd->last.len]) {
-                if (open_flag & O_CREAT)
-                        goto exit;
-                nd->flags |= LOOKUP_DIRECTORY | LOOKUP_FOLLOW;
-        }
-
-        /* just plain open? */
-        if (!(open_flag & O_CREAT)) {
-                error = do_lookup(nd, &nd->last, path);
-                if (error)
-                        goto exit;
-                error = -ENOENT;
-                if (!path->dentry->d_inode)
-                        goto exit_dput;
-                if (path->dentry->d_inode->i_op->follow_link)
-                        return NULL;
-                error = -ENOTDIR;
-                if (nd->flags & LOOKUP_DIRECTORY) {
-                        if (!path->dentry->d_inode->i_op->lookup)
-                                goto exit_dput;
-                }
-                path_to_nameidata(path, nd);
-                audit_inode(pathname, nd->path.dentry);
-                goto ok;
-        }
+        if (nd->last.name[nd->last.len])
+                goto exit;
 
-        /* OK, it's O_CREAT */
         mutex_lock(&dir->d_inode->i_mutex);
 
         path->dentry = lookup_hash(nd);
@@ -1711,8 +2192,9 @@ static struct file *do_last(struct nameidata *nd, struct path *path,
                 return NULL;
 
         path_to_nameidata(path, nd);
+        nd->inode = path->dentry->d_inode;
         error = -EISDIR;
-        if (S_ISDIR(path->dentry->d_inode->i_mode))
+        if (S_ISDIR(nd->inode->i_mode))
                 goto exit;
 ok:
         filp = finish_open(nd, open_flag, acc_mode);
@@ -1743,7 +2225,7 @@ struct file *do_filp_open(int dfd, const char *pathname,
         struct path path;
         int count = 0;
         int flag = open_to_namei_flags(open_flag);
-        int force_reval = 0;
+        int flags;
 
         if (!(open_flag & O_CREAT))
                 mode = 0;
@@ -1772,54 +2254,84 @@ struct file *do_filp_open(int dfd, const char *pathname,
         if (open_flag & O_APPEND)
                 acc_mode |= MAY_APPEND;
 
-        /* find the parent */
-reval:
-        error = path_init(dfd, pathname, LOOKUP_PARENT, &nd);
+        flags = LOOKUP_OPEN;
+        if (open_flag & O_CREAT) {
+                flags |= LOOKUP_CREATE;
+                if (open_flag & O_EXCL)
+                        flags |= LOOKUP_EXCL;
+        }
+        if (open_flag & O_DIRECTORY)
+                flags |= LOOKUP_DIRECTORY;
+        if (!(open_flag & O_NOFOLLOW))
+                flags |= LOOKUP_FOLLOW;
+
+        filp = get_empty_filp();
+        if (!filp)
+                return ERR_PTR(-ENFILE);
+
+        filp->f_flags = open_flag;
+        nd.intent.open.file = filp;
+        nd.intent.open.flags = flag;
+        nd.intent.open.create_mode = mode;
+
+        if (open_flag & O_CREAT)
+                goto creat;
+
+        /* !O_CREAT, simple open */
+        error = do_path_lookup(dfd, pathname, flags, &nd);
+        if (unlikely(error))
+                goto out_filp;
+        error = -ELOOP;
+        if (!(nd.flags & LOOKUP_FOLLOW)) {
+                if (nd.inode->i_op->follow_link)
+                        goto out_path;
+        }
+        error = -ENOTDIR;
+        if (nd.flags & LOOKUP_DIRECTORY) {
+                if (!nd.inode->i_op->lookup)
+                        goto out_path;
+        }
+        audit_inode(pathname, nd.path.dentry);
+        filp = finish_open(&nd, open_flag, acc_mode);
+        return filp;
+
+creat:
+        /* OK, have to create the file. Find the parent. */
+        error = path_init_rcu(dfd, pathname,
+                        LOOKUP_PARENT | (flags & LOOKUP_REVAL), &nd);
         if (error)
-                return ERR_PTR(error);
-        if (force_reval)
-                nd.flags |= LOOKUP_REVAL;
+                goto out_filp;
+        error = path_walk_rcu(pathname, &nd);
+        path_finish_rcu(&nd);
+        if (unlikely(error == -ECHILD || error == -ESTALE)) {
+                /* slower, locked walk */
+                if (error == -ESTALE) {
+reval:
+                        flags |= LOOKUP_REVAL;
+                }
+                error = path_init(dfd, pathname,
+                                LOOKUP_PARENT | (flags & LOOKUP_REVAL), &nd);
+                if (error)
+                        goto out_filp;
 
-        current->total_link_count = 0;
-        error = link_path_walk(pathname, &nd);
-        if (error) {
-                filp = ERR_PTR(error);
-                goto out;
+                error = path_walk_simple(pathname, &nd);
         }
-        if (unlikely(!audit_dummy_context()) && (open_flag & O_CREAT))
+        if (unlikely(error))
+                goto out_filp;
+        if (unlikely(!audit_dummy_context()))
                 audit_inode(pathname, nd.path.dentry);
 
         /*
          * We have the parent and last component.
          */
-
-        error = -ENFILE;
-        filp = get_empty_filp();
-        if (filp == NULL)
-                goto exit_parent;
-        nd.intent.open.file = filp;
-        filp->f_flags = open_flag;
-        nd.intent.open.flags = flag;
-        nd.intent.open.create_mode = mode;
-        nd.flags &= ~LOOKUP_PARENT;
-        nd.flags |= LOOKUP_OPEN;
-        if (open_flag & O_CREAT) {
-                nd.flags |= LOOKUP_CREATE;
-                if (open_flag & O_EXCL)
-                        nd.flags |= LOOKUP_EXCL;
-        }
-        if (open_flag & O_DIRECTORY)
-                nd.flags |= LOOKUP_DIRECTORY;
-        if (!(open_flag & O_NOFOLLOW))
-                nd.flags |= LOOKUP_FOLLOW;
+        nd.flags = flags;
         filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
         while (unlikely(!filp)) { /* trailing symlink */
                 struct path holder;
-                struct inode *inode = path.dentry->d_inode;
                 void *cookie;
                 error = -ELOOP;
                 /* S_ISDIR part is a temporary automount kludge */
-                if (!(nd.flags & LOOKUP_FOLLOW) && !S_ISDIR(inode->i_mode))
+                if (!(nd.flags & LOOKUP_FOLLOW) && !S_ISDIR(nd.inode->i_mode))
                         goto exit_dput;
                 if (count++ == 32)
                         goto exit_dput;
@@ -1840,36 +2352,33 @@ reval:
                         goto exit_dput;
                 error = __do_follow_link(&path, &nd, &cookie);
                 if (unlikely(error)) {
+                        if (!IS_ERR(cookie) && nd.inode->i_op->put_link)
+                                nd.inode->i_op->put_link(path.dentry, &nd, cookie);
                         /* nd.path had been dropped */
-                        if (!IS_ERR(cookie) && inode->i_op->put_link)
-                                inode->i_op->put_link(path.dentry, &nd, cookie);
-                        path_put(&path);
-                        release_open_intent(&nd);
-                        filp = ERR_PTR(error);
-                        goto out;
+                        nd.path = path;
+                        goto out_path;
                 }
                 holder = path;
                 nd.flags &= ~LOOKUP_PARENT;
                 filp = do_last(&nd, &path, open_flag, acc_mode, mode, pathname);
-                if (inode->i_op->put_link)
-                        inode->i_op->put_link(holder.dentry, &nd, cookie);
+                if (nd.inode->i_op->put_link)
+                        nd.inode->i_op->put_link(holder.dentry, &nd, cookie);
                 path_put(&holder);
         }
 out:
         if (nd.root.mnt)
                 path_put(&nd.root);
-        if (filp == ERR_PTR(-ESTALE) && !force_reval) {
-                force_reval = 1;
+        if (filp == ERR_PTR(-ESTALE) && !(flags & LOOKUP_REVAL))
                 goto reval;
-        }
         return filp;
 
 exit_dput:
         path_put_conditional(&path, &nd);
+out_path:
+        path_put(&nd.path);
+out_filp:
         if (!IS_ERR(nd.intent.open.file))
                 release_open_intent(&nd);
-exit_parent:
-        path_put(&nd.path);
         filp = ERR_PTR(error);
         goto out;
 }
@@ -2130,12 +2639,10 @@ void dentry_unhash(struct dentry *dentry)
 {
         dget(dentry);
         shrink_dcache_parent(dentry);
-        spin_lock(&dcache_lock);
         spin_lock(&dentry->d_lock);
-        if (atomic_read(&dentry->d_count) == 2)
+        if (dentry->d_count == 2)
                 __d_drop(dentry);
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
 }
 
 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
diff --git a/fs/namespace.c b/fs/namespace.c
index 3dbfc072ec70..3ddfd9046c44 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -138,6 +138,64 @@ void mnt_release_group_id(struct vfsmount *mnt)
         mnt->mnt_group_id = 0;
 }
 
+/*
+ * vfsmount lock must be held for read
+ */
+static inline void mnt_add_count(struct vfsmount *mnt, int n)
+{
+#ifdef CONFIG_SMP
+        this_cpu_add(mnt->mnt_pcp->mnt_count, n);
+#else
+        preempt_disable();
+        mnt->mnt_count += n;
+        preempt_enable();
+#endif
+}
+
+static inline void mnt_set_count(struct vfsmount *mnt, int n)
+{
+#ifdef CONFIG_SMP
+        this_cpu_write(mnt->mnt_pcp->mnt_count, n);
+#else
+        mnt->mnt_count = n;
+#endif
+}
+
+/*
+ * vfsmount lock must be held for read
+ */
+static inline void mnt_inc_count(struct vfsmount *mnt)
+{
+        mnt_add_count(mnt, 1);
+}
+
+/*
+ * vfsmount lock must be held for read
+ */
+static inline void mnt_dec_count(struct vfsmount *mnt)
+{
+        mnt_add_count(mnt, -1);
+}
+
+/*
+ * vfsmount lock must be held for write
+ */
+unsigned int mnt_get_count(struct vfsmount *mnt)
+{
+#ifdef CONFIG_SMP
+        unsigned int count = atomic_read(&mnt->mnt_longrefs);
+        int cpu;
+
+        for_each_possible_cpu(cpu) {
+                count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count;
+        }
+
+        return count;
+#else
+        return mnt->mnt_count;
+#endif
+}
+
 struct vfsmount *alloc_vfsmnt(const char *name)
 {
         struct vfsmount *mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL);
@@ -154,7 +212,17 @@ struct vfsmount *alloc_vfsmnt(const char *name)
                                 goto out_free_id;
                 }
 
-                atomic_set(&mnt->mnt_count, 1);
+#ifdef CONFIG_SMP
+                mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
+                if (!mnt->mnt_pcp)
+                        goto out_free_devname;
+
+                atomic_set(&mnt->mnt_longrefs, 1);
+#else
+                mnt->mnt_count = 1;
+                mnt->mnt_writers = 0;
+#endif
+
                 INIT_LIST_HEAD(&mnt->mnt_hash);
                 INIT_LIST_HEAD(&mnt->mnt_child);
                 INIT_LIST_HEAD(&mnt->mnt_mounts);
@@ -166,13 +234,6 @@ struct vfsmount *alloc_vfsmnt(const char *name)
 #ifdef CONFIG_FSNOTIFY
                 INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks);
 #endif
-#ifdef CONFIG_SMP
-                mnt->mnt_writers = alloc_percpu(int);
-                if (!mnt->mnt_writers)
-                        goto out_free_devname;
-#else
-                mnt->mnt_writers = 0;
-#endif
         }
         return mnt;
 
@@ -216,32 +277,32 @@ int __mnt_is_readonly(struct vfsmount *mnt)
 }
 EXPORT_SYMBOL_GPL(__mnt_is_readonly);
 
-static inline void inc_mnt_writers(struct vfsmount *mnt)
+static inline void mnt_inc_writers(struct vfsmount *mnt)
 {
 #ifdef CONFIG_SMP
-        (*per_cpu_ptr(mnt->mnt_writers, smp_processor_id()))++;
+        this_cpu_inc(mnt->mnt_pcp->mnt_writers);
 #else
         mnt->mnt_writers++;
 #endif
 }
 
-static inline void dec_mnt_writers(struct vfsmount *mnt)
+static inline void mnt_dec_writers(struct vfsmount *mnt)
 {
 #ifdef CONFIG_SMP
-        (*per_cpu_ptr(mnt->mnt_writers, smp_processor_id()))--;
+        this_cpu_dec(mnt->mnt_pcp->mnt_writers);
 #else
         mnt->mnt_writers--;
 #endif
 }
 
-static unsigned int count_mnt_writers(struct vfsmount *mnt)
+static unsigned int mnt_get_writers(struct vfsmount *mnt)
 {
 #ifdef CONFIG_SMP
         unsigned int count = 0;
         int cpu;
 
         for_each_possible_cpu(cpu) {
-                count += *per_cpu_ptr(mnt->mnt_writers, cpu);
+                count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers;
         }
 
         return count;
@@ -273,9 +334,9 @@ int mnt_want_write(struct vfsmount *mnt)
         int ret = 0;
 
         preempt_disable();
-        inc_mnt_writers(mnt);
+        mnt_inc_writers(mnt);
         /*
-         * The store to inc_mnt_writers must be visible before we pass
+         * The store to mnt_inc_writers must be visible before we pass
          * MNT_WRITE_HOLD loop below, so that the slowpath can see our
          * incremented count after it has set MNT_WRITE_HOLD.
          */
@@ -289,7 +350,7 @@ int mnt_want_write(struct vfsmount *mnt)
          */
         smp_rmb();
         if (__mnt_is_readonly(mnt)) {
-                dec_mnt_writers(mnt);
+                mnt_dec_writers(mnt);
                 ret = -EROFS;
                 goto out;
         }
@@ -317,7 +378,7 @@ int mnt_clone_write(struct vfsmount *mnt)
         if (__mnt_is_readonly(mnt))
                 return -EROFS;
         preempt_disable();
-        inc_mnt_writers(mnt);
+        mnt_inc_writers(mnt);
         preempt_enable();
         return 0;
 }
@@ -351,7 +412,7 @@ EXPORT_SYMBOL_GPL(mnt_want_write_file);
 void mnt_drop_write(struct vfsmount *mnt)
 {
         preempt_disable();
-        dec_mnt_writers(mnt);
+        mnt_dec_writers(mnt);
         preempt_enable();
 }
 EXPORT_SYMBOL_GPL(mnt_drop_write);
@@ -384,7 +445,7 @@ static int mnt_make_readonly(struct vfsmount *mnt)
          * MNT_WRITE_HOLD, so it can't be decremented by another CPU while
          * we're counting up here.
          */
-        if (count_mnt_writers(mnt) > 0)
+        if (mnt_get_writers(mnt) > 0)
                 ret = -EBUSY;
         else
                 mnt->mnt_flags |= MNT_READONLY;
@@ -418,7 +479,7 @@ void free_vfsmnt(struct vfsmount *mnt)
         kfree(mnt->mnt_devname);
         mnt_free_id(mnt);
 #ifdef CONFIG_SMP
-        free_percpu(mnt->mnt_writers);
+        free_percpu(mnt->mnt_pcp);
 #endif
         kmem_cache_free(mnt_cache, mnt);
 }
@@ -492,6 +553,27 @@ static void __touch_mnt_namespace(struct mnt_namespace *ns)
 }
 
 /*
+ * Clear dentry's mounted state if it has no remaining mounts.
+ * vfsmount_lock must be held for write.
+ */
+static void dentry_reset_mounted(struct vfsmount *mnt, struct dentry *dentry)
+{
+        unsigned u;
+
+        for (u = 0; u < HASH_SIZE; u++) {
+                struct vfsmount *p;
+
+                list_for_each_entry(p, &mount_hashtable[u], mnt_hash) {
+                        if (p->mnt_mountpoint == dentry)
+                                return;
+                }
+        }
+        spin_lock(&dentry->d_lock);
+        dentry->d_flags &= ~DCACHE_MOUNTED;
+        spin_unlock(&dentry->d_lock);
+}
+
+/*
  * vfsmount lock must be held for write
  */
 static void detach_mnt(struct vfsmount *mnt, struct path *old_path)
@@ -502,7 +584,7 @@ static void detach_mnt(struct vfsmount *mnt, struct path *old_path)
         mnt->mnt_mountpoint = mnt->mnt_root;
         list_del_init(&mnt->mnt_child);
         list_del_init(&mnt->mnt_hash);
-        old_path->dentry->d_mounted--;
+        dentry_reset_mounted(old_path->mnt, old_path->dentry);
 }
 
 /*
@@ -513,7 +595,9 @@ void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
 {
         child_mnt->mnt_parent = mntget(mnt);
         child_mnt->mnt_mountpoint = dget(dentry);
-        dentry->d_mounted++;
+        spin_lock(&dentry->d_lock);
+        dentry->d_flags |= DCACHE_MOUNTED;
+        spin_unlock(&dentry->d_lock);
 }
 
 /*
@@ -629,9 +713,10 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
         return NULL;
 }
 
-static inline void __mntput(struct vfsmount *mnt)
+static inline void mntfree(struct vfsmount *mnt)
 {
         struct super_block *sb = mnt->mnt_sb;
+
         /*
          * This probably indicates that somebody messed
          * up a mnt_want/drop_write() pair.  If this
@@ -639,38 +724,123 @@ static inline void __mntput(struct vfsmount *mnt)
          * to make r/w->r/o transitions.
          */
         /*
-         * atomic_dec_and_lock() used to deal with ->mnt_count decrements
-         * provides barriers, so count_mnt_writers() below is safe.  AV
+         * The locking used to deal with mnt_count decrement provides barriers,
+         * so mnt_get_writers() below is safe.
          */
-        WARN_ON(count_mnt_writers(mnt));
+        WARN_ON(mnt_get_writers(mnt));
         fsnotify_vfsmount_delete(mnt);
         dput(mnt->mnt_root);
         free_vfsmnt(mnt);
         deactivate_super(sb);
 }
 
-void mntput_no_expire(struct vfsmount *mnt)
-{
-repeat:
-        if (atomic_add_unless(&mnt->mnt_count, -1, 1))
-                return;
+#ifdef CONFIG_SMP
+static inline void __mntput(struct vfsmount *mnt, int longrefs)
+{
+        if (!longrefs) {
+put_again:
+                br_read_lock(vfsmount_lock);
+                if (likely(atomic_read(&mnt->mnt_longrefs))) {
+                        mnt_dec_count(mnt);
+                        br_read_unlock(vfsmount_lock);
+                        return;
+                }
+                br_read_unlock(vfsmount_lock);
+        } else {
+                BUG_ON(!atomic_read(&mnt->mnt_longrefs));
+                if (atomic_add_unless(&mnt->mnt_longrefs, -1, 1))
+                        return;
+        }
+
         br_write_lock(vfsmount_lock);
-        if (!atomic_dec_and_test(&mnt->mnt_count)) {
+        if (!longrefs)
+                mnt_dec_count(mnt);
+        else
+                atomic_dec(&mnt->mnt_longrefs);
+        if (mnt_get_count(mnt)) {
                 br_write_unlock(vfsmount_lock);
                 return;
         }
-        if (likely(!mnt->mnt_pinned)) {
+        if (unlikely(mnt->mnt_pinned)) {
+                mnt_add_count(mnt, mnt->mnt_pinned + 1);
+                mnt->mnt_pinned = 0;
                 br_write_unlock(vfsmount_lock);
-                __mntput(mnt);
+                acct_auto_close_mnt(mnt);
+                goto put_again;
+        }
+        br_write_unlock(vfsmount_lock);
+        mntfree(mnt);
+}
+#else
+static inline void __mntput(struct vfsmount *mnt, int longrefs)
+{
+put_again:
+        mnt_dec_count(mnt);
+        if (likely(mnt_get_count(mnt)))
                 return;
+        br_write_lock(vfsmount_lock);
+        if (unlikely(mnt->mnt_pinned)) {
+                mnt_add_count(mnt, mnt->mnt_pinned + 1);
+                mnt->mnt_pinned = 0;
+                br_write_unlock(vfsmount_lock);
+                acct_auto_close_mnt(mnt);
+                goto put_again;
         }
-        atomic_add(mnt->mnt_pinned + 1, &mnt->mnt_count);
-        mnt->mnt_pinned = 0;
         br_write_unlock(vfsmount_lock);
-        acct_auto_close_mnt(mnt);
-        goto repeat;
+        mntfree(mnt);
+}
+#endif
+
+static void mntput_no_expire(struct vfsmount *mnt)
+{
+        __mntput(mnt, 0);
+}
+
+void mntput(struct vfsmount *mnt)
+{
+        if (mnt) {
+                /* avoid cacheline pingpong, hope gcc doesn't get "smart" */
+                if (unlikely(mnt->mnt_expiry_mark))
+                        mnt->mnt_expiry_mark = 0;
+                __mntput(mnt, 0);
+        }
+}
+EXPORT_SYMBOL(mntput);
+
+struct vfsmount *mntget(struct vfsmount *mnt)
+{
+        if (mnt)
+                mnt_inc_count(mnt);
+        return mnt;
 }
-EXPORT_SYMBOL(mntput_no_expire);
+EXPORT_SYMBOL(mntget);
+
+void mntput_long(struct vfsmount *mnt)
+{
+#ifdef CONFIG_SMP
+        if (mnt) {
+                /* avoid cacheline pingpong, hope gcc doesn't get "smart" */
+                if (unlikely(mnt->mnt_expiry_mark))
+                        mnt->mnt_expiry_mark = 0;
+                __mntput(mnt, 1);
+        }
+#else
+        mntput(mnt);
+#endif
+}
+EXPORT_SYMBOL(mntput_long);
+
+struct vfsmount *mntget_long(struct vfsmount *mnt)
+{
+#ifdef CONFIG_SMP
+        if (mnt)
+                atomic_inc(&mnt->mnt_longrefs);
+        return mnt;
+#else
+        return mntget(mnt);
+#endif
+}
+EXPORT_SYMBOL(mntget_long);
 
 void mnt_pin(struct vfsmount *mnt)
 {
@@ -678,19 +848,17 @@ void mnt_pin(struct vfsmount *mnt)
         mnt->mnt_pinned++;
         br_write_unlock(vfsmount_lock);
 }
-
 EXPORT_SYMBOL(mnt_pin);
 
 void mnt_unpin(struct vfsmount *mnt)
 {
         br_write_lock(vfsmount_lock);
         if (mnt->mnt_pinned) {
-                atomic_inc(&mnt->mnt_count);
+                mnt_inc_count(mnt);
                 mnt->mnt_pinned--;
         }
         br_write_unlock(vfsmount_lock);
 }
-
 EXPORT_SYMBOL(mnt_unpin);
 
 static inline void mangle(struct seq_file *m, const char *s)
@@ -985,12 +1153,13 @@ int may_umount_tree(struct vfsmount *mnt)
         int minimum_refs = 0;
         struct vfsmount *p;
 
-        br_read_lock(vfsmount_lock);
+        /* write lock needed for mnt_get_count */
+        br_write_lock(vfsmount_lock);
         for (p = mnt; p; p = next_mnt(p, mnt)) {
-                actual_refs += atomic_read(&p->mnt_count);
+                actual_refs += mnt_get_count(p);
                 minimum_refs += 2;
         }
-        br_read_unlock(vfsmount_lock);
+        br_write_unlock(vfsmount_lock);
 
         if (actual_refs > minimum_refs)
                 return 0;
@@ -1017,10 +1186,10 @@ int may_umount(struct vfsmount *mnt)
 {
         int ret = 1;
         down_read(&namespace_sem);
-        br_read_lock(vfsmount_lock);
+        br_write_lock(vfsmount_lock);
         if (propagate_mount_busy(mnt, 2))
                 ret = 0;
-        br_read_unlock(vfsmount_lock);
+        br_write_unlock(vfsmount_lock);
         up_read(&namespace_sem);
         return ret;
 }
@@ -1047,7 +1216,7 @@ void release_mounts(struct list_head *head)
                         dput(dentry);
                         mntput(m);
                 }
-                mntput(mnt);
+                mntput_long(mnt);
         }
 }
 
@@ -1073,7 +1242,7 @@ void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
                 list_del_init(&p->mnt_child);
                 if (p->mnt_parent != p) {
                         p->mnt_parent->mnt_ghosts++;
-                        p->mnt_mountpoint->d_mounted--;
+                        dentry_reset_mounted(p->mnt_parent, p->mnt_mountpoint);
                 }
                 change_mnt_propagation(p, MS_PRIVATE);
         }
@@ -1102,8 +1271,16 @@ static int do_umount(struct vfsmount *mnt, int flags)
                     flags & (MNT_FORCE | MNT_DETACH))
                         return -EINVAL;
 
-                if (atomic_read(&mnt->mnt_count) != 2)
+                /*
+                 * probably don't strictly need the lock here if we examined
+                 * all race cases, but it's a slowpath.
+                 */
+                br_write_lock(vfsmount_lock);
+                if (mnt_get_count(mnt) != 2) {
+                        br_write_lock(vfsmount_lock);
                         return -EBUSY;
+                }
+                br_write_unlock(vfsmount_lock);
 
                 if (!xchg(&mnt->mnt_expiry_mark, 1))
                         return -EAGAIN;
@@ -1792,7 +1969,7 @@ int do_add_mount(struct vfsmount *newmnt, struct path *path,
 
 unlock:
         up_write(&namespace_sem);
-        mntput(newmnt);
+        mntput_long(newmnt);
         return err;
 }
 
@@ -2125,11 +2302,11 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
                 if (fs) {
                         if (p == fs->root.mnt) {
                                 rootmnt = p;
-                                fs->root.mnt = mntget(q);
+                                fs->root.mnt = mntget_long(q);
                         }
                         if (p == fs->pwd.mnt) {
                                 pwdmnt = p;
-                                fs->pwd.mnt = mntget(q);
+                                fs->pwd.mnt = mntget_long(q);
                         }
                 }
                 p = next_mnt(p, mnt_ns->root);
@@ -2138,9 +2315,9 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
         up_write(&namespace_sem);
 
         if (rootmnt)
-                mntput(rootmnt);
+                mntput_long(rootmnt);
         if (pwdmnt)
-                mntput(pwdmnt);
+                mntput_long(pwdmnt);
 
         return new_ns;
 }
@@ -2327,6 +2504,7 @@ SYSCALL_DEFINE2(pivot_root, const char __user *, new_root,
         touch_mnt_namespace(current->nsproxy->mnt_ns);
         br_write_unlock(vfsmount_lock);
         chroot_fs_refs(&root, &new);
+
         error = 0;
         path_put(&root_parent);
         path_put(&parent_path);
@@ -2353,6 +2531,7 @@ static void __init init_mount_tree(void)
         mnt = do_kern_mount("rootfs", 0, "rootfs", NULL);
         if (IS_ERR(mnt))
                 panic("Can't create rootfs");
+
         ns = create_mnt_ns(mnt);
         if (IS_ERR(ns))
                 panic("Can't allocate initial namespace");
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index f22b12e7d337..28f136d4aaec 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -17,6 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/vmalloc.h>
 #include <linux/mm.h>
+#include <linux/namei.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 
@@ -74,9 +75,12 @@ const struct inode_operations ncp_dir_inode_operations =
  * Dentry operations routines
  */
 static int ncp_lookup_validate(struct dentry *, struct nameidata *);
-static int ncp_hash_dentry(struct dentry *, struct qstr *);
-static int ncp_compare_dentry (struct dentry *, struct qstr *, struct qstr *);
-static int ncp_delete_dentry(struct dentry *);
+static int ncp_hash_dentry(const struct dentry *, const struct inode *,
+                struct qstr *);
+static int ncp_compare_dentry(const struct dentry *, const struct inode *,
+                const struct dentry *, const struct inode *,
+                unsigned int, const char *, const struct qstr *);
+static int ncp_delete_dentry(const struct dentry *);
 
 static const struct dentry_operations ncp_dentry_operations =
 {
@@ -113,10 +117,10 @@ static inline int ncp_preserve_entry_case(struct inode *i, __u32 nscreator)
 
 #define ncp_preserve_case(i)    (ncp_namespace(i) != NW_NS_DOS)
 
-static inline int ncp_case_sensitive(struct dentry *dentry)
+static inline int ncp_case_sensitive(const struct inode *i)
 {
 #ifdef CONFIG_NCPFS_NFS_NS
-        return ncp_namespace(dentry->d_inode) == NW_NS_NFS;
+        return ncp_namespace(i) == NW_NS_NFS;
 #else
         return 0;
 #endif /* CONFIG_NCPFS_NFS_NS */
@@ -127,14 +131,16 @@ static inline int ncp_case_sensitive(struct dentry *dentry)
  * is case-sensitive.
  */
 static int 
-ncp_hash_dentry(struct dentry *dentry, struct qstr *this)
+ncp_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *this)
 {
-        if (!ncp_case_sensitive(dentry)) {
+        if (!ncp_case_sensitive(inode)) {
+                struct super_block *sb = dentry->d_sb;
                 struct nls_table *t;
                 unsigned long hash;
                 int i;
 
-                t = NCP_IO_TABLE(dentry);
+                t = NCP_IO_TABLE(sb);
                 hash = init_name_hash();
                 for (i=0; i<this->len ; i++)
                         hash = partial_name_hash(ncp_tolower(t, this->name[i]),
@@ -145,15 +151,17 @@ ncp_hash_dentry(struct dentry *dentry, struct qstr *this)
 }
 
 static int
-ncp_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
+ncp_compare_dentry(const struct dentry *parent, const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        if (a->len != b->len)
+        if (len != name->len)
                 return 1;
 
-        if (ncp_case_sensitive(dentry))
-                return strncmp(a->name, b->name, a->len);
+        if (ncp_case_sensitive(pinode))
+                return strncmp(str, name->name, len);
 
-        return ncp_strnicmp(NCP_IO_TABLE(dentry), a->name, b->name, a->len);
+        return ncp_strnicmp(NCP_IO_TABLE(pinode->i_sb), str, name->name, len);
 }
 
 /*
@@ -162,7 +170,7 @@ ncp_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
  * Closing files can be safely postponed until iput() - it's done there anyway.
  */
 static int
-ncp_delete_dentry(struct dentry * dentry)
+ncp_delete_dentry(const struct dentry * dentry)
 {
         struct inode *inode = dentry->d_inode;
 
@@ -301,6 +309,9 @@ ncp_lookup_validate(struct dentry *dentry, struct nameidata *nd)
         int res, val = 0, len;
         __u8 __name[NCP_MAXPATHLEN + 1];
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
         parent = dget_parent(dentry);
         dir = parent->d_inode;
 
@@ -384,21 +395,21 @@ ncp_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
         }
 
         /* If a pointer is invalid, we search the dentry. */
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
                 dent = list_entry(next, struct dentry, d_u.d_child);
                 if ((unsigned long)dent->d_fsdata == fpos) {
                         if (dent->d_inode)
-                                dget_locked(dent);
+                                dget(dent);
                         else
                                 dent = NULL;
-                        spin_unlock(&dcache_lock);
+                        spin_unlock(&parent->d_lock);
                         goto out;
                 }
                 next = next->next;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
         return NULL;
 
 out:
@@ -592,7 +603,7 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
         qname.hash = full_name_hash(qname.name, qname.len);
 
         if (dentry->d_op && dentry->d_op->d_hash)
-                if (dentry->d_op->d_hash(dentry, &qname) != 0)
+                if (dentry->d_op->d_hash(dentry, dentry->d_inode, &qname) != 0)
                         goto end_advance;
 
         newdent = d_lookup(dentry, &qname);
@@ -611,35 +622,12 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                         shrink_dcache_parent(newdent);
 
                 /*
-                 * It is not as dangerous as it looks.  NetWare's OS2 namespace is
-                 * case preserving yet case insensitive.  So we update dentry's name
-                 * as received from server.  We found dentry via d_lookup with our
-                 * hash, so we know that hash does not change, and so replacing name
-                 * should be reasonably safe.
+                 * NetWare's OS2 namespace is case preserving yet case
+                 * insensitive.  So we update dentry's name as received from
+                 * server. Parent dir's i_mutex is locked because we're in
+                 * readdir.
                  */
-                if (qname.len == newdent->d_name.len &&
-                    memcmp(newdent->d_name.name, qname.name, newdent->d_name.len)) {
-                        struct inode *inode = newdent->d_inode;
-
-                        /*
-                         * Inside ncpfs all uses of d_name are either for debugging,
-                         * or on functions which acquire inode mutex (mknod, creat,
-                         * lookup).  So grab i_mutex here, to be sure.  d_path
-                         * uses dcache_lock when generating path, so we should too.
-                         * And finally d_compare is protected by dentry's d_lock, so
-                         * here we go.
-                         */
-                        if (inode)
-                                mutex_lock(&inode->i_mutex);
-                        spin_lock(&dcache_lock);
-                        spin_lock(&newdent->d_lock);
-                        memcpy((char *) newdent->d_name.name, qname.name,
-                                                                newdent->d_name.len);
-                        spin_unlock(&newdent->d_lock);
-                        spin_unlock(&dcache_lock);
-                        if (inode)
-                                mutex_unlock(&inode->i_mutex);
-                }
+                dentry_update_name_case(newdent, &qname);
         }
 
         if (!newdent->d_inode) {
@@ -649,7 +637,7 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                 entry->ino = iunique(dir->i_sb, 2);
                 inode = ncp_iget(dir->i_sb, entry);
                 if (inode) {
-                        newdent->d_op = &ncp_dentry_operations;
+                        d_set_d_op(newdent, &ncp_dentry_operations);
                         d_instantiate(newdent, inode);
                         if (!hashed)
                                 d_rehash(newdent);
@@ -657,7 +645,7 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
         } else {
                 struct inode *inode = newdent->d_inode;
 
-                mutex_lock(&inode->i_mutex);
+                mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
                 ncp_update_inode2(inode, entry);
                 mutex_unlock(&inode->i_mutex);
         }
@@ -905,7 +893,7 @@ static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, struc
         if (inode) {
                 ncp_new_dentry(dentry);
 add_entry:
-                dentry->d_op = &ncp_dentry_operations;
+                d_set_d_op(dentry, &ncp_dentry_operations);
                 d_add(dentry, inode);
                 error = 0;
         }
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 8fb93b604e73..9531c052d7a4 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -29,6 +29,7 @@
 #include <linux/vfs.h>
 #include <linux/mount.h>
 #include <linux/seq_file.h>
+#include <linux/namei.h>
 
 #include <linux/ncp_fs.h>
 
@@ -58,11 +59,18 @@ static struct inode *ncp_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void ncp_destroy_inode(struct inode *inode)
+static void ncp_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
 }
 
+static void ncp_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, ncp_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
@@ -710,7 +718,7 @@ static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
         sb->s_root = d_alloc_root(root_inode);
         if (!sb->s_root)
                 goto out_no_root;
-        sb->s_root->d_op = &ncp_root_dentry_operations;
+        d_set_d_op(sb->s_root, &ncp_root_dentry_operations);
         return 0;
 
 out_no_root:
diff --git a/fs/ncpfs/ncplib_kernel.h b/fs/ncpfs/ncplib_kernel.h
index 3c57eca634ce..1220df75ff22 100644
--- a/fs/ncpfs/ncplib_kernel.h
+++ b/fs/ncpfs/ncplib_kernel.h
@@ -135,7 +135,7 @@ int ncp__vol2io(struct ncp_server *, unsigned char *, unsigned int *,
                                 const unsigned char *, unsigned int, int);
 
 #define NCP_ESC                 ':'
-#define NCP_IO_TABLE(dentry)    (NCP_SERVER((dentry)->d_inode)->nls_io)
+#define NCP_IO_TABLE(sb)        (NCP_SBP(sb)->nls_io)
 #define ncp_tolower(t, c)       nls_tolower(t, c)
 #define ncp_toupper(t, c)       nls_toupper(t, c)
 #define ncp_strnicmp(t, s1, s2, len) \
@@ -150,15 +150,15 @@ int ncp__io2vol(unsigned char *, unsigned int *,
 int ncp__vol2io(unsigned char *, unsigned int *,
                                 const unsigned char *, unsigned int, int);
 
-#define NCP_IO_TABLE(dentry)    NULL
+#define NCP_IO_TABLE(sb)        NULL
 #define ncp_tolower(t, c)       tolower(c)
 #define ncp_toupper(t, c)       toupper(c)
 #define ncp_io2vol(S,m,i,n,k,U) ncp__io2vol(m,i,n,k,U)
 #define ncp_vol2io(S,m,i,n,k,U) ncp__vol2io(m,i,n,k,U)
 
 
-static inline int ncp_strnicmp(struct nls_table *t, const unsigned char *s1,
-                const unsigned char *s2, int len)
+static inline int ncp_strnicmp(const struct nls_table *t,
+                const unsigned char *s1, const unsigned char *s2, int len)
 {
         while (len--) {
                 if (tolower(*s1++) != tolower(*s2++))
@@ -193,7 +193,7 @@ ncp_renew_dentries(struct dentry *parent)
         struct list_head *next;
         struct dentry *dentry;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
                 dentry = list_entry(next, struct dentry, d_u.d_child);
@@ -205,7 +205,7 @@ ncp_renew_dentries(struct dentry *parent)
 
                 next = next->next;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
 }
 
 static inline void
@@ -215,7 +215,7 @@ ncp_invalidate_dircache_entries(struct dentry *parent)
         struct list_head *next;
         struct dentry *dentry;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&parent->d_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
                 dentry = list_entry(next, struct dentry, d_u.d_child);
@@ -223,7 +223,7 @@ ncp_invalidate_dircache_entries(struct dentry *parent)
                 ncp_age_dentry(server, dentry);
                 next = next->next;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&parent->d_lock);
 }
 
 struct ncp_cache_head {
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 996dd8989a91..d33da530097a 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -438,7 +438,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
         if (dentry == NULL)
                 return;
 
-        dentry->d_op = NFS_PROTO(dir)->dentry_ops;
+        d_set_d_op(dentry, NFS_PROTO(dir)->dentry_ops);
         inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
         if (IS_ERR(inode))
                 goto out;
@@ -938,7 +938,8 @@ static int nfs_check_verifier(struct inode *dir, struct dentry *dentry)
  * component of the path.
  * We check for this using LOOKUP_CONTINUE and LOOKUP_PARENT.
  */
-static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd, unsigned int mask)
+static inline unsigned int nfs_lookup_check_intent(struct nameidata *nd,
+                                                unsigned int mask)
 {
         if (nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))
                 return 0;
@@ -1018,7 +1019,7 @@ int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry,
  * If the parent directory is seen to have changed, we throw out the
  * cached dentry and do a new lookup.
  */
-static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
+static int nfs_lookup_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
         struct inode *dir;
         struct inode *inode;
@@ -1027,6 +1028,9 @@ static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
         struct nfs_fattr *fattr = NULL;
         int error;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
         parent = dget_parent(dentry);
         dir = parent->d_inode;
         nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE);
@@ -1117,7 +1121,7 @@ out_error:
 /*
  * This is called from dput() when d_count is going to 0.
  */
-static int nfs_dentry_delete(struct dentry *dentry)
+static int nfs_dentry_delete(const struct dentry *dentry)
 {
         dfprintk(VFS, "NFS: dentry_delete(%s/%s, %x)\n",
                 dentry->d_parent->d_name.name, dentry->d_name.name,
@@ -1188,7 +1192,7 @@ static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, stru
         if (dentry->d_name.len > NFS_SERVER(dir)->namelen)
                 goto out;
 
-        dentry->d_op = NFS_PROTO(dir)->dentry_ops;
+        d_set_d_op(dentry, NFS_PROTO(dir)->dentry_ops);
 
         /*
          * If we're doing an exclusive create, optimize away the lookup
@@ -1333,7 +1337,7 @@ static struct dentry *nfs_atomic_lookup(struct inode *dir, struct dentry *dentry
                 res = ERR_PTR(-ENAMETOOLONG);
                 goto out;
         }
-        dentry->d_op = NFS_PROTO(dir)->dentry_ops;
+        d_set_d_op(dentry, NFS_PROTO(dir)->dentry_ops);
 
         /* Let vfs_create() deal with O_EXCL. Instantiate, but don't hash
          * the dentry. */
@@ -1718,11 +1722,9 @@ static int nfs_unlink(struct inode *dir, struct dentry *dentry)
         dfprintk(VFS, "NFS: unlink(%s/%ld, %s)\n", dir->i_sb->s_id,
                 dir->i_ino, dentry->d_name.name);
 
-        spin_lock(&dcache_lock);
         spin_lock(&dentry->d_lock);
-        if (atomic_read(&dentry->d_count) > 1) {
+        if (dentry->d_count > 1) {
                 spin_unlock(&dentry->d_lock);
-                spin_unlock(&dcache_lock);
                 /* Start asynchronous writeout of the inode */
                 write_inode_now(dentry->d_inode, 0);
                 error = nfs_sillyrename(dir, dentry);
@@ -1733,7 +1735,6 @@ static int nfs_unlink(struct inode *dir, struct dentry *dentry)
                 need_rehash = 1;
         }
         spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
         error = nfs_safe_remove(dentry);
         if (!error || error == -ENOENT) {
                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
@@ -1868,7 +1869,7 @@ static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         dfprintk(VFS, "NFS: rename(%s/%s -> %s/%s, ct=%d)\n",
                  old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
                  new_dentry->d_parent->d_name.name, new_dentry->d_name.name,
-                 atomic_read(&new_dentry->d_count));
+                 new_dentry->d_count);
 
         /*
          * For non-directories, check whether the target is busy and if so,
@@ -1886,7 +1887,7 @@ static int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         rehash = new_dentry;
                 }
 
-                if (atomic_read(&new_dentry->d_count) > 2) {
+                if (new_dentry->d_count > 2) {
                         int err;
 
                         /* copy the target dentry's name */
@@ -2188,11 +2189,14 @@ int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags)
         return nfs_do_access(inode, cred, nfs_open_permission_mask(openflags));
 }
 
-int nfs_permission(struct inode *inode, int mask)
+int nfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
         struct rpc_cred *cred;
         int res = 0;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         nfs_inc_stats(inode, NFSIOS_VFSACCESS);
 
         if ((mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
@@ -2240,7 +2244,7 @@ out:
 out_notsup:
         res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
         if (res == 0)
-                res = generic_permission(inode, mask, NULL);
+                res = generic_permission(inode, mask, flags, NULL);
         goto out;
 }
 
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index ac7b814ce162..5596c6a2881e 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -63,9 +63,11 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
                  * This again causes shrink_dcache_for_umount_subtree() to
                  * Oops, since the test for IS_ROOT() will fail.
                  */
-                spin_lock(&dcache_lock);
+                spin_lock(&sb->s_root->d_inode->i_lock);
+                spin_lock(&sb->s_root->d_lock);
                 list_del_init(&sb->s_root->d_alias);
-                spin_unlock(&dcache_lock);
+                spin_unlock(&sb->s_root->d_lock);
+                spin_unlock(&sb->s_root->d_inode->i_lock);
         }
         return 0;
 }
@@ -119,7 +121,7 @@ struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh)
         security_d_instantiate(ret, inode);
 
         if (ret->d_op == NULL)
-                ret->d_op = server->nfs_client->rpc_ops->dentry_ops;
+                d_set_d_op(ret, server->nfs_client->rpc_ops->dentry_ops);
 out:
         nfs_free_fattr(fsinfo.fattr);
         return ret;
@@ -226,7 +228,7 @@ struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh)
         security_d_instantiate(ret, inode);
 
         if (ret->d_op == NULL)
-                ret->d_op = server->nfs_client->rpc_ops->dentry_ops;
+                d_set_d_op(ret, server->nfs_client->rpc_ops->dentry_ops);
 
 out:
         nfs_free_fattr(fattr);
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index e67e31c73416..017daa3bed38 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1438,11 +1438,18 @@ struct inode *nfs_alloc_inode(struct super_block *sb)
         return &nfsi->vfs_inode;
 }
 
-void nfs_destroy_inode(struct inode *inode)
+static void nfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
 }
 
+void nfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, nfs_i_callback);
+}
+
 static inline void nfs4_init_once(struct nfs_inode *nfsi)
 {
 #ifdef CONFIG_NFS_V4
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index db6aa3673cf3..74aaf3963c10 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -49,12 +49,17 @@ char *nfs_path(const char *base,
                const struct dentry *dentry,
                char *buffer, ssize_t buflen)
 {
-        char *end = buffer+buflen;
+        char *end;
         int namelen;
+        unsigned seq;
 
+rename_retry:
+        end = buffer+buflen;
         *--end = '\0';
         buflen--;
-        spin_lock(&dcache_lock);
+
+        seq = read_seqbegin(&rename_lock);
+        rcu_read_lock();
         while (!IS_ROOT(dentry) && dentry != droot) {
                 namelen = dentry->d_name.len;
                 buflen -= namelen + 1;
@@ -65,7 +70,9 @@ char *nfs_path(const char *base,
                 *--end = '/';
                 dentry = dentry->d_parent;
         }
-        spin_unlock(&dcache_lock);
+        rcu_read_unlock();
+        if (read_seqretry(&rename_lock, seq))
+                goto rename_retry;
         if (*end != '/') {
                 if (--buflen < 0)
                         goto Elong;
@@ -82,7 +89,9 @@ char *nfs_path(const char *base,
         memcpy(end, base, namelen);
         return end;
 Elong_unlock:
-        spin_unlock(&dcache_lock);
+        rcu_read_unlock();
+        if (read_seqretry(&rename_lock, seq))
+                goto rename_retry;
 Elong:
         return ERR_PTR(-ENAMETOOLONG);
 }
diff --git a/fs/nfs/unlink.c b/fs/nfs/unlink.c
index 7bdec8531400..8fe9eb47a97f 100644
--- a/fs/nfs/unlink.c
+++ b/fs/nfs/unlink.c
@@ -496,7 +496,7 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
 
         dfprintk(VFS, "NFS: silly-rename(%s/%s, ct=%d)\n",
                 dentry->d_parent->d_name.name, dentry->d_name.name,
-                atomic_read(&dentry->d_count));
+                dentry->d_count);
         nfs_inc_stats(dir, NFSIOS_SILLYRENAME);
 
         /*
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 184938fcff04..3a359023c9f7 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -1756,8 +1756,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
                 goto out_dput_new;
 
         if (svc_msnfs(ffhp) &&
-                ((atomic_read(&odentry->d_count) > 1)
-                 || (atomic_read(&ndentry->d_count) > 1))) {
+                ((odentry->d_count > 1) || (ndentry->d_count > 1))) {
                         host_err = -EPERM;
                         goto out_dput_new;
         }
@@ -1843,7 +1842,7 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
         if (type != S_IFDIR) { /* It's UNLINK */
 #ifdef MSNFS
                 if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
-                        (atomic_read(&rdentry->d_count) > 1)) {
+                        (rdentry->d_count > 1)) {
                         host_err = -EPERM;
                 } else
 #endif
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 71d4bc8464e0..77b48c8fab17 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -785,15 +785,19 @@ out_err:
         return err;
 }
 
-int nilfs_permission(struct inode *inode, int mask)
+int nilfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
-        struct nilfs_root *root = NILFS_I(inode)->i_root;
+        struct nilfs_root *root;
+
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
 
+        root = NILFS_I(inode)->i_root;
         if ((mask & MAY_WRITE) && root &&
             root->cno != NILFS_CPTREE_CURRENT_CNO)
                 return -EROFS; /* snapshot is not writable */
 
-        return generic_permission(inode, mask, NULL);
+        return generic_permission(inode, mask, flags, NULL);
 }
 
 int nilfs_load_inode_block(struct nilfs_sb_info *sbi, struct inode *inode,
diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index f7560da5a567..0ca98823db59 100644
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -256,7 +256,7 @@ extern void nilfs_update_inode(struct inode *, struct buffer_head *);
 extern void nilfs_truncate(struct inode *);
 extern void nilfs_evict_inode(struct inode *);
 extern int nilfs_setattr(struct dentry *, struct iattr *);
-int nilfs_permission(struct inode *inode, int mask);
+int nilfs_permission(struct inode *inode, int mask, unsigned int flags);
 extern int nilfs_load_inode_block(struct nilfs_sb_info *, struct inode *,
                                   struct buffer_head **);
 extern int nilfs_inode_dirty(struct inode *);
diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index f804d41ec9d3..e2dcc9c733f7 100644
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -162,10 +162,13 @@ struct inode *nilfs_alloc_inode(struct super_block *sb)
         return &ii->vfs_inode;
 }
 
-void nilfs_destroy_inode(struct inode *inode)
+static void nilfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
         struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
 
+        INIT_LIST_HEAD(&inode->i_dentry);
+
         if (mdi) {
                 kfree(mdi->mi_bgl); /* kfree(NULL) is safe */
                 kfree(mdi);
@@ -173,6 +176,11 @@ void nilfs_destroy_inode(struct inode *inode)
         kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode));
 }
 
+void nilfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, nilfs_i_callback);
+}
+
 static int nilfs_sync_super(struct nilfs_sb_info *sbi, int flag)
 {
         struct the_nilfs *nilfs = sbi->s_nilfs;
@@ -838,7 +846,7 @@ static int nilfs_attach_snapshot(struct super_block *s, __u64 cno,
 
 static int nilfs_tree_was_touched(struct dentry *root_dentry)
 {
-        return atomic_read(&root_dentry->d_count) > 1;
+        return root_dentry->d_count > 1;
 }
 
 /**
diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
index 20dc218707ca..79b47cbb5cd8 100644
--- a/fs/notify/fsnotify.c
+++ b/fs/notify/fsnotify.c
@@ -59,7 +59,7 @@ void __fsnotify_update_child_dentry_flags(struct inode *inode)
         /* determine if the children should tell inode about their events */
         watched = fsnotify_inode_watches_children(inode);
 
-        spin_lock(&dcache_lock);
+        spin_lock(&inode->i_lock);
         /* run all of the dentries associated with this inode.  Since this is a
          * directory, there damn well better only be one item on this list */
         list_for_each_entry(alias, &inode->i_dentry, d_alias) {
@@ -68,19 +68,21 @@ void __fsnotify_update_child_dentry_flags(struct inode *inode)
                 /* run all of the children of the original inode and fix their
                  * d_flags to indicate parental interest (their parent is the
                  * original inode) */
+                spin_lock(&alias->d_lock);
                 list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) {
                         if (!child->d_inode)
                                 continue;
 
-                        spin_lock(&child->d_lock);
+                        spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
                         if (watched)
                                 child->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
                         else
                                 child->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
                         spin_unlock(&child->d_lock);
                 }
+                spin_unlock(&alias->d_lock);
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
 }
 
 /* Notify this dentry's parent about a child's events. */
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 93622b175fc7..a627ed82c0a3 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -332,6 +332,13 @@ struct inode *ntfs_alloc_big_inode(struct super_block *sb)
         return NULL;
 }
 
+static void ntfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(ntfs_big_inode_cache, NTFS_I(inode));
+}
+
 void ntfs_destroy_big_inode(struct inode *inode)
 {
         ntfs_inode *ni = NTFS_I(inode);
@@ -340,7 +347,7 @@ void ntfs_destroy_big_inode(struct inode *inode)
         BUG_ON(ni->page);
         if (!atomic_dec_and_test(&ni->count))
                 BUG();
-        kmem_cache_free(ntfs_big_inode_cache, NTFS_I(inode));
+        call_rcu(&inode->i_rcu, ntfs_i_callback);
 }
 
 static inline ntfs_inode *ntfs_alloc_extent_inode(void)
diff --git a/fs/ocfs2/acl.c b/fs/ocfs2/acl.c
index 391915093fe1..704f6b1742f3 100644
--- a/fs/ocfs2/acl.c
+++ b/fs/ocfs2/acl.c
@@ -291,13 +291,17 @@ static int ocfs2_set_acl(handle_t *handle,
         return ret;
 }
 
-int ocfs2_check_acl(struct inode *inode, int mask)
+int ocfs2_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_super *osb;
         struct buffer_head *di_bh = NULL;
         struct posix_acl *acl;
         int ret = -EAGAIN;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
+        osb = OCFS2_SB(inode->i_sb);
         if (!(osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL))
                 return ret;
 
diff --git a/fs/ocfs2/acl.h b/fs/ocfs2/acl.h
index 5c5d31f05853..4fe7c9cf4bfb 100644
--- a/fs/ocfs2/acl.h
+++ b/fs/ocfs2/acl.h
@@ -26,7 +26,7 @@ struct ocfs2_acl_entry {
         __le32 e_id;
 };
 
-extern int ocfs2_check_acl(struct inode *, int);
+extern int ocfs2_check_acl(struct inode *, int, unsigned int);
 extern int ocfs2_acl_chmod(struct inode *);
 extern int ocfs2_init_acl(handle_t *, struct inode *, struct inode *,
                           struct buffer_head *, struct buffer_head *,
diff --git a/fs/ocfs2/dcache.c b/fs/ocfs2/dcache.c
index 895532ac4d98..6d80ecc7834f 100644
--- a/fs/ocfs2/dcache.c
+++ b/fs/ocfs2/dcache.c
@@ -52,9 +52,15 @@ void ocfs2_dentry_attach_gen(struct dentry *dentry)
 static int ocfs2_dentry_revalidate(struct dentry *dentry,
                                    struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode;
         int ret = 0;    /* if all else fails, just return false */
-        struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
+        struct ocfs2_super *osb;
+
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = dentry->d_inode;
+        osb = OCFS2_SB(dentry->d_sb);
 
         mlog_entry("(0x%p, '%.*s')\n", dentry,
                    dentry->d_name.len, dentry->d_name.name);
@@ -169,23 +175,25 @@ struct dentry *ocfs2_find_local_alias(struct inode *inode,
         struct list_head *p;
         struct dentry *dentry = NULL;
 
-        spin_lock(&dcache_lock);
-
+        spin_lock(&inode->i_lock);
         list_for_each(p, &inode->i_dentry) {
                 dentry = list_entry(p, struct dentry, d_alias);
 
+                spin_lock(&dentry->d_lock);
                 if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {
                         mlog(0, "dentry found: %.*s\n",
                              dentry->d_name.len, dentry->d_name.name);
 
-                        dget_locked(dentry);
+                        dget_dlock(dentry);
+                        spin_unlock(&dentry->d_lock);
                         break;
                 }
+                spin_unlock(&dentry->d_lock);
 
                 dentry = NULL;
         }
 
-        spin_unlock(&dcache_lock);
+        spin_unlock(&inode->i_lock);
 
         return dentry;
 }
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index b2df490a19ed..8c5c0eddc365 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -351,11 +351,18 @@ static struct inode *dlmfs_alloc_inode(struct super_block *sb)
         return &ip->ip_vfs_inode;
 }
 
-static void dlmfs_destroy_inode(struct inode *inode)
+static void dlmfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(dlmfs_inode_cache, DLMFS_I(inode));
 }
 
+static void dlmfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, dlmfs_i_callback);
+}
+
 static void dlmfs_evict_inode(struct inode *inode)
 {
         int status;
diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
index 19ad145d2af3..6adafa576065 100644
--- a/fs/ocfs2/export.c
+++ b/fs/ocfs2/export.c
@@ -138,7 +138,7 @@ check_gen:
 
         result = d_obtain_alias(inode);
         if (!IS_ERR(result))
-                result->d_op = &ocfs2_dentry_ops;
+                d_set_d_op(result, &ocfs2_dentry_ops);
         else
                 mlog_errno(PTR_ERR(result));
 
@@ -176,7 +176,7 @@ static struct dentry *ocfs2_get_parent(struct dentry *child)
 
         parent = d_obtain_alias(ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0));
         if (!IS_ERR(parent))
-                parent->d_op = &ocfs2_dentry_ops;
+                d_set_d_op(parent, &ocfs2_dentry_ops);
 
 bail_unlock:
         ocfs2_inode_unlock(dir, 0);
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index f6cba566429d..bdadbae09094 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1307,10 +1307,13 @@ bail:
         return err;
 }
 
-int ocfs2_permission(struct inode *inode, int mask)
+int ocfs2_permission(struct inode *inode, int mask, unsigned int flags)
 {
         int ret;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         mlog_entry_void();
 
         ret = ocfs2_inode_lock(inode, NULL, 0);
@@ -1320,7 +1323,7 @@ int ocfs2_permission(struct inode *inode, int mask)
                 goto out;
         }
 
-        ret = generic_permission(inode, mask, ocfs2_check_acl);
+        ret = generic_permission(inode, mask, flags, ocfs2_check_acl);
 
         ocfs2_inode_unlock(inode, 0);
 out:
diff --git a/fs/ocfs2/file.h b/fs/ocfs2/file.h
index 97bf761c9e7c..f5afbbef6703 100644
--- a/fs/ocfs2/file.h
+++ b/fs/ocfs2/file.h
@@ -61,7 +61,7 @@ int ocfs2_zero_extend(struct inode *inode, struct buffer_head *di_bh,
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr);
 int ocfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
                   struct kstat *stat);
-int ocfs2_permission(struct inode *inode, int mask);
+int ocfs2_permission(struct inode *inode, int mask, unsigned int flags);
 
 int ocfs2_should_update_atime(struct inode *inode,
                               struct vfsmount *vfsmnt);
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index ff5744e1e36f..d14cad6e2e41 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -147,7 +147,7 @@ static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
         spin_unlock(&oi->ip_lock);
 
 bail_add:
-        dentry->d_op = &ocfs2_dentry_ops;
+        d_set_d_op(dentry, &ocfs2_dentry_ops);
         ret = d_splice_alias(inode, dentry);
 
         if (inode) {
@@ -415,7 +415,7 @@ static int ocfs2_mknod(struct inode *dir,
                 mlog_errno(status);
                 goto leave;
         }
-        dentry->d_op = &ocfs2_dentry_ops;
+        d_set_d_op(dentry, &ocfs2_dentry_ops);
 
         status = ocfs2_add_entry(handle, dentry, inode,
                                  OCFS2_I(inode)->ip_blkno, parent_fe_bh,
@@ -743,7 +743,7 @@ static int ocfs2_link(struct dentry *old_dentry,
         }
 
         ihold(inode);
-        dentry->d_op = &ocfs2_dentry_ops;
+        d_set_d_op(dentry, &ocfs2_dentry_ops);
         d_instantiate(dentry, inode);
 
 out_commit:
@@ -1794,7 +1794,7 @@ static int ocfs2_symlink(struct inode *dir,
                 mlog_errno(status);
                 goto bail;
         }
-        dentry->d_op = &ocfs2_dentry_ops;
+        d_set_d_op(dentry, &ocfs2_dentry_ops);
 
         status = ocfs2_add_entry(handle, dentry, inode,
                                  le64_to_cpu(fe->i_blkno), parent_fe_bh,
@@ -2459,7 +2459,7 @@ int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
                 goto out_commit;
         }
 
-        dentry->d_op = &ocfs2_dentry_ops;
+        d_set_d_op(dentry, &ocfs2_dentry_ops);
         d_instantiate(dentry, inode);
         status = 0;
 out_commit:
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index cfeab7ce3697..17ff46fa8a10 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -569,11 +569,18 @@ static struct inode *ocfs2_alloc_inode(struct super_block *sb)
         return &oi->vfs_inode;
 }
 
-static void ocfs2_destroy_inode(struct inode *inode)
+static void ocfs2_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(ocfs2_inode_cachep, OCFS2_I(inode));
 }
 
+static void ocfs2_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, ocfs2_i_callback);
+}
+
 static unsigned long long ocfs2_max_file_offset(unsigned int bbits,
                                                 unsigned int cbits)
 {
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 911e61f348fc..a2a5bff774e3 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -343,11 +343,18 @@ static struct inode *openprom_alloc_inode(struct super_block *sb)
         return &oi->vfs_inode;
 }
 
-static void openprom_destroy_inode(struct inode *inode)
+static void openprom_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(op_inode_cachep, OP_I(inode));
 }
 
+static void openprom_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, openprom_i_callback);
+}
+
 static struct inode *openprom_iget(struct super_block *sb, ino_t ino)
 {
         struct inode *inode;
diff --git a/fs/pipe.c b/fs/pipe.c
index 04629f36e397..68f1f8e4e23b 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -999,12 +999,12 @@ struct file *create_write_pipe(int flags)
                 goto err;
 
         err = -ENOMEM;
-        path.dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &name);
+        path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name);
         if (!path.dentry)
                 goto err_inode;
         path.mnt = mntget(pipe_mnt);
 
-        path.dentry->d_op = &pipefs_dentry_operations;
+        d_set_d_op(path.dentry, &pipefs_dentry_operations);
         d_instantiate(path.dentry, inode);
 
         err = -ENFILE;
@@ -1253,6 +1253,10 @@ out:
         return ret;
 }
 
+static const struct super_operations pipefs_ops = {
+        .destroy_inode = free_inode_nonrcu,
+};
+
 /*
  * pipefs should _never_ be mounted by userland - too much of security hassle,
  * no real gain from having the whole whorehouse mounted. So we don't need
@@ -1262,7 +1266,7 @@ out:
 static struct dentry *pipefs_mount(struct file_system_type *fs_type,
                          int flags, const char *dev_name, void *data)
 {
-        return mount_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC);
+        return mount_pseudo(fs_type, "pipe:", &pipefs_ops, PIPEFS_MAGIC);
 }
 
 static struct file_system_type pipe_fs_type = {
@@ -1288,7 +1292,7 @@ static int __init init_pipe_fs(void)
 static void __exit exit_pipe_fs(void)
 {
         unregister_filesystem(&pipe_fs_type);
-        mntput(pipe_mnt);
+        mntput_long(pipe_mnt);
 }
 
 fs_initcall(init_pipe_fs);
diff --git a/fs/pnode.c b/fs/pnode.c
index 8066b8dd748f..d42514e32380 100644
--- a/fs/pnode.c
+++ b/fs/pnode.c
@@ -288,7 +288,7 @@ out:
  */
 static inline int do_refcount_check(struct vfsmount *mnt, int count)
 {
-        int mycount = atomic_read(&mnt->mnt_count) - mnt->mnt_ghosts;
+        int mycount = mnt_get_count(mnt) - mnt->mnt_ghosts;
         return (mycount > count);
 }
 
@@ -300,7 +300,7 @@ static inline int do_refcount_check(struct vfsmount *mnt, int count)
  * Check if any of these mounts that **do not have submounts**
  * have more references than 'refcnt'. If so return busy.
  *
- * vfsmount lock must be held for read or write
+ * vfsmount lock must be held for write
  */
 int propagate_mount_busy(struct vfsmount *mnt, int refcnt)
 {
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 08cba2c3b612..b20962c71a52 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1795,10 +1795,16 @@ static int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat
  */
 static int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
-        struct task_struct *task = get_proc_task(inode);
+        struct inode *inode;
+        struct task_struct *task;
         const struct cred *cred;
 
+        if (nd && nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = dentry->d_inode;
+        task = get_proc_task(inode);
+
         if (task) {
                 if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
                     task_dumpable(task)) {
@@ -1820,7 +1826,7 @@ static int pid_revalidate(struct dentry *dentry, struct nameidata *nd)
         return 0;
 }
 
-static int pid_delete_dentry(struct dentry * dentry)
+static int pid_delete_dentry(const struct dentry * dentry)
 {
         /* Is the task we represent dead?
          * If so, then don't put the dentry on the lru list,
@@ -1964,12 +1970,19 @@ static int proc_fd_link(struct inode *inode, struct path *path)
 
 static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
-        struct task_struct *task = get_proc_task(inode);
-        int fd = proc_fd(inode);
+        struct inode *inode;
+        struct task_struct *task;
+        int fd;
         struct files_struct *files;
         const struct cred *cred;
 
+        if (nd && nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = dentry->d_inode;
+        task = get_proc_task(inode);
+        fd = proc_fd(inode);
+
         if (task) {
                 files = get_files_struct(task);
                 if (files) {
@@ -2045,7 +2058,7 @@ static struct dentry *proc_fd_instantiate(struct inode *dir,
         inode->i_op = &proc_pid_link_inode_operations;
         inode->i_size = 64;
         ei->op.proc_get_link = proc_fd_link;
-        dentry->d_op = &tid_fd_dentry_operations;
+        d_set_d_op(dentry, &tid_fd_dentry_operations);
         d_add(dentry, inode);
         /* Close the race of the process dying before we return the dentry */
         if (tid_fd_revalidate(dentry, NULL))
@@ -2177,11 +2190,13 @@ static const struct file_operations proc_fd_operations = {
  * /proc/pid/fd needs a special permission handler so that a process can still
  * access /proc/self/fd after it has executed a setuid().
  */
-static int proc_fd_permission(struct inode *inode, int mask)
+static int proc_fd_permission(struct inode *inode, int mask, unsigned int flags)
 {
         int rv;
 
-        rv = generic_permission(inode, mask, NULL);
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+        rv = generic_permission(inode, mask, flags, NULL);
         if (rv == 0)
                 return 0;
         if (task_pid(current) == proc_pid(inode))
@@ -2213,7 +2228,7 @@ static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
         ei->fd = fd;
         inode->i_mode = S_IFREG | S_IRUSR;
         inode->i_fop = &proc_fdinfo_file_operations;
-        dentry->d_op = &tid_fd_dentry_operations;
+        d_set_d_op(dentry, &tid_fd_dentry_operations);
         d_add(dentry, inode);
         /* Close the race of the process dying before we return the dentry */
         if (tid_fd_revalidate(dentry, NULL))
@@ -2272,7 +2287,7 @@ static struct dentry *proc_pident_instantiate(struct inode *dir,
         if (p->fop)
                 inode->i_fop = p->fop;
         ei->op = p->op;
-        dentry->d_op = &pid_dentry_operations;
+        d_set_d_op(dentry, &pid_dentry_operations);
         d_add(dentry, inode);
         /* Close the race of the process dying before we return the dentry */
         if (pid_revalidate(dentry, NULL))
@@ -2639,8 +2654,14 @@ static const struct pid_entry proc_base_stuff[] = {
  */
 static int proc_base_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct inode *inode = dentry->d_inode;
-        struct task_struct *task = get_proc_task(inode);
+        struct inode *inode;
+        struct task_struct *task;
+
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        inode = dentry->d_inode;
+        task = get_proc_task(inode);
         if (task) {
                 put_task_struct(task);
                 return 1;
@@ -2691,7 +2712,7 @@ static struct dentry *proc_base_instantiate(struct inode *dir,
         if (p->fop)
                 inode->i_fop = p->fop;
         ei->op = p->op;
-        dentry->d_op = &proc_base_dentry_operations;
+        d_set_d_op(dentry, &proc_base_dentry_operations);
         d_add(dentry, inode);
         error = NULL;
 out:
@@ -3005,7 +3026,7 @@ static struct dentry *proc_pid_instantiate(struct inode *dir,
         inode->i_nlink = 2 + pid_entry_count_dirs(tgid_base_stuff,
                 ARRAY_SIZE(tgid_base_stuff));
 
-        dentry->d_op = &pid_dentry_operations;
+        d_set_d_op(dentry, &pid_dentry_operations);
 
         d_add(dentry, inode);
         /* Close the race of the process dying before we return the dentry */
@@ -3248,7 +3269,7 @@ static struct dentry *proc_task_instantiate(struct inode *dir,
         inode->i_nlink = 2 + pid_entry_count_dirs(tid_base_stuff,
                 ARRAY_SIZE(tid_base_stuff));
 
-        dentry->d_op = &pid_dentry_operations;
+        d_set_d_op(dentry, &pid_dentry_operations);
 
         d_add(dentry, inode);
         /* Close the race of the process dying before we return the dentry */
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index dd29f0337661..f766be29d2c7 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -400,7 +400,7 @@ static const struct inode_operations proc_link_inode_operations = {
  * smarter: we could keep a "volatile" flag in the 
  * inode to indicate which ones to keep.
  */
-static int proc_delete_dentry(struct dentry * dentry)
+static int proc_delete_dentry(const struct dentry * dentry)
 {
         return 1;
 }
@@ -439,7 +439,7 @@ struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
 out_unlock:
 
         if (inode) {
-                dentry->d_op = &proc_dentry_operations;
+                d_set_d_op(dentry, &proc_dentry_operations);
                 d_add(dentry, inode);
                 return NULL;
         }
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 3ddb6068177c..6bcb926b101b 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -65,11 +65,18 @@ static struct inode *proc_alloc_inode(struct super_block *sb)
         return inode;
 }
 
-static void proc_destroy_inode(struct inode *inode)
+static void proc_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(proc_inode_cachep, PROC_I(inode));
 }
 
+static void proc_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, proc_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct proc_inode *ei = (struct proc_inode *) foo;
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index b652cb00906b..09a1f92a34ef 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -5,6 +5,7 @@
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
 #include <linux/security.h>
+#include <linux/namei.h>
 #include "internal.h"
 
 static const struct dentry_operations proc_sys_dentry_operations;
@@ -120,7 +121,7 @@ static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
                 goto out;
 
         err = NULL;
-        dentry->d_op = &proc_sys_dentry_operations;
+        d_set_d_op(dentry, &proc_sys_dentry_operations);
         d_add(dentry, inode);
 
 out:
@@ -201,7 +202,7 @@ static int proc_sys_fill_cache(struct file *filp, void *dirent,
                                 dput(child);
                                 return -ENOMEM;
                         } else {
-                                child->d_op = &proc_sys_dentry_operations;
+                                d_set_d_op(child, &proc_sys_dentry_operations);
                                 d_add(child, inode);
                         }
                 } else {
@@ -294,7 +295,7 @@ out:
         return ret;
 }
 
-static int proc_sys_permission(struct inode *inode, int mask)
+static int proc_sys_permission(struct inode *inode, int mask,unsigned int flags)
 {
         /*
          * sysctl entries that are not writeable,
@@ -304,6 +305,9 @@ static int proc_sys_permission(struct inode *inode, int mask)
         struct ctl_table *table;
         int error;
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         /* Executable files are not allowed under /proc/sys/ */
         if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
                 return -EACCES;
@@ -389,23 +393,30 @@ static const struct inode_operations proc_sys_dir_operations = {
 
 static int proc_sys_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
         return !PROC_I(dentry->d_inode)->sysctl->unregistering;
 }
 
-static int proc_sys_delete(struct dentry *dentry)
+static int proc_sys_delete(const struct dentry *dentry)
 {
         return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
 }
 
-static int proc_sys_compare(struct dentry *dir, struct qstr *qstr,
-                            struct qstr *name)
+static int proc_sys_compare(const struct dentry *parent,
+                const struct inode *pinode,
+                const struct dentry *dentry, const struct inode *inode,
+                unsigned int len, const char *str, const struct qstr *name)
 {
-        struct dentry *dentry = container_of(qstr, struct dentry, d_name);
-        if (qstr->len != name->len)
+        /* Although proc doesn't have negative dentries, rcu-walk means
+         * that inode here can be NULL */
+        if (!inode)
+                return 0;
+        if (name->len != len)
                 return 1;
-        if (memcmp(qstr->name, name->name, name->len))
+        if (memcmp(name->name, str, len))
                 return 1;
-        return !sysctl_is_seen(PROC_I(dentry->d_inode)->sysctl);
+        return !sysctl_is_seen(PROC_I(inode)->sysctl);
 }
 
 static const struct dentry_operations proc_sys_dentry_operations = {
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index fcada42f1aa3..e63b4171d583 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -425,11 +425,18 @@ static struct inode *qnx4_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void qnx4_destroy_inode(struct inode *inode)
+static void qnx4_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode));
 }
 
+static void qnx4_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, qnx4_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo;
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index b243117b8752..2575682a9ead 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -529,11 +529,18 @@ static struct inode *reiserfs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void reiserfs_destroy_inode(struct inode *inode)
+static void reiserfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
 }
 
+static void reiserfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, reiserfs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index 5d04a7828e7a..3cfb2e933644 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -870,11 +870,14 @@ out:
         return err;
 }
 
-static int reiserfs_check_acl(struct inode *inode, int mask)
+static int reiserfs_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
         struct posix_acl *acl;
         int error = -EAGAIN; /* do regular unix permission checks by default */
 
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
         acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
 
         if (acl) {
@@ -951,8 +954,10 @@ static int xattr_mount_check(struct super_block *s)
         return 0;
 }
 
-int reiserfs_permission(struct inode *inode, int mask)
+int reiserfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
         /*
          * We don't do permission checks on the internal objects.
          * Permissions are determined by the "owning" object.
@@ -965,13 +970,16 @@ int reiserfs_permission(struct inode *inode, int mask)
          * Stat data v1 doesn't support ACLs.
          */
         if (get_inode_sd_version(inode) != STAT_DATA_V1)
-                return generic_permission(inode, mask, reiserfs_check_acl);
+                return generic_permission(inode, mask, flags,
+                                        reiserfs_check_acl);
 #endif
-        return generic_permission(inode, mask, NULL);
+        return generic_permission(inode, mask, flags, NULL);
 }
 
 static int xattr_hide_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
         return -EPERM;
 }
 
@@ -990,7 +998,7 @@ int reiserfs_lookup_privroot(struct super_block *s)
                                 strlen(PRIVROOT_NAME));
         if (!IS_ERR(dentry)) {
                 REISERFS_SB(s)->priv_root = dentry;
-                dentry->d_op = &xattr_lookup_poison_ops;
+                d_set_d_op(dentry, &xattr_lookup_poison_ops);
                 if (dentry->d_inode)
                         dentry->d_inode->i_flags |= S_PRIVATE;
         } else
diff --git a/fs/romfs/super.c b/fs/romfs/super.c
index 6647f90e55cd..2305e3121cb1 100644
--- a/fs/romfs/super.c
+++ b/fs/romfs/super.c
@@ -400,11 +400,18 @@ static struct inode *romfs_alloc_inode(struct super_block *sb)
 /*
  * return a spent inode to the slab cache
  */
-static void romfs_destroy_inode(struct inode *inode)
+static void romfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(romfs_inode_cachep, ROMFS_I(inode));
 }
 
+static void romfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, romfs_i_callback);
+}
+
 /*
  * get filesystem statistics
  */
diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index 24de30ba34c1..20700b9f2b4c 100644
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -440,11 +440,18 @@ static struct inode *squashfs_alloc_inode(struct super_block *sb)
 }
 
 
-static void squashfs_destroy_inode(struct inode *inode)
+static void squashfs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(squashfs_inode_cachep, squashfs_i(inode));
 }
 
+static void squashfs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, squashfs_i_callback);
+}
+
 
 static struct file_system_type squashfs_fs_type = {
         .owner = THIS_MODULE,
diff --git a/fs/super.c b/fs/super.c
index ca696155cd9a..823e061faa87 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -30,6 +30,7 @@
 #include <linux/idr.h>
 #include <linux/mutex.h>
 #include <linux/backing-dev.h>
+#include <linux/rculist_bl.h>
 #include "internal.h"
 
 
@@ -71,7 +72,7 @@ static struct super_block *alloc_super(struct file_system_type *type)
                 INIT_LIST_HEAD(&s->s_files);
 #endif
                 INIT_LIST_HEAD(&s->s_instances);
-                INIT_HLIST_HEAD(&s->s_anon);
+                INIT_HLIST_BL_HEAD(&s->s_anon);
                 INIT_LIST_HEAD(&s->s_inodes);
                 INIT_LIST_HEAD(&s->s_dentry_lru);
                 init_rwsem(&s->s_umount);
@@ -1139,7 +1140,7 @@ static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
         return mnt;
 
  err:
-        mntput(mnt);
+        mntput_long(mnt);
         return ERR_PTR(err);
 }
 
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 7e54bac8c4b0..ea9120a830d8 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -231,7 +231,7 @@ void release_sysfs_dirent(struct sysfs_dirent * sd)
                 goto repeat;
 }
 
-static int sysfs_dentry_delete(struct dentry *dentry)
+static int sysfs_dentry_delete(const struct dentry *dentry)
 {
         struct sysfs_dirent *sd = dentry->d_fsdata;
         return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
@@ -239,9 +239,13 @@ static int sysfs_dentry_delete(struct dentry *dentry)
 
 static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
-        struct sysfs_dirent *sd = dentry->d_fsdata;
+        struct sysfs_dirent *sd;
         int is_dir;
 
+        if (nd->flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        sd = dentry->d_fsdata;
         mutex_lock(&sysfs_mutex);
 
         /* The sysfs dirent has been deleted */
@@ -701,7 +705,7 @@ static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
         /* instantiate and hash dentry */
         ret = d_find_alias(inode);
         if (!ret) {
-                dentry->d_op = &sysfs_dentry_ops;
+                d_set_d_op(dentry, &sysfs_dentry_ops);
                 dentry->d_fsdata = sysfs_get(sd);
                 d_add(dentry, inode);
         } else {
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index cffb1fd8ba33..30ac27345586 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -348,13 +348,18 @@ int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const void *ns, const cha
                 return -ENOENT;
 }
 
-int sysfs_permission(struct inode *inode, int mask)
+int sysfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
-        struct sysfs_dirent *sd = inode->i_private;
+        struct sysfs_dirent *sd;
+
+        if (flags & IPERM_FLAG_RCU)
+                return -ECHILD;
+
+        sd = inode->i_private;
 
         mutex_lock(&sysfs_mutex);
         sysfs_refresh_inode(sd, inode);
         mutex_unlock(&sysfs_mutex);
 
-        return generic_permission(inode, mask, NULL);
+        return generic_permission(inode, mask, flags, NULL);
 }
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index d9be60a2e956..ffaaa816bfba 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -200,7 +200,7 @@ static inline void __sysfs_put(struct sysfs_dirent *sd)
 struct inode *sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd);
 void sysfs_evict_inode(struct inode *inode);
 int sysfs_sd_setattr(struct sysfs_dirent *sd, struct iattr *iattr);
-int sysfs_permission(struct inode *inode, int mask);
+int sysfs_permission(struct inode *inode, int mask, unsigned int flags);
 int sysfs_setattr(struct dentry *dentry, struct iattr *iattr);
 int sysfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat);
 int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index de44d067b9e6..0630eb969a28 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -333,11 +333,18 @@ static struct inode *sysv_alloc_inode(struct super_block *sb)
         return &si->vfs_inode;
 }
 
-static void sysv_destroy_inode(struct inode *inode)
+static void sysv_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(sysv_inode_cachep, SYSV_I(inode));
 }
 
+static void sysv_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, sysv_i_callback);
+}
+
 static void init_once(void *p)
 {
         struct sysv_inode_info *si = (struct sysv_inode_info *)p;
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index 11e7f7d11cd0..b5e68da2db32 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -27,7 +27,8 @@ static int add_nondir(struct dentry *dentry, struct inode *inode)
         return err;
 }
 
-static int sysv_hash(struct dentry *dentry, struct qstr *qstr)
+static int sysv_hash(const struct dentry *dentry, const struct inode *inode,
+                struct qstr *qstr)
 {
         /* Truncate the name in place, avoids having to define a compare
            function. */
@@ -47,7 +48,7 @@ static struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry, st
         struct inode * inode = NULL;
         ino_t ino;
 
-        dentry->d_op = dir->i_sb->s_root->d_op;
+        d_set_d_op(dentry, dir->i_sb->s_root->d_op);
         if (dentry->d_name.len > SYSV_NAMELEN)
                 return ERR_PTR(-ENAMETOOLONG);
         ino = sysv_inode_by_name(dentry);
diff --git a/fs/sysv/super.c b/fs/sysv/super.c
index 3d9c62be0c10..76712aefc4ab 100644
--- a/fs/sysv/super.c
+++ b/fs/sysv/super.c
@@ -346,7 +346,7 @@ static int complete_read_super(struct super_block *sb, int silent, int size)
         if (sbi->s_forced_ro)
                 sb->s_flags |= MS_RDONLY;
         if (sbi->s_truncate)
-                sb->s_root->d_op = &sysv_dentry_operations;
+                d_set_d_op(sb->s_root, &sysv_dentry_operations);
         return 1;
 }
 
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 91fac54c70e3..6e11c2975dcf 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -272,12 +272,20 @@ static struct inode *ubifs_alloc_inode(struct super_block *sb)
         return &ui->vfs_inode;
 };
 
+static void ubifs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        struct ubifs_inode *ui = ubifs_inode(inode);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(ubifs_inode_slab, ui);
+}
+
 static void ubifs_destroy_inode(struct inode *inode)
 {
         struct ubifs_inode *ui = ubifs_inode(inode);
 
         kfree(ui->data);
-        kmem_cache_free(ubifs_inode_slab, inode);
+        call_rcu(&inode->i_rcu, ubifs_i_callback);
 }
 
 /*
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 4a5c7c61836a..b539d53320fb 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -139,11 +139,18 @@ static struct inode *udf_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void udf_destroy_inode(struct inode *inode)
+static void udf_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(udf_inode_cachep, UDF_I(inode));
 }
 
+static void udf_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, udf_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct udf_inode_info *ei = (struct udf_inode_info *)foo;
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 2c47daed56da..2c61ac5d4e48 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1412,11 +1412,18 @@ static struct inode *ufs_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void ufs_destroy_inode(struct inode *inode)
+static void ufs_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(ufs_inode_cachep, UFS_I(inode));
 }
 
+static void ufs_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, ufs_i_callback);
+}
+
 static void init_once(void *foo)
 {
         struct ufs_inode_info *ei = (struct ufs_inode_info *) foo;
diff --git a/fs/xfs/linux-2.6/xfs_acl.c b/fs/xfs/linux-2.6/xfs_acl.c
index b2771862fd3d..39f4f809bb68 100644
--- a/fs/xfs/linux-2.6/xfs_acl.c
+++ b/fs/xfs/linux-2.6/xfs_acl.c
@@ -219,12 +219,13 @@ xfs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
 }
 
 int
-xfs_check_acl(struct inode *inode, int mask)
+xfs_check_acl(struct inode *inode, int mask, unsigned int flags)
 {
-        struct xfs_inode *ip = XFS_I(inode);
+        struct xfs_inode *ip;
         struct posix_acl *acl;
         int error = -EAGAIN;
 
+        ip = XFS_I(inode);
         trace_xfs_check_acl(ip);
 
         /*
@@ -234,6 +235,12 @@ xfs_check_acl(struct inode *inode, int mask)
         if (!XFS_IFORK_Q(ip))
                 return -EAGAIN;
 
+        if (flags & IPERM_FLAG_RCU) {
+                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
+                        return -ECHILD;
+                return -EAGAIN;
+        }
+
         acl = xfs_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
diff --git a/fs/xfs/xfs_acl.h b/fs/xfs/xfs_acl.h
index 0135e2a669d7..11dd72070cbb 100644
--- a/fs/xfs/xfs_acl.h
+++ b/fs/xfs/xfs_acl.h
@@ -42,7 +42,7 @@ struct xfs_acl {
 #define SGI_ACL_DEFAULT_SIZE    (sizeof(SGI_ACL_DEFAULT)-1)
 
 #ifdef CONFIG_XFS_POSIX_ACL
-extern int xfs_check_acl(struct inode *inode, int mask);
+extern int xfs_check_acl(struct inode *inode, int mask, unsigned int flags);
 extern struct posix_acl *xfs_get_acl(struct inode *inode, int type);
 extern int xfs_inherit_acl(struct inode *inode, struct posix_acl *default_acl);
 extern int xfs_acl_chmod(struct inode *inode);
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index 0cdd26932d8e..d7de5a3f7867 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -91,6 +91,17 @@ xfs_inode_alloc(
         return ip;
 }
 
+STATIC void
+xfs_inode_free_callback(
+        struct rcu_head         *head)
+{
+        struct inode            *inode = container_of(head, struct inode, i_rcu);
+        struct xfs_inode        *ip = XFS_I(inode);
+
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_zone_free(xfs_inode_zone, ip);
+}
+
 void
 xfs_inode_free(
         struct xfs_inode        *ip)
@@ -134,7 +145,7 @@ xfs_inode_free(
         ASSERT(!spin_is_locked(&ip->i_flags_lock));
         ASSERT(completion_done(&ip->i_flush));
 
-        kmem_zone_free(xfs_inode_zone, ip);
+        call_rcu(&ip->i_vnode.i_rcu, xfs_inode_free_callback);
 }
 
 /*
diff --git a/include/linux/bit_spinlock.h b/include/linux/bit_spinlock.h
index 7113a32a86ea..e612575a2596 100644
--- a/include/linux/bit_spinlock.h
+++ b/include/linux/bit_spinlock.h
@@ -1,6 +1,10 @@
 #ifndef __LINUX_BIT_SPINLOCK_H
 #define __LINUX_BIT_SPINLOCK_H
 
+#include <linux/kernel.h>
+#include <linux/preempt.h>
+#include <asm/atomic.h>
+
 /*
  *  bit-based spin_lock()
  *
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index 2e914d0771b9..4ccc59c1ea82 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -37,7 +37,7 @@ extern const struct file_operations coda_ioctl_operations;
 /* operations shared over more than one file */
 int coda_open(struct inode *i, struct file *f);
 int coda_release(struct inode *i, struct file *f);
-int coda_permission(struct inode *inode, int mask);
+int coda_permission(struct inode *inode, int mask, unsigned int flags);
 int coda_revalidate_inode(struct dentry *);
 int coda_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 int coda_setattr(struct dentry *, struct iattr *);
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 6a4aea30aa09..bd07758943e0 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -4,7 +4,9 @@
 #include <asm/atomic.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
+#include <linux/rculist_bl.h>
 #include <linux/spinlock.h>
+#include <linux/seqlock.h>
 #include <linux/cache.h>
 #include <linux/rcupdate.h>
 
@@ -45,6 +47,27 @@ struct dentry_stat_t {
 };
 extern struct dentry_stat_t dentry_stat;
 
+/*
+ * Compare 2 name strings, return 0 if they match, otherwise non-zero.
+ * The strings are both count bytes long, and count is non-zero.
+ */
+static inline int dentry_cmp(const unsigned char *cs, size_t scount,
+                                const unsigned char *ct, size_t tcount)
+{
+        int ret;
+        if (scount != tcount)
+                return 1;
+        do {
+                ret = (*cs != *ct);
+                if (ret)
+                        break;
+                cs++;
+                ct++;
+                tcount--;
+        } while (tcount);
+        return ret;
+}
+
 /* Name hashing routines. Initial hash value */
 /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
 #define init_name_hash()                0
@@ -81,25 +104,33 @@ full_name_hash(const unsigned char *name, unsigned int len)
  * large memory footprint increase).
  */
 #ifdef CONFIG_64BIT
-#define DNAME_INLINE_LEN_MIN 32 /* 192 bytes */
+# define DNAME_INLINE_LEN 32 /* 192 bytes */
 #else
-#define DNAME_INLINE_LEN_MIN 40 /* 128 bytes */
+# ifdef CONFIG_SMP
+#  define DNAME_INLINE_LEN 36 /* 128 bytes */
+# else
+#  define DNAME_INLINE_LEN 40 /* 128 bytes */
+# endif
 #endif
 
 struct dentry {
-        atomic_t d_count;
+        /* RCU lookup touched fields */
         unsigned int d_flags;           /* protected by d_lock */
-        spinlock_t d_lock;              /* per dentry lock */
-        int d_mounted;
-        struct inode *d_inode;          /* Where the name belongs to - NULL is
-                                         * negative */
-        /*
-         * The next three fields are touched by __d_lookup.  Place them here
-         * so they all fit in a cache line.
-         */
-        struct hlist_node d_hash;       /* lookup hash list */
+        seqcount_t d_seq;               /* per dentry seqlock */
+        struct hlist_bl_node d_hash;    /* lookup hash list */
         struct dentry *d_parent;        /* parent directory */
         struct qstr d_name;
+        struct inode *d_inode;          /* Where the name belongs to - NULL is
+                                         * negative */
+        unsigned char d_iname[DNAME_INLINE_LEN];        /* small names */
+
+        /* Ref lookup also touches following */
+        unsigned int d_count;           /* protected by d_lock */
+        spinlock_t d_lock;              /* per dentry lock */
+        const struct dentry_operations *d_op;
+        struct super_block *d_sb;       /* The root of the dentry tree */
+        unsigned long d_time;           /* used by d_revalidate */
+        void *d_fsdata;                 /* fs-specific data */
 
         struct list_head d_lru;         /* LRU list */
         /*
@@ -111,12 +142,6 @@ struct dentry {
         } d_u;
         struct list_head d_subdirs;     /* our children */
         struct list_head d_alias;       /* inode alias list */
-        unsigned long d_time;           /* used by d_revalidate */
-        const struct dentry_operations *d_op;
-        struct super_block *d_sb;       /* The root of the dentry tree */
-        void *d_fsdata;                 /* fs-specific data */
-
-        unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* small names */
 };
 
 /*
@@ -133,96 +158,61 @@ enum dentry_d_lock_class
 
 struct dentry_operations {
         int (*d_revalidate)(struct dentry *, struct nameidata *);
-        int (*d_hash) (struct dentry *, struct qstr *);
-        int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
-        int (*d_delete)(struct dentry *);
+        int (*d_hash)(const struct dentry *, const struct inode *,
+                        struct qstr *);
+        int (*d_compare)(const struct dentry *, const struct inode *,
+                        const struct dentry *, const struct inode *,
+                        unsigned int, const char *, const struct qstr *);
+        int (*d_delete)(const struct dentry *);
         void (*d_release)(struct dentry *);
         void (*d_iput)(struct dentry *, struct inode *);
         char *(*d_dname)(struct dentry *, char *, int);
-};
-
-/* the dentry parameter passed to d_hash and d_compare is the parent
- * directory of the entries to be compared. It is used in case these
- * functions need any directory specific information for determining
- * equivalency classes.  Using the dentry itself might not work, as it
- * might be a negative dentry which has no information associated with
- * it */
+} ____cacheline_aligned;
 
 /*
-locking rules:
-                big lock        dcache_lock     d_lock   may block
-d_revalidate:   no              no              no       yes
-d_hash          no              no              no       yes
-d_compare:      no              yes             yes      no
-d_delete:       no              yes             no       no
-d_release:      no              no              no       yes
-d_iput:         no              no              no       yes
+ * Locking rules for dentry_operations callbacks are to be found in
+ * Documentation/filesystems/Locking. Keep it updated!
+ *
+ * FUrther descriptions are found in Documentation/filesystems/vfs.txt.
+ * Keep it updated too!
  */
 
 /* d_flags entries */
 #define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
-#define DCACHE_NFSFS_RENAMED  0x0002    /* this dentry has been "silly
-                                         * renamed" and has to be
-                                         * deleted on the last dput()
-                                         */
-#define DCACHE_DISCONNECTED 0x0004
-     /* This dentry is possibly not currently connected to the dcache tree,
-      * in which case its parent will either be itself, or will have this
-      * flag as well.  nfsd will not use a dentry with this bit set, but will
-      * first endeavour to clear the bit either by discovering that it is
-      * connected, or by performing lookup operations.   Any filesystem which
-      * supports nfsd_operations MUST have a lookup function which, if it finds
-      * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move
-      * that dentry into place and return that dentry rather than the passed one,
-      * typically using d_splice_alias.
-      */
+#define DCACHE_NFSFS_RENAMED  0x0002
+     /* this dentry has been "silly renamed" and has to be deleted on the last
+      * dput() */
+
+#define DCACHE_DISCONNECTED     0x0004
+     /* This dentry is possibly not currently connected to the dcache tree, in
+      * which case its parent will either be itself, or will have this flag as
+      * well.  nfsd will not use a dentry with this bit set, but will first
+      * endeavour to clear the bit either by discovering that it is connected,
+      * or by performing lookup operations.   Any filesystem which supports
+      * nfsd_operations MUST have a lookup function which, if it finds a
+      * directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
+      * dentry into place and return that dentry rather than the passed one,
+      * typically using d_splice_alias. */
 
 #define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
 #define DCACHE_UNHASHED         0x0010  
-
-#define DCACHE_INOTIFY_PARENT_WATCHED   0x0020 /* Parent inode is watched by inotify */
+#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020
+     /* Parent inode is watched by inotify */
 
 #define DCACHE_COOKIE           0x0040  /* For use by dcookie subsystem */
-
-#define DCACHE_FSNOTIFY_PARENT_WATCHED  0x0080 /* Parent inode is watched by some fsnotify listener */
+#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080
+     /* Parent inode is watched by some fsnotify listener */
 
 #define DCACHE_CANT_MOUNT       0x0100
+#define DCACHE_GENOCIDE         0x0200
+#define DCACHE_MOUNTED          0x0400  /* is a mountpoint */
 
-extern spinlock_t dcache_lock;
-extern seqlock_t rename_lock;
-
-/**
- * d_drop - drop a dentry
- * @dentry: dentry to drop
- *
- * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
- * be found through a VFS lookup any more. Note that this is different from
- * deleting the dentry - d_delete will try to mark the dentry negative if
- * possible, giving a successful _negative_ lookup, while d_drop will
- * just make the cache lookup fail.
- *
- * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
- * reason (NFS timeouts or autofs deletes).
- *
- * __d_drop requires dentry->d_lock.
- */
-
-static inline void __d_drop(struct dentry *dentry)
-{
-        if (!(dentry->d_flags & DCACHE_UNHASHED)) {
-                dentry->d_flags |= DCACHE_UNHASHED;
-                hlist_del_rcu(&dentry->d_hash);
-        }
-}
+#define DCACHE_OP_HASH          0x1000
+#define DCACHE_OP_COMPARE       0x2000
+#define DCACHE_OP_REVALIDATE    0x4000
+#define DCACHE_OP_DELETE        0x8000
 
-static inline void d_drop(struct dentry *dentry)
-{
-        spin_lock(&dcache_lock);
-        spin_lock(&dentry->d_lock);
-        __d_drop(dentry);
-        spin_unlock(&dentry->d_lock);
-        spin_unlock(&dcache_lock);
-}
+extern seqlock_t rename_lock;
 
 static inline int dname_external(struct dentry *dentry)
 {
@@ -235,10 +225,14 @@ static inline int dname_external(struct dentry *dentry)
 extern void d_instantiate(struct dentry *, struct inode *);
 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
 extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
+extern void __d_drop(struct dentry *dentry);
+extern void d_drop(struct dentry *dentry);
 extern void d_delete(struct dentry *);
+extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
 
 /* allocate/de-allocate */
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
+extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
 extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
 extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
 extern struct dentry * d_obtain_alias(struct inode *);
@@ -296,14 +290,40 @@ static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *in
         return res;
 }
 
+extern void dentry_update_name_case(struct dentry *, struct qstr *);
+
 /* used for rename() and baskets */
 extern void d_move(struct dentry *, struct dentry *);
 extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
 
 /* appendix may either be NULL or be used for transname suffixes */
-extern struct dentry * d_lookup(struct dentry *, struct qstr *);
-extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
-extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
+extern struct dentry *d_lookup(struct dentry *, struct qstr *);
+extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
+extern struct dentry *__d_lookup(struct dentry *, struct qstr *);
+extern struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name,
+                                unsigned *seq, struct inode **inode);
+
+/**
+ * __d_rcu_to_refcount - take a refcount on dentry if sequence check is ok
+ * @dentry: dentry to take a ref on
+ * @seq: seqcount to verify against
+ * @Returns: 0 on failure, else 1.
+ *
+ * __d_rcu_to_refcount operates on a dentry,seq pair that was returned
+ * by __d_lookup_rcu, to get a reference on an rcu-walk dentry.
+ */
+static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
+{
+        int ret = 0;
+
+        assert_spin_locked(&dentry->d_lock);
+        if (!read_seqcount_retry(&dentry->d_seq, seq)) {
+                ret = 1;
+                dentry->d_count++;
+        }
+
+        return ret;
+}
 
 /* validate "insecure" dentry pointer */
 extern int d_validate(struct dentry *, struct dentry *);
@@ -316,34 +336,37 @@ extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 extern char *__d_path(const struct path *path, struct path *root, char *, int);
 extern char *d_path(const struct path *, char *, int);
 extern char *d_path_with_unreachable(const struct path *, char *, int);
-extern char *__dentry_path(struct dentry *, char *, int);
+extern char *dentry_path_raw(struct dentry *, char *, int);
 extern char *dentry_path(struct dentry *, char *, int);
 
 /* Allocation counts.. */
 
 /**
- *      dget, dget_locked       -       get a reference to a dentry
+ *      dget, dget_dlock -      get a reference to a dentry
  *      @dentry: dentry to get a reference to
  *
  *      Given a dentry or %NULL pointer increment the reference count
  *      if appropriate and return the dentry. A dentry will not be 
- *      destroyed when it has references. dget() should never be
- *      called for dentries with zero reference counter. For these cases
- *      (preferably none, functions in dcache.c are sufficient for normal
- *      needs and they take necessary precautions) you should hold dcache_lock
- *      and call dget_locked() instead of dget().
+ *      destroyed when it has references.
  */
- 
+static inline struct dentry *dget_dlock(struct dentry *dentry)
+{
+        if (dentry)
+                dentry->d_count++;
+        return dentry;
+}
+
 static inline struct dentry *dget(struct dentry *dentry)
 {
         if (dentry) {
-                BUG_ON(!atomic_read(&dentry->d_count));
-                atomic_inc(&dentry->d_count);
+                spin_lock(&dentry->d_lock);
+                dget_dlock(dentry);
+                spin_unlock(&dentry->d_lock);
         }
         return dentry;
 }
 
-extern struct dentry * dget_locked(struct dentry *);
+extern struct dentry *dget_parent(struct dentry *dentry);
 
 /**
  *      d_unhashed -    is dentry hashed
@@ -374,21 +397,11 @@ static inline void dont_mount(struct dentry *dentry)
         spin_unlock(&dentry->d_lock);
 }
 
-static inline struct dentry *dget_parent(struct dentry *dentry)
-{
-        struct dentry *ret;
-
-        spin_lock(&dentry->d_lock);
-        ret = dget(dentry->d_parent);
-        spin_unlock(&dentry->d_lock);
-        return ret;
-}
-
 extern void dput(struct dentry *);
 
 static inline int d_mountpoint(struct dentry *dentry)
 {
-        return dentry->d_mounted;
+        return dentry->d_flags & DCACHE_MOUNTED;
 }
 
 extern struct vfsmount *lookup_mnt(struct path *);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 090f0eacde29..baf3e556ff0e 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -392,6 +392,7 @@ struct inodes_stat_t {
 #include <linux/capability.h>
 #include <linux/semaphore.h>
 #include <linux/fiemap.h>
+#include <linux/rculist_bl.h>
 
 #include <asm/atomic.h>
 #include <asm/byteorder.h>
@@ -733,16 +734,31 @@ struct posix_acl;
 #define ACL_NOT_CACHED ((void *)(-1))
 
 struct inode {
+        /* RCU path lookup touches following: */
+        umode_t                 i_mode;
+        uid_t                   i_uid;
+        gid_t                   i_gid;
+        const struct inode_operations   *i_op;
+        struct super_block      *i_sb;
+
+        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
+        unsigned int            i_flags;
+        struct mutex            i_mutex;
+
+        unsigned long           i_state;
+        unsigned long           dirtied_when;   /* jiffies of first dirtying */
+
         struct hlist_node       i_hash;
         struct list_head        i_wb_list;      /* backing dev IO list */
         struct list_head        i_lru;          /* inode LRU list */
         struct list_head        i_sb_list;
-        struct list_head        i_dentry;
+        union {
+                struct list_head        i_dentry;
+                struct rcu_head         i_rcu;
+        };
         unsigned long           i_ino;
         atomic_t                i_count;
         unsigned int            i_nlink;
-        uid_t                   i_uid;
-        gid_t                   i_gid;
         dev_t                   i_rdev;
         unsigned int            i_blkbits;
         u64                     i_version;
@@ -755,13 +771,8 @@ struct inode {
         struct timespec         i_ctime;
         blkcnt_t                i_blocks;
         unsigned short          i_bytes;
-        umode_t                 i_mode;
-        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
-        struct mutex            i_mutex;
         struct rw_semaphore     i_alloc_sem;
-        const struct inode_operations   *i_op;
         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
-        struct super_block      *i_sb;
         struct file_lock        *i_flock;
         struct address_space    *i_mapping;
         struct address_space    i_data;
@@ -782,11 +793,6 @@ struct inode {
         struct hlist_head       i_fsnotify_marks;
 #endif
 
-        unsigned long           i_state;
-        unsigned long           dirtied_when;   /* jiffies of first dirtying */
-
-        unsigned int            i_flags;
-
 #ifdef CONFIG_IMA
         /* protected by i_lock */
         unsigned int            i_readcount; /* struct files open RO */
@@ -1372,13 +1378,13 @@ struct super_block {
         const struct xattr_handler **s_xattr;
 
         struct list_head        s_inodes;       /* all inodes */
-        struct hlist_head       s_anon;         /* anonymous dentries for (nfs) exporting */
+        struct hlist_bl_head    s_anon;         /* anonymous dentries for (nfs) exporting */
 #ifdef CONFIG_SMP
         struct list_head __percpu *s_files;
 #else
         struct list_head        s_files;
 #endif
-        /* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
+        /* s_dentry_lru, s_nr_dentry_unused protected by dcache.c lru locks */
         struct list_head        s_dentry_lru;   /* unused dentry lru */
         int                     s_nr_dentry_unused;     /* # of dentry on lru */
 
@@ -1545,9 +1551,18 @@ struct file_operations {
         int (*setlease)(struct file *, long, struct file_lock **);
 };
 
+#define IPERM_FLAG_RCU  0x0001
+
 struct inode_operations {
-        int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
         struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
+        void * (*follow_link) (struct dentry *, struct nameidata *);
+        int (*permission) (struct inode *, int, unsigned int);
+        int (*check_acl)(struct inode *, int, unsigned int);
+
+        int (*readlink) (struct dentry *, char __user *,int);
+        void (*put_link) (struct dentry *, struct nameidata *, void *);
+
+        int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
         int (*link) (struct dentry *,struct inode *,struct dentry *);
         int (*unlink) (struct inode *,struct dentry *);
         int (*symlink) (struct inode *,struct dentry *,const char *);
@@ -1556,12 +1571,7 @@ struct inode_operations {
         int (*mknod) (struct inode *,struct dentry *,int,dev_t);
         int (*rename) (struct inode *, struct dentry *,
                         struct inode *, struct dentry *);
-        int (*readlink) (struct dentry *, char __user *,int);
-        void * (*follow_link) (struct dentry *, struct nameidata *);
-        void (*put_link) (struct dentry *, struct nameidata *, void *);
         void (*truncate) (struct inode *);
-        int (*permission) (struct inode *, int);
-        int (*check_acl)(struct inode *, int);
         int (*setattr) (struct dentry *, struct iattr *);
         int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
         int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
@@ -1573,7 +1583,7 @@ struct inode_operations {
                           loff_t len);
         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
                       u64 len);
-};
+} ____cacheline_aligned;
 
 struct seq_file;
 
@@ -2158,8 +2168,8 @@ extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
 extern int inode_permission(struct inode *, int);
-extern int generic_permission(struct inode *, int,
-                int (*check_acl)(struct inode *, int));
+extern int generic_permission(struct inode *, int, unsigned int,
+                int (*check_acl)(struct inode *, int, unsigned int));
 
 static inline bool execute_ok(struct inode *inode)
 {
@@ -2230,6 +2240,7 @@ extern void iget_failed(struct inode *);
 extern void end_writeback(struct inode *);
 extern void __destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
+extern void free_inode_nonrcu(struct inode *inode);
 extern int should_remove_suid(struct dentry *);
 extern int file_remove_suid(struct file *);
 
@@ -2446,6 +2457,10 @@ static inline ino_t parent_ino(struct dentry *dentry)
 {
         ino_t res;
 
+        /*
+         * Don't strictly need d_lock here? If the parent ino could change
+         * then surely we'd have a deeper race in the caller?
+         */
         spin_lock(&dentry->d_lock);
         res = dentry->d_parent->d_inode->i_ino;
         spin_unlock(&dentry->d_lock);
diff --git a/include/linux/fs_struct.h b/include/linux/fs_struct.h
index a42b5bf02f8b..003dc0fd7347 100644
--- a/include/linux/fs_struct.h
+++ b/include/linux/fs_struct.h
@@ -2,10 +2,13 @@
 #define _LINUX_FS_STRUCT_H
 
 #include <linux/path.h>
+#include <linux/spinlock.h>
+#include <linux/seqlock.h>
 
 struct fs_struct {
         int users;
         spinlock_t lock;
+        seqcount_t seq;
         int umask;
         int in_exec;
         struct path root, pwd;
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index b10bcdeaef76..2a53f10712b3 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -17,7 +17,6 @@
 
 /*
  * fsnotify_d_instantiate - instantiate a dentry for inode
- * Called with dcache_lock held.
  */
 static inline void fsnotify_d_instantiate(struct dentry *dentry,
                                           struct inode *inode)
@@ -62,7 +61,6 @@ static inline int fsnotify_perm(struct file *file, int mask)
 
 /*
  * fsnotify_d_move - dentry has been moved
- * Called with dcache_lock and dentry->d_lock held.
  */
 static inline void fsnotify_d_move(struct dentry *dentry)
 {
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 7380763595d3..69ad89b50489 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -329,9 +329,15 @@ static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
 {
         struct dentry *parent;
 
-        assert_spin_locked(&dcache_lock);
         assert_spin_locked(&dentry->d_lock);
 
+        /*
+         * Serialisation of setting PARENT_WATCHED on the dentries is provided
+         * by d_lock. If inotify_inode_watched changes after we have taken
+         * d_lock, the following __fsnotify_update_child_dentry_flags call will
+         * find our entry, so it will spin until we complete here, and update
+         * us with the new state.
+         */
         parent = dentry->d_parent;
         if (parent->d_inode && fsnotify_inode_watches_children(parent->d_inode))
                 dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
@@ -341,15 +347,12 @@ static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
 
 /*
  * fsnotify_d_instantiate - instantiate a dentry for inode
- * Called with dcache_lock held.
  */
 static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
 {
         if (!inode)
                 return;
 
-        assert_spin_locked(&dcache_lock);
-
         spin_lock(&dentry->d_lock);
         __fsnotify_update_dcache_flags(dentry);
         spin_unlock(&dentry->d_lock);
diff --git a/include/linux/generic_acl.h b/include/linux/generic_acl.h
index 574bea4013b6..0437e377b555 100644
--- a/include/linux/generic_acl.h
+++ b/include/linux/generic_acl.h
@@ -10,6 +10,6 @@ extern const struct xattr_handler generic_acl_default_handler;
 
 int generic_acl_init(struct inode *, struct inode *);
 int generic_acl_chmod(struct inode *);
-int generic_check_acl(struct inode *inode, int mask);
+int generic_check_acl(struct inode *inode, int mask, unsigned int flags);
 
 #endif /* LINUX_GENERIC_ACL_H */
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index c760991b354a..61b9609e55f2 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -593,6 +593,13 @@ enum twl4030_usb_mode {
 
 struct twl4030_usb_data {
         enum twl4030_usb_mode   usb_mode;
+
+        int             (*phy_init)(struct device *dev);
+        int             (*phy_exit)(struct device *dev);
+        /* Power on/off the PHY */
+        int             (*phy_power)(struct device *dev, int iD, int on);
+        /* enable/disable  phy clocks */
+        int             (*phy_set_clock)(struct device *dev, int on);
 };
 
 struct twl4030_ins {
diff --git a/include/linux/list_bl.h b/include/linux/list_bl.h
new file mode 100644
index 000000000000..9ee97e7f2be4
--- /dev/null
+++ b/include/linux/list_bl.h
@@ -0,0 +1,144 @@
+#ifndef _LINUX_LIST_BL_H
+#define _LINUX_LIST_BL_H
+
+#include <linux/list.h>
+
+/*
+ * Special version of lists, where head of the list has a lock in the lowest
+ * bit. This is useful for scalable hash tables without increasing memory
+ * footprint overhead.
+ *
+ * For modification operations, the 0 bit of hlist_bl_head->first
+ * pointer must be set.
+ *
+ * With some small modifications, this can easily be adapted to store several
+ * arbitrary bits (not just a single lock bit), if the need arises to store
+ * some fast and compact auxiliary data.
+ */
+
+#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
+#define LIST_BL_LOCKMASK        1UL
+#else
+#define LIST_BL_LOCKMASK        0UL
+#endif
+
+#ifdef CONFIG_DEBUG_LIST
+#define LIST_BL_BUG_ON(x) BUG_ON(x)
+#else
+#define LIST_BL_BUG_ON(x)
+#endif
+
+
+struct hlist_bl_head {
+        struct hlist_bl_node *first;
+};
+
+struct hlist_bl_node {
+        struct hlist_bl_node *next, **pprev;
+};
+#define INIT_HLIST_BL_HEAD(ptr) \
+        ((ptr)->first = NULL)
+
+static inline void INIT_HLIST_BL_NODE(struct hlist_bl_node *h)
+{
+        h->next = NULL;
+        h->pprev = NULL;
+}
+
+#define hlist_bl_entry(ptr, type, member) container_of(ptr,type,member)
+
+static inline int hlist_bl_unhashed(const struct hlist_bl_node *h)
+{
+        return !h->pprev;
+}
+
+static inline struct hlist_bl_node *hlist_bl_first(struct hlist_bl_head *h)
+{
+        return (struct hlist_bl_node *)
+                ((unsigned long)h->first & ~LIST_BL_LOCKMASK);
+}
+
+static inline void hlist_bl_set_first(struct hlist_bl_head *h,
+                                        struct hlist_bl_node *n)
+{
+        LIST_BL_BUG_ON((unsigned long)n & LIST_BL_LOCKMASK);
+        LIST_BL_BUG_ON(!((unsigned long)h->first & LIST_BL_LOCKMASK));
+        h->first = (struct hlist_bl_node *)((unsigned long)n | LIST_BL_LOCKMASK);
+}
+
+static inline int hlist_bl_empty(const struct hlist_bl_head *h)
+{
+        return !((unsigned long)h->first & ~LIST_BL_LOCKMASK);
+}
+
+static inline void hlist_bl_add_head(struct hlist_bl_node *n,
+                                        struct hlist_bl_head *h)
+{
+        struct hlist_bl_node *first = hlist_bl_first(h);
+
+        n->next = first;
+        if (first)
+                first->pprev = &n->next;
+        n->pprev = &h->first;
+        hlist_bl_set_first(h, n);
+}
+
+static inline void __hlist_bl_del(struct hlist_bl_node *n)
+{
+        struct hlist_bl_node *next = n->next;
+        struct hlist_bl_node **pprev = n->pprev;
+
+        LIST_BL_BUG_ON((unsigned long)n & LIST_BL_LOCKMASK);
+
+        /* pprev may be `first`, so be careful not to lose the lock bit */
+        *pprev = (struct hlist_bl_node *)
+                        ((unsigned long)next |
+                         ((unsigned long)*pprev & LIST_BL_LOCKMASK));
+        if (next)
+                next->pprev = pprev;
+}
+
+static inline void hlist_bl_del(struct hlist_bl_node *n)
+{
+        __hlist_bl_del(n);
+        n->next = LIST_POISON1;
+        n->pprev = LIST_POISON2;
+}
+
+static inline void hlist_bl_del_init(struct hlist_bl_node *n)
+{
+        if (!hlist_bl_unhashed(n)) {
+                __hlist_bl_del(n);
+                INIT_HLIST_BL_NODE(n);
+        }
+}
+
+/**
+ * hlist_bl_for_each_entry      - iterate over list of given type
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ *
+ */
+#define hlist_bl_for_each_entry(tpos, pos, head, member)                \
+        for (pos = hlist_bl_first(head);                                \
+             pos &&                                                     \
+                ({ tpos = hlist_bl_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = pos->next)
+
+/**
+ * hlist_bl_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
+ * @n:          another &struct hlist_node to use as temporary storage
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_bl_for_each_entry_safe(tpos, pos, n, head, member)         \
+        for (pos = hlist_bl_first(head);                                 \
+             pos && ({ n = pos->next; 1; }) &&                           \
+                ({ tpos = hlist_bl_entry(pos, typeof(*tpos), member); 1;}); \
+             pos = n)
+
+#endif
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 5e7a59408dd4..1869ea24a739 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -13,6 +13,7 @@
 #include <linux/list.h>
 #include <linux/nodemask.h>
 #include <linux/spinlock.h>
+#include <linux/seqlock.h>
 #include <asm/atomic.h>
 
 struct super_block;
@@ -46,12 +47,24 @@ struct mnt_namespace;
 
 #define MNT_INTERNAL    0x4000
 
+struct mnt_pcp {
+        int mnt_count;
+        int mnt_writers;
+};
+
 struct vfsmount {
         struct list_head mnt_hash;
         struct vfsmount *mnt_parent;    /* fs we are mounted on */
         struct dentry *mnt_mountpoint;  /* dentry of mountpoint */
         struct dentry *mnt_root;        /* root of the mounted tree */
         struct super_block *mnt_sb;     /* pointer to superblock */
+#ifdef CONFIG_SMP
+        struct mnt_pcp __percpu *mnt_pcp;
+        atomic_t mnt_longrefs;
+#else
+        int mnt_count;
+        int mnt_writers;
+#endif
         struct list_head mnt_mounts;    /* list of children, anchored here */
         struct list_head mnt_child;     /* and going through their mnt_child */
         int mnt_flags;
@@ -70,57 +83,25 @@ struct vfsmount {
         struct mnt_namespace *mnt_ns;   /* containing namespace */
         int mnt_id;                     /* mount identifier */
         int mnt_group_id;               /* peer group identifier */
-        /*
-         * We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
-         * to let these frequently modified fields in a separate cache line
-         * (so that reads of mnt_flags wont ping-pong on SMP machines)
-         */
-        atomic_t mnt_count;
         int mnt_expiry_mark;            /* true if marked for expiry */
         int mnt_pinned;
         int mnt_ghosts;
-#ifdef CONFIG_SMP
-        int __percpu *mnt_writers;
-#else
-        int mnt_writers;
-#endif
 };
 
-static inline int *get_mnt_writers_ptr(struct vfsmount *mnt)
-{
-#ifdef CONFIG_SMP
-        return mnt->mnt_writers;
-#else
-        return &mnt->mnt_writers;
-#endif
-}
-
-static inline struct vfsmount *mntget(struct vfsmount *mnt)
-{
-        if (mnt)
-                atomic_inc(&mnt->mnt_count);
-        return mnt;
-}
-
 struct file; /* forward dec */
 
 extern int mnt_want_write(struct vfsmount *mnt);
 extern int mnt_want_write_file(struct file *file);
 extern int mnt_clone_write(struct vfsmount *mnt);
 extern void mnt_drop_write(struct vfsmount *mnt);
-extern void mntput_no_expire(struct vfsmount *mnt);
+extern void mntput(struct vfsmount *mnt);
+extern struct vfsmount *mntget(struct vfsmount *mnt);
+extern void mntput_long(struct vfsmount *mnt);
+extern struct vfsmount *mntget_long(struct vfsmount *mnt);
 extern void mnt_pin(struct vfsmount *mnt);
 extern void mnt_unpin(struct vfsmount *mnt);
 extern int __mnt_is_readonly(struct vfsmount *mnt);
 
-static inline void mntput(struct vfsmount *mnt)
-{
-        if (mnt) {
-                mnt->mnt_expiry_mark = 0;
-                mntput_no_expire(mnt);
-        }
-}
-
 extern struct vfsmount *do_kern_mount(const char *fstype, int flags,
                                       const char *name, void *data);
 
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 05b441d93642..18d06add0a40 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -19,7 +19,10 @@ struct nameidata {
         struct path     path;
         struct qstr     last;
         struct path     root;
+        struct file     *file;
+        struct inode    *inode; /* path.dentry.d_inode */
         unsigned int    flags;
+        unsigned        seq;
         int             last_type;
         unsigned        depth;
         char *saved_names[MAX_NESTED_LINKS + 1];
@@ -41,14 +44,15 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
  *  - require a directory
  *  - ending slashes ok even for nonexistent files
  *  - internal "there are more path components" flag
- *  - locked when lookup done with dcache_lock held
  *  - dentry cache is untrusted; force a real lookup
  */
-#define LOOKUP_FOLLOW            1
-#define LOOKUP_DIRECTORY         2
-#define LOOKUP_CONTINUE          4
-#define LOOKUP_PARENT           16
-#define LOOKUP_REVAL            64
+#define LOOKUP_FOLLOW           0x0001
+#define LOOKUP_DIRECTORY        0x0002
+#define LOOKUP_CONTINUE         0x0004
+
+#define LOOKUP_PARENT           0x0010
+#define LOOKUP_REVAL            0x0020
+#define LOOKUP_RCU              0x0040
 /*
  * Intent data
  */
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index ef663061d5ac..1c27f201c856 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -184,13 +184,13 @@ struct ncp_entry_info {
         __u8                    file_handle[6];
 };
 
-static inline struct ncp_server *NCP_SBP(struct super_block *sb)
+static inline struct ncp_server *NCP_SBP(const struct super_block *sb)
 {
         return sb->s_fs_info;
 }
 
 #define NCP_SERVER(inode)       NCP_SBP((inode)->i_sb)
-static inline struct ncp_inode_info *NCP_FINFO(struct inode *inode)
+static inline struct ncp_inode_info *NCP_FINFO(const struct inode *inode)
 {
         return container_of(inode, struct ncp_inode_info, vfs_inode);
 }
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 29d504d5d1c3..0779bb8f95be 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -351,7 +351,7 @@ extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
 extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
-extern int nfs_permission(struct inode *, int);
+extern int nfs_permission(struct inode *, int, unsigned int);
 extern int nfs_open(struct inode *, struct file *);
 extern int nfs_release(struct inode *, struct file *);
 extern int nfs_attribute_timeout(struct inode *inode);
diff --git a/include/linux/path.h b/include/linux/path.h
index edc98dec6266..a581e8c06533 100644
--- a/include/linux/path.h
+++ b/include/linux/path.h
@@ -10,7 +10,9 @@ struct path {
 };
 
 extern void path_get(struct path *);
+extern void path_get_long(struct path *);
 extern void path_put(struct path *);
+extern void path_put_long(struct path *);
 
 static inline int path_equal(const struct path *path1, const struct path *path2)
 {
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 67608161df6b..d68283a898bb 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -108,6 +108,25 @@ static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
         return acl;
 }
 
+static inline int negative_cached_acl(struct inode *inode, int type)
+{
+        struct posix_acl **p, *acl;
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                p = &inode->i_acl;
+                break;
+        case ACL_TYPE_DEFAULT:
+                p = &inode->i_default_acl;
+                break;
+        default:
+                BUG();
+        }
+        acl = ACCESS_ONCE(*p);
+        if (acl)
+                return 0;
+        return 1;
+}
+
 static inline void set_cached_acl(struct inode *inode,
                                   int type,
                                   struct posix_acl *acl)
diff --git a/include/linux/rculist_bl.h b/include/linux/rculist_bl.h
new file mode 100644
index 000000000000..b872b493724d
--- /dev/null
+++ b/include/linux/rculist_bl.h
@@ -0,0 +1,127 @@
+#ifndef _LINUX_RCULIST_BL_H
+#define _LINUX_RCULIST_BL_H
+
+/*
+ * RCU-protected bl list version. See include/linux/list_bl.h.
+ */
+#include <linux/list_bl.h>
+#include <linux/rcupdate.h>
+
+static inline void hlist_bl_set_first_rcu(struct hlist_bl_head *h,
+                                        struct hlist_bl_node *n)
+{
+        LIST_BL_BUG_ON((unsigned long)n & LIST_BL_LOCKMASK);
+        LIST_BL_BUG_ON(!((unsigned long)h->first & LIST_BL_LOCKMASK));
+        rcu_assign_pointer(h->first,
+                (struct hlist_bl_node *)((unsigned long)n | LIST_BL_LOCKMASK));
+}
+
+static inline struct hlist_bl_node *hlist_bl_first_rcu(struct hlist_bl_head *h)
+{
+        return (struct hlist_bl_node *)
+                ((unsigned long)rcu_dereference(h->first) & ~LIST_BL_LOCKMASK);
+}
+
+/**
+ * hlist_bl_del_init_rcu - deletes entry from hash list with re-initialization
+ * @n: the element to delete from the hash list.
+ *
+ * Note: hlist_bl_unhashed() on the node returns true after this. It is
+ * useful for RCU based read lockfree traversal if the writer side
+ * must know if the list entry is still hashed or already unhashed.
+ *
+ * In particular, it means that we can not poison the forward pointers
+ * that may still be used for walking the hash list and we can only
+ * zero the pprev pointer so list_unhashed() will return true after
+ * this.
+ *
+ * The caller must take whatever precautions are necessary (such as
+ * holding appropriate locks) to avoid racing with another
+ * list-mutation primitive, such as hlist_bl_add_head_rcu() or
+ * hlist_bl_del_rcu(), running on this same list.  However, it is
+ * perfectly legal to run concurrently with the _rcu list-traversal
+ * primitives, such as hlist_bl_for_each_entry_rcu().
+ */
+static inline void hlist_bl_del_init_rcu(struct hlist_bl_node *n)
+{
+        if (!hlist_bl_unhashed(n)) {
+                __hlist_bl_del(n);
+                n->pprev = NULL;
+        }
+}
+
+/**
+ * hlist_bl_del_rcu - deletes entry from hash list without re-initialization
+ * @n: the element to delete from the hash list.
+ *
+ * Note: hlist_bl_unhashed() on entry does not return true after this,
+ * the entry is in an undefined state. It is useful for RCU based
+ * lockfree traversal.
+ *
+ * In particular, it means that we can not poison the forward
+ * pointers that may still be used for walking the hash list.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as hlist_bl_add_head_rcu()
+ * or hlist_bl_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * hlist_bl_for_each_entry().
+ */
+static inline void hlist_bl_del_rcu(struct hlist_bl_node *n)
+{
+        __hlist_bl_del(n);
+        n->pprev = LIST_POISON2;
+}
+
+/**
+ * hlist_bl_add_head_rcu
+ * @n: the element to add to the hash list.
+ * @h: the list to add to.
+ *
+ * Description:
+ * Adds the specified element to the specified hlist_bl,
+ * while permitting racing traversals.
+ *
+ * The caller must take whatever precautions are necessary
+ * (such as holding appropriate locks) to avoid racing
+ * with another list-mutation primitive, such as hlist_bl_add_head_rcu()
+ * or hlist_bl_del_rcu(), running on this same list.
+ * However, it is perfectly legal to run concurrently with
+ * the _rcu list-traversal primitives, such as
+ * hlist_bl_for_each_entry_rcu(), used to prevent memory-consistency
+ * problems on Alpha CPUs.  Regardless of the type of CPU, the
+ * list-traversal primitive must be guarded by rcu_read_lock().
+ */
+static inline void hlist_bl_add_head_rcu(struct hlist_bl_node *n,
+                                        struct hlist_bl_head *h)
+{
+        struct hlist_bl_node *first;
+
+        /* don't need hlist_bl_first_rcu because we're under lock */
+        first = hlist_bl_first(h);
+
+        n->next = first;
+        if (first)
+                first->pprev = &n->next;
+        n->pprev = &h->first;
+
+        /* need _rcu because we can have concurrent lock free readers */
+        hlist_bl_set_first_rcu(h, n);
+}
+/**
+ * hlist_bl_for_each_entry_rcu - iterate over rcu list of given type
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_bl_node to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_bl_node within the struct.
+ *
+ */
+#define hlist_bl_for_each_entry_rcu(tpos, pos, head, member)            \
+        for (pos = hlist_bl_first_rcu(head);                            \
+                pos &&                                                  \
+                ({ tpos = hlist_bl_entry(pos, typeof(*tpos), member); 1; }); \
+                pos = rcu_dereference_raw(pos->next))
+
+#endif
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index b2cf2089769b..3b94c91f20a6 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -41,7 +41,7 @@ int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
 int reiserfs_lookup_privroot(struct super_block *sb);
 int reiserfs_delete_xattrs(struct inode *inode);
 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
-int reiserfs_permission(struct inode *inode, int mask);
+int reiserfs_permission(struct inode *inode, int mask, unsigned int flags);
 
 #ifdef CONFIG_REISERFS_FS_XATTR
 #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
diff --git a/include/linux/security.h b/include/linux/security.h
index d47a4c24b3e4..1ac42475ea08 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -457,7 +457,6 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      called when the actual read/write operations are performed.
  *      @inode contains the inode structure to check.
  *      @mask contains the permission mask.
- *      @nd contains the nameidata (may be NULL).
  *      Return 0 if permission is granted.
  * @inode_setattr:
  *      Check permission before setting file attributes.  Note that the kernel
@@ -1713,6 +1712,7 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
 int security_inode_readlink(struct dentry *dentry);
 int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
 int security_inode_permission(struct inode *inode, int mask);
+int security_inode_exec_permission(struct inode *inode, unsigned int flags);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
 int security_inode_setxattr(struct dentry *dentry, const char *name,
@@ -2102,6 +2102,12 @@ static inline int security_inode_permission(struct inode *inode, int mask)
         return 0;
 }
 
+static inline int security_inode_exec_permission(struct inode *inode,
+                                                  unsigned int flags)
+{
+        return 0;
+}
+
 static inline int security_inode_setattr(struct dentry *dentry,
                                           struct iattr *attr)
 {
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index 632205ccc25d..e98cd2e57194 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -107,7 +107,7 @@ static __always_inline int read_seqretry(const seqlock_t *sl, unsigned start)
 {
         smp_rmb();
 
-        return (sl->sequence != start);
+        return unlikely(sl->sequence != start);
 }
 
 
@@ -125,14 +125,25 @@ typedef struct seqcount {
 #define SEQCNT_ZERO { 0 }
 #define seqcount_init(x)        do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)
 
-/* Start of read using pointer to a sequence counter only.  */
-static inline unsigned read_seqcount_begin(const seqcount_t *s)
+/**
+ * __read_seqcount_begin - begin a seq-read critical section (without barrier)
+ * @s: pointer to seqcount_t
+ * Returns: count to be passed to read_seqcount_retry
+ *
+ * __read_seqcount_begin is like read_seqcount_begin, but has no smp_rmb()
+ * barrier. Callers should ensure that smp_rmb() or equivalent ordering is
+ * provided before actually loading any of the variables that are to be
+ * protected in this critical section.
+ *
+ * Use carefully, only in critical code, and comment how the barrier is
+ * provided.
+ */
+static inline unsigned __read_seqcount_begin(const seqcount_t *s)
 {
         unsigned ret;
 
 repeat:
         ret = s->sequence;
-        smp_rmb();
         if (unlikely(ret & 1)) {
                 cpu_relax();
                 goto repeat;
@@ -140,14 +151,56 @@ repeat:
         return ret;
 }
 
-/*
- * Test if reader processed invalid data because sequence number has changed.
+/**
+ * read_seqcount_begin - begin a seq-read critical section
+ * @s: pointer to seqcount_t
+ * Returns: count to be passed to read_seqcount_retry
+ *
+ * read_seqcount_begin opens a read critical section of the given seqcount.
+ * Validity of the critical section is tested by checking read_seqcount_retry
+ * function.
+ */
+static inline unsigned read_seqcount_begin(const seqcount_t *s)
+{
+        unsigned ret = __read_seqcount_begin(s);
+        smp_rmb();
+        return ret;
+}
+
+/**
+ * __read_seqcount_retry - end a seq-read critical section (without barrier)
+ * @s: pointer to seqcount_t
+ * @start: count, from read_seqcount_begin
+ * Returns: 1 if retry is required, else 0
+ *
+ * __read_seqcount_retry is like read_seqcount_retry, but has no smp_rmb()
+ * barrier. Callers should ensure that smp_rmb() or equivalent ordering is
+ * provided before actually loading any of the variables that are to be
+ * protected in this critical section.
+ *
+ * Use carefully, only in critical code, and comment how the barrier is
+ * provided.
+ */
+static inline int __read_seqcount_retry(const seqcount_t *s, unsigned start)
+{
+        return unlikely(s->sequence != start);
+}
+
+/**
+ * read_seqcount_retry - end a seq-read critical section
+ * @s: pointer to seqcount_t
+ * @start: count, from read_seqcount_begin
+ * Returns: 1 if retry is required, else 0
+ *
+ * read_seqcount_retry closes a read critical section of the given seqcount.
+ * If the critical section was invalid, it must be ignored (and typically
+ * retried).
  */
 static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
 {
         smp_rmb();
 
-        return s->sequence != start;
+        return __read_seqcount_retry(s, start);
 }
 
 
@@ -167,6 +220,19 @@ static inline void write_seqcount_end(seqcount_t *s)
         s->sequence++;
 }
 
+/**
+ * write_seqcount_barrier - invalidate in-progress read-side seq operations
+ * @s: pointer to seqcount_t
+ *
+ * After write_seqcount_barrier, no read-side seq operations will complete
+ * successfully and see data older than this.
+ */
+static inline void write_seqcount_barrier(seqcount_t *s)
+{
+        smp_wmb();
+        s->sequence+=2;
+}
+
 /*
  * Possible sw/hw IRQ protected versions of the interfaces.
  */
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 59260e21bdf5..fa9086647eb7 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -106,8 +106,6 @@ int kmem_cache_shrink(struct kmem_cache *);
 void kmem_cache_free(struct kmem_cache *, void *);
 unsigned int kmem_cache_size(struct kmem_cache *);
 const char *kmem_cache_name(struct kmem_cache *);
-int kern_ptr_validate(const void *ptr, unsigned long size);
-int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
 
 /*
  * Please use this macro to create slab caches. Simply specify the
diff --git a/include/linux/usb.h b/include/linux/usb.h
index a28eb2592577..bd69b65f3356 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -20,6 +20,7 @@
 #include <linux/completion.h>   /* for struct completion */
 #include <linux/sched.h>        /* for current && schedule_timeout */
 #include <linux/mutex.h>        /* for struct mutex */
+#include <linux/pm_runtime.h>   /* for runtime PM */
 
 struct usb_device;
 struct usb_driver;
@@ -411,8 +412,6 @@ struct usb_tt;
  * @quirks: quirks of the whole device
  * @urbnum: number of URBs submitted for the whole device
  * @active_duration: total time device is not suspended
- * @last_busy: time of last use
- * @autosuspend_delay: in jiffies
  * @connect_time: time device was first connected
  * @do_remote_wakeup:  remote wakeup should be enabled
  * @reset_resume: needs reset instead of resume
@@ -485,8 +484,6 @@ struct usb_device {
         unsigned long active_duration;
 
 #ifdef CONFIG_PM
-        unsigned long last_busy;
-        int autosuspend_delay;
         unsigned long connect_time;
 
         unsigned do_remote_wakeup:1;
@@ -531,7 +528,7 @@ extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
 
 static inline void usb_mark_last_busy(struct usb_device *udev)
 {
-        udev->last_busy = jiffies;
+        pm_runtime_mark_last_busy(&udev->dev);
 }
 
 #else
diff --git a/include/linux/usb/ch11.h b/include/linux/usb/ch11.h
index 119194c85d10..10ec0699bea4 100644
--- a/include/linux/usb/ch11.h
+++ b/include/linux/usb/ch11.h
@@ -28,6 +28,13 @@
 #define HUB_STOP_TT             11
 
 /*
+ * Hub class additional requests defined by USB 3.0 spec
+ * See USB 3.0 spec Table 10-6
+ */
+#define HUB_SET_DEPTH           12
+#define HUB_GET_PORT_ERR_COUNT  13
+
+/*
  * Hub Class feature numbers
  * See USB 2.0 spec Table 11-17
  */
@@ -56,6 +63,20 @@
 #define USB_PORT_FEAT_C_PORT_L1         23
 
 /*
+ * Port feature selectors added by USB 3.0 spec.
+ * See USB 3.0 spec Table 10-7
+ */
+#define USB_PORT_FEAT_LINK_STATE                5
+#define USB_PORT_FEAT_U1_TIMEOUT                23
+#define USB_PORT_FEAT_U2_TIMEOUT                24
+#define USB_PORT_FEAT_C_LINK_STATE              25
+#define USB_PORT_FEAT_C_CONFIG_ERR              26
+#define USB_PORT_FEAT_REMOTE_WAKE_MASK          27
+#define USB_PORT_FEAT_BH_PORT_RESET             28
+#define USB_PORT_FEAT_C_BH_PORT_RESET           29
+#define USB_PORT_FEAT_FORCE_LINKPM_ACCEPT       30
+
+/*
  * Hub Status and Hub Change results
  * See USB 2.0 spec Table 11-19 and Table 11-20
  */
@@ -84,6 +105,32 @@ struct usb_port_status {
 #define USB_PORT_STAT_SUPER_SPEED       0x8000  /* Linux-internal */
 
 /*
+ * Additions to wPortStatus bit field from USB 3.0
+ * See USB 3.0 spec Table 10-10
+ */
+#define USB_PORT_STAT_LINK_STATE        0x01e0
+#define USB_SS_PORT_STAT_POWER          0x0200
+#define USB_PORT_STAT_SPEED_5GBPS       0x0000
+/* Valid only if port is enabled */
+
+/*
+ * Definitions for PORT_LINK_STATE values
+ * (bits 5-8) in wPortStatus
+ */
+#define USB_SS_PORT_LS_U0               0x0000
+#define USB_SS_PORT_LS_U1               0x0020
+#define USB_SS_PORT_LS_U2               0x0040
+#define USB_SS_PORT_LS_U3               0x0060
+#define USB_SS_PORT_LS_SS_DISABLED      0x0080
+#define USB_SS_PORT_LS_RX_DETECT        0x00a0
+#define USB_SS_PORT_LS_SS_INACTIVE      0x00c0
+#define USB_SS_PORT_LS_POLLING          0x00e0
+#define USB_SS_PORT_LS_RECOVERY         0x0100
+#define USB_SS_PORT_LS_HOT_RESET        0x0120
+#define USB_SS_PORT_LS_COMP_MOD         0x0140
+#define USB_SS_PORT_LS_LOOPBACK         0x0160
+
+/*
  * wPortChange bit field
  * See USB 2.0 spec Table 11-22
  * Bits 0 to 4 shown, bits 5 to 15 are reserved
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index f917bbbc8901..ab461948b579 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -124,6 +124,16 @@
 #define USB_DEVICE_DEBUG_MODE           6       /* (special devices only) */
 
 /*
+ * Test Mode Selectors
+ * See USB 2.0 spec Table 9-7
+ */
+#define TEST_J          1
+#define TEST_K          2
+#define TEST_SE0_NAK    3
+#define TEST_PACKET     4
+#define TEST_FORCE_EN   5
+
+/*
  * New Feature Selectors as added by USB 3.0
  * See USB 3.0 spec Table 9-6
  */
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 0b6e751ea0b1..dd6ee49a0844 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -471,6 +471,10 @@ extern void usb_ep0_reinit(struct usb_device *);
 
 /*-------------------------------------------------------------------------*/
 
+/* class requests from USB 3.0 hub spec, table 10-5 */
+#define SetHubDepth             (0x3000 | HUB_SET_DEPTH)
+#define GetPortErrorCount       (0x8000 | HUB_GET_PORT_ERR_COUNT)
+
 /*
  * Generic bandwidth allocation constants/support
  */
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
new file mode 100644
index 000000000000..3675e03b1539
--- /dev/null
+++ b/include/linux/usb/msm_hsusb.h
@@ -0,0 +1,112 @@
+/* linux/include/asm-arm/arch-msm/hsusb.h
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Brian Swetland <swetland@google.com>
+ * Copyright (c) 2009-2010, Code Aurora Forum. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __ASM_ARCH_MSM_HSUSB_H
+#define __ASM_ARCH_MSM_HSUSB_H
+
+#include <linux/types.h>
+#include <linux/usb/otg.h>
+
+/**
+ * Supported USB modes
+ *
+ * USB_PERIPHERAL       Only peripheral mode is supported.
+ * USB_HOST             Only host mode is supported.
+ * USB_OTG              OTG mode is supported.
+ *
+ */
+enum usb_mode_type {
+        USB_NONE = 0,
+        USB_PERIPHERAL,
+        USB_HOST,
+        USB_OTG,
+};
+
+/**
+ * OTG control
+ *
+ * OTG_NO_CONTROL       Id/VBUS notifications not required. Useful in host
+ *                      only configuration.
+ * OTG_PHY_CONTROL      Id/VBUS notifications comes form USB PHY.
+ * OTG_PMIC_CONTROL     Id/VBUS notifications comes from PMIC hardware.
+ * OTG_USER_CONTROL     Id/VBUS notifcations comes from User via sysfs.
+ *
+ */
+enum otg_control_type {
+        OTG_NO_CONTROL = 0,
+        OTG_PHY_CONTROL,
+        OTG_PMIC_CONTROL,
+        OTG_USER_CONTROL,
+};
+
+/**
+ * struct msm_otg_platform_data - platform device data
+ *              for msm72k_otg driver.
+ * @phy_init_seq: PHY configuration sequence. val, reg pairs
+ *              terminated by -1.
+ * @vbus_power: VBUS power on/off routine.
+ * @power_budget: VBUS power budget in mA (0 will be treated as 500mA).
+ * @mode: Supported mode (OTG/peripheral/host).
+ * @otg_control: OTG switch controlled by user/Id pin
+ * @default_mode: Default operational mode. Applicable only if
+ *              OTG switch is controller by user.
+ *
+ */
+struct msm_otg_platform_data {
+        int *phy_init_seq;
+        void (*vbus_power)(bool on);
+        unsigned power_budget;
+        enum usb_mode_type mode;
+        enum otg_control_type otg_control;
+        enum usb_mode_type default_mode;
+        void (*setup_gpio)(enum usb_otg_state state);
+};
+
+/**
+ * struct msm_otg: OTG driver data. Shared by HCD and DCD.
+ * @otg: USB OTG Transceiver structure.
+ * @pdata: otg device platform data.
+ * @irq: IRQ number assigned for HSUSB controller.
+ * @clk: clock struct of usb_hs_clk.
+ * @pclk: clock struct of usb_hs_pclk.
+ * @phy_reset_clk: clock struct of usb_phy_clk.
+ * @core_clk: clock struct of usb_hs_core_clk.
+ * @regs: ioremapped register base address.
+ * @inputs: OTG state machine inputs(Id, SessValid etc).
+ * @sm_work: OTG state machine work.
+ * @in_lpm: indicates low power mode (LPM) state.
+ * @async_int: Async interrupt arrived.
+ *
+ */
+struct msm_otg {
+        struct otg_transceiver otg;
+        struct msm_otg_platform_data *pdata;
+        int irq;
+        struct clk *clk;
+        struct clk *pclk;
+        struct clk *phy_reset_clk;
+        struct clk *core_clk;
+        void __iomem *regs;
+#define ID              0
+#define B_SESS_VLD      1
+        unsigned long inputs;
+        struct work_struct sm_work;
+        atomic_t in_lpm;
+        int async_int;
+};
+
+#endif
diff --git a/include/linux/usb/msm_hsusb_hw.h b/include/linux/usb/msm_hsusb_hw.h
new file mode 100644
index 000000000000..b92e17349c7b
--- /dev/null
+++ b/include/linux/usb/msm_hsusb_hw.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2007 Google, Inc.
+ * Author: Brian Swetland <swetland@google.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_USB_GADGET_MSM72K_UDC_H__
+#define __LINUX_USB_GADGET_MSM72K_UDC_H__
+
+#ifdef CONFIG_ARCH_MSM7X00A
+#define USB_SBUSCFG          (MSM_USB_BASE + 0x0090)
+#else
+#define USB_AHBBURST         (MSM_USB_BASE + 0x0090)
+#define USB_AHBMODE          (MSM_USB_BASE + 0x0098)
+#endif
+#define USB_CAPLENGTH        (MSM_USB_BASE + 0x0100) /* 8 bit */
+
+#define USB_USBCMD           (MSM_USB_BASE + 0x0140)
+#define USB_PORTSC           (MSM_USB_BASE + 0x0184)
+#define USB_OTGSC            (MSM_USB_BASE + 0x01A4)
+#define USB_USBMODE          (MSM_USB_BASE + 0x01A8)
+
+#define USBCMD_RESET   2
+#define USB_USBINTR          (MSM_USB_BASE + 0x0148)
+
+#define PORTSC_PHCD            (1 << 23) /* phy suspend mode */
+#define PORTSC_PTS_MASK         (3 << 30)
+#define PORTSC_PTS_ULPI         (3 << 30)
+
+#define USB_ULPI_VIEWPORT    (MSM_USB_BASE + 0x0170)
+#define ULPI_RUN              (1 << 30)
+#define ULPI_WRITE            (1 << 29)
+#define ULPI_READ             (0 << 29)
+#define ULPI_ADDR(n)          (((n) & 255) << 16)
+#define ULPI_DATA(n)          ((n) & 255)
+#define ULPI_DATA_READ(n)     (((n) >> 8) & 255)
+
+#define ASYNC_INTR_CTRL         (1 << 29) /* Enable async interrupt */
+#define ULPI_STP_CTRL           (1 << 30) /* Block communication with PHY */
+
+/* OTG definitions */
+#define OTGSC_INTSTS_MASK       (0x7f << 16)
+#define OTGSC_ID                (1 << 8)
+#define OTGSC_BSV               (1 << 11)
+#define OTGSC_IDIS              (1 << 16)
+#define OTGSC_BSVIS             (1 << 19)
+#define OTGSC_IDIE              (1 << 24)
+#define OTGSC_BSVIE             (1 << 27)
+
+#endif /* __LINUX_USB_GADGET_MSM72K_UDC_H__ */
diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
index 2387f9fc8138..eb505250940a 100644
--- a/include/linux/usb/musb.h
+++ b/include/linux/usb/musb.h
@@ -3,7 +3,7 @@
  * Inventra (Multidrop) Highspeed Dual-Role Controllers:  (M)HDRC.
  *
  * Board initialization should put one of these into dev->platform_data,
- * probably on some platform_device named "musb_hdrc".  It encapsulates
+ * probably on some platform_device named "musb-hdrc".  It encapsulates
  * key configuration differences between boards.
  */
 
@@ -120,14 +120,14 @@ struct musb_hdrc_platform_data {
         /* Power the device on or off */
         int             (*set_power)(int state);
 
-        /* Turn device clock on or off */
-        int             (*set_clock)(struct clk *clock, int is_on);
-
         /* MUSB configuration-specific details */
         struct musb_hdrc_config *config;
 
         /* Architecture specific board data     */
         void            *board_data;
+
+        /* Platform specific struct musb_ops pointer */
+        const void      *platform_ops;
 };
 
 
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 0a5b3711e502..a1a1e7a73ec9 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -116,7 +116,7 @@ struct otg_transceiver {
 /* for board-specific init logic */
 extern int otg_set_transceiver(struct otg_transceiver *);
 
-#if defined(CONFIG_NOP_USB_XCEIV) || defined(CONFIG_NOP_USB_XCEIV_MODULE)
+#if defined(CONFIG_NOP_USB_XCEIV) || (defined(CONFIG_NOP_USB_XCEIV_MODULE) && defined(MODULE))
 /* sometimes transceivers are accessed only through e.g. ULPI */
 extern void usb_nop_xceiv_register(void);
 extern void usb_nop_xceiv_unregister(void);
diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h
index a8631acd37c3..c3e1cbcc2ad2 100644
--- a/include/scsi/iscsi_if.h
+++ b/include/scsi/iscsi_if.h
@@ -263,6 +263,7 @@ enum iscsi_err {
         ISCSI_ERR_INVALID_HOST          = ISCSI_ERR_BASE + 18,
         ISCSI_ERR_XMIT_FAILED           = ISCSI_ERR_BASE + 19,
         ISCSI_ERR_TCP_CONN_CLOSE        = ISCSI_ERR_BASE + 20,
+        ISCSI_ERR_SCSI_EH_SESSION_RST   = ISCSI_ERR_BASE + 21,
 };
 
 /*
diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h
index 5c4c1678f7be..f53c8e31d5fb 100644
--- a/include/scsi/libfc.h
+++ b/include/scsi/libfc.h
@@ -221,8 +221,8 @@ struct fc_rport_priv {
  * @InputRequests:         Number of input requests
  * @OutputRequests:        Number of output requests
  * @ControlRequests:       Number of control requests
- * @InputMegabytes:        Number of received megabytes
- * @OutputMegabytes:       Number of transmitted megabytes
+ * @InputBytes:            Number of received bytes
+ * @OutputBytes:           Number of transmitted bytes
  * @VLinkFailureCount:     Number of virtual link failures
  * @MissDiscAdvCount:      Number of missing FIP discovery advertisement
  */
@@ -241,8 +241,8 @@ struct fcoe_dev_stats {
         u64             InputRequests;
         u64             OutputRequests;
         u64             ControlRequests;
-        u64             InputMegabytes;
-        u64             OutputMegabytes;
+        u64             InputBytes;
+        u64             OutputBytes;
         u64             VLinkFailureCount;
         u64             MissDiscAdvCount;
 };
@@ -263,7 +263,6 @@ struct fc_seq_els_data {
  * struct fc_fcp_pkt - FCP request structure (one for each scsi_cmnd request)
  * @lp:              The associated local port
  * @state:           The state of the I/O
- * @tgt_flags:       Target's flags
  * @ref_cnt:         Reference count
  * @scsi_pkt_lock:   Lock to protect the SCSI packet (must be taken before the
  *                   host_lock if both are to be held at the same time)
@@ -298,7 +297,6 @@ struct fc_fcp_pkt {
         /* Housekeeping information */
         struct fc_lport   *lp;
         u16               state;
-        u16               tgt_flags;
         atomic_t          ref_cnt;
         spinlock_t        scsi_pkt_lock;
 
diff --git a/include/scsi/libfcoe.h b/include/scsi/libfcoe.h
index 06f1b5a8ed19..feb6a94c90ea 100644
--- a/include/scsi/libfcoe.h
+++ b/include/scsi/libfcoe.h
@@ -92,10 +92,12 @@ enum fip_state {
  * @timer_work:    &work_struct for doing keep-alives and resets.
  * @recv_work:     &work_struct for receiving FIP frames.
  * @fip_recv_list: list of received FIP frames.
+ * @flogi_req:     clone of FLOGI request sent
  * @rnd_state:     state for pseudo-random number generator.
  * @port_id:       proposed or selected local-port ID.
  * @user_mfs:      configured maximum FC frame size, including FC header.
  * @flogi_oxid:    exchange ID of most recent fabric login.
+ * @flogi_req_send: send of FLOGI requested
  * @flogi_count:   number of FLOGI attempts in AUTO mode.
  * @map_dest:      use the FC_MAP mode for destination MAC addresses.
  * @spma:          supports SPMA server-provided MACs mode
@@ -106,6 +108,7 @@ enum fip_state {
  * @update_mac:    LLD-supplied function to handle changes to MAC addresses.
  * @get_src_addr:  LLD-supplied function to supply a source MAC address.
  * @ctlr_mutex:    lock protecting this structure.
+ * @ctlr_lock:     spinlock covering flogi_req
  *
  * This structure is used by all FCoE drivers.  It contains information
  * needed by all FCoE low-level drivers (LLDs) as well as internal state
@@ -126,12 +129,14 @@ struct fcoe_ctlr {
         struct work_struct timer_work;
         struct work_struct recv_work;
         struct sk_buff_head fip_recv_list;
+        struct sk_buff *flogi_req;
 
         struct rnd_state rnd_state;
         u32 port_id;
 
         u16 user_mfs;
         u16 flogi_oxid;
+        u8 flogi_req_send;
         u8 flogi_count;
         u8 map_dest;
         u8 spma;
@@ -143,6 +148,7 @@ struct fcoe_ctlr {
         void (*update_mac)(struct fc_lport *, u8 *addr);
         u8 * (*get_src_addr)(struct fc_lport *);
         struct mutex ctlr_mutex;
+        spinlock_t ctlr_lock;
 };
 
 /**
@@ -155,6 +161,7 @@ struct fcoe_ctlr {
  * @fcf_mac:     Ethernet address of the FCF
  * @vfid:        virtual fabric ID
  * @pri:         selection priority, smaller values are better
+ * @flogi_sent:  current FLOGI sent to this FCF
  * @flags:       flags received from advertisement
  * @fka_period:  keep-alive period, in jiffies
  *
@@ -176,6 +183,7 @@ struct fcoe_fcf {
         u8 fcf_mac[ETH_ALEN];
 
         u8 pri;
+        u8 flogi_sent;
         u16 flags;
         u32 fka_period;
         u8 fd_flags:1;
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h
index b81d969ddc67..748382b32b52 100644
--- a/include/scsi/libiscsi.h
+++ b/include/scsi/libiscsi.h
@@ -89,6 +89,7 @@ enum {
         ISCSI_TASK_RUNNING,
         ISCSI_TASK_ABRT_TMF,            /* aborted due to TMF */
         ISCSI_TASK_ABRT_SESS_RECOV,     /* aborted due to session recovery */
+        ISCSI_TASK_REQUEUE_SCSIQ,       /* qcmd requeueing to scsi-ml */
 };
 
 struct iscsi_r2t_info {
@@ -341,7 +342,7 @@ extern int iscsi_eh_abort(struct scsi_cmnd *sc);
 extern int iscsi_eh_recover_target(struct scsi_cmnd *sc);
 extern int iscsi_eh_session_reset(struct scsi_cmnd *sc);
 extern int iscsi_eh_device_reset(struct scsi_cmnd *sc);
-extern int iscsi_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *sc);
+extern int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc);
 
 /*
  * iSCSI host helpers.
@@ -419,6 +420,7 @@ extern struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *, itt_t);
 extern struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *, itt_t);
 extern void iscsi_requeue_task(struct iscsi_task *task);
 extern void iscsi_put_task(struct iscsi_task *task);
+extern void __iscsi_put_task(struct iscsi_task *task);
 extern void __iscsi_get_task(struct iscsi_task *task);
 extern void iscsi_complete_scsi_task(struct iscsi_task *task,
                                      uint32_t exp_cmdsn, uint32_t max_cmdsn);
diff --git a/include/scsi/libsas.h b/include/scsi/libsas.h
index 90ce527ecf3d..8f6bb9c7f3eb 100644
--- a/include/scsi/libsas.h
+++ b/include/scsi/libsas.h
@@ -361,6 +361,8 @@ struct sas_ha_struct {
         /* The class calls this to send a task for execution. */
         int lldd_max_execute_num;
         int lldd_queue_size;
+        int strict_wide_ports; /* both sas_addr and attached_sas_addr must match
+                                * their siblings when forming wide ports */
 
         /* LLDD calls these to notify the class of an event. */
         void (*notify_ha_event)(struct sas_ha_struct *, enum ha_event);
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index 216af8538cc9..1651fef18831 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
@@ -115,33 +115,61 @@ struct scsi_cmnd;
 #define PERSISTENT_RESERVE_OUT 0x5f
 #define VARIABLE_LENGTH_CMD   0x7f
 #define REPORT_LUNS           0xa0
+#define SECURITY_PROTOCOL_IN  0xa2
 #define MAINTENANCE_IN        0xa3
 #define MAINTENANCE_OUT       0xa4
 #define MOVE_MEDIUM           0xa5
 #define EXCHANGE_MEDIUM       0xa6
 #define READ_12               0xa8
 #define WRITE_12              0xaa
+#define READ_MEDIA_SERIAL_NUMBER 0xab
 #define WRITE_VERIFY_12       0xae
 #define VERIFY_12             0xaf
 #define SEARCH_HIGH_12        0xb0
 #define SEARCH_EQUAL_12       0xb1
 #define SEARCH_LOW_12         0xb2
+#define SECURITY_PROTOCOL_OUT 0xb5
 #define READ_ELEMENT_STATUS   0xb8
 #define SEND_VOLUME_TAG       0xb6
 #define WRITE_LONG_2          0xea
+#define EXTENDED_COPY         0x83
+#define RECEIVE_COPY_RESULTS  0x84
+#define ACCESS_CONTROL_IN     0x86
+#define ACCESS_CONTROL_OUT    0x87
 #define READ_16               0x88
 #define WRITE_16              0x8a
+#define READ_ATTRIBUTE        0x8c
+#define WRITE_ATTRIBUTE       0x8d
 #define VERIFY_16             0x8f
 #define WRITE_SAME_16         0x93
 #define SERVICE_ACTION_IN     0x9e
 /* values for service action in */
 #define SAI_READ_CAPACITY_16  0x10
 #define SAI_GET_LBA_STATUS    0x12
+/* values for VARIABLE_LENGTH_CMD service action codes
+ * see spc4r17 Section D.3.5, table D.7 and D.8 */
+#define VLC_SA_RECEIVE_CREDENTIAL 0x1800
 /* values for maintenance in */
+#define MI_REPORT_IDENTIFYING_INFORMATION 0x05
 #define MI_REPORT_TARGET_PGS  0x0a
+#define MI_REPORT_ALIASES     0x0b
+#define MI_REPORT_SUPPORTED_OPERATION_CODES 0x0c
+#define MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS 0x0d
+#define MI_REPORT_PRIORITY   0x0e
+#define MI_REPORT_TIMESTAMP  0x0f
+#define MI_MANAGEMENT_PROTOCOL_IN 0x10
 /* values for maintenance out */
+#define MO_SET_IDENTIFYING_INFORMATION 0x06
 #define MO_SET_TARGET_PGS     0x0a
+#define MO_CHANGE_ALIASES     0x0b
+#define MO_SET_PRIORITY       0x0e
+#define MO_SET_TIMESTAMP      0x0f
+#define MO_MANAGEMENT_PROTOCOL_OUT 0x10
 /* values for variable length command */
+#define XDREAD_32             0x03
+#define XDWRITE_32            0x04
+#define XPWRITE_32            0x06
+#define XDWRITEREAD_32        0x07
 #define READ_32               0x09
 #define VERIFY_32             0x0a
 #define WRITE_32              0x0b
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 035f4399edbc..14fb6d67e6a3 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -237,11 +237,18 @@ static struct inode *mqueue_alloc_inode(struct super_block *sb)
         return &ei->vfs_inode;
 }
 
-static void mqueue_destroy_inode(struct inode *inode)
+static void mqueue_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(mqueue_inode_cachep, MQUEUE_I(inode));
 }
 
+static void mqueue_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, mqueue_i_callback);
+}
+
 static void mqueue_evict_inode(struct inode *inode)
 {
         struct mqueue_inode_info *info;
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 66a416b42c18..51cddc11cd85 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -763,6 +763,8 @@ EXPORT_SYMBOL_GPL(cgroup_unlock);
  * -> cgroup_mkdir.
  */
 
+static struct dentry *cgroup_lookup(struct inode *dir,
+                        struct dentry *dentry, struct nameidata *nd);
 static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry);
 static int cgroup_populate_dir(struct cgroup *cgrp);
@@ -874,25 +876,29 @@ static void cgroup_clear_directory(struct dentry *dentry)
         struct list_head *node;
 
         BUG_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
-        spin_lock(&dcache_lock);
+        spin_lock(&dentry->d_lock);
         node = dentry->d_subdirs.next;
         while (node != &dentry->d_subdirs) {
                 struct dentry *d = list_entry(node, struct dentry, d_u.d_child);
+
+                spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
                 list_del_init(node);
                 if (d->d_inode) {
                         /* This should never be called on a cgroup
                          * directory with child cgroups */
                         BUG_ON(d->d_inode->i_mode & S_IFDIR);
-                        d = dget_locked(d);
-                        spin_unlock(&dcache_lock);
+                        dget_dlock(d);
+                        spin_unlock(&d->d_lock);
+                        spin_unlock(&dentry->d_lock);
                         d_delete(d);
                         simple_unlink(dentry->d_inode, d);
                         dput(d);
-                        spin_lock(&dcache_lock);
-                }
+                        spin_lock(&dentry->d_lock);
+                } else
+                        spin_unlock(&d->d_lock);
                 node = dentry->d_subdirs.next;
         }
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
 }
 
 /*
@@ -900,11 +906,16 @@ static void cgroup_clear_directory(struct dentry *dentry)
  */
 static void cgroup_d_remove_dir(struct dentry *dentry)
 {
+        struct dentry *parent;
+
         cgroup_clear_directory(dentry);
 
-        spin_lock(&dcache_lock);
+        parent = dentry->d_parent;
+        spin_lock(&parent->d_lock);
+        spin_lock(&dentry->d_lock);
         list_del_init(&dentry->d_u.d_child);
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
+        spin_unlock(&parent->d_lock);
         remove_dir(dentry);
 }
 
@@ -2180,7 +2191,7 @@ static const struct file_operations cgroup_file_operations = {
 };
 
 static const struct inode_operations cgroup_dir_inode_operations = {
-        .lookup = simple_lookup,
+        .lookup = cgroup_lookup,
         .mkdir = cgroup_mkdir,
         .rmdir = cgroup_rmdir,
         .rename = cgroup_rename,
@@ -2196,13 +2207,29 @@ static inline struct cftype *__file_cft(struct file *file)
         return __d_cft(file->f_dentry);
 }
 
-static int cgroup_create_file(struct dentry *dentry, mode_t mode,
-                                struct super_block *sb)
+static int cgroup_delete_dentry(const struct dentry *dentry)
+{
+        return 1;
+}
+
+static struct dentry *cgroup_lookup(struct inode *dir,
+                        struct dentry *dentry, struct nameidata *nd)
 {
-        static const struct dentry_operations cgroup_dops = {
+        static const struct dentry_operations cgroup_dentry_operations = {
+                .d_delete = cgroup_delete_dentry,
                 .d_iput = cgroup_diput,
         };
 
+        if (dentry->d_name.len > NAME_MAX)
+                return ERR_PTR(-ENAMETOOLONG);
+        d_set_d_op(dentry, &cgroup_dentry_operations);
+        d_add(dentry, NULL);
+        return NULL;
+}
+
+static int cgroup_create_file(struct dentry *dentry, mode_t mode,
+                                struct super_block *sb)
+{
         struct inode *inode;
 
         if (!dentry)
@@ -2228,7 +2255,6 @@ static int cgroup_create_file(struct dentry *dentry, mode_t mode,
                 inode->i_size = 0;
                 inode->i_fop = &cgroup_file_operations;
         }
-        dentry->d_op = &cgroup_dops;
         d_instantiate(dentry, inode);
         dget(dentry);   /* Extra count - pin the dentry in core */
         return 0;
@@ -3638,9 +3664,7 @@ again:
         list_del(&cgrp->sibling);
         cgroup_unlock_hierarchy(cgrp->root);
 
-        spin_lock(&cgrp->dentry->d_lock);
         d = dget(cgrp->dentry);
-        spin_unlock(&d->d_lock);
 
         cgroup_d_remove_dir(d);
         dput(d);
diff --git a/mm/filemap.c b/mm/filemap.c
index 6b9aee20f242..ca389394fa2a 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -102,9 +102,6 @@
  *    ->inode_lock              (zap_pte_range->set_page_dirty)
  *    ->private_lock            (zap_pte_range->__set_page_dirty_buffers)
  *
- *  ->task->proc_lock
- *    ->dcache_lock             (proc_pid_lookup)
- *
  *  (code doesn't rely on that order, so you could switch it around)
  *  ->tasklist_lock             (memory_failure, collect_procs_ao)
  *    ->i_mmap_lock
diff --git a/mm/shmem.c b/mm/shmem.c
index 47fdeeb9d636..5ee67c990602 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2415,13 +2415,20 @@ static struct inode *shmem_alloc_inode(struct super_block *sb)
         return &p->vfs_inode;
 }
 
+static void shmem_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(shmem_inode_cachep, SHMEM_I(inode));
+}
+
 static void shmem_destroy_inode(struct inode *inode)
 {
         if ((inode->i_mode & S_IFMT) == S_IFREG) {
                 /* only struct inode is valid if it's an inline symlink */
                 mpol_free_shared_policy(&SHMEM_I(inode)->policy);
         }
-        kmem_cache_free(shmem_inode_cachep, SHMEM_I(inode));
+        call_rcu(&inode->i_rcu, shmem_i_callback);
 }
 
 static void init_once(void *foo)
diff --git a/mm/slab.c b/mm/slab.c
index b1e40dafbab3..6107f2380e08 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -2781,7 +2781,7 @@ static void slab_put_obj(struct kmem_cache *cachep, struct slab *slabp,
 /*
  * Map pages beginning at addr to the given cache and slab. This is required
  * for the slab allocator to be able to lookup the cache and slab of a
- * virtual address for kfree, ksize, kmem_ptr_validate, and slab debugging.
+ * virtual address for kfree, ksize, and slab debugging.
  */
 static void slab_map_pages(struct kmem_cache *cache, struct slab *slab,
                            void *addr)
@@ -3660,36 +3660,6 @@ void *kmem_cache_alloc_notrace(struct kmem_cache *cachep, gfp_t flags)
 EXPORT_SYMBOL(kmem_cache_alloc_notrace);
 #endif
 
-/**
- * kmem_ptr_validate - check if an untrusted pointer might be a slab entry.
- * @cachep: the cache we're checking against
- * @ptr: pointer to validate
- *
- * This verifies that the untrusted pointer looks sane;
- * it is _not_ a guarantee that the pointer is actually
- * part of the slab cache in question, but it at least
- * validates that the pointer can be dereferenced and
- * looks half-way sane.
- *
- * Currently only used for dentry validation.
- */
-int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr)
-{
-        unsigned long size = cachep->buffer_size;
-        struct page *page;
-
-        if (unlikely(!kern_ptr_validate(ptr, size)))
-                goto out;
-        page = virt_to_page(ptr);
-        if (unlikely(!PageSlab(page)))
-                goto out;
-        if (unlikely(page_get_cache(page) != cachep))
-                goto out;
-        return 1;
-out:
-        return 0;
-}
-
 #ifdef CONFIG_NUMA
 void *kmem_cache_alloc_node(struct kmem_cache *cachep, gfp_t flags, int nodeid)
 {
diff --git a/mm/slob.c b/mm/slob.c
index 617b6d6c42c7..3588eaaef726 100644
--- a/mm/slob.c
+++ b/mm/slob.c
@@ -678,11 +678,6 @@ int kmem_cache_shrink(struct kmem_cache *d)
 }
 EXPORT_SYMBOL(kmem_cache_shrink);
 
-int kmem_ptr_validate(struct kmem_cache *a, const void *b)
-{
-        return 0;
-}
-
 static unsigned int slob_ready __read_mostly;
 
 int slab_is_available(void)
diff --git a/mm/slub.c b/mm/slub.c
index bec0e355fbad..a2fe1727ed85 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -1917,17 +1917,6 @@ void kmem_cache_free(struct kmem_cache *s, void *x)
 }
 EXPORT_SYMBOL(kmem_cache_free);
 
-/* Figure out on which slab page the object resides */
-static struct page *get_object_page(const void *x)
-{
-        struct page *page = virt_to_head_page(x);
-
-        if (!PageSlab(page))
-                return NULL;
-
-        return page;
-}
-
 /*
  * Object placement in a slab is made very easy because we always start at
  * offset 0. If we tune the size of the object to the alignment then we can
@@ -2386,35 +2375,6 @@ error:
 }
 
 /*
- * Check if a given pointer is valid
- */
-int kmem_ptr_validate(struct kmem_cache *s, const void *object)
-{
-        struct page *page;
-
-        if (!kern_ptr_validate(object, s->size))
-                return 0;
-
-        page = get_object_page(object);
-
-        if (!page || s != page->slab)
-                /* No slab or wrong slab */
-                return 0;
-
-        if (!check_valid_pointer(s, page, object))
-                return 0;
-
-        /*
-         * We could also check if the object is on the slabs freelist.
-         * But this would be too expensive and it seems that the main
-         * purpose of kmem_ptr_valid() is to check if the object belongs
-         * to a certain slab.
-         */
-        return 1;
-}
-EXPORT_SYMBOL(kmem_ptr_validate);
-
-/*
  * Determine the size of a slab object
  */
 unsigned int kmem_cache_size(struct kmem_cache *s)
diff --git a/mm/util.c b/mm/util.c
index 73dac81e9f78..f126975ef23e 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -186,27 +186,6 @@ void kzfree(const void *p)
 }
 EXPORT_SYMBOL(kzfree);
 
-int kern_ptr_validate(const void *ptr, unsigned long size)
-{
-        unsigned long addr = (unsigned long)ptr;
-        unsigned long min_addr = PAGE_OFFSET;
-        unsigned long align_mask = sizeof(void *) - 1;
-
-        if (unlikely(addr < min_addr))
-                goto out;
-        if (unlikely(addr > (unsigned long)high_memory - size))
-                goto out;
-        if (unlikely(addr & align_mask))
-                goto out;
-        if (unlikely(!kern_addr_valid(addr)))
-                goto out;
-        if (unlikely(!kern_addr_valid(addr + size - 1)))
-                goto out;
-        return 1;
-out:
-        return 0;
-}
-
 /*
  * strndup_user - duplicate an existing string from user space
  * @s: The string to duplicate
diff --git a/net/socket.c b/net/socket.c
index c1663c0ff3d3..ccc576a6a508 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -262,6 +262,7 @@ static struct inode *sock_alloc_inode(struct super_block *sb)
 }
 
 
+
 static void wq_free_rcu(struct rcu_head *head)
 {
         struct socket_wq *wq = container_of(head, struct socket_wq, rcu);
@@ -360,14 +361,14 @@ static int sock_alloc_file(struct socket *sock, struct file **f, int flags)
         if (unlikely(fd < 0))
                 return fd;
 
-        path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
+        path.dentry = d_alloc_pseudo(sock_mnt->mnt_sb, &name);
         if (unlikely(!path.dentry)) {
                 put_unused_fd(fd);
                 return -ENOMEM;
         }
         path.mnt = mntget(sock_mnt);
 
-        path.dentry->d_op = &sockfs_dentry_operations;
+        d_set_d_op(path.dentry, &sockfs_dentry_operations);
         d_instantiate(path.dentry, SOCK_INODE(sock));
         SOCK_INODE(sock)->i_fop = &socket_file_ops;
 
@@ -2390,6 +2391,8 @@ EXPORT_SYMBOL(sock_unregister);
 
 static int __init sock_init(void)
 {
+        int err;
+
         /*
          *      Initialize sock SLAB cache.
          */
@@ -2406,8 +2409,15 @@ static int __init sock_init(void)
          */
 
         init_inodecache();
-        register_filesystem(&sock_fs_type);
+
+        err = register_filesystem(&sock_fs_type);
+        if (err)
+                goto out_fs;
         sock_mnt = kern_mount(&sock_fs_type);
+        if (IS_ERR(sock_mnt)) {
+                err = PTR_ERR(sock_mnt);
+                goto out_mount;
+        }
 
         /* The real protocol initialization is performed in later initcalls.
          */
@@ -2420,7 +2430,13 @@ static int __init sock_init(void)
         skb_timestamping_init();
 #endif
 
-        return 0;
+out:
+        return err;
+
+out_mount:
+        unregister_filesystem(&sock_fs_type);
+out_fs:
+        goto out;
 }
 
 core_initcall(sock_init);       /* early initcall */
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 10a17a37ec4e..09f01f41e55a 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -162,11 +162,19 @@ rpc_alloc_inode(struct super_block *sb)
 }
 
 static void
-rpc_destroy_inode(struct inode *inode)
+rpc_i_callback(struct rcu_head *head)
 {
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
         kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
 }
 
+static void
+rpc_destroy_inode(struct inode *inode)
+{
+        call_rcu(&inode->i_rcu, rpc_i_callback);
+}
+
 static int
 rpc_pipe_open(struct inode *inode, struct file *filp)
 {
@@ -430,7 +438,7 @@ void rpc_put_mount(void)
 }
 EXPORT_SYMBOL_GPL(rpc_put_mount);
 
-static int rpc_delete_dentry(struct dentry *dentry)
+static int rpc_delete_dentry(const struct dentry *dentry)
 {
         return 1;
 }
@@ -583,7 +591,7 @@ static struct dentry *__rpc_lookup_create(struct dentry *parent,
                 }
         }
         if (!dentry->d_inode)
-                dentry->d_op = &rpc_dentry_operations;
+                d_set_d_op(dentry, &rpc_dentry_operations);
 out_err:
         return dentry;
 }
diff --git a/security/security.c b/security/security.c
index e5fb07a3052d..739e40362f44 100644
--- a/security/security.c
+++ b/security/security.c
@@ -513,6 +513,15 @@ int security_inode_permission(struct inode *inode, int mask)
         return security_ops->inode_permission(inode, mask);
 }
 
+int security_inode_exec_permission(struct inode *inode, unsigned int flags)
+{
+        if (unlikely(IS_PRIVATE(inode)))
+                return 0;
+        if (flags)
+                return -ECHILD;
+        return security_ops->inode_permission(inode, MAY_EXEC);
+}
+
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
 {
         if (unlikely(IS_PRIVATE(dentry->d_inode)))
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index 073fd5b0a53a..43deac219491 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -1145,24 +1145,28 @@ static void sel_remove_entries(struct dentry *de)
 {
         struct list_head *node;
 
-        spin_lock(&dcache_lock);
+        spin_lock(&de->d_lock);
         node = de->d_subdirs.next;
         while (node != &de->d_subdirs) {
                 struct dentry *d = list_entry(node, struct dentry, d_u.d_child);
+
+                spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
                 list_del_init(node);
 
                 if (d->d_inode) {
-                        d = dget_locked(d);
-                        spin_unlock(&dcache_lock);
+                        dget_dlock(d);
+                        spin_unlock(&de->d_lock);
+                        spin_unlock(&d->d_lock);
                         d_delete(d);
                         simple_unlink(de->d_inode, d);
                         dput(d);
-                        spin_lock(&dcache_lock);
-                }
+                        spin_lock(&de->d_lock);
+                } else
+                        spin_unlock(&d->d_lock);
                 node = de->d_subdirs.next;
         }
 
-        spin_unlock(&dcache_lock);
+        spin_unlock(&de->d_lock);
 }
 
 #define BOOL_DIR_NAME "booleans"
diff --git a/security/tomoyo/realpath.c b/security/tomoyo/realpath.c
index 1d0bf8fa1922..d1e05b047715 100644
--- a/security/tomoyo/realpath.c
+++ b/security/tomoyo/realpath.c
@@ -14,6 +14,7 @@
 #include <linux/slab.h>
 #include <net/sock.h>
 #include "common.h"
+#include "../../fs/internal.h"
 
 /**
  * tomoyo_encode: Convert binary string to ascii string.