1 /*-
2 * spkr.c -- device driver for console speaker
3 *
4 * v1.4 by Eric S. Raymond ([email protected]) Aug 1993
5 * modified for FreeBSD by Andrew A. Chernov <[email protected]>
6 * modified for PC98 by Kakefuda
7 */
8
9 #include <sys/cdefs.h>
10 __FBSDID("$FreeBSD$");
11
12 #include <sys/param.h>
13 #include <sys/systm.h>
14 #include <sys/kernel.h>
15 #include <sys/module.h>
16 #include <sys/uio.h>
17 #include <sys/conf.h>
18 #include <sys/ctype.h>
19 #include <sys/malloc.h>
20 #include <machine/clock.h>
21 #include <dev/speaker/speaker.h>
22
23 static d_open_t spkropen;
24 static d_close_t spkrclose;
25 static d_write_t spkrwrite;
26 static d_ioctl_t spkrioctl;
27
28 static struct cdevsw spkr_cdevsw = {
29 .d_version = D_VERSION,
30 .d_flags = D_NEEDGIANT,
31 .d_open = spkropen,
32 .d_close = spkrclose,
33 .d_write = spkrwrite,
34 .d_ioctl = spkrioctl,
35 .d_name = "spkr",
36 };
37
38 static MALLOC_DEFINE(M_SPKR, "spkr", "Speaker buffer");
39
40 /*
41 **************** MACHINE DEPENDENT PART STARTS HERE *************************
42 * This section defines a function tone() which causes a tone of given
43 * frequency and duration from the ISA console speaker.
44 * Another function endtone() is defined to force sound off, and there is
45 * also a rest() entry point to do pauses.
46 *
47 * Audible sound is generated using the Programmable Interval Timer (PIT) and
48 * Programmable Peripheral Interface (PPI) attached to the ISA speaker. The
49 * PPI controls whether sound is passed through at all; the PIT's channel 2 is
50 * used to generate clicks (a square wave) of whatever frequency is desired.
51 */
52
53 #define SPKRPRI PSOCK
54 static char endtone, endrest;
55
56 static void tone(unsigned int thz, unsigned int centisecs);
57 static void rest(int centisecs);
58 static void playinit(void);
59 static void playtone(int pitch, int value, int sustain);
60 static void playstring(char *cp, size_t slen);
61
62 /*
63 * Emit tone of frequency thz for given number of centisecs
64 */
65 static void
tone(unsigned int thz,unsigned int centisecs)66 tone(unsigned int thz, unsigned int centisecs)
67 {
68 int sps, timo;
69
70 if (thz <= 0)
71 return;
72
73 #ifdef DEBUG
74 (void) printf("tone: thz=%d centisecs=%d\n", thz, centisecs);
75 #endif /* DEBUG */
76
77 /* set timer to generate clicks at given frequency in Hertz */
78 sps = splclock();
79
80 if (timer_spkr_acquire()) {
81 /* enter list of waiting procs ??? */
82 splx(sps);
83 return;
84 }
85 splx(sps);
86 disable_intr();
87 timer_spkr_setfreq(thz);
88 enable_intr();
89
90 /*
91 * Set timeout to endtone function, then give up the timeslice.
92 * This is so other processes can execute while the tone is being
93 * emitted.
94 */
95 timo = centisecs * hz / 100;
96 if (timo > 0)
97 tsleep(&endtone, SPKRPRI | PCATCH, "spkrtn", timo);
98 sps = splclock();
99 timer_spkr_release();
100 splx(sps);
101 }
102
103 /*
104 * Rest for given number of centisecs
105 */
106 static void
rest(int centisecs)107 rest(int centisecs)
108 {
109 int timo;
110
111 /*
112 * Set timeout to endrest function, then give up the timeslice.
113 * This is so other processes can execute while the rest is being
114 * waited out.
115 */
116 #ifdef DEBUG
117 (void) printf("rest: %d\n", centisecs);
118 #endif /* DEBUG */
119 timo = centisecs * hz / 100;
120 if (timo > 0)
121 tsleep(&endrest, SPKRPRI | PCATCH, "spkrrs", timo);
122 }
123
124 /*
125 **************** PLAY STRING INTERPRETER BEGINS HERE **********************
126 * Play string interpretation is modelled on IBM BASIC 2.0's PLAY statement;
127 * M[LNS] are missing; the ~ synonym and the _ slur mark and the octave-
128 * tracking facility are added.
129 * Requires tone(), rest(), and endtone(). String play is not interruptible
130 * except possibly at physical block boundaries.
131 */
132
133 #ifndef __bool_true_false_are_defined
134 typedef int bool;
135 #endif
136 #define TRUE 1
137 #define FALSE 0
138
139 #define dtoi(c) ((c) - '0')
140
141 static int octave; /* currently selected octave */
142 static int whole; /* whole-note time at current tempo, in ticks */
143 static int value; /* whole divisor for note time, quarter note = 1 */
144 static int fill; /* controls spacing of notes */
145 static bool octtrack; /* octave-tracking on? */
146 static bool octprefix; /* override current octave-tracking state? */
147
148 /*
149 * Magic number avoidance...
150 */
151 #define SECS_PER_MIN 60 /* seconds per minute */
152 #define WHOLE_NOTE 4 /* quarter notes per whole note */
153 #define MIN_VALUE 64 /* the most we can divide a note by */
154 #define DFLT_VALUE 4 /* default value (quarter-note) */
155 #define FILLTIME 8 /* for articulation, break note in parts */
156 #define STACCATO 6 /* 6/8 = 3/4 of note is filled */
157 #define NORMAL 7 /* 7/8ths of note interval is filled */
158 #define LEGATO 8 /* all of note interval is filled */
159 #define DFLT_OCTAVE 4 /* default octave */
160 #define MIN_TEMPO 32 /* minimum tempo */
161 #define DFLT_TEMPO 120 /* default tempo */
162 #define MAX_TEMPO 255 /* max tempo */
163 #define NUM_MULT 3 /* numerator of dot multiplier */
164 #define DENOM_MULT 2 /* denominator of dot multiplier */
165
166 /* letter to half-tone: A B C D E F G */
167 static int notetab[8] = {9, 11, 0, 2, 4, 5, 7};
168
169 /*
170 * This is the American Standard A440 Equal-Tempered scale with frequencies
171 * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook...
172 * our octave 0 is standard octave 2.
173 */
174 #define OCTAVE_NOTES 12 /* semitones per octave */
175 static int pitchtab[] =
176 {
177 /* C C# D D# E F F# G G# A A# B*/
178 /* 0 */ 65, 69, 73, 78, 82, 87, 93, 98, 103, 110, 117, 123,
179 /* 1 */ 131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247,
180 /* 2 */ 262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494,
181 /* 3 */ 523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988,
182 /* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975,
183 /* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
184 /* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902,
185 };
186
187 static void
playinit()188 playinit()
189 {
190 octave = DFLT_OCTAVE;
191 whole = (100 * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO;
192 fill = NORMAL;
193 value = DFLT_VALUE;
194 octtrack = FALSE;
195 octprefix = TRUE; /* act as though there was an initial O(n) */
196 }
197
198 /*
199 * Play tone of proper duration for current rhythm signature
200 */
201 static void
playtone(int pitch,int value,int sustain)202 playtone(int pitch, int value, int sustain)
203 {
204 int sound, silence, snum = 1, sdenom = 1;
205
206 /* this weirdness avoids floating-point arithmetic */
207 for (; sustain; sustain--) {
208 /* See the BUGS section in the man page for discussion */
209 snum *= NUM_MULT;
210 sdenom *= DENOM_MULT;
211 }
212
213 if (value == 0 || sdenom == 0)
214 return;
215
216 if (pitch == -1)
217 rest(whole * snum / (value * sdenom));
218 else {
219 sound = (whole * snum) / (value * sdenom)
220 - (whole * (FILLTIME - fill)) / (value * FILLTIME);
221 silence = whole * (FILLTIME-fill) * snum / (FILLTIME * value * sdenom);
222
223 #ifdef DEBUG
224 (void) printf("playtone: pitch %d for %d ticks, rest for %d ticks\n",
225 pitch, sound, silence);
226 #endif /* DEBUG */
227
228 tone(pitchtab[pitch], sound);
229 if (fill != LEGATO)
230 rest(silence);
231 }
232 }
233
234 /*
235 * Interpret and play an item from a notation string
236 */
237 static void
playstring(char * cp,size_t slen)238 playstring(char *cp, size_t slen)
239 {
240 int pitch, oldfill, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;
241
242 #define GETNUM(cp, v) for(v=0; isdigit(cp[1]) && slen > 0; ) \
243 {v = v * 10 + (*++cp - '0'); slen--;}
244 for (; slen--; cp++) {
245 int sustain, timeval, tempo;
246 char c = toupper(*cp);
247
248 #ifdef DEBUG
249 (void) printf("playstring: %c (%x)\n", c, c);
250 #endif /* DEBUG */
251
252 switch (c) {
253 case 'A':
254 case 'B':
255 case 'C':
256 case 'D':
257 case 'E':
258 case 'F':
259 case 'G':
260 /* compute pitch */
261 pitch = notetab[c - 'A'] + octave * OCTAVE_NOTES;
262
263 /* this may be followed by an accidental sign */
264 if (cp[1] == '#' || cp[1] == '+') {
265 ++pitch;
266 ++cp;
267 slen--;
268 } else if (cp[1] == '-') {
269 --pitch;
270 ++cp;
271 slen--;
272 }
273
274 /*
275 * If octave-tracking mode is on, and there has been no octave-
276 * setting prefix, find the version of the current letter note
277 * closest to the last regardless of octave.
278 */
279 if (octtrack && !octprefix) {
280 if (abs(pitch-lastpitch) > abs(pitch+OCTAVE_NOTES -
281 lastpitch)) {
282 ++octave;
283 pitch += OCTAVE_NOTES;
284 }
285
286 if (abs(pitch-lastpitch) > abs((pitch-OCTAVE_NOTES) -
287 lastpitch)) {
288 --octave;
289 pitch -= OCTAVE_NOTES;
290 }
291 }
292 octprefix = FALSE;
293 lastpitch = pitch;
294
295 /* ...which may in turn be followed by an override time value */
296 GETNUM(cp, timeval);
297 if (timeval <= 0 || timeval > MIN_VALUE)
298 timeval = value;
299
300 /* ...and/or sustain dots */
301 for (sustain = 0; cp[1] == '.'; cp++) {
302 slen--;
303 sustain++;
304 }
305
306 /* ...and/or a slur mark */
307 oldfill = fill;
308 if (cp[1] == '_') {
309 fill = LEGATO;
310 ++cp;
311 slen--;
312 }
313
314 /* time to emit the actual tone */
315 playtone(pitch, timeval, sustain);
316
317 fill = oldfill;
318 break;
319 case 'O':
320 if (cp[1] == 'N' || cp[1] == 'n') {
321 octprefix = octtrack = FALSE;
322 ++cp;
323 slen--;
324 } else if (cp[1] == 'L' || cp[1] == 'l') {
325 octtrack = TRUE;
326 ++cp;
327 slen--;
328 } else {
329 GETNUM(cp, octave);
330 if (octave >= nitems(pitchtab) / OCTAVE_NOTES)
331 octave = DFLT_OCTAVE;
332 octprefix = TRUE;
333 }
334 break;
335 case '>':
336 if (octave < nitems(pitchtab) / OCTAVE_NOTES - 1)
337 octave++;
338 octprefix = TRUE;
339 break;
340 case '<':
341 if (octave > 0)
342 octave--;
343 octprefix = TRUE;
344 break;
345 case 'N':
346 GETNUM(cp, pitch);
347 for (sustain = 0; cp[1] == '.'; cp++) {
348 slen--;
349 sustain++;
350 }
351 oldfill = fill;
352 if (cp[1] == '_') {
353 fill = LEGATO;
354 ++cp;
355 slen--;
356 }
357 playtone(pitch - 1, value, sustain);
358 fill = oldfill;
359 break;
360 case 'L':
361 GETNUM(cp, value);
362 if (value <= 0 || value > MIN_VALUE)
363 value = DFLT_VALUE;
364 break;
365 case 'P':
366 case '~':
367 /* this may be followed by an override time value */
368 GETNUM(cp, timeval);
369 if (timeval <= 0 || timeval > MIN_VALUE)
370 timeval = value;
371 for (sustain = 0; cp[1] == '.'; cp++) {
372 slen--;
373 sustain++;
374 }
375 playtone(-1, timeval, sustain);
376 break;
377 case 'T':
378 GETNUM(cp, tempo);
379 if (tempo < MIN_TEMPO || tempo > MAX_TEMPO)
380 tempo = DFLT_TEMPO;
381 whole = (100 * SECS_PER_MIN * WHOLE_NOTE) / tempo;
382 break;
383 case 'M':
384 if (cp[1] == 'N' || cp[1] == 'n') {
385 fill = NORMAL;
386 ++cp;
387 slen--;
388 } else if (cp[1] == 'L' || cp[1] == 'l') {
389 fill = LEGATO;
390 ++cp;
391 slen--;
392 } else if (cp[1] == 'S' || cp[1] == 's') {
393 fill = STACCATO;
394 ++cp;
395 slen--;
396 }
397 break;
398 }
399 }
400 }
401
402 /*
403 * ****************** UNIX DRIVER HOOKS BEGIN HERE **************************
404 * This section implements driver hooks to run playstring() and the tone(),
405 * endtone(), and rest() functions defined above.
406 */
407
408 static int spkr_active = FALSE; /* exclusion flag */
409 static char *spkr_inbuf; /* incoming buf */
410
411 static int
spkropen(dev,flags,fmt,td)412 spkropen(dev, flags, fmt, td)
413 struct cdev *dev;
414 int flags;
415 int fmt;
416 struct thread *td;
417 {
418 #ifdef DEBUG
419 (void) printf("spkropen: entering with dev = %s\n", devtoname(dev));
420 #endif /* DEBUG */
421
422 if (spkr_active)
423 return(EBUSY);
424 else {
425 #ifdef DEBUG
426 (void) printf("spkropen: about to perform play initialization\n");
427 #endif /* DEBUG */
428 playinit();
429 spkr_inbuf = malloc(DEV_BSIZE, M_SPKR, M_WAITOK);
430 spkr_active = TRUE;
431 return(0);
432 }
433 }
434
435 static int
spkrwrite(dev,uio,ioflag)436 spkrwrite(dev, uio, ioflag)
437 struct cdev *dev;
438 struct uio *uio;
439 int ioflag;
440 {
441 #ifdef DEBUG
442 printf("spkrwrite: entering with dev = %s, count = %zd\n",
443 devtoname(dev), uio->uio_resid);
444 #endif /* DEBUG */
445
446 if (uio->uio_resid > (DEV_BSIZE - 1)) /* prevent system crashes */
447 return(E2BIG);
448 else {
449 unsigned n;
450 char *cp;
451 int error;
452
453 n = uio->uio_resid;
454 cp = spkr_inbuf;
455 error = uiomove(cp, n, uio);
456 if (!error) {
457 cp[n] = '\0';
458 playstring(cp, n);
459 }
460 return(error);
461 }
462 }
463
464 static int
spkrclose(dev,flags,fmt,td)465 spkrclose(dev, flags, fmt, td)
466 struct cdev *dev;
467 int flags;
468 int fmt;
469 struct thread *td;
470 {
471 #ifdef DEBUG
472 (void) printf("spkrclose: entering with dev = %s\n", devtoname(dev));
473 #endif /* DEBUG */
474
475 wakeup(&endtone);
476 wakeup(&endrest);
477 free(spkr_inbuf, M_SPKR);
478 spkr_active = FALSE;
479 return(0);
480 }
481
482 static int
spkrioctl(dev,cmd,cmdarg,flags,td)483 spkrioctl(dev, cmd, cmdarg, flags, td)
484 struct cdev *dev;
485 unsigned long cmd;
486 caddr_t cmdarg;
487 int flags;
488 struct thread *td;
489 {
490 #ifdef DEBUG
491 (void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n",
492 devtoname(dev), cmd);
493 #endif /* DEBUG */
494
495 if (cmd == SPKRTONE) {
496 tone_t *tp = (tone_t *)cmdarg;
497
498 if (tp->frequency == 0)
499 rest(tp->duration);
500 else
501 tone(tp->frequency, tp->duration);
502 return 0;
503 } else if (cmd == SPKRTUNE) {
504 tone_t *tp = (tone_t *)(*(caddr_t *)cmdarg);
505 tone_t ttp;
506 int error;
507
508 for (; ; tp++) {
509 error = copyin(tp, &ttp, sizeof(tone_t));
510 if (error)
511 return(error);
512
513 if (ttp.duration == 0)
514 break;
515
516 if (ttp.frequency == 0)
517 rest(ttp.duration);
518 else
519 tone(ttp.frequency, ttp.duration);
520 }
521 return(0);
522 }
523 return(EINVAL);
524 }
525
526 static struct cdev *speaker_dev;
527
528 /*
529 * Module handling
530 */
531 static int
speaker_modevent(module_t mod,int type,void * data)532 speaker_modevent(module_t mod, int type, void *data)
533 {
534 int error = 0;
535
536 switch(type) {
537 case MOD_LOAD:
538 speaker_dev = make_dev(&spkr_cdevsw, 0,
539 UID_ROOT, GID_WHEEL, 0600, "speaker");
540 break;
541 case MOD_SHUTDOWN:
542 case MOD_UNLOAD:
543 destroy_dev(speaker_dev);
544 break;
545 default:
546 error = EOPNOTSUPP;
547 }
548 return (error);
549 }
550
551 DEV_MODULE(speaker, speaker_modevent, NULL);
552