sys/dev/sound/isa/i386/spkr/spkr.c

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