root/dev/isa/ess.c

DEFINITIONS

1. ess_printsc
2. ess_dump_mixer
3. ess_config_addr
4. ess_config_irq
5. ess_config_drq
6. ess_setup
7. ess_identify
8. ess_setup_sc
9. essmatch
10. essattach
11. ess_open
12. ess_1788_close
13. ess_1888_close
14. ess_drain
15. ess_speaker_ctl
16. ess_getdev
17. ess_query_encoding
18. ess_set_params
19. ess_audio1_trigger_output
20. ess_audio2_trigger_output
21. ess_audio1_trigger_input
22. ess_audio1_halt
23. ess_audio2_halt
24. ess_audio1_intr
25. ess_audio2_intr
26. ess_audio1_poll
27. ess_audio2_poll
28. ess_round_blocksize
29. ess_set_port
30. ess_get_port
31. ess_query_devinfo
32. ess_malloc
33. ess_free
34. ess_round_buffersize
35. ess_mappage
36. ess_1788_get_props
37. ess_1888_get_props
38. ess_reset
39. ess_set_gain
40. ess_set_in_port
41. ess_set_in_ports
42. ess_speaker_on
43. ess_speaker_off
44. ess_srtotc
45. ess_srtofc
46. ess_get_dsp_status
47. ess_dsp_read_ready
48. ess_dsp_write_ready
49. ess_rdsp
50. ess_wdsp
51. ess_write_x_reg
52. ess_read_x_reg
53. ess_clear_xreg_bits
54. ess_set_xreg_bits
55. ess_write_mix_reg
56. ess_read_mix_reg
57. ess_clear_mreg_bits
58. ess_set_mreg_bits
59. ess_read_multi_mix_reg

    1 /*      $OpenBSD: ess.c,v 1.11 2006/02/22 19:43:42 miod Exp $   */
    2 /*      $NetBSD: ess.c,v 1.44.4.1 1999/06/21 01:18:00 thorpej Exp $     */
    4 /*
    5  * Copyright 1997
    6  * Digital Equipment Corporation. All rights reserved.
    7  *
    8  * This software is furnished under license and may be used and
    9  * copied only in accordance with the following terms and conditions.
   10  * Subject to these conditions, you may download, copy, install,
   11  * use, modify and distribute this software in source and/or binary
   12  * form. No title or ownership is transferred hereby.
   13  *
   14  * 1) Any source code used, modified or distributed must reproduce
   15  *    and retain this copyright notice and list of conditions as
   16  *    they appear in the source file.
   17  *
   18  * 2) No right is granted to use any trade name, trademark, or logo of
   19  *    Digital Equipment Corporation. Neither the "Digital Equipment
   20  *    Corporation" name nor any trademark or logo of Digital Equipment
   21  *    Corporation may be used to endorse or promote products derived
   22  *    from this software without the prior written permission of
   23  *    Digital Equipment Corporation.
   24  *
   25  * 3) This software is provided "AS-IS" and any express or implied
   26  *    warranties, including but not limited to, any implied warranties
   27  *    of merchantability, fitness for a particular purpose, or
   28  *    non-infringement are disclaimed. In no event shall DIGITAL be
   29  *    liable for any damages whatsoever, and in particular, DIGITAL
   30  *    shall not be liable for special, indirect, consequential, or
   31  *    incidental damages or damages for lost profits, loss of
   32  *    revenue or loss of use, whether such damages arise in contract,
   33  *    negligence, tort, under statute, in equity, at law or otherwise,
   34  *    even if advised of the possibility of such damage.
   35  */
   37 /*
   38 **++
   39 **
   40 **  ess.c
   41 **
   42 **  FACILITY:
   43 **
   44 **      DIGITAL Network Appliance Reference Design (DNARD)
   45 **
   46 **  MODULE DESCRIPTION:
   47 **
   48 **      This module contains the device driver for the ESS
   49 **      Technologies 1888/1887/888 sound chip. The code in sbdsp.c was
   50 **      used as a reference point when implementing this driver.
   51 **
   52 **  AUTHORS:
   53 **
   54 **      Blair Fidler    Software Engineering Australia
   55 **                      Gold Coast, Australia.
   56 **
   57 **  CREATION DATE:
   58 **
   59 **      March 10, 1997.
   60 **
   61 **  MODIFICATION HISTORY:
   62 **
   63 **      Heavily modified by Lennart Augustsson and Charles M. Hannum for
   64 **      bus_dma, changes to audio interface, and many bug fixes.
   65 **      ESS1788 support by Nathan J. Williams and Charles M. Hannum.
   66 **--
   67 */
   69 #include <sys/param.h>
   70 #include <sys/systm.h>
   71 #include <sys/errno.h>
   72 #include <sys/ioctl.h>
   73 #include <sys/syslog.h>
   74 #include <sys/device.h>
   75 #include <sys/proc.h>
   76 #include <sys/kernel.h>
   77 #include <sys/timeout.h>
   79 #include <machine/cpu.h>
   80 #include <machine/intr.h>
   81 #include <machine/bus.h>
   83 #include <sys/audioio.h>
   84 #include <dev/audio_if.h>
   85 #include <dev/auconv.h>
   86 #include <dev/mulaw.h>
   88 #include <dev/isa/isavar.h>
   89 #include <dev/isa/isadmavar.h>
   91 #include <dev/isa/essvar.h>
   92 #include <dev/isa/essreg.h>
   94 #ifdef AUDIO_DEBUG
   95 #define DPRINTF(x)      if (essdebug) printf x
   96 #define DPRINTFN(n,x)   if (essdebug>(n)) printf x
   97 int     essdebug = 0;
   98 #else
   99 #define DPRINTF(x)
  100 #define DPRINTFN(n,x)
  101 #endif
  103 #if 0
  104 unsigned uuu;
  105 #define EREAD1(t, h, a) (uuu=bus_space_read_1(t, h, a),printf("EREAD  %02x=%02x\n", ((int)h&0xfff)+a, uuu),uuu)
  106 #define EWRITE1(t, h, a, d) (printf("EWRITE %02x=%02x\n", ((int)h & 0xfff)+a, d), bus_space_write_1(t, h, a, d))
  107 #else
  108 #define EREAD1(t, h, a) bus_space_read_1(t, h, a)
  109 #define EWRITE1(t, h, a, d) bus_space_write_1(t, h, a, d)
  110 #endif
  112 struct cfdriver ess_cd = {
NULL, "ess", DV_DULL
  114 };
  116 int     ess_setup_sc(struct ess_softc *, int);
  118 int     ess_open(void *, int);
  119 void    ess_1788_close(void *);
  120 void    ess_1888_close(void *);
  121 int     ess_getdev(void *, struct audio_device *);
  122 int     ess_drain(void *);
  124 int     ess_query_encoding(void *, struct audio_encoding *);
  126 int     ess_set_params(void *, int, int, struct audio_params *,
  127             struct audio_params *);
  129 int     ess_round_blocksize(void *, int);
  131 int     ess_audio1_trigger_output(void *, void *, void *, int,
  132             void (*)(void *), void *, struct audio_params *);
  133 int     ess_audio2_trigger_output(void *, void *, void *, int,
  134             void (*)(void *), void *, struct audio_params *);
  135 int     ess_audio1_trigger_input(void *, void *, void *, int,
  136             void (*)(void *), void *, struct audio_params *);
  137 int     ess_audio1_halt(void *);
  138 int     ess_audio2_halt(void *);
  139 int     ess_audio1_intr(void *);
  140 int     ess_audio2_intr(void *);
  141 void    ess_audio1_poll(void *);
  142 void    ess_audio2_poll(void *);
  144 int     ess_speaker_ctl(void *, int);
  146 int     ess_getdev(void *, struct audio_device *);
  148 int     ess_set_port(void *, mixer_ctrl_t *);
  149 int     ess_get_port(void *, mixer_ctrl_t *);
  151 void   *ess_malloc(void *, int, size_t, int, int);
  152 void    ess_free(void *, void *, int);
size_t  ess_round_buffersize(void *, int, size_t);
paddr_t ess_mappage(void *, void *, off_t, int);
  157 int     ess_query_devinfo(void *, mixer_devinfo_t *);
  158 int     ess_1788_get_props(void *);
  159 int     ess_1888_get_props(void *);
  161 void    ess_speaker_on(struct ess_softc *);
  162 void    ess_speaker_off(struct ess_softc *);
  164 int     ess_config_addr(struct ess_softc *);
  165 void    ess_config_irq(struct ess_softc *);
  166 void    ess_config_drq(struct ess_softc *);
  167 void    ess_setup(struct ess_softc *);
  168 int     ess_identify(struct ess_softc *);
  170 int     ess_reset(struct ess_softc *);
  171 void    ess_set_gain(struct ess_softc *, int, int);
  172 int     ess_set_in_port(struct ess_softc *, int);
  173 int     ess_set_in_ports(struct ess_softc *, int);
u_int   ess_srtotc(u_int);
u_int   ess_srtofc(u_int);
u_char  ess_get_dsp_status(struct ess_softc *);
u_char  ess_dsp_read_ready(struct ess_softc *);
u_char  ess_dsp_write_ready(struct ess_softc *);
  179 int     ess_rdsp(struct ess_softc *);
  180 int     ess_wdsp(struct ess_softc *, u_char);
u_char  ess_read_x_reg(struct ess_softc *, u_char);
  182 int     ess_write_x_reg(struct ess_softc *, u_char, u_char);
  183 void    ess_clear_xreg_bits(struct ess_softc *, u_char, u_char);
  184 void    ess_set_xreg_bits(struct ess_softc *, u_char, u_char);
u_char  ess_read_mix_reg(struct ess_softc *, u_char);
  186 void    ess_write_mix_reg(struct ess_softc *, u_char, u_char);
  187 void    ess_clear_mreg_bits(struct ess_softc *, u_char, u_char);
  188 void    ess_set_mreg_bits(struct ess_softc *, u_char, u_char);
  189 void    ess_read_multi_mix_reg(struct ess_softc *, u_char, u_int8_t *, bus_size_t);
  191 static char *essmodel[] = {
  192         "unsupported",
  193         "1888",
  194         "1887",
  195         "888",
  196         "1788",
  197         "1869",
  198         "1879",
  199         "1868",
  200         "1878",
  201 };
  203 struct audio_device ess_device = {
  204         "ESS Technology",
  205         "x",
  206         "ess"
  207 };
  209 /*
  210  * Define our interface to the higher level audio driver.
  211  */
  213 struct audio_hw_if ess_1788_hw_if = {
ess_open,
ess_1788_close,
ess_drain,
ess_query_encoding,
ess_set_params,
ess_round_blocksize,
NULL,
NULL,
NULL,
NULL,
NULL,
ess_audio1_halt,
ess_audio1_halt,
ess_speaker_ctl,
ess_getdev,
NULL,
ess_set_port,
ess_get_port,
ess_query_devinfo,
ess_malloc,
ess_free,
ess_round_buffersize,
ess_mappage,
ess_1788_get_props,
ess_audio1_trigger_output,
ess_audio1_trigger_input,
  240 };
  242 struct audio_hw_if ess_1888_hw_if = {
ess_open,
ess_1888_close,
ess_drain,
ess_query_encoding,
ess_set_params,
ess_round_blocksize,
NULL,
NULL,
NULL,
NULL,
NULL,
ess_audio2_halt,
ess_audio1_halt,
ess_speaker_ctl,
ess_getdev,
NULL,
ess_set_port,
ess_get_port,
ess_query_devinfo,
ess_malloc,
ess_free,
ess_round_buffersize,
ess_mappage,
ess_1888_get_props,
ess_audio2_trigger_output,
ess_audio1_trigger_input,
  269 };
  271 #ifdef AUDIO_DEBUG
  272 void ess_printsc(struct ess_softc *);
  273 void ess_dump_mixer(struct ess_softc *);
  275 void
ess_printsc(sc)
  277         struct ess_softc *sc;
  278 {
  279         int i;
printf("open %d iobase 0x%x outport %u inport %u speaker %s\n",
  282                (int)sc->sc_open, sc->sc_iobase, sc->out_port,
sc->in_port, sc->spkr_state ? "on" : "off");
printf("audio1: dmachan %d irq %d nintr %lu intr %p arg %p\n",
sc->sc_audio1.drq, sc->sc_audio1.irq, sc->sc_audio1.nintr,
sc->sc_audio1.intr, sc->sc_audio1.arg);
  289         if (!ESS_USE_AUDIO1(sc->sc_model)) {
printf("audio2: dmachan %d irq %d nintr %lu intr %p arg %p\n",
sc->sc_audio2.drq, sc->sc_audio2.irq, sc->sc_audio2.nintr,
sc->sc_audio2.intr, sc->sc_audio2.arg);
  293         }
printf("gain:");
  296         for (i = 0; i < sc->ndevs; i++)
printf(" %u,%u", sc->gain[i][ESS_LEFT], sc->gain[i][ESS_RIGHT]);
printf("\n");
  299 }
  301 void
ess_dump_mixer(sc)
  303         struct ess_softc *sc;
  304 {
printf("ESS_DAC_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
  306                0x7C, ess_read_mix_reg(sc, 0x7C));
printf("ESS_MIC_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
  308                0x1A, ess_read_mix_reg(sc, 0x1A));
printf("ESS_LINE_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
  310                0x3E, ess_read_mix_reg(sc, 0x3E));
printf("ESS_SYNTH_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
  312                0x36, ess_read_mix_reg(sc, 0x36));
printf("ESS_CD_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
  314                0x38, ess_read_mix_reg(sc, 0x38));
printf("ESS_AUXB_PLAY_VOL: mix reg 0x%02x=0x%02x\n",
  316                0x3A, ess_read_mix_reg(sc, 0x3A));
printf("ESS_MASTER_VOL: mix reg 0x%02x=0x%02x\n",
  318                0x32, ess_read_mix_reg(sc, 0x32));
printf("ESS_PCSPEAKER_VOL: mix reg 0x%02x=0x%02x\n",
  320                0x3C, ess_read_mix_reg(sc, 0x3C));
printf("ESS_DAC_REC_VOL: mix reg 0x%02x=0x%02x\n",
  322                0x69, ess_read_mix_reg(sc, 0x69));
printf("ESS_MIC_REC_VOL: mix reg 0x%02x=0x%02x\n",
  324                0x68, ess_read_mix_reg(sc, 0x68));
printf("ESS_LINE_REC_VOL: mix reg 0x%02x=0x%02x\n",
  326                0x6E, ess_read_mix_reg(sc, 0x6E));
printf("ESS_SYNTH_REC_VOL: mix reg 0x%02x=0x%02x\n",
  328                0x6B, ess_read_mix_reg(sc, 0x6B));
printf("ESS_CD_REC_VOL: mix reg 0x%02x=0x%02x\n",
  330                0x6A, ess_read_mix_reg(sc, 0x6A));
printf("ESS_AUXB_REC_VOL: mix reg 0x%02x=0x%02x\n",
  332                0x6C, ess_read_mix_reg(sc, 0x6C));
printf("ESS_RECORD_VOL: x reg 0x%02x=0x%02x\n",
  334                0xB4, ess_read_x_reg(sc, 0xB4));
printf("Audio 1 play vol (unused): mix reg 0x%02x=0x%02x\n",
  336                0x14, ess_read_mix_reg(sc, 0x14));
printf("ESS_MIC_PREAMP: x reg 0x%02x=0x%02x\n",
ESS_XCMD_PREAMP_CTRL, ess_read_x_reg(sc, ESS_XCMD_PREAMP_CTRL));
printf("ESS_RECORD_MONITOR: x reg 0x%02x=0x%02x\n",
ESS_XCMD_AUDIO_CTRL, ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL));
printf("Record source: mix reg 0x%02x=0x%02x, 0x%02x=0x%02x\n",
ESS_MREG_ADC_SOURCE, ess_read_mix_reg(sc, ESS_MREG_ADC_SOURCE),
ESS_MREG_AUDIO2_CTRL2, ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2));
  345 }
  347 #endif
  349 /*
  350  * Configure the ESS chip for the desired audio base address.
  351  */
  352 int
ess_config_addr(sc)
  354         struct ess_softc *sc;
  355 {
  356         int iobase = sc->sc_iobase;
bus_space_tag_t iot = sc->sc_iot;
  359         /*
  360          * Configure using the System Control Register method.  This
  361          * method is used when the AMODE line is tied high, which is
  362          * the case for the Shark, but not for the evaluation board.
  363          */
bus_space_handle_t scr_access_ioh;
bus_space_handle_t scr_ioh;
u_short scr_value;
  369         /*
  370          * Set the SCR bit to enable audio.
  371          */
scr_value = ESS_SCR_AUDIO_ENABLE;
  374         /*
  375          * Set the SCR bits necessary to select the specified audio
  376          * base address.
  377          */
  378         switch(iobase) {
  379         case 0x220:
scr_value |= ESS_SCR_AUDIO_220;
  381                 break;
  382         case 0x230:
scr_value |= ESS_SCR_AUDIO_230;
  384                 break;
  385         case 0x240:
scr_value |= ESS_SCR_AUDIO_240;
  387                 break;
  388         case 0x250:
scr_value |= ESS_SCR_AUDIO_250;
  390                 break;
  391         default:
printf("ess: configured iobase 0x%x invalid\n", iobase);
  393                 return (1);
  394                 break;
  395         }
  397         /*
  398          * Get a mapping for the System Control Register (SCR) access
  399          * registers and the SCR data registers.
  400          */
  401         if (bus_space_map(iot, ESS_SCR_ACCESS_BASE, ESS_SCR_ACCESS_PORTS,
  402                           0, &scr_access_ioh)) {
printf("ess: can't map SCR access registers\n");
  404                 return (1);
  405         }
  406         if (bus_space_map(iot, ESS_SCR_BASE, ESS_SCR_PORTS,
  407                           0, &scr_ioh)) {
printf("ess: can't map SCR registers\n");
bus_space_unmap(iot, scr_access_ioh, ESS_SCR_ACCESS_PORTS);
  410                 return (1);
  411         }
  413         /* Unlock the SCR. */
EWRITE1(iot, scr_access_ioh, ESS_SCR_UNLOCK, 0);
  416         /* Write the base address information into SCR[0]. */
EWRITE1(iot, scr_ioh, ESS_SCR_INDEX, 0);
EWRITE1(iot, scr_ioh, ESS_SCR_DATA, scr_value);
  420         /* Lock the SCR. */
EWRITE1(iot, scr_access_ioh, ESS_SCR_LOCK, 0);
  423         /* Unmap the SCR access ports and the SCR data ports. */
bus_space_unmap(iot, scr_access_ioh, ESS_SCR_ACCESS_PORTS);
bus_space_unmap(iot, scr_ioh, ESS_SCR_PORTS);
  427         return 0;
  428 }
  431 /*
  432  * Configure the ESS chip for the desired IRQ and DMA channels.
  433  * ESS  ISA
  434  * --------
  435  * IRQA irq9
  436  * IRQB irq5
  437  * IRQC irq7
  438  * IRQD irq10
  439  * IRQE irq15
  440  *
  441  * DRQA drq0
  442  * DRQB drq1
  443  * DRQC drq3
  444  * DRQD drq5
  445  */
  446 void
ess_config_irq(sc)
  448         struct ess_softc *sc;
  449 {
  450         int v;
DPRINTFN(2,("ess_config_irq\n"));
  454         if (sc->sc_model == ESS_1887 &&
sc->sc_audio1.irq == sc->sc_audio2.irq &&
sc->sc_audio1.irq != -1) {
  457                 /* Use new method, both interrupts are the same. */
v = ESS_IS_SELECT_IRQ;  /* enable intrs */
  459                 switch (sc->sc_audio1.irq) {
  460                 case 5:
v |= ESS_IS_INTRB;
  462                         break;
  463                 case 7:
v |= ESS_IS_INTRC;
  465                         break;
  466                 case 9:
v |= ESS_IS_INTRA;
  468                         break;
  469                 case 10:
v |= ESS_IS_INTRD;
  471                         break;
  472                 case 15:
v |= ESS_IS_INTRE;
  474                         break;
  475 #ifdef DIAGNOSTIC
  476                 default:
printf("ess_config_irq: configured irq %d not supported for Audio 1\n",
sc->sc_audio1.irq);
  479                         return;
  480 #endif
  481                 }
  482                 /* Set the IRQ */
ess_write_mix_reg(sc, ESS_MREG_INTR_ST, v);
  484                 return;
  485         }
  487         if (sc->sc_model == ESS_1887) {
  488                 /* Tell the 1887 to use the old interrupt method. */
ess_write_mix_reg(sc, ESS_MREG_INTR_ST, ESS_IS_ES1888);
  490         }
  492         if (sc->sc_audio1.polled) {
  493                 /* Turn off Audio1 interrupts. */
v = 0;
  495         } else {
  496                 /* Configure Audio 1 for the appropriate IRQ line. */
v = ESS_IRQ_CTRL_MASK | ESS_IRQ_CTRL_EXT; /* All intrs on */
  498                 switch (sc->sc_audio1.irq) {
  499                 case 5:
v |= ESS_IRQ_CTRL_INTRB;
  501                         break;
  502                 case 7:
v |= ESS_IRQ_CTRL_INTRC;
  504                         break;
  505                 case 9:
v |= ESS_IRQ_CTRL_INTRA;
  507                         break;
  508                 case 10:
v |= ESS_IRQ_CTRL_INTRD;
  510                         break;
  511 #ifdef DIAGNOSTIC
  512                 default:
printf("ess: configured irq %d not supported for Audio 1\n",
sc->sc_audio1.irq);
  515                         return;
  516 #endif
  517                 }
  518         }
ess_write_x_reg(sc, ESS_XCMD_IRQ_CTRL, v);
  521         if (ESS_USE_AUDIO1(sc->sc_model))
  522                 return;
  524         if (sc->sc_audio2.polled) {
  525                 /* Turn off Audio2 interrupts. */
ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
ESS_AUDIO2_CTRL2_IRQ2_ENABLE);
  528         } else {
  529                 /* Audio2 is hardwired to INTRE in this mode. */
ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
ESS_AUDIO2_CTRL2_IRQ2_ENABLE);
  532         }
  533 }
  536 void
ess_config_drq(sc)
  538         struct ess_softc *sc;
  539 {
  540         int v;
DPRINTFN(2,("ess_config_drq\n"));
  544         /* Configure Audio 1 (record) for DMA on the appropriate channel. */
v = ESS_DRQ_CTRL_PU | ESS_DRQ_CTRL_EXT;
  546         switch (sc->sc_audio1.drq) {
  547         case 0:
v |= ESS_DRQ_CTRL_DRQA;
  549                 break;
  550         case 1:
v |= ESS_DRQ_CTRL_DRQB;
  552                 break;
  553         case 3:
v |= ESS_DRQ_CTRL_DRQC;
  555                 break;
  556 #ifdef DIAGNOSTIC
  557         default:
printf("ess_config_drq: configured dma chan %d not supported for Audio 1\n",
sc->sc_audio1.drq);
  560                 return;
  561 #endif
  562         }
  563         /* Set DRQ1 */
ess_write_x_reg(sc, ESS_XCMD_DRQ_CTRL, v);
  566         if (ESS_USE_AUDIO1(sc->sc_model))
  567                 return;
  569         /* Configure DRQ2 */
v = ESS_AUDIO2_CTRL3_DRQ_PD;
  571         switch (sc->sc_audio2.drq) {
  572         case 0:
v |= ESS_AUDIO2_CTRL3_DRQA;
  574                 break;
  575         case 1:
v |= ESS_AUDIO2_CTRL3_DRQB;
  577                 break;
  578         case 3:
v |= ESS_AUDIO2_CTRL3_DRQC;
  580                 break;
  581         case 5:
v |= ESS_AUDIO2_CTRL3_DRQD;
  583                 break;
  584 #ifdef DIAGNOSTIC
  585         default:
printf("ess_config_drq: configured dma chan %d not supported for Audio 2\n",
sc->sc_audio2.drq);
  588                 return;
  589 #endif
  590         }
ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL3, v);
  592         /* Enable DMA 2 */
ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2,
ESS_AUDIO2_CTRL2_DMA_ENABLE);
  595 }
  597 /*
  598  * Set up registers after a reset.
  599  */
  600 void
ess_setup(sc)
  602         struct ess_softc *sc;
  603 {
ess_config_irq(sc);
ess_config_drq(sc);
DPRINTFN(2,("ess_setup: done\n"));
  609 }
  611 /*
  612  * Determine the model of ESS chip we are talking to.  Currently we
  613  * only support ES1888, ES1887 and ES888.  The method of determining
  614  * the chip is based on the information on page 27 of the ES1887 data
  615  * sheet.
  616  *
  617  * This routine sets the values of sc->sc_model and sc->sc_version.
  618  */
  619 int
ess_identify(sc)
  621         struct ess_softc *sc;
  622 {
u_char reg1;
u_char reg2;
u_char reg3;
u_int8_t ident[4];
sc->sc_model = ESS_UNSUPPORTED;
sc->sc_version = 0;
memset(ident, 0, sizeof(ident));
  633         /*
  634          * 1. Check legacy ID bytes.  These should be 0x68 0x8n, where
  635          *    n >= 8 for an ES1887 or an ES888.  Other values indicate
  636          *    earlier (unsupported) chips.
  637          */
ess_wdsp(sc, ESS_ACMD_LEGACY_ID);
  640         if ((reg1 = ess_rdsp(sc)) != 0x68) {
printf("ess: First ID byte wrong (0x%02x)\n", reg1);
  642                 return 1;
  643         }
reg2 = ess_rdsp(sc);
  646         if (((reg2 & 0xf0) != 0x80) ||
  647             ((reg2 & 0x0f) < 8)) {
printf("ess: Second ID byte wrong (0x%02x)\n", reg2);
  649                 return 1;
  650         }
  652         /*
  653          * Store the ID bytes as the version.
  654          */
sc->sc_version = (reg1 << 8) + reg2;
  658         /*
  659          * 2. Verify we can change bit 2 in mixer register 0x64.  This
  660          *    should be possible on all supported chips.
  661          */
reg1 = ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL);
reg2 = reg1 ^ 0x04;  /* toggle bit 2 */
ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg2);
  667         if (ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL) != reg2) {
printf("ess: Hardware error (unable to toggle bit 2 of mixer register 0x64)\n");
  669                 return 1;
  670         }
  672         /*
  673          * Restore the original value of mixer register 0x64.
  674          */
ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg1);
  678         /*
  679          * 3. Verify we can change the value of mixer register
  680          *    ESS_MREG_SAMPLE_RATE.
  681          *    This is possible on the 1888/1887/888, but not on the 1788.
  682          *    It is not necessary to restore the value of this mixer register.
  683          */
reg1 = ess_read_mix_reg(sc, ESS_MREG_SAMPLE_RATE);
reg2 = reg1 ^ 0xff;  /* toggle all bits */
ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE, reg2);
  689         if (ess_read_mix_reg(sc, ESS_MREG_SAMPLE_RATE) != reg2) {
  690                 /* If we got this far before failing, it's a 1788. */
sc->sc_model = ESS_1788;
  693                 /*
  694                  * Identify ESS model for ES18[67]8.
  695                  */
ess_read_multi_mix_reg(sc, 0x40, ident, sizeof(ident));
  697                 if(ident[0] == 0x18) {
  698                         switch(ident[1]) {
  699                         case 0x68:
sc->sc_model = ESS_1868;
  701                                 break;
  702                         case 0x78:
sc->sc_model = ESS_1878;
  704                                 break;
  705                         }
  706                 }
  707         } else {
  708                 /*
  709                  * 4. Determine if we can change bit 5 in mixer register 0x64.
  710                  *    This determines whether we have an ES1887:
  711                  *
  712                  *    - can change indicates ES1887
  713                  *    - can't change indicates ES1888 or ES888
  714                  */
reg1 = ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL);
reg2 = reg1 ^ 0x20;  /* toggle bit 5 */
ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg2);
  720                 if (ess_read_mix_reg(sc, ESS_MREG_VOLUME_CTRL) == reg2) {
sc->sc_model = ESS_1887;
  723                         /*
  724                          * Restore the original value of mixer register 0x64.
  725                          */
ess_write_mix_reg(sc, ESS_MREG_VOLUME_CTRL, reg1);
  728                         /*
  729                          * Identify ESS model for ES18[67]9.
  730                          */
ess_read_multi_mix_reg(sc, 0x40, ident, sizeof(ident));
  732                         if(ident[0] == 0x18) {
  733                                 switch(ident[1]) {
  734                                 case 0x69:
sc->sc_model = ESS_1869;
  736                                         break;
  737                                 case 0x79:
sc->sc_model = ESS_1879;
  739                                         break;
  740                                 }
  741                         }
  742                 } else {
  743                         /*
  744                          * 5. Determine if we can change the value of mixer
  745                          *    register 0x69 independently of mixer register
  746                          *    0x68. This determines which chip we have:
  747                          *
  748                          *    - can modify idependently indicates ES888
  749                          *    - register 0x69 is an alias of 0x68 indicates ES1888
  750                          */
reg1 = ess_read_mix_reg(sc, 0x68);
reg2 = ess_read_mix_reg(sc, 0x69);
reg3 = reg2 ^ 0xff;  /* toggle all bits */
  755                         /*
  756                          * Write different values to each register.
  757                          */
ess_write_mix_reg(sc, 0x68, reg2);
ess_write_mix_reg(sc, 0x69, reg3);
  761                         if (ess_read_mix_reg(sc, 0x68) == reg2 &&
ess_read_mix_reg(sc, 0x69) == reg3)
sc->sc_model = ESS_888;
  764                         else
sc->sc_model = ESS_1888;
  767                         /*
  768                          * Restore the original value of the registers.
  769                          */
ess_write_mix_reg(sc, 0x68, reg1);
ess_write_mix_reg(sc, 0x69, reg2);
  772                 }
  773         }
  775         return 0;
  776 }
  779 int
ess_setup_sc(sc, doinit)
  781         struct ess_softc *sc;
  782         int doinit;
  783 {
  784         /* Reset the chip. */
  785         if (ess_reset(sc) != 0) {
DPRINTF(("ess_setup_sc: couldn't reset chip\n"));
  787                 return (1);
  788         }
  790         /* Identify the ESS chip, and check that it is supported. */
  791         if (ess_identify(sc)) {
DPRINTF(("ess_setup_sc: couldn't identify\n"));
  793                 return (1);
  794         }
  796         return (0);
  797 }
  799 /*
  800  * Probe for the ESS hardware.
  801  */
  802 int
essmatch(sc)
  804         struct ess_softc *sc;
  805 {
  806         if (!ESS_BASE_VALID(sc->sc_iobase)) {
printf("ess: configured iobase 0x%x invalid\n", sc->sc_iobase);
  808                 return (0);
  809         }
  811         /* Configure the ESS chip for the desired audio base address. */
  812         if (ess_config_addr(sc))
  813                 return (0);
  815         if (ess_setup_sc(sc, 1))
  816                 return (0);
  818         if (sc->sc_model == ESS_UNSUPPORTED) {
DPRINTF(("ess: Unsupported model\n"));
  820                 return (0);
  821         }
  823         /* Check that requested DMA channels are valid and different. */
  824         if (!ESS_DRQ1_VALID(sc->sc_audio1.drq)) {
printf("ess: record drq %d invalid\n", sc->sc_audio1.drq);
  826                 return (0);
  827         }
  828         if (!isa_drq_isfree(sc->sc_isa, sc->sc_audio1.drq))
  829                 return (0);
  830         if (!ESS_USE_AUDIO1(sc->sc_model)) {
  831                 if (!ESS_DRQ2_VALID(sc->sc_audio2.drq)) {
printf("ess: play drq %d invalid\n", sc->sc_audio2.drq);
  833                         return (0);
  834                 }
  835                 if (sc->sc_audio1.drq == sc->sc_audio2.drq) {
printf("ess: play and record drq both %d\n",
sc->sc_audio1.drq);
  838                         return (0);
  839                 }
  840                 if (!isa_drq_isfree(sc->sc_isa, sc->sc_audio2.drq))
  841                         return (0);
  842         }
  844         /*
  845          * The 1887 has an additional IRQ mode where both channels are mapped
  846          * to the same IRQ.
  847          */
  848         if (sc->sc_model == ESS_1887 &&
sc->sc_audio1.irq == sc->sc_audio2.irq &&
sc->sc_audio1.irq != -1 &&
ESS_IRQ12_VALID(sc->sc_audio1.irq))
  852                 goto irq_not1888;
  854         /* Check that requested IRQ lines are valid and different. */
  855         if (sc->sc_audio1.irq != -1 &&
  856             !ESS_IRQ1_VALID(sc->sc_audio1.irq)) {
printf("ess: record irq %d invalid\n", sc->sc_audio1.irq);
  858                 return (0);
  859         }
  860         if (!ESS_USE_AUDIO1(sc->sc_model)) {
  861                 if (sc->sc_audio2.irq != -1 &&
  862                     !ESS_IRQ2_VALID(sc->sc_audio2.irq)) {
printf("ess: play irq %d invalid\n", sc->sc_audio2.irq);
  864                         return (0);
  865                 }
  866                 if (sc->sc_audio1.irq == sc->sc_audio2.irq &&
sc->sc_audio1.irq != -1) {
printf("ess: play and record irq both %d\n",
sc->sc_audio1.irq);
  870                         return (0);
  871                 }
  872         }
irq_not1888:
  875         /* XXX should we check IRQs as well? */
  877         return (1);
  878 }
  881 /*
  882  * Attach hardware to driver, attach hardware driver to audio
  883  * pseudo-device driver.
  884  */
  885 void
essattach(sc)
  887         struct ess_softc *sc;
  888 {
  889         struct audio_attach_args arg;
  890         struct audio_params pparams, rparams;
  891         int i;
u_int v;
  894         if (ess_setup_sc(sc, 0)) {
printf(": setup failed\n");
  896                 return;
  897         }
printf(": ESS Technology ES%s [version 0x%04x]\n",
essmodel[sc->sc_model], sc->sc_version);
sc->sc_audio1.polled = sc->sc_audio1.irq == -1;
  903         if (!sc->sc_audio1.polled) {
sc->sc_audio1.ih = isa_intr_establish(sc->sc_ic,
sc->sc_audio1.irq, sc->sc_audio1.ist, IPL_AUDIO,
ess_audio1_intr, sc, sc->sc_dev.dv_xname);
printf("%s: audio1 interrupting at irq %d\n",
sc->sc_dev.dv_xname, sc->sc_audio1.irq);
  909         } else
printf("%s: audio1 polled\n", sc->sc_dev.dv_xname);
  911         if (isa_dmamap_create(sc->sc_isa, sc->sc_audio1.drq,
MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
printf("%s: can't create map for drq %d\n",
sc->sc_dev.dv_xname, sc->sc_audio1.drq);
  915                 return;
  916         }
  918         if (!ESS_USE_AUDIO1(sc->sc_model)) {
sc->sc_audio2.polled = sc->sc_audio2.irq == -1;
  920                 if (!sc->sc_audio2.polled) {
sc->sc_audio2.ih = isa_intr_establish(sc->sc_ic,
sc->sc_audio2.irq, sc->sc_audio2.ist, IPL_AUDIO,
ess_audio2_intr, sc, sc->sc_dev.dv_xname);
printf("%s: audio2 interrupting at irq %d\n",
sc->sc_dev.dv_xname, sc->sc_audio2.irq);
  926                 } else
printf("%s: audio2 polled\n", sc->sc_dev.dv_xname);
  928                 if (isa_dmamap_create(sc->sc_isa, sc->sc_audio2.drq,
MAX_ISADMA, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
printf("%s: can't create map for drq %d\n",
sc->sc_dev.dv_xname, sc->sc_audio2.drq);
  932                         return;
  933                 }
  934         }
timeout_set(&sc->sc_tmo1, ess_audio1_poll, sc);
timeout_set(&sc->sc_tmo2, ess_audio2_poll, sc);
  939         /*
  940          * Set record and play parameters to default values defined in
  941          * generic audio driver.
  942          */
pparams = audio_default;
rparams = audio_default;
ess_set_params(sc, AUMODE_RECORD|AUMODE_PLAY, 0, &pparams, &rparams);
  947         /* Do a hardware reset on the mixer. */
ess_write_mix_reg(sc, ESS_MIX_RESET, ESS_MIX_RESET);
  950         /*
  951          * Set volume of Audio 1 to zero and disable Audio 1 DAC input
  952          * to playback mixer, since playback is always through Audio 2.
  953          */
  954         if (!ESS_USE_AUDIO1(sc->sc_model))
ess_write_mix_reg(sc, ESS_MREG_VOLUME_VOICE, 0);
ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);
  958         if (ESS_USE_AUDIO1(sc->sc_model)) {
ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIC);
sc->in_port = ESS_SOURCE_MIC;
sc->ndevs = ESS_1788_NDEVS;
  962         } else {
  963                 /*
  964                  * Set hardware record source to use output of the record
  965                  * mixer. We do the selection of record source in software by
  966                  * setting the gain of the unused sources to zero. (See
  967                  * ess_set_in_ports.)
  968                  */
ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ESS_SOURCE_MIXER);
sc->in_mask = 1 << ESS_MIC_REC_VOL;
sc->ndevs = ESS_1888_NDEVS;
ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2, 0x10);
ess_set_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL2, 0x08);
  974         }
  976         /*
  977          * Set gain on each mixer device to a sensible value.
  978          * Devices not normally used are turned off, and other devices
  979          * are set to 50% volume.
  980          */
  981         for (i = 0; i < sc->ndevs; i++) {
  982                 switch (i) {
  983                 case ESS_MIC_PLAY_VOL:
  984                 case ESS_LINE_PLAY_VOL:
  985                 case ESS_CD_PLAY_VOL:
  986                 case ESS_AUXB_PLAY_VOL:
  987                 case ESS_DAC_REC_VOL:
  988                 case ESS_LINE_REC_VOL:
  989                 case ESS_SYNTH_REC_VOL:
  990                 case ESS_CD_REC_VOL:
  991                 case ESS_AUXB_REC_VOL:
v = 0;
  993                         break;
  994                 default:
v = ESS_4BIT_GAIN(AUDIO_MAX_GAIN / 2);
  996                         break;
  997                 }
sc->gain[i][ESS_LEFT] = sc->gain[i][ESS_RIGHT] = v;
ess_set_gain(sc, i, 1);
 1000         }
ess_setup(sc);
 1004         /* Disable the speaker until the device is opened.  */
ess_speaker_off(sc);
sc->spkr_state = SPKR_OFF;
snprintf(ess_device.name, sizeof ess_device.name, "ES%s",
essmodel[sc->sc_model]);
snprintf(ess_device.version, sizeof ess_device.version, "0x%04x",
sc->sc_version);
 1013         if (ESS_USE_AUDIO1(sc->sc_model))
audio_attach_mi(&ess_1788_hw_if, sc, &sc->sc_dev);
 1015         else
audio_attach_mi(&ess_1888_hw_if, sc, &sc->sc_dev);
arg.type = AUDIODEV_TYPE_OPL;
arg.hwif = 0;
arg.hdl = 0;
 1021         (void)config_found(&sc->sc_dev, &arg, audioprint);
 1023 #ifdef AUDIO_DEBUG
 1024         if (essdebug > 0)
ess_printsc(sc);
 1026 #endif
 1027 }
 1029 /*
 1030  * Various routines to interface to higher level audio driver
 1031  */
 1033 int
ess_open(addr, flags)
 1035         void *addr;
 1036         int flags;
 1037 {
 1038         struct ess_softc *sc = addr;
DPRINTF(("ess_open: sc=%p\n", sc));
 1042         if (sc->sc_open != 0 || ess_reset(sc) != 0)
 1043                 return ENXIO;
ess_setup(sc);          /* because we did a reset */
sc->sc_open = 1;
DPRINTF(("ess_open: opened\n"));
 1051         return (0);
 1052 }
 1054 void
ess_1788_close(addr)
 1056         void *addr;
 1057 {
 1058         struct ess_softc *sc = addr;
DPRINTF(("ess_1788_close: sc=%p\n", sc));
ess_speaker_off(sc);
sc->spkr_state = SPKR_OFF;
ess_audio1_halt(sc);
sc->sc_open = 0;
DPRINTF(("ess_1788_close: closed\n"));
 1069 }
 1071 void
ess_1888_close(addr)
 1073         void *addr;
 1074 {
 1075         struct ess_softc *sc = addr;
DPRINTF(("ess_1888_close: sc=%p\n", sc));
ess_speaker_off(sc);
sc->spkr_state = SPKR_OFF;
ess_audio1_halt(sc);
ess_audio2_halt(sc);
sc->sc_open = 0;
DPRINTF(("ess_1888_close: closed\n"));
 1087 }
 1089 /*
 1090  * Wait for FIFO to drain, and analog section to settle.
 1091  * XXX should check FIFO empty bit.
 1092  */
 1093 int
ess_drain(addr)
 1095         void *addr;
 1096 {
tsleep(addr, PWAIT | PCATCH, "essdr", hz/20); /* XXX */
 1098         return (0);
 1099 }
 1101 /* XXX should use reference count */
 1102 int
ess_speaker_ctl(addr, newstate)
 1104         void *addr;
 1105         int newstate;
 1106 {
 1107         struct ess_softc *sc = addr;
 1109         if ((newstate == SPKR_ON) && (sc->spkr_state == SPKR_OFF)) {
ess_speaker_on(sc);
sc->spkr_state = SPKR_ON;
 1112         }
 1113         if ((newstate == SPKR_OFF) && (sc->spkr_state == SPKR_ON)) {
ess_speaker_off(sc);
sc->spkr_state = SPKR_OFF;
 1116         }
 1117         return (0);
 1118 }
 1120 int
ess_getdev(addr, retp)
 1122         void *addr;
 1123         struct audio_device *retp;
 1124 {
 1125         *retp = ess_device;
 1126         return (0);
 1127 }
 1129 int
ess_query_encoding(addr, fp)
 1131         void *addr;
 1132         struct audio_encoding *fp;
 1133 {
 1134         /*struct ess_softc *sc = addr;*/
 1136         switch (fp->index) {
 1137         case 0:
strlcpy(fp->name, AudioEulinear, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR;
fp->precision = 8;
fp->flags = 0;
 1142                 return (0);
 1143         case 1:
strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULAW;
fp->precision = 8;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 1148                 return (0);
 1149         case 2:
strlcpy(fp->name, AudioEalaw, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ALAW;
fp->precision = 8;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 1154                 return (0);
 1155         case 3:
strlcpy(fp->name, AudioEslinear, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR;
fp->precision = 8;
fp->flags = 0;
 1160                 return (0);
 1161         case 4:
strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
fp->precision = 16;
fp->flags = 0;
 1166                 return (0);
 1167         case 5:
strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
fp->precision = 16;
fp->flags = 0;
 1172                 return (0);
 1173         case 6:
strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
fp->precision = 16;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 1178                 return (0);
 1179         case 7:
strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
fp->precision = 16;
fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
 1184                 return (0);
 1185         default:
 1186                 return EINVAL;
 1187         }
 1188         return (0);
 1189 }
 1191 int
ess_set_params(addr, setmode, usemode, play, rec)
 1193         void *addr;
 1194         int setmode, usemode;
 1195         struct audio_params *play, *rec;
 1196 {
 1197         struct ess_softc *sc = addr;
 1198         struct audio_params *p;
 1199         int mode;
 1200         int rate;
DPRINTF(("ess_set_params: set=%d use=%d\n", setmode, usemode));
 1204         /*
 1205          * The ES1887 manual (page 39, `Full-Duplex DMA Mode') claims that in
 1206          * full-duplex operation the sample rates must be the same for both
 1207          * channels.  This appears to be false; the only bit in common is the
 1208          * clock source selection.  However, we'll be conservative here.
 1209          * - mycroft
 1210          */
 1211         if (play->sample_rate != rec->sample_rate &&
usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
 1213                 if (setmode == AUMODE_PLAY) {
rec->sample_rate = play->sample_rate;
setmode |= AUMODE_RECORD;
 1216                 } else if (setmode == AUMODE_RECORD) {
play->sample_rate = rec->sample_rate;
setmode |= AUMODE_PLAY;
 1219                 } else
 1220                         return (EINVAL);
 1221         }
 1223         for (mode = AUMODE_RECORD; mode != -1;
mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
 1225                 if ((setmode & mode) == 0)
 1226                         continue;
p = mode == AUMODE_PLAY ? play : rec;
 1230                 if (p->sample_rate < ESS_MINRATE ||
p->sample_rate > ESS_MAXRATE ||
 1232                     (p->precision != 8 && p->precision != 16) ||
 1233                     (p->channels != 1 && p->channels != 2))
 1234                         return (EINVAL);
p->factor = 1;
p->sw_code = 0;
 1238                 switch (p->encoding) {
 1239                 case AUDIO_ENCODING_SLINEAR_BE:
 1240                 case AUDIO_ENCODING_ULINEAR_BE:
 1241                         if (p->precision == 16)
p->sw_code = swap_bytes;
 1243                         break;
 1244                 case AUDIO_ENCODING_SLINEAR_LE:
 1245                 case AUDIO_ENCODING_ULINEAR_LE:
 1246                         break;
 1247                 case AUDIO_ENCODING_ULAW:
 1248                         if (mode == AUMODE_PLAY) {
p->factor = 2;
p->sw_code = mulaw_to_ulinear16;
 1251                         } else
p->sw_code = ulinear8_to_mulaw;
 1253                         break;
 1254                 case AUDIO_ENCODING_ALAW:
 1255                         if (mode == AUMODE_PLAY) {
p->factor = 2;
p->sw_code = alaw_to_ulinear16;
 1258                         } else
p->sw_code = ulinear8_to_alaw;
 1260                         break;
 1261                 default:
 1262                         return (EINVAL);
 1263                 }
 1264         }
 1266         if (usemode == AUMODE_RECORD)
rate = rec->sample_rate;
 1268         else
rate = play->sample_rate;
ess_write_x_reg(sc, ESS_XCMD_SAMPLE_RATE, ess_srtotc(rate));
ess_write_x_reg(sc, ESS_XCMD_FILTER_CLOCK, ess_srtofc(rate));
 1274         if (!ESS_USE_AUDIO1(sc->sc_model)) {
ess_write_mix_reg(sc, ESS_MREG_SAMPLE_RATE, ess_srtotc(rate));
ess_write_mix_reg(sc, ESS_MREG_FILTER_CLOCK, ess_srtofc(rate));
 1277         }
 1279         return (0);
 1280 }
 1282 int
ess_audio1_trigger_output(addr, start, end, blksize, intr, arg, param)
 1284         void *addr;
 1285         void *start, *end;
 1286         int blksize;
 1287         void (*intr)(void *);
 1288         void *arg;
 1289         struct audio_params *param;
 1290 {
 1291         struct ess_softc *sc = addr;
u_int8_t reg;
DPRINTFN(1, ("ess_audio1_trigger_output: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
addr, start, end, blksize, intr, arg));
 1297         if (sc->sc_audio1.active)
panic("ess_audio1_trigger_output: already running");
sc->sc_audio1.active = 1;
sc->sc_audio1.intr = intr;
sc->sc_audio1.arg = arg;
 1303         if (sc->sc_audio1.polled) {
sc->sc_audio1.dmapos = 0;
sc->sc_audio1.buffersize = (char *)end - (char *)start;
sc->sc_audio1.dmacount = 0;
sc->sc_audio1.blksize = blksize;
timeout_add(&sc->sc_tmo1, hz/30);
 1309         }
reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL);
 1312         if (param->channels == 2) {
reg &= ~ESS_AUDIO_CTRL_MONO;
reg |= ESS_AUDIO_CTRL_STEREO;
 1315         } else {
reg |= ESS_AUDIO_CTRL_MONO;
reg &= ~ESS_AUDIO_CTRL_STEREO;
 1318         }
ess_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);
reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
 1322         if (param->precision * param->factor == 16)
reg |= ESS_AUDIO1_CTRL1_FIFO_SIZE;
 1324         else
reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIZE;
 1326         if (param->channels == 2)
reg |= ESS_AUDIO1_CTRL1_FIFO_STEREO;
 1328         else
reg &= ~ESS_AUDIO1_CTRL1_FIFO_STEREO;
 1330         if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
param->encoding == AUDIO_ENCODING_SLINEAR_LE)
reg |= ESS_AUDIO1_CTRL1_FIFO_SIGNED;
 1333         else
reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIGNED;
reg |= ESS_AUDIO1_CTRL1_FIFO_CONNECT;
ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);
isa_dmastart(sc->sc_isa, sc->sc_audio1.drq, start,
 1339                      (char *)end - (char *)start, NULL,
DMAMODE_WRITE | DMAMODE_LOOP, BUS_DMA_NOWAIT);
 1342         /* Program transfer count registers with 2's complement of count. */
blksize = -blksize;
ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTLO, blksize);
ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTHI, blksize >> 8);
 1347         /* Use 4 bytes per output DMA. */
ess_set_xreg_bits(sc, ESS_XCMD_DEMAND_CTRL, ESS_DEMAND_CTRL_DEMAND_4);
 1350         /* Start auto-init DMA */
ess_wdsp(sc, ESS_ACMD_ENABLE_SPKR);
reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2);
reg &= ~(ESS_AUDIO1_CTRL2_DMA_READ | ESS_AUDIO1_CTRL2_ADC_ENABLE);
reg |= ESS_AUDIO1_CTRL2_FIFO_ENABLE | ESS_AUDIO1_CTRL2_AUTO_INIT;
ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);
 1357         return (0);
 1358 }
 1360 int
ess_audio2_trigger_output(addr, start, end, blksize, intr, arg, param)
 1362         void *addr;
 1363         void *start, *end;
 1364         int blksize;
 1365         void (*intr)(void *);
 1366         void *arg;
 1367         struct audio_params *param;
 1368 {
 1369         struct ess_softc *sc = addr;
u_int8_t reg;
DPRINTFN(1, ("ess_audio2_trigger_output: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
addr, start, end, blksize, intr, arg));
 1375         if (sc->sc_audio2.active)
panic("ess_audio2_trigger_output: already running");
sc->sc_audio2.active = 1;
sc->sc_audio2.intr = intr;
sc->sc_audio2.arg = arg;
 1381         if (sc->sc_audio2.polled) {
sc->sc_audio2.dmapos = 0;
sc->sc_audio2.buffersize = (char *)end - (char *)start;
sc->sc_audio2.dmacount = 0;
sc->sc_audio2.blksize = blksize;
timeout_add(&sc->sc_tmo2, hz/30);
 1387         }
reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
 1390         if (param->precision * param->factor == 16)
reg |= ESS_AUDIO2_CTRL2_FIFO_SIZE;
 1392         else
reg &= ~ESS_AUDIO2_CTRL2_FIFO_SIZE;
 1394         if (param->channels == 2)
reg |= ESS_AUDIO2_CTRL2_CHANNELS;
 1396         else
reg &= ~ESS_AUDIO2_CTRL2_CHANNELS;
 1398         if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
param->encoding == AUDIO_ENCODING_SLINEAR_LE)
reg |= ESS_AUDIO2_CTRL2_FIFO_SIGNED;
 1401         else
reg &= ~ESS_AUDIO2_CTRL2_FIFO_SIGNED;
ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2, reg);
isa_dmastart(sc->sc_isa, sc->sc_audio2.drq, start,
 1406                      (char *)end - (char *)start, NULL,
DMAMODE_WRITE | DMAMODE_LOOP, BUS_DMA_NOWAIT);
 1409         if (IS16BITDRQ(sc->sc_audio2.drq))
blksize >>= 1;  /* use word count for 16 bit DMA */
 1411         /* Program transfer count registers with 2's complement of count. */
blksize = -blksize;
ess_write_mix_reg(sc, ESS_MREG_XFER_COUNTLO, blksize);
ess_write_mix_reg(sc, ESS_MREG_XFER_COUNTHI, blksize >> 8);
reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL1);
 1417         if (IS16BITDRQ(sc->sc_audio2.drq))
reg |= ESS_AUDIO2_CTRL1_XFER_SIZE;
 1419         else
reg &= ~ESS_AUDIO2_CTRL1_XFER_SIZE;
reg |= ESS_AUDIO2_CTRL1_DEMAND_8;
reg |= ESS_AUDIO2_CTRL1_DAC_ENABLE | ESS_AUDIO2_CTRL1_FIFO_ENABLE |
ESS_AUDIO2_CTRL1_AUTO_INIT;
ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL1, reg);
 1426         return (0);
 1427 }
 1429 int
ess_audio1_trigger_input(addr, start, end, blksize, intr, arg, param)
 1431         void *addr;
 1432         void *start, *end;
 1433         int blksize;
 1434         void (*intr)(void *);
 1435         void *arg;
 1436         struct audio_params *param;
 1437 {
 1438         struct ess_softc *sc = addr;
u_int8_t reg;
DPRINTFN(1, ("ess_audio1_trigger_input: sc=%p start=%p end=%p blksize=%d intr=%p(%p)\n",
addr, start, end, blksize, intr, arg));
 1444         if (sc->sc_audio1.active)
panic("ess_audio1_trigger_input: already running");
sc->sc_audio1.active = 1;
sc->sc_audio1.intr = intr;
sc->sc_audio1.arg = arg;
 1450         if (sc->sc_audio1.polled) {
sc->sc_audio1.dmapos = 0;
sc->sc_audio1.buffersize = (char *)end - (char *)start;
sc->sc_audio1.dmacount = 0;
sc->sc_audio1.blksize = blksize;
timeout_add(&sc->sc_tmo1, hz/30);
 1456         }
reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL);
 1459         if (param->channels == 2) {
reg &= ~ESS_AUDIO_CTRL_MONO;
reg |= ESS_AUDIO_CTRL_STEREO;
 1462         } else {
reg |= ESS_AUDIO_CTRL_MONO;
reg &= ~ESS_AUDIO_CTRL_STEREO;
 1465         }
ess_write_x_reg(sc, ESS_XCMD_AUDIO_CTRL, reg);
reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1);
 1469         if (param->precision * param->factor == 16)
reg |= ESS_AUDIO1_CTRL1_FIFO_SIZE;
 1471         else
reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIZE;
 1473         if (param->channels == 2)
reg |= ESS_AUDIO1_CTRL1_FIFO_STEREO;
 1475         else
reg &= ~ESS_AUDIO1_CTRL1_FIFO_STEREO;
 1477         if (param->encoding == AUDIO_ENCODING_SLINEAR_BE ||
param->encoding == AUDIO_ENCODING_SLINEAR_LE)
reg |= ESS_AUDIO1_CTRL1_FIFO_SIGNED;
 1480         else
reg &= ~ESS_AUDIO1_CTRL1_FIFO_SIGNED;
reg |= ESS_AUDIO1_CTRL1_FIFO_CONNECT;
ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL1, reg);
isa_dmastart(sc->sc_isa, sc->sc_audio1.drq, start,
 1486                      (char *)end - (char *)start, NULL,
DMAMODE_READ | DMAMODE_LOOP, BUS_DMA_NOWAIT);
 1489         /* Program transfer count registers with 2's complement of count. */
blksize = -blksize;
ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTLO, blksize);
ess_write_x_reg(sc, ESS_XCMD_XFER_COUNTHI, blksize >> 8);
 1494         /* Use 4 bytes per input DMA. */
ess_set_xreg_bits(sc, ESS_XCMD_DEMAND_CTRL, ESS_DEMAND_CTRL_DEMAND_4);
 1497         /* Start auto-init DMA */
ess_wdsp(sc, ESS_ACMD_DISABLE_SPKR);
reg = ess_read_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2);
reg |= ESS_AUDIO1_CTRL2_DMA_READ | ESS_AUDIO1_CTRL2_ADC_ENABLE;
reg |= ESS_AUDIO1_CTRL2_FIFO_ENABLE | ESS_AUDIO1_CTRL2_AUTO_INIT;
ess_write_x_reg(sc, ESS_XCMD_AUDIO1_CTRL2, reg);
 1504         return (0);
 1505 }
 1507 int
ess_audio1_halt(addr)
 1509         void *addr;
 1510 {
 1511         struct ess_softc *sc = addr;
DPRINTF(("ess_audio1_halt: sc=%p\n", sc));
 1515         if (sc->sc_audio1.active) {
ess_clear_xreg_bits(sc, ESS_XCMD_AUDIO1_CTRL2,
ESS_AUDIO1_CTRL2_FIFO_ENABLE);
isa_dmaabort(sc->sc_isa, sc->sc_audio1.drq);
 1519                 if (sc->sc_audio1.polled)
timeout_del(&sc->sc_tmo1);
sc->sc_audio1.active = 0;
 1522         }
 1524         return (0);
 1525 }
 1527 int
ess_audio2_halt(addr)
 1529         void *addr;
 1530 {
 1531         struct ess_softc *sc = addr;
DPRINTF(("ess_audio2_halt: sc=%p\n", sc));
 1535         if (sc->sc_audio2.active) {
ess_clear_mreg_bits(sc, ESS_MREG_AUDIO2_CTRL1,
ESS_AUDIO2_CTRL1_DAC_ENABLE |
ESS_AUDIO2_CTRL1_FIFO_ENABLE);
isa_dmaabort(sc->sc_isa, sc->sc_audio2.drq);
 1540                 if (sc->sc_audio2.polled)
timeout_del(&sc->sc_tmo2);
sc->sc_audio2.active = 0;
 1543         }
 1545         return (0);
 1546 }
 1548 int
ess_audio1_intr(arg)
 1550         void *arg;
 1551 {
 1552         struct ess_softc *sc = arg;
u_int8_t reg;
DPRINTFN(1,("ess_audio1_intr: intr=%p\n", sc->sc_audio1.intr));
 1557         /* Check and clear interrupt on Audio1. */
reg = EREAD1(sc->sc_iot, sc->sc_ioh, ESS_DSP_RW_STATUS);
 1559         if ((reg & ESS_DSP_READ_OFLOW) == 0)
 1560                 return (0);
reg = EREAD1(sc->sc_iot, sc->sc_ioh, ESS_CLEAR_INTR);
sc->sc_audio1.nintr++;
 1565         if (sc->sc_audio1.active) {
 1566                 (*sc->sc_audio1.intr)(sc->sc_audio1.arg);
 1567                 return (1);
 1568         } else
 1569                 return (0);
 1570 }
 1572 int
ess_audio2_intr(arg)
 1574         void *arg;
 1575 {
 1576         struct ess_softc *sc = arg;
u_int8_t reg;
DPRINTFN(1,("ess_audio2_intr: intr=%p\n", sc->sc_audio2.intr));
 1581         /* Check and clear interrupt on Audio2. */
reg = ess_read_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2);
 1583         if ((reg & ESS_AUDIO2_CTRL2_IRQ_LATCH) == 0)
 1584                 return (0);
reg &= ~ESS_AUDIO2_CTRL2_IRQ_LATCH;
ess_write_mix_reg(sc, ESS_MREG_AUDIO2_CTRL2, reg);
sc->sc_audio2.nintr++;
 1590         if (sc->sc_audio2.active) {
 1591                 (*sc->sc_audio2.intr)(sc->sc_audio2.arg);
 1592                 return (1);
 1593         } else
 1594                 return (0);
 1595 }
 1597 void
ess_audio1_poll(addr)
 1599         void *addr;
 1600 {
 1601         struct ess_softc *sc = addr;
 1602         int dmapos, dmacount;
 1604         if (!sc->sc_audio1.active)
 1605                 return;
sc->sc_audio1.nintr++;
dmapos = isa_dmacount(sc->sc_isa, sc->sc_audio1.drq);
dmacount = sc->sc_audio1.dmapos - dmapos;
 1611         if (dmacount < 0)
dmacount += sc->sc_audio1.buffersize;
sc->sc_audio1.dmapos = dmapos;
 1614 #if 1
dmacount += sc->sc_audio1.dmacount;
 1616         while (dmacount > sc->sc_audio1.blksize) {
dmacount -= sc->sc_audio1.blksize;
 1618                 (*sc->sc_audio1.intr)(sc->sc_audio1.arg);
 1619         }
sc->sc_audio1.dmacount = dmacount;
 1621 #else
 1622         (*sc->sc_audio1.intr)(sc->sc_audio1.arg, dmacount);
 1623 #endif
timeout_add(&sc->sc_tmo1, hz/30);
 1626 }
 1628 void
ess_audio2_poll(addr)
 1630         void *addr;
 1631 {
 1632         struct ess_softc *sc = addr;
 1633         int dmapos, dmacount;
 1635         if (!sc->sc_audio2.active)
 1636                 return;
sc->sc_audio2.nintr++;
dmapos = isa_dmacount(sc->sc_isa, sc->sc_audio2.drq);
dmacount = sc->sc_audio2.dmapos - dmapos;
 1642         if (dmacount < 0)
dmacount += sc->sc_audio2.buffersize;
sc->sc_audio2.dmapos = dmapos;
 1645 #if 1
dmacount += sc->sc_audio2.dmacount;
 1647         while (dmacount > sc->sc_audio2.blksize) {
dmacount -= sc->sc_audio2.blksize;
 1649                 (*sc->sc_audio2.intr)(sc->sc_audio2.arg);
 1650         }
sc->sc_audio2.dmacount = dmacount;
 1652 #else
 1653         (*sc->sc_audio2.intr)(sc->sc_audio2.arg, dmacount);
 1654 #endif
timeout_add(&sc->sc_tmo2, hz/30);
 1657 }
 1659 int
ess_round_blocksize(addr, blk)
 1661         void *addr;
 1662         int blk;
 1663 {
 1664         return ((blk + 7) & -8);        /* round for max DMA size */
 1665 }
 1667 int
ess_set_port(addr, cp)
 1669         void *addr;
mixer_ctrl_t *cp;
 1671 {
 1672         struct ess_softc *sc = addr;
 1673         int lgain, rgain;
DPRINTFN(5,("ess_set_port: port=%d num_channels=%d\n",
cp->dev, cp->un.value.num_channels));
 1678         switch (cp->dev) {
 1679         /*
 1680          * The following mixer ports are all stereo. If we get a
 1681          * single-channel gain value passed in, then we duplicate it
 1682          * to both left and right channels.
 1683          */
 1684         case ESS_MASTER_VOL:
 1685         case ESS_DAC_PLAY_VOL:
 1686         case ESS_MIC_PLAY_VOL:
 1687         case ESS_LINE_PLAY_VOL:
 1688         case ESS_SYNTH_PLAY_VOL:
 1689         case ESS_CD_PLAY_VOL:
 1690         case ESS_AUXB_PLAY_VOL:
 1691         case ESS_RECORD_VOL:
 1692                 if (cp->type != AUDIO_MIXER_VALUE)
 1693                         return EINVAL;
 1695                 switch (cp->un.value.num_channels) {
 1696                 case 1:
lgain = rgain = ESS_4BIT_GAIN(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
 1699                         break;
 1700                 case 2:
lgain = ESS_4BIT_GAIN(
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
rgain = ESS_4BIT_GAIN(
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
 1705                         break;
 1706                 default:
 1707                         return EINVAL;
 1708                 }
sc->gain[cp->dev][ESS_LEFT]  = lgain;
sc->gain[cp->dev][ESS_RIGHT] = rgain;
ess_set_gain(sc, cp->dev, 1);
 1713                 return (0);
 1715         /*
 1716          * The PC speaker port is mono. If we get a stereo gain value
 1717          * passed in, then we return EINVAL.
 1718          */
 1719         case ESS_PCSPEAKER_VOL:
 1720                 if (cp->un.value.num_channels != 1)
 1721                         return EINVAL;
sc->gain[cp->dev][ESS_LEFT] = sc->gain[cp->dev][ESS_RIGHT] =
ESS_3BIT_GAIN(cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
ess_set_gain(sc, cp->dev, 1);
 1726                 return (0);
 1728         case ESS_RECORD_SOURCE:
 1729                 if (ESS_USE_AUDIO1(sc->sc_model)) {
 1730                         if (cp->type == AUDIO_MIXER_ENUM)
 1731                                 return (ess_set_in_port(sc, cp->un.ord));
 1732                         else
 1733                                 return (EINVAL);
 1734                 } else {
 1735                         if (cp->type == AUDIO_MIXER_SET)
 1736                                 return (ess_set_in_ports(sc, cp->un.mask));
 1737                         else
 1738                                 return (EINVAL);
 1739                 }
 1740                 return (0);
 1742         case ESS_RECORD_MONITOR:
 1743                 if (cp->type != AUDIO_MIXER_ENUM)
 1744                         return EINVAL;
 1746                 if (cp->un.ord)
 1747                         /* Enable monitor */
ess_set_xreg_bits(sc, ESS_XCMD_AUDIO_CTRL,
ESS_AUDIO_CTRL_MONITOR);
 1750                 else
 1751                         /* Disable monitor */
ess_clear_xreg_bits(sc, ESS_XCMD_AUDIO_CTRL,
ESS_AUDIO_CTRL_MONITOR);
 1754                 return (0);
 1755         }
 1757         if (ESS_USE_AUDIO1(sc->sc_model))
 1758                 return (EINVAL);
 1760         switch (cp->dev) {
 1761         case ESS_DAC_REC_VOL:
 1762         case ESS_MIC_REC_VOL:
 1763         case ESS_LINE_REC_VOL:
 1764         case ESS_SYNTH_REC_VOL:
 1765         case ESS_CD_REC_VOL:
 1766         case ESS_AUXB_REC_VOL:
 1767                 if (cp->type != AUDIO_MIXER_VALUE)
 1768                         return EINVAL;
 1770                 switch (cp->un.value.num_channels) {
 1771                 case 1:
lgain = rgain = ESS_4BIT_GAIN(
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
 1774                         break;
 1775                 case 2:
lgain = ESS_4BIT_GAIN(
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT]);
rgain = ESS_4BIT_GAIN(
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
 1780                         break;
 1781                 default:
 1782                         return EINVAL;
 1783                 }
sc->gain[cp->dev][ESS_LEFT]  = lgain;
sc->gain[cp->dev][ESS_RIGHT] = rgain;
ess_set_gain(sc, cp->dev, 1);
 1788                 return (0);
 1790         case ESS_MIC_PREAMP:
 1791                 if (cp->type != AUDIO_MIXER_ENUM)
 1792                         return EINVAL;
 1794                 if (cp->un.ord)
 1795                         /* Enable microphone preamp */
ess_set_xreg_bits(sc, ESS_XCMD_PREAMP_CTRL,
ESS_PREAMP_CTRL_ENABLE);
 1798                 else
 1799                         /* Disable microphone preamp */
ess_clear_xreg_bits(sc, ESS_XCMD_PREAMP_CTRL,
ESS_PREAMP_CTRL_ENABLE);
 1802                 return (0);
 1803         }
 1805         return (EINVAL);
 1806 }
 1808 int
ess_get_port(addr, cp)
 1810         void *addr;
mixer_ctrl_t *cp;
 1812 {
 1813         struct ess_softc *sc = addr;
DPRINTFN(5,("ess_get_port: port=%d\n", cp->dev));
 1817         switch (cp->dev) {
 1818         case ESS_MASTER_VOL:
 1819         case ESS_DAC_PLAY_VOL:
 1820         case ESS_MIC_PLAY_VOL:
 1821         case ESS_LINE_PLAY_VOL:
 1822         case ESS_SYNTH_PLAY_VOL:
 1823         case ESS_CD_PLAY_VOL:
 1824         case ESS_AUXB_PLAY_VOL:
 1825         case ESS_RECORD_VOL:
 1826                 switch (cp->un.value.num_channels) {
 1827                 case 1:
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
sc->gain[cp->dev][ESS_LEFT];
 1830                         break;
 1831                 case 2:
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
sc->gain[cp->dev][ESS_LEFT];
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
sc->gain[cp->dev][ESS_RIGHT];
 1836                         break;
 1837                 default:
 1838                         return EINVAL;
 1839                 }
 1840                 return (0);
 1842         case ESS_PCSPEAKER_VOL:
 1843                 if (cp->un.value.num_channels != 1)
 1844                         return EINVAL;
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
sc->gain[cp->dev][ESS_LEFT];
 1848                 return (0);
 1850         case ESS_RECORD_SOURCE:
 1851                 if (ESS_USE_AUDIO1(sc->sc_model))
cp->un.ord = sc->in_port;
 1853                 else
cp->un.mask = sc->in_mask;
 1855                 return (0);
 1857         case ESS_RECORD_MONITOR:
cp->un.ord = (ess_read_x_reg(sc, ESS_XCMD_AUDIO_CTRL) &
ESS_AUDIO_CTRL_MONITOR) ? 1 : 0;
 1860                 return (0);
 1861         }
 1863         if (ESS_USE_AUDIO1(sc->sc_model))
 1864                 return (EINVAL);
 1866         switch (cp->dev) {
 1867         case ESS_DAC_REC_VOL:
 1868         case ESS_MIC_REC_VOL:
 1869         case ESS_LINE_REC_VOL:
 1870         case ESS_SYNTH_REC_VOL:
 1871         case ESS_CD_REC_VOL:
 1872         case ESS_AUXB_REC_VOL:
 1873                 switch (cp->un.value.num_channels) {
 1874                 case 1:
cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
sc->gain[cp->dev][ESS_LEFT];
 1877                         break;
 1878                 case 2:
cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
sc->gain[cp->dev][ESS_LEFT];
cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
sc->gain[cp->dev][ESS_RIGHT];
 1883                         break;
 1884                 default:
 1885                         return EINVAL;
 1886                 }
 1887                 return (0);
 1889         case ESS_MIC_PREAMP:
cp->un.ord = (ess_read_x_reg(sc, ESS_XCMD_PREAMP_CTRL) &
ESS_PREAMP_CTRL_ENABLE) ? 1 : 0;
 1892                 return (0);
 1893         }
 1895         return (EINVAL);
 1896 }
 1898 int
ess_query_devinfo(addr, dip)
 1900         void *addr;
mixer_devinfo_t *dip;
 1902 {
 1903         struct ess_softc *sc = addr;
DPRINTFN(5,("ess_query_devinfo: model=%d index=%d\n",
sc->sc_model, dip->index));
 1908         /*
 1909          * REVISIT: There are some slight differences between the
 1910          *          mixers on the different ESS chips, which can
 1911          *          be sorted out using the chip model rather than a
 1912          *          separate mixer model.
 1913          *          This is currently coded assuming an ES1887; we
 1914          *          need to work out which bits are not applicable to
 1915          *          the other models (1888 and 888).
 1916          */
 1917         switch (dip->index) {
 1918         case ESS_DAC_PLAY_VOL:
dip->mixer_class = ESS_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1925                     sizeof dip->un.v.units.name);
 1926                 return (0);
 1928         case ESS_MIC_PLAY_VOL:
dip->mixer_class = ESS_INPUT_CLASS;
dip->prev = AUDIO_MIXER_LAST;
 1931                 if (ESS_USE_AUDIO1(sc->sc_model))
dip->next = AUDIO_MIXER_LAST;
 1933                 else
dip->next = ESS_MIC_PREAMP;
strlcpy(dip->label.name, AudioNmicrophone,
 1936                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1940                     sizeof dip->un.v.units.name);
 1941                 return (0);
 1943         case ESS_LINE_PLAY_VOL:
dip->mixer_class = ESS_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1950                     sizeof dip->un.v.units.name);
 1951                 return (0);
 1953         case ESS_SYNTH_PLAY_VOL:
dip->mixer_class = ESS_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNfmsynth,
 1957                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1961                     sizeof dip->un.v.units.name);
 1962                 return (0);
 1964         case ESS_CD_PLAY_VOL:
dip->mixer_class = ESS_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1971                     sizeof dip->un.v.units.name);
 1972                 return (0);
 1974         case ESS_AUXB_PLAY_VOL:
dip->mixer_class = ESS_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "auxb", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1981                     sizeof dip->un.v.units.name);
 1982                 return (0);
 1984         case ESS_INPUT_CLASS:
dip->mixer_class = ESS_INPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 1989                 return (0);
 1991         case ESS_MASTER_VOL:
dip->mixer_class = ESS_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 1998                     sizeof dip->un.v.units.name);
 1999                 return (0);
 2001         case ESS_PCSPEAKER_VOL:
dip->mixer_class = ESS_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "pc_speaker", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 1;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2008                     sizeof dip->un.v.units.name);
 2009                 return (0);
 2011         case ESS_OUTPUT_CLASS:
dip->mixer_class = ESS_OUTPUT_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 2016                 return (0);
 2018         case ESS_RECORD_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2025                     sizeof dip->un.v.units.name);
 2026                 return (0);
 2028         case ESS_RECORD_SOURCE:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
 2032                 if (ESS_USE_AUDIO1(sc->sc_model)) {
 2033                         /*
 2034                          * The 1788 doesn't use the input mixer control that
 2035                          * the 1888 uses, because it's a pain when you only
 2036                          * have one mixer.
 2037                          * Perhaps it could be emulated by keeping both sets of
 2038                          * gain values, and doing a `context switch' of the
 2039                          * mixer registers when shifting from playing to
 2040                          * recording.
 2041                          */
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 4;
strlcpy(dip->un.e.member[0].label.name,
AudioNmicrophone,
 2046                             sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = ESS_SOURCE_MIC;
strlcpy(dip->un.e.member[1].label.name, AudioNline,
 2049                             sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = ESS_SOURCE_LINE;
strlcpy(dip->un.e.member[2].label.name, AudioNcd,
 2052                             sizeof dip->un.e.member[2].label.name);
dip->un.e.member[2].ord = ESS_SOURCE_CD;
strlcpy(dip->un.e.member[3].label.name, AudioNmixerout,
 2055                             sizeof dip->un.e.member[3].label.name);
dip->un.e.member[3].ord = ESS_SOURCE_MIXER;
 2057                 } else {
dip->type = AUDIO_MIXER_SET;
dip->un.s.num_mem = 6;
strlcpy(dip->un.s.member[0].label.name, AudioNdac,
 2061                             sizeof dip->un.e.member[0].label.name);
dip->un.s.member[0].mask = 1 << ESS_DAC_REC_VOL;
strlcpy(dip->un.s.member[1].label.name,
AudioNmicrophone,
 2065                             sizeof dip->un.e.member[1].label.name);
dip->un.s.member[1].mask = 1 << ESS_MIC_REC_VOL;
strlcpy(dip->un.s.member[2].label.name, AudioNline,
 2068                             sizeof dip->un.e.member[2].label.name);
dip->un.s.member[2].mask = 1 << ESS_LINE_REC_VOL;
strlcpy(dip->un.s.member[3].label.name, AudioNfmsynth,
 2071                             sizeof dip->un.e.member[3].label.name);
dip->un.s.member[3].mask = 1 << ESS_SYNTH_REC_VOL;
strlcpy(dip->un.s.member[4].label.name, AudioNcd,
 2074                             sizeof dip->un.e.member[4].label.name);
dip->un.s.member[4].mask = 1 << ESS_CD_REC_VOL;
strlcpy(dip->un.s.member[5].label.name, "auxb",
 2077                             sizeof dip->un.e.member[5].label.name);
dip->un.s.member[5].mask = 1 << ESS_AUXB_REC_VOL;
 2079                 }
 2080                 return (0);
 2082         case ESS_RECORD_CLASS:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 2087                 return (0);
 2089         case ESS_RECORD_MONITOR:
dip->prev = dip->next = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->mixer_class = ESS_MONITOR_CLASS;
dip->un.e.num_mem = 2;
strlcpy(dip->un.e.member[0].label.name, AudioNoff,
 2096                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = 0;
strlcpy(dip->un.e.member[1].label.name, AudioNon,
 2099                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = 1;
 2101                 return (0);
 2103         case ESS_MONITOR_CLASS:
dip->mixer_class = ESS_MONITOR_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioCmonitor,
 2107                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_CLASS;
 2109                 return (0);
 2110         }
 2112         if (ESS_USE_AUDIO1(sc->sc_model))
 2113                 return (ENXIO);
 2115         switch (dip->index) {
 2116         case ESS_DAC_REC_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2123                     sizeof dip->un.v.units.name);
 2124                 return (0);
 2126         case ESS_MIC_REC_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNmicrophone,
 2130                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2134                     sizeof dip->un.v.units.name);
 2135                 return (0);
 2137         case ESS_LINE_REC_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2144                     sizeof dip->un.v.units.name);
 2145                 return (0);
 2147         case ESS_SYNTH_REC_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNfmsynth,
 2151                     sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2155                     sizeof dip->un.v.units.name);
 2156                 return (0);
 2158         case ESS_CD_REC_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2165                     sizeof dip->un.v.units.name);
 2166                 return (0);
 2168         case ESS_AUXB_REC_VOL:
dip->mixer_class = ESS_RECORD_CLASS;
dip->next = dip->prev = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, "auxb", sizeof dip->label.name);
dip->type = AUDIO_MIXER_VALUE;
dip->un.v.num_channels = 2;
strlcpy(dip->un.v.units.name, AudioNvolume,
 2175                     sizeof dip->un.v.units.name);
 2176                 return (0);
 2178         case ESS_MIC_PREAMP:
dip->mixer_class = ESS_INPUT_CLASS;
dip->prev = ESS_MIC_PLAY_VOL;
dip->next = AUDIO_MIXER_LAST;
strlcpy(dip->label.name, AudioNpreamp, sizeof dip->label.name);
dip->type = AUDIO_MIXER_ENUM;
dip->un.e.num_mem = 2;
strlcpy(dip->un.e.member[0].label.name, AudioNoff,
 2186                     sizeof dip->un.e.member[0].label.name);
dip->un.e.member[0].ord = 0;
strlcpy(dip->un.e.member[1].label.name, AudioNon,
 2189                     sizeof dip->un.e.member[1].label.name);
dip->un.e.member[1].ord = 1;
 2191                 return (0);
 2192         }
 2194         return (ENXIO);
 2195 }
 2197 void *
ess_malloc(addr, direction, size, pool, flags)
 2199         void *addr;
 2200         int direction;
size_t size;
 2202         int pool, flags;
 2203 {
 2204         struct ess_softc *sc = addr;
 2205         int drq;
 2207         if (!ESS_USE_AUDIO1(sc->sc_model))
drq = sc->sc_audio2.drq;
 2209         else
drq = sc->sc_audio1.drq;
 2211         return (isa_malloc(sc->sc_isa, drq, size, pool, flags));
 2212 }
 2214 void
ess_free(addr, ptr, pool)
 2216         void *addr;
 2217         void *ptr;
 2218         int pool;
 2219 {
isa_free(ptr, pool);
 2221 }
size_t
ess_round_buffersize(addr, direction, size)
 2225         void *addr;
 2226         int direction;
size_t size;
 2228 {
 2229         if (size > MAX_ISADMA)
size = MAX_ISADMA;
 2231         return (size);
 2232 }
paddr_t
ess_mappage(addr, mem, off, prot)
 2236         void *addr;
 2237         void *mem;
off_t off;
 2239         int prot;
 2240 {
 2241         return (isa_mappage(mem, off, prot));
 2242 }
 2244 int
ess_1788_get_props(addr)
 2246         void *addr;
 2247 {
 2249         return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT);
 2250 }
 2252 int
ess_1888_get_props(addr)
 2254         void *addr;
 2255 {
 2257         return (AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX);
 2258 }
 2260 /* ============================================
 2261  * Generic functions for ess, not used by audio h/w i/f
 2262  * =============================================
 2263  */
 2265 /*
 2266  * Reset the chip.
 2267  * Return non-zero if the chip isn't detected.
 2268  */
 2269 int
ess_reset(sc)
 2271         struct ess_softc *sc;
 2272 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
sc->sc_audio1.active = 0;
sc->sc_audio2.active = 0;
EWRITE1(iot, ioh, ESS_DSP_RESET, ESS_RESET_EXT);
delay(10000);
EWRITE1(iot, ioh, ESS_DSP_RESET, 0);
 2282         if (ess_rdsp(sc) != ESS_MAGIC)
 2283                 return (1);
 2285         /* Enable access to the ESS extension commands. */
ess_wdsp(sc, ESS_ACMD_ENABLE_EXT);
 2288         return (0);
 2289 }
 2291 void
ess_set_gain(sc, port, on)
 2293         struct ess_softc *sc;
 2294         int port;
 2295         int on;
 2296 {
 2297         int gain, left, right;
 2298         int mix;
 2299         int src;
 2300         int stereo;
 2302         /*
 2303          * Most gain controls are found in the mixer registers and
 2304          * are stereo. Any that are not, must set mix and stereo as
 2305          * required.
 2306          */
mix = 1;
stereo = 1;
 2310         switch (port) {
 2311         case ESS_MASTER_VOL:
src = ESS_MREG_VOLUME_MASTER;
 2313                 break;
 2314         case ESS_DAC_PLAY_VOL:
 2315                 if (ESS_USE_AUDIO1(sc->sc_model))
src = ESS_MREG_VOLUME_VOICE;
 2317                 else
src = 0x7C;
 2319                 break;
 2320         case ESS_MIC_PLAY_VOL:
src = ESS_MREG_VOLUME_MIC;
 2322                 break;
 2323         case ESS_LINE_PLAY_VOL:
src = ESS_MREG_VOLUME_LINE;
 2325                 break;
 2326         case ESS_SYNTH_PLAY_VOL:
src = ESS_MREG_VOLUME_SYNTH;
 2328                 break;
 2329         case ESS_CD_PLAY_VOL:
src = ESS_MREG_VOLUME_CD;
 2331                 break;
 2332         case ESS_AUXB_PLAY_VOL:
src = ESS_MREG_VOLUME_AUXB;
 2334                 break;
 2335         case ESS_PCSPEAKER_VOL:
src = ESS_MREG_VOLUME_PCSPKR;
stereo = 0;
 2338                 break;
 2339         case ESS_DAC_REC_VOL:
src = 0x69;
 2341                 break;
 2342         case ESS_MIC_REC_VOL:
src = 0x68;
 2344                 break;
 2345         case ESS_LINE_REC_VOL:
src = 0x6E;
 2347                 break;
 2348         case ESS_SYNTH_REC_VOL:
src = 0x6B;
 2350                 break;
 2351         case ESS_CD_REC_VOL:
src = 0x6A;
 2353                 break;
 2354         case ESS_AUXB_REC_VOL:
src = 0x6C;
 2356                 break;
 2357         case ESS_RECORD_VOL:
src = ESS_XCMD_VOLIN_CTRL;
mix = 0;
 2360                 break;
 2361         default:
 2362                 return;
 2363         }
 2365         /* 1788 doesn't have a separate recording mixer */
 2366         if (ESS_USE_AUDIO1(sc->sc_model) && mix && src > 0x62)
 2367                 return;
 2369         if (on) {
left = sc->gain[port][ESS_LEFT];
right = sc->gain[port][ESS_RIGHT];
 2372         } else {
left = right = 0;
 2374         }
 2376         if (stereo)
gain = ESS_STEREO_GAIN(left, right);
 2378         else
gain = ESS_MONO_GAIN(left);
 2381         if (mix)
ess_write_mix_reg(sc, src, gain);
 2383         else
ess_write_x_reg(sc, src, gain);
 2385 }
 2387 /* Set the input device on devices without an input mixer. */
 2388 int
ess_set_in_port(sc, ord)
 2390         struct ess_softc *sc;
 2391         int ord;
 2392 {
mixer_devinfo_t di;
 2394         int i;
DPRINTF(("ess_set_in_port: ord=0x%x\n", ord));
 2398         /*
 2399          * Get the device info for the record source control,
 2400          * including the list of available sources.
 2401          */
di.index = ESS_RECORD_SOURCE;
 2403         if (ess_query_devinfo(sc, &di))
 2404                 return EINVAL;
 2406         /* See if the given ord value was anywhere in the list. */
 2407         for (i = 0; i < di.un.e.num_mem; i++) {
 2408                 if (ord == di.un.e.member[i].ord)
 2409                         break;
 2410         }
 2411         if (i == di.un.e.num_mem)
 2412                 return EINVAL;
ess_write_mix_reg(sc, ESS_MREG_ADC_SOURCE, ord);
sc->in_port = ord;
 2417         return (0);
 2418 }
 2420 /* Set the input device levels on input-mixer-enabled devices. */
 2421 int
ess_set_in_ports(sc, mask)
 2423         struct ess_softc *sc;
 2424         int mask;
 2425 {
mixer_devinfo_t di;
 2427         int i, port;
DPRINTF(("ess_set_in_ports: mask=0x%x\n", mask));
 2431         /*
 2432          * Get the device info for the record source control,
 2433          * including the list of available sources.
 2434          */
di.index = ESS_RECORD_SOURCE;
 2436         if (ess_query_devinfo(sc, &di))
 2437                 return EINVAL;
 2439         /*
 2440          * Set or disable the record volume control for each of the
 2441          * possible sources.
 2442          */
 2443         for (i = 0; i < di.un.s.num_mem; i++) {
 2444                 /*
 2445                  * Calculate the source port number from its mask.
 2446                  */
port = ffs(di.un.s.member[i].mask);
 2449                 /*
 2450                  * Set the source gain:
 2451                  *      to the current value if source is enabled
 2452                  *      to zero if source is disabled
 2453                  */
ess_set_gain(sc, port, mask & di.un.s.member[i].mask);
 2455         }
sc->in_mask = mask;
 2458         return (0);
 2459 }
 2461 void
ess_speaker_on(sc)
 2463         struct ess_softc *sc;
 2464 {
 2465         /* Unmute the DAC. */
ess_set_gain(sc, ESS_DAC_PLAY_VOL, 1);
 2467 }
 2469 void
ess_speaker_off(sc)
 2471         struct ess_softc *sc;
 2472 {
 2473         /* Mute the DAC. */
ess_set_gain(sc, ESS_DAC_PLAY_VOL, 0);
 2475 }
 2477 /*
 2478  * Calculate the time constant for the requested sampling rate.
 2479  */
u_int
ess_srtotc(rate)
u_int rate;
 2483 {
u_int tc;
 2486         /* The following formulae are from the ESS data sheet. */
 2487         if (rate <= 22050)
tc = 128 - 397700L / rate;
 2489         else
tc = 256 - 795500L / rate;
 2492         return (tc);
 2493 }
 2496 /*
 2497  * Calculate the filter constant for the reuqested sampling rate.
 2498  */
u_int
ess_srtofc(rate)
u_int rate;
 2502 {
 2503         /*
 2504          * The following formula is derived from the information in
 2505          * the ES1887 data sheet, based on a roll-off frequency of
 2506          * 87%.
 2507          */
 2508         return (256 - 200279L / rate);
 2509 }
 2512 /*
 2513  * Return the status of the DSP.
 2514  */
u_char
ess_get_dsp_status(sc)
 2517         struct ess_softc *sc;
 2518 {
 2519         return (EREAD1(sc->sc_iot, sc->sc_ioh, ESS_DSP_RW_STATUS));
 2520 }
 2523 /*
 2524  * Return the read status of the DSP:   1 -> DSP ready for reading
 2525  *                                      0 -> DSP not ready for reading
 2526  */
u_char
ess_dsp_read_ready(sc)
 2529         struct ess_softc *sc;
 2530 {
 2531         return ((ess_get_dsp_status(sc) & ESS_DSP_READ_READY) ? 1 : 0);
 2532 }
 2535 /*
 2536  * Return the write status of the DSP:  1 -> DSP ready for writing
 2537  *                                      0 -> DSP not ready for writing
 2538  */
u_char
ess_dsp_write_ready(sc)
 2541         struct ess_softc *sc;
 2542 {
 2543         return ((ess_get_dsp_status(sc) & ESS_DSP_WRITE_BUSY) ? 0 : 1);
 2544 }
 2547 /*
 2548  * Read a byte from the DSP.
 2549  */
 2550 int
ess_rdsp(sc)
 2552         struct ess_softc *sc;
 2553 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 2556         int i;
 2558         for (i = ESS_READ_TIMEOUT; i > 0; --i) {
 2559                 if (ess_dsp_read_ready(sc)) {
i = EREAD1(iot, ioh, ESS_DSP_READ);
DPRINTFN(8,("ess_rdsp() = 0x%02x\n", i));
 2562                         return i;
 2563                 } else
delay(10);
 2565         }
DPRINTF(("ess_rdsp: timed out\n"));
 2568         return (-1);
 2569 }
 2571 /*
 2572  * Write a byte to the DSP.
 2573  */
 2574 int
ess_wdsp(sc, v)
 2576         struct ess_softc *sc;
u_char v;
 2578 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 2581         int i;
DPRINTFN(8,("ess_wdsp(0x%02x)\n", v));
 2585         for (i = ESS_WRITE_TIMEOUT; i > 0; --i) {
 2586                 if (ess_dsp_write_ready(sc)) {
EWRITE1(iot, ioh, ESS_DSP_WRITE, v);
 2588                         return (0);
 2589                 } else
delay(10);
 2591         }
DPRINTF(("ess_wdsp(0x%02x): timed out\n", v));
 2594         return (-1);
 2595 }
 2597 /*
 2598  * Write a value to one of the ESS extended registers.
 2599  */
 2600 int
ess_write_x_reg(sc, reg, val)
 2602         struct ess_softc *sc;
u_char reg;
u_char val;
 2605 {
 2606         int error;
DPRINTFN(2,("ess_write_x_reg: %02x=%02x\n", reg, val));
 2609         if ((error = ess_wdsp(sc, reg)) == 0)
error = ess_wdsp(sc, val);
 2612         return error;
 2613 }
 2615 /*
 2616  * Read the value of one of the ESS extended registers.
 2617  */
u_char
ess_read_x_reg(sc, reg)
 2620         struct ess_softc *sc;
u_char reg;
 2622 {
 2623         int error;
 2624         int val;
 2626         if ((error = ess_wdsp(sc, 0xC0)) == 0)
error = ess_wdsp(sc, reg);
 2628         if (error)
DPRINTF(("Error reading extended register 0x%02x\n", reg));
 2630 /* REVISIT: what if an error is returned above? */
val = ess_rdsp(sc);
DPRINTFN(2,("ess_read_x_reg: %02x=%02x\n", reg, val));
 2633         return val;
 2634 }
 2636 void
ess_clear_xreg_bits(sc, reg, mask)
 2638         struct ess_softc *sc;
u_char reg;
u_char mask;
 2641 {
 2642         if (ess_write_x_reg(sc, reg, ess_read_x_reg(sc, reg) & ~mask) == -1)
DPRINTF(("Error clearing bits in extended register 0x%02x\n",
reg));
 2645 }
 2647 void
ess_set_xreg_bits(sc, reg, mask)
 2649         struct ess_softc *sc;
u_char reg;
u_char mask;
 2652 {
 2653         if (ess_write_x_reg(sc, reg, ess_read_x_reg(sc, reg) | mask) == -1)
DPRINTF(("Error setting bits in extended register 0x%02x\n",
reg));
 2656 }
 2659 /*
 2660  * Write a value to one of the ESS mixer registers.
 2661  */
 2662 void
ess_write_mix_reg(sc, reg, val)
 2664         struct ess_softc *sc;
u_char reg;
u_char val;
 2667 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 2670         int s;
DPRINTFN(2,("ess_write_mix_reg: %x=%x\n", reg, val));
s = splaudio();
EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
EWRITE1(iot, ioh, ESS_MIX_REG_DATA, val);
splx(s);
 2678 }
 2680 /*
 2681  * Read the value of one of the ESS mixer registers.
 2682  */
u_char
ess_read_mix_reg(sc, reg)
 2685         struct ess_softc *sc;
u_char reg;
 2687 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 2690         int s;
u_char val;
s = splaudio();
EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
val = EREAD1(iot, ioh, ESS_MIX_REG_DATA);
splx(s);
DPRINTFN(2,("ess_read_mix_reg: %x=%x\n", reg, val));
 2699         return val;
 2700 }
 2702 void
ess_clear_mreg_bits(sc, reg, mask)
 2704         struct ess_softc *sc;
u_char reg;
u_char mask;
 2707 {
ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) & ~mask);
 2709 }
 2711 void
ess_set_mreg_bits(sc, reg, mask)
 2713         struct ess_softc *sc;
u_char reg;
u_char mask;
 2716 {
ess_write_mix_reg(sc, reg, ess_read_mix_reg(sc, reg) | mask);
 2718 }
 2720 void
ess_read_multi_mix_reg(sc, reg, datap, count)
 2722         struct ess_softc *sc;
u_char reg;
u_int8_t *datap;
bus_size_t count;
 2726 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 2729         int s;
s = splaudio();
EWRITE1(iot, ioh, ESS_MIX_REG_SELECT, reg);
bus_space_read_multi_1(iot, ioh, ESS_MIX_REG_DATA, datap, count);
splx(s);
 2735 }