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

Cache object: 515348fb5ac7db0198a72c492873df88


[ 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.