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(lock: &tscm->lock); |
31 | |
32 | if (copy_to_user(to: buf, from: &event, n: 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(lock: &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(lock: &tscm->lock); |
78 | if (copy_to_user(to: pos, from: &entries[head_pos], n: length)) |
79 | return -EFAULT; |
80 | |
81 | spin_lock_irq(lock: &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(lock: &tscm->lock); |
91 | |
92 | if (copy_to_user(to: buf, from: &type, n: 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(lock: &tscm->lock); |
105 | |
106 | while (!tscm->dev_lock_changed && tscm->push_pos == tscm->pull_pos) { |
107 | prepare_to_wait(wq_head: &tscm->hwdep_wait, wq_entry: &wait, TASK_INTERRUPTIBLE); |
108 | spin_unlock_irq(lock: &tscm->lock); |
109 | schedule(); |
110 | finish_wait(wq_head: &tscm->hwdep_wait, wq_entry: &wait); |
111 | if (signal_pending(current)) |
112 | return -ERESTARTSYS; |
113 | spin_lock_irq(lock: &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, remained: count, offset); |
121 | } else { |
122 | spin_unlock_irq(lock: &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(filp: file, wait_address: &tscm->hwdep_wait, p: wait); |
136 | |
137 | spin_lock_irq(lock: &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(lock: &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(to: arg, from: &info, n: 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(lock: &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(lock: &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(lock: &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(lock: &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(to: arg, from: tscm->state, n: 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(lock: &tscm->lock); |
215 | if (tscm->dev_lock_count == -1) |
216 | tscm->dev_lock_count = 0; |
217 | spin_unlock_irq(lock: &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, arg: (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, arg: (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 | arg: (unsigned long)compat_ptr(uptr: 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(card: tscm->card, id: "Tascam" , device: 0, rhwdep: &hwdep); |
265 | if (err < 0) |
266 | return err; |
267 | |
268 | strcpy(p: hwdep->name, q: "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 | |