Merge tag 'sound-4.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

Pull sound updates from Takashi Iwai:
 "This development cycle resulted in a fair amount of changes in both
  core and driver sides. The most significant change in ALSA core is
  about PCM. Also the support of of-graph card and the new DAPM widget
  for DSP are noteworthy changes in ASoC core. And there're lots of
  small changes splat over the tree, as you can see in diffstat.

  Below are a few highlights:

  ALSA core:
   - Removal of set_fs() hackery from PCM core stuff, and the code
     reorganization / optimization thereafter
   - Improved support of PCM ack ops, and a new ABI for improved
     control/status mmap handling
   - Lots of constifications in various codes

  ASoC core:
   - The support of of-graph card, which may work as a better generic
     device for a replacement of simple-card
   - New widget types intended mainly for use with DSPs

  ASoC drivers:
   - New drivers for Allwinner V3s SoCs
   - Ensonic ES8316 codec support
   - More Intel SKL and KBL works
   - More device support for Intel SST Atom (mostly for cheap tablets
     and 2-in-1 devices)
   - Support for Rockchip PDM controllers
   - Support for STM32 I2S and S/PDIF controllers
   - Support for ZTE AUD96P22 codecs

  HD-audio:
   - Support of new Realtek codecs (ALC215/ALC285/ALC289), more quirks
     for HP and Dell machines
   - A few more fixes for i915 component binding"

* tag 'sound-4.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (418 commits)
  ALSA: hda - Fix unbalance of i915 module refcount
  ASoC: Intel: Skylake: Remove driver debugfs exit
  ASoC: Intel: Skylake: explicitly add the headers sst-dsp.h
  ALSA: hda/realtek - Remove GPIO_MASK
  ALSA: hda/realtek - Fix typo of pincfg for Dell quirk
  ALSA: pcm: add a documentation for tracepoints
  ALSA: atmel: ac97c: fix error return code in atmel_ac97c_probe()
  ALSA: x86: fix error return code in hdmi_lpe_audio_probe()
  ASoC: Intel: Skylake: Add support to read firmware registers
  ASoC: Intel: Skylake: Add sram address to sst_addr structure
  ASoC: Intel: Skylake: Debugfs facility to dump module config
  ASoC: Intel: Skylake: Add debugfs support
  ASoC: fix semicolon.cocci warnings
  ASoC: rt5645: Add quirk override by module option
  ASoC: rsnd: make arrays path and cmd_case static const
  ASoC: audio-graph-card: add widgets and routing for external amplifier support
  ASoC: audio-graph-card: update bindings for amplifier support
  ASoC: rt5665: calibration should be done before jack detection
  ASoC: rsnd: constify dev_pm_ops structures.
  ASoC: nau8825: change crosstalk-bypass property to bool type
  ...

1 files changed, 24 insertions, 77 deletions

diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index cd8b7bef8d06..e49f448ee04f 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -67,18 +67,6 @@ static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file);
 static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file);
 static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file);
 
-static inline mm_segment_t snd_enter_user(void)
-{
-        mm_segment_t fs = get_fs();
-        set_fs(get_ds());
-        return fs;
-}
-
-static inline void snd_leave_user(mm_segment_t fs)
-{
-        set_fs(fs);
-}
-
 /*
  * helper functions to process hw_params
  */
@@ -799,7 +787,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream,
 static int choose_rate(struct snd_pcm_substream *substream,
                        struct snd_pcm_hw_params *params, unsigned int best_rate)
 {
-        struct snd_interval *it;
+        const struct snd_interval *it;
         struct snd_pcm_hw_params *save;
         unsigned int rate, prev;
 
@@ -807,7 +795,7 @@ static int choose_rate(struct snd_pcm_substream *substream,
         if (save == NULL)
                 return -ENOMEM;
         *save = *params;
-        it = hw_param_interval(save, SNDRV_PCM_HW_PARAM_RATE);
+        it = hw_param_interval_c(save, SNDRV_PCM_HW_PARAM_RATE);
 
         /* try multiples of the best rate */
         rate = best_rate;
@@ -848,7 +836,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream,
         int direct;
         snd_pcm_format_t format, sformat;
         int n;
-        struct snd_mask sformat_mask;
+        const struct snd_mask *sformat_mask;
         struct snd_mask mask;
 
         if (trylock) {
@@ -891,18 +879,18 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream,
 
         format = snd_pcm_oss_format_from(runtime->oss.format);
 
-        sformat_mask = *hw_param_mask(sparams, SNDRV_PCM_HW_PARAM_FORMAT);
+        sformat_mask = hw_param_mask_c(sparams, SNDRV_PCM_HW_PARAM_FORMAT);
         if (direct)
                 sformat = format;
         else
-                sformat = snd_pcm_plug_slave_format(format, &sformat_mask);
+                sformat = snd_pcm_plug_slave_format(format, sformat_mask);
 
         if ((__force int)sformat < 0 ||
-            !snd_mask_test(&sformat_mask, (__force int)sformat)) {
+            !snd_mask_test(sformat_mask, (__force int)sformat)) {
                 for (sformat = (__force snd_pcm_format_t)0;
                      (__force int)sformat <= (__force int)SNDRV_PCM_FORMAT_LAST;
                      sformat = (__force snd_pcm_format_t)((__force int)sformat + 1)) {
-                        if (snd_mask_test(&sformat_mask, (__force int)sformat) &&
+                        if (snd_mask_test(sformat_mask, (__force int)sformat) &&
                             snd_pcm_oss_format_to(sformat) >= 0)
                                 break;
                 }
@@ -1191,14 +1179,8 @@ snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const
                         if (ret < 0)
                                 break;
                 }
-                if (in_kernel) {
-                        mm_segment_t fs;
-                        fs = snd_enter_user();
-                        ret = snd_pcm_lib_write(substream, (void __force __user *)ptr, frames);
-                        snd_leave_user(fs);
-                } else {
-                        ret = snd_pcm_lib_write(substream, (void __force __user *)ptr, frames);
-                }
+                ret = __snd_pcm_lib_xfer(substream, (void *)ptr, true,
+                                         frames, in_kernel);
                 if (ret != -EPIPE && ret != -ESTRPIPE)
                         break;
                 /* test, if we can't store new data, because the stream */
@@ -1234,14 +1216,8 @@ snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *p
                 ret = snd_pcm_oss_capture_position_fixup(substream, &delay);
                 if (ret < 0)
                         break;
-                if (in_kernel) {
-                        mm_segment_t fs;
-                        fs = snd_enter_user();
-                        ret = snd_pcm_lib_read(substream, (void __force __user *)ptr, frames);
-                        snd_leave_user(fs);
-                } else {
-                        ret = snd_pcm_lib_read(substream, (void __force __user *)ptr, frames);
-                }
+                ret = __snd_pcm_lib_xfer(substream, (void *)ptr, true,
+                                         frames, in_kernel);
                 if (ret == -EPIPE) {
                         if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
                                 ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
@@ -1256,7 +1232,8 @@ snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *p
         return ret;
 }
 
-snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
+#ifdef CONFIG_SND_PCM_OSS_PLUGINS
+snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         int ret;
@@ -1273,14 +1250,7 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void
                         if (ret < 0)
                                 break;
                 }
-                if (in_kernel) {
-                        mm_segment_t fs;
-                        fs = snd_enter_user();
-                        ret = snd_pcm_lib_writev(substream, (void __user **)bufs, frames);
-                        snd_leave_user(fs);
-                } else {
-                        ret = snd_pcm_lib_writev(substream, (void __user **)bufs, frames);
-                }
+                ret = snd_pcm_kernel_writev(substream, bufs, frames);
                 if (ret != -EPIPE && ret != -ESTRPIPE)
                         break;
 
@@ -1292,7 +1262,7 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void
         return ret;
 }
         
-snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel)
+snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         int ret;
@@ -1313,19 +1283,13 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void *
                         if (ret < 0)
                                 break;
                 }
-                if (in_kernel) {
-                        mm_segment_t fs;
-                        fs = snd_enter_user();
-                        ret = snd_pcm_lib_readv(substream, (void __user **)bufs, frames);
-                        snd_leave_user(fs);
-                } else {
-                        ret = snd_pcm_lib_readv(substream, (void __user **)bufs, frames);
-                }
+                ret = snd_pcm_kernel_readv(substream, bufs, frames);
                 if (ret != -EPIPE && ret != -ESTRPIPE)
                         break;
         }
         return ret;
 }
+#endif /* CONFIG_SND_PCM_OSS_PLUGINS */
 
 static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel)
 {
@@ -1650,27 +1614,10 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                 size = runtime->control->appl_ptr % runtime->period_size;
                 if (size > 0) {
                         size = runtime->period_size - size;
-                        if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
-                                size = (runtime->frame_bits * size) / 8;
-                                while (size > 0) {
-                                        mm_segment_t fs;
-                                        size_t size1 = size < runtime->oss.period_bytes ? size : runtime->oss.period_bytes;
-                                        size -= size1;
-                                        size1 *= 8;
-                                        size1 /= runtime->sample_bits;
-                                        snd_pcm_format_set_silence(runtime->format,
-                                                                   runtime->oss.buffer,
-                                                                   size1);
-                                        size1 /= runtime->channels; /* frames */
-                                        fs = snd_enter_user();
-                                        snd_pcm_lib_write(substream, (void __force __user *)runtime->oss.buffer, size1);
-                                        snd_leave_user(fs);
-                                }
-                        } else if (runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) {
-                                void __user *buffers[runtime->channels];
-                                memset(buffers, 0, runtime->channels * sizeof(void *));
-                                snd_pcm_lib_writev(substream, buffers, size);
-                        }
+                        if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED)
+                                snd_pcm_lib_write(substream, NULL, size);
+                        else if (runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
+                                snd_pcm_lib_writev(substream, NULL, size);
                 }
                 mutex_unlock(&runtime->oss.params_lock);
                 /*
@@ -1780,7 +1727,7 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
         int direct;
         struct snd_pcm_hw_params *params;
         unsigned int formats = 0;
-        struct snd_mask format_mask;
+        const struct snd_mask *format_mask;
         int fmt;
 
         if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
@@ -1802,12 +1749,12 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
                 return -ENOMEM;
         _snd_pcm_hw_params_any(params);
         err = snd_pcm_hw_refine(substream, params);
-        format_mask = *hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 
+        format_mask = hw_param_mask_c(params, SNDRV_PCM_HW_PARAM_FORMAT);
         kfree(params);
         if (err < 0)
                 return err;
         for (fmt = 0; fmt < 32; ++fmt) {
-                if (snd_mask_test(&format_mask, fmt)) {
+                if (snd_mask_test(format_mask, fmt)) {
                         int f = snd_pcm_oss_format_to(fmt);
                         if (f >= 0)
                                 formats |= f;