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