![[BACK]](/icons/back.gif){kind=icon}
Return to midi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev|
Return to midi.c CVS log | Up to [local] / sys / dev |
1.1 nbrk 1: /* $OpenBSD: midi.c,v 1.16 2006/12/21 02:28:47 krw Exp $ */
2:
3: /*
4: * Copyright (c) 2003, 2004 Alexandre Ratchov
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: /*
20: * TODO
21: * - put the sequencer stuff in sequencer.c and sequencervar.h
22: * there is no reason to have it here. The sequencer
23: * driver need only to open the midi hw_if thus it does not
24: * need this driver
25: */
26:
27: #include "midi.h"
28: #include "sequencer.h"
29: #if NMIDI > 0
30:
31: #include <sys/param.h>
32: #include <sys/fcntl.h>
33: #include <sys/systm.h>
34: #include <sys/ioctl.h>
35: #include <sys/exec.h>
36: #include <sys/conf.h>
37: #include <sys/lkm.h>
38: #include <sys/proc.h>
39: #include <sys/poll.h>
40: #include <sys/kernel.h>
41: #include <sys/timeout.h>
42: #include <sys/vnode.h>
43: #include <sys/signalvar.h>
44: #include <sys/malloc.h>
45: #include <sys/device.h>
46:
47: #include <dev/midi_if.h>
48: #include <dev/audio_if.h>
49: #include <dev/midivar.h>
50:
51:
52: int midiopen(dev_t, int, int, struct proc *);
53: int midiclose(dev_t, int, int, struct proc *);
54: int midiread(dev_t, struct uio *, int);
55: int midiwrite(dev_t, struct uio *, int);
56: int midipoll(dev_t, int, struct proc *);
57: int midiioctl(dev_t, u_long, caddr_t, int, struct proc *);
58: int midiprobe(struct device *, void *, void *);
59: void midiattach(struct device *, struct device *, void *);
60: int mididetach(struct device *, int);
61: int midiprint(void *, const char *);
62:
63: void midi_iintr(void *, int);
64: void midi_ointr(void *);
65: void midi_out_start(struct midi_softc *);
66: void midi_out_stop(struct midi_softc *);
67: void midi_out_do(struct midi_softc *);
68: void midi_attach(struct midi_softc *, struct device *);
69:
70:
71: #if NSEQUENCER > 0
72: int midi_unit_count(void);
73: struct midi_hw_if *midi_get_hwif(int);
74: void midi_toevent(struct midi_softc *, int);
75: int midi_writebytes(int, u_char *, int);
76: void midiseq_in(struct midi_dev *, u_char *, int);
77: #endif
78:
79: struct cfattach midi_ca = {
80: sizeof(struct midi_softc), midiprobe, midiattach, mididetach
81: };
82:
83: struct cfdriver midi_cd = {
84: NULL, "midi", DV_DULL
85: };
86:
87:
88: void
89: midi_iintr(void *addr, int data)
90: {
91: struct midi_softc *sc = (struct midi_softc *)addr;
92: struct midi_buffer *mb = &sc->inbuf;
93:
94: if (sc->isdying || !sc->isopen || !(sc->flags & FREAD)) return;
95:
96: #if NSEQUENCER > 0
97: if (sc->seqopen) {
98: midi_toevent(sc, data);
99: return;
100: }
101: #endif
102: if (MIDIBUF_ISFULL(mb))
103: return; /* discard data */
104: if (MIDIBUF_ISEMPTY(mb)) {
105: if (sc->rchan) {
106: sc->rchan = 0;
107: wakeup(&sc->rchan);
108: }
109: selwakeup(&sc->rsel);
110: if (sc->async)
111: psignal(sc->async, SIGIO);
112: }
113: MIDIBUF_WRITE(mb, data);
114: }
115:
116:
117: int
118: midiread(dev_t dev, struct uio *uio, int ioflag)
119: {
120: struct midi_softc *sc = MIDI_DEV2SC(dev);
121: struct midi_buffer *mb = &sc->inbuf;
122: unsigned count;
123: int s, error;
124:
125: if (!(sc->flags & FREAD))
126: return ENXIO;
127:
128: /* if there is no data then sleep (unless IO_NDELAY flag is set) */
129:
130: s = splaudio();
131: while(MIDIBUF_ISEMPTY(mb)) {
132: if (sc->isdying) {
133: splx(s);
134: return EIO;
135: }
136: if (ioflag & IO_NDELAY) {
137: splx(s);
138: return EWOULDBLOCK;
139: }
140: sc->rchan = 1;
141: error = tsleep(&sc->rchan, PWAIT|PCATCH, "mid_rd", 0);
142: if (error) {
143: splx(s);
144: return error;
145: }
146: }
147:
148: /* at this stage, there is at least 1 byte */
149:
150: while (uio->uio_resid > 0 && mb->used > 0) {
151: count = MIDIBUF_SIZE - mb->start;
152: if (count > mb->used)
153: count = mb->used;
154: if (count > uio->uio_resid)
155: count = uio->uio_resid;
156: error = uiomove(mb->data + mb->start, count, uio);
157: if (error) {
158: splx(s);
159: return error;
160: }
161: MIDIBUF_REMOVE(mb, count);
162: }
163: splx(s);
164: return 0;
165: }
166:
167:
168: void
169: midi_ointr(void *addr)
170: {
171: struct midi_softc *sc = (struct midi_softc *)addr;
172: struct midi_buffer *mb;
173: int s;
174:
175: if (sc->isopen && !sc->isdying) {
176: #ifdef MIDI_DEBUG
177: if (!sc->isbusy) {
178: printf("midi_ointr: output should be busy\n");
179: }
180: #endif
181: mb = &sc->outbuf;
182: s = splaudio();
183: if (mb->used == 0)
184: midi_out_stop(sc);
185: else
186: midi_out_do(sc); /* restart output */
187: splx(s);
188: }
189: }
190:
191:
192: void
193: midi_out_start(struct midi_softc *sc)
194: {
195: if (!sc->isbusy) {
196: sc->isbusy = 1;
197: midi_out_do(sc);
198: }
199: }
200:
201: void
202: midi_out_stop(struct midi_softc *sc)
203: {
204: sc->isbusy = 0;
205: if (sc->wchan) {
206: sc->wchan = 0;
207: wakeup(&sc->wchan);
208: }
209: selwakeup(&sc->wsel);
210: if (sc->async)
211: psignal(sc->async, SIGIO);
212: }
213:
214:
215: /*
216: * drain output buffer, must be called with
217: * interrupts disabled
218: */
219: void
220: midi_out_do(struct midi_softc *sc)
221: {
222: struct midi_buffer *mb = &sc->outbuf;
223: unsigned i, max;
224: int error;
225:
226: /*
227: * If output interrupts are not supported then we write MIDI_MAXWRITE
228: * bytes instead of 1, and then we wait sc->wait
229: */
230:
231: max = sc->props & MIDI_PROP_OUT_INTR ? 1 : MIDI_MAXWRITE;
232: for (i = max; i != 0;) {
233: if (mb->used == 0)
234: break;
235: error = sc->hw_if->output(sc->hw_hdl, mb->data[mb->start]);
236: /*
237: * 0 means that data is being sent, an interrupt will
238: * be generated when the interface becomes ready again
239: *
240: * EINPROGRESS means that data has been queued, but
241: * will not be sent immediately and thus will not
242: * generate interrupt, in this case we can send
243: * another byte. The flush() method can be called
244: * to force the transfer.
245: *
246: * EAGAIN means that data cannot be queued or sent;
247: * because the interface isn't ready. An interrupt
248: * will be generated once the interface is ready again
249: *
250: * any other (fatal) error code means that data couldn't
251: * be sent and was lost, interrupt will not be generated
252: */
253: if (error == EINPROGRESS) {
254: MIDIBUF_REMOVE(mb, 1);
255: if (MIDIBUF_ISEMPTY(mb)) {
256: if (sc->hw_if->flush != NULL)
257: sc->hw_if->flush(sc->hw_hdl);
258: midi_out_stop(sc);
259: return;
260: }
261: } else if (error == 0) {
262: MIDIBUF_REMOVE(mb, 1);
263: i--;
264: } else if (error == EAGAIN) {
265: break;
266: } else {
267: MIDIBUF_INIT(mb);
268: midi_out_stop(sc);
269: return;
270: }
271: }
272:
273: if (!(sc->props & MIDI_PROP_OUT_INTR)) {
274: if (MIDIBUF_ISEMPTY(mb))
275: midi_out_stop(sc);
276: else
277: timeout_add(&sc->timeo, sc->wait);
278: }
279: }
280:
281:
282: int
283: midiwrite(dev_t dev, struct uio *uio, int ioflag)
284: {
285: struct midi_softc *sc = MIDI_DEV2SC(dev);
286: struct midi_buffer *mb = &sc->outbuf;
287: unsigned count;
288: int s, error;
289:
290: if (!(sc->flags & FWRITE))
291: return ENXIO;
292: if (sc->isdying)
293: return EIO;
294:
295: /*
296: * If IO_NDELAY flag is set then check if there is enough room
297: * in the buffer to store at least one byte. If not then dont
298: * start the write process.
299: */
300:
301: if ((ioflag & IO_NDELAY) && MIDIBUF_ISFULL(mb) &&
302: (uio->uio_resid > 0))
303: return EWOULDBLOCK;
304:
305: while (uio->uio_resid > 0) {
306: s = splaudio();
307: while (MIDIBUF_ISFULL(mb)) {
308: if (ioflag & IO_NDELAY) {
309: /*
310: * At this stage at least one byte is already
311: * moved so we do not return EWOULDBLOCK
312: */
313: splx(s);
314: return 0;
315: }
316: sc->wchan = 1;
317: error = tsleep(&sc->wchan, PWAIT|PCATCH, "mid_wr", 0);
318: if (error) {
319: splx(s);
320: return error;
321: }
322: if (sc->isdying) {
323: splx(s);
324: return EIO;
325: }
326: }
327:
328: count = MIDIBUF_SIZE - MIDIBUF_END(mb);
329: if (count > MIDIBUF_AVAIL(mb))
330: count = MIDIBUF_AVAIL(mb);
331: if (count > uio->uio_resid)
332: count = uio->uio_resid;
333: error = uiomove(mb->data + MIDIBUF_END(mb), count, uio);
334: if (error) {
335: splx(s);
336: return error;
337: }
338: mb->used += count;
339: midi_out_start(sc);
340: splx(s);
341: }
342: return 0;
343: }
344:
345:
346: int
347: midipoll(dev_t dev, int events, struct proc *p)
348: {
349: struct midi_softc *sc = MIDI_DEV2SC(dev);
350: int s, revents;
351:
352: if (sc->isdying)
353: return POLLERR;
354:
355: revents = 0;
356: s = splaudio();
357: if (events & (POLLIN | POLLRDNORM)) {
358: if (!MIDIBUF_ISEMPTY(&sc->inbuf))
359: revents |= events & (POLLIN | POLLRDNORM);
360: }
361: if (events & (POLLOUT | POLLWRNORM)) {
362: if (!MIDIBUF_ISFULL(&sc->outbuf))
363: revents |= events & (POLLOUT | POLLWRNORM);
364: }
365: if (revents == 0) {
366: if (events & (POLLIN | POLLRDNORM))
367: selrecord(p, &sc->rsel);
368: if (events & (POLLOUT | POLLWRNORM))
369: selrecord(p, &sc->wsel);
370: }
371: splx(s);
372: return (revents);
373: }
374:
375:
376: int
377: midiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
378: {
379: struct midi_softc *sc = MIDI_DEV2SC(dev);
380:
381: if (sc->isdying) return EIO;
382:
383: switch(cmd) {
384: case FIONBIO:
385: /* All handled in the upper FS layer */
386: break;
387: case FIOASYNC:
388: if (*(int *)addr) {
389: if (sc->async) return EBUSY;
390: sc->async = p;
391: } else
392: sc->async = 0;
393: break;
394: default:
395: return ENOTTY;
396: break;
397: }
398: return 0;
399: }
400:
401:
402: int
403: midiopen(dev_t dev, int flags, int mode, struct proc *p)
404: {
405: struct midi_softc *sc;
406: int err;
407:
408: if (MIDI_UNIT(dev) >= midi_cd.cd_ndevs)
409: return ENXIO;
410: sc = MIDI_DEV2SC(dev);
411: if (sc == NULL) /* there may be more units than devices */
412: return ENXIO;
413: if (sc->isdying)
414: return EIO;
415: if (sc->isopen)
416: return EBUSY;
417:
418: MIDIBUF_INIT(&sc->inbuf);
419: MIDIBUF_INIT(&sc->outbuf);
420: sc->isbusy = 0;
421: sc->rchan = sc->wchan = 0;
422: sc->async = 0;
423: sc->flags = flags;
424:
425: err = sc->hw_if->open(sc->hw_hdl, flags, midi_iintr, midi_ointr, sc);
426: if (err)
427: return err;
428: sc->isopen = 1;
429: #if NSEQUENCER > 0
430: sc->seq_md = 0;
431: sc->seqopen = 0;
432: sc->evstatus = 0xff;
433: #endif
434: return 0;
435: }
436:
437:
438: int
439: midiclose(dev_t dev, int fflag, int devtype, struct proc *p)
440: {
441: struct midi_softc *sc = MIDI_DEV2SC(dev);
442: struct midi_buffer *mb;
443: int error;
444: int s;
445:
446: mb = &sc->outbuf;
447: if (!sc->isdying) {
448: /* start draining output buffer */
449: s = splaudio();
450: if (!MIDIBUF_ISEMPTY(mb))
451: midi_out_start(sc);
452: while (sc->isbusy) {
453: sc->wchan = 1;
454: error = tsleep(&sc->wchan, PWAIT|PCATCH, "mid_dr", 0);
455: if (error || sc->isdying)
456: break;
457: }
458: splx(s);
459: }
460:
461: /*
462: * some hw_if->close() reset immediately the midi uart
463: * which flushes the internal buffer of the uart device,
464: * so we may lose some (important) data. To avoid this, we sleep 2*wait,
465: * which gives the time to the uart to drain its internal buffers.
466: *
467: * Note: we'd better sleep in the corresponding hw_if->close()
468: */
469:
470: tsleep(&sc->wchan, PWAIT|PCATCH, "mid_cl", 2 * sc->wait);
471: sc->hw_if->close(sc->hw_hdl);
472: sc->isopen = 0;
473: return 0;
474: }
475:
476:
477: int
478: midiprobe(struct device *parent, void *match, void *aux)
479: {
480: struct audio_attach_args *sa = aux;
481: return (sa != NULL && (sa->type == AUDIODEV_TYPE_MIDI) ? 1 : 0);
482: }
483:
484:
485: void
486: midi_attach(struct midi_softc *sc, struct device *parent)
487: {
488: struct midi_info mi;
489:
490: sc->isdying = 0;
491: sc->wait = (hz * MIDI_MAXWRITE) / MIDI_RATE;
492: if (sc->wait == 0)
493: sc->wait = 1;
494: sc->hw_if->getinfo(sc->hw_hdl, &mi);
495: sc->props = mi.props;
496: sc->isopen = 0;
497: timeout_set(&sc->timeo, midi_ointr, sc);
498: printf(": <%s>\n", mi.name);
499: }
500:
501:
502: void
503: midiattach(struct device *parent, struct device *self, void *aux)
504: {
505: struct midi_softc *sc = (struct midi_softc *)self;
506: struct audio_attach_args *sa = (struct audio_attach_args *)aux;
507: struct midi_hw_if *hwif = sa->hwif;
508: void *hdl = sa->hdl;
509:
510: #ifdef DIAGNOSTIC
511: if (hwif == 0 ||
512: hwif->open == 0 ||
513: hwif->close == 0 ||
514: hwif->output == 0 ||
515: hwif->getinfo == 0) {
516: printf("midi: missing method\n");
517: return;
518: }
519: #endif
520: sc->hw_if = hwif;
521: sc->hw_hdl = hdl;
522: midi_attach(sc, parent);
523: }
524:
525:
526: int
527: mididetach(struct device *self, int flags)
528: {
529: struct midi_softc *sc = (struct midi_softc *)self;
530: int maj, mn;
531:
532: sc->isdying = 1;
533: if (sc->wchan) {
534: sc->wchan = 0;
535: wakeup(&sc->wchan);
536: }
537: if (sc->rchan) {
538: sc->rchan = 0;
539: wakeup(&sc->rchan);
540: }
541:
542: /* locate the major number */
543: for (maj = 0; maj < nchrdev; maj++)
544: if (cdevsw[maj].d_open == midiopen)
545: break;
546:
547: /* Nuke the vnodes for any open instances (calls close). */
548: mn = self->dv_unit;
549: vdevgone(maj, mn, mn, VCHR);
550:
551: return 0;
552: }
553:
554:
555: int
556: midiprint(void *aux, const char *pnp)
557: {
558: if (pnp)
559: printf("midi at %s", pnp);
560: return (UNCONF);
561: }
562:
563:
564: void
565: midi_getinfo(dev_t dev, struct midi_info *mi)
566: {
567: struct midi_softc *sc = MIDI_DEV2SC(dev);
568: if (MIDI_UNIT(dev) >= midi_cd.cd_ndevs || sc == NULL || sc->isdying) {
569: mi->name = "unconfigured";
570: mi->props = 0;
571: return;
572: }
573: sc->hw_if->getinfo(sc->hw_hdl, mi);
574: }
575:
576:
577: struct device *
578: midi_attach_mi(struct midi_hw_if *hwif, void *hdl, struct device *dev)
579: {
580: struct audio_attach_args arg;
581:
582: arg.type = AUDIODEV_TYPE_MIDI;
583: arg.hwif = hwif;
584: arg.hdl = hdl;
585: return config_found(dev, &arg, midiprint);
586: }
587:
588:
589: int
590: midi_unit_count(void)
591: {
592: return midi_cd.cd_ndevs;
593: }
594:
595:
596: #if NSEQUENCER > 0
597: #define MIDI_EVLEN(status) (midi_evlen[((status) >> 4) & 7])
598: unsigned midi_evlen[] = { 2, 2, 2, 2, 1, 1, 2 };
599:
600: void
601: midi_toevent(struct midi_softc *sc, int data)
602: {
603: unsigned char mesg[3];
604:
605: if (data >= 0xf8) { /* is it a realtime message ? */
606: switch(data) {
607: case 0xf8: /* midi timer tic */
608: case 0xfa: /* midi timer start */
609: case 0xfb: /* midi timer continue (after stop) */
610: case 0xfc: /* midi timer stop */
611: mesg[0] = data;
612: midiseq_in(sc->seq_md, mesg, 1);
613: break;
614: default:
615: break;
616: }
617: } else if (data >= 0x80) { /* is it a common or voice message ? */
618: sc->evstatus = data;
619: sc->evindex = 0;
620: } else { /* else it is a data byte */
621: /* strip common messages and bogus data */
622: if (sc->evstatus >= 0xf0 || sc->evstatus < 0x80)
623: return;
624:
625: sc->evdata[sc->evindex++] = data;
626: if (sc->evindex == MIDI_EVLEN(sc->evstatus)) {
627: sc->evindex = 0;
628: mesg[0] = sc->evstatus;
629: mesg[1] = sc->evdata[0];
630: mesg[2] = sc->evdata[1];
631: midiseq_in(sc->seq_md, mesg, 1 + MIDI_EVLEN(sc->evstatus));
632: }
633: }
634: }
635:
636:
637: int
638: midi_writebytes(int unit, unsigned char *mesg, int mesglen)
639: {
640: struct midi_softc *sc = midi_cd.cd_devs[unit];
641: struct midi_buffer *mb = &sc->outbuf;
642: unsigned count;
643: int s;
644:
645: s = splaudio();
646: if (mesglen > MIDIBUF_AVAIL(mb)) {
647: splx(s);
648: return EWOULDBLOCK;
649: }
650:
651: while (mesglen > 0) {
652: count = MIDIBUF_SIZE - MIDIBUF_END(mb);
653: if (count > MIDIBUF_AVAIL(mb)) count = MIDIBUF_AVAIL(mb);
654: if (count > mesglen) count = mesglen;
655: bcopy(mesg, mb->data + MIDIBUF_END(mb), count);
656: mb->used += count;
657: mesg += count;
658: mesglen -= count;
659: midi_out_start(sc);
660: }
661: splx(s);
662: return 0;
663: }
664:
665: #endif /* NSEQUENCER > 0 */
666: #endif /* NMIDI > 0 */