Annotation of sys/dev/isa/spkr.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: spkr.c,v 1.10 2006/03/09 22:35:23 miod Exp $ */
! 2: /* $NetBSD: spkr.c,v 1.1 1998/04/15 20:26:18 drochner Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1990 Eric S. Raymond (esr@snark.thyrsus.com)
! 6: * Copyright (c) 1990 Andrew A. Chernov (ache@astral.msk.su)
! 7: * Copyright (c) 1990 Lennart Augustsson (lennart@augustsson.net)
! 8: * All rights reserved.
! 9: *
! 10: * Redistribution and use in source and binary forms, with or without
! 11: * modification, are permitted provided that the following conditions
! 12: * are met:
! 13: * 1. Redistributions of source code must retain the above copyright
! 14: * notice, this list of conditions and the following disclaimer.
! 15: * 2. Redistributions in binary form must reproduce the above copyright
! 16: * notice, this list of conditions and the following disclaimer in the
! 17: * documentation and/or other materials provided with the distribution.
! 18: * 3. All advertising materials mentioning features or use of this software
! 19: * must display the following acknowledgement:
! 20: * This product includes software developed by Eric S. Raymond
! 21: * 4. The name of the author may not be used to endorse or promote products
! 22: * derived from this software without specific prior written permission.
! 23: *
! 24: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 25: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 26: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 27: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 28: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 29: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 30: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 32: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 33: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 34: * POSSIBILITY OF SUCH DAMAGE.
! 35: */
! 36:
! 37: /*
! 38: * spkr.c -- device driver for console speaker on 80386
! 39: *
! 40: * v1.1 by Eric S. Raymond (esr@snark.thyrsus.com) Feb 1990
! 41: * modified for 386bsd by Andrew A. Chernov <ache@astral.msk.su>
! 42: * 386bsd only clean version, all SYSV stuff removed
! 43: * use hz value from param.c
! 44: */
! 45:
! 46: #include <sys/param.h>
! 47: #include <sys/systm.h>
! 48: #include <sys/kernel.h>
! 49: #include <sys/errno.h>
! 50: #include <sys/device.h>
! 51: #include <sys/malloc.h>
! 52: #include <sys/uio.h>
! 53: #include <sys/proc.h>
! 54: #include <sys/ioctl.h>
! 55: #include <sys/conf.h>
! 56:
! 57: #include <dev/isa/pcppivar.h>
! 58:
! 59: #include <dev/isa/spkrio.h>
! 60:
! 61: cdev_decl(spkr);
! 62:
! 63: int spkrprobe(struct device *, void *, void *);
! 64: void spkrattach(struct device *, struct device *, void *);
! 65:
! 66: struct cfattach spkr_ca = {
! 67: sizeof(struct device), spkrprobe, spkrattach
! 68: };
! 69:
! 70: struct cfdriver spkr_cd = {
! 71: NULL, "spkr", DV_DULL
! 72: };
! 73:
! 74: static pcppi_tag_t ppicookie;
! 75:
! 76: #define SPKRPRI (PZERO - 1)
! 77:
! 78: static void tone(u_int, u_int);
! 79: static void rest(int);
! 80: static void playinit(void);
! 81: static void playtone(int, int, int);
! 82: static void playstring(char *, int);
! 83:
! 84: /* emit tone of frequency hz for given number of ticks */
! 85: static void
! 86: tone(hz, ticks)
! 87: u_int hz, ticks;
! 88: {
! 89: pcppi_bell(ppicookie, hz, ticks, PCPPI_BELL_SLEEP);
! 90: }
! 91:
! 92: /* rest for given number of ticks */
! 93: static void
! 94: rest(ticks)
! 95: int ticks;
! 96: {
! 97: /*
! 98: * Set timeout to endrest function, then give up the timeslice.
! 99: * This is so other processes can execute while the rest is being
! 100: * waited out.
! 101: */
! 102: #ifdef SPKRDEBUG
! 103: printf("rest: %d\n", ticks);
! 104: #endif /* SPKRDEBUG */
! 105: if (ticks > 0)
! 106: tsleep(rest, SPKRPRI | PCATCH, "rest", ticks);
! 107: }
! 108:
! 109: /**************** PLAY STRING INTERPRETER BEGINS HERE **********************
! 110: *
! 111: * Play string interpretation is modelled on IBM BASIC 2.0's PLAY statement;
! 112: * M[LNS] are missing and the ~ synonym and octave-tracking facility is added.
! 113: * Requires tone(), rest(), and endtone(). String play is not interruptible
! 114: * except possibly at physical block boundaries.
! 115: */
! 116:
! 117: typedef int bool;
! 118: #define TRUE 1
! 119: #define FALSE 0
! 120:
! 121: #define toupper(c) ((c) - ' ' * (((c) >= 'a') && ((c) <= 'z')))
! 122: #define isdigit(c) (((c) >= '0') && ((c) <= '9'))
! 123: #define dtoi(c) ((c) - '0')
! 124:
! 125: static int octave; /* currently selected octave */
! 126: static int whole; /* whole-note time at current tempo, in ticks */
! 127: static int value; /* whole divisor for note time, quarter note = 1 */
! 128: static int fill; /* controls spacing of notes */
! 129: static bool octtrack; /* octave-tracking on? */
! 130: static bool octprefix; /* override current octave-tracking state? */
! 131:
! 132: /*
! 133: * Magic number avoidance...
! 134: */
! 135: #define SECS_PER_MIN 60 /* seconds per minute */
! 136: #define WHOLE_NOTE 4 /* quarter notes per whole note */
! 137: #define MIN_VALUE 64 /* the most we can divide a note by */
! 138: #define DFLT_VALUE 4 /* default value (quarter-note) */
! 139: #define FILLTIME 8 /* for articulation, break note in parts */
! 140: #define STACCATO 6 /* 6/8 = 3/4 of note is filled */
! 141: #define NORMAL 7 /* 7/8ths of note interval is filled */
! 142: #define LEGATO 8 /* all of note interval is filled */
! 143: #define DFLT_OCTAVE 4 /* default octave */
! 144: #define MIN_TEMPO 32 /* minimum tempo */
! 145: #define DFLT_TEMPO 120 /* default tempo */
! 146: #define MAX_TEMPO 255 /* max tempo */
! 147: #define NUM_MULT 3 /* numerator of dot multiplier */
! 148: #define DENOM_MULT 2 /* denominator of dot multiplier */
! 149:
! 150: /* letter to half-tone: A B C D E F G */
! 151: static int notetab[8] = { 9, 11, 0, 2, 4, 5, 7 };
! 152:
! 153: /*
! 154: * This is the American Standard A440 Equal-Tempered scale with frequencies
! 155: * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook...
! 156: * our octave 0 is standard octave 2.
! 157: */
! 158: #define OCTAVE_NOTES 12 /* semitones per octave */
! 159: static int pitchtab[] =
! 160: {
! 161: /* C C# D D# E F F# G G# A A# B*/
! 162: /* 0 */ 65, 69, 73, 78, 82, 87, 93, 98, 103, 110, 117, 123,
! 163: /* 1 */ 131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247,
! 164: /* 2 */ 262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494,
! 165: /* 3 */ 523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988,
! 166: /* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975,
! 167: /* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
! 168: /* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902,
! 169: };
! 170: #define NOCTAVES (sizeof(pitchtab) / sizeof(pitchtab[0]) / OCTAVE_NOTES)
! 171:
! 172: static void
! 173: playinit()
! 174: {
! 175: octave = DFLT_OCTAVE;
! 176: whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO;
! 177: fill = NORMAL;
! 178: value = DFLT_VALUE;
! 179: octtrack = FALSE;
! 180: octprefix = TRUE; /* act as though there was an initial O(n) */
! 181: }
! 182:
! 183: /* play tone of proper duration for current rhythm signature */
! 184: static void
! 185: playtone(pitch, value, sustain)
! 186: int pitch, value, sustain;
! 187: {
! 188: int sound, silence, snum = 1, sdenom = 1;
! 189:
! 190: /* this weirdness avoids floating-point arithmetic */
! 191: for (; sustain; sustain--) {
! 192: snum *= NUM_MULT;
! 193: sdenom *= DENOM_MULT;
! 194: }
! 195:
! 196: if (pitch == -1)
! 197: rest(whole * snum / (value * sdenom));
! 198: else if (pitch >= 0 &&
! 199: pitch < (sizeof(pitchtab) / sizeof(pitchtab[0]))) {
! 200: sound = (whole * snum) / (value * sdenom) -
! 201: (whole * (FILLTIME - fill)) / (value * FILLTIME);
! 202: silence = whole * (FILLTIME-fill) * snum /
! 203: (FILLTIME * value * sdenom);
! 204:
! 205: #ifdef SPKRDEBUG
! 206: printf("playtone: pitch %d for %d ticks, rest for %d ticks\n",
! 207: pitch, sound, silence);
! 208: #endif /* SPKRDEBUG */
! 209:
! 210: tone(pitchtab[pitch], sound);
! 211: if (fill != LEGATO)
! 212: rest(silence);
! 213: }
! 214: }
! 215:
! 216: /* interpret and play an item from a notation string */
! 217: static void
! 218: playstring(cp, slen)
! 219: char *cp;
! 220: int slen;
! 221: {
! 222: int pitch, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;
! 223:
! 224: #define GETNUM(cp, v) \
! 225: do { \
! 226: for (v = 0; slen > 0 && isdigit(cp[1]); ) { \
! 227: v = v * 10 + (*++cp - '0'); \
! 228: slen--; \
! 229: } \
! 230: } while (0)
! 231:
! 232: for (; slen--; cp++) {
! 233: int sustain, timeval, tempo;
! 234: char c = toupper(*cp);
! 235:
! 236: #ifdef SPKRDEBUG
! 237: printf("playstring: %c (%x)\n", c, c);
! 238: #endif /* SPKRDEBUG */
! 239:
! 240: switch (c) {
! 241: case 'A':
! 242: case 'B':
! 243: case 'C':
! 244: case 'D':
! 245: case 'E':
! 246: case 'F':
! 247: case 'G':
! 248: /* compute pitch */
! 249: pitch = notetab[c - 'A'] + octave * OCTAVE_NOTES;
! 250:
! 251: /* this may be followed by an accidental sign */
! 252: if (slen > 0 && (cp[1] == '#' || cp[1] == '+')) {
! 253: ++pitch;
! 254: ++cp;
! 255: slen--;
! 256: } else if (slen > 0 && cp[1] == '-') {
! 257: --pitch;
! 258: ++cp;
! 259: slen--;
! 260: }
! 261:
! 262: /*
! 263: * If octave-tracking mode is on, and there has been
! 264: * no octave-setting prefix, find the version of the
! 265: * current letter note closest to the last regardless
! 266: * of octave.
! 267: */
! 268: if (octtrack && !octprefix) {
! 269: if (abs(pitch - lastpitch) >
! 270: abs(pitch + OCTAVE_NOTES - lastpitch)) {
! 271: ++octave;
! 272: pitch += OCTAVE_NOTES;
! 273: }
! 274:
! 275: if (abs(pitch - lastpitch) >
! 276: abs(pitch - OCTAVE_NOTES - lastpitch)) {
! 277: --octave;
! 278: pitch -= OCTAVE_NOTES;
! 279: }
! 280: }
! 281: octprefix = FALSE;
! 282: lastpitch = pitch;
! 283:
! 284: /*
! 285: * ...which may in turn be followed by an override
! 286: * time value
! 287: */
! 288: GETNUM(cp, timeval);
! 289: if (timeval <= 0 || timeval > MIN_VALUE)
! 290: timeval = value;
! 291:
! 292: /* ...and/or sustain dots */
! 293: for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) {
! 294: slen--;
! 295: sustain++;
! 296: }
! 297:
! 298: /* time to emit the actual tone */
! 299: playtone(pitch, timeval, sustain);
! 300: break;
! 301:
! 302: case 'O':
! 303: if (slen > 0 && (cp[1] == 'N' || cp[1] == 'n')) {
! 304: octprefix = octtrack = FALSE;
! 305: ++cp;
! 306: slen--;
! 307: } else if (slen > 0 && (cp[1] == 'L' || cp[1] == 'l')) {
! 308: octtrack = TRUE;
! 309: ++cp;
! 310: slen--;
! 311: } else {
! 312: GETNUM(cp, octave);
! 313: if (octave >= NOCTAVES)
! 314: octave = DFLT_OCTAVE;
! 315: octprefix = TRUE;
! 316: }
! 317: break;
! 318:
! 319: case '>':
! 320: if (octave < NOCTAVES - 1)
! 321: octave++;
! 322: octprefix = TRUE;
! 323: break;
! 324:
! 325: case '<':
! 326: if (octave > 0)
! 327: octave--;
! 328: octprefix = TRUE;
! 329: break;
! 330:
! 331: case 'N':
! 332: GETNUM(cp, pitch);
! 333: for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) {
! 334: slen--;
! 335: sustain++;
! 336: }
! 337: playtone(pitch - 1, value, sustain);
! 338: break;
! 339:
! 340: case 'L':
! 341: GETNUM(cp, value);
! 342: if (value <= 0 || value > MIN_VALUE)
! 343: value = DFLT_VALUE;
! 344: break;
! 345:
! 346: case 'P':
! 347: case '~':
! 348: /* this may be followed by an override time value */
! 349: GETNUM(cp, timeval);
! 350: if (timeval <= 0 || timeval > MIN_VALUE)
! 351: timeval = value;
! 352: for (sustain = 0; slen > 0 && cp[1] == '.'; cp++) {
! 353: slen--;
! 354: sustain++;
! 355: }
! 356: playtone(-1, timeval, sustain);
! 357: break;
! 358:
! 359: case 'T':
! 360: GETNUM(cp, tempo);
! 361: if (tempo < MIN_TEMPO || tempo > MAX_TEMPO)
! 362: tempo = DFLT_TEMPO;
! 363: whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / tempo;
! 364: break;
! 365:
! 366: case 'M':
! 367: if (slen > 0 && (cp[1] == 'N' || cp[1] == 'n')) {
! 368: fill = NORMAL;
! 369: ++cp;
! 370: slen--;
! 371: } else if (slen > 0 && (cp[1] == 'L' || cp[1] == 'l')) {
! 372: fill = LEGATO;
! 373: ++cp;
! 374: slen--;
! 375: } else if (slen > 0 && (cp[1] == 'S' || cp[1] == 's')) {
! 376: fill = STACCATO;
! 377: ++cp;
! 378: slen--;
! 379: }
! 380: break;
! 381: }
! 382: }
! 383: }
! 384:
! 385: /******************* UNIX DRIVER HOOKS BEGIN HERE **************************
! 386: *
! 387: * This section implements driver hooks to run playstring() and the tone(),
! 388: * endtone(), and rest() functions defined above.
! 389: */
! 390:
! 391: static int spkr_active; /* exclusion flag */
! 392: static void *spkr_inbuf;
! 393:
! 394: static int spkr_attached = 0;
! 395:
! 396: int
! 397: spkrprobe(parent, match, aux)
! 398: struct device *parent;
! 399: void *match;
! 400: void *aux;
! 401: {
! 402: return (!spkr_attached);
! 403: }
! 404:
! 405: void
! 406: spkrattach(parent, self, aux)
! 407: struct device *parent;
! 408: struct device *self;
! 409: void *aux;
! 410: {
! 411: printf("\n");
! 412: ppicookie = ((struct pcppi_attach_args *)aux)->pa_cookie;
! 413: spkr_attached = 1;
! 414: }
! 415:
! 416: int
! 417: spkropen(dev, flags, mode, p)
! 418: dev_t dev;
! 419: int flags;
! 420: int mode;
! 421: struct proc *p;
! 422: {
! 423: #ifdef SPKRDEBUG
! 424: printf("spkropen: entering with dev = %x\n", dev);
! 425: #endif /* SPKRDEBUG */
! 426:
! 427: if (minor(dev) != 0 || !spkr_attached)
! 428: return (ENXIO);
! 429: else if (spkr_active)
! 430: return (EBUSY);
! 431: else {
! 432: playinit();
! 433: spkr_inbuf = malloc(DEV_BSIZE, M_DEVBUF, M_WAITOK);
! 434: spkr_active = 1;
! 435: }
! 436: return (0);
! 437: }
! 438:
! 439: int
! 440: spkrwrite(dev, uio, flags)
! 441: dev_t dev;
! 442: struct uio *uio;
! 443: int flags;
! 444: {
! 445: int n;
! 446: int error;
! 447: #ifdef SPKRDEBUG
! 448: printf("spkrwrite: entering with dev = %x, count = %d\n",
! 449: dev, uio->uio_resid);
! 450: #endif /* SPKRDEBUG */
! 451:
! 452: if (minor(dev) != 0)
! 453: return (ENXIO);
! 454: else {
! 455: n = min(DEV_BSIZE, uio->uio_resid);
! 456: error = uiomove(spkr_inbuf, n, uio);
! 457: if (!error)
! 458: playstring((char *)spkr_inbuf, n);
! 459: return (error);
! 460: }
! 461: }
! 462:
! 463: int
! 464: spkrclose(dev, flags, mode, p)
! 465: dev_t dev;
! 466: int flags;
! 467: int mode;
! 468: struct proc *p;
! 469: {
! 470: #ifdef SPKRDEBUG
! 471: printf("spkrclose: entering with dev = %x\n", dev);
! 472: #endif /* SPKRDEBUG */
! 473:
! 474: if (minor(dev) != 0)
! 475: return (ENXIO);
! 476: else {
! 477: tone(0, 0);
! 478: free(spkr_inbuf, M_DEVBUF);
! 479: spkr_active = 0;
! 480: }
! 481: return (0);
! 482: }
! 483:
! 484: int
! 485: spkrioctl(dev, cmd, data, flag, p)
! 486: dev_t dev;
! 487: u_long cmd;
! 488: caddr_t data;
! 489: int flag;
! 490: struct proc *p;
! 491: {
! 492: tone_t *tp, ttp;
! 493: int error;
! 494:
! 495: #ifdef SPKRDEBUG
! 496: printf("spkrioctl: entering with dev = %x, cmd = %lx\n", dev, cmd);
! 497: #endif /* SPKRDEBUG */
! 498:
! 499: if (minor(dev) != 0)
! 500: return (ENXIO);
! 501:
! 502: switch (cmd) {
! 503: case SPKRTONE:
! 504: tp = (tone_t *)data;
! 505:
! 506: if (tp->frequency == 0)
! 507: rest(tp->duration);
! 508: else
! 509: tone(tp->frequency, tp->duration);
! 510: break;
! 511: case SPKRTUNE:
! 512: tp = (tone_t *)(*(caddr_t *)data);
! 513:
! 514: for (; ; tp++) {
! 515: error = copyin(tp, &ttp, sizeof(tone_t));
! 516: if (error)
! 517: return (error);
! 518: if (ttp.duration == 0)
! 519: break;
! 520: if (ttp.frequency == 0)
! 521: rest(ttp.duration);
! 522: else
! 523: tone(ttp.frequency, ttp.duration);
! 524: }
! 525: break;
! 526: default:
! 527: return (ENOTTY);
! 528: }
! 529:
! 530: return (0);
! 531: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to spkr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa