WIP FPC-III support
[linux/fpc-iii.git] / sound / firewire / tascam / tascam-hwdep.c
blob6f38335fe10bfd56673166c9ebc3d52cf4dfa25c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * tascam-hwdep.c - a part of driver for TASCAM FireWire series
5 * Copyright (c) 2015 Takashi Sakamoto
6 */
8 /*
9 * This codes give three functionality.
11 * 1.get firewire node information
12 * 2.get notification about starting/stopping stream
13 * 3.lock/unlock stream
16 #include "tascam.h"
18 static long tscm_hwdep_read_locked(struct snd_tscm *tscm, char __user *buf,
19 long count, loff_t *offset)
20 __releases(&tscm->lock)
22 struct snd_firewire_event_lock_status event = {
23 .type = SNDRV_FIREWIRE_EVENT_LOCK_STATUS,
26 event.status = (tscm->dev_lock_count > 0);
27 tscm->dev_lock_changed = false;
28 count = min_t(long, count, sizeof(event));
30 spin_unlock_irq(&tscm->lock);
32 if (copy_to_user(buf, &event, count))
33 return -EFAULT;
35 return count;
38 static long tscm_hwdep_read_queue(struct snd_tscm *tscm, char __user *buf,
39 long remained, loff_t *offset)
40 __releases(&tscm->lock)
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;
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;
53 // Copy the type field later.
54 count = sizeof(type);
55 remained -= sizeof(type);
56 pos += sizeof(type);
58 while (true) {
59 unsigned int head_pos;
60 unsigned int tail_pos;
61 unsigned int length;
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;
71 length = (tail_pos - head_pos) * sizeof(*entries);
72 if (remained < length)
73 length = rounddown(remained, sizeof(*entries));
74 if (length == 0)
75 break;
77 spin_unlock_irq(&tscm->lock);
78 if (copy_to_user(pos, &entries[head_pos], length))
79 return -EFAULT;
81 spin_lock_irq(&tscm->lock);
83 tscm->pull_pos = tail_pos % SND_TSCM_QUEUE_COUNT;
85 count += length;
86 remained -= length;
87 pos += length;
90 spin_unlock_irq(&tscm->lock);
92 if (copy_to_user(buf, &type, sizeof(type)))
93 return -EFAULT;
95 return count;
98 static long hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count,
99 loff_t *offset)
101 struct snd_tscm *tscm = hwdep->private_data;
102 DEFINE_WAIT(wait);
104 spin_lock_irq(&tscm->lock);
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);
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;
126 return count;
129 static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
130 poll_table *wait)
132 struct snd_tscm *tscm = hwdep->private_data;
133 __poll_t events;
135 poll_wait(file, &tscm->hwdep_wait, wait);
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);
144 return events;
147 static int hwdep_get_info(struct snd_tscm *tscm, void __user *arg)
149 struct fw_device *dev = fw_parent_device(tscm->unit);
150 struct snd_firewire_get_info info;
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 strlcpy(info.device_name, dev_name(&dev->device),
158 sizeof(info.device_name));
160 if (copy_to_user(arg, &info, sizeof(info)))
161 return -EFAULT;
163 return 0;
166 static int hwdep_lock(struct snd_tscm *tscm)
168 int err;
170 spin_lock_irq(&tscm->lock);
172 if (tscm->dev_lock_count == 0) {
173 tscm->dev_lock_count = -1;
174 err = 0;
175 } else {
176 err = -EBUSY;
179 spin_unlock_irq(&tscm->lock);
181 return err;
184 static int hwdep_unlock(struct snd_tscm *tscm)
186 int err;
188 spin_lock_irq(&tscm->lock);
190 if (tscm->dev_lock_count == -1) {
191 tscm->dev_lock_count = 0;
192 err = 0;
193 } else {
194 err = -EBADFD;
197 spin_unlock_irq(&tscm->lock);
199 return err;
202 static int tscm_hwdep_state(struct snd_tscm *tscm, void __user *arg)
204 if (copy_to_user(arg, tscm->state, sizeof(tscm->state)))
205 return -EFAULT;
207 return 0;
210 static int hwdep_release(struct snd_hwdep *hwdep, struct file *file)
212 struct snd_tscm *tscm = hwdep->private_data;
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);
219 return 0;
222 static int hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
223 unsigned int cmd, unsigned long arg)
225 struct snd_tscm *tscm = hwdep->private_data;
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;
241 #ifdef CONFIG_COMPAT
242 static int hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
243 unsigned int cmd, unsigned long arg)
245 return hwdep_ioctl(hwdep, file, cmd,
246 (unsigned long)compat_ptr(arg));
248 #else
249 #define hwdep_compat_ioctl NULL
250 #endif
252 int snd_tscm_create_hwdep_device(struct snd_tscm *tscm)
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,
261 struct snd_hwdep *hwdep;
262 int err;
264 err = snd_hwdep_new(tscm->card, "Tascam", 0, &hwdep);
265 if (err < 0)
266 return err;
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;
274 tscm->hwdep = hwdep;
276 return err;