18 files changed, 205 insertions, 56 deletions

diff --git a/include/asm-generic/fcntl.h b/include/asm-generic/fcntl.h
index 0c3dd8603927..495dc8af4044 100644
--- a/include/asm-generic/fcntl.h
+++ b/include/asm-generic/fcntl.h
@@ -73,14 +73,23 @@
 #define F_SETSIG        10      /* for sockets. */
 #define F_GETSIG        11      /* for sockets. */
 #endif
+
+#ifndef CONFIG_64BIT
+#ifndef F_GETLK64
+#define F_GETLK64       12      /*  using 'struct flock64' */
+#define F_SETLK64       13
+#define F_SETLKW64      14
+#endif
+#endif
+
 #ifndef F_SETOWN_EX
-#define F_SETOWN_EX     12
-#define F_GETOWN_EX     13
+#define F_SETOWN_EX     15
+#define F_GETOWN_EX     16
 #endif
 
 #define F_OWNER_TID     0
 #define F_OWNER_PID     1
-#define F_OWNER_GID     2
+#define F_OWNER_PGRP    2
 
 struct f_owner_ex {
         int     type;
@@ -139,12 +148,6 @@ struct flock {
 
 #ifndef CONFIG_64BIT
 
-#ifndef F_GETLK64
-#define F_GETLK64       12      /*  using 'struct flock64' */
-#define F_SETLK64       13
-#define F_SETLKW64      14
-#endif
-
 #ifndef HAVE_ARCH_STRUCT_FLOCK64
 #ifndef __ARCH_FLOCK64_PAD
 #define __ARCH_FLOCK64_PAD
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
index ca1bfe90004f..93e7428156ba 100644
--- a/include/linux/ext3_fs_i.h
+++ b/include/linux/ext3_fs_i.h
@@ -137,6 +137,14 @@ struct ext3_inode_info {
          * by other means, so we have truncate_mutex.
          */
         struct mutex truncate_mutex;
+
+        /*
+         * Transactions that contain inode's metadata needed to complete
+         * fsync and fdatasync, respectively.
+         */
+        atomic_t i_sync_tid;
+        atomic_t i_datasync_tid;
+
         struct inode vfs_inode;
 };
 
diff --git a/include/linux/fb.h b/include/linux/fb.h
index a34bdf5a9d23..de9c722e7b90 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -669,12 +669,6 @@ struct fb_ops {
         /* perform fb specific mmap */
         int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
 
-        /* save current hardware state */
-        void (*fb_save_state)(struct fb_info *info);
-
-        /* restore saved state */
-        void (*fb_restore_state)(struct fb_info *info);
-
         /* get capability given var */
         void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
                             struct fb_var_screeninfo *var);
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 84d3532dd3ea..7be0c6fbe880 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -91,6 +91,8 @@ struct fscache_operation {
 #define FSCACHE_OP_WAITING      4       /* cleared when op is woken */
 #define FSCACHE_OP_EXCLUSIVE    5       /* exclusive op, other ops must wait */
 #define FSCACHE_OP_DEAD         6       /* op is now dead */
+#define FSCACHE_OP_DEC_READ_CNT 7       /* decrement object->n_reads on destruction */
+#define FSCACHE_OP_KEEP_FLAGS   0xc0    /* flags to keep when repurposing an op */
 
         atomic_t                usage;
         unsigned                debug_id;       /* debugging ID */
@@ -102,6 +104,16 @@ struct fscache_operation {
 
         /* operation releaser */
         fscache_operation_release_t release;
+
+#ifdef CONFIG_SLOW_WORK_PROC
+        const char *name;               /* operation name */
+        const char *state;              /* operation state */
+#define fscache_set_op_name(OP, N)      do { (OP)->name  = (N); } while(0)
+#define fscache_set_op_state(OP, S)     do { (OP)->state = (S); } while(0)
+#else
+#define fscache_set_op_name(OP, N)      do { } while(0)
+#define fscache_set_op_state(OP, S)     do { } while(0)
+#endif
 };
 
 extern atomic_t fscache_op_debug_id;
@@ -125,6 +137,7 @@ static inline void fscache_operation_init(struct fscache_operation *op,
         op->debug_id = atomic_inc_return(&fscache_op_debug_id);
         op->release = release;
         INIT_LIST_HEAD(&op->pend_link);
+        fscache_set_op_state(op, "Init");
 }
 
 /**
@@ -221,8 +234,10 @@ struct fscache_cache_ops {
         struct fscache_object *(*alloc_object)(struct fscache_cache *cache,
                                                struct fscache_cookie *cookie);
 
-        /* look up the object for a cookie */
-        void (*lookup_object)(struct fscache_object *object);
+        /* look up the object for a cookie
+         * - return -ETIMEDOUT to be requeued
+         */
+        int (*lookup_object)(struct fscache_object *object);
 
         /* finished looking up */
         void (*lookup_complete)(struct fscache_object *object);
@@ -297,12 +312,14 @@ struct fscache_cookie {
         atomic_t                        usage;          /* number of users of this cookie */
         atomic_t                        n_children;     /* number of children of this cookie */
         spinlock_t                      lock;
+        spinlock_t                      stores_lock;    /* lock on page store tree */
         struct hlist_head               backing_objects; /* object(s) backing this file/index */
         const struct fscache_cookie_def *def;           /* definition */
         struct fscache_cookie           *parent;        /* parent of this entry */
         void                            *netfs_data;    /* back pointer to netfs */
         struct radix_tree_root          stores;         /* pages to be stored on this cookie */
 #define FSCACHE_COOKIE_PENDING_TAG      0               /* pages tag: pending write to cache */
+#define FSCACHE_COOKIE_STORING_TAG      1               /* pages tag: writing to cache */
 
         unsigned long                   flags;
 #define FSCACHE_COOKIE_LOOKING_UP       0       /* T if non-index cookie being looked up still */
@@ -337,6 +354,7 @@ struct fscache_object {
                 FSCACHE_OBJECT_RECYCLING,       /* retiring object */
                 FSCACHE_OBJECT_WITHDRAWING,     /* withdrawing object */
                 FSCACHE_OBJECT_DEAD,            /* object is now dead */
+                FSCACHE_OBJECT__NSTATES
         } state;
 
         int                     debug_id;       /* debugging ID */
@@ -345,6 +363,7 @@ struct fscache_object {
         int                     n_obj_ops;      /* number of object ops outstanding on object */
         int                     n_in_progress;  /* number of ops in progress */
         int                     n_exclusive;    /* number of exclusive ops queued */
+        atomic_t                n_reads;        /* number of read ops in progress */
         spinlock_t              lock;           /* state and operations lock */
 
         unsigned long           lookup_jif;     /* time at which lookup started */
@@ -358,6 +377,7 @@ struct fscache_object {
 #define FSCACHE_OBJECT_EV_RELEASE       4       /* T if netfs requested object release */
 #define FSCACHE_OBJECT_EV_RETIRE        5       /* T if netfs requested object retirement */
 #define FSCACHE_OBJECT_EV_WITHDRAW      6       /* T if cache requested object withdrawal */
+#define FSCACHE_OBJECT_EVENTS_MASK      0x7f    /* mask of all events*/
 
         unsigned long           flags;
 #define FSCACHE_OBJECT_LOCK             0       /* T if object is busy being processed */
@@ -373,7 +393,11 @@ struct fscache_object {
         struct list_head        dependents;     /* FIFO of dependent objects */
         struct list_head        dep_link;       /* link in parent's dependents list */
         struct list_head        pending_ops;    /* unstarted operations on this object */
+#ifdef CONFIG_FSCACHE_OBJECT_LIST
+        struct rb_node          objlist_link;   /* link in global object list */
+#endif
         pgoff_t                 store_limit;    /* current storage limit */
+        loff_t                  store_limit_l;  /* current storage limit */
 };
 
 extern const char *fscache_object_states[];
@@ -383,6 +407,10 @@ extern const char *fscache_object_states[];
          (obj)->state >= FSCACHE_OBJECT_AVAILABLE &&          \
          (obj)->state < FSCACHE_OBJECT_DYING)
 
+#define fscache_object_is_dead(obj)                             \
+        (test_bit(FSCACHE_IOERROR, &(obj)->cache->flags) &&     \
+         (obj)->state >= FSCACHE_OBJECT_DYING)
+
 extern const struct slow_work_ops fscache_object_slow_work_ops;
 
 /**
@@ -414,6 +442,7 @@ void fscache_object_init(struct fscache_object *object,
         object->events = object->event_mask = 0;
         object->flags = 0;
         object->store_limit = 0;
+        object->store_limit_l = 0;
         object->cache = cache;
         object->cookie = cookie;
         object->parent = NULL;
@@ -422,6 +451,12 @@ void fscache_object_init(struct fscache_object *object,
 extern void fscache_object_lookup_negative(struct fscache_object *object);
 extern void fscache_obtained_object(struct fscache_object *object);
 
+#ifdef CONFIG_FSCACHE_OBJECT_LIST
+extern void fscache_object_destroy(struct fscache_object *object);
+#else
+#define fscache_object_destroy(object) do {} while(0)
+#endif
+
 /**
  * fscache_object_destroyed - Note destruction of an object in a cache
  * @cache: The cache from which the object came
@@ -460,6 +495,7 @@ static inline void fscache_object_lookup_error(struct fscache_object *object)
 static inline
 void fscache_set_store_limit(struct fscache_object *object, loff_t i_size)
 {
+        object->store_limit_l = i_size;
         object->store_limit = i_size >> PAGE_SHIFT;
         if (i_size & ~PAGE_MASK)
                 object->store_limit++;
diff --git a/include/linux/fscache.h b/include/linux/fscache.h
index 6d8ee466e0a0..595ce49288b7 100644
--- a/include/linux/fscache.h
+++ b/include/linux/fscache.h
@@ -202,6 +202,8 @@ extern int __fscache_write_page(struct fscache_cookie *, struct page *, gfp_t);
 extern void __fscache_uncache_page(struct fscache_cookie *, struct page *);
 extern bool __fscache_check_page_write(struct fscache_cookie *, struct page *);
 extern void __fscache_wait_on_page_write(struct fscache_cookie *, struct page *);
+extern bool __fscache_maybe_release_page(struct fscache_cookie *, struct page *,
+                                         gfp_t);
 
 /**
  * fscache_register_netfs - Register a filesystem as desiring caching services
@@ -615,4 +617,29 @@ void fscache_wait_on_page_write(struct fscache_cookie *cookie,
                 __fscache_wait_on_page_write(cookie, page);
 }
 
+/**
+ * fscache_maybe_release_page - Consider releasing a page, cancelling a store
+ * @cookie: The cookie representing the cache object
+ * @page: The netfs page that is being cached.
+ * @gfp: The gfp flags passed to releasepage()
+ *
+ * Consider releasing a page for the vmscan algorithm, on behalf of the netfs's
+ * releasepage() call.  A storage request on the page may cancelled if it is
+ * not currently being processed.
+ *
+ * The function returns true if the page no longer has a storage request on it,
+ * and false if a storage request is left in place.  If true is returned, the
+ * page will have been passed to fscache_uncache_page().  If false is returned
+ * the page cannot be freed yet.
+ */
+static inline
+bool fscache_maybe_release_page(struct fscache_cookie *cookie,
+                                struct page *page,
+                                gfp_t gfp)
+{
+        if (fscache_cookie_valid(cookie) && PageFsCache(page))
+                return __fscache_maybe_release_page(cookie, page, gfp);
+        return false;
+}
+
 #endif /* _LINUX_FSCACHE_H */
diff --git a/include/linux/i2c-pnx.h b/include/linux/i2c-pnx.h
index f13255e06406..9eb07bbc6522 100644
--- a/include/linux/i2c-pnx.h
+++ b/include/linux/i2c-pnx.h
@@ -21,7 +21,7 @@ struct i2c_pnx_mif {
         int                     mode;           /* Interface mode */
         struct completion       complete;       /* I/O completion */
         struct timer_list       timer;          /* Timeout */
-        char *                  buf;            /* Data buffer */
+        u8 *                    buf;            /* Data buffer */
         int                     len;            /* Length of data buffer */
 };
 
diff --git a/include/linux/input.h b/include/linux/input.h
index 0ccfc30cd40f..c2b1a7d244d9 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -1377,6 +1377,10 @@ extern struct class input_class;
  * methods; erase() is optional. set_gain() and set_autocenter() need
  * only be implemented if driver sets up FF_GAIN and FF_AUTOCENTER
  * bits.
+ *
+ * Note that playback(), set_gain() and set_autocenter() are called with
+ * dev->event_lock spinlock held and interrupts off and thus may not
+ * sleep.
  */
 struct ff_device {
         int (*upload)(struct input_dev *dev, struct ff_effect *effect,
diff --git a/include/linux/isdn_ppp.h b/include/linux/isdn_ppp.h
index 4c218ee7587a..8687a7dc0632 100644
--- a/include/linux/isdn_ppp.h
+++ b/include/linux/isdn_ppp.h
@@ -157,7 +157,7 @@ typedef struct {
 
 typedef struct {
   int mp_mrru;                        /* unused                             */
-  struct sk_buff_head frags;    /* fragments sl list */
+  struct sk_buff * frags;       /* fragments sl list -- use skb->next */
   long frames;                  /* number of frames in the frame list */
   unsigned int seq;             /* last processed packet seq #: any packets
                                  * with smaller seq # will be dropped
diff --git a/include/linux/mfd/wm831x/regulator.h b/include/linux/mfd/wm831x/regulator.h
index f95466343fb2..955d30fc6a27 100644
--- a/include/linux/mfd/wm831x/regulator.h
+++ b/include/linux/mfd/wm831x/regulator.h
@@ -1212,7 +1212,7 @@
 #define WM831X_LDO1_OK_SHIFT                         0  /* LDO1_OK */
 #define WM831X_LDO1_OK_WIDTH                         1  /* LDO1_OK */
 
-#define WM831X_ISINK_MAX_ISEL 56
-extern int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL];
+#define WM831X_ISINK_MAX_ISEL 55
+extern int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1];
 
 #endif
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index 79fec6af3f9f..ce520402e840 100644
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -425,15 +425,6 @@ struct nilfs_dat_entry {
 };
 
 /**
- * struct nilfs_dat_group_desc - block group descriptor
- * @dg_nfrees: number of free virtual block numbers in block group
- */
-struct nilfs_dat_group_desc {
-        __le32 dg_nfrees;
-};
-
-
-/**
  * struct nilfs_snapshot_list - snapshot list
  * @ssl_next: next checkpoint number on snapshot list
  * @ssl_prev: previous checkpoint number on snapshot list
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 9ceb392cb984..84cf1f3b7838 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1956,6 +1956,8 @@
 #define PCI_DEVICE_ID_LAVA_DSERIAL      0x0100 /* 2x 16550 */
 #define PCI_DEVICE_ID_LAVA_QUATRO_A     0x0101 /* 2x 16550, half of 4 port */
 #define PCI_DEVICE_ID_LAVA_QUATRO_B     0x0102 /* 2x 16550, half of 4 port */
+#define PCI_DEVICE_ID_LAVA_QUATTRO_A    0x0120 /* 2x 16550A, half of 4 port */
+#define PCI_DEVICE_ID_LAVA_QUATTRO_B    0x0121 /* 2x 16550A, half of 4 port */
 #define PCI_DEVICE_ID_LAVA_OCTO_A       0x0180 /* 4x 16550A, half of 8 port */
 #define PCI_DEVICE_ID_LAVA_OCTO_B       0x0181 /* 4x 16550A, half of 8 port */
 #define PCI_DEVICE_ID_LAVA_PORT_PLUS    0x0200 /* 2x 16650 */
diff --git a/include/linux/slow-work.h b/include/linux/slow-work.h
index b65c8881f07a..13337bf6c3f5 100644
--- a/include/linux/slow-work.h
+++ b/include/linux/slow-work.h
@@ -17,13 +17,20 @@
 #ifdef CONFIG_SLOW_WORK
 
 #include <linux/sysctl.h>
+#include <linux/timer.h>
 
 struct slow_work;
+#ifdef CONFIG_SLOW_WORK_DEBUG
+struct seq_file;
+#endif
 
 /*
  * The operations used to support slow work items
  */
 struct slow_work_ops {
+        /* owner */
+        struct module *owner;
+
         /* get a ref on a work item
          * - return 0 if successful, -ve if not
          */
@@ -34,6 +41,11 @@ struct slow_work_ops {
 
         /* execute a work item */
         void (*execute)(struct slow_work *work);
+
+#ifdef CONFIG_SLOW_WORK_DEBUG
+        /* describe a work item for debugfs */
+        void (*desc)(struct slow_work *work, struct seq_file *m);
+#endif
 };
 
 /*
@@ -42,13 +54,24 @@ struct slow_work_ops {
  *   queued
  */
 struct slow_work {
+        struct module           *owner; /* the owning module */
         unsigned long           flags;
 #define SLOW_WORK_PENDING       0       /* item pending (further) execution */
 #define SLOW_WORK_EXECUTING     1       /* item currently executing */
 #define SLOW_WORK_ENQ_DEFERRED  2       /* item enqueue deferred */
 #define SLOW_WORK_VERY_SLOW     3       /* item is very slow */
+#define SLOW_WORK_CANCELLING    4       /* item is being cancelled, don't enqueue */
+#define SLOW_WORK_DELAYED       5       /* item is struct delayed_slow_work with active timer */
         const struct slow_work_ops *ops; /* operations table for this item */
         struct list_head        link;   /* link in queue */
+#ifdef CONFIG_SLOW_WORK_DEBUG
+        struct timespec         mark;   /* jiffies at which queued or exec begun */
+#endif
+};
+
+struct delayed_slow_work {
+        struct slow_work        work;
+        struct timer_list       timer;
 };
 
 /**
@@ -67,6 +90,20 @@ static inline void slow_work_init(struct slow_work *work,
 }
 
 /**
+ * slow_work_init - Initialise a delayed slow work item
+ * @work: The work item to initialise
+ * @ops: The operations to use to handle the slow work item
+ *
+ * Initialise a delayed slow work item.
+ */
+static inline void delayed_slow_work_init(struct delayed_slow_work *dwork,
+                                          const struct slow_work_ops *ops)
+{
+        init_timer(&dwork->timer);
+        slow_work_init(&dwork->work, ops);
+}
+
+/**
  * vslow_work_init - Initialise a very slow work item
  * @work: The work item to initialise
  * @ops: The operations to use to handle the slow work item
@@ -83,9 +120,40 @@ static inline void vslow_work_init(struct slow_work *work,
         INIT_LIST_HEAD(&work->link);
 }
 
+/**
+ * slow_work_is_queued - Determine if a slow work item is on the work queue
+ * work: The work item to test
+ *
+ * Determine if the specified slow-work item is on the work queue.  This
+ * returns true if it is actually on the queue.
+ *
+ * If the item is executing and has been marked for requeue when execution
+ * finishes, then false will be returned.
+ *
+ * Anyone wishing to wait for completion of execution can wait on the
+ * SLOW_WORK_EXECUTING bit.
+ */
+static inline bool slow_work_is_queued(struct slow_work *work)
+{
+        unsigned long flags = work->flags;
+        return flags & SLOW_WORK_PENDING && !(flags & SLOW_WORK_EXECUTING);
+}
+
 extern int slow_work_enqueue(struct slow_work *work);
-extern int slow_work_register_user(void);
-extern void slow_work_unregister_user(void);
+extern void slow_work_cancel(struct slow_work *work);
+extern int slow_work_register_user(struct module *owner);
+extern void slow_work_unregister_user(struct module *owner);
+
+extern int delayed_slow_work_enqueue(struct delayed_slow_work *dwork,
+                                     unsigned long delay);
+
+static inline void delayed_slow_work_cancel(struct delayed_slow_work *dwork)
+{
+        slow_work_cancel(&dwork->work);
+}
+
+extern bool slow_work_sleep_till_thread_needed(struct slow_work *work,
+                                               signed long *_timeout);
 
 #ifdef CONFIG_SYSCTL
 extern ctl_table slow_work_sysctls[];
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index cd15df6c63cd..5e781d824e6d 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -301,6 +301,8 @@ static inline int unregister_pm_notifier(struct notifier_block *nb)
 #define pm_notifier(fn, pri)    do { (void)(fn); } while (0)
 #endif /* !CONFIG_PM_SLEEP */
 
+extern struct mutex pm_mutex;
+
 #ifndef CONFIG_HIBERNATION
 static inline void register_nosave_region(unsigned long b, unsigned long e)
 {
@@ -308,8 +310,23 @@ static inline void register_nosave_region(unsigned long b, unsigned long e)
 static inline void register_nosave_region_late(unsigned long b, unsigned long e)
 {
 }
-#endif
 
-extern struct mutex pm_mutex;
+static inline void lock_system_sleep(void) {}
+static inline void unlock_system_sleep(void) {}
+
+#else
+
+/* Let some subsystems like memory hotadd exclude hibernation */
+
+static inline void lock_system_sleep(void)
+{
+        mutex_lock(&pm_mutex);
+}
+
+static inline void unlock_system_sleep(void)
+{
+        mutex_unlock(&pm_mutex);
+}
+#endif
 
 #endif /* _LINUX_SUSPEND_H */
diff --git a/include/linux/vt.h b/include/linux/vt.h
index 7afca0d72139..7ffa11f06232 100644
--- a/include/linux/vt.h
+++ b/include/linux/vt.h
@@ -70,8 +70,8 @@ struct vt_event {
 #define VT_EVENT_UNBLANK        0x0004  /* Screen unblank */
 #define VT_EVENT_RESIZE         0x0008  /* Resize display */
 #define VT_MAX_EVENT            0x000F
-        unsigned int old;               /* Old console */
-        unsigned int new;               /* New console (if changing) */
+        unsigned int oldev;             /* Old console */
+        unsigned int newev;             /* New console (if changing) */
         unsigned int pad[4];            /* Padding for expansion */
 };
 
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index c75b960c8ac8..998c30fc8981 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -1283,6 +1283,12 @@ enum ieee80211_filter_flags {
  *
  * These flags are used with the ampdu_action() callback in
  * &struct ieee80211_ops to indicate which action is needed.
+ *
+ * Note that drivers MUST be able to deal with a TX aggregation
+ * session being stopped even before they OK'ed starting it by
+ * calling ieee80211_start_tx_ba_cb(_irqsafe), because the peer
+ * might receive the addBA frame and send a delBA right away!
+ *
  * @IEEE80211_AMPDU_RX_START: start Rx aggregation
  * @IEEE80211_AMPDU_RX_STOP: stop Rx aggregation
  * @IEEE80211_AMPDU_TX_START: start Tx aggregation
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 6e5f0e0c7967..0a474568b003 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -893,7 +893,6 @@ struct sctp_transport {
          */
         /* RTO         : The current retransmission timeout value.  */
         unsigned long rto;
-        unsigned long last_rto;
 
         __u32 rtt;              /* This is the most recent RTT.  */
 
@@ -1980,7 +1979,7 @@ void sctp_assoc_set_primary(struct sctp_association *,
 void sctp_assoc_del_nonprimary_peers(struct sctp_association *,
                                     struct sctp_transport *);
 int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *,
-                                     gfp_t);
+                                     sctp_scope_t, gfp_t);
 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
                                          struct sctp_cookie*,
                                          gfp_t gfp);
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 9af48cbf0036..f097ae340bc1 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -145,6 +145,7 @@ struct scsi_device {
         unsigned retry_hwerror:1;       /* Retry HARDWARE_ERROR */
         unsigned last_sector_bug:1;     /* do not use multisector accesses on
                                            SD_LAST_BUGGY_SECTORS */
+        unsigned is_visible:1;  /* is the device visible in sysfs */
 
         DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
         struct list_head event_list;    /* asserted events */
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 6e728b176904..47941fc5aba7 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -797,30 +797,23 @@ static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
 
 static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
 {
-        switch (target_type) {
-        case 1:
-                if (shost->prot_capabilities & SHOST_DIF_TYPE1_PROTECTION)
-                        return target_type;
-        case 2:
-                if (shost->prot_capabilities & SHOST_DIF_TYPE2_PROTECTION)
-                        return target_type;
-        case 3:
-                if (shost->prot_capabilities & SHOST_DIF_TYPE3_PROTECTION)
-                        return target_type;
-        }
+        static unsigned char cap[] = { 0,
+                                       SHOST_DIF_TYPE1_PROTECTION,
+                                       SHOST_DIF_TYPE2_PROTECTION,
+                                       SHOST_DIF_TYPE3_PROTECTION };
 
-        return 0;
+        return shost->prot_capabilities & cap[target_type] ? target_type : 0;
 }
 
 static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
 {
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
-        switch (target_type) {
-        case 0: return shost->prot_capabilities & SHOST_DIX_TYPE0_PROTECTION;
-        case 1: return shost->prot_capabilities & SHOST_DIX_TYPE1_PROTECTION;
-        case 2: return shost->prot_capabilities & SHOST_DIX_TYPE2_PROTECTION;
-        case 3: return shost->prot_capabilities & SHOST_DIX_TYPE3_PROTECTION;
-        }
+        static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
+                                       SHOST_DIX_TYPE1_PROTECTION,
+                                       SHOST_DIX_TYPE2_PROTECTION,
+                                       SHOST_DIX_TYPE3_PROTECTION };
+
+        return shost->prot_capabilities & cap[target_type];
 #endif
         return 0;
 }