spkr.c revision 179004 
1/*-
2 * spkr.c -- device driver for console speaker
3 *
4 * v1.4 by Eric S. Raymond (esr@snark.thyrsus.com) Aug 1993
5 * modified for FreeBSD by Andrew A. Chernov <ache@astral.msk.su>
6 * modified for PC98 by Kakefuda
7 */
8
9#include <sys/cdefs.h>
10__FBSDID("$FreeBSD: head/sys/dev/speaker/spkr.c 179004 2008-05-15 01:22:48Z phk $");
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
23static	d_open_t	spkropen;
24static	d_close_t	spkrclose;
25static	d_write_t	spkrwrite;
26static	d_ioctl_t	spkrioctl;
27
28static 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
38static 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
54static char endtone, endrest;
55
56static void tone(unsigned int thz, unsigned int centisecs);
57static void rest(int centisecs);
58static void playinit(void);
59static void playtone(int pitch, int value, int sustain);
60static void playstring(char *cp, size_t slen);
61
62/*
63 * Emit tone of frequency thz for given number of centisecs
64 */
65static void
66tone(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 */
106static void
107rest(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
133typedef int	bool;
134#define TRUE	1
135#define FALSE	0
136
137#define dtoi(c)		((c) - '0')
138
139static int octave;	/* currently selected octave */
140static int whole;	/* whole-note time at current tempo, in ticks */
141static int value;	/* whole divisor for note time, quarter note = 1 */
142static int fill;	/* controls spacing of notes */
143static bool octtrack;	/* octave-tracking on? */
144static bool octprefix;	/* override current octave-tracking state? */
145
146/*
147 * Magic number avoidance...
148 */
149#define SECS_PER_MIN	60	/* seconds per minute */
150#define WHOLE_NOTE	4	/* quarter notes per whole note */
151#define MIN_VALUE	64	/* the most we can divide a note by */
152#define DFLT_VALUE	4	/* default value (quarter-note) */
153#define FILLTIME	8	/* for articulation, break note in parts */
154#define STACCATO	6	/* 6/8 = 3/4 of note is filled */
155#define NORMAL		7	/* 7/8ths of note interval is filled */
156#define LEGATO		8	/* all of note interval is filled */
157#define DFLT_OCTAVE	4	/* default octave */
158#define MIN_TEMPO	32	/* minimum tempo */
159#define DFLT_TEMPO	120	/* default tempo */
160#define MAX_TEMPO	255	/* max tempo */
161#define NUM_MULT	3	/* numerator of dot multiplier */
162#define DENOM_MULT	2	/* denominator of dot multiplier */
163
164/* letter to half-tone:  A   B  C  D  E  F  G */
165static int notetab[8] = {9, 11, 0, 2, 4, 5, 7};
166
167/*
168 * This is the American Standard A440 Equal-Tempered scale with frequencies
169 * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook...
170 * our octave 0 is standard octave 2.
171 */
172#define OCTAVE_NOTES	12	/* semitones per octave */
173static int pitchtab[] =
174{
175/*        C     C#    D     D#    E     F     F#    G     G#    A     A#    B*/
176/* 0 */   65,   69,   73,   78,   82,   87,   93,   98,  103,  110,  117,  123,
177/* 1 */  131,  139,  147,  156,  165,  175,  185,  196,  208,  220,  233,  247,
178/* 2 */  262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494,
179/* 3 */  523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988,
180/* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975,
181/* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
182/* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902,
183};
184
185static void
186playinit()
187{
188    octave = DFLT_OCTAVE;
189    whole = (100 * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO;
190    fill = NORMAL;
191    value = DFLT_VALUE;
192    octtrack = FALSE;
193    octprefix = TRUE;	/* act as though there was an initial O(n) */
194}
195
196/*
197 * Play tone of proper duration for current rhythm signature
198 */
199static void
200playtone(int pitch, int value, int sustain)
201{
202	register int sound, silence, snum = 1, sdenom = 1;
203
204	/* this weirdness avoids floating-point arithmetic */
205	for (; sustain; sustain--) {
206		/* See the BUGS section in the man page for discussion */
207		snum *= NUM_MULT;
208		sdenom *= DENOM_MULT;
209	}
210
211	if (value == 0 || sdenom == 0)
212		return;
213
214	if (pitch == -1)
215		rest(whole * snum / (value * sdenom));
216	else {
217		sound = (whole * snum) / (value * sdenom)
218			- (whole * (FILLTIME - fill)) / (value * FILLTIME);
219		silence = whole * (FILLTIME-fill) * snum / (FILLTIME * value * sdenom);
220
221#ifdef DEBUG
222		(void) printf("playtone: pitch %d for %d ticks, rest for %d ticks\n",
223			pitch, sound, silence);
224#endif /* DEBUG */
225
226		tone(pitchtab[pitch], sound);
227		if (fill != LEGATO)
228			rest(silence);
229	}
230}
231
232/*
233 * Interpret and play an item from a notation string
234 */
235static void
236playstring(char *cp, size_t slen)
237{
238	int pitch, oldfill, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;
239
240#define GETNUM(cp, v)	for(v=0; isdigit(cp[1]) && slen > 0; ) \
241				{v = v * 10 + (*++cp - '0'); slen--;}
242	for (; slen--; cp++) {
243		int sustain, timeval, tempo;
244		register char c = toupper(*cp);
245
246#ifdef DEBUG
247		(void) printf("playstring: %c (%x)\n", c, c);
248#endif /* DEBUG */
249
250		switch (c) {
251		case 'A':
252		case 'B':
253		case 'C':
254		case 'D':
255		case 'E':
256		case 'F':
257		case 'G':
258			/* compute pitch */
259			pitch = notetab[c - 'A'] + octave * OCTAVE_NOTES;
260
261			/* this may be followed by an accidental sign */
262			if (cp[1] == '#' || cp[1] == '+') {
263				++pitch;
264				++cp;
265				slen--;
266			} else if (cp[1] == '-') {
267				--pitch;
268				++cp;
269				slen--;
270			}
271
272			/*
273			 * If octave-tracking mode is on, and there has been no octave-
274			 * setting prefix, find the version of the current letter note
275			 * closest to the last regardless of octave.
276			 */
277			if (octtrack && !octprefix) {
278				if (abs(pitch-lastpitch) > abs(pitch+OCTAVE_NOTES -
279					lastpitch)) {
280					++octave;
281					pitch += OCTAVE_NOTES;
282				}
283
284				if (abs(pitch-lastpitch) > abs((pitch-OCTAVE_NOTES) -
285					lastpitch)) {
286					--octave;
287					pitch -= OCTAVE_NOTES;
288				}
289			}
290			octprefix = FALSE;
291			lastpitch = pitch;
292
293			/* ...which may in turn be followed by an override time value */
294			GETNUM(cp, timeval);
295			if (timeval <= 0 || timeval > MIN_VALUE)
296				timeval = value;
297
298			/* ...and/or sustain dots */
299			for (sustain = 0; cp[1] == '.'; cp++) {
300				slen--;
301				sustain++;
302			}
303
304			/* ...and/or a slur mark */
305			oldfill = fill;
306			if (cp[1] == '_') {
307				fill = LEGATO;
308				++cp;
309				slen--;
310			}
311
312			/* time to emit the actual tone */
313			playtone(pitch, timeval, sustain);
314
315			fill = oldfill;
316			break;
317		case 'O':
318			if (cp[1] == 'N' || cp[1] == 'n') {
319				octprefix = octtrack = FALSE;
320				++cp;
321				slen--;
322			} else if (cp[1] == 'L' || cp[1] == 'l') {
323				octtrack = TRUE;
324				++cp;
325				slen--;
326			} else {
327				GETNUM(cp, octave);
328				if (octave >= sizeof(pitchtab) / sizeof(pitchtab[0]) /
329					OCTAVE_NOTES)
330					octave = DFLT_OCTAVE;
331				octprefix = TRUE;
332			}
333			break;
334		case '>':
335			if (octave < sizeof(pitchtab) / sizeof(pitchtab[0]) /
336				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
408static int spkr_active = FALSE; /* exclusion flag */
409static char *spkr_inbuf;  /* incoming buf */
410
411static int
412spkropen(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 (minor(dev) != 0)
423		return(ENXIO);
424	else if (spkr_active)
425		return(EBUSY);
426	else {
427#ifdef DEBUG
428		(void) printf("spkropen: about to perform play initialization\n");
429#endif /* DEBUG */
430		playinit();
431		spkr_inbuf = malloc(DEV_BSIZE, M_SPKR, M_WAITOK);
432		spkr_active = TRUE;
433		return(0);
434    	}
435}
436
437static int
438spkrwrite(dev, uio, ioflag)
439	struct cdev *dev;
440	struct uio *uio;
441	int ioflag;
442{
443#ifdef DEBUG
444	printf("spkrwrite: entering with dev = %s, count = %d\n",
445		devtoname(dev), uio->uio_resid);
446#endif /* DEBUG */
447	if (minor(dev) != 0)
448		return(ENXIO);
449	else if (uio->uio_resid > (DEV_BSIZE - 1))     /* prevent system crashes */
450		return(E2BIG);
451	else {
452		unsigned n;
453		char *cp;
454		int error;
455
456		n = uio->uio_resid;
457		cp = spkr_inbuf;
458		error = uiomove(cp, n, uio);
459		if (!error) {
460			cp[n] = '\0';
461			playstring(cp, n);
462		}
463	return(error);
464	}
465}
466
467static int
468spkrclose(dev, flags, fmt, td)
469	struct cdev *dev;
470	int flags;
471	int fmt;
472	struct thread *td;
473{
474#ifdef DEBUG
475	(void) printf("spkrclose: entering with dev = %s\n", devtoname(dev));
476#endif /* DEBUG */
477
478	if (minor(dev) != 0)
479		return(ENXIO);
480	else {
481		wakeup(&endtone);
482		wakeup(&endrest);
483		free(spkr_inbuf, M_SPKR);
484		spkr_active = FALSE;
485		return(0);
486	}
487}
488
489static int
490spkrioctl(dev, cmd, cmdarg, flags, td)
491	struct cdev *dev;
492	unsigned long cmd;
493	caddr_t cmdarg;
494	int flags;
495	struct thread *td;
496{
497#ifdef DEBUG
498	(void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n",
499    		devtoname(dev), cmd);
500#endif /* DEBUG */
501
502	if (minor(dev) != 0)
503		return(ENXIO);
504	else if (cmd == SPKRTONE) {
505		tone_t	*tp = (tone_t *)cmdarg;
506
507		if (tp->frequency == 0)
508			rest(tp->duration);
509		else
510			tone(tp->frequency, tp->duration);
511		return 0;
512	} else if (cmd == SPKRTUNE) {
513		tone_t  *tp = (tone_t *)(*(caddr_t *)cmdarg);
514		tone_t ttp;
515		int error;
516
517		for (; ; tp++) {
518			error = copyin(tp, &ttp, sizeof(tone_t));
519			if (error)
520				return(error);
521
522			if (ttp.duration == 0)
523				break;
524
525			if (ttp.frequency == 0)
526				rest(ttp.duration);
527			else
528				tone(ttp.frequency, ttp.duration);
529		}
530		return(0);
531	}
532	return(EINVAL);
533}
534
535static struct cdev *speaker_dev;
536
537/*
538 * Module handling
539 */
540static int
541speaker_modevent(module_t mod, int type, void *data)
542{
543	int error = 0;
544
545	switch(type) {
546	case MOD_LOAD:
547		speaker_dev = make_dev(&spkr_cdevsw, 0,
548		    UID_ROOT, GID_WHEEL, 0600, "speaker");
549		break;
550	case MOD_SHUTDOWN:
551	case MOD_UNLOAD:
552		destroy_dev(speaker_dev);
553		break;
554	default:
555		error = EOPNOTSUPP;
556	}
557	return (error);
558}
559
560DEV_MODULE(speaker, speaker_modevent, NULL);
561