spkr.c revision 111748 
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 * $FreeBSD: head/sys/dev/speaker/spkr.c 111748 2003-03-02 16:54:40Z des $
9 */
10
11#include <sys/param.h>
12#include <sys/systm.h>
13#include <sys/bus.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 <isa/isavar.h>
21#ifdef PC98
22#include <pc98/pc98/pc98.h>
23#else
24#include <i386/isa/isa.h>
25#endif
26#include <i386/isa/timerreg.h>
27#include <machine/clock.h>
28#include <machine/speaker.h>
29
30static	d_open_t	spkropen;
31static	d_close_t	spkrclose;
32static	d_write_t	spkrwrite;
33static	d_ioctl_t	spkrioctl;
34
35#define CDEV_MAJOR 26
36static struct cdevsw spkr_cdevsw = {
37	/* open */	spkropen,
38	/* close */	spkrclose,
39	/* read */	noread,
40	/* write */	spkrwrite,
41	/* ioctl */	spkrioctl,
42	/* poll */	nopoll,
43	/* mmap */	nommap,
44	/* strategy */	nostrategy,
45	/* name */	"spkr",
46	/* maj */	CDEV_MAJOR,
47	/* dump */	nodump,
48	/* psize */	nopsize,
49	/* flags */	0,
50};
51
52static MALLOC_DEFINE(M_SPKR, "spkr", "Speaker buffer");
53
54/**************** MACHINE DEPENDENT PART STARTS HERE *************************
55 *
56 * This section defines a function tone() which causes a tone of given
57 * frequency and duration from the ISA console speaker.
58 * Another function endtone() is defined to force sound off, and there is
59 * also a rest() entry point to do pauses.
60 *
61 * Audible sound is generated using the Programmable Interval Timer (PIT) and
62 * Programmable Peripheral Interface (PPI) attached to the ISA speaker. The
63 * PPI controls whether sound is passed through at all; the PIT's channel 2 is
64 * used to generate clicks (a square wave) of whatever frequency is desired.
65 */
66
67/*
68 * XXX PPI control values should be in a header and used in clock.c.
69 */
70#ifdef PC98
71#define	PPI_SPKR	0x08	/* turn these PPI bits on to pass sound */
72#define	PIT_COUNT	0x3fdb	/* PIT count address */
73
74#define	SPEAKER_ON	outb(IO_PPI, inb(IO_PPI) & ~PPI_SPKR)
75#define	SPEAKER_OFF	outb(IO_PPI, inb(IO_PPI) | PPI_SPKR)
76#define	TIMER_ACQUIRE	acquire_timer1(TIMER_SEL1 | TIMER_SQWAVE | TIMER_16BIT)
77#define	TIMER_RELEASE	release_timer1()
78#define	SPEAKER_WRITE(val)	{ \
79					outb(PIT_COUNT, (val & 0xff)); \
80					outb(PIT_COUNT, (val >> 8)); \
81				}
82#else
83#define PPI_SPKR	0x03	/* turn these PPI bits on to pass sound */
84
85#define	SPEAKER_ON	outb(IO_PPI, inb(IO_PPI) | PPI_SPKR)
86#define	SPEAKER_OFF	outb(IO_PPI, inb(IO_PPI) & ~PPI_SPKR)
87#define	TIMER_ACQUIRE	acquire_timer2(TIMER_SEL2 | TIMER_SQWAVE | TIMER_16BIT)
88#define	TIMER_RELEASE	release_timer2()
89#define	SPEAKER_WRITE(val)	{ \
90					outb(TIMER_CNTR2, (val & 0xff)); \
91    					outb(TIMER_CNTR2, (val >> 8)); \
92				}
93#endif
94
95#define SPKRPRI PSOCK
96static char endtone, endrest;
97
98static void tone(unsigned int thz, unsigned int ticks);
99static void rest(int ticks);
100static void playinit(void);
101static void playtone(int pitch, int value, int sustain);
102static void playstring(char *cp, size_t slen);
103
104/* emit tone of frequency thz for given number of ticks */
105static void
106tone(thz, ticks)
107	unsigned int thz, ticks;
108{
109    unsigned int divisor;
110    int sps;
111
112    if (thz <= 0)
113	return;
114
115    divisor = timer_freq / thz;
116
117#ifdef DEBUG
118    (void) printf("tone: thz=%d ticks=%d\n", thz, ticks);
119#endif /* DEBUG */
120
121    /* set timer to generate clicks at given frequency in Hertz */
122    sps = splclock();
123
124    if (TIMER_ACQUIRE) {
125	/* enter list of waiting procs ??? */
126	splx(sps);
127	return;
128    }
129    splx(sps);
130    disable_intr();
131    SPEAKER_WRITE(divisor);
132    enable_intr();
133
134    /* turn the speaker on */
135    SPEAKER_ON;
136
137    /*
138     * Set timeout to endtone function, then give up the timeslice.
139     * This is so other processes can execute while the tone is being
140     * emitted.
141     */
142    if (ticks > 0)
143	tsleep(&endtone, SPKRPRI | PCATCH, "spkrtn", ticks);
144    SPEAKER_OFF;
145    sps = splclock();
146    TIMER_RELEASE;
147    splx(sps);
148}
149
150/* rest for given number of ticks */
151static void
152rest(ticks)
153	int	ticks;
154{
155    /*
156     * Set timeout to endrest function, then give up the timeslice.
157     * This is so other processes can execute while the rest is being
158     * waited out.
159     */
160#ifdef DEBUG
161    (void) printf("rest: %d\n", ticks);
162#endif /* DEBUG */
163    if (ticks > 0)
164	tsleep(&endrest, SPKRPRI | PCATCH, "spkrrs", ticks);
165}
166
167/**************** PLAY STRING INTERPRETER BEGINS HERE **********************
168 *
169 * Play string interpretation is modelled on IBM BASIC 2.0's PLAY statement;
170 * M[LNS] are missing; the ~ synonym and the _ slur mark and the octave-
171 * tracking facility are added.
172 * Requires tone(), rest(), and endtone(). String play is not interruptible
173 * except possibly at physical block boundaries.
174 */
175
176typedef int	bool;
177#define TRUE	1
178#define FALSE	0
179
180#define dtoi(c)		((c) - '0')
181
182static int octave;	/* currently selected octave */
183static int whole;	/* whole-note time at current tempo, in ticks */
184static int value;	/* whole divisor for note time, quarter note = 1 */
185static int fill;	/* controls spacing of notes */
186static bool octtrack;	/* octave-tracking on? */
187static bool octprefix;	/* override current octave-tracking state? */
188
189/*
190 * Magic number avoidance...
191 */
192#define SECS_PER_MIN	60	/* seconds per minute */
193#define WHOLE_NOTE	4	/* quarter notes per whole note */
194#define MIN_VALUE	64	/* the most we can divide a note by */
195#define DFLT_VALUE	4	/* default value (quarter-note) */
196#define FILLTIME	8	/* for articulation, break note in parts */
197#define STACCATO	6	/* 6/8 = 3/4 of note is filled */
198#define NORMAL		7	/* 7/8ths of note interval is filled */
199#define LEGATO		8	/* all of note interval is filled */
200#define DFLT_OCTAVE	4	/* default octave */
201#define MIN_TEMPO	32	/* minimum tempo */
202#define DFLT_TEMPO	120	/* default tempo */
203#define MAX_TEMPO	255	/* max tempo */
204#define NUM_MULT	3	/* numerator of dot multiplier */
205#define DENOM_MULT	2	/* denominator of dot multiplier */
206
207/* letter to half-tone:  A   B  C  D  E  F  G */
208static int notetab[8] = {9, 11, 0, 2, 4, 5, 7};
209
210/*
211 * This is the American Standard A440 Equal-Tempered scale with frequencies
212 * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook...
213 * our octave 0 is standard octave 2.
214 */
215#define OCTAVE_NOTES	12	/* semitones per octave */
216static int pitchtab[] =
217{
218/*        C     C#    D     D#    E     F     F#    G     G#    A     A#    B*/
219/* 0 */   65,   69,   73,   78,   82,   87,   93,   98,  103,  110,  117,  123,
220/* 1 */  131,  139,  147,  156,  165,  175,  185,  196,  208,  220,  233,  247,
221/* 2 */  262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494,
222/* 3 */  523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988,
223/* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975,
224/* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
225/* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902,
226};
227
228static void
229playinit()
230{
231    octave = DFLT_OCTAVE;
232    whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO;
233    fill = NORMAL;
234    value = DFLT_VALUE;
235    octtrack = FALSE;
236    octprefix = TRUE;	/* act as though there was an initial O(n) */
237}
238
239/* play tone of proper duration for current rhythm signature */
240static void
241playtone(pitch, value, sustain)
242	int	pitch, value, sustain;
243{
244    register int	sound, silence, snum = 1, sdenom = 1;
245
246    /* this weirdness avoids floating-point arithmetic */
247    for (; sustain; sustain--)
248    {
249	/* See the BUGS section in the man page for discussion */
250	snum *= NUM_MULT;
251	sdenom *= DENOM_MULT;
252    }
253
254    if (value == 0 || sdenom == 0)
255	return;
256
257    if (pitch == -1)
258	rest(whole * snum / (value * sdenom));
259    else
260    {
261	sound = (whole * snum) / (value * sdenom)
262		- (whole * (FILLTIME - fill)) / (value * FILLTIME);
263	silence = whole * (FILLTIME-fill) * snum / (FILLTIME * value * sdenom);
264
265#ifdef DEBUG
266	(void) printf("playtone: pitch %d for %d ticks, rest for %d ticks\n",
267			pitch, sound, silence);
268#endif /* DEBUG */
269
270	tone(pitchtab[pitch], sound);
271	if (fill != LEGATO)
272	    rest(silence);
273    }
274}
275
276/* interpret and play an item from a notation string */
277static void
278playstring(cp, slen)
279	char	*cp;
280	size_t	slen;
281{
282    int		pitch, oldfill, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;
283
284#define GETNUM(cp, v)	for(v=0; isdigit(cp[1]) && slen > 0; ) \
285				{v = v * 10 + (*++cp - '0'); slen--;}
286    for (; slen--; cp++)
287    {
288	int		sustain, timeval, tempo;
289	register char	c = toupper(*cp);
290
291#ifdef DEBUG
292	(void) printf("playstring: %c (%x)\n", c, c);
293#endif /* DEBUG */
294
295	switch (c)
296	{
297	case 'A':  case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
298
299	    /* compute pitch */
300	    pitch = notetab[c - 'A'] + octave * OCTAVE_NOTES;
301
302	    /* this may be followed by an accidental sign */
303	    if (cp[1] == '#' || cp[1] == '+')
304	    {
305		++pitch;
306		++cp;
307		slen--;
308	    }
309	    else if (cp[1] == '-')
310	    {
311		--pitch;
312		++cp;
313		slen--;
314	    }
315
316	    /*
317	     * If octave-tracking mode is on, and there has been no octave-
318	     * setting prefix, find the version of the current letter note
319	     * closest to the last regardless of octave.
320	     */
321	    if (octtrack && !octprefix)
322	    {
323		if (abs(pitch-lastpitch) > abs(pitch+OCTAVE_NOTES-lastpitch))
324		{
325		    ++octave;
326		    pitch += OCTAVE_NOTES;
327		}
328
329		if (abs(pitch-lastpitch) > abs((pitch-OCTAVE_NOTES)-lastpitch))
330		{
331		    --octave;
332		    pitch -= OCTAVE_NOTES;
333		}
334	    }
335	    octprefix = FALSE;
336	    lastpitch = pitch;
337
338	    /* ...which may in turn be followed by an override time value */
339	    GETNUM(cp, timeval);
340	    if (timeval <= 0 || timeval > MIN_VALUE)
341		timeval = value;
342
343	    /* ...and/or sustain dots */
344	    for (sustain = 0; cp[1] == '.'; cp++)
345	    {
346		slen--;
347		sustain++;
348	    }
349
350	    /* ...and/or a slur mark */
351	    oldfill = fill;
352	    if (cp[1] == '_')
353	    {
354		fill = LEGATO;
355		++cp;
356		slen--;
357	    }
358
359	    /* time to emit the actual tone */
360	    playtone(pitch, timeval, sustain);
361
362	    fill = oldfill;
363	    break;
364
365	case 'O':
366	    if (cp[1] == 'N' || cp[1] == 'n')
367	    {
368		octprefix = octtrack = FALSE;
369		++cp;
370		slen--;
371	    }
372	    else if (cp[1] == 'L' || cp[1] == 'l')
373	    {
374		octtrack = TRUE;
375		++cp;
376		slen--;
377	    }
378	    else
379	    {
380		GETNUM(cp, octave);
381		if (octave >= sizeof(pitchtab) / sizeof(pitchtab[0]) / OCTAVE_NOTES)
382		    octave = DFLT_OCTAVE;
383		octprefix = TRUE;
384	    }
385	    break;
386
387	case '>':
388	    if (octave < sizeof(pitchtab) / sizeof(pitchtab[0]) / OCTAVE_NOTES - 1)
389		octave++;
390	    octprefix = TRUE;
391	    break;
392
393	case '<':
394	    if (octave > 0)
395		octave--;
396	    octprefix = TRUE;
397	    break;
398
399	case 'N':
400	    GETNUM(cp, pitch);
401	    for (sustain = 0; cp[1] == '.'; cp++)
402	    {
403		slen--;
404		sustain++;
405	    }
406	    oldfill = fill;
407	    if (cp[1] == '_')
408	    {
409		fill = LEGATO;
410		++cp;
411		slen--;
412	    }
413	    playtone(pitch - 1, value, sustain);
414	    fill = oldfill;
415	    break;
416
417	case 'L':
418	    GETNUM(cp, value);
419	    if (value <= 0 || value > MIN_VALUE)
420		value = DFLT_VALUE;
421	    break;
422
423	case 'P':
424	case '~':
425	    /* this may be followed by an override time value */
426	    GETNUM(cp, timeval);
427	    if (timeval <= 0 || timeval > MIN_VALUE)
428		timeval = value;
429	    for (sustain = 0; cp[1] == '.'; cp++)
430	    {
431		slen--;
432		sustain++;
433	    }
434	    playtone(-1, timeval, sustain);
435	    break;
436
437	case 'T':
438	    GETNUM(cp, tempo);
439	    if (tempo < MIN_TEMPO || tempo > MAX_TEMPO)
440		tempo = DFLT_TEMPO;
441	    whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / tempo;
442	    break;
443
444	case 'M':
445	    if (cp[1] == 'N' || cp[1] == 'n')
446	    {
447		fill = NORMAL;
448		++cp;
449		slen--;
450	    }
451	    else if (cp[1] == 'L' || cp[1] == 'l')
452	    {
453		fill = LEGATO;
454		++cp;
455		slen--;
456	    }
457	    else if (cp[1] == 'S' || cp[1] == 's')
458	    {
459		fill = STACCATO;
460		++cp;
461		slen--;
462	    }
463	    break;
464	}
465    }
466}
467
468/******************* UNIX DRIVER HOOKS BEGIN HERE **************************
469 *
470 * This section implements driver hooks to run playstring() and the tone(),
471 * endtone(), and rest() functions defined above.
472 */
473
474static int spkr_active = FALSE; /* exclusion flag */
475static char *spkr_inbuf;  /* incoming buf */
476
477static int
478spkropen(dev, flags, fmt, td)
479	dev_t		dev;
480	int		flags;
481	int		fmt;
482	struct thread	*td;
483{
484#ifdef DEBUG
485    (void) printf("spkropen: entering with dev = %s\n", devtoname(dev));
486#endif /* DEBUG */
487
488    if (minor(dev) != 0)
489	return(ENXIO);
490    else if (spkr_active)
491	return(EBUSY);
492    else
493    {
494#ifdef DEBUG
495	(void) printf("spkropen: about to perform play initialization\n");
496#endif /* DEBUG */
497	playinit();
498	spkr_inbuf = malloc(DEV_BSIZE, M_SPKR, M_WAITOK);
499	spkr_active = TRUE;
500	return(0);
501    }
502}
503
504static int
505spkrwrite(dev, uio, ioflag)
506	dev_t		dev;
507	struct uio	*uio;
508	int		ioflag;
509{
510#ifdef DEBUG
511    printf("spkrwrite: entering with dev = %s, count = %d\n",
512		devtoname(dev), uio->uio_resid);
513#endif /* DEBUG */
514
515    if (minor(dev) != 0)
516	return(ENXIO);
517    else if (uio->uio_resid > (DEV_BSIZE - 1))     /* prevent system crashes */
518	return(E2BIG);
519    else
520    {
521	unsigned n;
522	char *cp;
523	int error;
524
525	n = uio->uio_resid;
526	cp = spkr_inbuf;
527	error = uiomove(cp, n, uio);
528	if (!error) {
529		cp[n] = '\0';
530		playstring(cp, n);
531	}
532	return(error);
533    }
534}
535
536static int
537spkrclose(dev, flags, fmt, td)
538	dev_t		dev;
539	int		flags;
540	int		fmt;
541	struct thread	*td;
542{
543#ifdef DEBUG
544    (void) printf("spkrclose: entering with dev = %s\n", devtoname(dev));
545#endif /* DEBUG */
546
547    if (minor(dev) != 0)
548	return(ENXIO);
549    else
550    {
551	wakeup(&endtone);
552	wakeup(&endrest);
553	free(spkr_inbuf, M_SPKR);
554	spkr_active = FALSE;
555	return(0);
556    }
557}
558
559static int
560spkrioctl(dev, cmd, cmdarg, flags, td)
561	dev_t		dev;
562	unsigned long	cmd;
563	caddr_t		cmdarg;
564	int		flags;
565	struct thread	*td;
566{
567#ifdef DEBUG
568    (void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n",
569    	devtoname(dev), cmd);
570#endif /* DEBUG */
571
572    if (minor(dev) != 0)
573	return(ENXIO);
574    else if (cmd == SPKRTONE)
575    {
576	tone_t	*tp = (tone_t *)cmdarg;
577
578	if (tp->frequency == 0)
579	    rest(tp->duration);
580	else
581	    tone(tp->frequency, tp->duration);
582	return 0;
583    }
584    else if (cmd == SPKRTUNE)
585    {
586	tone_t  *tp = (tone_t *)(*(caddr_t *)cmdarg);
587	tone_t ttp;
588	int error;
589
590	for (; ; tp++) {
591	    error = copyin(tp, &ttp, sizeof(tone_t));
592	    if (error)
593		    return(error);
594	    if (ttp.duration == 0)
595		    break;
596	    if (ttp.frequency == 0)
597		 rest(ttp.duration);
598	    else
599		 tone(ttp.frequency, ttp.duration);
600	}
601	return(0);
602    }
603    return(EINVAL);
604}
605
606/*
607 * Install placeholder to claim the resources owned by the
608 * AT tone generator.
609 */
610static struct isa_pnp_id speaker_ids[] = {
611#ifndef PC98
612	{ 0x0008d041 /* PNP0800 */, "PC speaker" },
613#endif
614	{ 0 }
615};
616
617static dev_t speaker_dev;
618
619static int
620speaker_probe(device_t dev)
621{
622	int	error;
623
624	error = ISA_PNP_PROBE(device_get_parent(dev), dev, speaker_ids);
625
626	/* PnP match */
627	if (error == 0)
628		return (0);
629
630	/* No match */
631	if (error == ENXIO)
632		return (ENXIO);
633
634	/* Not configured by hints. */
635	if (strncmp(device_get_name(dev), "speaker", 9))
636		return (ENXIO);
637
638	device_set_desc(dev, "PC speaker");
639
640	return (0);
641}
642
643static int
644speaker_attach(device_t dev)
645{
646
647	if (speaker_dev) {
648		device_printf(dev, "Already attached!\n");
649		return (ENXIO);
650	}
651
652	speaker_dev = make_dev(&spkr_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
653	    "speaker");
654	return (0);
655}
656
657static int
658speaker_detach(device_t dev)
659{
660	destroy_dev(speaker_dev);
661	return (0);
662}
663
664static device_method_t speaker_methods[] = {
665	/* Device interface */
666	DEVMETHOD(device_probe,		speaker_probe),
667	DEVMETHOD(device_attach,	speaker_attach),
668	DEVMETHOD(device_detach,	speaker_detach),
669	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
670	DEVMETHOD(device_suspend,	bus_generic_suspend),
671	DEVMETHOD(device_resume,	bus_generic_resume),
672	{ 0, 0 }
673};
674
675static driver_t speaker_driver = {
676	"speaker",
677	speaker_methods,
678	1,		/* no softc */
679};
680
681static devclass_t speaker_devclass;
682
683DRIVER_MODULE(speaker, isa, speaker_driver, speaker_devclass, 0, 0);
684#ifndef PC98
685DRIVER_MODULE(speaker, acpi, speaker_driver, speaker_devclass, 0, 0);
686#endif
687
688/* spkr.c ends here */
689