header cleaning: don't include smp_lock.h when not used
[linux-3.10.git] / sound / core / pcm_native.c
index 7b5729c..9052348 100644 (file)
 
 #include <sound/driver.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/file.h>
 #include <linux/slab.h>
 #include <linux/time.h>
+#include <linux/latency.h>
 #include <linux/uio.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -347,11 +347,26 @@ out:
        return err;
 }
 
+static int period_to_usecs(struct snd_pcm_runtime *runtime)
+{
+       int usecs;
+
+       if (! runtime->rate)
+               return -1; /* invalid */
+
+       /* take 75% of period time as the deadline */
+       usecs = (750000 / runtime->rate) * runtime->period_size;
+       usecs += ((750000 % runtime->rate) * runtime->period_size) /
+               runtime->rate;
+
+       return usecs;
+}
+
 static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
                             struct snd_pcm_hw_params *params)
 {
        struct snd_pcm_runtime *runtime;
-       int err;
+       int err, usecs;
        unsigned int bits;
        snd_pcm_uframes_t frames;
 
@@ -372,7 +387,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
        if (!substream->oss.oss)
 #endif
-               if (atomic_read(&runtime->mmap_count))
+               if (atomic_read(&substream->mmap_count))
                        return -EBADFD;
 
        params->rmask = ~0U;
@@ -431,6 +446,10 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
 
        snd_pcm_timer_resolution_change(substream);
        runtime->status->state = SNDRV_PCM_STATE_SETUP;
+
+       remove_acceptable_latency(substream->latency_id);
+       if ((usecs = period_to_usecs(runtime)) >= 0)
+               set_acceptable_latency(substream->latency_id, usecs);
        return 0;
  _error:
        /* hardware might be unuseable from this time,
@@ -485,11 +504,12 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
                return -EBADFD;
        }
        snd_pcm_stream_unlock_irq(substream);
-       if (atomic_read(&runtime->mmap_count))
+       if (atomic_read(&substream->mmap_count))
                return -EBADFD;
        if (substream->ops->hw_free)
                result = substream->ops->hw_free(substream);
        runtime->status->state = SNDRV_PCM_STATE_OPEN;
+       remove_acceptable_latency(substream->latency_id);
        return result;
 }
 
@@ -1284,13 +1304,17 @@ static int snd_pcm_reset(struct snd_pcm_substream *substream)
 /*
  * prepare ioctl
  */
-static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, int state)
+/* we use the second argument for updating f_flags */
+static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
+                              int f_flags)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
-       if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+       if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
+           runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
                return -EBADFD;
        if (snd_pcm_running(substream))
                return -EBUSY;
+       substream->f_flags = f_flags;
        return 0;
 }
 
@@ -1319,17 +1343,26 @@ static struct action_ops snd_pcm_action_prepare = {
 /**
  * snd_pcm_prepare
  * @substream: the PCM substream instance
+ * @file: file to refer f_flags
  *
  * Prepare the PCM substream to be triggerable.
  */
-static int snd_pcm_prepare(struct snd_pcm_substream *substream)
+static int snd_pcm_prepare(struct snd_pcm_substream *substream,
+                          struct file *file)
 {
        int res;
        struct snd_card *card = substream->pcm->card;
+       int f_flags;
+
+       if (file)
+               f_flags = file->f_flags;
+       else
+               f_flags = substream->f_flags;
 
        snd_power_lock(card);
        if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0)) >= 0)
-               res = snd_pcm_action_nonatomic(&snd_pcm_action_prepare, substream, 0);
+               res = snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
+                                              substream, f_flags);
        snd_power_unlock(card);
        return res;
 }
@@ -1340,7 +1373,7 @@ static int snd_pcm_prepare(struct snd_pcm_substream *substream)
 
 static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
 {
-       if (substream->ffile->f_flags & O_NONBLOCK)
+       if (substream->f_flags & O_NONBLOCK)
                return -EAGAIN;
        substream->runtime->trigger_master = substream;
        return 0;
@@ -1457,8 +1490,6 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream)
                }
        }
        up_read(&snd_pcm_link_rwsem);
-       if (! num_drecs)
-               goto _error;
 
        snd_pcm_stream_lock_irq(substream);
        /* resume pause */
@@ -1537,7 +1568,8 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream)
        runtime = substream->runtime;
        card = substream->pcm->card;
 
-       if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+       if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
+           runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
                return -EBADFD;
 
        snd_power_lock(card);
@@ -1571,7 +1603,7 @@ static struct file *snd_pcm_file_fd(int fd)
        file = fget(fd);
        if (!file)
                return NULL;
-       inode = file->f_dentry->d_inode;
+       inode = file->f_path.dentry->d_inode;
        if (!S_ISCHR(inode->i_mode) ||
            imajor(inode) != snd_major) {
                fput(file);
@@ -1982,39 +2014,17 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
        return 0;
 }
 
-static void snd_pcm_add_file(struct snd_pcm_str *str,
-                            struct snd_pcm_file *pcm_file)
-{
-       pcm_file->next = str->files;
-       str->files = pcm_file;
-}
-
-static void snd_pcm_remove_file(struct snd_pcm_str *str,
-                               struct snd_pcm_file *pcm_file)
-{
-       struct snd_pcm_file * pcm_file1;
-       if (str->files == pcm_file) {
-               str->files = pcm_file->next;
-       } else {
-               pcm_file1 = str->files;
-               while (pcm_file1 && pcm_file1->next != pcm_file)
-                       pcm_file1 = pcm_file1->next;
-               if (pcm_file1 != NULL)
-                       pcm_file1->next = pcm_file->next;
-       }
-}
-
 static void pcm_release_private(struct snd_pcm_substream *substream)
 {
-       struct snd_pcm_file *pcm_file = substream->file;
-
        snd_pcm_unlink(substream);
-       snd_pcm_remove_file(substream->pstr, pcm_file);
-       kfree(pcm_file);
 }
 
 void snd_pcm_release_substream(struct snd_pcm_substream *substream)
 {
+       substream->ref_count--;
+       if (substream->ref_count > 0)
+               return;
+
        snd_pcm_drop(substream);
        if (substream->hw_opened) {
                if (substream->ops->hw_free != NULL)
@@ -2041,7 +2051,11 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
        err = snd_pcm_attach_substream(pcm, stream, file, &substream);
        if (err < 0)
                return err;
-       substream->no_mmap_ctrl = 0;
+       if (substream->ref_count > 1) {
+               *rsubstream = substream;
+               return 0;
+       }
+
        err = snd_pcm_hw_constraints_init(substream);
        if (err < 0) {
                snd_printd("snd_pcm_hw_constraints_init failed\n");
@@ -2091,12 +2105,12 @@ static int snd_pcm_open_file(struct file *file,
                snd_pcm_release_substream(substream);
                return -ENOMEM;
        }
-       str = substream->pstr;
-       substream->file = pcm_file;
-       substream->pcm_release = pcm_release_private;
        pcm_file->substream = substream;
-       snd_pcm_add_file(str, pcm_file);
-
+       if (substream->ref_count == 1) {
+               str = substream->pstr;
+               substream->file = pcm_file;
+               substream->pcm_release = pcm_release_private;
+       }
        file->private_data = pcm_file;
        *rpcm_file = pcm_file;
        return 0;
@@ -2183,11 +2197,11 @@ static int snd_pcm_release(struct inode *inode, struct file *file)
        pcm_file = file->private_data;
        substream = pcm_file->substream;
        snd_assert(substream != NULL, return -ENXIO);
-       snd_assert(!atomic_read(&substream->runtime->mmap_count), );
        pcm = substream->pcm;
        fasync_helper(-1, file, 0, &substream->runtime->fasync);
        mutex_lock(&pcm->open_mutex);
        snd_pcm_release_substream(substream);
+       kfree(pcm_file);
        mutex_unlock(&pcm->open_mutex);
        wake_up(&pcm->open_wait);
        module_put(pcm->card->module);
@@ -2506,7 +2520,8 @@ static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
        return 0;
 }
                
-static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream,
+static int snd_pcm_common_ioctl1(struct file *file,
+                                struct snd_pcm_substream *substream,
                                 unsigned int cmd, void __user *arg)
 {
        snd_assert(substream != NULL, return -ENXIO);
@@ -2531,7 +2546,7 @@ static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream,
        case SNDRV_PCM_IOCTL_CHANNEL_INFO:
                return snd_pcm_channel_info_user(substream, arg);
        case SNDRV_PCM_IOCTL_PREPARE:
-               return snd_pcm_prepare(substream);
+               return snd_pcm_prepare(substream, file);
        case SNDRV_PCM_IOCTL_RESET:
                return snd_pcm_reset(substream);
        case SNDRV_PCM_IOCTL_START:
@@ -2573,7 +2588,8 @@ static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream,
        return -ENOTTY;
 }
 
-static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream,
+static int snd_pcm_playback_ioctl1(struct file *file,
+                                  struct snd_pcm_substream *substream,
                                   unsigned int cmd, void __user *arg)
 {
        snd_assert(substream != NULL, return -ENXIO);
@@ -2649,10 +2665,11 @@ static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream,
                return result < 0 ? result : 0;
        }
        }
-       return snd_pcm_common_ioctl1(substream, cmd, arg);
+       return snd_pcm_common_ioctl1(file, substream, cmd, arg);
 }
 
-static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream,
+static int snd_pcm_capture_ioctl1(struct file *file,
+                                 struct snd_pcm_substream *substream,
                                  unsigned int cmd, void __user *arg)
 {
        snd_assert(substream != NULL, return -ENXIO);
@@ -2728,7 +2745,7 @@ static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream,
                return result < 0 ? result : 0;
        }
        }
-       return snd_pcm_common_ioctl1(substream, cmd, arg);
+       return snd_pcm_common_ioctl1(file, substream, cmd, arg);
 }
 
 static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
@@ -2741,7 +2758,8 @@ static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
        if (((cmd >> 8) & 0xff) != 'A')
                return -ENOTTY;
 
-       return snd_pcm_playback_ioctl1(pcm_file->substream, cmd, (void __user *)arg);
+       return snd_pcm_playback_ioctl1(file, pcm_file->substream, cmd,
+                                      (void __user *)arg);
 }
 
 static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
@@ -2754,7 +2772,8 @@ static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
        if (((cmd >> 8) & 0xff) != 'A')
                return -ENOTTY;
 
-       return snd_pcm_capture_ioctl1(pcm_file->substream, cmd, (void __user *)arg);
+       return snd_pcm_capture_ioctl1(file, pcm_file->substream, cmd,
+                                     (void __user *)arg);
 }
 
 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
@@ -2766,12 +2785,12 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
        fs = snd_enter_user();
        switch (substream->stream) {
        case SNDRV_PCM_STREAM_PLAYBACK:
-               result = snd_pcm_playback_ioctl1(substream,
-                                                cmd, (void __user *)arg);
+               result = snd_pcm_playback_ioctl1(NULL, substream, cmd,
+                                                (void __user *)arg);
                break;
        case SNDRV_PCM_STREAM_CAPTURE:
-               result = snd_pcm_capture_ioctl1(substream,
-                                               cmd, (void __user *)arg);
+               result = snd_pcm_capture_ioctl1(NULL, substream, cmd,
+                                               (void __user *)arg);
                break;
        default:
                result = -EINVAL;
@@ -2834,8 +2853,8 @@ static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
        return result;
 }
 
-static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector,
-                            unsigned long count, loff_t * offset)
+static ssize_t snd_pcm_aio_read(struct kiocb *iocb, const struct iovec *iov,
+                            unsigned long nr_segs, loff_t pos)
 
 {
        struct snd_pcm_file *pcm_file;
@@ -2846,22 +2865,22 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector,
        void __user **bufs;
        snd_pcm_uframes_t frames;
 
-       pcm_file = file->private_data;
+       pcm_file = iocb->ki_filp->private_data;
        substream = pcm_file->substream;
        snd_assert(substream != NULL, return -ENXIO);
        runtime = substream->runtime;
        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                return -EBADFD;
-       if (count > 1024 || count != runtime->channels)
+       if (nr_segs > 1024 || nr_segs != runtime->channels)
                return -EINVAL;
-       if (!frame_aligned(runtime, _vector->iov_len))
+       if (!frame_aligned(runtime, iov->iov_len))
                return -EINVAL;
-       frames = bytes_to_samples(runtime, _vector->iov_len);
-       bufs = kmalloc(sizeof(void *) * count, GFP_KERNEL);
+       frames = bytes_to_samples(runtime, iov->iov_len);
+       bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
        if (bufs == NULL)
                return -ENOMEM;
-       for (i = 0; i < count; ++i)
-               bufs[i] = _vector[i].iov_base;
+       for (i = 0; i < nr_segs; ++i)
+               bufs[i] = iov[i].iov_base;
        result = snd_pcm_lib_readv(substream, bufs, frames);
        if (result > 0)
                result = frames_to_bytes(runtime, result);
@@ -2869,8 +2888,8 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector,
        return result;
 }
 
-static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector,
-                             unsigned long count, loff_t * offset)
+static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
+                             unsigned long nr_segs, loff_t pos)
 {
        struct snd_pcm_file *pcm_file;
        struct snd_pcm_substream *substream;
@@ -2880,7 +2899,7 @@ static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector,
        void __user **bufs;
        snd_pcm_uframes_t frames;
 
-       pcm_file = file->private_data;
+       pcm_file = iocb->ki_filp->private_data;
        substream = pcm_file->substream;
        snd_assert(substream != NULL, result = -ENXIO; goto end);
        runtime = substream->runtime;
@@ -2888,17 +2907,17 @@ static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector,
                result = -EBADFD;
                goto end;
        }
-       if (count > 128 || count != runtime->channels ||
-           !frame_aligned(runtime, _vector->iov_len)) {
+       if (nr_segs > 128 || nr_segs != runtime->channels ||
+           !frame_aligned(runtime, iov->iov_len)) {
                result = -EINVAL;
                goto end;
        }
-       frames = bytes_to_samples(runtime, _vector->iov_len);
-       bufs = kmalloc(sizeof(void *) * count, GFP_KERNEL);
+       frames = bytes_to_samples(runtime, iov->iov_len);
+       bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
        if (bufs == NULL)
                return -ENOMEM;
-       for (i = 0; i < count; ++i)
-               bufs[i] = _vector[i].iov_base;
+       for (i = 0; i < nr_segs; ++i)
+               bufs[i] = iov[i].iov_base;
        result = snd_pcm_lib_writev(substream, bufs, frames);
        if (result > 0)
                result = frames_to_bytes(runtime, result);
@@ -3007,7 +3026,7 @@ static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area,
        struct page * page;
        
        if (substream == NULL)
-               return NOPAGE_OOM;
+               return NOPAGE_SIGBUS;
        runtime = substream->runtime;
        page = virt_to_page(runtime->status);
        get_page(page);
@@ -3050,7 +3069,7 @@ static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area,
        struct page * page;
        
        if (substream == NULL)
-               return NOPAGE_OOM;
+               return NOPAGE_SIGBUS;
        runtime = substream->runtime;
        page = virt_to_page(runtime->control);
        get_page(page);
@@ -3111,18 +3130,18 @@ static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area,
        size_t dma_bytes;
        
        if (substream == NULL)
-               return NOPAGE_OOM;
+               return NOPAGE_SIGBUS;
        runtime = substream->runtime;
        offset = area->vm_pgoff << PAGE_SHIFT;
        offset += address - area->vm_start;
-       snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_OOM);
+       snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_SIGBUS);
        dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
        if (offset > dma_bytes - PAGE_SIZE)
                return NOPAGE_SIGBUS;
        if (substream->ops->page) {
                page = substream->ops->page(substream, offset);
                if (! page)
-                       return NOPAGE_OOM;
+                       return NOPAGE_OOM; /* XXX: is this really due to OOM? */
        } else {
                vaddr = runtime->dma_area + offset;
                page = virt_to_page(vaddr);
@@ -3149,7 +3168,7 @@ static int snd_pcm_default_mmap(struct snd_pcm_substream *substream,
        area->vm_ops = &snd_pcm_vm_ops_data;
        area->vm_private_data = substream;
        area->vm_flags |= VM_RESERVED;
-       atomic_inc(&substream->runtime->mmap_count);
+       atomic_inc(&substream->mmap_count);
        return 0;
 }
 
@@ -3181,7 +3200,7 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
                                (substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
                                size, area->vm_page_prot))
                return -EAGAIN;
-       atomic_inc(&substream->runtime->mmap_count);
+       atomic_inc(&substream->mmap_count);
        return 0;
 }
 
@@ -3244,11 +3263,11 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
        offset = area->vm_pgoff << PAGE_SHIFT;
        switch (offset) {
        case SNDRV_PCM_MMAP_OFFSET_STATUS:
-               if (substream->no_mmap_ctrl)
+               if (pcm_file->no_compat_mmap)
                        return -ENXIO;
                return snd_pcm_mmap_status(substream, file, area);
        case SNDRV_PCM_MMAP_OFFSET_CONTROL:
-               if (substream->no_mmap_ctrl)
+               if (pcm_file->no_compat_mmap)
                        return -ENXIO;
                return snd_pcm_mmap_control(substream, file, area);
        default:
@@ -3404,11 +3423,11 @@ out:
  *  Register section
  */
 
-struct file_operations snd_pcm_f_ops[2] = {
+const struct file_operations snd_pcm_f_ops[2] = {
        {
                .owner =                THIS_MODULE,
                .write =                snd_pcm_write,
-               .writev =               snd_pcm_writev,
+               .aio_write =            snd_pcm_aio_write,
                .open =                 snd_pcm_playback_open,
                .release =              snd_pcm_release,
                .poll =                 snd_pcm_playback_poll,
@@ -3420,7 +3439,7 @@ struct file_operations snd_pcm_f_ops[2] = {
        {
                .owner =                THIS_MODULE,
                .read =                 snd_pcm_read,
-               .readv =                snd_pcm_readv,
+               .aio_read =             snd_pcm_aio_read,
                .open =                 snd_pcm_capture_open,
                .release =              snd_pcm_release,
                .poll =                 snd_pcm_capture_poll,