Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound-2.6: (250 commits)
  ALSA: hda: Storage class should be before const qualifier
  ASoC: tpa6130a2: Remove CPVSS and HPVdd supplies
  ASoC: tpa6130a2: Define output pins with SND_SOC_DAPM_OUTPUT
  ASoC: sdp4430 - add sdp4430 pcm ops to DAI.
  ASoC: TWL6040: Enable earphone path in codec
  ASoC: SDP4430: Add support for Earphone speaker
  ASoC: SDP4430: Add sdp4430 machine driver
  ASoC: tlv320dac33: Avoid powering off while in BIAS_OFF
  ASoC: tlv320dac33: Use dev_dbg in dac33_hard_power function
  ALSA: sound/pci/asihpi: Use kzalloc
  ALSA: hdmi - dont fail on extra nodes
  ALSA: intelhdmi - add id for the CougarPoint chipset
  ALSA: intelhdmi - user friendly codec name
  ALSA: intelhdmi - add dependency on SND_DYNAMIC_MINORS
  ALSA: asihpi: incorrect range check
  ALSA: asihpi: testing the wrong variable
  ALSA: es1688: add pedantic range checks
  ARM: McBSP: Add support for omap4 in McBSP driver
  ARM: McBSP: Fix request for irq in OMAP4
  OMAP: McBSP: Add 32-bit mode support
  ...

10 files changed, 210 insertions, 89 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index 439ce64f9d82..070aab490191 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -50,6 +50,10 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
         struct snd_ctl_file *ctl;
         int err;
 
+        err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
+
         card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL);
         if (!card) {
                 err = -ENODEV;
@@ -1388,6 +1392,7 @@ static const struct file_operations snd_ctl_f_ops =
         .read =         snd_ctl_read,
         .open =         snd_ctl_open,
         .release =      snd_ctl_release,
+        .llseek =       no_llseek,
         .poll =         snd_ctl_poll,
         .unlocked_ioctl =       snd_ctl_ioctl,
         .compat_ioctl = snd_ctl_ioctl_compat,
diff --git a/sound/core/info.c b/sound/core/info.c
index cc4a53d4b7f8..b70564ed8b37 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -164,40 +164,44 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
 {
         struct snd_info_private_data *data;
         struct snd_info_entry *entry;
-        loff_t ret;
+        loff_t ret = -EINVAL, size;
 
         data = file->private_data;
         entry = data->entry;
-        lock_kernel();
-        switch (entry->content) {
-        case SNDRV_INFO_CONTENT_TEXT:
-                switch (orig) {
-                case SEEK_SET:
-                        file->f_pos = offset;
-                        ret = file->f_pos;
-                        goto out;
-                case SEEK_CUR:
-                        file->f_pos += offset;
-                        ret = file->f_pos;
-                        goto out;
-                case SEEK_END:
-                default:
-                        ret = -EINVAL;
-                        goto out;
-                }
+        mutex_lock(&entry->access);
+        if (entry->content == SNDRV_INFO_CONTENT_DATA &&
+            entry->c.ops->llseek) {
+                offset = entry->c.ops->llseek(entry,
+                                              data->file_private_data,
+                                              file, offset, orig);
+                goto out;
+        }
+        if (entry->content == SNDRV_INFO_CONTENT_DATA)
+                size = entry->size;
+        else
+                size = 0;
+        switch (orig) {
+        case SEEK_SET:
                 break;
-        case SNDRV_INFO_CONTENT_DATA:
-                if (entry->c.ops->llseek) {
-                        ret = entry->c.ops->llseek(entry,
-                                                    data->file_private_data,
-                                                    file, offset, orig);
+        case SEEK_CUR:
+                offset += file->f_pos;
+                break;
+        case SEEK_END:
+                if (!size)
                         goto out;
-                }
+                offset += size;
                 break;
-        }
-        ret = -ENXIO;
-out:
-        unlock_kernel();
+        default:
+                goto out;
+        }
+        if (offset < 0)
+                goto out;
+        if (size && offset > size)
+                offset = size;
+        file->f_pos = offset;
+        ret = offset;
+ out:
+        mutex_unlock(&entry->access);
         return ret;
 }
 
@@ -232,10 +236,15 @@ static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
                         return -EFAULT;
                 break;
         case SNDRV_INFO_CONTENT_DATA:
-                if (entry->c.ops->read)
+                if (pos >= entry->size)
+                        return 0;
+                if (entry->c.ops->read) {
+                        size = entry->size - pos;
+                        size = min(count, size);
                         size = entry->c.ops->read(entry,
                                                   data->file_private_data,
-                                                  file, buffer, count, pos);
+                                                  file, buffer, size, pos);
+                }
                 break;
         }
         if ((ssize_t) size > 0)
@@ -282,10 +291,13 @@ static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer
                 size = count;
                 break;
         case SNDRV_INFO_CONTENT_DATA:
-                if (entry->c.ops->write)
+                if (entry->c.ops->write && count > 0) {
+                        size_t maxsize = entry->size - pos;
+                        count = min(count, maxsize);
                         size = entry->c.ops->write(entry,
                                                    data->file_private_data,
                                                    file, buffer, count, pos);
+                }
                 break;
         }
         if ((ssize_t) size > 0)
diff --git a/sound/core/jack.c b/sound/core/jack.c
index 14b8a4ee690d..4902ae568730 100644
--- a/sound/core/jack.c
+++ b/sound/core/jack.c
@@ -24,7 +24,7 @@
 #include <sound/jack.h>
 #include <sound/core.h>
 
-static int jack_types[] = {
+static int jack_switch_types[] = {
         SW_HEADPHONE_INSERT,
         SW_MICROPHONE_INSERT,
         SW_LINEOUT_INSERT,
@@ -56,7 +56,7 @@ static int snd_jack_dev_register(struct snd_device *device)
 {
         struct snd_jack *jack = device->device_data;
         struct snd_card *card = device->card;
-        int err;
+        int err, i;
 
         snprintf(jack->name, sizeof(jack->name), "%s %s",
                  card->shortname, jack->id);
@@ -66,6 +66,19 @@ static int snd_jack_dev_register(struct snd_device *device)
         if (!jack->input_dev->dev.parent)
                 jack->input_dev->dev.parent = snd_card_get_device_link(card);
 
+        /* Add capabilities for any keys that are enabled */
+        for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
+                int testbit = SND_JACK_BTN_0 >> i;
+
+                if (!(jack->type & testbit))
+                        continue;
+
+                if (!jack->key[i])
+                        jack->key[i] = BTN_0 + i;
+
+                input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
+        }
+
         err = input_register_device(jack->input_dev);
         if (err == 0)
                 jack->registered = 1;
@@ -113,10 +126,10 @@ int snd_jack_new(struct snd_card *card, const char *id, int type,
 
         jack->type = type;
 
-        for (i = 0; i < ARRAY_SIZE(jack_types); i++)
+        for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++)
                 if (type & (1 << i))
                         input_set_capability(jack->input_dev, EV_SW,
-                                             jack_types[i]);
+                                             jack_switch_types[i]);
 
         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
         if (err < 0)
@@ -152,6 +165,43 @@ void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
 EXPORT_SYMBOL(snd_jack_set_parent);
 
 /**
+ * snd_jack_set_key - Set a key mapping on a jack
+ *
+ * @jack:    The jack to configure
+ * @type:    Jack report type for this key
+ * @keytype: Input layer key type to be reported
+ *
+ * Map a SND_JACK_BTN_ button type to an input layer key, allowing
+ * reporting of keys on accessories via the jack abstraction.  If no
+ * mapping is provided but keys are enabled in the jack type then
+ * BTN_n numeric buttons will be reported.
+ *
+ * Note that this is intended to be use by simple devices with small
+ * numbers of keys that can be reported.  It is also possible to
+ * access the input device directly - devices with complex input
+ * capabilities on accessories should consider doing this rather than
+ * using this abstraction.
+ *
+ * This function may only be called prior to registration of the jack.
+ */
+int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
+                     int keytype)
+{
+        int key = fls(SND_JACK_BTN_0) - fls(type);
+
+        WARN_ON(jack->registered);
+
+        if (!keytype || key >= ARRAY_SIZE(jack->key))
+                return -EINVAL;
+
+        jack->type |= type;
+        jack->key[key] = keytype;
+
+        return 0;
+}
+EXPORT_SYMBOL(snd_jack_set_key);
+
+/**
  * snd_jack_report - Report the current status of a jack
  *
  * @jack:   The jack to report status for
@@ -164,10 +214,19 @@ void snd_jack_report(struct snd_jack *jack, int status)
         if (!jack)
                 return;
 
-        for (i = 0; i < ARRAY_SIZE(jack_types); i++) {
+        for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
+                int testbit = SND_JACK_BTN_0 >> i;
+
+                if (jack->type & testbit)
+                        input_report_key(jack->input_dev, jack->key[i],
+                                         status & testbit);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
                 int testbit = 1 << i;
                 if (jack->type & testbit)
-                        input_report_switch(jack->input_dev, jack_types[i],
+                        input_report_switch(jack->input_dev,
+                                            jack_switch_types[i],
                                             status & testbit);
         }
 
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 54e2eb56e4c2..f50ebf20df96 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -43,6 +43,10 @@ static int snd_mixer_oss_open(struct inode *inode, struct file *file)
         struct snd_mixer_oss_file *fmixer;
         int err;
 
+        err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
+
         card = snd_lookup_oss_minor_data(iminor(inode),
                                          SNDRV_OSS_DEVICE_TYPE_MIXER);
         if (card == NULL)
@@ -397,6 +401,7 @@ static const struct file_operations snd_mixer_oss_f_ops =
         .owner =        THIS_MODULE,
         .open =         snd_mixer_oss_open,
         .release =      snd_mixer_oss_release,
+        .llseek =       no_llseek,
         .unlocked_ioctl =       snd_mixer_oss_ioctl,
         .compat_ioctl = snd_mixer_oss_ioctl_compat,
 };
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 82d4e3329b3d..5c8c7dff8ede 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -2379,6 +2379,10 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file)
         int nonblock;
         wait_queue_t wait;
 
+        err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
+
         pcm = snd_lookup_oss_minor_data(iminor(inode),
                                         SNDRV_OSS_DEVICE_TYPE_PCM);
         if (pcm == NULL) {
@@ -2977,6 +2981,7 @@ static const struct file_operations snd_pcm_oss_f_reg =
         .write =        snd_pcm_oss_write,
         .open =         snd_pcm_oss_open,
         .release =      snd_pcm_oss_release,
+        .llseek =       no_llseek,
         .poll =         snd_pcm_oss_poll,
         .unlocked_ioctl =       snd_pcm_oss_ioctl,
         .compat_ioctl = snd_pcm_oss_ioctl_compat,
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 192dd407512f..644c2bb17b86 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -2112,7 +2112,9 @@ static int snd_pcm_open_file(struct file *file,
 static int snd_pcm_playback_open(struct inode *inode, struct file *file)
 {
         struct snd_pcm *pcm;
-
+        int err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
         pcm = snd_lookup_minor_data(iminor(inode),
                                     SNDRV_DEVICE_TYPE_PCM_PLAYBACK);
         return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
@@ -2121,7 +2123,9 @@ static int snd_pcm_playback_open(struct inode *inode, struct file *file)
 static int snd_pcm_capture_open(struct inode *inode, struct file *file)
 {
         struct snd_pcm *pcm;
-
+        int err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
         pcm = snd_lookup_minor_data(iminor(inode),
                                     SNDRV_DEVICE_TYPE_PCM_CAPTURE);
         return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE);
@@ -3312,18 +3316,13 @@ static int snd_pcm_fasync(int fd, struct file * file, int on)
         struct snd_pcm_file * pcm_file;
         struct snd_pcm_substream *substream;
         struct snd_pcm_runtime *runtime;
-        int err = -ENXIO;
 
-        lock_kernel();
         pcm_file = file->private_data;
         substream = pcm_file->substream;
         if (PCM_RUNTIME_CHECK(substream))
-                goto out;
+                return -ENXIO;
         runtime = substream->runtime;
-        err = fasync_helper(fd, file, on, &runtime->fasync);
-out:
-        unlock_kernel();
-        return err;
+        return fasync_helper(fd, file, on, &runtime->fasync);
 }
 
 /*
@@ -3443,14 +3442,28 @@ out:
 #endif /* CONFIG_SND_SUPPORT_OLD_API */
 
 #ifndef CONFIG_MMU
-unsigned long dummy_get_unmapped_area(struct file *file, unsigned long addr,
-                                      unsigned long len, unsigned long pgoff,
-                                      unsigned long flags)
-{
-        return 0;
+static unsigned long snd_pcm_get_unmapped_area(struct file *file,
+                                               unsigned long addr,
+                                               unsigned long len,
+                                               unsigned long pgoff,
+                                               unsigned long flags)
+{
+        struct snd_pcm_file *pcm_file = file->private_data;
+        struct snd_pcm_substream *substream = pcm_file->substream;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        unsigned long offset = pgoff << PAGE_SHIFT;
+
+        switch (offset) {
+        case SNDRV_PCM_MMAP_OFFSET_STATUS:
+                return (unsigned long)runtime->status;
+        case SNDRV_PCM_MMAP_OFFSET_CONTROL:
+                return (unsigned long)runtime->control;
+        default:
+                return (unsigned long)runtime->dma_area + offset;
+        }
 }
 #else
-# define dummy_get_unmapped_area NULL
+# define snd_pcm_get_unmapped_area NULL
 #endif
 
 /*
@@ -3464,12 +3477,13 @@ const struct file_operations snd_pcm_f_ops[2] = {
                 .aio_write =            snd_pcm_aio_write,
                 .open =                 snd_pcm_playback_open,
                 .release =              snd_pcm_release,
+                .llseek =               no_llseek,
                 .poll =                 snd_pcm_playback_poll,
                 .unlocked_ioctl =       snd_pcm_playback_ioctl,
                 .compat_ioctl =         snd_pcm_ioctl_compat,
                 .mmap =                 snd_pcm_mmap,
                 .fasync =               snd_pcm_fasync,
-                .get_unmapped_area =    dummy_get_unmapped_area,
+                .get_unmapped_area =    snd_pcm_get_unmapped_area,
         },
         {
                 .owner =                THIS_MODULE,
@@ -3477,11 +3491,12 @@ const struct file_operations snd_pcm_f_ops[2] = {
                 .aio_read =             snd_pcm_aio_read,
                 .open =                 snd_pcm_capture_open,
                 .release =              snd_pcm_release,
+                .llseek =               no_llseek,
                 .poll =                 snd_pcm_capture_poll,
                 .unlocked_ioctl =       snd_pcm_capture_ioctl,
                 .compat_ioctl =         snd_pcm_ioctl_compat,
                 .mmap =                 snd_pcm_mmap,
                 .fasync =               snd_pcm_fasync,
-                .get_unmapped_area =    dummy_get_unmapped_area,
+                .get_unmapped_area =    snd_pcm_get_unmapped_area,
         }
 };
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 0f5a194695d9..eb68326c37d4 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -376,6 +376,10 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
         if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 
                 return -EINVAL;         /* invalid combination */
 
+        err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
+
         if (maj == snd_major) {
                 rmidi = snd_lookup_minor_data(iminor(inode),
                                               SNDRV_DEVICE_TYPE_RAWMIDI);
@@ -1391,6 +1395,7 @@ static const struct file_operations snd_rawmidi_f_ops =
         .write =        snd_rawmidi_write,
         .open =         snd_rawmidi_open,
         .release =      snd_rawmidi_release,
+        .llseek =       no_llseek,
         .poll =         snd_rawmidi_poll,
         .unlocked_ioctl =       snd_rawmidi_ioctl,
         .compat_ioctl = snd_rawmidi_ioctl_compat,
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 48eca9ff9ee7..99a485f13648 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -318,6 +318,11 @@ static int snd_seq_open(struct inode *inode, struct file *file)
         int c, mode;                    /* client id */
         struct snd_seq_client *client;
         struct snd_seq_user_client *user;
+        int err;
+
+        err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
 
         if (mutex_lock_interruptible(&register_mutex))
                 return -ERESTARTSYS;
@@ -2550,6 +2555,7 @@ static const struct file_operations snd_seq_f_ops =
         .write =        snd_seq_write,
         .open =         snd_seq_open,
         .release =      snd_seq_release,
+        .llseek =       no_llseek,
         .poll =         snd_seq_poll,
         .unlocked_ioctl =       snd_seq_ioctl,
         .compat_ioctl = snd_seq_ioctl_compat,
diff --git a/sound/core/sound.c b/sound/core/sound.c
index 563d1967a0ad..ac42af42b787 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -120,7 +120,29 @@ void *snd_lookup_minor_data(unsigned int minor, int type)
 
 EXPORT_SYMBOL(snd_lookup_minor_data);
 
-static int __snd_open(struct inode *inode, struct file *file)
+#ifdef CONFIG_MODULES
+static struct snd_minor *autoload_device(unsigned int minor)
+{
+        int dev;
+        mutex_unlock(&sound_mutex); /* release lock temporarily */
+        dev = SNDRV_MINOR_DEVICE(minor);
+        if (dev == SNDRV_MINOR_CONTROL) {
+                /* /dev/aloadC? */
+                int card = SNDRV_MINOR_CARD(minor);
+                if (snd_cards[card] == NULL)
+                        snd_request_card(card);
+        } else if (dev == SNDRV_MINOR_GLOBAL) {
+                /* /dev/aloadSEQ */
+                snd_request_other(minor);
+        }
+        mutex_lock(&sound_mutex); /* reacuire lock */
+        return snd_minors[minor];
+}
+#else /* !CONFIG_MODULES */
+#define autoload_device(minor)  NULL
+#endif /* CONFIG_MODULES */
+
+static int snd_open(struct inode *inode, struct file *file)
 {
         unsigned int minor = iminor(inode);
         struct snd_minor *mptr = NULL;
@@ -129,55 +151,36 @@ static int __snd_open(struct inode *inode, struct file *file)
 
         if (minor >= ARRAY_SIZE(snd_minors))
                 return -ENODEV;
+        mutex_lock(&sound_mutex);
         mptr = snd_minors[minor];
         if (mptr == NULL) {
-#ifdef CONFIG_MODULES
-                int dev = SNDRV_MINOR_DEVICE(minor);
-                if (dev == SNDRV_MINOR_CONTROL) {
-                        /* /dev/aloadC? */
-                        int card = SNDRV_MINOR_CARD(minor);
-                        if (snd_cards[card] == NULL)
-                                snd_request_card(card);
-                } else if (dev == SNDRV_MINOR_GLOBAL) {
-                        /* /dev/aloadSEQ */
-                        snd_request_other(minor);
-                }
-#ifndef CONFIG_SND_DYNAMIC_MINORS
-                /* /dev/snd/{controlC?,seq} */
-                mptr = snd_minors[minor];
-                if (mptr == NULL)
-#endif
-#endif
+                mptr = autoload_device(minor);
+                if (!mptr) {
+                        mutex_unlock(&sound_mutex);
                         return -ENODEV;
+                }
         }
         old_fops = file->f_op;
         file->f_op = fops_get(mptr->f_ops);
         if (file->f_op == NULL) {
                 file->f_op = old_fops;
-                return -ENODEV;
+                err = -ENODEV;
         }
-        if (file->f_op->open)
+        mutex_unlock(&sound_mutex);
+        if (err < 0)
+                return err;
+
+        if (file->f_op->open) {
                 err = file->f_op->open(inode, file);
-        if (err) {
-                fops_put(file->f_op);
-                file->f_op = fops_get(old_fops);
+                if (err) {
+                        fops_put(file->f_op);
+                        file->f_op = fops_get(old_fops);
+                }
         }
         fops_put(old_fops);
         return err;
 }
 
-
-/* BKL pushdown: nasty #ifdef avoidance wrapper */
-static int snd_open(struct inode *inode, struct file *file)
-{
-        int ret;
-
-        lock_kernel();
-        ret = __snd_open(inode, file);
-        unlock_kernel();
-        return ret;
-}
-
 static const struct file_operations snd_fops =
 {
         .owner =        THIS_MODULE,
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 5040c7b862fe..13afb60999b9 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -1238,6 +1238,11 @@ static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
 static int snd_timer_user_open(struct inode *inode, struct file *file)
 {
         struct snd_timer_user *tu;
+        int err;
+
+        err = nonseekable_open(inode, file);
+        if (err < 0)
+                return err;
 
         tu = kzalloc(sizeof(*tu), GFP_KERNEL);
         if (tu == NULL)
@@ -1922,6 +1927,7 @@ static const struct file_operations snd_timer_f_ops =
         .read =         snd_timer_user_read,
         .open =         snd_timer_user_open,
         .release =      snd_timer_user_release,
+        .llseek =       no_llseek,
         .poll =         snd_timer_user_poll,
         .unlocked_ioctl =       snd_timer_user_ioctl,
         .compat_ioctl = snd_timer_user_ioctl_compat,