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, 60 insertions, 65 deletions

diff --git a/sound/core/timer.c b/sound/core/timer.c
index 884c3066b028..a9b9a277e00c 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -319,6 +319,7 @@ int snd_timer_open(struct snd_timer_instance **ti,
         *ti = timeri;
         return 0;
 }
+EXPORT_SYMBOL(snd_timer_open);
 
 /*
  * close a timer instance
@@ -384,6 +385,7 @@ int snd_timer_close(struct snd_timer_instance *timeri)
         mutex_unlock(&register_mutex);
         return 0;
 }
+EXPORT_SYMBOL(snd_timer_close);
 
 unsigned long snd_timer_resolution(struct snd_timer_instance *timeri)
 {
@@ -398,6 +400,7 @@ unsigned long snd_timer_resolution(struct snd_timer_instance *timeri)
         }
         return 0;
 }
+EXPORT_SYMBOL(snd_timer_resolution);
 
 static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
 {
@@ -589,6 +592,7 @@ int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks)
         else
                 return snd_timer_start1(timeri, true, ticks);
 }
+EXPORT_SYMBOL(snd_timer_start);
 
 /*
  * stop the timer instance.
@@ -602,6 +606,7 @@ int snd_timer_stop(struct snd_timer_instance *timeri)
         else
                 return snd_timer_stop1(timeri, true);
 }
+EXPORT_SYMBOL(snd_timer_stop);
 
 /*
  * start again..  the tick is kept.
@@ -617,6 +622,7 @@ int snd_timer_continue(struct snd_timer_instance *timeri)
         else
                 return snd_timer_start1(timeri, false, 0);
 }
+EXPORT_SYMBOL(snd_timer_continue);
 
 /*
  * pause.. remember the ticks left
@@ -628,6 +634,7 @@ int snd_timer_pause(struct snd_timer_instance * timeri)
         else
                 return snd_timer_stop1(timeri, false);
 }
+EXPORT_SYMBOL(snd_timer_pause);
 
 /*
  * reschedule the timer
@@ -809,6 +816,7 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left)
         if (use_tasklet)
                 tasklet_schedule(&timer->task_queue);
 }
+EXPORT_SYMBOL(snd_timer_interrupt);
 
 /*
 
@@ -859,6 +867,7 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
                 *rtimer = timer;
         return 0;
 }
+EXPORT_SYMBOL(snd_timer_new);
 
 static int snd_timer_free(struct snd_timer *timer)
 {
@@ -978,6 +987,7 @@ void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstam
         }
         spin_unlock_irqrestore(&timer->lock, flags);
 }
+EXPORT_SYMBOL(snd_timer_notify);
 
 /*
  * exported functions for global timers
@@ -993,11 +1003,13 @@ int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer)
         tid.subdevice = 0;
         return snd_timer_new(NULL, id, &tid, rtimer);
 }
+EXPORT_SYMBOL(snd_timer_global_new);
 
 int snd_timer_global_free(struct snd_timer *timer)
 {
         return snd_timer_free(timer);
 }
+EXPORT_SYMBOL(snd_timer_global_free);
 
 int snd_timer_global_register(struct snd_timer *timer)
 {
@@ -1007,6 +1019,7 @@ int snd_timer_global_register(struct snd_timer *timer)
         dev.device_data = timer;
         return snd_timer_dev_register(&dev);
 }
+EXPORT_SYMBOL(snd_timer_global_register);
 
 /*
  *  System timer
@@ -1327,6 +1340,33 @@ static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
         wake_up(&tu->qchange_sleep);
 }
 
+static int realloc_user_queue(struct snd_timer_user *tu, int size)
+{
+        struct snd_timer_read *queue = NULL;
+        struct snd_timer_tread *tqueue = NULL;
+
+        if (tu->tread) {
+                tqueue = kcalloc(size, sizeof(*tqueue), GFP_KERNEL);
+                if (!tqueue)
+                        return -ENOMEM;
+        } else {
+                queue = kcalloc(size, sizeof(*queue), GFP_KERNEL);
+                if (!queue)
+                        return -ENOMEM;
+        }
+
+        spin_lock_irq(&tu->qlock);
+        kfree(tu->queue);
+        kfree(tu->tqueue);
+        tu->queue_size = size;
+        tu->queue = queue;
+        tu->tqueue = tqueue;
+        tu->qhead = tu->qtail = tu->qused = 0;
+        spin_unlock_irq(&tu->qlock);
+
+        return 0;
+}
+
 static int snd_timer_user_open(struct inode *inode, struct file *file)
 {
         struct snd_timer_user *tu;
@@ -1343,10 +1383,7 @@ static int snd_timer_user_open(struct inode *inode, struct file *file)
         init_waitqueue_head(&tu->qchange_sleep);
         mutex_init(&tu->ioctl_lock);
         tu->ticks = 1;
-        tu->queue_size = 128;
-        tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read),
-                            GFP_KERNEL);
-        if (tu->queue == NULL) {
+        if (realloc_user_queue(tu, 128) < 0) {
                 kfree(tu);
                 return -ENOMEM;
         }
@@ -1618,34 +1655,12 @@ static int snd_timer_user_tselect(struct file *file,
         if (err < 0)
                 goto __err;
 
-        tu->qhead = tu->qtail = tu->qused = 0;
-        kfree(tu->queue);
-        tu->queue = NULL;
-        kfree(tu->tqueue);
-        tu->tqueue = NULL;
-        if (tu->tread) {
-                tu->tqueue = kmalloc(tu->queue_size * sizeof(struct snd_timer_tread),
-                                     GFP_KERNEL);
-                if (tu->tqueue == NULL)
-                        err = -ENOMEM;
-        } else {
-                tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read),
-                                    GFP_KERNEL);
-                if (tu->queue == NULL)
-                        err = -ENOMEM;
-        }
-
-        if (err < 0) {
-                snd_timer_close(tu->timeri);
-                tu->timeri = NULL;
-        } else {
-                tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;
-                tu->timeri->callback = tu->tread
+        tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;
+        tu->timeri->callback = tu->tread
                         ? snd_timer_user_tinterrupt : snd_timer_user_interrupt;
-                tu->timeri->ccallback = snd_timer_user_ccallback;
-                tu->timeri->callback_data = (void *)tu;
-                tu->timeri->disconnect = snd_timer_user_disconnect;
-        }
+        tu->timeri->ccallback = snd_timer_user_ccallback;
+        tu->timeri->callback_data = (void *)tu;
+        tu->timeri->disconnect = snd_timer_user_disconnect;
 
       __err:
         return err;
@@ -1687,8 +1702,6 @@ static int snd_timer_user_params(struct file *file,
         struct snd_timer_user *tu;
         struct snd_timer_params params;
         struct snd_timer *t;
-        struct snd_timer_read *tr;
-        struct snd_timer_tread *ttr;
         int err;
 
         tu = file->private_data;
@@ -1751,24 +1764,11 @@ static int snd_timer_user_params(struct file *file,
         spin_unlock_irq(&t->lock);
         if (params.queue_size > 0 &&
             (unsigned int)tu->queue_size != params.queue_size) {
-                if (tu->tread) {
-                        ttr = kmalloc(params.queue_size * sizeof(*ttr),
-                                      GFP_KERNEL);
-                        if (ttr) {
-                                kfree(tu->tqueue);
-                                tu->queue_size = params.queue_size;
-                                tu->tqueue = ttr;
-                        }
-                } else {
-                        tr = kmalloc(params.queue_size * sizeof(*tr),
-                                     GFP_KERNEL);
-                        if (tr) {
-                                kfree(tu->queue);
-                                tu->queue_size = params.queue_size;
-                                tu->queue = tr;
-                        }
-                }
+                err = realloc_user_queue(tu, params.queue_size);
+                if (err < 0)
+                        goto _end;
         }
+        spin_lock_irq(&tu->qlock);
         tu->qhead = tu->qtail = tu->qused = 0;
         if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {
                 if (tu->tread) {
@@ -1789,6 +1789,7 @@ static int snd_timer_user_params(struct file *file,
         }
         tu->filter = params.filter;
         tu->ticks = params.ticks;
+        spin_unlock_irq(&tu->qlock);
         err = 0;
  _end:
         if (copy_to_user(_params, &params, sizeof(params)))
@@ -1891,13 +1892,19 @@ static long __snd_timer_user_ioctl(struct file *file, unsigned int cmd,
                 return snd_timer_user_next_device(argp);
         case SNDRV_TIMER_IOCTL_TREAD:
         {
-                int xarg;
+                int xarg, old_tread;
 
                 if (tu->timeri) /* too late */
                         return -EBUSY;
                 if (get_user(xarg, p))
                         return -EFAULT;
+                old_tread = tu->tread;
                 tu->tread = xarg ? 1 : 0;
+                if (tu->tread != old_tread &&
+                    realloc_user_queue(tu, tu->queue_size) < 0) {
+                        tu->tread = old_tread;
+                        return -ENOMEM;
+                }
                 return 0;
         }
         case SNDRV_TIMER_IOCTL_GINFO:
@@ -2030,10 +2037,12 @@ static unsigned int snd_timer_user_poll(struct file *file, poll_table * wait)
         poll_wait(file, &tu->qchange_sleep, wait);
 
         mask = 0;
+        spin_lock_irq(&tu->qlock);
         if (tu->qused)
                 mask |= POLLIN | POLLRDNORM;
         if (tu->disconnected)
                 mask |= POLLERR;
+        spin_unlock_irq(&tu->qlock);
 
         return mask;
 }
@@ -2117,17 +2126,3 @@ static void __exit alsa_timer_exit(void)
 
 module_init(alsa_timer_init)
 module_exit(alsa_timer_exit)
-
-EXPORT_SYMBOL(snd_timer_open);
-EXPORT_SYMBOL(snd_timer_close);
-EXPORT_SYMBOL(snd_timer_resolution);
-EXPORT_SYMBOL(snd_timer_start);
-EXPORT_SYMBOL(snd_timer_stop);
-EXPORT_SYMBOL(snd_timer_continue);
-EXPORT_SYMBOL(snd_timer_pause);
-EXPORT_SYMBOL(snd_timer_new);
-EXPORT_SYMBOL(snd_timer_notify);
-EXPORT_SYMBOL(snd_timer_global_new);
-EXPORT_SYMBOL(snd_timer_global_free);
-EXPORT_SYMBOL(snd_timer_global_register);
-EXPORT_SYMBOL(snd_timer_interrupt);