The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/spkr.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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: releng/6.0/sys/i386/isa/spkr.c 146211 2005-05-14 09:10:02Z nyan $");
   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/speaker.h>
   24 #include <machine/ppireg.h>
   25 #include <machine/timerreg.h>
   26 
   27 static  d_open_t        spkropen;
   28 static  d_close_t       spkrclose;
   29 static  d_write_t       spkrwrite;
   30 static  d_ioctl_t       spkrioctl;
   31 
   32 static 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 
   42 static 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
   64 static char endtone, endrest;
   65 
   66 static void tone(unsigned int thz, unsigned int ticks);
   67 static void rest(int ticks);
   68 static void playinit(void);
   69 static void playtone(int pitch, int value, int sustain);
   70 static void playstring(char *cp, size_t slen);
   71 
   72 /* emit tone of frequency thz for given number of ticks */
   73 static void
   74 tone(thz, ticks)
   75         unsigned int thz, ticks;
   76 {
   77     unsigned int divisor;
   78     int sps;
   79 
   80     if (thz <= 0)
   81         return;
   82 
   83     divisor = timer_freq / thz;
   84 
   85 #ifdef DEBUG
   86     (void) printf("tone: thz=%d ticks=%d\n", thz, ticks);
   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     if (ticks > 0)
  111         tsleep(&endtone, SPKRPRI | PCATCH, "spkrtn", ticks);
  112     ppi_spkr_off();
  113     sps = splclock();
  114     timer_spkr_release();
  115     splx(sps);
  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(&endrest, SPKRPRI | 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) - '')
  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 /* interpret and play an item from a notation string */
  245 static void
  246 playstring(cp, slen)
  247         char    *cp;
  248         size_t  slen;
  249 {
  250     int         pitch, oldfill, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;
  251 
  252 #define GETNUM(cp, v)   for(v=0; isdigit(cp[1]) && slen > 0; ) \
  253                                 {v = v * 10 + (*++cp - ''); slen--;}
  254     for (; slen--; cp++)
  255     {
  256         int             sustain, timeval, tempo;
  257         register char   c = toupper(*cp);
  258 
  259 #ifdef DEBUG
  260         (void) printf("playstring: %c (%x)\n", c, c);
  261 #endif /* DEBUG */
  262 
  263         switch (c)
  264         {
  265         case 'A':  case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
  266 
  267             /* compute pitch */
  268             pitch = notetab[c - 'A'] + octave * OCTAVE_NOTES;
  269 
  270             /* this may be followed by an accidental sign */
  271             if (cp[1] == '#' || cp[1] == '+')
  272             {
  273                 ++pitch;
  274                 ++cp;
  275                 slen--;
  276             }
  277             else if (cp[1] == '-')
  278             {
  279                 --pitch;
  280                 ++cp;
  281                 slen--;
  282             }
  283 
  284             /*
  285              * If octave-tracking mode is on, and there has been no octave-
  286              * setting prefix, find the version of the current letter note
  287              * closest to the last regardless of octave.
  288              */
  289             if (octtrack && !octprefix)
  290             {
  291                 if (abs(pitch-lastpitch) > abs(pitch+OCTAVE_NOTES-lastpitch))
  292                 {
  293                     ++octave;
  294                     pitch += OCTAVE_NOTES;
  295                 }
  296 
  297                 if (abs(pitch-lastpitch) > abs((pitch-OCTAVE_NOTES)-lastpitch))
  298                 {
  299                     --octave;
  300                     pitch -= OCTAVE_NOTES;
  301                 }
  302             }
  303             octprefix = FALSE;
  304             lastpitch = pitch;
  305 
  306             /* ...which may in turn be followed by an override time value */
  307             GETNUM(cp, timeval);
  308             if (timeval <= 0 || timeval > MIN_VALUE)
  309                 timeval = value;
  310 
  311             /* ...and/or sustain dots */
  312             for (sustain = 0; cp[1] == '.'; cp++)
  313             {
  314                 slen--;
  315                 sustain++;
  316             }
  317 
  318             /* ...and/or a slur mark */
  319             oldfill = fill;
  320             if (cp[1] == '_')
  321             {
  322                 fill = LEGATO;
  323                 ++cp;
  324                 slen--;
  325             }
  326 
  327             /* time to emit the actual tone */
  328             playtone(pitch, timeval, sustain);
  329 
  330             fill = oldfill;
  331             break;
  332 
  333         case 'O':
  334             if (cp[1] == 'N' || cp[1] == 'n')
  335             {
  336                 octprefix = octtrack = FALSE;
  337                 ++cp;
  338                 slen--;
  339             }
  340             else if (cp[1] == 'L' || cp[1] == 'l')
  341             {
  342                 octtrack = TRUE;
  343                 ++cp;
  344                 slen--;
  345             }
  346             else
  347             {
  348                 GETNUM(cp, octave);
  349                 if (octave >= sizeof(pitchtab) / sizeof(pitchtab[0]) / OCTAVE_NOTES)
  350                     octave = DFLT_OCTAVE;
  351                 octprefix = TRUE;
  352             }
  353             break;
  354 
  355         case '>':
  356             if (octave < sizeof(pitchtab) / sizeof(pitchtab[0]) / OCTAVE_NOTES - 1)
  357                 octave++;
  358             octprefix = TRUE;
  359             break;
  360 
  361         case '<':
  362             if (octave > 0)
  363                 octave--;
  364             octprefix = TRUE;
  365             break;
  366 
  367         case 'N':
  368             GETNUM(cp, pitch);
  369             for (sustain = 0; cp[1] == '.'; cp++)
  370             {
  371                 slen--;
  372                 sustain++;
  373             }
  374             oldfill = fill;
  375             if (cp[1] == '_')
  376             {
  377                 fill = LEGATO;
  378                 ++cp;
  379                 slen--;
  380             }
  381             playtone(pitch - 1, value, sustain);
  382             fill = oldfill;
  383             break;
  384 
  385         case 'L':
  386             GETNUM(cp, value);
  387             if (value <= 0 || value > MIN_VALUE)
  388                 value = DFLT_VALUE;
  389             break;
  390 
  391         case 'P':
  392         case '~':
  393             /* this may be followed by an override time value */
  394             GETNUM(cp, timeval);
  395             if (timeval <= 0 || timeval > MIN_VALUE)
  396                 timeval = value;
  397             for (sustain = 0; cp[1] == '.'; cp++)
  398             {
  399                 slen--;
  400                 sustain++;
  401             }
  402             playtone(-1, timeval, sustain);
  403             break;
  404 
  405         case 'T':
  406             GETNUM(cp, tempo);
  407             if (tempo < MIN_TEMPO || tempo > MAX_TEMPO)
  408                 tempo = DFLT_TEMPO;
  409             whole = (hz * SECS_PER_MIN * WHOLE_NOTE) / tempo;
  410             break;
  411 
  412         case 'M':
  413             if (cp[1] == 'N' || cp[1] == 'n')
  414             {
  415                 fill = NORMAL;
  416                 ++cp;
  417                 slen--;
  418             }
  419             else if (cp[1] == 'L' || cp[1] == 'l')
  420             {
  421                 fill = LEGATO;
  422                 ++cp;
  423                 slen--;
  424             }
  425             else if (cp[1] == 'S' || cp[1] == 's')
  426             {
  427                 fill = STACCATO;
  428                 ++cp;
  429                 slen--;
  430             }
  431             break;
  432         }
  433     }
  434 }
  435 
  436 /******************* UNIX DRIVER HOOKS BEGIN HERE **************************
  437  *
  438  * This section implements driver hooks to run playstring() and the tone(),
  439  * endtone(), and rest() functions defined above.
  440  */
  441 
  442 static int spkr_active = FALSE; /* exclusion flag */
  443 static char *spkr_inbuf;  /* incoming buf */
  444 
  445 static int
  446 spkropen(dev, flags, fmt, td)
  447         struct cdev *dev;
  448         int             flags;
  449         int             fmt;
  450         struct thread   *td;
  451 {
  452 #ifdef DEBUG
  453     (void) printf("spkropen: entering with dev = %s\n", devtoname(dev));
  454 #endif /* DEBUG */
  455 
  456     if (minor(dev) != 0)
  457         return(ENXIO);
  458     else if (spkr_active)
  459         return(EBUSY);
  460     else
  461     {
  462 #ifdef DEBUG
  463         (void) printf("spkropen: about to perform play initialization\n");
  464 #endif /* DEBUG */
  465         playinit();
  466         spkr_inbuf = malloc(DEV_BSIZE, M_SPKR, M_WAITOK);
  467         spkr_active = TRUE;
  468         return(0);
  469     }
  470 }
  471 
  472 static int
  473 spkrwrite(dev, uio, ioflag)
  474         struct cdev *dev;
  475         struct uio      *uio;
  476         int             ioflag;
  477 {
  478 #ifdef DEBUG
  479     printf("spkrwrite: entering with dev = %s, count = %d\n",
  480                 devtoname(dev), uio->uio_resid);
  481 #endif /* DEBUG */
  482 
  483     if (minor(dev) != 0)
  484         return(ENXIO);
  485     else if (uio->uio_resid > (DEV_BSIZE - 1))     /* prevent system crashes */
  486         return(E2BIG);
  487     else
  488     {
  489         unsigned n;
  490         char *cp;
  491         int error;
  492 
  493         n = uio->uio_resid;
  494         cp = spkr_inbuf;
  495         error = uiomove(cp, n, uio);
  496         if (!error) {
  497                 cp[n] = '\0';
  498                 playstring(cp, n);
  499         }
  500         return(error);
  501     }
  502 }
  503 
  504 static int
  505 spkrclose(dev, flags, fmt, td)
  506         struct cdev *dev;
  507         int             flags;
  508         int             fmt;
  509         struct thread   *td;
  510 {
  511 #ifdef DEBUG
  512     (void) printf("spkrclose: entering with dev = %s\n", devtoname(dev));
  513 #endif /* DEBUG */
  514 
  515     if (minor(dev) != 0)
  516         return(ENXIO);
  517     else
  518     {
  519         wakeup(&endtone);
  520         wakeup(&endrest);
  521         free(spkr_inbuf, M_SPKR);
  522         spkr_active = FALSE;
  523         return(0);
  524     }
  525 }
  526 
  527 static int
  528 spkrioctl(dev, cmd, cmdarg, flags, td)
  529         struct cdev *dev;
  530         unsigned long   cmd;
  531         caddr_t         cmdarg;
  532         int             flags;
  533         struct thread   *td;
  534 {
  535 #ifdef DEBUG
  536     (void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n",
  537         devtoname(dev), cmd);
  538 #endif /* DEBUG */
  539 
  540     if (minor(dev) != 0)
  541         return(ENXIO);
  542     else if (cmd == SPKRTONE)
  543     {
  544         tone_t  *tp = (tone_t *)cmdarg;
  545 
  546         if (tp->frequency == 0)
  547             rest(tp->duration);
  548         else
  549             tone(tp->frequency, tp->duration);
  550         return 0;
  551     }
  552     else if (cmd == SPKRTUNE)
  553     {
  554         tone_t  *tp = (tone_t *)(*(caddr_t *)cmdarg);
  555         tone_t ttp;
  556         int error;
  557 
  558         for (; ; tp++) {
  559             error = copyin(tp, &ttp, sizeof(tone_t));
  560             if (error)
  561                     return(error);
  562             if (ttp.duration == 0)
  563                     break;
  564             if (ttp.frequency == 0)
  565                  rest(ttp.duration);
  566             else
  567                  tone(ttp.frequency, ttp.duration);
  568         }
  569         return(0);
  570     }
  571     return(EINVAL);
  572 }
  573 
  574 /*
  575  * Install placeholder to claim the resources owned by the
  576  * AT tone generator.
  577  */
  578 static struct isa_pnp_id speaker_ids[] = {
  579 #ifndef PC98
  580         { 0x0008d041 /* PNP0800 */, SPKR_DESC },
  581 #endif
  582         { 0 }
  583 };
  584 
  585 static struct cdev *speaker_dev;
  586 
  587 static int
  588 speaker_probe(device_t dev)
  589 {
  590         int     error;
  591 
  592         error = ISA_PNP_PROBE(device_get_parent(dev), dev, speaker_ids);
  593         
  594         /* PnP match */
  595         if (error == 0)
  596                 return (0);
  597 
  598         /* No match */
  599         if (error == ENXIO)
  600                 return (ENXIO);
  601 
  602         /* Not configured by hints. */
  603         if (strncmp(device_get_name(dev), "speaker", 9))
  604                 return (ENXIO);
  605 
  606         device_set_desc(dev, SPKR_DESC);
  607 
  608         return (0);
  609 }
  610 
  611 static int
  612 speaker_attach(device_t dev)
  613 {
  614 
  615         if (speaker_dev) {
  616                 device_printf(dev, "Already attached!\n");
  617                 return (ENXIO);
  618         }
  619 
  620         speaker_dev = make_dev(&spkr_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
  621             "speaker");
  622         return (0);
  623 }
  624 
  625 static int
  626 speaker_detach(device_t dev)
  627 {
  628         destroy_dev(speaker_dev);
  629         return (0);
  630 }
  631 
  632 static device_method_t speaker_methods[] = {
  633         /* Device interface */
  634         DEVMETHOD(device_probe,         speaker_probe),
  635         DEVMETHOD(device_attach,        speaker_attach),
  636         DEVMETHOD(device_detach,        speaker_detach),
  637         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  638         DEVMETHOD(device_suspend,       bus_generic_suspend),
  639         DEVMETHOD(device_resume,        bus_generic_resume),
  640         { 0, 0 }
  641 };
  642 
  643 static driver_t speaker_driver = {
  644         "speaker",
  645         speaker_methods,
  646         1,              /* no softc */
  647 };
  648 
  649 static devclass_t speaker_devclass;
  650 
  651 DRIVER_MODULE(speaker, isa, speaker_driver, speaker_devclass, 0, 0);
  652 #ifndef PC98
  653 DRIVER_MODULE(speaker, acpi, speaker_driver, speaker_devclass, 0, 0);
  654 #endif
  655 
  656 /* spkr.c ends here */

Cache object: 66b472cd5bae06a97523f26dba935e9f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.