![[BACK]](/icons/back.gif){kind=icon}
Return to spkr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa|
Return to spkr.c CVS log | Up to [local] / sys / dev / isa |
1.1 nbrk 1: /* $OpenBSD: spkr.c,v 1.10 2006/03/09 22:35:23 miod Exp $ */
2: /* $NetBSD: spkr.c,v 1.1 1998/04/15 20:26:18 drochner Exp $ */
3:
4: /*
5: * Copyright (c) 1990 Eric S. Raymond (esr@snark.thyrsus.com)
6: * Copyright (c) 1990 Andrew A. Chernov (ache@astral.msk.su)
7: * Copyright (c) 1990 Lennart Augustsson (lennart@augustsson.net)
8: * All rights reserved.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by Eric S. Raymond
21: * 4. The name of the author may not be used to endorse or promote products
22: * derived from this software without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
26: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
28: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
29: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
30: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
32: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34: * POSSIBILITY OF SUCH DAMAGE.
35: */
36:
37: /*
38: * spkr.c -- device driver for console speaker on 80386
39: *
40: * v1.1 by Eric S. Raymond (esr@snark.thyrsus.com) Feb 1990
41: * modified for 386bsd by Andrew A. Chernov <ache@astral.msk.su>
42: * 386bsd only clean version, all SYSV stuff removed
43: * use hz value from param.c
44: */
45:
46: #include <sys/param.h>
47: #include <sys/systm.h>
48: #include <sys/kernel.h>
49: #include <sys/errno.h>
50: #include <sys/device.h>
51: #include <sys/malloc.h>
52: #include <sys/uio.h>
53: #include <sys/proc.h>
54: #include <sys/ioctl.h>
55: #include <sys/conf.h>
56:
57: #include <dev/isa/pcppivar.h>
58:
59: #include <dev/isa/spkrio.h>
60:
61: cdev_decl(spkr);
62:
63: int spkrprobe(struct device *, void *, void *);
64: void spkrattach(struct device *, struct device *, void *);
65:
66: struct cfattach spkr_ca = {
67: sizeof(struct device), spkrprobe, spkrattach
68: };
69:
70: struct cfdriver spkr_cd = {
71: NULL, "spkr", DV_DULL
72: };
73:
74: static pcppi_tag_t ppicookie;
75:
76: #define SPKRPRI (PZERO - 1)
77:
78: static void tone(u_int, u_int);
79: static void rest(int);
80: static void playinit(void);
81: static void playtone(int, int, int);
82: static void playstring(char *, int);
83:
84: /* emit tone of frequency hz for given number of ticks */
85: static void
86: tone(hz, ticks)
87: u_int hz, ticks;
88: {
89: pcppi_bell(ppicookie, hz, ticks, PCPPI_BELL_SLEEP);
90: }
91:
92: /* rest for given number of ticks */
93: static void
94: rest(ticks)
95: int ticks;
96: {
97: /*
98: * Set timeout to endrest function, then give up the timeslice.
99: * This is so other processes can execute while the rest is being
100: * waited out.
101: */
102: #ifdef SPKRDEBUG
103: printf("rest: %d\n", ticks);
104: #endif /* SPKRDEBUG */
105: if (ticks > 0)
106: tsleep(rest, SPKRPRI | PCATCH, "rest", ticks);
107: }
108:
109: /**************** PLAY STRING INTERPRETER BEGINS HERE **********************
110: *
111: * Play string interpretation is modelled on IBM BASIC 2.0's PLAY statement;
112: * M[LNS] are missing and the ~ synonym and octave-tracking facility is added.
113: * Requires tone(), rest(), and endtone(). String play is not interruptible
114: * except possibly at physical block boundaries.
115: */
116:
117: typedef int bool;
118: #define TRUE 1
119: #define FALSE 0
120:
121: #define toupper(c) ((c) - ' ' * (((c) >= 'a') && ((c) <= 'z')))
122: #define isdigit(c) (((c) >= '0') && ((c) <= '9'))
123: #define dtoi(c) ((c) - '0')
124:
125: static int octave; /* currently selected octave */
126: static int whole; /* whole-note time at current tempo, in ticks */
127: static int value; /* whole divisor for note time, quarter note = 1 */
128: static int fill; /* controls spacing of notes */
129: static bool octtrack; /* octave-tracking on? */
130: static bool octprefix; /* override current octave-tracking state? */
131:
132: /*
133: * Magic number avoidance...
134: */
135: #define SECS_PER_MIN 60 /* seconds per minute */
136: #define WHOLE_NOTE 4 /* quarter notes per whole note */
137: #define MIN_VALUE 64 /* the most we can divide a note by */
138: #define DFLT_VALUE 4 /* default value (quarter-note) */
139: #define FILLTIME 8 /* for articulation, break note in parts */
140: #define STACCATO 6 /* 6/8 = 3/4 of note is filled */
141: #define NORMAL 7 /* 7/8ths of note interval is filled */
142: #define LEGATO 8 /* all of note interval is filled */
143: #define DFLT_OCTAVE 4 /* default octave */
144: #define MIN_TEMPO 32 /* minimum tempo */
145: #define DFLT_TEMPO 120 /* default tempo */
146: #define MAX_TEMPO 255 /* max tempo */
147: #define NUM_MULT 3 /* numerator of dot multiplier */
148: #define DENOM_MULT 2 /* denominator of dot multiplier */
149:
150: /* letter to half-tone: A B C D E F G */
151: static int notetab[8] = { 9, 11, 0, 2, 4, 5, 7 };
152:
153: /*
154: * This is the American Standard A440 Equal-Tempered scale with frequencies
155: * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook...
156: * our octave 0 is standard octave 2.
157: */
158: #define OCTAVE_NOTES 12 /* semitones per octave */
159: static int pitchtab[] =
160: {
161: /* C C# D D# E F F# G G# A A# B*/
162: /* 0 */ 65, 69, 73, 78, 82, 87, 93, 98, 103, 110, 117, 123,
163: /* 1 */ 131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247,
164: /* 2 */ 262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494,
165: /* 3 */ 523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988,
166: /* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975,
167: /* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
168: /* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902,
169: };
170: #define NOCTAVES (sizeof(pitchtab) / sizeof(pitchtab[0]) / OCTAVE_NOTES)
171:
172: static void
173: playinit()
174: {
175: octave = DFLT_OCTAVE;
176: whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO;
177: fill = NORMAL;
178: value = DFLT_VALUE;
179: octtrack = FALSE;
180: octprefix = TRUE; /* act as though there was an initial O(n) */
181: }
182:
183: /* play tone of proper duration for current rhythm signature */
184: static void
185: playtone(pitch, value, sustain)
186: int pitch, value, sustain;
187: {
188: int sound, silence, snum = 1, sdenom = 1;
189:
190: /* this weirdness avoids floating-point arithmetic */
191: for (; sustain; sustain--) {
192: snum *= NUM_MULT;
193: sdenom *= DENOM_MULT;
194: }
195:
196: if (pitch == -1)
197: rest(whole * snum / (value * sdenom));
198: else if (pitch >= 0 &&
199: pitch < (sizeof(pitchtab) / sizeof(pitchtab[0]))) {
200: sound = (whole * snum) / (value * sdenom) -
201: (whole * (FILLTIME - fill)) / (value * FILLTIME);
202: silence = whole * (FILLTIME-fill) * snum /
203: (FILLTIME * value * sdenom);
204:
205: #ifdef SPKRDEBUG
206: printf("playtone: pitch %d for %d ticks, rest for %d ticks\n",
207: pitch, sound, silence);
208: #endif /* SPKRDEBUG */
209:
210: tone(pitchtab[pitch], sound);
211: if (fill != LEGATO)
212: rest(silence);
213: }
214: }
215:
216: /* interpret and play an item from a notation string */
217: static void
218: playstring(cp, slen)
219: char *cp;
220: int slen;
221: {
222: int pitch, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;
223:
224: #define GETNUM(cp, v) \
225: do { \
226: for (v = 0; slen > 0 && isdigit(cp[1]); ) { \
227: v = v * 10 + (*++cp - '0'); \
228: slen--; \
229: } \
230: } while (0)
231:
232: for (; slen--; cp++) {
233: int sustain, timeval, tempo;
234: char c = toupper(*cp);
235:
236: #ifdef SPKRDEBUG
237: printf("playstring: %c (%x)\n", c, c);
238: #endif /* SPKRDEBUG */
239:
240: switch (c) {
241: case 'A':
242: case 'B':
243: case 'C':
244: case 'D':
245: case 'E':
246: case 'F':
247: case 'G':
248: /* compute pitch */
249: pitch = notetab[c - 'A'] + octave * OCTAVE_NOTES;
250:
251: /* this may be followed by an accidental sign */
252: if (slen > 0 && (cp[1] == '#' || cp[1] == '+')) {
253: ++pitch;
254: ++cp;
255: slen--;
256: } else if (slen > 0 && cp[1] == '-') {
257: --pitch;
258: ++cp;
259: slen--;
260: }
261:
262: /*
263: * If octave-tracking mode is on, and there has been
264: * no octave-setting prefix, find the version of the
265: * current letter note closest to the last regardless
266: * of octave.
267: */
268: if (octtrack && !octprefix) {
269: if (abs(pitch - lastpitch) >
270: abs(pitch + OCTAVE_NOTES - lastpitch)) {
271: ++octave;
272: pitch += OCTAVE_NOTES;
273: }
274:
275: if (abs(pitch - lastpitch) >
276: abs(pitch - OCTAVE_NOTES - lastpitch)) {
277: --octave;
278: pitch -= OCTAVE_NOTES;
279: }
280: }
281: octprefix = FALSE;
282: lastpitch = pitch;
283:
284: /*
285: * ...which may in turn be followed by an override
286: * time value
287: */
288: GETNUM(cp, timeval);
289: if (timeval <= 0 || timeval > MIN_VALUE)
290: timeval = value;
291:
292: /* ...and/or sustain dots */
293: for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) {
294: slen--;
295: sustain++;
296: }
297:
298: /* time to emit the actual tone */
299: playtone(pitch, timeval, sustain);
300: break;
301:
302: case 'O':
303: if (slen > 0 && (cp[1] == 'N' || cp[1] == 'n')) {
304: octprefix = octtrack = FALSE;
305: ++cp;
306: slen--;
307: } else if (slen > 0 && (cp[1] == 'L' || cp[1] == 'l')) {
308: octtrack = TRUE;
309: ++cp;
310: slen--;
311: } else {
312: GETNUM(cp, octave);
313: if (octave >= NOCTAVES)
314: octave = DFLT_OCTAVE;
315: octprefix = TRUE;
316: }
317: break;
318:
319: case '>':
320: if (octave < NOCTAVES - 1)
321: octave++;
322: octprefix = TRUE;
323: break;
324:
325: case '<':
326: if (octave > 0)
327: octave--;
328: octprefix = TRUE;
329: break;
330:
331: case 'N':
332: GETNUM(cp, pitch);
333: for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) {
334: slen--;
335: sustain++;
336: }
337: playtone(pitch - 1, value, sustain);
338: break;
339:
340: case 'L':
341: GETNUM(cp, value);
342: if (value <= 0 || value > MIN_VALUE)
343: value = DFLT_VALUE;
344: break;
345:
346: case 'P':
347: case '~':
348: /* this may be followed by an override time value */
349: GETNUM(cp, timeval);
350: if (timeval <= 0 || timeval > MIN_VALUE)
351: timeval = value;
352: for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) {
353: slen--;
354: sustain++;
355: }
356: playtone(-1, timeval, sustain);
357: break;
358:
359: case 'T':
360: GETNUM(cp, tempo);
361: if (tempo < MIN_TEMPO || tempo > MAX_TEMPO)
362: tempo = DFLT_TEMPO;
363: whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / tempo;
364: break;
365:
366: case 'M':
367: if (slen > 0 && (cp[1] == 'N' || cp[1] == 'n')) {
368: fill = NORMAL;
369: ++cp;
370: slen--;
371: } else if (slen > 0 && (cp[1] == 'L' || cp[1] == 'l')) {
372: fill = LEGATO;
373: ++cp;
374: slen--;
375: } else if (slen > 0 && (cp[1] == 'S' || cp[1] == 's')) {
376: fill = STACCATO;
377: ++cp;
378: slen--;
379: }
380: break;
381: }
382: }
383: }
384:
385: /******************* UNIX DRIVER HOOKS BEGIN HERE **************************
386: *
387: * This section implements driver hooks to run playstring() and the tone(),
388: * endtone(), and rest() functions defined above.
389: */
390:
391: static int spkr_active; /* exclusion flag */
392: static void *spkr_inbuf;
393:
394: static int spkr_attached = 0;
395:
396: int
397: spkrprobe(parent, match, aux)
398: struct device *parent;
399: void *match;
400: void *aux;
401: {
402: return (!spkr_attached);
403: }
404:
405: void
406: spkrattach(parent, self, aux)
407: struct device *parent;
408: struct device *self;
409: void *aux;
410: {
411: printf("\n");
412: ppicookie = ((struct pcppi_attach_args *)aux)->pa_cookie;
413: spkr_attached = 1;
414: }
415:
416: int
417: spkropen(dev, flags, mode, p)
418: dev_t dev;
419: int flags;
420: int mode;
421: struct proc *p;
422: {
423: #ifdef SPKRDEBUG
424: printf("spkropen: entering with dev = %x\n", dev);
425: #endif /* SPKRDEBUG */
426:
427: if (minor(dev) != 0 || !spkr_attached)
428: return (ENXIO);
429: else if (spkr_active)
430: return (EBUSY);
431: else {
432: playinit();
433: spkr_inbuf = malloc(DEV_BSIZE, M_DEVBUF, M_WAITOK);
434: spkr_active = 1;
435: }
436: return (0);
437: }
438:
439: int
440: spkrwrite(dev, uio, flags)
441: dev_t dev;
442: struct uio *uio;
443: int flags;
444: {
445: int n;
446: int error;
447: #ifdef SPKRDEBUG
448: printf("spkrwrite: entering with dev = %x, count = %d\n",
449: dev, uio->uio_resid);
450: #endif /* SPKRDEBUG */
451:
452: if (minor(dev) != 0)
453: return (ENXIO);
454: else {
455: n = min(DEV_BSIZE, uio->uio_resid);
456: error = uiomove(spkr_inbuf, n, uio);
457: if (!error)
458: playstring((char *)spkr_inbuf, n);
459: return (error);
460: }
461: }
462:
463: int
464: spkrclose(dev, flags, mode, p)
465: dev_t dev;
466: int flags;
467: int mode;
468: struct proc *p;
469: {
470: #ifdef SPKRDEBUG
471: printf("spkrclose: entering with dev = %x\n", dev);
472: #endif /* SPKRDEBUG */
473:
474: if (minor(dev) != 0)
475: return (ENXIO);
476: else {
477: tone(0, 0);
478: free(spkr_inbuf, M_DEVBUF);
479: spkr_active = 0;
480: }
481: return (0);
482: }
483:
484: int
485: spkrioctl(dev, cmd, data, flag, p)
486: dev_t dev;
487: u_long cmd;
488: caddr_t data;
489: int flag;
490: struct proc *p;
491: {
492: tone_t *tp, ttp;
493: int error;
494:
495: #ifdef SPKRDEBUG
496: printf("spkrioctl: entering with dev = %x, cmd = %lx\n", dev, cmd);
497: #endif /* SPKRDEBUG */
498:
499: if (minor(dev) != 0)
500: return (ENXIO);
501:
502: switch (cmd) {
503: case SPKRTONE:
504: tp = (tone_t *)data;
505:
506: if (tp->frequency == 0)
507: rest(tp->duration);
508: else
509: tone(tp->frequency, tp->duration);
510: break;
511: case SPKRTUNE:
512: tp = (tone_t *)(*(caddr_t *)data);
513:
514: for (; ; tp++) {
515: error = copyin(tp, &ttp, sizeof(tone_t));
516: if (error)
517: return (error);
518: if (ttp.duration == 0)
519: break;
520: if (ttp.frequency == 0)
521: rest(ttp.duration);
522: else
523: tone(ttp.frequency, ttp.duration);
524: }
525: break;
526: default:
527: return (ENOTTY);
528: }
529:
530: return (0);
531: }