/*      $NetBSD: ym.c,v 1.50 2021/08/07 16:19:12 thorpej Exp $  */

/*-
* Copyright (c) 1999-2002, 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by ITOH Yasufumi.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Copyright (c) 1998 Constantine Sapuntzakis. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
*  Original code from OpenBSD.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ym.c,v 1.50 2021/08/07 16:19:12 thorpej Exp $");

#include "mpu_ym.h"
#include "opt_ym.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/kernel.h>
#include <sys/proc.h>

#include <sys/cpu.h>
#include <sys/intr.h>
#include <sys/bus.h>

#include <sys/audioio.h>
#include <dev/audio/audio_if.h>

#include <dev/isa/isavar.h>
#include <dev/isa/isadmavar.h>

#include <dev/ic/ad1848reg.h>
#include <dev/isa/ad1848var.h>
#include <dev/ic/opl3sa3reg.h>
#include <dev/isa/wssreg.h>
#if NMPU_YM > 0
#include <dev/ic/mpuvar.h>
#endif
#include <dev/isa/ymvar.h>
#include <dev/isa/sbreg.h>

/* Power management mode. */
#ifndef YM_POWER_MODE
#define YM_POWER_MODE           YM_POWER_POWERSAVE
#endif

/* Time in second before power down the chip. */
#ifndef YM_POWER_OFF_SEC
#define YM_POWER_OFF_SEC        5
#endif

/* Default mixer settings. */
#ifndef YM_VOL_MASTER
#define YM_VOL_MASTER           208
#endif

#ifndef YM_VOL_DAC
#define YM_VOL_DAC              224
#endif

#ifndef YM_VOL_OPL3
#define YM_VOL_OPL3             184
#endif

/*
* Default position of the equalizer.
*/
#ifndef YM_DEFAULT_TREBLE
#define YM_DEFAULT_TREBLE       YM_EQ_FLAT_OFFSET
#endif
#ifndef YM_DEFAULT_BASS
#define YM_DEFAULT_BASS         YM_EQ_FLAT_OFFSET
#endif

#ifdef __i386__         /* XXX */
# include "joy.h"
#else
# define NJOY   0
#endif

#ifdef AUDIO_DEBUG
#define DPRINTF(x)      if (ymdebug) printf x
int     ymdebug = 0;
#else
#define DPRINTF(x)
#endif
#define DVNAME(softc)   (device_xname((softc)->sc_ad1848.sc_ad1848.sc_dev))

int     ym_getdev(void *, struct audio_device *);
int     ym_mixer_set_port(void *, mixer_ctrl_t *);
int     ym_mixer_get_port(void *, mixer_ctrl_t *);
int     ym_query_devinfo(void *, mixer_devinfo_t *);
int     ym_intr(void *);
#ifndef AUDIO_NO_POWER_CTL
static void ym_save_codec_regs(struct ym_softc *);
static void ym_restore_codec_regs(struct ym_softc *);
int     ym_codec_power_ctl(void *, int);
static void ym_chip_powerdown(struct ym_softc *);
static void ym_chip_powerup(struct ym_softc *, int);
static void     ym_powerdown_blocks(struct ym_softc *);
static void     ym_powerdown_callout(void *);
void    ym_power_ctl(struct ym_softc *, int, int);
#endif

static void ym_init(struct ym_softc *);
static void ym_mute(struct ym_softc *, int, int);
static void ym_set_master_gain(struct ym_softc *, struct ad1848_volume*);
static void ym_hvol_to_master_gain(struct ym_softc *);
static void ym_set_mic_gain(struct ym_softc *, int);
static void ym_set_3d(struct ym_softc *, mixer_ctrl_t *,
       struct ad1848_volume *, int);
static bool ym_suspend(device_t, const pmf_qual_t *);
static bool ym_resume(device_t, const pmf_qual_t *);


const struct audio_hw_if ym_hw_if = {
       .open                   = ad1848_isa_open,
       .close                  = ad1848_isa_close,
       .query_format           = ad1848_query_format,
       .set_format             = ad1848_set_format,
       .commit_settings        = ad1848_commit_settings,
       .halt_output            = ad1848_isa_halt_output,
       .halt_input             = ad1848_isa_halt_input,
       .getdev                 = ym_getdev,
       .set_port               = ym_mixer_set_port,
       .get_port               = ym_mixer_get_port,
       .query_devinfo          = ym_query_devinfo,
       .allocm                 = ad1848_isa_malloc,
       .freem                  = ad1848_isa_free,
       .round_buffersize       = ad1848_isa_round_buffersize,
       .get_props              = ad1848_isa_get_props,
       .trigger_output         = ad1848_isa_trigger_output,
       .trigger_input          = ad1848_isa_trigger_input,
       .get_locks              = ad1848_get_locks,
};

static inline int ym_read(struct ym_softc *, int);
static inline void ym_write(struct ym_softc *, int, int);

void
ym_attach(struct ym_softc *sc)
{
       static struct ad1848_volume vol_master = {YM_VOL_MASTER, YM_VOL_MASTER};
       static struct ad1848_volume vol_dac    = {YM_VOL_DAC,    YM_VOL_DAC};
       static struct ad1848_volume vol_opl3   = {YM_VOL_OPL3,   YM_VOL_OPL3};
       struct ad1848_softc *ac;
       mixer_ctrl_t mctl;
       struct audio_attach_args arg;

       ac = &sc->sc_ad1848.sc_ad1848;
       callout_init(&sc->sc_powerdown_ch, CALLOUT_MPSAFE);
       cv_init(&sc->sc_cv, "ym");
       ad1848_init_locks(ac, IPL_AUDIO);

       /* Mute the output to reduce noise during initialization. */
       ym_mute(sc, SA3_VOL_L, 1);
       ym_mute(sc, SA3_VOL_R, 1);

       sc->sc_version = ym_read(sc, SA3_MISC) & SA3_MISC_VER;
       ac->chip_name = YM_IS_SA3(sc) ? "OPL3-SA3" : "OPL3-SA2";

       sc->sc_ad1848.sc_ih = isa_intr_establish(sc->sc_ic, sc->ym_irq,
           IST_EDGE, IPL_AUDIO, ym_intr, sc);

#ifndef AUDIO_NO_POWER_CTL
       sc->sc_ad1848.powerctl = ym_codec_power_ctl;
       sc->sc_ad1848.powerarg = sc;
#endif
       ad1848_isa_attach(&sc->sc_ad1848);
       printf("\n");
       ac->parent = sc;

       /* Establish chip in well known mode */
       ym_set_master_gain(sc, &vol_master);
       ym_set_mic_gain(sc, 0);
       sc->master_mute = 0;

       /* Override ad1848 settings. */
       ad1848_set_channel_gain(ac, AD1848_DAC_CHANNEL, &vol_dac);
       ad1848_set_channel_gain(ac, AD1848_AUX2_CHANNEL, &vol_opl3);

       /*
        * Mute all external sources.  If you change this, you must
        * also change the initial value of sc->sc_external_sources
        * (currently 0 --- no external source is active).
        */
       sc->mic_mute = 1;
       ym_mute(sc, SA3_MIC_VOL, sc->mic_mute);
       ad1848_mute_channel(ac, AD1848_AUX1_CHANNEL, MUTE_ALL); /* CD */
       ad1848_mute_channel(ac, AD1848_LINE_CHANNEL, MUTE_ALL); /* line */
       ac->mute[AD1848_AUX1_CHANNEL] = MUTE_ALL;
       ac->mute[AD1848_LINE_CHANNEL] = MUTE_ALL;
       /* speaker is muted by default */

       /* We use only one IRQ (IRQ-A). */
       ym_write(sc, SA3_IRQ_CONF, SA3_IRQ_CONF_MPU_A | SA3_IRQ_CONF_WSS_A);
       ym_write(sc, SA3_HVOL_INTR_CNF, SA3_HVOL_INTR_CNF_A);

       /* audio at ym attachment */
       sc->sc_audiodev = audio_attach_mi(&ym_hw_if, ac, ac->sc_dev);

       /* opl at ym attachment */
       if (sc->sc_opl_ioh) {
               arg.type = AUDIODEV_TYPE_OPL;
               arg.hwif = 0;
               arg.hdl = 0;
               (void)config_found(ac->sc_dev, &arg, audioprint,
                   CFARGS(.iattr = "ym"));
       }

#if NMPU_YM > 0
       /* mpu at ym attachment */
       if (sc->sc_mpu_ioh) {
               arg.type = AUDIODEV_TYPE_MPU;
               arg.hwif = 0;
               arg.hdl = 0;
               sc->sc_mpudev = config_found(ac->sc_dev, &arg, audioprint,
                   CFARGS(.iattr = "ym"));
       }
#endif

       /* This must be AFTER the attachment of sub-devices. */
       mutex_spin_enter(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       ym_init(sc);

#ifndef AUDIO_NO_POWER_CTL
       /*
        * Initialize power control.
        */
       sc->sc_pow_mode = YM_POWER_MODE;
       sc->sc_pow_timeout = YM_POWER_OFF_SEC;

       sc->sc_on_blocks = sc->sc_turning_off =
           YM_POWER_CODEC_P | YM_POWER_CODEC_R |
           YM_POWER_OPL3 | YM_POWER_MPU401 | YM_POWER_3D |
           YM_POWER_CODEC_DA | YM_POWER_CODEC_AD | YM_POWER_OPL3_DA;
#if NJOY > 0
       sc->sc_on_blocks |= YM_POWER_JOYSTICK;  /* prevents chip powerdown */
#endif
       ym_powerdown_blocks(sc);
       mutex_spin_exit(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       if (!pmf_device_register(ac->sc_dev, ym_suspend, ym_resume)) {
               aprint_error_dev(ac->sc_dev,
                   "cannot set power mgmt handler\n");
       }
#endif

       /* Set tone control to the default position. */
       mctl.un.value.num_channels = 1;
       mctl.un.value.level[AUDIO_MIXER_LEVEL_MONO] = YM_DEFAULT_TREBLE;
       mctl.dev = YM_MASTER_TREBLE;
       ym_mixer_set_port(sc, &mctl);
       mctl.un.value.level[AUDIO_MIXER_LEVEL_MONO] = YM_DEFAULT_BASS;
       mctl.dev = YM_MASTER_BASS;
       ym_mixer_set_port(sc, &mctl);

       /* Unmute the output now if the chip is on. */
#ifndef AUDIO_NO_POWER_CTL
       if (sc->sc_on_blocks & YM_POWER_ACTIVE)
#endif
       {
               ym_mute(sc, SA3_VOL_L, sc->master_mute);
               ym_mute(sc, SA3_VOL_R, sc->master_mute);
       }
}

static inline int
ym_read(struct ym_softc *sc, int reg)
{

       bus_space_write_1(sc->sc_iot, sc->sc_controlioh,
           SA3_CTL_INDEX, (reg & 0xff));
       return bus_space_read_1(sc->sc_iot, sc->sc_controlioh, SA3_CTL_DATA);
}

static inline void
ym_write(struct ym_softc *sc, int reg, int data)
{

       bus_space_write_1(sc->sc_iot, sc->sc_controlioh,
           SA3_CTL_INDEX, (reg & 0xff));
       bus_space_write_1(sc->sc_iot, sc->sc_controlioh,
           SA3_CTL_DATA, (data & 0xff));
}

static void
ym_init(struct ym_softc *sc)
{
       uint8_t dpd, apd;

       KASSERT(mutex_owned(&sc->sc_ad1848.sc_ad1848.sc_intr_lock));

       /* Mute SoundBlaster output if possible. */
       if (sc->sc_sb_ioh) {
               bus_space_write_1(sc->sc_iot, sc->sc_sb_ioh, SBP_MIXER_ADDR,
                   SBP_MASTER_VOL);
               bus_space_write_1(sc->sc_iot, sc->sc_sb_ioh, SBP_MIXER_DATA,
                   0x00);
       }

       if (!YM_IS_SA3(sc)) {
               /* OPL3-SA2 */
               ym_write(sc, SA3_PWR_MNG, SA2_PWR_MNG_CLKO |
                   (sc->sc_opl_ioh == 0 ? SA2_PWR_MNG_FMPS : 0));
               return;
       }

       /* OPL3-SA3 */
       /* Figure out which part can be power down. */
       dpd = SA3_DPWRDWN_SB            /* we never use SB */
#if NMPU_YM > 0
           | (sc->sc_mpu_ioh ? 0 : SA3_DPWRDWN_MPU)
#else
           | SA3_DPWRDWN_MPU
#endif
#if NJOY == 0
           | SA3_DPWRDWN_JOY
#endif
           | SA3_DPWRDWN_PNP   /* ISA Plug and Play is done */
           /*
            * The master clock is for external wavetable synthesizer
            * OPL4-ML (YMF704) or OPL4-ML2 (YMF721),
            * and is currently unused.
            */
           | SA3_DPWRDWN_MCLKO;

       apd = SA3_APWRDWN_SBDAC;        /* we never use SB */

       /* Power down OPL3 if not attached. */
       if (sc->sc_opl_ioh == 0) {
               dpd |= SA3_DPWRDWN_FM;
               apd |= SA3_APWRDWN_FMDAC;
       }
       /* CODEC is always attached. */

       /* Power down unused digital parts. */
       ym_write(sc, SA3_DPWRDWN, dpd);

       /* Power down unused analog parts. */
       ym_write(sc, SA3_APWRDWN, apd);
}


int
ym_getdev(void *addr, struct audio_device *retp)
{
       struct ym_softc *sc;
       struct ad1848_softc *ac;

       sc = addr;
       ac = &sc->sc_ad1848.sc_ad1848;
       strlcpy(retp->name, ac->chip_name, sizeof(retp->name));
       snprintf(retp->version, sizeof(retp->version), "%d", sc->sc_version);
       strlcpy(retp->config, "ym", sizeof(retp->config));

       return 0;
}


static ad1848_devmap_t mappings[] = {
       { YM_DAC_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL },
       { YM_MIDI_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL },
       { YM_CD_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL },
       { YM_LINE_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL },
       { YM_SPEAKER_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL },
       { YM_MONITOR_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL },
       { YM_DAC_MUTE, AD1848_KIND_MUTE, AD1848_DAC_CHANNEL },
       { YM_MIDI_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL },
       { YM_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL },
       { YM_LINE_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL },
       { YM_SPEAKER_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL },
       { YM_MONITOR_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL },
       { YM_REC_LVL, AD1848_KIND_RECORDGAIN, -1 },
       { YM_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1}
};

#define NUMMAP  (sizeof(mappings) / sizeof(mappings[0]))


static void
ym_mute(struct ym_softc *sc, int left_reg, int mute)
{
       uint8_t reg;

       reg = ym_read(sc, left_reg);
       if (mute)
               ym_write(sc, left_reg, reg | 0x80);
       else
               ym_write(sc, left_reg, reg & ~0x80);
}


static void
ym_set_master_gain(struct ym_softc *sc, struct ad1848_volume *vol)
{
       u_int atten;

       sc->master_gain = *vol;

       atten = ((AUDIO_MAX_GAIN - vol->left) * (SA3_VOL_MV + 1)) /
               (AUDIO_MAX_GAIN + 1);

       ym_write(sc, SA3_VOL_L, (ym_read(sc, SA3_VOL_L) & ~SA3_VOL_MV) | atten);

       atten = ((AUDIO_MAX_GAIN - vol->right) * (SA3_VOL_MV + 1)) /
               (AUDIO_MAX_GAIN + 1);

       ym_write(sc, SA3_VOL_R, (ym_read(sc, SA3_VOL_R) & ~SA3_VOL_MV) | atten);
}

/*
* Read current setting of master volume from hardware
* and update the software value if changed.
* [SA3] This function clears hardware volume interrupt.
*/
static void
ym_hvol_to_master_gain(struct ym_softc *sc)
{
       u_int prevval, val;
       int changed;

       changed = 0;
       val = SA3_VOL_MV & ~ym_read(sc, SA3_VOL_L);
       prevval = (sc->master_gain.left * (SA3_VOL_MV + 1)) /
           (AUDIO_MAX_GAIN + 1);
       if (val != prevval) {
               sc->master_gain.left =
                   val * ((AUDIO_MAX_GAIN + 1) / (SA3_VOL_MV + 1));
               changed = 1;
       }

       val = SA3_VOL_MV & ~ym_read(sc, SA3_VOL_R);
       prevval = (sc->master_gain.right * (SA3_VOL_MV + 1)) /
           (AUDIO_MAX_GAIN + 1);
       if (val != prevval) {
               sc->master_gain.right =
                   val * ((AUDIO_MAX_GAIN + 1) / (SA3_VOL_MV + 1));
               changed = 1;
       }

#if 0   /* XXX NOT YET */
       /* Notify the change to async processes. */
       if (changed && sc->sc_audiodev)
               mixer_signal(sc->sc_audiodev);
#else
       __USE(changed);
#endif
}

static void
ym_set_mic_gain(struct ym_softc *sc, int vol)
{
       u_int atten;

       sc->mic_gain = vol;

       atten = ((AUDIO_MAX_GAIN - vol) * (SA3_MIC_MCV + 1)) /
               (AUDIO_MAX_GAIN + 1);

       ym_write(sc, SA3_MIC_VOL,
                (ym_read(sc, SA3_MIC_VOL) & ~SA3_MIC_MCV) | atten);
}

static void
ym_set_3d(struct ym_softc *sc, mixer_ctrl_t *cp,
   struct ad1848_volume *val, int reg)
{
       uint8_t l, r, e;

       KASSERT(mutex_owned(&sc->sc_ad1848.sc_ad1848.sc_intr_lock));

       ad1848_to_vol(cp, val);

       l = val->left;
       r = val->right;
       if (reg != SA3_3D_WIDE) {
               /* flat on center */
               l = YM_EQ_EXPAND_VALUE(l);
               r = YM_EQ_EXPAND_VALUE(r);
       }

       e = (l * (SA3_3D_BITS + 1) + (SA3_3D_BITS + 1) / 2) /
           (AUDIO_MAX_GAIN + 1) << SA3_3D_LSHIFT |
           (r * (SA3_3D_BITS + 1) + (SA3_3D_BITS + 1) / 2) /
           (AUDIO_MAX_GAIN + 1) << SA3_3D_RSHIFT;

#ifndef AUDIO_NO_POWER_CTL
       /* turn wide stereo on if necessary */
       if (e)
               ym_power_ctl(sc, YM_POWER_3D, 1);
#endif

       ym_write(sc, reg, e);

#ifndef AUDIO_NO_POWER_CTL
       /* turn wide stereo off if necessary */
       if (YM_EQ_OFF(&sc->sc_treble) && YM_EQ_OFF(&sc->sc_bass) &&
           YM_WIDE_OFF(&sc->sc_wide))
               ym_power_ctl(sc, YM_POWER_3D, 0);
#endif
}

int
ym_mixer_set_port(void *addr, mixer_ctrl_t *cp)
{
       struct ad1848_softc *ac;
       struct ym_softc *sc;
       struct ad1848_volume vol;
       int error;
       uint8_t extsources;

       ac = addr;
       sc = ac->parent;
       error = 0;
       DPRINTF(("%s: ym_mixer_set_port: dev 0x%x, type 0x%x, 0x%x (%d; %d, %d)\n",
               DVNAME(sc), cp->dev, cp->type, cp->un.ord,
               cp->un.value.num_channels, cp->un.value.level[0],
               cp->un.value.level[1]));

       /* SA2 doesn't have equalizer */
       if (!YM_IS_SA3(sc) && YM_MIXER_SA3_ONLY(cp->dev))
               return ENXIO;

       mutex_spin_enter(&ac->sc_intr_lock);

#ifndef AUDIO_NO_POWER_CTL
       /* Power-up chip */
       ym_power_ctl(sc, YM_POWER_CODEC_CTL, 1);
#endif

       switch (cp->dev) {
       case YM_OUTPUT_LVL:
               ad1848_to_vol(cp, &vol);
               ym_set_master_gain(sc, &vol);
               goto out;

       case YM_OUTPUT_MUTE:
               sc->master_mute = (cp->un.ord != 0);
               ym_mute(sc, SA3_VOL_L, sc->master_mute);
               ym_mute(sc, SA3_VOL_R, sc->master_mute);
               goto out;

       case YM_MIC_LVL:
               if (cp->un.value.num_channels != 1)
                       error = EINVAL;
               else
                       ym_set_mic_gain(sc,
                           cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
               goto out;

       case YM_MASTER_EQMODE:
               sc->sc_eqmode = cp->un.ord & SA3_SYS_CTL_YMODE;
               ym_write(sc, SA3_SYS_CTL, (ym_read(sc, SA3_SYS_CTL) &
                            ~SA3_SYS_CTL_YMODE) | sc->sc_eqmode);
               goto out;

       case YM_MASTER_TREBLE:
               ym_set_3d(sc, cp, &sc->sc_treble, SA3_3D_TREBLE);
               goto out;

       case YM_MASTER_BASS:
               ym_set_3d(sc, cp, &sc->sc_bass, SA3_3D_BASS);
               goto out;

       case YM_MASTER_WIDE:
               ym_set_3d(sc, cp, &sc->sc_wide, SA3_3D_WIDE);
               goto out;

#ifndef AUDIO_NO_POWER_CTL
       case YM_PWR_MODE:
               if ((unsigned) cp->un.ord > YM_POWER_NOSAVE)
                       error = EINVAL;
               else
                       sc->sc_pow_mode = cp->un.ord;
               goto out;

       case YM_PWR_TIMEOUT:
               if (cp->un.value.num_channels != 1)
                       error = EINVAL;
               else
                       sc->sc_pow_timeout =
                           cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
               goto out;

       /*
        * Needs power-up to hear external sources.
        */
       case YM_CD_MUTE:
       case YM_LINE_MUTE:
       case YM_SPEAKER_MUTE:
       case YM_MIC_MUTE:
               extsources = YM_MIXER_TO_XS(cp->dev);
               if (cp->un.ord) {
                       if ((sc->sc_external_sources &= ~extsources) == 0) {
                               /*
                                * All the external sources are muted
                                *  --- no need to keep the chip on.
                                */
                               ym_power_ctl(sc, YM_POWER_EXT_SRC, 0);
                               DPRINTF(("%s: ym_mixer_set_port: off for ext\n",
                                       DVNAME(sc)));
                       }
               } else {
                       /* mute off - power-up the chip */
                       sc->sc_external_sources |= extsources;
                       ym_power_ctl(sc, YM_POWER_EXT_SRC, 1);
                       DPRINTF(("%s: ym_mixer_set_port: on for ext\n",
                               DVNAME(sc)));
               }
               break;  /* fall to ad1848_mixer_set_port() */

       /*
        * Power on/off the playback part for monitoring.
        */
       case YM_MONITOR_MUTE:
               if ((ac->open_mode & (FREAD | FWRITE)) == FREAD)
                       ym_power_ctl(sc, YM_POWER_CODEC_P | YM_POWER_CODEC_DA,
                           cp->un.ord == 0);
               break;  /* fall to ad1848_mixer_set_port() */
#endif
       }

       error = ad1848_mixer_set_port(ac, mappings, NUMMAP, cp);

       if (error != ENXIO)
               goto out;

       error = 0;

       switch (cp->dev) {
       case YM_MIC_MUTE:
               sc->mic_mute = (cp->un.ord != 0);
               ym_mute(sc, SA3_MIC_VOL, sc->mic_mute);
               break;

       default:
               error = ENXIO;
               break;
       }

out:
#ifndef AUDIO_NO_POWER_CTL
       /* Power-down chip */
       ym_power_ctl(sc, YM_POWER_CODEC_CTL, 0);
#endif
       mutex_spin_exit(&ac->sc_intr_lock);

       return error;
}

int
ym_mixer_get_port(void *addr, mixer_ctrl_t *cp)
{
       struct ad1848_softc *ac;
       struct ym_softc *sc;
       int error;

       ac = addr;
       sc = ac->parent;
       /* SA2 doesn't have equalizer */
       if (!YM_IS_SA3(sc) && YM_MIXER_SA3_ONLY(cp->dev))
               return ENXIO;

       switch (cp->dev) {
       case YM_OUTPUT_LVL:
               if (!YM_IS_SA3(sc)) {
                       /*
                        * SA2 doesn't have hardware volume interrupt.
                        * Read current value and update every time.
                        */
                       mutex_spin_enter(&ac->sc_intr_lock);
#ifndef AUDIO_NO_POWER_CTL
                       /* Power-up chip */
                       ym_power_ctl(sc, YM_POWER_CODEC_CTL, 1);
#endif
                       ym_hvol_to_master_gain(sc);
#ifndef AUDIO_NO_POWER_CTL
                       /* Power-down chip */
                       ym_power_ctl(sc, YM_POWER_CODEC_CTL, 0);
#endif
                       mutex_spin_exit(&ac->sc_intr_lock);
               }
               ad1848_from_vol(cp, &sc->master_gain);
               return 0;

       case YM_OUTPUT_MUTE:
               cp->un.ord = sc->master_mute;
               return 0;

       case YM_MIC_LVL:
               if (cp->un.value.num_channels != 1)
                       return EINVAL;
               cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->mic_gain;
               return 0;

       case YM_MASTER_EQMODE:
               cp->un.ord = sc->sc_eqmode;
               return 0;

       case YM_MASTER_TREBLE:
               ad1848_from_vol(cp, &sc->sc_treble);
               return 0;

       case YM_MASTER_BASS:
               ad1848_from_vol(cp, &sc->sc_bass);
               return 0;

       case YM_MASTER_WIDE:
               ad1848_from_vol(cp, &sc->sc_wide);
               return 0;

#ifndef AUDIO_NO_POWER_CTL
       case YM_PWR_MODE:
               cp->un.ord = sc->sc_pow_mode;
               return 0;

       case YM_PWR_TIMEOUT:
               if (cp->un.value.num_channels != 1)
                       return EINVAL;
               cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_pow_timeout;
               return 0;
#endif
       }

       error = ad1848_mixer_get_port(ac, mappings, NUMMAP, cp);

       if (error != ENXIO)
               return error;

       error = 0;

       switch (cp->dev) {
       case YM_MIC_MUTE:
               cp->un.ord = sc->mic_mute;
               break;

       default:
               error = ENXIO;
               break;
       }

       return error;
}

static const char *mixer_classes[] = {
       AudioCinputs, AudioCrecord, AudioCoutputs, AudioCmonitor,
#ifndef AUDIO_NO_POWER_CTL
       AudioCpower,
#endif
       AudioCequalization
};

int
ym_query_devinfo(void *addr, mixer_devinfo_t *dip)
{
       static const char *mixer_port_names[] = {
               AudioNdac, AudioNmidi, AudioNcd, AudioNline, AudioNspeaker,
               AudioNmicrophone, AudioNmonitor
       };
       struct ad1848_softc *ac;
       struct ym_softc *sc;

       ac = addr;
       sc = ac->parent;
       /* SA2 doesn't have equalizer */
       if (!YM_IS_SA3(sc) && YM_MIXER_SA3_ONLY(dip->index))
               return ENXIO;

       dip->next = dip->prev = AUDIO_MIXER_LAST;

       switch(dip->index) {
       case YM_INPUT_CLASS:
       case YM_OUTPUT_CLASS:
       case YM_MONITOR_CLASS:
       case YM_RECORD_CLASS:
#ifndef AUDIO_NO_POWER_CTL
       case YM_PWR_CLASS:
#endif
       case YM_EQ_CLASS:
               dip->type = AUDIO_MIXER_CLASS;
               dip->mixer_class = dip->index;
               strcpy(dip->label.name,
                      mixer_classes[dip->index - YM_INPUT_CLASS]);
               break;

       case YM_DAC_LVL:
       case YM_MIDI_LVL:
       case YM_CD_LVL:
       case YM_LINE_LVL:
       case YM_SPEAKER_LVL:
       case YM_MIC_LVL:
       case YM_MONITOR_LVL:
               dip->type = AUDIO_MIXER_VALUE;
               if (dip->index == YM_MONITOR_LVL)
                       dip->mixer_class = YM_MONITOR_CLASS;
               else
                       dip->mixer_class = YM_INPUT_CLASS;

               dip->next = dip->index + 7;

               strcpy(dip->label.name,
                      mixer_port_names[dip->index - YM_DAC_LVL]);

               if (dip->index == YM_SPEAKER_LVL ||
                   dip->index == YM_MIC_LVL)
                       dip->un.v.num_channels = 1;
               else
                       dip->un.v.num_channels = 2;

               if (dip->index == YM_SPEAKER_LVL)
                       dip->un.v.delta = 1 << (8 - 4 /* valid bits */);
               else if (dip->index == YM_DAC_LVL ||
                   dip->index == YM_MONITOR_LVL)
                       dip->un.v.delta = 1 << (8 - 6 /* valid bits */);
               else
                       dip->un.v.delta = 1 << (8 - 5 /* valid bits */);

               strcpy(dip->un.v.units.name, AudioNvolume);
               break;

       case YM_DAC_MUTE:
       case YM_MIDI_MUTE:
       case YM_CD_MUTE:
       case YM_LINE_MUTE:
       case YM_SPEAKER_MUTE:
       case YM_MIC_MUTE:
       case YM_MONITOR_MUTE:
               if (dip->index == YM_MONITOR_MUTE)
                       dip->mixer_class = YM_MONITOR_CLASS;
               else
                       dip->mixer_class = YM_INPUT_CLASS;
               dip->type = AUDIO_MIXER_ENUM;
               dip->prev = dip->index - 7;
       mute:
               strcpy(dip->label.name, AudioNmute);
               dip->un.e.num_mem = 2;
               strcpy(dip->un.e.member[0].label.name, AudioNoff);
               dip->un.e.member[0].ord = 0;
               strcpy(dip->un.e.member[1].label.name, AudioNon);
               dip->un.e.member[1].ord = 1;
               break;


       case YM_OUTPUT_LVL:
               dip->type = AUDIO_MIXER_VALUE;
               dip->mixer_class = YM_OUTPUT_CLASS;
               dip->next = YM_OUTPUT_MUTE;
               strcpy(dip->label.name, AudioNmaster);
               dip->un.v.num_channels = 2;
               dip->un.v.delta = (AUDIO_MAX_GAIN + 1) / (SA3_VOL_MV + 1);
               strcpy(dip->un.v.units.name, AudioNvolume);
               break;

       case YM_OUTPUT_MUTE:
               dip->mixer_class = YM_OUTPUT_CLASS;
               dip->type = AUDIO_MIXER_ENUM;
               dip->prev = YM_OUTPUT_LVL;
               goto mute;


       case YM_REC_LVL:        /* record level */
               dip->type = AUDIO_MIXER_VALUE;
               dip->mixer_class = YM_RECORD_CLASS;
               dip->next = YM_RECORD_SOURCE;
               strcpy(dip->label.name, AudioNrecord);
               dip->un.v.num_channels = 2;
               dip->un.v.delta = 1 << (8 - 4 /* valid bits */);
               strcpy(dip->un.v.units.name, AudioNvolume);
               break;

       case YM_RECORD_SOURCE:
               dip->mixer_class = YM_RECORD_CLASS;
               dip->type = AUDIO_MIXER_ENUM;
               dip->prev = YM_REC_LVL;
               strcpy(dip->label.name, AudioNsource);
               dip->un.e.num_mem = 4;
               strcpy(dip->un.e.member[0].label.name, AudioNmicrophone);
               dip->un.e.member[0].ord = MIC_IN_PORT;
               strcpy(dip->un.e.member[1].label.name, AudioNline);
               dip->un.e.member[1].ord = LINE_IN_PORT;
               strcpy(dip->un.e.member[2].label.name, AudioNdac);
               dip->un.e.member[2].ord = DAC_IN_PORT;
               strcpy(dip->un.e.member[3].label.name, AudioNcd);
               dip->un.e.member[3].ord = AUX1_IN_PORT;
               break;


       case YM_MASTER_EQMODE:
               dip->type = AUDIO_MIXER_ENUM;
               dip->mixer_class = YM_EQ_CLASS;
               strcpy(dip->label.name, AudioNmode);
               strcpy(dip->un.v.units.name, AudioNmode);
               dip->un.e.num_mem = 4;
               strcpy(dip->un.e.member[0].label.name, AudioNdesktop);
               dip->un.e.member[0].ord = SA3_SYS_CTL_YMODE0;
               strcpy(dip->un.e.member[1].label.name, AudioNlaptop);
               dip->un.e.member[1].ord = SA3_SYS_CTL_YMODE1;
               strcpy(dip->un.e.member[2].label.name, AudioNsubnote);
               dip->un.e.member[2].ord = SA3_SYS_CTL_YMODE2;
               strcpy(dip->un.e.member[3].label.name, AudioNhifi);
               dip->un.e.member[3].ord = SA3_SYS_CTL_YMODE3;
               break;

       case YM_MASTER_TREBLE:
               dip->type = AUDIO_MIXER_VALUE;
               dip->mixer_class = YM_EQ_CLASS;
               strcpy(dip->label.name, AudioNtreble);
               dip->un.v.num_channels = 2;
               dip->un.v.delta = (AUDIO_MAX_GAIN + 1) / (SA3_3D_BITS + 1)
                   >> YM_EQ_REDUCE_BIT;
               strcpy(dip->un.v.units.name, AudioNtreble);
               break;

       case YM_MASTER_BASS:
               dip->type = AUDIO_MIXER_VALUE;
               dip->mixer_class = YM_EQ_CLASS;
               strcpy(dip->label.name, AudioNbass);
               dip->un.v.num_channels = 2;
               dip->un.v.delta = (AUDIO_MAX_GAIN + 1) / (SA3_3D_BITS + 1)
                   >> YM_EQ_REDUCE_BIT;
               strcpy(dip->un.v.units.name, AudioNbass);
               break;

       case YM_MASTER_WIDE:
               dip->type = AUDIO_MIXER_VALUE;
               dip->mixer_class = YM_EQ_CLASS;
               strcpy(dip->label.name, AudioNsurround);
               dip->un.v.num_channels = 2;
               dip->un.v.delta = (AUDIO_MAX_GAIN + 1) / (SA3_3D_BITS + 1);
               strcpy(dip->un.v.units.name, AudioNsurround);
               break;


#ifndef AUDIO_NO_POWER_CTL
       case YM_PWR_MODE:
               dip->type = AUDIO_MIXER_ENUM;
               dip->mixer_class = YM_PWR_CLASS;
               dip->next = YM_PWR_TIMEOUT;
               strcpy(dip->label.name, AudioNsave);
               dip->un.e.num_mem = 3;
               strcpy(dip->un.e.member[0].label.name, AudioNpowerdown);
               dip->un.e.member[0].ord = YM_POWER_POWERDOWN;
               strcpy(dip->un.e.member[1].label.name, AudioNpowersave);
               dip->un.e.member[1].ord = YM_POWER_POWERSAVE;
               strcpy(dip->un.e.member[2].label.name, AudioNnosave);
               dip->un.e.member[2].ord = YM_POWER_NOSAVE;
               break;

       case YM_PWR_TIMEOUT:
               dip->type = AUDIO_MIXER_VALUE;
               dip->mixer_class = YM_PWR_CLASS;
               dip->prev = YM_PWR_MODE;
               strcpy(dip->label.name, AudioNtimeout);
               dip->un.v.num_channels = 1;
               strcpy(dip->un.v.units.name, AudioNtimeout);
               break;
#endif /* not AUDIO_NO_POWER_CTL */

       default:
               return ENXIO;
               /*NOTREACHED*/
       }

       return 0;
}

int
ym_intr(void *arg)
{
       struct ym_softc *sc = arg;
#if NMPU_YM > 0
       struct mpu_softc *sc_mpu = device_private(sc->sc_mpudev);
#endif
       u_int8_t ist;
       int processed;

       mutex_spin_enter(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       /* OPL3 timer is currently unused. */
       if (((ist = ym_read(sc, SA3_IRQA_STAT)) &
            ~(SA3_IRQ_STAT_SB|SA3_IRQ_STAT_OPL3)) == 0) {
               DPRINTF(("%s: ym_intr: spurious interrupt\n", DVNAME(sc)));
               mutex_spin_exit(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
               return 0;
       }

       /* Process pending interrupts. */
       do {
               processed = 0;
               /*
                * CODEC interrupts.
                */
               if (ist & (SA3_IRQ_STAT_TI|SA3_IRQ_STAT_CI|SA3_IRQ_STAT_PI)) {
                       ad1848_isa_intr(&sc->sc_ad1848);
                       processed = 1;
               }
#if NMPU_YM > 0
               /*
                * MPU401 interrupt.
                */
               if (ist & SA3_IRQ_STAT_MPU) {
                       mpu_intr(sc_mpu);
                       processed = 1;
               }
#endif
               /*
                * Hardware volume interrupt (SA3 only).
                * Recalculate master volume from the hardware setting.
                */
               if ((ist & SA3_IRQ_STAT_MV) && YM_IS_SA3(sc)) {
                       ym_hvol_to_master_gain(sc);
                       processed = 1;
               }
       } while (processed && (ist = ym_read(sc, SA3_IRQA_STAT)));

       mutex_spin_exit(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       return 1;
}


#ifndef AUDIO_NO_POWER_CTL
static void
ym_save_codec_regs(struct ym_softc *sc)
{
       struct ad1848_softc *ac;
       int i;

       DPRINTF(("%s: ym_save_codec_regs\n", DVNAME(sc)));
       ac = &sc->sc_ad1848.sc_ad1848;
       for (i = 0; i <= 0x1f; i++)
               sc->sc_codec_scan[i] = ad_read(ac, i);
}

static void
ym_restore_codec_regs(struct ym_softc *sc)
{
       struct ad1848_softc *ac;
       int i, t;

       DPRINTF(("%s: ym_restore_codec_regs\n", DVNAME(sc)));
       ac = &sc->sc_ad1848.sc_ad1848;
       for (i = 0; i <= 0x1f; i++) {
               /*
                * Wait til the chip becomes ready.
                * This is required after suspend/resume.
                */
               for (t = 0;
                   t < 100000 && ADREAD(ac, AD1848_IADDR) & SP_IN_INIT; t++)
                       ;
#ifdef AUDIO_DEBUG
               if (t)
                       DPRINTF(("%s: ym_restore_codec_regs: reg %d, t %d\n",
                                DVNAME(sc), i, t));
#endif
               ad_write(ac, i, sc->sc_codec_scan[i]);
       }
}

/*
* Save and restore the state on suspending / resumning.
*
* XXX This is not complete.
* Currently only the parameters, such as output gain, are restored.
* DMA state should also be restored.  FIXME.
*/
static bool
ym_suspend(device_t self, const pmf_qual_t *qual)
{
       struct ym_softc *sc = device_private(self);

       DPRINTF(("%s: ym_power_hook: suspend\n", DVNAME(sc)));

       mutex_spin_enter(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       /*
        * suspending...
        */
       callout_halt(&sc->sc_powerdown_ch,
           &sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       if (sc->sc_turning_off)
               ym_powerdown_blocks(sc);

       /*
        * Save CODEC registers.
        * Note that the registers read incorrect
        * if the CODEC part is in power-down mode.
        */
       if (sc->sc_on_blocks & YM_POWER_CODEC_DIGITAL)
               ym_save_codec_regs(sc);

       /*
        * Save OPL3-SA3 control registers and power-down the chip.
        * Note that the registers read incorrect
        * if the chip is in global power-down mode.
        */
       sc->sc_sa3_scan[SA3_PWR_MNG] = ym_read(sc, SA3_PWR_MNG);
       if (sc->sc_on_blocks)
               ym_chip_powerdown(sc);
       mutex_spin_exit(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       return true;
}

static bool
ym_resume(device_t self, const pmf_qual_t *qual)
{
       struct ym_softc *sc = device_private(self);
       int i, xmax;

       DPRINTF(("%s: ym_power_hook: resume\n", DVNAME(sc)));

       mutex_spin_enter(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       /*
        * resuming...
        */
       ym_chip_powerup(sc, 1);
       ym_init(sc);            /* power-on CODEC */

       /* Restore control registers. */
       xmax = YM_IS_SA3(sc)? YM_SAVE_REG_MAX_SA3 : YM_SAVE_REG_MAX_SA2;
       for (i = SA3_PWR_MNG + 1; i <= xmax; i++) {
               if (i == SA3_SB_SCAN || i == SA3_SB_SCAN_DATA ||
                   i == SA3_DPWRDWN)
                       continue;
               ym_write(sc, i, sc->sc_sa3_scan[i]);
       }

       /* Restore CODEC registers (including mixer). */
       ym_restore_codec_regs(sc);

       /* Restore global/digital power-down state. */
       ym_write(sc, SA3_PWR_MNG, sc->sc_sa3_scan[SA3_PWR_MNG]);
       if (YM_IS_SA3(sc))
               ym_write(sc, SA3_DPWRDWN, sc->sc_sa3_scan[SA3_DPWRDWN]);
       mutex_spin_exit(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       return true;
}

int
ym_codec_power_ctl(void *arg, int flags)
{
       struct ym_softc *sc;
       struct ad1848_softc *ac;
       int parts;

       sc = arg;
       ac = &sc->sc_ad1848.sc_ad1848;
       DPRINTF(("%s: ym_codec_power_ctl: flags = 0x%x\n", DVNAME(sc), flags));
       KASSERT(mutex_owned(&ac->sc_intr_lock));

       if (flags != 0) {
               parts = 0;
               if (flags & FREAD) {
                       parts |= YM_POWER_CODEC_R | YM_POWER_CODEC_AD;
                       if (ac->mute[AD1848_MONITOR_CHANNEL] == 0)
                               parts |= YM_POWER_CODEC_P | YM_POWER_CODEC_DA;
               }
               if (flags & FWRITE)
                       parts |= YM_POWER_CODEC_P | YM_POWER_CODEC_DA;
       } else
               parts = YM_POWER_CODEC_P | YM_POWER_CODEC_R |
                       YM_POWER_CODEC_DA | YM_POWER_CODEC_AD;

       ym_power_ctl(sc, parts, flags);

       return 0;
}

/*
* Enter Power Save mode or Global Power Down mode.
* Total dissipation becomes 5mA and 10uA (typ.) respective.
*/
static void
ym_chip_powerdown(struct ym_softc *sc)
{
       int i, xmax;

       DPRINTF(("%s: ym_chip_powerdown\n", DVNAME(sc)));
       KASSERT(mutex_owned(&sc->sc_ad1848.sc_ad1848.sc_intr_lock));

       xmax = YM_IS_SA3(sc) ? YM_SAVE_REG_MAX_SA3 : YM_SAVE_REG_MAX_SA2;

       /* Save control registers. */
       for (i = SA3_PWR_MNG + 1; i <= xmax; i++) {
               if (i == SA3_SB_SCAN || i == SA3_SB_SCAN_DATA)
                       continue;
               sc->sc_sa3_scan[i] = ym_read(sc, i);
       }
       ym_write(sc, SA3_PWR_MNG,
                (sc->sc_pow_mode == YM_POWER_POWERDOWN ?
                       SA3_PWR_MNG_PDN : SA3_PWR_MNG_PSV) | SA3_PWR_MNG_PDX);
}

/*
* Power up from Power Save / Global Power Down Mode.
*/
static void
ym_chip_powerup(struct ym_softc *sc, int nosleep)
{
       uint8_t pw;

       DPRINTF(("%s: ym_chip_powerup\n", DVNAME(sc)));
       KASSERT(mutex_owned(&sc->sc_ad1848.sc_ad1848.sc_intr_lock));

       pw = ym_read(sc, SA3_PWR_MNG);

       if ((pw & (SA3_PWR_MNG_PSV | SA3_PWR_MNG_PDN | SA3_PWR_MNG_PDX)) == 0)
               return;         /* already on */

       pw &= ~SA3_PWR_MNG_PDX;
       ym_write(sc, SA3_PWR_MNG, pw);

       /* wait 100 ms */
       if (nosleep)
               delay(100000);
       else
               kpause("ym_pu1", false, hz / 10,
                   &sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       pw &= ~(SA3_PWR_MNG_PSV | SA3_PWR_MNG_PDN);
       ym_write(sc, SA3_PWR_MNG, pw);

       /* wait 70 ms */
       if (nosleep)
               delay(70000);
       else
               kpause("ym_pu1", false, hz / 10,
                   &sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       /* The chip is muted automatically --- unmute it now. */
       ym_mute(sc, SA3_VOL_L, sc->master_mute);
       ym_mute(sc, SA3_VOL_R, sc->master_mute);
}

/* callout handler for power-down */
static void
ym_powerdown_callout(void *arg)
{
       struct ym_softc *sc;

       sc = arg;

       mutex_spin_enter(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
       if ((sc->sc_in_power_ctl & YM_POWER_CTL_INUSE) == 0) {
               ym_powerdown_blocks(sc);
       }
       mutex_spin_exit(&sc->sc_ad1848.sc_ad1848.sc_intr_lock);
}

static void
ym_powerdown_blocks(struct ym_softc *sc)
{
       uint16_t parts;
       uint16_t on_blocks;
       uint8_t sv;

       on_blocks = sc->sc_on_blocks;
       DPRINTF(("%s: ym_powerdown_blocks: turning_off 0x%x\n",
               DVNAME(sc), sc->sc_turning_off));
       KASSERT(mutex_owned(&sc->sc_ad1848.sc_ad1848.sc_intr_lock));

       on_blocks = sc->sc_on_blocks;

       /* Be sure not to change the state of the chip.  Save it first. */
       sv =  bus_space_read_1(sc->sc_iot, sc->sc_controlioh, SA3_CTL_INDEX);

       parts = sc->sc_turning_off;

       if (on_blocks & ~parts & YM_POWER_CODEC_CTL)
               parts &= ~(YM_POWER_CODEC_P | YM_POWER_CODEC_R);
       if (parts & YM_POWER_CODEC_CTL) {
               if ((on_blocks & YM_POWER_CODEC_P) == 0)
                       parts |= YM_POWER_CODEC_P;
               if ((on_blocks & YM_POWER_CODEC_R) == 0)
                       parts |= YM_POWER_CODEC_R;
       }
       parts &= ~YM_POWER_CODEC_PSEUDO;

       /* If CODEC is being off, save the state. */
       if ((sc->sc_on_blocks & YM_POWER_CODEC_DIGITAL) &&
           (sc->sc_on_blocks & ~sc->sc_turning_off &
                               YM_POWER_CODEC_DIGITAL) == 0)
               ym_save_codec_regs(sc);

       if (YM_IS_SA3(sc)) {
               /* OPL3-SA3 */
               ym_write(sc, SA3_DPWRDWN,
                   ym_read(sc, SA3_DPWRDWN) | (u_int8_t) parts);
               ym_write(sc, SA3_APWRDWN,
                   ym_read(sc, SA3_APWRDWN) | (parts >> 8));
       } else {
               /* OPL3-SA2 (only OPL3 can be off partially) */
               if (parts & YM_POWER_OPL3)
                       ym_write(sc, SA3_PWR_MNG,
                           ym_read(sc, SA3_PWR_MNG) | SA2_PWR_MNG_FMPS);
       }

       if (((sc->sc_on_blocks &= ~sc->sc_turning_off) & YM_POWER_ACTIVE) == 0)
               ym_chip_powerdown(sc);

       sc->sc_turning_off = 0;

       /* Restore the state of the chip. */
       bus_space_write_1(sc->sc_iot, sc->sc_controlioh, SA3_CTL_INDEX, sv);
}

/*
* Power control entry point.
*/
void
ym_power_ctl(struct ym_softc *sc, int parts, int onoff)
{
       int need_restore_codec;

       KASSERT(mutex_owned(&sc->sc_ad1848.sc_ad1848.sc_intr_lock));

       DPRINTF(("%s: ym_power_ctl: parts = 0x%x, %s\n",
               DVNAME(sc), parts, onoff ? "on" : "off"));

       /* This function may sleep --- needs locking. */
       while (sc->sc_in_power_ctl & YM_POWER_CTL_INUSE) {
               sc->sc_in_power_ctl |= YM_POWER_CTL_WANTED;
               DPRINTF(("%s: ym_power_ctl: sleeping\n", DVNAME(sc)));
               cv_wait(&sc->sc_cv, &sc->sc_ad1848.sc_ad1848.sc_intr_lock);
               DPRINTF(("%s: ym_power_ctl: awaken\n", DVNAME(sc)));
       }
       sc->sc_in_power_ctl |= YM_POWER_CTL_INUSE;

       /* If ON requested to parts which are scheduled to OFF, cancel it. */
       if (onoff && sc->sc_turning_off && (sc->sc_turning_off &= ~parts) == 0)
               callout_halt(&sc->sc_powerdown_ch,
                   &sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       if (!onoff && sc->sc_turning_off)
               parts &= ~sc->sc_turning_off;

       /* Discard bits which are currently {on,off}. */
       parts &= onoff ? ~sc->sc_on_blocks : sc->sc_on_blocks;

       /* Cancel previous timeout if needed. */
       if (parts != 0 && sc->sc_turning_off)
               callout_halt(&sc->sc_powerdown_ch,
                   &sc->sc_ad1848.sc_ad1848.sc_intr_lock);

       if (parts == 0)
               goto unlock;            /* no work to do */

       if (onoff) {
               /* Turning on is done immediately. */

               /* If the chip is off, turn it on. */
               if ((sc->sc_on_blocks & YM_POWER_ACTIVE) == 0)
                       ym_chip_powerup(sc, 0);

               need_restore_codec = (parts & YM_POWER_CODEC_DIGITAL) &&
                   (sc->sc_on_blocks & YM_POWER_CODEC_DIGITAL) == 0;

               sc->sc_on_blocks |= parts;
               if (parts & YM_POWER_CODEC_CTL)
                       parts |= YM_POWER_CODEC_P | YM_POWER_CODEC_R;

               if (YM_IS_SA3(sc)) {
                       /* OPL3-SA3 */
                       ym_write(sc, SA3_DPWRDWN,
                           ym_read(sc, SA3_DPWRDWN) & (u_int8_t)~parts);
                       ym_write(sc, SA3_APWRDWN,
                           ym_read(sc, SA3_APWRDWN) & ~(parts >> 8));
               } else {
                       /* OPL3-SA2 (only OPL3 can be off partially) */
                       if (parts & YM_POWER_OPL3)
                               ym_write(sc, SA3_PWR_MNG,
                                   ym_read(sc, SA3_PWR_MNG)
                                       & ~SA2_PWR_MNG_FMPS);
               }
               if (need_restore_codec)
                       ym_restore_codec_regs(sc);
       } else {
               /* Turning off is delayed. */
               sc->sc_turning_off |= parts;
       }

       /* Schedule turning off. */
       if (sc->sc_pow_mode != YM_POWER_NOSAVE && sc->sc_turning_off)
               callout_reset(&sc->sc_powerdown_ch, hz * sc->sc_pow_timeout,
                   ym_powerdown_callout, sc);

unlock:
       if (sc->sc_in_power_ctl & YM_POWER_CTL_WANTED)
               cv_broadcast(&sc->sc_cv);
       sc->sc_in_power_ctl = 0;
}
#endif /* not AUDIO_NO_POWER_CTL */