projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] mark struct file_operations const 9
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / oss / emu10k1 / midi.c
1 /*
2 **********************************************************************
3 * midi.c - /dev/midi interface for emu10k1 driver
4 * Copyright 1999, 2000 Creative Labs, Inc.
5 *
6 **********************************************************************
7 *
8 * Date Author Summary of changes
9 * ---- ------ ------------------
10 * October 20, 1999 Bertrand Lee base code release
11 *
12 **********************************************************************
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License as
16 * published by the Free Software Foundation; either version 2 of
17 * the License, or (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public
25 * License along with this program; if not, write to the Free
26 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
27 * USA.
28 *
29 **********************************************************************
30 */
31
32 #include <linux/module.h>
33 #include <linux/poll.h>
34 #include <linux/slab.h>
35 #include <linux/sched.h>
36 #include <linux/smp_lock.h>
37 #include <asm/uaccess.h>
38
39 #include "hwaccess.h"
40 #include "cardmo.h"
41 #include "cardmi.h"
42 #include "midi.h"
43
44 #ifdef EMU10K1_SEQUENCER
45 #include "../sound_config.h"
46 #endif
47
48 static DEFINE_SPINLOCK(midi_spinlock);
49
50 static void init_midi_hdr(struct midi_hdr *midihdr)
51 {
52 midihdr->bufferlength = MIDIIN_BUFLEN;
53 midihdr->bytesrecorded = 0;
54 midihdr->flags = 0;
55 }
56
57 static int midiin_add_buffer(struct emu10k1_mididevice *midi_dev, struct midi_hdr **midihdrptr)
58 {
59 struct midi_hdr *midihdr;
60
61 if ((midihdr = kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL) {
62 ERROR();
63 return -EINVAL;
64 }
65
66 init_midi_hdr(midihdr);
67
68 midihdr->data = kmalloc(MIDIIN_BUFLEN, GFP_KERNEL);
69 if (!midihdr->data) {
70 ERROR();
71 kfree(midihdr);
72 return -1;
73 }
74
75 if (emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr) < 0) {
76 ERROR();
77 kfree(midihdr->data);
78 kfree(midihdr);
79 return -1;
80 }
81
82 *midihdrptr = midihdr;
83 list_add_tail(&midihdr->list, &midi_dev->mid_hdrs);
84
85 return 0;
86 }
87
88 static int emu10k1_midi_open(struct inode *inode, struct file *file)
89 {
90 int minor = iminor(inode);
91 struct emu10k1_card *card = NULL;
92 struct emu10k1_mididevice *midi_dev;
93 struct list_head *entry;
94
95 DPF(2, "emu10k1_midi_open()\n");
96
97 /* Check for correct device to open */
98 list_for_each(entry, &emu10k1_devs) {
99 card = list_entry(entry, struct emu10k1_card, list);
100
101 if (card->midi_dev == minor)
102 goto match;
103 }
104
105 return -ENODEV;
106
107 match:
108 #ifdef EMU10K1_SEQUENCER
109 if (card->seq_mididev) /* card is opened by sequencer */
110 return -EBUSY;
111 #endif
112
113 /* Wait for device to become free */
114 mutex_lock(&card->open_sem);
115 while (card->open_mode & (file->f_mode << FMODE_MIDI_SHIFT)) {
116 if (file->f_flags & O_NONBLOCK) {
117 mutex_unlock(&card->open_sem);
118 return -EBUSY;
119 }
120
121 mutex_unlock(&card->open_sem);
122 interruptible_sleep_on(&card->open_wait);
123
124 if (signal_pending(current)) {
125 return -ERESTARTSYS;
126 }
127
128 mutex_lock(&card->open_sem);
129 }
130
131 if ((midi_dev = kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL)
132 return -EINVAL;
133
134 midi_dev->card = card;
135 midi_dev->mistate = MIDIIN_STATE_STOPPED;
136 init_waitqueue_head(&midi_dev->oWait);
137 init_waitqueue_head(&midi_dev->iWait);
138 midi_dev->ird = 0;
139 midi_dev->iwr = 0;
140 midi_dev->icnt = 0;
141 INIT_LIST_HEAD(&midi_dev->mid_hdrs);
142
143 if (file->f_mode & FMODE_READ) {
144 struct midi_openinfo dsCardMidiOpenInfo;
145 struct midi_hdr *midihdr1;
146 struct midi_hdr *midihdr2;
147
148 dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
149
150 if (emu10k1_mpuin_open(card, &dsCardMidiOpenInfo) < 0) {
151 ERROR();
152 kfree(midi_dev);
153 return -ENODEV;
154 }
155
156 /* Add two buffers to receive sysex buffer */
157 if (midiin_add_buffer(midi_dev, &midihdr1) < 0) {
158 kfree(midi_dev);
159 return -ENODEV;
160 }
161
162 if (midiin_add_buffer(midi_dev, &midihdr2) < 0) {
163 list_del(&midihdr1->list);
164 kfree(midihdr1->data);
165 kfree(midihdr1);
166 kfree(midi_dev);
167 return -ENODEV;
168 }
169 }
170
171 if (file->f_mode & FMODE_WRITE) {
172 struct midi_openinfo dsCardMidiOpenInfo;
173
174 dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
175
176 if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) {
177 ERROR();
178 kfree(midi_dev);
179 return -ENODEV;
180 }
181 }
182
183 file->private_data = (void *) midi_dev;
184
185 card->open_mode |= (file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE);
186
187 mutex_unlock(&card->open_sem);
188
189 return nonseekable_open(inode, file);
190 }
191
192 static int emu10k1_midi_release(struct inode *inode, struct file *file)
193 {
194 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
195 struct emu10k1_card *card;
196
197 lock_kernel();
198
199 card = midi_dev->card;
200 DPF(2, "emu10k1_midi_release()\n");
201
202 if (file->f_mode & FMODE_WRITE) {
203 if (!(file->f_flags & O_NONBLOCK)) {
204
205 while (!signal_pending(current) && (card->mpuout->firstmidiq != NULL)) {
206 DPF(4, "Cannot close - buffers not empty\n");
207
208 interruptible_sleep_on(&midi_dev->oWait);
209
210 }
211 }
212
213 emu10k1_mpuout_close(card);
214 }
215
216 if (file->f_mode & FMODE_READ) {
217 struct midi_hdr *midihdr;
218
219 if (midi_dev->mistate == MIDIIN_STATE_STARTED) {
220 emu10k1_mpuin_stop(card);
221 midi_dev->mistate = MIDIIN_STATE_STOPPED;
222 }
223
224 emu10k1_mpuin_reset(card);
225 emu10k1_mpuin_close(card);
226
227 while (!list_empty(&midi_dev->mid_hdrs)) {
228 midihdr = list_entry(midi_dev->mid_hdrs.next, struct midi_hdr, list);
229
230 list_del(midi_dev->mid_hdrs.next);
231 kfree(midihdr->data);
232 kfree(midihdr);
233 }
234 }
235
236 kfree(midi_dev);
237
238 mutex_lock(&card->open_sem);
239 card->open_mode &= ~((file->f_mode << FMODE_MIDI_SHIFT) & (FMODE_MIDI_READ | FMODE_MIDI_WRITE));
240 mutex_unlock(&card->open_sem);
241 wake_up_interruptible(&card->open_wait);
242
243 unlock_kernel();
244
245 return 0;
246 }
247
248 static ssize_t emu10k1_midi_read(struct file *file, char __user *buffer, size_t count, loff_t * pos)
249 {
250 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
251 ssize_t ret = 0;
252 u16 cnt;
253 unsigned long flags;
254
255 DPD(4, "emu10k1_midi_read(), count %#x\n", (u32) count);
256
257 if (!access_ok(VERIFY_WRITE, buffer, count))
258 return -EFAULT;
259
260 if (midi_dev->mistate == MIDIIN_STATE_STOPPED) {
261 if (emu10k1_mpuin_start(midi_dev->card) < 0) {
262 ERROR();
263 return -EINVAL;
264 }
265
266 midi_dev->mistate = MIDIIN_STATE_STARTED;
267 }
268
269 while (count > 0) {
270 cnt = MIDIIN_BUFLEN - midi_dev->ird;
271
272 spin_lock_irqsave(&midi_spinlock, flags);
273
274 if (midi_dev->icnt < cnt)
275 cnt = midi_dev->icnt;
276
277 spin_unlock_irqrestore(&midi_spinlock, flags);
278
279 if (cnt > count)
280 cnt = count;
281
282 if (cnt <= 0) {
283 if (file->f_flags & O_NONBLOCK)
284 return ret ? ret : -EAGAIN;
285 DPF(2, " Go to sleep...\n");
286
287 interruptible_sleep_on(&midi_dev->iWait);
288
289 if (signal_pending(current))
290 return ret ? ret : -ERESTARTSYS;
291
292 continue;
293 }
294
295 if (copy_to_user(buffer, midi_dev->iBuf + midi_dev->ird, cnt)) {
296 ERROR();
297 return ret ? ret : -EFAULT;
298 }
299
300 midi_dev->ird += cnt;
301 midi_dev->ird %= MIDIIN_BUFLEN;
302
303 spin_lock_irqsave(&midi_spinlock, flags);
304
305 midi_dev->icnt -= cnt;
306
307 spin_unlock_irqrestore(&midi_spinlock, flags);
308
309 count -= cnt;
310 buffer += cnt;
311 ret += cnt;
312
313 if (midi_dev->icnt == 0)
314 break;
315 }
316
317 return ret;
318 }
319
320 static ssize_t emu10k1_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t * pos)
321 {
322 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
323 struct midi_hdr *midihdr;
324 unsigned long flags;
325
326 DPD(4, "emu10k1_midi_write(), count=%#x\n", (u32) count);
327
328 if (!access_ok(VERIFY_READ, buffer, count))
329 return -EFAULT;
330
331 if ((midihdr = kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL)
332 return -EINVAL;
333
334 midihdr->bufferlength = count;
335 midihdr->bytesrecorded = 0;
336 midihdr->flags = 0;
337
338 midihdr->data = kmalloc(count, GFP_KERNEL);
339 if (!midihdr->data) {
340 ERROR();
341 kfree(midihdr);
342 return -EINVAL;
343 }
344
345 if (copy_from_user(midihdr->data, buffer, count)) {
346 kfree(midihdr->data);
347 kfree(midihdr);
348 return -EFAULT;
349 }
350
351 spin_lock_irqsave(&midi_spinlock, flags);
352
353 if (emu10k1_mpuout_add_buffer(midi_dev->card, midihdr) < 0) {
354 ERROR();
355 kfree(midihdr->data);
356 kfree(midihdr);
357 spin_unlock_irqrestore(&midi_spinlock, flags);
358 return -EINVAL;
359 }
360
361 spin_unlock_irqrestore(&midi_spinlock, flags);
362
363 return count;
364 }
365
366 static unsigned int emu10k1_midi_poll(struct file *file, struct poll_table_struct *wait)
367 {
368 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) file->private_data;
369 unsigned long flags;
370 unsigned int mask = 0;
371
372 DPF(4, "emu10k1_midi_poll() called\n");
373
374 if (file->f_mode & FMODE_WRITE)
375 poll_wait(file, &midi_dev->oWait, wait);
376
377 if (file->f_mode & FMODE_READ)
378 poll_wait(file, &midi_dev->iWait, wait);
379
380 spin_lock_irqsave(&midi_spinlock, flags);
381
382 if (file->f_mode & FMODE_WRITE)
383 mask |= POLLOUT | POLLWRNORM;
384
385 if (file->f_mode & FMODE_READ) {
386 if (midi_dev->mistate == MIDIIN_STATE_STARTED)
387 if (midi_dev->icnt > 0)
388 mask |= POLLIN | POLLRDNORM;
389 }
390
391 spin_unlock_irqrestore(&midi_spinlock, flags);
392
393 return mask;
394 }
395
396 int emu10k1_midi_callback(unsigned long msg, unsigned long refdata, unsigned long *pmsg)
397 {
398 struct emu10k1_mididevice *midi_dev = (struct emu10k1_mididevice *) refdata;
399 struct midi_hdr *midihdr = NULL;
400 unsigned long flags;
401 int i;
402
403 DPF(4, "emu10k1_midi_callback()\n");
404
405 spin_lock_irqsave(&midi_spinlock, flags);
406
407 switch (msg) {
408 case ICARDMIDI_OUTLONGDATA:
409 midihdr = (struct midi_hdr *) pmsg[2];
410
411 kfree(midihdr->data);
412 kfree(midihdr);
413 wake_up_interruptible(&midi_dev->oWait);
414
415 break;
416
417 case ICARDMIDI_INLONGDATA:
418 midihdr = (struct midi_hdr *) pmsg[2];
419
420 for (i = 0; i < midihdr->bytesrecorded; i++) {
421 midi_dev->iBuf[midi_dev->iwr++] = midihdr->data[i];
422 midi_dev->iwr %= MIDIIN_BUFLEN;
423 }
424
425 midi_dev->icnt += midihdr->bytesrecorded;
426
427 if (midi_dev->mistate == MIDIIN_STATE_STARTED) {
428 init_midi_hdr(midihdr);
429 emu10k1_mpuin_add_buffer(midi_dev->card->mpuin, midihdr);
430 wake_up_interruptible(&midi_dev->iWait);
431 }
432 break;
433
434 case ICARDMIDI_INDATA:
435 {
436 u8 *pBuf = (u8 *) & pmsg[1];
437 u16 bytesvalid = pmsg[2];
438
439 for (i = 0; i < bytesvalid; i++) {
440 midi_dev->iBuf[midi_dev->iwr++] = pBuf[i];
441 midi_dev->iwr %= MIDIIN_BUFLEN;
442 }
443
444 midi_dev->icnt += bytesvalid;
445 }
446
447 wake_up_interruptible(&midi_dev->iWait);
448 break;
449
450 default: /* Unknown message */
451 spin_unlock_irqrestore(&midi_spinlock, flags);
452 return -1;
453 }
454
455 spin_unlock_irqrestore(&midi_spinlock, flags);
456
457 return 0;
458 }
459
460 /* MIDI file operations */
461 const struct file_operations emu10k1_midi_fops = {
462 .owner = THIS_MODULE,
463 .read = emu10k1_midi_read,
464 .write = emu10k1_midi_write,
465 .poll = emu10k1_midi_poll,
466 .open = emu10k1_midi_open,
467 .release = emu10k1_midi_release,
468 };
469
470
471 #ifdef EMU10K1_SEQUENCER
472
473 /* functions used for sequencer access */
474
475 int emu10k1_seq_midi_open(int dev, int mode,
476 void (*input) (int dev, unsigned char data),
477 void (*output) (int dev))
478 {
479 struct emu10k1_card *card;
480 struct midi_openinfo dsCardMidiOpenInfo;
481 struct emu10k1_mididevice *midi_dev;
482
483 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
484 return -EINVAL;
485
486 card = midi_devs[dev]->devc;
487
488 if (card->open_mode) /* card is opened native */
489 return -EBUSY;
490
491 DPF(2, "emu10k1_seq_midi_open()\n");
492
493 if ((midi_dev = kmalloc(sizeof(*midi_dev), GFP_KERNEL)) == NULL)
494 return -EINVAL;
495
496 midi_dev->card = card;
497 midi_dev->mistate = MIDIIN_STATE_STOPPED;
498 init_waitqueue_head(&midi_dev->oWait);
499 init_waitqueue_head(&midi_dev->iWait);
500 midi_dev->ird = 0;
501 midi_dev->iwr = 0;
502 midi_dev->icnt = 0;
503 INIT_LIST_HEAD(&midi_dev->mid_hdrs);
504
505 dsCardMidiOpenInfo.refdata = (unsigned long) midi_dev;
506
507 if (emu10k1_mpuout_open(card, &dsCardMidiOpenInfo) < 0) {
508 ERROR();
509 return -ENODEV;
510 }
511
512 card->seq_mididev = midi_dev;
513
514 return 0;
515 }
516
517 void emu10k1_seq_midi_close(int dev)
518 {
519 struct emu10k1_card *card;
520
521 DPF(2, "emu10k1_seq_midi_close()\n");
522 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
523 return;
524
525 card = midi_devs[dev]->devc;
526 emu10k1_mpuout_close(card);
527
528 kfree(card->seq_mididev);
529 card->seq_mididev = NULL;
530 }
531
532 int emu10k1_seq_midi_out(int dev, unsigned char midi_byte)
533 {
534 struct emu10k1_card *card;
535 struct midi_hdr *midihdr;
536 unsigned long flags;
537
538 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
539 return -EINVAL;
540
541 card = midi_devs[dev]->devc;
542
543 if ((midihdr = kmalloc(sizeof(struct midi_hdr), GFP_KERNEL)) == NULL)
544 return -EINVAL;
545
546 midihdr->bufferlength = 1;
547 midihdr->bytesrecorded = 0;
548 midihdr->flags = 0;
549
550 midihdr->data = kmalloc(1, GFP_KERNEL);
551 if (!midihdr->data) {
552 ERROR();
553 kfree(midihdr);
554 return -EINVAL;
555 }
556
557 *(midihdr->data) = midi_byte;
558
559 spin_lock_irqsave(&midi_spinlock, flags);
560
561 if (emu10k1_mpuout_add_buffer(card, midihdr) < 0) {
562 ERROR();
563 kfree(midihdr->data);
564 kfree(midihdr);
565 spin_unlock_irqrestore(&midi_spinlock, flags);
566 return -EINVAL;
567 }
568
569 spin_unlock_irqrestore(&midi_spinlock, flags);
570
571 return 1;
572 }
573
574 int emu10k1_seq_midi_start_read(int dev)
575 {
576 return 0;
577 }
578
579 int emu10k1_seq_midi_end_read(int dev)
580 {
581 return 0;
582 }
583
584 void emu10k1_seq_midi_kick(int dev)
585 {
586 }
587
588 int emu10k1_seq_midi_buffer_status(int dev)
589 {
590 int count;
591 struct midi_queue *queue;
592 struct emu10k1_card *card;
593
594 if (midi_devs[dev] == NULL || midi_devs[dev]->devc == NULL)
595 return -EINVAL;
596
597 count = 0;
598
599 card = midi_devs[dev]->devc;
600 queue = card->mpuout->firstmidiq;
601
602 while (queue != NULL) {
603 count++;
604 if (queue == card->mpuout->lastmidiq)
605 break;
606
607 queue = queue->next;
608 }
609
610 return count;
611 }
612
613 #endif
614
kernel source for telekom puls (alcatel/mediatek)