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

TOMOYO Linux Cross Reference
Linux/sound/firewire/tascam/tascam-hwdep.c

Version: ~ [ linux-5.16-rc1 ] ~ [ linux-5.15.2 ] ~ [ linux-5.14.18 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.79 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.159 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.217 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.255 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.290 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.292 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * tascam-hwdep.c - a part of driver for TASCAM FireWire series
  4  *
  5  * Copyright (c) 2015 Takashi Sakamoto
  6  */
  7 
  8 /*
  9  * This codes give three functionality.
 10  *
 11  * 1.get firewire node information
 12  * 2.get notification about starting/stopping stream
 13  * 3.lock/unlock stream
 14  */
 15 
 16 #include "tascam.h"
 17 
 18 static long tscm_hwdep_read_locked(struct snd_tscm *tscm, char __user *buf,
 19                                    long count, loff_t *offset)
 20         __releases(&tscm->lock)
 21 {
 22         struct snd_firewire_event_lock_status event = {
 23                 .type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS,
 24         };
 25 
 26         event.status = (tscm->dev_lock_count > 0);
 27         tscm->dev_lock_changed = false;
 28         count = min_t(long, count, sizeof(event));
 29 
 30         spin_unlock_irq(&tscm->lock);
 31 
 32         if (copy_to_user(buf, &event, count))
 33                 return -EFAULT;
 34 
 35         return count;
 36 }
 37 
 38 static long tscm_hwdep_read_queue(struct snd_tscm *tscm, char __user *buf,
 39                                   long remained, loff_t *offset)
 40         __releases(&tscm->lock)
 41 {
 42         char __user *pos = buf;
 43         unsigned int type = SNDRV_FIREWIRE_EVENT_TASCAM_CONTROL;
 44         struct snd_firewire_tascam_change *entries = tscm->queue;
 45         long count;
 46 
 47         // At least, one control event can be copied.
 48         if (remained < sizeof(type) + sizeof(*entries)) {
 49                 spin_unlock_irq(&tscm->lock);
 50                 return -EINVAL;
 51         }
 52 
 53         // Copy the type field later.
 54         count = sizeof(type);
 55         remained -= sizeof(type);
 56         pos += sizeof(type);
 57 
 58         while (true) {
 59                 unsigned int head_pos;
 60                 unsigned int tail_pos;
 61                 unsigned int length;
 62 
 63                 if (tscm->pull_pos == tscm->push_pos)
 64                         break;
 65                 else if (tscm->pull_pos < tscm->push_pos)
 66                         tail_pos = tscm->push_pos;
 67                 else
 68                         tail_pos = SND_TSCM_QUEUE_COUNT;
 69                 head_pos = tscm->pull_pos;
 70 
 71                 length = (tail_pos - head_pos) * sizeof(*entries);
 72                 if (remained < length)
 73                         length = rounddown(remained, sizeof(*entries));
 74                 if (length == 0)
 75                         break;
 76 
 77                 spin_unlock_irq(&tscm->lock);
 78                 if (copy_to_user(pos, &entries[head_pos], length))
 79                         return -EFAULT;
 80 
 81                 spin_lock_irq(&tscm->lock);
 82 
 83                 tscm->pull_pos = tail_pos % SND_TSCM_QUEUE_COUNT;
 84 
 85                 count += length;
 86                 remained -= length;
 87                 pos += length;
 88         }
 89 
 90         spin_unlock_irq(&tscm->lock);
 91 
 92         if (copy_to_user(buf, &type, sizeof(type)))
 93                 return -EFAULT;
 94 
 95         return count;
 96 }
 97 
 98 static long hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count,
 99                        loff_t *offset)
100 {
101         struct snd_tscm *tscm = hwdep->private_data;
102         DEFINE_WAIT(wait);
103 
104         spin_lock_irq(&tscm->lock);
105 
106         while (!tscm->dev_lock_changed && tscm->push_pos == tscm->pull_pos) {
107                 prepare_to_wait(&tscm->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
108                 spin_unlock_irq(&tscm->lock);
109                 schedule();
110                 finish_wait(&tscm->hwdep_wait, &wait);
111                 if (signal_pending(current))
112                         return -ERESTARTSYS;
113                 spin_lock_irq(&tscm->lock);
114         }
115 
116         // NOTE: The acquired lock should be released in callee side.
117         if (tscm->dev_lock_changed) {
118                 count = tscm_hwdep_read_locked(tscm, buf, count, offset);
119         } else if (tscm->push_pos != tscm->pull_pos) {
120                 count = tscm_hwdep_read_queue(tscm, buf, count, offset);
121         } else {
122                 spin_unlock_irq(&tscm->lock);
123                 count = 0;
124         }
125 
126         return count;
127 }
128 
129 static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
130                                poll_table *wait)
131 {
132         struct snd_tscm *tscm = hwdep->private_data;
133         __poll_t events;
134 
135         poll_wait(file, &tscm->hwdep_wait, wait);
136 
137         spin_lock_irq(&tscm->lock);
138         if (tscm->dev_lock_changed || tscm->push_pos != tscm->pull_pos)
139                 events = EPOLLIN | EPOLLRDNORM;
140         else
141                 events = 0;
142         spin_unlock_irq(&tscm->lock);
143 
144         return events;
145 }
146 
147 static int hwdep_get_info(struct snd_tscm *tscm, void __user *arg)
148 {
149         struct fw_device *dev = fw_parent_device(tscm->unit);
150         struct snd_firewire_get_info info;
151 
152         memset(&info, 0, sizeof(info));
153         info.type = SNDRV_FIREWIRE_TYPE_TASCAM;
154         info.card = dev->card->index;
155         *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
156         *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
157         strscpy(info.device_name, dev_name(&dev->device),
158                 sizeof(info.device_name));
159 
160         if (copy_to_user(arg, &info, sizeof(info)))
161                 return -EFAULT;
162 
163         return 0;
164 }
165 
166 static int hwdep_lock(struct snd_tscm *tscm)
167 {
168         int err;
169 
170         spin_lock_irq(&tscm->lock);
171 
172         if (tscm->dev_lock_count == 0) {
173                 tscm->dev_lock_count = -1;
174                 err = 0;
175         } else {
176                 err = -EBUSY;
177         }
178 
179         spin_unlock_irq(&tscm->lock);
180 
181         return err;
182 }
183 
184 static int hwdep_unlock(struct snd_tscm *tscm)
185 {
186         int err;
187 
188         spin_lock_irq(&tscm->lock);
189 
190         if (tscm->dev_lock_count == -1) {
191                 tscm->dev_lock_count = 0;
192                 err = 0;
193         } else {
194                 err = -EBADFD;
195         }
196 
197         spin_unlock_irq(&tscm->lock);
198 
199         return err;
200 }
201 
202 static int tscm_hwdep_state(struct snd_tscm *tscm, void __user *arg)
203 {
204         if (copy_to_user(arg, tscm->state, sizeof(tscm->state)))
205                 return -EFAULT;
206 
207         return 0;
208 }
209 
210 static int hwdep_release(struct snd_hwdep *hwdep, struct file *file)
211 {
212         struct snd_tscm *tscm = hwdep->private_data;
213 
214         spin_lock_irq(&tscm->lock);
215         if (tscm->dev_lock_count == -1)
216                 tscm->dev_lock_count = 0;
217         spin_unlock_irq(&tscm->lock);
218 
219         return 0;
220 }
221 
222 static int hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
223             unsigned int cmd, unsigned long arg)
224 {
225         struct snd_tscm *tscm = hwdep->private_data;
226 
227         switch (cmd) {
228         case SNDRV_FIREWIRE_IOCTL_GET_INFO:
229                 return hwdep_get_info(tscm, (void __user *)arg);
230         case SNDRV_FIREWIRE_IOCTL_LOCK:
231                 return hwdep_lock(tscm);
232         case SNDRV_FIREWIRE_IOCTL_UNLOCK:
233                 return hwdep_unlock(tscm);
234         case SNDRV_FIREWIRE_IOCTL_TASCAM_STATE:
235                 return tscm_hwdep_state(tscm, (void __user *)arg);
236         default:
237                 return -ENOIOCTLCMD;
238         }
239 }
240 
241 #ifdef CONFIG_COMPAT
242 static int hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
243                               unsigned int cmd, unsigned long arg)
244 {
245         return hwdep_ioctl(hwdep, file, cmd,
246                            (unsigned long)compat_ptr(arg));
247 }
248 #else
249 #define hwdep_compat_ioctl NULL
250 #endif
251 
252 int snd_tscm_create_hwdep_device(struct snd_tscm *tscm)
253 {
254         static const struct snd_hwdep_ops ops = {
255                 .read           = hwdep_read,
256                 .release        = hwdep_release,
257                 .poll           = hwdep_poll,
258                 .ioctl          = hwdep_ioctl,
259                 .ioctl_compat   = hwdep_compat_ioctl,
260         };
261         struct snd_hwdep *hwdep;
262         int err;
263 
264         err = snd_hwdep_new(tscm->card, "Tascam", 0, &hwdep);
265         if (err < 0)
266                 return err;
267 
268         strcpy(hwdep->name, "Tascam");
269         hwdep->iface = SNDRV_HWDEP_IFACE_FW_TASCAM;
270         hwdep->ops = ops;
271         hwdep->private_data = tscm;
272         hwdep->exclusive = true;
273 
274         tscm->hwdep = hwdep;
275 
276         return err;
277 }
278 

~ [ 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