Merge branch 'next' into for-linus
[linux-2.6] / sound / core / seq / oss / seq_oss_synth.c
1 /*
2  * OSS compatible sequencer driver
3  *
4  * synth device handlers
5  *
6  * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  */
22
23 #include "seq_oss_synth.h"
24 #include "seq_oss_midi.h"
25 #include "../seq_lock.h"
26 #include <linux/init.h>
27
28 /*
29  * constants
30  */
31 #define SNDRV_SEQ_OSS_MAX_SYNTH_NAME    30
32 #define MAX_SYSEX_BUFLEN                128
33
34
35 /*
36  * definition of synth info records
37  */
38
39 /* sysex buffer */
40 struct seq_oss_synth_sysex {
41         int len;
42         int skip;
43         unsigned char buf[MAX_SYSEX_BUFLEN];
44 };
45
46 /* synth info */
47 struct seq_oss_synth {
48         int seq_device;
49
50         /* for synth_info */
51         int synth_type;
52         int synth_subtype;
53         int nr_voices;
54
55         char name[SNDRV_SEQ_OSS_MAX_SYNTH_NAME];
56         struct snd_seq_oss_callback oper;
57
58         int opened;
59
60         void *private_data;
61         snd_use_lock_t use_lock;
62 };
63
64
65 /*
66  * device table
67  */
68 static int max_synth_devs;
69 static struct seq_oss_synth *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS];
70 static struct seq_oss_synth midi_synth_dev = {
71         -1, /* seq_device */
72         SYNTH_TYPE_MIDI, /* synth_type */
73         0, /* synth_subtype */
74         16, /* nr_voices */
75         "MIDI", /* name */
76 };
77
78 static DEFINE_SPINLOCK(register_lock);
79
80 /*
81  * prototypes
82  */
83 static struct seq_oss_synth *get_synthdev(struct seq_oss_devinfo *dp, int dev);
84 static void reset_channels(struct seq_oss_synthinfo *info);
85
86 /*
87  * global initialization
88  */
89 void __init
90 snd_seq_oss_synth_init(void)
91 {
92         snd_use_lock_init(&midi_synth_dev.use_lock);
93 }
94
95 /*
96  * registration of the synth device
97  */
98 int
99 snd_seq_oss_synth_register(struct snd_seq_device *dev)
100 {
101         int i;
102         struct seq_oss_synth *rec;
103         struct snd_seq_oss_reg *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev);
104         unsigned long flags;
105
106         if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) {
107                 snd_printk(KERN_ERR "can't malloc synth info\n");
108                 return -ENOMEM;
109         }
110         rec->seq_device = -1;
111         rec->synth_type = reg->type;
112         rec->synth_subtype = reg->subtype;
113         rec->nr_voices = reg->nvoices;
114         rec->oper = reg->oper;
115         rec->private_data = reg->private_data;
116         rec->opened = 0;
117         snd_use_lock_init(&rec->use_lock);
118
119         /* copy and truncate the name of synth device */
120         strlcpy(rec->name, dev->name, sizeof(rec->name));
121
122         /* registration */
123         spin_lock_irqsave(&register_lock, flags);
124         for (i = 0; i < max_synth_devs; i++) {
125                 if (synth_devs[i] == NULL)
126                         break;
127         }
128         if (i >= max_synth_devs) {
129                 if (max_synth_devs >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS) {
130                         spin_unlock_irqrestore(&register_lock, flags);
131                         snd_printk(KERN_ERR "no more synth slot\n");
132                         kfree(rec);
133                         return -ENOMEM;
134                 }
135                 max_synth_devs++;
136         }
137         rec->seq_device = i;
138         synth_devs[i] = rec;
139         debug_printk(("synth %s registered %d\n", rec->name, i));
140         spin_unlock_irqrestore(&register_lock, flags);
141         dev->driver_data = rec;
142 #ifdef SNDRV_OSS_INFO_DEV_SYNTH
143         if (i < SNDRV_CARDS)
144                 snd_oss_info_register(SNDRV_OSS_INFO_DEV_SYNTH, i, rec->name);
145 #endif
146         return 0;
147 }
148
149
150 int
151 snd_seq_oss_synth_unregister(struct snd_seq_device *dev)
152 {
153         int index;
154         struct seq_oss_synth *rec = dev->driver_data;
155         unsigned long flags;
156
157         spin_lock_irqsave(&register_lock, flags);
158         for (index = 0; index < max_synth_devs; index++) {
159                 if (synth_devs[index] == rec)
160                         break;
161         }
162         if (index >= max_synth_devs) {
163                 spin_unlock_irqrestore(&register_lock, flags);
164                 snd_printk(KERN_ERR "can't unregister synth\n");
165                 return -EINVAL;
166         }
167         synth_devs[index] = NULL;
168         if (index == max_synth_devs - 1) {
169                 for (index--; index >= 0; index--) {
170                         if (synth_devs[index])
171                                 break;
172                 }
173                 max_synth_devs = index + 1;
174         }
175         spin_unlock_irqrestore(&register_lock, flags);
176 #ifdef SNDRV_OSS_INFO_DEV_SYNTH
177         if (rec->seq_device < SNDRV_CARDS)
178                 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_SYNTH, rec->seq_device);
179 #endif
180
181         snd_use_lock_sync(&rec->use_lock);
182         kfree(rec);
183
184         return 0;
185 }
186
187
188 /*
189  */
190 static struct seq_oss_synth *
191 get_sdev(int dev)
192 {
193         struct seq_oss_synth *rec;
194         unsigned long flags;
195
196         spin_lock_irqsave(&register_lock, flags);
197         rec = synth_devs[dev];
198         if (rec)
199                 snd_use_lock_use(&rec->use_lock);
200         spin_unlock_irqrestore(&register_lock, flags);
201         return rec;
202 }
203
204
205 /*
206  * set up synth tables
207  */
208
209 void
210 snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp)
211 {
212         int i;
213         struct seq_oss_synth *rec;
214         struct seq_oss_synthinfo *info;
215
216         dp->max_synthdev = max_synth_devs;
217         dp->synth_opened = 0;
218         memset(dp->synths, 0, sizeof(dp->synths));
219         for (i = 0; i < dp->max_synthdev; i++) {
220                 rec = get_sdev(i);
221                 if (rec == NULL)
222                         continue;
223                 if (rec->oper.open == NULL || rec->oper.close == NULL) {
224                         snd_use_lock_free(&rec->use_lock);
225                         continue;
226                 }
227                 info = &dp->synths[i];
228                 info->arg.app_index = dp->port;
229                 info->arg.file_mode = dp->file_mode;
230                 info->arg.seq_mode = dp->seq_mode;
231                 if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH)
232                         info->arg.event_passing = SNDRV_SEQ_OSS_PROCESS_EVENTS;
233                 else
234                         info->arg.event_passing = SNDRV_SEQ_OSS_PASS_EVENTS;
235                 info->opened = 0;
236                 if (!try_module_get(rec->oper.owner)) {
237                         snd_use_lock_free(&rec->use_lock);
238                         continue;
239                 }
240                 if (rec->oper.open(&info->arg, rec->private_data) < 0) {
241                         module_put(rec->oper.owner);
242                         snd_use_lock_free(&rec->use_lock);
243                         continue;
244                 }
245                 info->nr_voices = rec->nr_voices;
246                 if (info->nr_voices > 0) {
247                         info->ch = kcalloc(info->nr_voices, sizeof(struct seq_oss_chinfo), GFP_KERNEL);
248                         if (!info->ch) {
249                                 snd_printk(KERN_ERR "Cannot malloc\n");
250                                 rec->oper.close(&info->arg);
251                                 module_put(rec->oper.owner);
252                                 snd_use_lock_free(&rec->use_lock);
253                                 continue;
254                         }
255                         reset_channels(info);
256                 }
257                 debug_printk(("synth %d assigned\n", i));
258                 info->opened++;
259                 rec->opened++;
260                 dp->synth_opened++;
261                 snd_use_lock_free(&rec->use_lock);
262         }
263 }
264
265
266 /*
267  * set up synth tables for MIDI emulation - /dev/music mode only
268  */
269
270 void
271 snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp)
272 {
273         int i;
274
275         if (dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)
276                 return;
277
278         for (i = 0; i < dp->max_mididev; i++) {
279                 struct seq_oss_synthinfo *info;
280                 info = &dp->synths[dp->max_synthdev];
281                 if (snd_seq_oss_midi_open(dp, i, dp->file_mode) < 0)
282                         continue;
283                 info->arg.app_index = dp->port;
284                 info->arg.file_mode = dp->file_mode;
285                 info->arg.seq_mode = dp->seq_mode;
286                 info->arg.private_data = info;
287                 info->is_midi = 1;
288                 info->midi_mapped = i;
289                 info->arg.event_passing = SNDRV_SEQ_OSS_PASS_EVENTS;
290                 snd_seq_oss_midi_get_addr(dp, i, &info->arg.addr);
291                 info->opened = 1;
292                 midi_synth_dev.opened++;
293                 dp->max_synthdev++;
294                 if (dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)
295                         break;
296         }
297 }
298
299
300 /*
301  * clean up synth tables
302  */
303
304 void
305 snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp)
306 {
307         int i;
308         struct seq_oss_synth *rec;
309         struct seq_oss_synthinfo *info;
310
311         snd_assert(dp->max_synthdev <= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS, return);
312         for (i = 0; i < dp->max_synthdev; i++) {
313                 info = &dp->synths[i];
314                 if (! info->opened)
315                         continue;
316                 if (info->is_midi) {
317                         if (midi_synth_dev.opened > 0) {
318                                 snd_seq_oss_midi_close(dp, info->midi_mapped);
319                                 midi_synth_dev.opened--;
320                         }
321                 } else {
322                         rec = get_sdev(i);
323                         if (rec == NULL)
324                                 continue;
325                         if (rec->opened > 0) {
326                                 debug_printk(("synth %d closed\n", i));
327                                 rec->oper.close(&info->arg);
328                                 module_put(rec->oper.owner);
329                                 rec->opened = 0;
330                         }
331                         snd_use_lock_free(&rec->use_lock);
332                 }
333                 kfree(info->sysex);
334                 info->sysex = NULL;
335                 kfree(info->ch);
336                 info->ch = NULL;
337         }
338         dp->synth_opened = 0;
339         dp->max_synthdev = 0;
340 }
341
342 /*
343  * check if the specified device is MIDI mapped device
344  */
345 static int
346 is_midi_dev(struct seq_oss_devinfo *dp, int dev)
347 {
348         if (dev < 0 || dev >= dp->max_synthdev)
349                 return 0;
350         if (dp->synths[dev].is_midi)
351                 return 1;
352         return 0;
353 }
354
355 /*
356  * return synth device information pointer
357  */
358 static struct seq_oss_synth *
359 get_synthdev(struct seq_oss_devinfo *dp, int dev)
360 {
361         struct seq_oss_synth *rec;
362         if (dev < 0 || dev >= dp->max_synthdev)
363                 return NULL;
364         if (! dp->synths[dev].opened)
365                 return NULL;
366         if (dp->synths[dev].is_midi)
367                 return &midi_synth_dev;
368         if ((rec = get_sdev(dev)) == NULL)
369                 return NULL;
370         if (! rec->opened) {
371                 snd_use_lock_free(&rec->use_lock);
372                 return NULL;
373         }
374         return rec;
375 }
376
377
378 /*
379  * reset note and velocity on each channel.
380  */
381 static void
382 reset_channels(struct seq_oss_synthinfo *info)
383 {
384         int i;
385         if (info->ch == NULL || ! info->nr_voices)
386                 return;
387         for (i = 0; i < info->nr_voices; i++) {
388                 info->ch[i].note = -1;
389                 info->ch[i].vel = 0;
390         }
391 }
392
393
394 /*
395  * reset synth device:
396  * call reset callback.  if no callback is defined, send a heartbeat
397  * event to the corresponding port.
398  */
399 void
400 snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev)
401 {
402         struct seq_oss_synth *rec;
403         struct seq_oss_synthinfo *info;
404
405         snd_assert(dev >= 0 && dev < dp->max_synthdev, return);
406         info = &dp->synths[dev];
407         if (! info->opened)
408                 return;
409         if (info->sysex)
410                 info->sysex->len = 0; /* reset sysex */
411         reset_channels(info);
412         if (info->is_midi) {
413                 if (midi_synth_dev.opened <= 0)
414                         return;
415                 snd_seq_oss_midi_reset(dp, info->midi_mapped);
416                 /* reopen the device */
417                 snd_seq_oss_midi_close(dp, dev);
418                 if (snd_seq_oss_midi_open(dp, info->midi_mapped,
419                                           dp->file_mode) < 0) {
420                         midi_synth_dev.opened--;
421                         info->opened = 0;
422                         kfree(info->sysex);
423                         info->sysex = NULL;
424                         kfree(info->ch);
425                         info->ch = NULL;
426                 }
427                 return;
428         }
429
430         rec = get_sdev(dev);
431         if (rec == NULL)
432                 return;
433         if (rec->oper.reset) {
434                 rec->oper.reset(&info->arg);
435         } else {
436                 struct snd_seq_event ev;
437                 memset(&ev, 0, sizeof(ev));
438                 snd_seq_oss_fill_addr(dp, &ev, info->arg.addr.client,
439                                       info->arg.addr.port);
440                 ev.type = SNDRV_SEQ_EVENT_RESET;
441                 snd_seq_oss_dispatch(dp, &ev, 0, 0);
442         }
443         snd_use_lock_free(&rec->use_lock);
444 }
445
446
447 /*
448  * load a patch record:
449  * call load_patch callback function
450  */
451 int
452 snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt,
453                             const char __user *buf, int p, int c)
454 {
455         struct seq_oss_synth *rec;
456         int rc;
457
458         if (dev < 0 || dev >= dp->max_synthdev)
459                 return -ENXIO;
460
461         if (is_midi_dev(dp, dev))
462                 return 0;
463         if ((rec = get_synthdev(dp, dev)) == NULL)
464                 return -ENXIO;
465
466         if (rec->oper.load_patch == NULL)
467                 rc = -ENXIO;
468         else
469                 rc = rec->oper.load_patch(&dp->synths[dev].arg, fmt, buf, p, c);
470         snd_use_lock_free(&rec->use_lock);
471         return rc;
472 }
473
474 /*
475  * check if the device is valid synth device
476  */
477 int
478 snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev)
479 {
480         struct seq_oss_synth *rec;
481         rec = get_synthdev(dp, dev);
482         if (rec) {
483                 snd_use_lock_free(&rec->use_lock);
484                 return 1;
485         }
486         return 0;
487 }
488
489
490 /*
491  * receive OSS 6 byte sysex packet:
492  * the full sysex message will be sent if it reaches to the end of data
493  * (0xff).
494  */
495 int
496 snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, struct snd_seq_event *ev)
497 {
498         int i, send;
499         unsigned char *dest;
500         struct seq_oss_synth_sysex *sysex;
501
502         if (! snd_seq_oss_synth_is_valid(dp, dev))
503                 return -ENXIO;
504
505         sysex = dp->synths[dev].sysex;
506         if (sysex == NULL) {
507                 sysex = kzalloc(sizeof(*sysex), GFP_KERNEL);
508                 if (sysex == NULL)
509                         return -ENOMEM;
510                 dp->synths[dev].sysex = sysex;
511         }
512
513         send = 0;
514         dest = sysex->buf + sysex->len;
515         /* copy 6 byte packet to the buffer */
516         for (i = 0; i < 6; i++) {
517                 if (buf[i] == 0xff) {
518                         send = 1;
519                         break;
520                 }
521                 dest[i] = buf[i];
522                 sysex->len++;
523                 if (sysex->len >= MAX_SYSEX_BUFLEN) {
524                         sysex->len = 0;
525                         sysex->skip = 1;
526                         break;
527                 }
528         }
529
530         if (sysex->len && send) {
531                 if (sysex->skip) {
532                         sysex->skip = 0;
533                         sysex->len = 0;
534                         return -EINVAL; /* skip */
535                 }
536                 /* copy the data to event record and send it */
537                 ev->flags = SNDRV_SEQ_EVENT_LENGTH_VARIABLE;
538                 if (snd_seq_oss_synth_addr(dp, dev, ev))
539                         return -EINVAL;
540                 ev->data.ext.len = sysex->len;
541                 ev->data.ext.ptr = sysex->buf;
542                 sysex->len = 0;
543                 return 0;
544         }
545
546         return -EINVAL; /* skip */
547 }
548
549 /*
550  * fill the event source/destination addresses
551  */
552 int
553 snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev)
554 {
555         if (! snd_seq_oss_synth_is_valid(dp, dev))
556                 return -EINVAL;
557         snd_seq_oss_fill_addr(dp, ev, dp->synths[dev].arg.addr.client,
558                               dp->synths[dev].arg.addr.port);
559         return 0;
560 }
561
562
563 /*
564  * OSS compatible ioctl
565  */
566 int
567 snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, unsigned long addr)
568 {
569         struct seq_oss_synth *rec;
570         int rc;
571
572         if (is_midi_dev(dp, dev))
573                 return -ENXIO;
574         if ((rec = get_synthdev(dp, dev)) == NULL)
575                 return -ENXIO;
576         if (rec->oper.ioctl == NULL)
577                 rc = -ENXIO;
578         else
579                 rc = rec->oper.ioctl(&dp->synths[dev].arg, cmd, addr);
580         snd_use_lock_free(&rec->use_lock);
581         return rc;
582 }
583
584
585 /*
586  * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME
587  */
588 int
589 snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, unsigned char *data, struct snd_seq_event *ev)
590 {
591         if (! snd_seq_oss_synth_is_valid(dp, dev) || is_midi_dev(dp, dev))
592                 return -ENXIO;
593         ev->type = SNDRV_SEQ_EVENT_OSS;
594         memcpy(ev->data.raw8.d, data, 8);
595         return snd_seq_oss_synth_addr(dp, dev, ev);
596 }
597
598
599 /*
600  * create OSS compatible synth_info record
601  */
602 int
603 snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf)
604 {
605         struct seq_oss_synth *rec;
606
607         if (dev < 0 || dev >= dp->max_synthdev)
608                 return -ENXIO;
609
610         if (dp->synths[dev].is_midi) {
611                 struct midi_info minf;
612                 snd_seq_oss_midi_make_info(dp, dp->synths[dev].midi_mapped, &minf);
613                 inf->synth_type = SYNTH_TYPE_MIDI;
614                 inf->synth_subtype = 0;
615                 inf->nr_voices = 16;
616                 inf->device = dev;
617                 strlcpy(inf->name, minf.name, sizeof(inf->name));
618         } else {
619                 if ((rec = get_synthdev(dp, dev)) == NULL)
620                         return -ENXIO;
621                 inf->synth_type = rec->synth_type;
622                 inf->synth_subtype = rec->synth_subtype;
623                 inf->nr_voices = rec->nr_voices;
624                 inf->device = dev;
625                 strlcpy(inf->name, rec->name, sizeof(inf->name));
626                 snd_use_lock_free(&rec->use_lock);
627         }
628         return 0;
629 }
630
631
632 #ifdef CONFIG_PROC_FS
633 /*
634  * proc interface
635  */
636 void
637 snd_seq_oss_synth_info_read(struct snd_info_buffer *buf)
638 {
639         int i;
640         struct seq_oss_synth *rec;
641
642         snd_iprintf(buf, "\nNumber of synth devices: %d\n", max_synth_devs);
643         for (i = 0; i < max_synth_devs; i++) {
644                 snd_iprintf(buf, "\nsynth %d: ", i);
645                 rec = get_sdev(i);
646                 if (rec == NULL) {
647                         snd_iprintf(buf, "*empty*\n");
648                         continue;
649                 }
650                 snd_iprintf(buf, "[%s]\n", rec->name);
651                 snd_iprintf(buf, "  type 0x%x : subtype 0x%x : voices %d\n",
652                             rec->synth_type, rec->synth_subtype,
653                             rec->nr_voices);
654                 snd_iprintf(buf, "  capabilities : ioctl %s / load_patch %s\n",
655                             enabled_str((long)rec->oper.ioctl),
656                             enabled_str((long)rec->oper.load_patch));
657                 snd_use_lock_free(&rec->use_lock);
658         }
659 }
660 #endif /* CONFIG_PROC_FS */