clk: imx: correct i.MX7D AV PLL num/denom offset
[sfrench/cifs-2.6.git] / sound / firewire / tascam / tascam-hwdep.c
1 /*
2  * tascam-hwdep.c - a part of driver for TASCAM FireWire series
3  *
4  * Copyright (c) 2015 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 "tascam.h"
18
19 static long tscm_hwdep_read_locked(struct snd_tscm *tscm, char __user *buf,
20                                    long count, loff_t *offset)
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 {
41         char __user *pos = buf;
42         unsigned int type = SNDRV_FIREWIRE_EVENT_TASCAM_CONTROL;
43         struct snd_firewire_tascam_change *entries = tscm->queue;
44         long count;
45
46         // At least, one control event can be copied.
47         if (remained < sizeof(type) + sizeof(*entries)) {
48                 spin_unlock_irq(&tscm->lock);
49                 return -EINVAL;
50         }
51
52         // Copy the type field later.
53         count = sizeof(type);
54         remained -= sizeof(type);
55         pos += sizeof(type);
56
57         while (true) {
58                 unsigned int head_pos;
59                 unsigned int tail_pos;
60                 unsigned int length;
61
62                 if (tscm->pull_pos == tscm->push_pos)
63                         break;
64                 else if (tscm->pull_pos < tscm->push_pos)
65                         tail_pos = tscm->push_pos;
66                 else
67                         tail_pos = SND_TSCM_QUEUE_COUNT;
68                 head_pos = tscm->pull_pos;
69
70                 length = (tail_pos - head_pos) * sizeof(*entries);
71                 if (remained < length)
72                         length = rounddown(remained, sizeof(*entries));
73                 if (length == 0)
74                         break;
75
76                 spin_unlock_irq(&tscm->lock);
77                 if (copy_to_user(pos, &entries[head_pos], length))
78                         return -EFAULT;
79
80                 spin_lock_irq(&tscm->lock);
81
82                 tscm->pull_pos = tail_pos % SND_TSCM_QUEUE_COUNT;
83
84                 count += length;
85                 remained -= length;
86                 pos += length;
87         }
88
89         spin_unlock_irq(&tscm->lock);
90
91         if (copy_to_user(buf, &type, sizeof(type)))
92                 return -EFAULT;
93
94         return count;
95 }
96
97 static long hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count,
98                        loff_t *offset)
99 {
100         struct snd_tscm *tscm = hwdep->private_data;
101         DEFINE_WAIT(wait);
102
103         spin_lock_irq(&tscm->lock);
104
105         while (!tscm->dev_lock_changed && tscm->push_pos == tscm->pull_pos) {
106                 prepare_to_wait(&tscm->hwdep_wait, &wait, TASK_INTERRUPTIBLE);
107                 spin_unlock_irq(&tscm->lock);
108                 schedule();
109                 finish_wait(&tscm->hwdep_wait, &wait);
110                 if (signal_pending(current))
111                         return -ERESTARTSYS;
112                 spin_lock_irq(&tscm->lock);
113         }
114
115         // NOTE: The acquired lock should be released in callee side.
116         if (tscm->dev_lock_changed) {
117                 count = tscm_hwdep_read_locked(tscm, buf, count, offset);
118         } else if (tscm->push_pos != tscm->pull_pos) {
119                 count = tscm_hwdep_read_queue(tscm, buf, count, offset);
120         } else {
121                 spin_unlock_irq(&tscm->lock);
122                 count = 0;
123         }
124
125         return count;
126 }
127
128 static __poll_t hwdep_poll(struct snd_hwdep *hwdep, struct file *file,
129                                poll_table *wait)
130 {
131         struct snd_tscm *tscm = hwdep->private_data;
132         __poll_t events;
133
134         poll_wait(file, &tscm->hwdep_wait, wait);
135
136         spin_lock_irq(&tscm->lock);
137         if (tscm->dev_lock_changed || tscm->push_pos != tscm->pull_pos)
138                 events = EPOLLIN | EPOLLRDNORM;
139         else
140                 events = 0;
141         spin_unlock_irq(&tscm->lock);
142
143         return events;
144 }
145
146 static int hwdep_get_info(struct snd_tscm *tscm, void __user *arg)
147 {
148         struct fw_device *dev = fw_parent_device(tscm->unit);
149         struct snd_firewire_get_info info;
150
151         memset(&info, 0, sizeof(info));
152         info.type = SNDRV_FIREWIRE_TYPE_TASCAM;
153         info.card = dev->card->index;
154         *(__be32 *)&info.guid[0] = cpu_to_be32(dev->config_rom[3]);
155         *(__be32 *)&info.guid[4] = cpu_to_be32(dev->config_rom[4]);
156         strlcpy(info.device_name, dev_name(&dev->device),
157                 sizeof(info.device_name));
158
159         if (copy_to_user(arg, &info, sizeof(info)))
160                 return -EFAULT;
161
162         return 0;
163 }
164
165 static int hwdep_lock(struct snd_tscm *tscm)
166 {
167         int err;
168
169         spin_lock_irq(&tscm->lock);
170
171         if (tscm->dev_lock_count == 0) {
172                 tscm->dev_lock_count = -1;
173                 err = 0;
174         } else {
175                 err = -EBUSY;
176         }
177
178         spin_unlock_irq(&tscm->lock);
179
180         return err;
181 }
182
183 static int hwdep_unlock(struct snd_tscm *tscm)
184 {
185         int err;
186
187         spin_lock_irq(&tscm->lock);
188
189         if (tscm->dev_lock_count == -1) {
190                 tscm->dev_lock_count = 0;
191                 err = 0;
192         } else {
193                 err = -EBADFD;
194         }
195
196         spin_unlock_irq(&tscm->lock);
197
198         return err;
199 }
200
201 static int tscm_hwdep_state(struct snd_tscm *tscm, void __user *arg)
202 {
203         if (copy_to_user(arg, tscm->state, sizeof(tscm->state)))
204                 return -EFAULT;
205
206         return 0;
207 }
208
209 static int hwdep_release(struct snd_hwdep *hwdep, struct file *file)
210 {
211         struct snd_tscm *tscm = hwdep->private_data;
212
213         spin_lock_irq(&tscm->lock);
214         if (tscm->dev_lock_count == -1)
215                 tscm->dev_lock_count = 0;
216         spin_unlock_irq(&tscm->lock);
217
218         return 0;
219 }
220
221 static int hwdep_ioctl(struct snd_hwdep *hwdep, struct file *file,
222             unsigned int cmd, unsigned long arg)
223 {
224         struct snd_tscm *tscm = hwdep->private_data;
225
226         switch (cmd) {
227         case SNDRV_FIREWIRE_IOCTL_GET_INFO:
228                 return hwdep_get_info(tscm, (void __user *)arg);
229         case SNDRV_FIREWIRE_IOCTL_LOCK:
230                 return hwdep_lock(tscm);
231         case SNDRV_FIREWIRE_IOCTL_UNLOCK:
232                 return hwdep_unlock(tscm);
233         case SNDRV_FIREWIRE_IOCTL_TASCAM_STATE:
234                 return tscm_hwdep_state(tscm, (void __user *)arg);
235         default:
236                 return -ENOIOCTLCMD;
237         }
238 }
239
240 #ifdef CONFIG_COMPAT
241 static int hwdep_compat_ioctl(struct snd_hwdep *hwdep, struct file *file,
242                               unsigned int cmd, unsigned long arg)
243 {
244         return hwdep_ioctl(hwdep, file, cmd,
245                            (unsigned long)compat_ptr(arg));
246 }
247 #else
248 #define hwdep_compat_ioctl NULL
249 #endif
250
251 int snd_tscm_create_hwdep_device(struct snd_tscm *tscm)
252 {
253         static const struct snd_hwdep_ops ops = {
254                 .read           = hwdep_read,
255                 .release        = hwdep_release,
256                 .poll           = hwdep_poll,
257                 .ioctl          = hwdep_ioctl,
258                 .ioctl_compat   = hwdep_compat_ioctl,
259         };
260         struct snd_hwdep *hwdep;
261         int err;
262
263         err = snd_hwdep_new(tscm->card, "Tascam", 0, &hwdep);
264         if (err < 0)
265                 return err;
266
267         strcpy(hwdep->name, "Tascam");
268         hwdep->iface = SNDRV_HWDEP_IFACE_FW_TASCAM;
269         hwdep->ops = ops;
270         hwdep->private_data = tscm;
271         hwdep->exclusive = true;
272
273         tscm->hwdep = hwdep;
274
275         return err;
276 }