~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/firewire/fireface/ff-hwdep.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * ff-hwdep.c - a part of driver for RME Fireface series
  3  *
  4  * Copyright (c) 2015-2017 Takashi Sakamoto
  5  *
  6  * Licensed under the terms of the GNU General Public License, version 2.
  7  */
  8 
  9 /*
 10  * This codes give three functionality.
 11  *
 12  * 1.get firewire node information
 13  * 2.get notification about starting/stopping stream
 14  * 3.lock/unlock stream
 15  */
 16 
 17 #include "ff.h"
 18 
 19 static long hwdep_read(struct snd_hwdep *hwdep, char __user *buf,  long count,
 20                        loff_t *offset)
 21 {
 22         struct snd_ff *ff = hwdep->private_data;
 23         DEFINE_WAIT(wait);
 24         union snd_firewire_event event;
 25 
 26         spin_lock_irq(&ff->lock);
 27 
 28         while (!ff->dev_lock_changed) {
 29                 prepare_to_wait(&ff->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
 30                 spin_unlock_irq(&ff->lock);
 31                 schedule();
 32                 finish_wait(&ff->hwdep_wait, &wait);
 33                 if (signal_pending(current))
 34                         return -ERESTARTSYS;
 35                 spin_lock_irq(&ff->lock);
 36         }
 37 
 38         memset(&event, 0, sizeof(event));
 39         if (ff->dev_lock_changed) {
 40                 event.lock_status.type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS;
 41                 event.lock_status.status = (ff->dev_lock_count > 0);
 42                 ff->dev_lock_changed = false;
 43 
 44                 count = min_t(long, count, sizeof(event.lock_status));
 45         }
 46 
 47         spin_unlock_irq(&ff->lock);
 48 
 49         if (copy_to_user(buf, &event, count))
 50                 return -EFAULT;
 51 
 52         return count;
 53 }
 54 
 55 static unsigned int hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
 56                                poll_table *wait)
 57 {
 58         struct snd_ff *ff = hwdep->private_data;
 59         unsigned int events;
 60 
 61         poll_wait(file, &ff->hwdep_wait, wait);
 62 
 63         spin_lock_irq(&ff->lock);
 64         if (ff->dev_lock_changed)
 65                 events = POLLIN | POLLRDNORM;
 66         else
 67                 events = 0;
 68         spin_unlock_irq(&ff->lock);
 69 
 70         return events;
 71 }
 72 
 73 static int hwdep_get_info(struct snd_ff *ff, void __user *arg)
 74 {
 75         struct fw_device *dev = fw_parent_device(ff->unit);
 76         struct snd_firewire_get_info info;
 77 
 78         memset(&info, 0, sizeof(info));
 79         info.type = SNDRV_FIREWIRE_TYPE_FIREFACE;
 80         info.card = dev->card->index;
 81         *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
 82         *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
 83         strlcpy(info.device_name, dev_name(&dev->device),
 84                 sizeof(info.device_name));
 85 
 86         if (copy_to_user(arg, &info, sizeof(info)))
 87                 return -EFAULT;
 88 
 89         return 0;
 90 }
 91 
 92 static int hwdep_lock(struct snd_ff *ff)
 93 {
 94         int err;
 95 
 96         spin_lock_irq(&ff->lock);
 97 
 98         if (ff->dev_lock_count == 0) {
 99                 ff->dev_lock_count = -1;
100                 err = 0;
101         } else {
102                 err = -EBUSY;
103         }
104 
105         spin_unlock_irq(&ff->lock);
106 
107         return err;
108 }
109 
110 static int hwdep_unlock(struct snd_ff *ff)
111 {
112         int err;
113 
114         spin_lock_irq(&ff->lock);
115 
116         if (ff->dev_lock_count == -1) {
117                 ff->dev_lock_count = 0;
118                 err = 0;
119         } else {
120                 err = -EBADFD;
121         }
122 
123         spin_unlock_irq(&ff->lock);
124 
125         return err;
126 }
127 
128 static int hwdep_release(struct snd_hwdep *hwdep, struct file *file)
129 {
130         struct snd_ff *ff = hwdep->private_data;
131 
132         spin_lock_irq(&ff->lock);
133         if (ff->dev_lock_count == -1)
134                 ff->dev_lock_count = 0;
135         spin_unlock_irq(&ff->lock);
136 
137         return 0;
138 }
139 
140 static int hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
141                        unsigned int cmd, unsigned long arg)
142 {
143         struct snd_ff *ff = hwdep->private_data;
144 
145         switch (cmd) {
146         case SNDRV_FIREWIRE_IOCTL_GET_INFO:
147                 return hwdep_get_info(ff, (void __user *)arg);
148         case SNDRV_FIREWIRE_IOCTL_LOCK:
149                 return hwdep_lock(ff);
150         case SNDRV_FIREWIRE_IOCTL_UNLOCK:
151                 return hwdep_unlock(ff);
152         default:
153                 return -ENOIOCTLCMD;
154         }
155 }
156 
157 #ifdef CONFIG_COMPAT
158 static int hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
159                               unsigned int cmd, unsigned long arg)
160 {
161         return hwdep_ioctl(hwdep, file, cmd,
162                            (unsigned long)compat_ptr(arg));
163 }
164 #else
165 #define hwdep_compat_ioctl NULL
166 #endif
167 
168 int snd_ff_create_hwdep_devices(struct snd_ff *ff)
169 {
170         static const struct snd_hwdep_ops hwdep_ops = {
171                 .read           = hwdep_read,
172                 .release        = hwdep_release,
173                 .poll           = hwdep_poll,
174                 .ioctl          = hwdep_ioctl,
175                 .ioctl_compat   = hwdep_compat_ioctl,
176         };
177         struct snd_hwdep *hwdep;
178         int err;
179 
180         err = snd_hwdep_new(ff->card, ff->card->driver, 0, &hwdep);
181         if (err < 0)
182                 return err;
183 
184         strcpy(hwdep->name, ff->card->driver);
185         hwdep->iface = SNDRV_HWDEP_IFACE_FW_FIREFACE;
186         hwdep->ops = hwdep_ops;
187         hwdep->private_data = ff;
188         hwdep->exclusive = true;
189 
190         return 0;
191 }
192 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp