/* $NetBSD: spkr.c,v 1.25 2023/03/31 15:00:26 riastradh Exp $ */ /* * Copyright (c) 1990 Eric S. Raymond (esr@snark.thyrsus.com) * Copyright (c) 1990 Andrew A. Chernov (ache@astral.msk.su) * Copyright (c) 1990 Lennart Augustsson (lennart@augustsson.net) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Eric S. Raymond * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * spkr.c -- device driver for console speaker on 80386 * * v1.1 by Eric S. Raymond (esr@snark.thyrsus.com) Feb 1990 * modified for 386bsd by Andrew A. Chernov * 386bsd only clean version, all SYSV stuff removed * use hz value from param.c */ #include __KERNEL_RCSID(0, "$NetBSD: spkr.c,v 1.25 2023/03/31 15:00:26 riastradh Exp $"); #if defined(_KERNEL_OPT) #include "wsmux.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ioconf.h" dev_type_open(spkropen); dev_type_close(spkrclose); dev_type_write(spkrwrite); dev_type_ioctl(spkrioctl); const struct cdevsw spkr_cdevsw = { .d_open = spkropen, .d_close = spkrclose, .d_read = noread, .d_write = spkrwrite, .d_ioctl = spkrioctl, .d_stop = nostop, .d_tty = notty, .d_poll = nopoll, .d_mmap = nommap, .d_kqfilter = nokqfilter, .d_discard = nodiscard, .d_flag = D_OTHER }; static void playinit(struct spkr_softc *); static void playtone(struct spkr_softc *, int, int, int); static void playstring(struct spkr_softc *, const char *, size_t); /**************** PLAY STRING INTERPRETER BEGINS HERE ********************** * * Play string interpretation is modelled on IBM BASIC 2.0's PLAY statement; * M[LNS] are missing and the ~ synonym and octave-tracking facility is added. * String play is not interruptible except possibly at physical block * boundaries. */ /* * Magic number avoidance... */ #define SECS_PER_MIN 60 /* seconds per minute */ #define WHOLE_NOTE 4 /* quarter notes per whole note */ #define MIN_VALUE 64 /* the most we can divide a note by */ #define DFLT_VALUE 4 /* default value (quarter-note) */ #define FILLTIME 8 /* for articulation, break note in parts */ #define STACCATO 6 /* 6/8 = 3/4 of note is filled */ #define NORMAL 7 /* 7/8ths of note interval is filled */ #define LEGATO 8 /* all of note interval is filled */ #define DFLT_OCTAVE 4 /* default octave */ #define MIN_TEMPO 32 /* minimum tempo */ #define DFLT_TEMPO 120 /* default tempo */ #define MAX_TEMPO 255 /* max tempo */ #define NUM_MULT 3 /* numerator of dot multiplier */ #define DENOM_MULT 2 /* denominator of dot multiplier */ /* letter to half-tone: A B C D E F G */ static const int notetab[8] = { 9, 11, 0, 2, 4, 5, 7 }; /* * This is the American Standard A440 Equal-Tempered scale with frequencies * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook... * our octave 0 is standard octave 2. */ #define OCTAVE_NOTES 12 /* semitones per octave */ static const int pitchtab[] = { /* C C# D D# E F F# G G# A A# B*/ /* 0 */ 65, 69, 73, 78, 82, 87, 93, 98, 103, 110, 117, 123, /* 1 */ 131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247, /* 2 */ 262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494, /* 3 */ 523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988, /* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975, /* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951, /* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902, }; #define NOCTAVES (int)(__arraycount(pitchtab) / OCTAVE_NOTES) static void playinit(struct spkr_softc *sc) { sc->sc_octave = DFLT_OCTAVE; sc->sc_whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO; sc->sc_fill = NORMAL; sc->sc_value = DFLT_VALUE; sc->sc_octtrack = false; sc->sc_octprefix = true;/* act as though there was an initial O(n) */ } #define SPKRPRI (PZERO - 1) /* Rest for given number of ticks */ static void rest(struct spkr_softc *sc, int ticks) { #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: rest for %d ticks\n", __func__, ticks); #endif /* SPKRDEBUG */ KASSERT(ticks > 0); tsleep(sc->sc_dev, SPKRPRI | PCATCH, device_xname(sc->sc_dev), ticks); } /* * Play tone of proper duration for current rhythm signature. * note indicates "O0C" = 0, "O0C#" = 1, "O0D" = 2, ... , and * -1 indiacates a rest. * val indicates the length, "L4" = 4, "L8" = 8. * sustain indicates the number of subsequent dots that extend the sound * by one a half. */ static void playtone(struct spkr_softc *sc, int note, int val, int sustain) { int whole; int total; int sound; int silence; /* this weirdness avoids floating-point arithmetic */ whole = sc->sc_whole; for (; sustain; sustain--) { whole *= NUM_MULT; val *= DENOM_MULT; } /* Total length in tick */ total = whole / val; if (note == -1) { #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: rest for %d ticks\n", __func__, total); #endif /* SPKRDEBUG */ if (total != 0) rest(sc, total); return; } KASSERTMSG(note < __arraycount(pitchtab), "note=%d", note); /* * Rest 1/8 (if NORMAL) or 3/8 (if STACCATO) in tick. * silence should be rounded down. */ silence = total * (FILLTIME - sc->sc_fill) / FILLTIME; sound = total - silence; #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: note %d for %d ticks, rest for %d ticks\n", __func__, note, sound, silence); #endif /* SPKRDEBUG */ if (sound != 0) (*sc->sc_tone)(sc->sc_dev, pitchtab[note], sound); if (silence != 0) rest(sc, silence); } /* interpret and play an item from a notation string */ static void playstring(struct spkr_softc *sc, const char *cp, size_t slen) { int pitch; int lastpitch = OCTAVE_NOTES * DFLT_OCTAVE; #define GETNUM(cp, v) \ for (v = 0; slen > 0 && isdigit((unsigned char)cp[1]); ) { \ if (v > INT_MAX/10 - (cp[1] - '0')) { \ v = INT_MAX; \ continue; \ } \ v = v * 10 + (*++cp - '0'); \ slen--; \ } for (; slen--; cp++) { int sustain, timeval, tempo; char c = toupper((unsigned char)*cp); #ifdef SPKRDEBUG if (0x20 <= c && c < 0x7f) { device_printf(sc->sc_dev, "%s: '%c'\n", __func__, c); } else { device_printf(sc->sc_dev, "%s: (0x%x)\n", __func__, c); } #endif /* SPKRDEBUG */ switch (c) { case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': /* compute pitch */ pitch = notetab[c - 'A'] + sc->sc_octave * OCTAVE_NOTES; /* this may be followed by an accidental sign */ if (slen > 0 && (cp[1] == '#' || cp[1] == '+')) { ++pitch; ++cp; slen--; } else if (slen > 0 && cp[1] == '-') { --pitch; ++cp; slen--; } /* * If octave-tracking mode is on, and there has been no * octave- setting prefix, find the version of the * current letter note * closest to the last * regardless of octave. */ if (sc->sc_octtrack && !sc->sc_octprefix) { int d = abs(pitch - lastpitch); if (d > abs(pitch + OCTAVE_NOTES - lastpitch)) { if (sc->sc_octave < NOCTAVES - 1) { ++sc->sc_octave; pitch += OCTAVE_NOTES; } } if (d > abs(pitch - OCTAVE_NOTES - lastpitch)) { if (sc->sc_octave > 0) { --sc->sc_octave; pitch -= OCTAVE_NOTES; } } } sc->sc_octprefix = false; lastpitch = pitch; /* * ...which may in turn be followed by an override * time value */ GETNUM(cp, timeval); if (timeval <= 0 || timeval > MIN_VALUE) timeval = sc->sc_value; /* ...and/or sustain dots */ for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) { slen--; sustain++; } /* time to emit the actual tone */ playtone(sc, pitch, timeval, sustain); break; case 'O': if (slen > 0 && (cp[1] == 'N' || cp[1] == 'n')) { sc->sc_octprefix = sc->sc_octtrack = false; ++cp; slen--; } else if (slen > 0 && (cp[1] == 'L' || cp[1] == 'l')) { sc->sc_octtrack = true; ++cp; slen--; } else { GETNUM(cp, sc->sc_octave); KASSERTMSG(sc->sc_octave >= 0, "%d", sc->sc_octave); if (sc->sc_octave >= NOCTAVES) sc->sc_octave = DFLT_OCTAVE; sc->sc_octprefix = true; } break; case '>': if (sc->sc_octave < NOCTAVES - 1) sc->sc_octave++; sc->sc_octprefix = true; break; case '<': if (sc->sc_octave > 0) sc->sc_octave--; sc->sc_octprefix = true; break; case 'N': GETNUM(cp, pitch); KASSERTMSG(pitch >= 0, "pitch=%d", pitch); if (pitch >= __arraycount(pitchtab)) break; for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) { slen--; sustain++; } playtone(sc, pitch - 1, sc->sc_value, sustain); break; case 'L': GETNUM(cp, sc->sc_value); if (sc->sc_value <= 0 || sc->sc_value > MIN_VALUE) sc->sc_value = DFLT_VALUE; break; case 'P': case '~': /* this may be followed by an override time value */ GETNUM(cp, timeval); if (timeval <= 0 || timeval > MIN_VALUE) timeval = sc->sc_value; for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) { slen--; sustain++; } playtone(sc, -1, timeval, sustain); break; case 'T': GETNUM(cp, tempo); if (tempo < MIN_TEMPO || tempo > MAX_TEMPO) tempo = DFLT_TEMPO; sc->sc_whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / tempo; break; case 'M': if (slen > 0 && (cp[1] == 'N' || cp[1] == 'n')) { sc->sc_fill = NORMAL; ++cp; slen--; } else if (slen > 0 && (cp[1] == 'L' || cp[1] == 'l')) { sc->sc_fill = LEGATO; ++cp; slen--; } else if (slen > 0 && (cp[1] == 'S' || cp[1] == 's')) { sc->sc_fill = STACCATO; ++cp; slen--; } break; } } } /******************* UNIX DRIVER HOOKS BEGIN HERE **************************/ #define spkrenter(d) device_lookup_private(&spkr_cd, d) /* * Attaches spkr. Specify tone function with the following specification: * * void * tone(device_t self, u_int pitch, u_int tick) * plays a beep with specified parameters. * The argument 'pitch' specifies the pitch of a beep in Hz. The argument * 'tick' specifies the period of a beep in tick(9). This function waits * to finish playing the beep and then halts it. * If the pitch is zero, it halts all sound if any (for compatibility * with the past confused specifications, but there should be no sound at * this point). And it returns immediately, without waiting ticks. So * you cannot use this as a rest. * If the tick is zero, it returns immediately. */ void spkr_attach(device_t self, void (*tone)(device_t, u_int, u_int)) { struct spkr_softc *sc = device_private(self); #ifdef SPKRDEBUG aprint_debug("%s: entering for unit %d\n", __func__, device_unit(self)); #endif /* SPKRDEBUG */ sc->sc_dev = self; sc->sc_tone = tone; sc->sc_inbuf = NULL; sc->sc_wsbelldev = NULL; spkr_rescan(self, NULL, NULL); } int spkr_detach(device_t self, int flags) { struct spkr_softc *sc = device_private(self); int rc; #ifdef SPKRDEBUG aprint_debug("%s: entering for unit %d\n", __func__, device_unit(self)); #endif /* SPKRDEBUG */ if (sc == NULL) return ENXIO; /* XXXNS If speaker never closes, we cannot complete the detach. */ while ((flags & DETACH_FORCE) != 0 && sc->sc_inbuf != NULL) kpause("spkrwait", TRUE, 1, NULL); if (sc->sc_inbuf != NULL) return EBUSY; rc = config_detach_children(self, flags); return rc; } /* ARGSUSED */ int spkr_rescan(device_t self, const char *iattr, const int *locators) { #if NWSMUX > 0 struct spkr_softc *sc = device_private(self); struct wsbelldev_attach_args a; if (sc->sc_wsbelldev == NULL) { a.accesscookie = sc; sc->sc_wsbelldev = config_found(self, &a, wsbelldevprint, CFARGS_NONE); } #endif return 0; } int spkr_childdet(device_t self, device_t child) { struct spkr_softc *sc = device_private(self); if (sc->sc_wsbelldev == child) sc->sc_wsbelldev = NULL; return 0; } int spkropen(dev_t dev, int flags, int mode, struct lwp *l) { struct spkr_softc *sc = spkrenter(minor(dev)); #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: entering\n", __func__); #endif /* SPKRDEBUG */ if (sc == NULL) return ENXIO; if (sc->sc_inbuf != NULL) return EBUSY; sc->sc_inbuf = kmem_alloc(DEV_BSIZE, KM_SLEEP); playinit(sc); return 0; } int spkrwrite(dev_t dev, struct uio *uio, int flags) { struct spkr_softc *sc = spkrenter(minor(dev)); #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: entering with length = %zu\n", __func__, uio->uio_resid); #endif /* SPKRDEBUG */ if (sc == NULL) return ENXIO; if (sc->sc_inbuf == NULL) return EINVAL; size_t n = uimin(DEV_BSIZE, uio->uio_resid); int error = uiomove(sc->sc_inbuf, n, uio); if (error) return error; playstring(sc, sc->sc_inbuf, n); return 0; } int spkrclose(dev_t dev, int flags, int mode, struct lwp *l) { struct spkr_softc *sc = spkrenter(minor(dev)); #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: entering\n", __func__); #endif /* SPKRDEBUG */ if (sc == NULL) return ENXIO; if (sc->sc_inbuf == NULL) return EINVAL; sc->sc_tone(sc->sc_dev, 0, 0); kmem_free(sc->sc_inbuf, DEV_BSIZE); sc->sc_inbuf = NULL; return 0; } /* * Play tone specified by tp. * tp->frequency is the frequency (0 means a rest). * tp->duration is the length in tick (returns immediately if 0). */ static void playonetone(struct spkr_softc *sc, tone_t *tp) { if (tp->duration <= 0) return; if (tp->frequency == 0) rest(sc, tp->duration); else (*sc->sc_tone)(sc->sc_dev, tp->frequency, tp->duration); } int spkrioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) { struct spkr_softc *sc = spkrenter(minor(dev)); tone_t *tp; tone_t ttp; int error; #ifdef SPKRDEBUG device_printf(sc->sc_dev, "%s: entering with cmd = %lx\n", __func__, cmd); #endif /* SPKRDEBUG */ if (sc == NULL) return ENXIO; if (sc->sc_inbuf == NULL) return EINVAL; switch (cmd) { case SPKRTONE: playonetone(sc, data); return 0; case SPKRTUNE: for (tp = *(void **)data;; tp++) { error = copyin(tp, &ttp, sizeof(tone_t)); if (error) return(error); if (ttp.duration == 0) break; playonetone(sc, &ttp); } return 0; case SPKRGETVOL: if (data != NULL) *(u_int *)data = sc->sc_vol; return 0; case SPKRSETVOL: if (data != NULL && *(u_int *)data <= 100) sc->sc_vol = *(u_int *)data; return 0; default: return ENOTTY; } } #ifdef _MODULE #include "ioconf.c" #endif MODULE(MODULE_CLASS_DRIVER, spkr, "audio" /* and/or pcppi */ ); int spkr_modcmd(modcmd_t cmd, void *arg) { int error = 0; #ifdef _MODULE devmajor_t bmajor, cmajor; #endif switch(cmd) { case MODULE_CMD_INIT: #ifdef _MODULE bmajor = cmajor = -1; error = devsw_attach(spkr_cd.cd_name, NULL, &bmajor, &spkr_cdevsw, &cmajor); if (error) break; error = config_init_component(cfdriver_ioconf_spkr, cfattach_ioconf_spkr, cfdata_ioconf_spkr); if (error) { devsw_detach(NULL, &spkr_cdevsw); } #endif break; case MODULE_CMD_FINI: #ifdef _MODULE error = config_fini_component(cfdriver_ioconf_spkr, cfattach_ioconf_spkr, cfdata_ioconf_spkr); if (error == 0) devsw_detach(NULL, &spkr_cdevsw); #endif break; default: error = ENOTTY; break; } return error; }