Merge tag 'device-for-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg...
Linus Torvalds [Sat, 24 Mar 2012 17:41:37 +0000 (10:41 -0700)]
Pull <linux/device.h> avoidance patches from Paul Gortmaker:
 "Nearly every subsystem has some kind of header with a proto like:

void foo(struct device *dev);

  and yet there is no reason for most of these guys to care about the
  sub fields within the device struct.  This allows us to significantly
  reduce the scope of headers including headers.  For this instance, a
  reduction of about 40% is achieved by replacing the include with the
  simple fact that the device is some kind of a struct.

  Unlike the much larger module.h cleanup, this one is simply two
  commits.  One to fix the implicit <linux/device.h> users, and then one
  to delete the device.h includes from the linux/include/ dir wherever
  possible."

* tag 'device-for-3.4' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg/linux:
  device.h: audit and cleanup users in main include dir
  device.h: cleanup users outside of linux/include (C files)

29 files changed:
1  2 
drivers/base/regmap/regcache-lzo.c
drivers/base/regmap/regcache-rbtree.c
drivers/base/regmap/regcache.c
drivers/base/regmap/regmap-debugfs.c
drivers/mfd/wm8994-regmap.c
include/linux/amba/pl022.h
include/linux/atmdev.h
include/linux/cdrom.h
include/linux/cpu.h
include/linux/cpufreq.h
include/linux/fb.h
include/linux/firewire.h
include/linux/mmc/card.h
include/linux/mmc/host.h
include/linux/netdevice.h
include/linux/of_device.h
include/linux/pm_domain.h
include/linux/regmap.h
include/linux/regulator/consumer.h
include/media/v4l2-ctrls.h
include/media/v4l2-ioctl.h
include/net/mac80211.h
include/scsi/scsi_device.h
include/sound/core.h
include/sound/soc-dapm.h
include/trace/events/regmap.h
include/trace/events/writeback.h
sound/core/init.c
sound/core/pcm.c

@@@ -11,6 -11,7 +11,7 @@@
   */
  
  #include <linux/slab.h>
+ #include <linux/device.h>
  #include <linux/lzo.h>
  
  #include "internal.h"
@@@ -331,8 -332,7 +332,8 @@@ out
        return ret;
  }
  
 -static int regcache_lzo_sync(struct regmap *map)
 +static int regcache_lzo_sync(struct regmap *map, unsigned int min,
 +                           unsigned int max)
  {
        struct regcache_lzo_ctx **lzo_blocks;
        unsigned int val;
        int ret;
  
        lzo_blocks = map->cache;
 -      for_each_set_bit(i, lzo_blocks[0]->sync_bmp, lzo_blocks[0]->sync_bmp_nbits) {
 +      i = min;
 +      for_each_set_bit_from(i, lzo_blocks[0]->sync_bmp,
 +                            lzo_blocks[0]->sync_bmp_nbits) {
 +              if (i > max)
 +                      continue;
 +
                ret = regcache_read(map, i, &val);
                if (ret)
                        return ret;
 +
 +              /* Is this the hardware default?  If so skip. */
 +              ret = regcache_lookup_reg(map, i);
 +              if (ret > 0 && val == map->reg_defaults[ret].def)
 +                      continue;
 +
                map->cache_bypass = 1;
                ret = _regmap_write(map, i, val);
                map->cache_bypass = 0;
@@@ -11,6 -11,7 +11,7 @@@
   */
  
  #include <linux/slab.h>
+ #include <linux/device.h>
  #include <linux/debugfs.h>
  #include <linux/rbtree.h>
  #include <linux/seq_file.h>
@@@ -357,8 -358,7 +358,8 @@@ static int regcache_rbtree_write(struc
        return 0;
  }
  
 -static int regcache_rbtree_sync(struct regmap *map)
 +static int regcache_rbtree_sync(struct regmap *map, unsigned int min,
 +                              unsigned int max)
  {
        struct regcache_rbtree_ctx *rbtree_ctx;
        struct rb_node *node;
        unsigned int regtmp;
        unsigned int val;
        int ret;
 -      int i;
 +      int i, base, end;
  
        rbtree_ctx = map->cache;
        for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
                rbnode = rb_entry(node, struct regcache_rbtree_node, node);
 -              for (i = 0; i < rbnode->blklen; i++) {
 +
 +              if (rbnode->base_reg < min)
 +                      continue;
 +              if (rbnode->base_reg > max)
 +                      break;
 +              if (rbnode->base_reg + rbnode->blklen < min)
 +                      continue;
 +
 +              if (min > rbnode->base_reg)
 +                      base = min - rbnode->base_reg;
 +              else
 +                      base = 0;
 +
 +              if (max < rbnode->base_reg + rbnode->blklen)
 +                      end = rbnode->base_reg + rbnode->blklen - max;
 +              else
 +                      end = rbnode->blklen;
 +
 +              for (i = base; i < end; i++) {
                        regtmp = rbnode->base_reg + i;
                        val = regcache_rbtree_get_register(rbnode, i,
                                                           map->cache_word_size);
  
                        /* Is this the hardware default?  If so skip. */
                        ret = regcache_lookup_reg(map, i);
 -                      if (ret > 0 && val == map->reg_defaults[ret].def)
 +                      if (ret >= 0 && val == map->reg_defaults[ret].def)
                                continue;
  
                        map->cache_bypass = 1;
@@@ -12,6 -12,7 +12,7 @@@
  
  #include <linux/slab.h>
  #include <linux/export.h>
+ #include <linux/device.h>
  #include <trace/events/regmap.h>
  #include <linux/bsearch.h>
  #include <linux/sort.h>
@@@ -35,17 -36,12 +36,17 @@@ static int regcache_hw_init(struct regm
                return -EINVAL;
  
        if (!map->reg_defaults_raw) {
 +              u32 cache_bypass = map->cache_bypass;
                dev_warn(map->dev, "No cache defaults, reading back from HW\n");
 +
 +              /* Bypass the cache access till data read from HW*/
 +              map->cache_bypass = 1;
                tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL);
                if (!tmp_buf)
                        return -EINVAL;
                ret = regmap_bulk_read(map, 0, tmp_buf,
                                       map->num_reg_defaults_raw);
 +              map->cache_bypass = cache_bypass;
                if (ret < 0) {
                        kfree(tmp_buf);
                        return ret;
@@@ -58,7 -54,7 +59,7 @@@
        for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) {
                val = regcache_get_val(map->reg_defaults_raw,
                                       i, map->cache_word_size);
 -              if (!val)
 +              if (regmap_volatile(map, i))
                        continue;
                count++;
        }
@@@ -75,7 -71,7 +76,7 @@@
        for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) {
                val = regcache_get_val(map->reg_defaults_raw,
                                       i, map->cache_word_size);
 -              if (!val)
 +              if (regmap_volatile(map, i))
                        continue;
                map->reg_defaults[j].reg = i;
                map->reg_defaults[j].def = val;
@@@ -216,6 -212,7 +217,6 @@@ int regcache_read(struct regmap *map
  
        return -EINVAL;
  }
 -EXPORT_SYMBOL_GPL(regcache_read);
  
  /**
   * regcache_write: Set the value of a given register in the cache.
@@@ -242,6 -239,7 +243,6 @@@ int regcache_write(struct regmap *map
  
        return 0;
  }
 -EXPORT_SYMBOL_GPL(regcache_write);
  
  /**
   * regcache_sync: Sync the register cache with the hardware.
  int regcache_sync(struct regmap *map)
  {
        int ret = 0;
 -      unsigned int val;
        unsigned int i;
        const char *name;
        unsigned int bypass;
  
 -      BUG_ON(!map->cache_ops);
 +      BUG_ON(!map->cache_ops || !map->cache_ops->sync);
  
        mutex_lock(&map->lock);
        /* Remember the initial bypass state */
                map->cache_ops->name);
        name = map->cache_ops->name;
        trace_regcache_sync(map->dev, name, "start");
 +
        if (!map->cache_dirty)
                goto out;
 -      if (map->cache_ops->sync) {
 -              ret = map->cache_ops->sync(map);
 -      } else {
 -              for (i = 0; i < map->num_reg_defaults; i++) {
 -                      ret = regcache_read(map, i, &val);
 -                      if (ret < 0)
 -                              goto out;
 -                      map->cache_bypass = 1;
 -                      ret = _regmap_write(map, i, val);
 -                      map->cache_bypass = 0;
 -                      if (ret < 0)
 -                              goto out;
 -                      dev_dbg(map->dev, "Synced register %#x, value %#x\n",
 -                              map->reg_defaults[i].reg,
 -                              map->reg_defaults[i].def);
 -              }
  
 +      /* Apply any patch first */
 +      map->cache_bypass = 1;
 +      for (i = 0; i < map->patch_regs; i++) {
 +              ret = _regmap_write(map, map->patch[i].reg, map->patch[i].def);
 +              if (ret != 0) {
 +                      dev_err(map->dev, "Failed to write %x = %x: %d\n",
 +                              map->patch[i].reg, map->patch[i].def, ret);
 +                      goto out;
 +              }
        }
 +      map->cache_bypass = 0;
 +
 +      ret = map->cache_ops->sync(map, 0, map->max_register);
 +
 +      if (ret == 0)
 +              map->cache_dirty = false;
 +
  out:
        trace_regcache_sync(map->dev, name, "stop");
        /* Restore the bypass state */
  EXPORT_SYMBOL_GPL(regcache_sync);
  
  /**
 + * regcache_sync_region: Sync part  of the register cache with the hardware.
 + *
 + * @map: map to sync.
 + * @min: first register to sync
 + * @max: last register to sync
 + *
 + * Write all non-default register values in the specified region to
 + * the hardware.
 + *
 + * Return a negative value on failure, 0 on success.
 + */
 +int regcache_sync_region(struct regmap *map, unsigned int min,
 +                       unsigned int max)
 +{
 +      int ret = 0;
 +      const char *name;
 +      unsigned int bypass;
 +
 +      BUG_ON(!map->cache_ops || !map->cache_ops->sync);
 +
 +      mutex_lock(&map->lock);
 +
 +      /* Remember the initial bypass state */
 +      bypass = map->cache_bypass;
 +
 +      name = map->cache_ops->name;
 +      dev_dbg(map->dev, "Syncing %s cache from %d-%d\n", name, min, max);
 +
 +      trace_regcache_sync(map->dev, name, "start region");
 +
 +      if (!map->cache_dirty)
 +              goto out;
 +
 +      ret = map->cache_ops->sync(map, min, max);
 +
 +out:
 +      trace_regcache_sync(map->dev, name, "stop region");
 +      /* Restore the bypass state */
 +      map->cache_bypass = bypass;
 +      mutex_unlock(&map->lock);
 +
 +      return ret;
 +}
 +
 +/**
   * regcache_cache_only: Put a register map into cache only mode
   *
   * @map: map to configure
@@@ -363,7 -316,6 +364,7 @@@ void regcache_cache_only(struct regmap 
        mutex_lock(&map->lock);
        WARN_ON(map->cache_bypass && enable);
        map->cache_only = enable;
 +      trace_regmap_cache_only(map->dev, enable);
        mutex_unlock(&map->lock);
  }
  EXPORT_SYMBOL_GPL(regcache_cache_only);
@@@ -401,7 -353,6 +402,7 @@@ void regcache_cache_bypass(struct regma
        mutex_lock(&map->lock);
        WARN_ON(map->cache_only && enable);
        map->cache_bypass = enable;
 +      trace_regmap_cache_bypass(map->dev, enable);
        mutex_unlock(&map->lock);
  }
  EXPORT_SYMBOL_GPL(regcache_cache_bypass);
@@@ -424,16 -375,10 +425,16 @@@ bool regcache_set_val(void *base, unsig
                cache[idx] = val;
                break;
        }
 +      case 4: {
 +              u32 *cache = base;
 +              if (cache[idx] == val)
 +                      return true;
 +              cache[idx] = val;
 +              break;
 +      }
        default:
                BUG();
        }
 -      /* unreachable */
        return false;
  }
  
@@@ -452,10 -397,6 +453,10 @@@ unsigned int regcache_get_val(const voi
                const u16 *cache = base;
                return cache[idx];
        }
 +      case 4: {
 +              const u32 *cache = base;
 +              return cache[idx];
 +      }
        default:
                BUG();
        }
   */
  
  #include <linux/slab.h>
  #include <linux/mutex.h>
  #include <linux/debugfs.h>
  #include <linux/uaccess.h>
+ #include <linux/device.h>
  
  #include "internal.h"
  
@@@ -32,35 -34,6 +33,35 @@@ static int regmap_open_file(struct inod
        return 0;
  }
  
 +static ssize_t regmap_name_read_file(struct file *file,
 +                                   char __user *user_buf, size_t count,
 +                                   loff_t *ppos)
 +{
 +      struct regmap *map = file->private_data;
 +      int ret;
 +      char *buf;
 +
 +      buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 +      if (!buf)
 +              return -ENOMEM;
 +
 +      ret = snprintf(buf, PAGE_SIZE, "%s\n", map->dev->driver->name);
 +      if (ret < 0) {
 +              kfree(buf);
 +              return ret;
 +      }
 +
 +      ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
 +      kfree(buf);
 +      return ret;
 +}
 +
 +static const struct file_operations regmap_name_fops = {
 +      .open = regmap_open_file,
 +      .read = regmap_name_read_file,
 +      .llseek = default_llseek,
 +};
 +
  static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf,
                                    size_t count, loff_t *ppos)
  {
@@@ -131,51 -104,9 +132,51 @@@ out
        return ret;
  }
  
 +#undef REGMAP_ALLOW_WRITE_DEBUGFS
 +#ifdef REGMAP_ALLOW_WRITE_DEBUGFS
 +/*
 + * This can be dangerous especially when we have clients such as
 + * PMICs, therefore don't provide any real compile time configuration option
 + * for this feature, people who want to use this will need to modify
 + * the source code directly.
 + */
 +static ssize_t regmap_map_write_file(struct file *file,
 +                                   const char __user *user_buf,
 +                                   size_t count, loff_t *ppos)
 +{
 +      char buf[32];
 +      size_t buf_size;
 +      char *start = buf;
 +      unsigned long reg, value;
 +      struct regmap *map = file->private_data;
 +
 +      buf_size = min(count, (sizeof(buf)-1));
 +      if (copy_from_user(buf, user_buf, buf_size))
 +              return -EFAULT;
 +      buf[buf_size] = 0;
 +
 +      while (*start == ' ')
 +              start++;
 +      reg = simple_strtoul(start, &start, 16);
 +      while (*start == ' ')
 +              start++;
 +      if (strict_strtoul(start, 16, &value))
 +              return -EINVAL;
 +
 +      /* Userspace has been fiddling around behind the kernel's back */
 +      add_taint(TAINT_USER);
 +
 +      regmap_write(map, reg, value);
 +      return buf_size;
 +}
 +#else
 +#define regmap_map_write_file NULL
 +#endif
 +
  static const struct file_operations regmap_map_fops = {
        .open = regmap_open_file,
        .read = regmap_map_read_file,
 +      .write = regmap_map_write_file,
        .llseek = default_llseek,
  };
  
@@@ -256,24 -187,12 +257,24 @@@ void regmap_debugfs_init(struct regmap 
                return;
        }
  
 +      debugfs_create_file("name", 0400, map->debugfs,
 +                          map, &regmap_name_fops);
 +
        if (map->max_register) {
                debugfs_create_file("registers", 0400, map->debugfs,
                                    map, &regmap_map_fops);
                debugfs_create_file("access", 0400, map->debugfs,
                                    map, &regmap_access_fops);
        }
 +
 +      if (map->cache_type) {
 +              debugfs_create_bool("cache_only", 0400, map->debugfs,
 +                                  &map->cache_only);
 +              debugfs_create_bool("cache_dirty", 0400, map->debugfs,
 +                                  &map->cache_dirty);
 +              debugfs_create_bool("cache_bypass", 0400, map->debugfs,
 +                                  &map->cache_bypass);
 +      }
  }
  
  void regmap_debugfs_exit(struct regmap *map)
@@@ -15,6 -15,7 +15,7 @@@
  #include <linux/mfd/wm8994/core.h>
  #include <linux/mfd/wm8994/registers.h>
  #include <linux/regmap.h>
+ #include <linux/device.h>
  
  #include "wm8994.h"
  
@@@ -806,7 -807,6 +807,7 @@@ static bool wm1811_readable_register(st
        case WM8994_DC_SERVO_2:
        case WM8994_DC_SERVO_READBACK:
        case WM8994_DC_SERVO_4:
 +      case WM8994_DC_SERVO_4E:
        case WM8994_ANALOGUE_HP_1:
        case WM8958_MIC_DETECT_1:
        case WM8958_MIC_DETECT_2:
@@@ -25,8 -25,6 +25,6 @@@
  #ifndef _SSP_PL022_H
  #define _SSP_PL022_H
  
- #include <linux/device.h>
  /**
   * whether SSP is in loopback mode or not
   */
@@@ -241,8 -239,6 +239,8 @@@ struct dma_chan
   * @autosuspend_delay: delay in ms following transfer completion before the
   *     runtime power management system suspends the device. A setting of 0
   *     indicates no delay and the device will be suspended immediately.
 + * @rt: indicates the controller should run the message pump with realtime
 + *     priority to minimise the transfer latency on the bus.
   */
  struct pl022_ssp_controller {
        u16 bus_id;
        void *dma_rx_param;
        void *dma_tx_param;
        int autosuspend_delay;
 +      bool rt;
  };
  
  /**
diff --combined include/linux/atmdev.h
@@@ -213,11 -213,9 +213,10 @@@ struct atm_cirange 
  
  #ifdef __KERNEL__
  
  #include <linux/wait.h> /* wait_queue_head_t */
  #include <linux/time.h> /* struct timeval */
  #include <linux/net.h>
 +#include <linux/bug.h>
  #include <linux/skbuff.h> /* struct sk_buff */
  #include <linux/uio.h>
  #include <net/sock.h>
@@@ -250,6 -248,7 +249,7 @@@ struct k_atm_dev_stats 
        struct k_atm_aal_stats aal5;
  };
  
+ struct device;
  
  enum {
        ATM_VF_ADDR,            /* Address is in use. Set by anybody, cleared
diff --combined include/linux/cdrom.h
@@@ -910,7 -910,6 +910,6 @@@ struct mode_page_header 
  
  #ifdef __KERNEL__
  #include <linux/fs.h>         /* not really needed, later.. */
- #include <linux/device.h>
  #include <linux/list.h>
  
  struct packet_command
@@@ -952,8 -951,7 +951,8 @@@ struct cdrom_device_info 
        char name[20];                  /* name of the device type */
  /* per-device flags */
          __u8 sanyo_slot               : 2;    /* Sanyo 3 CD changer support */
 -        __u8 reserved         : 6;    /* not used yet */
 +        __u8 keeplocked               : 1;    /* CDROM_LOCKDOOR status */
 +        __u8 reserved         : 5;    /* not used yet */
        int cdda_method;                /* see flags */
        __u8 last_sense;
        __u8 media_written;             /* dirty flag, DVD+RW bookkeeping */
diff --combined include/linux/cpu.h
  #ifndef _LINUX_CPU_H_
  #define _LINUX_CPU_H_
  
- #include <linux/device.h>
  #include <linux/node.h>
  #include <linux/compiler.h>
  #include <linux/cpumask.h>
  
+ struct device;
  struct cpu {
        int node_id;            /* The node which contains the CPU */
        int hotpluggable;       /* creates sysfs control file if hotpluggable */
@@@ -44,13 -45,6 +45,13 @@@ extern ssize_t arch_cpu_release(const c
  #endif
  struct notifier_block;
  
 +#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
 +extern int arch_cpu_uevent(struct device *dev, struct kobj_uevent_env *env);
 +extern ssize_t arch_print_cpu_modalias(struct device *dev,
 +                                     struct device_attribute *attr,
 +                                     char *bufptr);
 +#endif
 +
  /*
   * CPU notifier priorities.
   */
diff --combined include/linux/cpufreq.h
@@@ -14,7 -14,6 +14,6 @@@
  #include <linux/mutex.h>
  #include <linux/notifier.h>
  #include <linux/threads.h>
- #include <linux/device.h>
  #include <linux/kobject.h>
  #include <linux/sysfs.h>
  #include <linux/completion.h>
@@@ -35,7 -34,6 +34,7 @@@
  #ifdef CONFIG_CPU_FREQ
  int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
  int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
 +extern void disable_cpufreq(void);
  #else         /* CONFIG_CPU_FREQ */
  static inline int cpufreq_register_notifier(struct notifier_block *nb,
                                                unsigned int list)
@@@ -47,7 -45,6 +46,7 @@@ static inline int cpufreq_unregister_no
  {
        return 0;
  }
 +static inline void disable_cpufreq(void) { }
  #endif                /* CONFIG_CPU_FREQ */
  
  /* if (cpufreq_driver->target) exists, the ->governor decides what frequency
diff --combined include/linux/fb.h
@@@ -407,7 -407,6 +407,6 @@@ struct fb_cursor 
  
  #include <linux/fs.h>
  #include <linux/init.h>
- #include <linux/device.h>
  #include <linux/workqueue.h>
  #include <linux/notifier.h>
  #include <linux/list.h>
@@@ -1003,7 -1002,6 +1002,7 @@@ extern ssize_t fb_sys_write(struct fb_i
  /* drivers/video/fbmem.c */
  extern int register_framebuffer(struct fb_info *fb_info);
  extern int unregister_framebuffer(struct fb_info *fb_info);
 +extern int unlink_framebuffer(struct fb_info *fb_info);
  extern void remove_conflicting_framebuffers(struct apertures_struct *a,
                                const char *name, bool primary);
  extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
diff --combined include/linux/firewire.h
@@@ -2,7 -2,6 +2,6 @@@
  #define _LINUX_FIREWIRE_H
  
  #include <linux/completion.h>
- #include <linux/device.h>
  #include <linux/dma-mapping.h>
  #include <linux/kernel.h>
  #include <linux/kref.h>
@@@ -17,6 -16,9 +16,6 @@@
  #include <linux/atomic.h>
  #include <asm/byteorder.h>
  
 -#define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
 -#define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
 -
  #define CSR_REGISTER_BASE             0xfffff0000000ULL
  
  /* register offsets are relative to CSR_REGISTER_BASE */
@@@ -65,6 -67,8 +64,8 @@@
  #define CSR_MODEL             0x17
  #define CSR_DIRECTORY_ID      0x20
  
+ struct device;
  struct fw_csr_iterator {
        const u32 *p;
        const u32 *end;
@@@ -200,6 -204,18 +201,6 @@@ static inline int fw_device_is_shutdown
        return atomic_read(&device->state) == FW_DEVICE_SHUTDOWN;
  }
  
 -static inline struct fw_device *fw_device_get(struct fw_device *device)
 -{
 -      get_device(&device->device);
 -
 -      return device;
 -}
 -
 -static inline void fw_device_put(struct fw_device *device)
 -{
 -      put_device(&device->device);
 -}
 -
  int fw_device_enable_phys_dma(struct fw_device *device);
  
  /*
@@@ -426,7 -442,6 +427,7 @@@ int fw_iso_context_queue(struct fw_iso_
                         struct fw_iso_buffer *buffer,
                         unsigned long payload);
  void fw_iso_context_queue_flush(struct fw_iso_context *ctx);
 +int fw_iso_context_flush_completions(struct fw_iso_context *ctx);
  int fw_iso_context_start(struct fw_iso_context *ctx,
                         int cycle, int sync, int tags);
  int fw_iso_context_stop(struct fw_iso_context *ctx);
diff --combined include/linux/mmc/card.h
@@@ -10,6 -10,7 +10,7 @@@
  #ifndef LINUX_MMC_CARD_H
  #define LINUX_MMC_CARD_H
  
+ #include <linux/device.h>
  #include <linux/mmc/core.h>
  #include <linux/mod_devicetable.h>
  
@@@ -217,7 -218,6 +218,7 @@@ struct mmc_card 
  #define MMC_CARD_SDXC         (1<<6)          /* card is SDXC */
  #define MMC_CARD_REMOVED      (1<<7)          /* card has been removed */
  #define MMC_STATE_HIGHSPEED_200       (1<<8)          /* card is in HS200 mode */
 +#define MMC_STATE_SLEEP               (1<<9)          /* card is in sleep state */
        unsigned int            quirks;         /* card quirks */
  #define MMC_QUIRK_LENIENT_FN0 (1<<0)          /* allow SDIO FN0 writes outside of the VS CCCR range */
  #define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1)  /* use func->cur_blksize */
@@@ -383,7 -383,6 +384,7 @@@ static inline void __maybe_unused remov
  #define mmc_sd_card_uhs(c)    ((c)->state & MMC_STATE_ULTRAHIGHSPEED)
  #define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
  #define mmc_card_removed(c)   ((c) && ((c)->state & MMC_CARD_REMOVED))
 +#define mmc_card_is_sleep(c)  ((c)->state & MMC_STATE_SLEEP)
  
  #define mmc_card_set_present(c)       ((c)->state |= MMC_STATE_PRESENT)
  #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)
  #define mmc_sd_card_set_uhs(c) ((c)->state |= MMC_STATE_ULTRAHIGHSPEED)
  #define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC)
  #define mmc_card_set_removed(c) ((c)->state |= MMC_CARD_REMOVED)
 +#define mmc_card_set_sleep(c) ((c)->state |= MMC_STATE_SLEEP)
  
 +#define mmc_card_clr_sleep(c) ((c)->state &= ~MMC_STATE_SLEEP)
  /*
   * Quirk add/remove for MMC products.
   */
diff --combined include/linux/mmc/host.h
@@@ -12,6 -12,7 +12,7 @@@
  
  #include <linux/leds.h>
  #include <linux/sched.h>
+ #include <linux/device.h>
  #include <linux/fault-inject.h>
  
  #include <linux/mmc/core.h>
@@@ -257,7 -258,6 +258,7 @@@ struct mmc_host 
  #define MMC_CAP2_HS200_1_2V_SDR       (1 << 6)        /* can support */
  #define MMC_CAP2_HS200                (MMC_CAP2_HS200_1_8V_SDR | \
                                 MMC_CAP2_HS200_1_2V_SDR)
 +#define MMC_CAP2_BROKEN_VOLTAGE       (1 << 7)        /* Use the broken voltage */
  
        mmc_pm_flag_t           pm_caps;        /* supported pm features */
        unsigned int        power_notify_type;
@@@ -445,23 -445,4 +446,23 @@@ static inline int mmc_boot_partition_ac
        return !(host->caps2 & MMC_CAP2_BOOTPART_NOACC);
  }
  
 +#ifdef CONFIG_MMC_CLKGATE
 +void mmc_host_clk_hold(struct mmc_host *host);
 +void mmc_host_clk_release(struct mmc_host *host);
 +unsigned int mmc_host_clk_rate(struct mmc_host *host);
 +
 +#else
 +static inline void mmc_host_clk_hold(struct mmc_host *host)
 +{
 +}
 +
 +static inline void mmc_host_clk_release(struct mmc_host *host)
 +{
 +}
 +
 +static inline unsigned int mmc_host_clk_rate(struct mmc_host *host)
 +{
 +      return host->ios.clock;
 +}
 +#endif
  #endif /* LINUX_MMC_HOST_H */
  #ifdef __KERNEL__
  #include <linux/pm_qos.h>
  #include <linux/timer.h>
 +#include <linux/bug.h>
  #include <linux/delay.h>
  #include <linux/atomic.h>
  #include <asm/cache.h>
  #include <asm/byteorder.h>
  
- #include <linux/device.h>
  #include <linux/percpu.h>
  #include <linux/rculist.h>
  #include <linux/dmaengine.h>
@@@ -57,6 -55,7 +56,7 @@@
  #include <linux/netdev_features.h>
  
  struct netpoll_info;
+ struct device;
  struct phy_device;
  /* 802.11 specific */
  struct wireless_dev;
@@@ -215,8 -214,8 +215,8 @@@ enum 
  #include <linux/skbuff.h>
  
  #ifdef CONFIG_RPS
 -#include <linux/jump_label.h>
 -extern struct jump_label_key rps_needed;
 +#include <linux/static_key.h>
 +extern struct static_key rps_needed;
  #endif
  
  struct neighbour;
@@@ -418,7 -417,7 +418,7 @@@ typedef rx_handler_result_t rx_handler_
  
  extern void __napi_schedule(struct napi_struct *n);
  
 -static inline int napi_disable_pending(struct napi_struct *n)
 +static inline bool napi_disable_pending(struct napi_struct *n)
  {
        return test_bit(NAPI_STATE_DISABLE, &n->state);
  }
   * insure only one NAPI poll instance runs.  We also make
   * sure there is no pending NAPI disable.
   */
 -static inline int napi_schedule_prep(struct napi_struct *n)
 +static inline bool napi_schedule_prep(struct napi_struct *n)
  {
        return !napi_disable_pending(n) &&
                !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
@@@ -452,13 -451,13 +452,13 @@@ static inline void napi_schedule(struc
  }
  
  /* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
 -static inline int napi_reschedule(struct napi_struct *napi)
 +static inline bool napi_reschedule(struct napi_struct *napi)
  {
        if (napi_schedule_prep(napi)) {
                __napi_schedule(napi);
 -              return 1;
 +              return true;
        }
 -      return 0;
 +      return false;
  }
  
  /**
@@@ -1083,8 -1082,7 +1083,8 @@@ struct net_device 
        const struct header_ops *header_ops;
  
        unsigned int            flags;  /* interface flags (a la BSD)   */
 -      unsigned int            priv_flags; /* Like 'flags' but invisible to userspace. */
 +      unsigned int            priv_flags; /* Like 'flags' but invisible to userspace.
 +                                           * See if.h for definitions. */
        unsigned short          gflags;
        unsigned short          padded; /* How much padding added by alloc_netdev() */
  
@@@ -1869,7 -1867,7 +1869,7 @@@ static inline void netif_tx_stop_all_qu
        }
  }
  
 -static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 +static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
  {
        return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  }
   *
   *    Test if transmit queue on device is currently unable to send.
   */
 -static inline int netif_queue_stopped(const struct net_device *dev)
 +static inline bool netif_queue_stopped(const struct net_device *dev)
  {
        return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
  }
  
 -static inline int netif_xmit_stopped(const struct netdev_queue *dev_queue)
 +static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
  {
        return dev_queue->state & QUEUE_STATE_ANY_XOFF;
  }
  
 -static inline int netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
 +static inline bool netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
  {
        return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
  }
@@@ -1900,22 -1898,12 +1900,22 @@@ static inline void netdev_tx_sent_queue
  {
  #ifdef CONFIG_BQL
        dql_queued(&dev_queue->dql, bytes);
 -      if (unlikely(dql_avail(&dev_queue->dql) < 0)) {
 -              set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
 -              if (unlikely(dql_avail(&dev_queue->dql) >= 0))
 -                      clear_bit(__QUEUE_STATE_STACK_XOFF,
 -                          &dev_queue->state);
 -      }
 +
 +      if (likely(dql_avail(&dev_queue->dql) >= 0))
 +              return;
 +
 +      set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
 +
 +      /*
 +       * The XOFF flag must be set before checking the dql_avail below,
 +       * because in netdev_tx_completed_queue we update the dql_completed
 +       * before checking the XOFF flag.
 +       */
 +      smp_mb();
 +
 +      /* check again in case another CPU has just made room avail */
 +      if (unlikely(dql_avail(&dev_queue->dql) >= 0))
 +              clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
  #endif
  }
  
@@@ -1928,23 -1916,16 +1928,23 @@@ static inline void netdev_tx_completed_
                                             unsigned pkts, unsigned bytes)
  {
  #ifdef CONFIG_BQL
 -      if (likely(bytes)) {
 -              dql_completed(&dev_queue->dql, bytes);
 -              if (unlikely(test_bit(__QUEUE_STATE_STACK_XOFF,
 -                  &dev_queue->state) &&
 -                  dql_avail(&dev_queue->dql) >= 0)) {
 -                      if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF,
 -                           &dev_queue->state))
 -                              netif_schedule_queue(dev_queue);
 -              }
 -      }
 +      if (unlikely(!bytes))
 +              return;
 +
 +      dql_completed(&dev_queue->dql, bytes);
 +
 +      /*
 +       * Without the memory barrier there is a small possiblity that
 +       * netdev_tx_sent_queue will miss the update and cause the queue to
 +       * be stopped forever
 +       */
 +      smp_mb();
 +
 +      if (dql_avail(&dev_queue->dql) < 0)
 +              return;
 +
 +      if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
 +              netif_schedule_queue(dev_queue);
  #endif
  }
  
@@@ -1957,7 -1938,6 +1957,7 @@@ static inline void netdev_completed_que
  static inline void netdev_tx_reset_queue(struct netdev_queue *q)
  {
  #ifdef CONFIG_BQL
 +      clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
        dql_reset(&q->dql);
  #endif
  }
@@@ -1973,7 -1953,7 +1973,7 @@@ static inline void netdev_reset_queue(s
   *
   *    Test if the device has been brought up.
   */
 -static inline int netif_running(const struct net_device *dev)
 +static inline bool netif_running(const struct net_device *dev)
  {
        return test_bit(__LINK_STATE_START, &dev->state);
  }
@@@ -2023,16 -2003,16 +2023,16 @@@ static inline void netif_stop_subqueue(
   *
   * Check individual transmit queue of a device with multiple transmit queues.
   */
 -static inline int __netif_subqueue_stopped(const struct net_device *dev,
 -                                       u16 queue_index)
 +static inline bool __netif_subqueue_stopped(const struct net_device *dev,
 +                                          u16 queue_index)
  {
        struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  
        return netif_tx_queue_stopped(txq);
  }
  
 -static inline int netif_subqueue_stopped(const struct net_device *dev,
 -                                       struct sk_buff *skb)
 +static inline bool netif_subqueue_stopped(const struct net_device *dev,
 +                                        struct sk_buff *skb)
  {
        return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
  }
@@@ -2071,7 -2051,7 +2071,7 @@@ static inline u16 skb_tx_hash(const str
   *
   * Check if device has multiple transmit queues
   */
 -static inline int netif_is_multiqueue(const struct net_device *dev)
 +static inline bool netif_is_multiqueue(const struct net_device *dev)
  {
        return dev->num_tx_queues > 1;
  }
@@@ -2141,7 -2121,7 +2141,7 @@@ extern int netdev_rx_handler_register(s
                                      void *rx_handler_data);
  extern void netdev_rx_handler_unregister(struct net_device *dev);
  
 -extern int            dev_valid_name(const char *name);
 +extern bool           dev_valid_name(const char *name);
  extern int            dev_ioctl(struct net *net, unsigned int cmd, void __user *);
  extern int            dev_ethtool(struct net *net, struct ifreq *);
  extern unsigned               dev_get_flags(const struct net_device *);
@@@ -2207,7 -2187,7 +2207,7 @@@ extern void linkwatch_forget_dev(struc
   *
   * Check if carrier is present on device
   */
 -static inline int netif_carrier_ok(const struct net_device *dev)
 +static inline bool netif_carrier_ok(const struct net_device *dev)
  {
        return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  }
@@@ -2259,7 -2239,7 +2259,7 @@@ static inline void netif_dormant_off(st
   *
   * Check if carrier is present on device
   */
 -static inline int netif_dormant(const struct net_device *dev)
 +static inline bool netif_dormant(const struct net_device *dev)
  {
        return test_bit(__LINK_STATE_DORMANT, &dev->state);
  }
   *
   * Check if carrier is operational
   */
 -static inline int netif_oper_up(const struct net_device *dev)
 +static inline bool netif_oper_up(const struct net_device *dev)
  {
        return (dev->operstate == IF_OPER_UP ||
                dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
   *
   * Check if device has not been removed from system.
   */
 -static inline int netif_device_present(struct net_device *dev)
 +static inline bool netif_device_present(struct net_device *dev)
  {
        return test_bit(__LINK_STATE_PRESENT, &dev->state);
  }
@@@ -2353,9 -2333,9 +2353,9 @@@ static inline void __netif_tx_lock_bh(s
        txq->xmit_lock_owner = smp_processor_id();
  }
  
 -static inline int __netif_tx_trylock(struct netdev_queue *txq)
 +static inline bool __netif_tx_trylock(struct netdev_queue *txq)
  {
 -      int ok = spin_trylock(&txq->_xmit_lock);
 +      bool ok = spin_trylock(&txq->_xmit_lock);
        if (likely(ok))
                txq->xmit_lock_owner = smp_processor_id();
        return ok;
@@@ -2576,8 -2556,6 +2576,8 @@@ extern void             dev_load(struct net *net, 
  extern void           dev_mcast_init(void);
  extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
                                               struct rtnl_link_stats64 *storage);
 +extern void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
 +                                  const struct net_device_stats *netdev_stats);
  
  extern int            netdev_max_backlog;
  extern int            netdev_tstamp_prequeue;
@@@ -2633,7 -2611,7 +2633,7 @@@ void netif_stacked_transfer_operstate(c
  
  netdev_features_t netif_skb_features(struct sk_buff *skb);
  
 -static inline int net_gso_ok(netdev_features_t features, int gso_type)
 +static inline bool net_gso_ok(netdev_features_t features, int gso_type)
  {
        netdev_features_t feature = gso_type << NETIF_F_GSO_SHIFT;
  
        return (features & feature) == feature;
  }
  
 -static inline int skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
 +static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
  {
        return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
               (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
  }
  
 -static inline int netif_needs_gso(struct sk_buff *skb,
 -      netdev_features_t features)
 +static inline bool netif_needs_gso(struct sk_buff *skb,
 +                                 netdev_features_t features)
  {
        return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
 -              unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
 +              unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
 +                       (skb->ip_summed != CHECKSUM_UNNECESSARY)));
  }
  
  static inline void netif_set_gso_max_size(struct net_device *dev,
        dev->gso_max_size = size;
  }
  
 -static inline int netif_is_bond_slave(struct net_device *dev)
 +static inline bool netif_is_bond_slave(struct net_device *dev)
  {
        return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
  }
  
 +static inline bool netif_supports_nofcs(struct net_device *dev)
 +{
 +      return dev->priv_flags & IFF_SUPP_NOFCS;
 +}
 +
  extern struct pernet_operations __net_initdata loopback_net_ops;
  
  /* Logging, debugging and troubleshooting/diagnostic helpers. */
@@@ -2715,14 -2687,14 +2715,14 @@@ int netdev_info(const struct net_devic
  #define MODULE_ALIAS_NETDEV(device) \
        MODULE_ALIAS("netdev-" device)
  
 -#if defined(DEBUG)
 -#define netdev_dbg(__dev, format, args...)                    \
 -      netdev_printk(KERN_DEBUG, __dev, format, ##args)
 -#elif defined(CONFIG_DYNAMIC_DEBUG)
 +#if defined(CONFIG_DYNAMIC_DEBUG)
  #define netdev_dbg(__dev, format, args...)                    \
  do {                                                          \
        dynamic_netdev_dbg(__dev, format, ##args);              \
  } while (0)
 +#elif defined(DEBUG)
 +#define netdev_dbg(__dev, format, args...)                    \
 +      netdev_printk(KERN_DEBUG, __dev, format, ##args)
  #else
  #define netdev_dbg(__dev, format, args...)                    \
  ({                                                            \
@@@ -5,10 -5,11 +5,11 @@@
  #include <linux/of_platform.h> /* temporary until merge */
  
  #ifdef CONFIG_OF_DEVICE
  #include <linux/of.h>
  #include <linux/mod_devicetable.h>
  
+ struct device;
  extern const struct of_device_id *of_match_device(
        const struct of_device_id *matches, const struct device *dev);
  extern void of_device_make_bus_id(struct device *dev);
@@@ -34,8 -35,7 +35,8 @@@ extern void of_device_unregister(struc
  extern ssize_t of_device_get_modalias(struct device *dev,
                                        char *str, ssize_t len);
  
 -extern int of_device_uevent(struct device *dev, struct kobj_uevent_env *env);
 +extern void of_device_uevent(struct device *dev, struct kobj_uevent_env *env);
 +extern int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env);
  
  static inline void of_device_node_put(struct device *dev)
  {
@@@ -50,10 -50,7 +51,10 @@@ static inline int of_driver_match_devic
        return 0;
  }
  
 -static inline int of_device_uevent(struct device *dev,
 +static inline void of_device_uevent(struct device *dev,
 +                      struct kobj_uevent_env *env) { }
 +
 +static inline int of_device_uevent_modalias(struct device *dev,
                                   struct kobj_uevent_env *env)
  {
        return -ENODEV;
  #define _LINUX_PM_DOMAIN_H
  
  #include <linux/device.h>
+ #include <linux/mutex.h>
+ #include <linux/pm.h>
  #include <linux/err.h>
 +#include <linux/of.h>
  
  enum gpd_status {
        GPD_STATE_ACTIVE = 0,   /* PM domain is active */
@@@ -71,7 -72,6 +73,7 @@@ struct generic_pm_domain 
        s64 break_even_ns;      /* Power break even for the entire domain. */
        s64 max_off_time_ns;    /* Maximum allowed "suspended" time. */
        ktime_t power_off_time;
 +      struct device_node *of_node; /* Node in device tree */
  };
  
  static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
@@@ -99,15 -99,14 +101,15 @@@ struct generic_pm_domain_data 
        struct gpd_dev_ops ops;
        struct gpd_timing_data td;
        bool need_restore;
 +      bool always_on;
  };
  
 +#ifdef CONFIG_PM_GENERIC_DOMAINS
  static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
  {
        return container_of(pdd, struct generic_pm_domain_data, base);
  }
  
 -#ifdef CONFIG_PM_GENERIC_DOMAINS
  static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
  {
        return to_gpd_data(dev->power.subsys_data->domain_data);
@@@ -120,25 -119,14 +122,25 @@@ extern int __pm_genpd_add_device(struc
                                 struct device *dev,
                                 struct gpd_timing_data *td);
  
 +extern int __pm_genpd_of_add_device(struct device_node *genpd_node,
 +                                  struct device *dev,
 +                                  struct gpd_timing_data *td);
 +
  static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
                                      struct device *dev)
  {
        return __pm_genpd_add_device(genpd, dev, NULL);
  }
  
 +static inline int pm_genpd_of_add_device(struct device_node *genpd_node,
 +                                       struct device *dev)
 +{
 +      return __pm_genpd_of_add_device(genpd_node, dev, NULL);
 +}
 +
  extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
                                  struct device *dev);
 +extern void pm_genpd_dev_always_on(struct device *dev, bool val);
  extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                  struct generic_pm_domain *new_subdomain);
  extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
@@@ -157,10 -145,6 +159,10 @@@ extern bool default_stop_ok(struct devi
  extern struct dev_power_governor pm_domain_always_on_gov;
  #else
  
 +static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 +{
 +      return ERR_PTR(-ENOSYS);
 +}
  static inline struct generic_pm_domain *dev_to_genpd(struct device *dev)
  {
        return ERR_PTR(-ENOSYS);
@@@ -181,7 -165,6 +183,7 @@@ static inline int pm_genpd_remove_devic
  {
        return -ENOSYS;
  }
 +static inline void pm_genpd_dev_always_on(struct device *dev, bool val) {}
  static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                         struct generic_pm_domain *new_sd)
  {
@@@ -202,8 -185,7 +204,8 @@@ static inline int __pm_genpd_remove_cal
  {
        return -ENOSYS;
  }
 -static inline void pm_genpd_init(struct generic_pm_domain *genpd, bool is_off)
 +static inline void pm_genpd_init(struct generic_pm_domain *genpd,
 +                               struct dev_power_governor *gov, bool is_off)
  {
  }
  static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
@@@ -214,7 -196,6 +216,7 @@@ static inline bool default_stop_ok(stru
  {
        return false;
  }
 +#define simple_qos_governor NULL
  #define pm_domain_always_on_gov NULL
  #endif
  
diff --combined include/linux/regmap.h
   * published by the Free Software Foundation.
   */
  
  #include <linux/list.h>
  
  struct module;
+ struct device;
  struct i2c_client;
  struct spi_device;
 +struct regmap;
  
  /* An enum of all the supported cache types */
  enum regcache_type {
@@@ -41,13 -40,10 +41,13 @@@ struct reg_default 
        unsigned int def;
  };
  
 +#ifdef CONFIG_REGMAP
 +
  /**
   * Configuration for the register map of a device.
   *
   * @reg_bits: Number of bits in a register address, mandatory.
 + * @pad_bits: Number of bits of padding between register and value.
   * @val_bits: Number of bits in a register value, mandatory.
   *
   * @writeable_reg: Optional callback returning true if the register
@@@ -78,7 -74,6 +78,7 @@@
   */
  struct regmap_config {
        int reg_bits;
 +      int pad_bits;
        int val_bits;
  
        bool (*writeable_reg)(struct device *dev, unsigned int reg);
@@@ -132,22 -127,12 +132,22 @@@ struct regmap *regmap_init_i2c(struct i
  struct regmap *regmap_init_spi(struct spi_device *dev,
                               const struct regmap_config *config);
  
 +struct regmap *devm_regmap_init(struct device *dev,
 +                              const struct regmap_bus *bus,
 +                              const struct regmap_config *config);
 +struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
 +                                  const struct regmap_config *config);
 +struct regmap *devm_regmap_init_spi(struct spi_device *dev,
 +                                  const struct regmap_config *config);
 +
  void regmap_exit(struct regmap *map);
  int regmap_reinit_cache(struct regmap *map,
                        const struct regmap_config *config);
  int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
  int regmap_raw_write(struct regmap *map, unsigned int reg,
                     const void *val, size_t val_len);
 +int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
 +                      size_t val_count);
  int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
  int regmap_raw_read(struct regmap *map, unsigned int reg,
                    void *val, size_t val_len);
@@@ -158,18 -143,12 +158,18 @@@ int regmap_update_bits(struct regmap *m
  int regmap_update_bits_check(struct regmap *map, unsigned int reg,
                             unsigned int mask, unsigned int val,
                             bool *change);
 +int regmap_get_val_bytes(struct regmap *map);
  
  int regcache_sync(struct regmap *map);
 +int regcache_sync_region(struct regmap *map, unsigned int min,
 +                       unsigned int max);
  void regcache_cache_only(struct regmap *map, bool enable);
  void regcache_cache_bypass(struct regmap *map, bool enable);
  void regcache_mark_dirty(struct regmap *map);
  
 +int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
 +                        int num_regs);
 +
  /**
   * Description of an IRQ for the generic regmap irq_chip.
   *
@@@ -218,115 -197,4 +218,115 @@@ int regmap_add_irq_chip(struct regmap *
  void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
  int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
  
 +#else
 +
 +/*
 + * These stubs should only ever be called by generic code which has
 + * regmap based facilities, if they ever get called at runtime
 + * something is going wrong and something probably needs to select
 + * REGMAP.
 + */
 +
 +static inline int regmap_write(struct regmap *map, unsigned int reg,
 +                             unsigned int val)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
 +                                 const void *val, size_t val_len)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
 +                                  const void *val, size_t val_count)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_read(struct regmap *map, unsigned int reg,
 +                            unsigned int *val)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
 +                                void *val, size_t val_len)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
 +                                 void *val, size_t val_count)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
 +                                   unsigned int mask, unsigned int val)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_update_bits_check(struct regmap *map,
 +                                         unsigned int reg,
 +                                         unsigned int mask, unsigned int val,
 +                                         bool *change)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regmap_get_val_bytes(struct regmap *map)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regcache_sync(struct regmap *map)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline int regcache_sync_region(struct regmap *map, unsigned int min,
 +                                     unsigned int max)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +static inline void regcache_cache_only(struct regmap *map, bool enable)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +}
 +
 +static inline void regcache_cache_bypass(struct regmap *map, bool enable)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +}
 +
 +static inline void regcache_mark_dirty(struct regmap *map)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +}
 +
 +static inline int regmap_register_patch(struct regmap *map,
 +                                      const struct reg_default *regs,
 +                                      int num_regs)
 +{
 +      WARN_ONCE(1, "regmap API is disabled");
 +      return -EINVAL;
 +}
 +
 +#endif
 +
  #endif
@@@ -35,7 -35,8 +35,8 @@@
  #ifndef __LINUX_REGULATOR_CONSUMER_H_
  #define __LINUX_REGULATOR_CONSUMER_H_
  
- #include <linux/device.h>
+ struct device;
+ struct notifier_block;
  
  /*
   * Regulator operating modes.
@@@ -132,12 -133,9 +133,12 @@@ struct regulator_bulk_data 
  /* regulator get and put */
  struct regulator *__must_check regulator_get(struct device *dev,
                                             const char *id);
 +struct regulator *__must_check devm_regulator_get(struct device *dev,
 +                                           const char *id);
  struct regulator *__must_check regulator_get_exclusive(struct device *dev,
                                                       const char *id);
  void regulator_put(struct regulator *regulator);
 +void devm_regulator_put(struct regulator *regulator);
  
  /* regulator output control and status */
  int regulator_enable(struct regulator *regulator);
@@@ -148,8 -146,6 +149,8 @@@ int regulator_disable_deferred(struct r
  
  int regulator_bulk_get(struct device *dev, int num_consumers,
                       struct regulator_bulk_data *consumers);
 +int devm_regulator_bulk_get(struct device *dev, int num_consumers,
 +                          struct regulator_bulk_data *consumers);
  int regulator_bulk_enable(int num_consumers,
                          struct regulator_bulk_data *consumers);
  int regulator_bulk_disable(int num_consumers,
@@@ -205,21 -201,10 +206,21 @@@ static inline struct regulator *__must_
         */
        return NULL;
  }
 +
 +static inline struct regulator *__must_check
 +devm_regulator_get(struct device *dev, const char *id)
 +{
 +      return NULL;
 +}
 +
  static inline void regulator_put(struct regulator *regulator)
  {
  }
  
 +static inline void devm_regulator_put(struct regulator *regulator)
 +{
 +}
 +
  static inline int regulator_enable(struct regulator *regulator)
  {
        return 0;
@@@ -253,12 -238,6 +254,12 @@@ static inline int regulator_bulk_get(st
        return 0;
  }
  
 +static inline int devm_regulator_bulk_get(struct device *dev, int num_consumers,
 +                                        struct regulator_bulk_data *consumers)
 +{
 +      return 0;
 +}
 +
  static inline int regulator_bulk_enable(int num_consumers,
                                        struct regulator_bulk_data *consumers)
  {
@@@ -22,7 -22,6 +22,6 @@@
  #define _V4L2_CTRLS_H
  
  #include <linux/list.h>
- #include <linux/device.h>
  #include <linux/videodev2.h>
  
  /* forward references */
@@@ -33,7 -32,6 +32,7 @@@ struct video_device
  struct v4l2_subdev;
  struct v4l2_subscribed_event;
  struct v4l2_fh;
 +struct poll_table_struct;
  
  /** struct v4l2_ctrl_ops - The control operations that the driver has to provide.
    * @g_volatile_ctrl: Get a new value for this control. Generally only relevant
@@@ -493,18 -491,6 +492,18 @@@ void v4l2_ctrl_add_event(struct v4l2_ct
  void v4l2_ctrl_del_event(struct v4l2_ctrl *ctrl,
                struct v4l2_subscribed_event *sev);
  
 +/* Can be used as a vidioc_log_status function that just dumps all controls
 +   associated with the filehandle. */
 +int v4l2_ctrl_log_status(struct file *file, void *fh);
 +
 +/* Can be used as a vidioc_subscribe_event function that just subscribes
 +   control events. */
 +int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
 +                              struct v4l2_event_subscription *sub);
 +
 +/* Can be used as a poll function that just polls for control events. */
 +unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait);
 +
  /* Helpers for ioctl_ops. If hdl == NULL then they will all return -EINVAL. */
  int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc);
  int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm);
@@@ -11,7 -11,6 +11,6 @@@
  
  #include <linux/poll.h>
  #include <linux/fs.h>
- #include <linux/device.h>
  #include <linux/mutex.h>
  #include <linux/compiler.h> /* need __user */
  #include <linux/videodev2.h>
@@@ -211,10 -210,6 +210,10 @@@ struct v4l2_ioctl_ops 
                                        struct v4l2_encoder_cmd *a);
        int (*vidioc_try_encoder_cmd)  (struct file *file, void *fh,
                                        struct v4l2_encoder_cmd *a);
 +      int (*vidioc_decoder_cmd)      (struct file *file, void *fh,
 +                                      struct v4l2_decoder_cmd *a);
 +      int (*vidioc_try_decoder_cmd)  (struct file *file, void *fh,
 +                                      struct v4l2_decoder_cmd *a);
  
        /* Stream type-dependent parameter ioctls */
        int (*vidioc_g_parm)           (struct file *file, void *fh,
diff --combined include/net/mac80211.h
  #ifndef MAC80211_H
  #define MAC80211_H
  
 +#include <linux/bug.h>
  #include <linux/kernel.h>
  #include <linux/if_ether.h>
  #include <linux/skbuff.h>
- #include <linux/device.h>
  #include <linux/ieee80211.h>
  #include <net/cfg80211.h>
  #include <asm/unaligned.h>
@@@ -88,6 -86,8 +87,8 @@@
   *
   */
  
+ struct device;
  /**
   * enum ieee80211_max_queues - maximum number of queues
   *
@@@ -230,8 -230,7 +231,8 @@@ enum ieee80211_rssi_event 
   *    valid in station mode only while @assoc is true and if also
   *    requested by %IEEE80211_HW_NEED_DTIM_PERIOD (cf. also hw conf
   *    @ps_dtim_period)
 - * @timestamp: beacon timestamp
 + * @last_tsf: last beacon's/probe response's TSF timestamp (could be old
 + *    as it may have been received during scanning long ago)
   * @beacon_int: beacon interval
   * @assoc_capability: capabilities taken from assoc resp
   * @basic_rates: bitmap of basic rates, each bit stands for an
@@@ -278,7 -277,7 +279,7 @@@ struct ieee80211_bss_conf 
        u8 dtim_period;
        u16 beacon_int;
        u16 assoc_capability;
 -      u64 timestamp;
 +      u64 last_tsf;
        u32 basic_rates;
        int mcast_rate[IEEE80211_NUM_BANDS];
        u16 ht_operation_mode;
   *    used to indicate that a frame was already retried due to PS
   * @IEEE80211_TX_INTFL_DONT_ENCRYPT: completely internal to mac80211,
   *    used to indicate frame should not be encrypted
 - * @IEEE80211_TX_CTL_POLL_RESPONSE: This frame is a response to a poll
 - *    frame (PS-Poll or uAPSD) and should be sent although the station
 - *    is in powersave mode.
 + * @IEEE80211_TX_CTL_NO_PS_BUFFER: This frame is a response to a poll
 + *    frame (PS-Poll or uAPSD) or a non-bufferable MMPDU and must
 + *    be sent although the station is in powersave mode.
   * @IEEE80211_TX_CTL_MORE_FRAMES: More frames will be passed to the
   *    transmit function after the current frame, this can be used
   *    by drivers to kick the DMA queue only if unset or when the
@@@ -401,7 -400,7 +402,7 @@@ enum mac80211_tx_control_flags 
        IEEE80211_TX_INTFL_NEED_TXPROCESSING    = BIT(14),
        IEEE80211_TX_INTFL_RETRIED              = BIT(15),
        IEEE80211_TX_INTFL_DONT_ENCRYPT         = BIT(16),
 -      IEEE80211_TX_CTL_POLL_RESPONSE          = BIT(17),
 +      IEEE80211_TX_CTL_NO_PS_BUFFER           = BIT(17),
        IEEE80211_TX_CTL_MORE_FRAMES            = BIT(18),
        IEEE80211_TX_INTFL_RETRANSMISSION       = BIT(19),
        /* hole at 20, use later */
        IEEE80211_TX_CTL_SEND_AFTER_DTIM | IEEE80211_TX_CTL_AMPDU |           \
        IEEE80211_TX_STAT_TX_FILTERED | IEEE80211_TX_STAT_ACK |               \
        IEEE80211_TX_STAT_AMPDU | IEEE80211_TX_STAT_AMPDU_NO_BACK |           \
 -      IEEE80211_TX_CTL_RATE_CTRL_PROBE | IEEE80211_TX_CTL_POLL_RESPONSE |   \
 +      IEEE80211_TX_CTL_RATE_CTRL_PROBE | IEEE80211_TX_CTL_NO_PS_BUFFER |    \
        IEEE80211_TX_CTL_MORE_FRAMES | IEEE80211_TX_CTL_LDPC |                \
        IEEE80211_TX_CTL_STBC | IEEE80211_TX_STATUS_EOSP)
  
@@@ -661,8 -660,6 +662,8 @@@ ieee80211_tx_info_clear_status(struct i
   * @RX_FLAG_HT: HT MCS was used and rate_idx is MCS index
   * @RX_FLAG_40MHZ: HT40 (40 MHz) was used
   * @RX_FLAG_SHORT_GI: Short guard interval was used
 + * @RX_FLAG_NO_SIGNAL_VAL: The signal strength value is not present.
 + *    Valid only for data frames (mainly A-MPDU)
   */
  enum mac80211_rx_flags {
        RX_FLAG_MMIC_ERROR      = 1<<0,
        RX_FLAG_HT              = 1<<9,
        RX_FLAG_40MHZ           = 1<<10,
        RX_FLAG_SHORT_GI        = 1<<11,
 +      RX_FLAG_NO_SIGNAL_VAL   = 1<<12,
  };
  
  /**
@@@ -857,21 -853,6 +858,21 @@@ struct ieee80211_channel_switch 
  };
  
  /**
 + * enum ieee80211_vif_flags - virtual interface flags
 + *
 + * @IEEE80211_VIF_BEACON_FILTER: the device performs beacon filtering
 + *    on this virtual interface to avoid unnecessary CPU wakeups
 + * @IEEE80211_VIF_SUPPORTS_CQM_RSSI: the device can do connection quality
 + *    monitoring on this virtual interface -- i.e. it can monitor
 + *    connection quality related parameters, such as the RSSI level and
 + *    provide notifications if configured trigger levels are reached.
 + */
 +enum ieee80211_vif_flags {
 +      IEEE80211_VIF_BEACON_FILTER             = BIT(0),
 +      IEEE80211_VIF_SUPPORTS_CQM_RSSI         = BIT(1),
 +};
 +
 +/**
   * struct ieee80211_vif - per-interface data
   *
   * Data in this structure is continually present for driver
   * @addr: address of this interface
   * @p2p: indicates whether this AP or STA interface is a p2p
   *    interface, i.e. a GO or p2p-sta respectively
 + * @driver_flags: flags/capabilities the driver has for this interface,
 + *    these need to be set (or cleared) when the interface is added
 + *    or, if supported by the driver, the interface type is changed
 + *    at runtime, mac80211 will never touch this field
   * @drv_priv: data area for driver use, will always be aligned to
   *    sizeof(void *).
   */
@@@ -895,7 -872,6 +896,7 @@@ struct ieee80211_vif 
        struct ieee80211_bss_conf bss_conf;
        u8 addr[ETH_ALEN];
        bool p2p;
 +      u32 driver_flags;
        /* must be last */
        u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
  };
@@@ -987,25 -963,6 +988,25 @@@ enum set_key_cmd 
  };
  
  /**
 + * enum ieee80211_sta_state - station state
 + *
 + * @IEEE80211_STA_NOTEXIST: station doesn't exist at all,
 + *    this is a special state for add/remove transitions
 + * @IEEE80211_STA_NONE: station exists without special state
 + * @IEEE80211_STA_AUTH: station is authenticated
 + * @IEEE80211_STA_ASSOC: station is associated
 + * @IEEE80211_STA_AUTHORIZED: station is authorized (802.1X)
 + */
 +enum ieee80211_sta_state {
 +      /* NOTE: These need to be ordered correctly! */
 +      IEEE80211_STA_NOTEXIST,
 +      IEEE80211_STA_NONE,
 +      IEEE80211_STA_AUTH,
 +      IEEE80211_STA_ASSOC,
 +      IEEE80211_STA_AUTHORIZED,
 +};
 +
 +/**
   * struct ieee80211_sta - station table entry
   *
   * A station table entry represents a station we are possibly
@@@ -1123,6 -1080,10 +1124,6 @@@ enum sta_notify_cmd 
   * @IEEE80211_HW_MFP_CAPABLE:
   *    Hardware supports management frame protection (MFP, IEEE 802.11w).
   *
 - * @IEEE80211_HW_BEACON_FILTER:
 - *    Hardware supports dropping of irrelevant beacon frames to
 - *    avoid waking up cpu.
 - *
   * @IEEE80211_HW_SUPPORTS_STATIC_SMPS:
   *    Hardware supports static spatial multiplexing powersave,
   *    ie. can turn off all but one chain even on HT connections
   *      When this flag is set, signaling beacon-loss will cause an immediate
   *      change to disassociated state.
   *
 - * @IEEE80211_HW_SUPPORTS_CQM_RSSI:
 - *    Hardware can do connection quality monitoring - i.e. it can monitor
 - *    connection quality related parameters, such as the RSSI level and
 - *    provide notifications if configured trigger levels are reached.
 - *
   * @IEEE80211_HW_NEED_DTIM_PERIOD:
   *    This device needs to know the DTIM period for the BSS before
   *    associating.
   * @IEEE80211_HW_TX_AMPDU_SETUP_IN_HW: The device handles TX A-MPDU session
   *    setup strictly in HW. mac80211 should not attempt to do this in
   *    software.
 + *
 + * @IEEE80211_HW_SCAN_WHILE_IDLE: The device can do hw scan while
 + *    being idle (i.e. mac80211 doesn't have to go idle-off during the
 + *    the scan).
   */
  enum ieee80211_hw_flags {
        IEEE80211_HW_HAS_RATE_CONTROL                   = 1<<0,
        IEEE80211_HW_PS_NULLFUNC_STACK                  = 1<<11,
        IEEE80211_HW_SUPPORTS_DYNAMIC_PS                = 1<<12,
        IEEE80211_HW_MFP_CAPABLE                        = 1<<13,
 -      IEEE80211_HW_BEACON_FILTER                      = 1<<14,
 +      /* reuse bit 14 */
        IEEE80211_HW_SUPPORTS_STATIC_SMPS               = 1<<15,
        IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS              = 1<<16,
        IEEE80211_HW_SUPPORTS_UAPSD                     = 1<<17,
        IEEE80211_HW_REPORTS_TX_ACK_STATUS              = 1<<18,
        IEEE80211_HW_CONNECTION_MONITOR                 = 1<<19,
 -      IEEE80211_HW_SUPPORTS_CQM_RSSI                  = 1<<20,
 +      /* reuse bit 20 */
        IEEE80211_HW_SUPPORTS_PER_STA_GTK               = 1<<21,
        IEEE80211_HW_AP_LINK_PS                         = 1<<22,
        IEEE80211_HW_TX_AMPDU_SETUP_IN_HW               = 1<<23,
 +      IEEE80211_HW_SCAN_WHILE_IDLE                    = 1<<24,
  };
  
  /**
@@@ -1486,8 -1447,8 +1487,8 @@@ void ieee80211_free_txskb(struct ieee80
   * way the host will only receive beacons where some relevant information
   * (for example ERP protection or WMM settings) have changed.
   *
 - * Beacon filter support is advertised with the %IEEE80211_HW_BEACON_FILTER
 - * hardware capability. The driver needs to enable beacon filter support
 + * Beacon filter support is advertised with the %IEEE80211_VIF_BEACON_FILTER
 + * interface capability. The driver needs to enable beacon filter support
   * whenever power save is enabled, that is %IEEE80211_CONF_PS is set. When
   * power save is enabled, the stack will not check for beacon loss and the
   * driver needs to notify about loss of beacons with ieee80211_beacon_loss().
   * the station sends a PS-Poll or a uAPSD trigger frame, mac80211
   * will inform the driver of this with the @allow_buffered_frames
   * callback; this callback is optional. mac80211 will then transmit
 - * the frames as usual and set the %IEEE80211_TX_CTL_POLL_RESPONSE
 + * the frames as usual and set the %IEEE80211_TX_CTL_NO_PS_BUFFER
   * on each frame. The last frame in the service period (or the only
   * response to a PS-Poll) also has %IEEE80211_TX_STATUS_EOSP set to
   * indicate that it ends the service period; as this frame must have
   * When TX status is reported for this frame, the service period is
   * marked has having ended and a new one can be started by the peer.
   *
 + * Additionally, non-bufferable MMPDUs can also be transmitted by
 + * mac80211 with the %IEEE80211_TX_CTL_NO_PS_BUFFER set in them.
 + *
   * Another race condition can happen on some devices like iwlwifi
   * when there are frames queued for the station and it wakes up
   * or polls; the frames that are already queued could end up being
@@@ -1768,6 -1726,20 +1769,6 @@@ enum ieee80211_ampdu_mlme_action 
  };
  
  /**
 - * enum ieee80211_tx_sync_type - TX sync type
 - * @IEEE80211_TX_SYNC_AUTH: sync TX for authentication
 - *    (and possibly also before direct probe)
 - * @IEEE80211_TX_SYNC_ASSOC: sync TX for association
 - * @IEEE80211_TX_SYNC_ACTION: sync TX for action frame
 - *    (not implemented yet)
 - */
 -enum ieee80211_tx_sync_type {
 -      IEEE80211_TX_SYNC_AUTH,
 -      IEEE80211_TX_SYNC_ASSOC,
 -      IEEE80211_TX_SYNC_ACTION,
 -};
 -
 -/**
   * enum ieee80211_frame_release_type - frame release reason
   * @IEEE80211_FRAME_RELEASE_PSPOLL: frame released for PS-Poll
   * @IEEE80211_FRAME_RELEASE_UAPSD: frame(s) released due to
@@@ -1877,6 -1849,26 +1878,6 @@@ enum ieee80211_frame_release_type 
   *    of the bss parameters has changed when a call is made. The callback
   *    can sleep.
   *
 - * @tx_sync: Called before a frame is sent to an AP/GO. In the GO case, the
 - *    driver should sync with the GO's powersaving so the device doesn't
 - *    transmit the frame while the GO is asleep. In the regular AP case
 - *    it may be used by drivers for devices implementing other restrictions
 - *    on talking to APs, e.g. due to regulatory enforcement or just HW
 - *    restrictions.
 - *    This function is called for every authentication, association and
 - *    action frame separately since applications might attempt to auth
 - *    with multiple APs before chosing one to associate to. If it returns
 - *    an error, the corresponding authentication, association or frame
 - *    transmission is aborted and reported as having failed. It is always
 - *    called after tuning to the correct channel.
 - *    The callback might be called multiple times before @finish_tx_sync
 - *    (but @finish_tx_sync will be called once for each) but in practice
 - *    this is unlikely to happen. It can also refuse in that case if the
 - *    driver cannot handle that situation.
 - *    This callback can sleep.
 - * @finish_tx_sync: Called as a counterpart to @tx_sync, unless that returned
 - *    an error. This callback can sleep.
 - *
   * @prepare_multicast: Prepare for multicast filter configuration.
   *    This callback is optional, and its return value is passed
   *    to configure_filter(). This callback must be atomic.
   *    in AP mode, this callback will not be called when the flag
   *    %IEEE80211_HW_AP_LINK_PS is set. Must be atomic.
   *
 + * @sta_state: Notifies low level driver about state transition of a
 + *    station (which can be the AP, a client, IBSS/WDS/mesh peer etc.)
 + *    This callback is mutually exclusive with @sta_add/@sta_remove.
 + *    It must not fail for down transitions but may fail for transitions
 + *    up the list of states.
 + *    The callback can sleep.
 + *
   * @conf_tx: Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
   *    bursting) for a hardware TX queue.
   *    Returns a negative error code on failure.
   * @allow_buffered_frames: Prepare device to allow the given number of frames
   *    to go out to the given station. The frames will be sent by mac80211
   *    via the usual TX path after this call. The TX information for frames
 - *    released will also have the %IEEE80211_TX_CTL_POLL_RESPONSE flag set
 + *    released will also have the %IEEE80211_TX_CTL_NO_PS_BUFFER flag set
   *    and the last one will also have %IEEE80211_TX_STATUS_EOSP set. In case
   *    frames from multiple TIDs are released and the driver might reorder
   *    them between the TIDs, it must set the %IEEE80211_TX_STATUS_EOSP flag
@@@ -2148,6 -2133,13 +2149,6 @@@ struct ieee80211_ops 
                                 struct ieee80211_bss_conf *info,
                                 u32 changed);
  
 -      int (*tx_sync)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 -                     const u8 *bssid, enum ieee80211_tx_sync_type type);
 -      void (*finish_tx_sync)(struct ieee80211_hw *hw,
 -                             struct ieee80211_vif *vif,
 -                             const u8 *bssid,
 -                             enum ieee80211_tx_sync_type type);
 -
        u64 (*prepare_multicast)(struct ieee80211_hw *hw,
                                 struct netdev_hw_addr_list *mc_list);
        void (*configure_filter)(struct ieee80211_hw *hw,
                          struct ieee80211_sta *sta);
        void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                        enum sta_notify_cmd, struct ieee80211_sta *sta);
 +      int (*sta_state)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 +                       struct ieee80211_sta *sta,
 +                       enum ieee80211_sta_state old_state,
 +                       enum ieee80211_sta_state new_state);
        int (*conf_tx)(struct ieee80211_hw *hw,
                       struct ieee80211_vif *vif, u16 queue,
                       const struct ieee80211_tx_queue_params *params);
@@@ -3329,7 -3317,7 +3330,7 @@@ struct sk_buff *ieee80211_ap_probereq_g
   *
   * @vif: &struct ieee80211_vif pointer from the add_interface callback.
   *
 - * When beacon filtering is enabled with %IEEE80211_HW_BEACON_FILTER and
 + * When beacon filtering is enabled with %IEEE80211_VIF_BEACON_FILTER and
   * %IEEE80211_CONF_PS is set, the driver needs to inform whenever the
   * hardware is not receiving beacons with this function.
   */
@@@ -3340,7 -3328,7 +3341,7 @@@ void ieee80211_beacon_loss(struct ieee8
   *
   * @vif: &struct ieee80211_vif pointer from the add_interface callback.
   *
 - * When beacon filtering is enabled with %IEEE80211_HW_BEACON_FILTER, and
 + * When beacon filtering is enabled with %IEEE80211_VIF_BEACON_FILTER, and
   * %IEEE80211_CONF_PS and %IEEE80211_HW_CONNECTION_MONITOR are set, the driver
   * needs to inform if the connection to the AP has been lost.
   *
@@@ -3410,7 -3398,7 +3411,7 @@@ void ieee80211_enable_dyn_ps(struct iee
   * @rssi_event: the RSSI trigger event type
   * @gfp: context flags
   *
 - * When the %IEEE80211_HW_SUPPORTS_CQM_RSSI is set, and a connection quality
 + * When the %IEEE80211_VIF_SUPPORTS_CQM_RSSI is set, and a connection quality
   * monitoring is configured with an rssi threshold, the driver will inform
   * whenever the rssi level reaches the threshold.
   */
@@@ -3529,8 -3517,6 +3530,8 @@@ enum rate_control_changed 
   * @hw: The hardware the algorithm is invoked for.
   * @sband: The band this frame is being transmitted on.
   * @bss_conf: the current BSS configuration
 + * @skb: the skb that will be transmitted, the control information in it needs
 + *    to be filled in
   * @reported_rate: The rate control algorithm can fill this in to indicate
   *    which rate should be reported to userspace as the current rate and
   *    used for rate calculations in the mesh network.
   *    RTS threshold
   * @short_preamble: whether mac80211 will request short-preamble transmission
   *    if the selected rate supports it
 - * @max_rate_idx: user-requested maximum rate (not MCS for now)
 + * @max_rate_idx: user-requested maximum (legacy) rate
   *    (deprecated; this will be removed once drivers get updated to use
   *    rate_idx_mask)
 - * @rate_idx_mask: user-requested rate mask (not MCS for now)
 - * @skb: the skb that will be transmitted, the control information in it needs
 - *    to be filled in
 + * @rate_idx_mask: user-requested (legacy) rate mask
 + * @rate_idx_mcs_mask: user-requested MCS rate mask
   * @bss: whether this frame is sent out in AP or IBSS mode
   */
  struct ieee80211_tx_rate_control {
        bool rts, short_preamble;
        u8 max_rate_idx;
        u32 rate_idx_mask;
 +      u8 rate_idx_mcs_mask[IEEE80211_HT_MCS_MASK_LEN];
        bool bss;
  };
  
@@@ -1,7 -1,6 +1,6 @@@
  #ifndef _SCSI_SCSI_DEVICE_H
  #define _SCSI_SCSI_DEVICE_H
  
- #include <linux/device.h>
  #include <linux/list.h>
  #include <linux/spinlock.h>
  #include <linux/workqueue.h>
@@@ -9,6 -8,7 +8,7 @@@
  #include <scsi/scsi.h>
  #include <linux/atomic.h>
  
+ struct device;
  struct request_queue;
  struct scsi_cmnd;
  struct scsi_lun;
@@@ -136,7 -136,6 +136,7 @@@ struct scsi_device 
        unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
        unsigned skip_ms_page_8:1;      /* do not use MODE SENSE page 0x08 */
        unsigned skip_ms_page_3f:1;     /* do not use MODE SENSE page 0x3f */
 +      unsigned skip_vpd_pages:1;      /* do not read VPD pages */
        unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
        unsigned no_start_on_add:1;     /* do not issue start on add */
        unsigned allow_restart:1; /* issue START_UNIT in error handler */
@@@ -247,10 -246,8 +247,10 @@@ struct scsi_target 
        unsigned int            single_lun:1;   /* Indicates we should only
                                                 * allow I/O to one of the luns
                                                 * for the device at a time. */
 -      unsigned int            pdt_1f_for_no_lun;      /* PDT = 0x1f */
 -                                              /* means no lun present */
 +      unsigned int            pdt_1f_for_no_lun:1;    /* PDT = 0x1f
 +                                               * means no lun present. */
 +      unsigned int            no_report_luns:1;       /* Don't use
 +                                               * REPORT LUNS for scanning. */
        /* commands actually active on LLD. protected by host lock. */
        unsigned int            target_busy;
        /*
diff --combined include/sound/core.h
@@@ -26,7 -26,6 +26,6 @@@
  #include <linux/mutex.h>              /* struct mutex */
  #include <linux/rwsem.h>              /* struct rw_semaphore */
  #include <linux/pm.h>                 /* pm_message_t */
- #include <linux/device.h>
  #include <linux/stringify.h>
  
  /* number of supported soundcards */
  #define CONFIG_SND_MAJOR      116     /* standard configuration */
  
  /* forward declarations */
- #ifdef CONFIG_PCI
  struct pci_dev;
- #endif
  struct module;
+ struct device;
+ struct device_attribute;
  
  /* device allocation stuff */
  
@@@ -417,7 -416,6 +416,7 @@@ static inline int __snd_bug_on(int cond
  #define gameport_get_port_data(gp) (gp)->port_data
  #endif
  
 +#ifdef CONFIG_PCI
  /* PCI quirk list helper */
  struct snd_pci_quirk {
        unsigned short subvendor;       /* PCI subvendor ID */
@@@ -457,6 -455,5 +456,6 @@@ snd_pci_quirk_lookup(struct pci_dev *pc
  const struct snd_pci_quirk *
  snd_pci_quirk_lookup_id(u16 vendor, u16 device,
                        const struct snd_pci_quirk *list);
 +#endif
  
  #endif /* __SOUND_CORE_H */
diff --combined include/sound/soc-dapm.h
  #ifndef __LINUX_SND_SOC_DAPM_H
  #define __LINUX_SND_SOC_DAPM_H
  
  #include <linux/types.h>
  #include <sound/control.h>
  
+ struct device;
  /* widget has no PM register bit */
  #define SND_SOC_NOPM  -1
  
  {     .id = snd_soc_dapm_supply, .name = wname, .reg = wreg,  \
        .shift = wshift, .invert = winvert, .event = wevent, \
        .event_flags = wflags}
 +#define SND_SOC_DAPM_REGULATOR_SUPPLY(wname, wdelay) \
 +{     .id = snd_soc_dapm_regulator_supply, .name = wname, \
 +      .reg = SND_SOC_NOPM, .shift = wdelay, .event = dapm_regulator_event, \
 +      .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }
  
  /* dapm kcontrol types */
  #define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) \
@@@ -326,8 -323,6 +327,8 @@@ struct snd_soc_dapm_context
  
  int dapm_reg_event(struct snd_soc_dapm_widget *w,
                   struct snd_kcontrol *kcontrol, int event);
 +int dapm_regulator_event(struct snd_soc_dapm_widget *w,
 +                       struct snd_kcontrol *kcontrol, int event);
  
  /* dapm controls */
  int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
@@@ -352,12 -347,11 +353,12 @@@ int snd_soc_dapm_get_pin_switch(struct 
        struct snd_ctl_elem_value *uncontrol);
  int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *uncontrol);
  int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
        const struct snd_soc_dapm_widget *widget,
        int num);
 +int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
 +                               struct snd_soc_dai *dai);
 +int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card);
  
  /* dapm path setup */
  int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm);
@@@ -368,16 -362,10 +369,16 @@@ int snd_soc_dapm_weak_routes(struct snd
                             const struct snd_soc_dapm_route *route, int num);
  
  /* dapm events */
 -int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
 -      const char *stream, int event);
 +int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
 +                            struct snd_soc_dai *dai, int event);
  void snd_soc_dapm_shutdown(struct snd_soc_card *card);
  
 +/* external DAPM widget events */
 +int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
 +              struct snd_kcontrol *kcontrol, int connect);
 +int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
 +                               struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e);
 +
  /* dapm sys fs - used by the core */
  int snd_soc_dapm_sys_add(struct device *dev);
  void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
@@@ -424,11 -412,9 +425,11 @@@ enum snd_soc_dapm_type 
        snd_soc_dapm_pre,                       /* machine specific pre widget - exec first */
        snd_soc_dapm_post,                      /* machine specific post widget - exec last */
        snd_soc_dapm_supply,            /* power/clock supply */
 +      snd_soc_dapm_regulator_supply,  /* external regulator */
        snd_soc_dapm_aif_in,            /* audio interface input */
        snd_soc_dapm_aif_out,           /* audio interface output */
        snd_soc_dapm_siggen,            /* signal generator */
 +      snd_soc_dapm_dai,               /* link to DAI structure */
  };
  
  /*
@@@ -449,8 -435,8 +450,8 @@@ struct snd_soc_dapm_route 
  
  /* dapm audio path between two widgets */
  struct snd_soc_dapm_path {
 -      char *name;
 -      char *long_name;
 +      const char *name;
 +      const char *long_name;
  
        /* source (input) and sink (output) widgets */
        struct snd_soc_dapm_widget *source;
  /* dapm widget */
  struct snd_soc_dapm_widget {
        enum snd_soc_dapm_type id;
 -      char *name;             /* widget name */
 -      char *sname;    /* stream name */
 +      const char *name;               /* widget name */
 +      const char *sname;      /* stream name */
        struct snd_soc_codec *codec;
        struct snd_soc_platform *platform;
        struct list_head list;
        struct snd_soc_dapm_context *dapm;
  
 +      void *priv;                             /* widget specific data */
 +
        /* dapm control */
        short reg;                                              /* negative reg = no direct dapm */
        unsigned char shift;                    /* bits to shift */
@@@ -4,10 -4,10 +4,10 @@@
  #if !defined(_TRACE_REGMAP_H) || defined(TRACE_HEADER_MULTI_READ)
  #define _TRACE_REGMAP_H
  
  #include <linux/ktime.h>
  #include <linux/tracepoint.h>
  
+ struct device;
  struct regmap;
  
  /*
@@@ -139,42 -139,6 +139,42 @@@ TRACE_EVENT(regcache_sync
                  __get_str(type), __get_str(status))
  );
  
 +DECLARE_EVENT_CLASS(regmap_bool,
 +
 +      TP_PROTO(struct device *dev, bool flag),
 +
 +      TP_ARGS(dev, flag),
 +
 +      TP_STRUCT__entry(
 +              __string(       name,           dev_name(dev)   )
 +              __field(        int,            flag            )
 +      ),
 +
 +      TP_fast_assign(
 +              __assign_str(name, dev_name(dev));
 +              __entry->flag = flag;
 +      ),
 +
 +      TP_printk("%s flag=%d", __get_str(name),
 +                (int)__entry->flag)
 +);
 +
 +DEFINE_EVENT(regmap_bool, regmap_cache_only,
 +
 +      TP_PROTO(struct device *dev, bool flag),
 +
 +      TP_ARGS(dev, flag)
 +
 +);
 +
 +DEFINE_EVENT(regmap_bool, regmap_cache_bypass,
 +
 +      TP_PROTO(struct device *dev, bool flag),
 +
 +      TP_ARGS(dev, flag)
 +
 +);
 +
  #endif /* _TRACE_REGMAP_H */
  
  /* This part must be outside protection */
@@@ -5,7 -5,6 +5,6 @@@
  #define _TRACE_WRITEBACK_H
  
  #include <linux/backing-dev.h>
- #include <linux/device.h>
  #include <linux/writeback.h>
  
  #define show_inode_state(state)                                       \
@@@ -47,10 -46,7 +46,10 @@@ DECLARE_EVENT_CLASS(writeback_work_clas
                __field(int, reason)
        ),
        TP_fast_assign(
 -              strncpy(__entry->name, dev_name(bdi->dev), 32);
 +              struct device *dev = bdi->dev;
 +              if (!dev)
 +                      dev = default_backing_dev_info.dev;
 +              strncpy(__entry->name, dev_name(dev), 32);
                __entry->nr_pages = work->nr_pages;
                __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
                __entry->sync_mode = work->sync_mode;
@@@ -429,7 -425,7 +428,7 @@@ DECLARE_EVENT_CLASS(writeback_single_in
  
        TP_fast_assign(
                strncpy(__entry->name,
 -                      dev_name(inode->i_mapping->backing_dev_info->dev), 32);
 +                      dev_name(inode_to_bdi(inode)->dev), 32);
                __entry->ino            = inode->i_ino;
                __entry->state          = inode->i_state;
                __entry->dirtied_when   = inode->dirtied_when;
diff --combined sound/core/init.c
@@@ -22,6 -22,7 +22,7 @@@
  #include <linux/init.h>
  #include <linux/sched.h>
  #include <linux/module.h>
+ #include <linux/device.h>
  #include <linux/file.h>
  #include <linux/slab.h>
  #include <linux/time.h>
@@@ -480,104 -481,74 +481,104 @@@ int snd_card_free(struct snd_card *card
  
  EXPORT_SYMBOL(snd_card_free);
  
 -static void snd_card_set_id_no_lock(struct snd_card *card, const char *nid)
 +/* retrieve the last word of shortname or longname */
 +static const char *retrieve_id_from_card_name(const char *name)
  {
 -      int i, len, idx_flag = 0, loops = SNDRV_CARDS;
 -      const char *spos, *src;
 -      char *id;
 -      
 -      if (nid == NULL) {
 -              id = card->shortname;
 -              spos = src = id;
 -              while (*id != '\0') {
 -                      if (*id == ' ')
 -                              spos = id + 1;
 -                      id++;
 -              }
 -      } else {
 -              spos = src = nid;
 +      const char *spos = name;
 +
 +      while (*name) {
 +              if (isspace(*name) && isalnum(name[1]))
 +                      spos = name + 1;
 +              name++;
        }
 -      id = card->id;
 -      while (*spos != '\0' && !isalnum(*spos))
 -              spos++;
 -      if (isdigit(*spos))
 -              *id++ = isalpha(src[0]) ? src[0] : 'D';
 -      while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
 -              if (isalnum(*spos))
 -                      *id++ = *spos;
 -              spos++;
 +      return spos;
 +}
 +
 +/* return true if the given id string doesn't conflict any other card ids */
 +static bool card_id_ok(struct snd_card *card, const char *id)
 +{
 +      int i;
 +      if (!snd_info_check_reserved_words(id))
 +              return false;
 +      for (i = 0; i < snd_ecards_limit; i++) {
 +              if (snd_cards[i] && snd_cards[i] != card &&
 +                  !strcmp(snd_cards[i]->id, id))
 +                      return false;
        }
 -      *id = '\0';
 +      return true;
 +}
  
 -      id = card->id;
 +/* copy to card->id only with valid letters from nid */
 +static void copy_valid_id_string(struct snd_card *card, const char *src,
 +                               const char *nid)
 +{
 +      char *id = card->id;
 +
 +      while (*nid && !isalnum(*nid))
 +              nid++;
 +      if (isdigit(*nid))
 +              *id++ = isalpha(*src) ? *src : 'D';
 +      while (*nid && (size_t)(id - card->id) < sizeof(card->id) - 1) {
 +              if (isalnum(*nid))
 +                      *id++ = *nid;
 +              nid++;
 +      }
 +      *id = 0;
 +}
 +
 +/* Set card->id from the given string
 + * If the string conflicts with other ids, add a suffix to make it unique.
 + */
 +static void snd_card_set_id_no_lock(struct snd_card *card, const char *src,
 +                                  const char *nid)
 +{
 +      int len, loops;
 +      bool with_suffix;
 +      bool is_default = false;
 +      char *id;
        
 -      if (*id == '\0')
 +      copy_valid_id_string(card, src, nid);
 +      id = card->id;
 +
 + again:
 +      /* use "Default" for obviously invalid strings
 +       * ("card" conflicts with proc directories)
 +       */
 +      if (!*id || !strncmp(id, "card", 4)) {
                strcpy(id, "Default");
 +              is_default = true;
 +      }
  
 -      while (1) {
 -              if (loops-- == 0) {
 -                      snd_printk(KERN_ERR "unable to set card id (%s)\n", id);
 -                              strcpy(card->id, card->proc_root->name);
 -                              return;
 -                      }
 -              if (!snd_info_check_reserved_words(id))
 -                              goto __change;
 -              for (i = 0; i < snd_ecards_limit; i++) {
 -                      if (snd_cards[i] && !strcmp(snd_cards[i]->id, id))
 -                              goto __change;
 -              }
 -              break;
 +      with_suffix = false;
 +      for (loops = 0; loops < SNDRV_CARDS; loops++) {
 +              if (card_id_ok(card, id))
 +                      return; /* OK */
  
 -            __change:
                len = strlen(id);
 -              if (idx_flag) {
 -                      if (id[len-1] != '9')
 -                              id[len-1]++;
 -                      else
 -                              id[len-1] = 'A';
 -              } else if ((size_t)len <= sizeof(card->id) - 3) {
 -                      strcat(id, "_1");
 -                      idx_flag++;
 +              if (!with_suffix) {
 +                      /* add the "_X" suffix */
 +                      char *spos = id + len;
 +                      if (len >  sizeof(card->id) - 3)
 +                              spos = id + sizeof(card->id) - 3;
 +                      strcpy(spos, "_1");
 +                      with_suffix = true;
                } else {
 -                      spos = id + len - 2;
 -                      if ((size_t)len <= sizeof(card->id) - 2)
 -                              spos++;
 -                      *(char *)spos++ = '_';
 -                      *(char *)spos++ = '1';
 -                      *(char *)spos++ = '\0';
 -                      idx_flag++;
 +                      /* modify the existing suffix */
 +                      if (id[len - 1] != '9')
 +                              id[len - 1]++;
 +                      else
 +                              id[len - 1] = 'A';
                }
        }
 +      /* fallback to the default id */
 +      if (!is_default) {
 +              *id = 0;
 +              goto again;
 +      }
 +      /* last resort... */
 +      snd_printk(KERN_ERR "unable to set card id (%s)\n", id);
 +      if (card->proc_root->name)
 +              strcpy(card->id, card->proc_root->name);
  }
  
  /**
@@@ -594,7 -565,7 +595,7 @@@ void snd_card_set_id(struct snd_card *c
        if (card->id[0] != '\0')
                return;
        mutex_lock(&snd_card_mutex);
 -      snd_card_set_id_no_lock(card, nid);
 +      snd_card_set_id_no_lock(card, nid, nid);
        mutex_unlock(&snd_card_mutex);
  }
  EXPORT_SYMBOL(snd_card_set_id);
@@@ -626,12 -597,22 +627,12 @@@ card_id_store_attr(struct device *dev, 
        memcpy(buf1, buf, copy);
        buf1[copy] = '\0';
        mutex_lock(&snd_card_mutex);
 -      if (!snd_info_check_reserved_words(buf1)) {
 -           __exist:
 +      if (!card_id_ok(NULL, buf1)) {
                mutex_unlock(&snd_card_mutex);
                return -EEXIST;
        }
 -      for (idx = 0; idx < snd_ecards_limit; idx++) {
 -              if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1)) {
 -                      if (card == snd_cards[idx])
 -                              goto __ok;
 -                      else
 -                              goto __exist;
 -              }
 -      }
        strcpy(card->id, buf1);
        snd_info_card_id_change(card);
 -__ok:
        mutex_unlock(&snd_card_mutex);
  
        return count;
@@@ -685,18 -666,7 +686,18 @@@ int snd_card_register(struct snd_card *
                mutex_unlock(&snd_card_mutex);
                return 0;
        }
 -      snd_card_set_id_no_lock(card, card->id[0] == '\0' ? NULL : card->id);
 +      if (*card->id) {
 +              /* make a unique id name from the given string */
 +              char tmpid[sizeof(card->id)];
 +              memcpy(tmpid, card->id, sizeof(card->id));
 +              snd_card_set_id_no_lock(card, tmpid, tmpid);
 +      } else {
 +              /* create an id from either shortname or longname */
 +              const char *src;
 +              src = *card->shortname ? card->shortname : card->longname;
 +              snd_card_set_id_no_lock(card, src,
 +                                      retrieve_id_from_card_name(src));
 +      }
        snd_cards[card->number] = card;
        mutex_unlock(&snd_card_mutex);
        init_info_for_card(card);
diff --combined sound/core/pcm.c
@@@ -24,6 -24,7 +24,7 @@@
  #include <linux/module.h>
  #include <linux/time.h>
  #include <linux/mutex.h>
+ #include <linux/device.h>
  #include <sound/core.h>
  #include <sound/minors.h>
  #include <sound/pcm.h>
@@@ -650,7 -651,7 +651,7 @@@ int snd_pcm_new_stream(struct snd_pcm *
        pstr->stream = stream;
        pstr->pcm = pcm;
        pstr->substream_count = substream_count;
 -      if (substream_count > 0) {
 +      if (substream_count > 0 && !pcm->internal) {
                err = snd_pcm_stream_proc_init(pstr);
                if (err < 0) {
                        snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
                        pstr->substream = substream;
                else
                        prev->next = substream;
 -              err = snd_pcm_substream_proc_init(substream);
 -              if (err < 0) {
 -                      snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
 -                      if (prev == NULL)
 -                              pstr->substream = NULL;
 -                      else
 -                              prev->next = NULL;
 -                      kfree(substream);
 -                      return err;
 +
 +              if (!pcm->internal) {
 +                      err = snd_pcm_substream_proc_init(substream);
 +                      if (err < 0) {
 +                              snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
 +                              if (prev == NULL)
 +                                      pstr->substream = NULL;
 +                              else
 +                                      prev->next = NULL;
 +                              kfree(substream);
 +                              return err;
 +                      }
                }
                substream->group = &substream->self_group;
                spin_lock_init(&substream->self_group.lock);
  
  EXPORT_SYMBOL(snd_pcm_new_stream);
  
 -/**
 - * snd_pcm_new - create a new PCM instance
 - * @card: the card instance
 - * @id: the id string
 - * @device: the device index (zero based)
 - * @playback_count: the number of substreams for playback
 - * @capture_count: the number of substreams for capture
 - * @rpcm: the pointer to store the new pcm instance
 - *
 - * Creates a new PCM instance.
 - *
 - * The pcm operators have to be set afterwards to the new instance
 - * via snd_pcm_set_ops().
 - *
 - * Returns zero if successful, or a negative error code on failure.
 - */
 -int snd_pcm_new(struct snd_card *card, const char *id, int device,
 -              int playback_count, int capture_count,
 -              struct snd_pcm ** rpcm)
 +static int _snd_pcm_new(struct snd_card *card, const char *id, int device,
 +              int playback_count, int capture_count, bool internal,
 +              struct snd_pcm **rpcm)
  {
        struct snd_pcm *pcm;
        int err;
        }
        pcm->card = card;
        pcm->device = device;
 +      pcm->internal = internal;
        if (id)
                strlcpy(pcm->id, id, sizeof(pcm->id));
        if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) {
        return 0;
  }
  
 +/**
 + * snd_pcm_new - create a new PCM instance
 + * @card: the card instance
 + * @id: the id string
 + * @device: the device index (zero based)
 + * @playback_count: the number of substreams for playback
 + * @capture_count: the number of substreams for capture
 + * @rpcm: the pointer to store the new pcm instance
 + *
 + * Creates a new PCM instance.
 + *
 + * The pcm operators have to be set afterwards to the new instance
 + * via snd_pcm_set_ops().
 + *
 + * Returns zero if successful, or a negative error code on failure.
 + */
 +int snd_pcm_new(struct snd_card *card, const char *id, int device,
 +              int playback_count, int capture_count, struct snd_pcm **rpcm)
 +{
 +      return _snd_pcm_new(card, id, device, playback_count, capture_count,
 +                      false, rpcm);
 +}
  EXPORT_SYMBOL(snd_pcm_new);
  
 +/**
 + * snd_pcm_new_internal - create a new internal PCM instance
 + * @card: the card instance
 + * @id: the id string
 + * @device: the device index (zero based - shared with normal PCMs)
 + * @playback_count: the number of substreams for playback
 + * @capture_count: the number of substreams for capture
 + * @rpcm: the pointer to store the new pcm instance
 + *
 + * Creates a new internal PCM instance with no userspace device or procfs
 + * entries. This is used by ASoC Back End PCMs in order to create a PCM that
 + * will only be used internally by kernel drivers. i.e. it cannot be opened
 + * by userspace. It provides existing ASoC components drivers with a substream
 + * and access to any private data.
 + *
 + * The pcm operators have to be set afterwards to the new instance
 + * via snd_pcm_set_ops().
 + *
 + * Returns zero if successful, or a negative error code on failure.
 + */
 +int snd_pcm_new_internal(struct snd_card *card, const char *id, int device,
 +      int playback_count, int capture_count,
 +      struct snd_pcm **rpcm)
 +{
 +      return _snd_pcm_new(card, id, device, playback_count, capture_count,
 +                      true, rpcm);
 +}
 +EXPORT_SYMBOL(snd_pcm_new_internal);
 +
  static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
  {
        struct snd_pcm_substream *substream, *substream_next;
@@@ -1033,7 -995,7 +1034,7 @@@ static int snd_pcm_dev_register(struct 
        }
        for (cidx = 0; cidx < 2; cidx++) {
                int devtype = -1;
 -              if (pcm->streams[cidx].substream == NULL)
 +              if (pcm->streams[cidx].substream == NULL || pcm->internal)
                        continue;
                switch (cidx) {
                case SNDRV_PCM_STREAM_PLAYBACK: