/*      $NetBSD: repulse.c,v 1.24 2022/02/12 23:30:30 andvar Exp $ */

/*-
* Copyright (c) 2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Ignatios Souvatzis.
*
* 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: repulse.c,v 1.24 2022/02/12 23:30:30 andvar Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/fcntl.h>          /* FREAD */
#include <sys/bus.h>

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

#include <dev/ic/ac97reg.h>
#include <dev/ic/ac97var.h>

#include <amiga/dev/zbusvar.h>
#include <amiga/amiga/isr.h>

#include <amiga/dev/repulse_firmware.h>

#ifndef vu_int8_t
#define vu_int8_t volatile uint8_t
#endif
#ifndef vu_int16_t
#define vu_int16_t volatile uint16_t
#endif
#ifndef vu_int32_t
#define vu_int32_t volatile uint32_t
#endif

/* ac97 attachment functions */

int repac_attach(void *, struct ac97_codec_if *);
int repac_read(void *, uint8_t, uint16_t *);
int repac_write(void *, uint8_t, uint16_t);
int repac_reset(void *);
enum ac97_host_flag repac_flags(void *);

/* audio attachment functions */

int rep_getdev(void *, struct audio_device *);
int rep_get_props(void *);
int rep_halt_output(void *);
int rep_halt_input(void *);
int rep_query_format(void *, audio_format_query_t *);
int rep_set_format(void *, int, const audio_params_t *, const audio_params_t *,
       audio_filter_reg_t *, audio_filter_reg_t *);
int rep_round_blocksize(void *, int, int, const audio_params_t *);
int rep_set_port(void *, mixer_ctrl_t *);
int rep_get_port(void *, mixer_ctrl_t *);
int rep_query_devinfo(void *, mixer_devinfo_t *);
void rep_get_locks(void *, kmutex_t **, kmutex_t **);

int rep_start_input(void *, void *, int, void (*)(void *), void *);
int rep_start_output(void *, void *, int, void (*)(void *), void *);

int rep_intr(void *);


/* audio attachment */

const struct audio_hw_if rep_hw_if = {
       .query_format           = rep_query_format,
       .set_format             = rep_set_format,
       .round_blocksize        = rep_round_blocksize,
       .start_output           = rep_start_output,
       .start_input            = rep_start_input,
       .halt_output            = rep_halt_output,
       .halt_input             = rep_halt_input,
       .getdev                 = rep_getdev,
       .set_port               = rep_set_port,
       .get_port               = rep_get_port,
       .query_devinfo          = rep_query_devinfo,
       .get_props              = rep_get_props,
       .get_locks              = rep_get_locks,
};

/* hardware registers */

struct repulse_hw {
       vu_int16_t      rhw_status;
       vu_int16_t      rhw_fifostatus;         /* 0xrrrrpppp0000flag */
       vu_int16_t      rhw_reg_address;
       vu_int16_t      rhw_reg_data;
/* 0x08 */
       vu_int16_t      rhw_fifo_lh;
       vu_int16_t      rhw_fifo_ll;
       vu_int16_t      rhw_fifo_rh;
       vu_int16_t      rhw_fifo_rl;
/* 0x10 */
       vu_int16_t      rhw_fifo_pack;
       vu_int16_t      rhw_play_fifosz;
       vu_int32_t      rhw_spdifin_stat;
#define rhw_spdifout_stat rhw_spdifin_stat;

/* 0x18 */
       vu_int16_t      rhw_capt_fifosz;
       vu_int16_t      rhw_version;
       vu_int16_t      rhw_dummy1;
       vu_int8_t       rhw_firmwareload;
/* 0x1F */
       vu_int8_t       rhw_dummy2[66 - 31];
/* 0x42 */
       vu_int16_t      rhw_reset;
} /* __attribute__((packed)) */;

#define REPSTATUS_PLAY          0x0001
#define REPSTATUS_RECORD        0x0002
#define REPSTATUS_PLAYFIFORST   0x0004
#define REPSTATUS_RECFIFORST    0x0008

#define REPSTATUS_REGSENDBUSY   0x0010
#define REPSTATUS_LOOPBACK      0x0020
#define REPSTATUS_ENSPDIFIN     0x0040
#define REPSTATUS_ENSPDIFOUT    0x0080

#define REPSTATUS_CODECRESET    0x0200
#define REPSTATUS_SPDIFOUT24    0x0400
#define REPSTATUS_SPDIFIN24     0x0800

#define REPSTATUS_RECIRQENABLE  0x1000
#define REPSTATUS_RECIRQACK     0x2000
#define REPSTATUS_PLAYIRQENABLE 0x4000
#define REPSTATUS_PLAYIRQACK    0x8000

#define REPFIFO_PLAYFIFOFULL    0x0001
#define REPFIFO_PLAYFIFOEMPTY   0x0002
#define REPFIFO_RECFIFOFULL     0x0004
#define REPFIFO_RECFIFOEMPTY    0x0008
#define REPFIFO_PLAYFIFOGAUGE(x) ((x << 4) & 0xf000)
#define REPFIFO_RECFIFOGAUGE(x)         (x & 0xf000)

/* AmigaDOS Delay() ticks */

#define USECPERTICK     (1000000/50)

/* NetBSD device attachment */

struct repulse_softc {
       device_t                sc_dev;
       struct isr              sc_isr;
       struct ac97_host_if     sc_achost;
       struct ac97_codec_if    *sc_codec_if;

       struct repulse_hw       *sc_boardp;

       void    (*sc_captmore)(void *);
       void     *sc_captarg;

       void     *sc_captbuf;
       int       sc_captscale;
       int       sc_captbufsz;
       unsigned  sc_captflags;


       void    (*sc_playmore)(void *);
       void     *sc_playarg;
       int       sc_playscale;
       unsigned  sc_playflags;

       kmutex_t  sc_lock;
       kmutex_t  sc_intr_lock;
};

const struct audio_format repulse_format = {
       .mode           = AUMODE_PLAY | AUMODE_RECORD,
       .encoding       = AUDIO_ENCODING_SLINEAR_BE,
       .validbits      = 16,
       .precision      = 16,
       .channels       = 2,
       .channel_mask   = AUFMT_STEREO,
       .frequency_type = 6,
       .frequency      = { 8000, 16000, 22050, 32000, 44100, 48000 },
};

int repulse_match (device_t, cfdata_t, void *);
void repulse_attach (device_t, device_t, void *);

CFATTACH_DECL_NEW(repulse, sizeof(struct repulse_softc),
   repulse_match, repulse_attach, NULL, NULL);

int
repulse_match(device_t parent, cfdata_t cf, void *aux)
{
       struct zbus_args *zap;

       zap = aux;

       if (zap->manid != 0x4144)
               return (0);

       if (zap->prodid != 0)
               return (0);

       return (1);
}

void
repulse_attach(device_t parent, device_t self, void *aux)
{
       struct repulse_softc *sc;
       struct zbus_args *zap;
       struct repulse_hw *bp;
       const uint8_t *fwp;
       int needs_firmware;
       uint16_t a;

       sc = device_private(self);
       sc->sc_dev = self;
       zap = aux;
       bp = (struct repulse_hw *)zap->va;
       sc->sc_boardp = bp;
       sc->sc_playscale = 4;
       sc->sc_captscale = 4;

       needs_firmware = 0;
       if (bp->rhw_fifostatus & 0x00f0)
               needs_firmware = 1;
       else {
               bp->rhw_status = 0x000c;
               if (bp->rhw_status != 0 || bp->rhw_fifostatus != 0x0f0a)
                       needs_firmware = 1;
       }

       printf(": ");
       if (needs_firmware) {
               printf("loading ");
               bp->rhw_reset = 0;

               delay(1 * USECPERTICK);

               for (fwp = (const uint8_t *)repulse_firmware;
                   fwp < (repulse_firmware_size +
                   (const uint8_t *)repulse_firmware); fwp++)
                       bp->rhw_firmwareload = *fwp;

               delay(1 * USECPERTICK);

               if (bp->rhw_fifostatus & 0x00f0)
                       goto Initerr;

               a = /* bp->rhw_status;
               a |= */ REPSTATUS_CODECRESET;
               bp->rhw_status = a;

               a = bp->rhw_status;
               if ((a & REPSTATUS_CODECRESET) == 0)
                       goto Initerr;

               (void)bp->rhw_status;
               (void)bp->rhw_status;
               (void)bp->rhw_status;
               a = bp->rhw_status;
               a &= ~REPSTATUS_CODECRESET;
               bp->rhw_status = a;
       }

       printf("firmware version 0x%x\n", bp->rhw_version);

       sc->sc_achost.arg = sc;

       sc->sc_achost.reset = repac_reset;
       sc->sc_achost.read = repac_read;
       sc->sc_achost.write = repac_write;
       sc->sc_achost.attach = repac_attach;
       sc->sc_achost.flags = 0;

       mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
       mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED);

       if (ac97_attach(&sc->sc_achost, self, &sc->sc_lock)) {
               printf("%s: error attaching codec\n", device_xname(self));
               return;
       }

#ifdef DIAGNOSTIC
       /*
        * Print a warning if the codec doesn't support hardware variable
        * rate audio. As the initial incarnations of the Repulse board
        * are AC'97 2.1, it is expected that we'll always have VRA.
        */
       /*
        * XXX this should be a panic(). OTOH, audio codec speed is not
        * important enough to do this.
        */
       a = sc->sc_codec_if->vtbl->get_extcaps(sc->sc_codec_if);
       if (!(a & AC97_EXT_AUDIO_VRA)) {
               printf("%s: warning: codec doesn't support "
                   "hardware AC'97 2.0 Variable Rate Audio\n",
                       device_xname(self));
       }
#endif

       sc->sc_isr.isr_ipl = 2;
       sc->sc_isr.isr_arg = sc;
       sc->sc_isr.isr_intr = rep_intr;
       add_isr(&sc->sc_isr);

       audio_attach_mi(&rep_hw_if, sc, self);

       return;

Initerr:
       printf("\n%s: firmware not successfully loaded\n", device_xname(self));
       return;

}

int
repac_reset(void *arg)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;
       uint16_t a;

       sc = arg;
       bp = sc->sc_boardp;
       a = bp->rhw_status;
       a |= REPSTATUS_CODECRESET;
       bp->rhw_status = a;

       a = bp->rhw_status;
#ifdef DIAGNOSTIC
       if ((a & REPSTATUS_CODECRESET) == 0)
               panic("%s: cannot set reset bit", device_xname(sc->sc_dev));
#endif

       a = bp->rhw_status;
       a = bp->rhw_status;
       a = bp->rhw_status;
       a = bp->rhw_status;
       a &= ~REPSTATUS_CODECRESET;
       bp->rhw_status = a;
       return 0;
}

int
repac_read(void *arg, u_int8_t reg, u_int16_t *valuep)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;

       sc = arg;
       bp = sc->sc_boardp;
       while (bp->rhw_status & REPSTATUS_REGSENDBUSY)
               continue;
       bp->rhw_reg_address = (reg & 0x7F) | 0x80;

       while (bp->rhw_status & REPSTATUS_REGSENDBUSY)
               continue;

       *valuep = bp->rhw_reg_data;

       return 0;
}

int
repac_write(void *arg, uint8_t reg, uint16_t value)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;

       sc = arg;
       bp = sc->sc_boardp;
       bp->rhw_reg_data = value;
       bp->rhw_reg_address = reg & 0x7F;

       while (bp->rhw_status & REPSTATUS_REGSENDBUSY)
               continue;

       return 0;
}

int
repac_attach(void *arg, struct ac97_codec_if *acip)
{
       struct repulse_softc *sc;

       sc = arg;
       sc->sc_codec_if = acip;

       return 0;
}

/* audio(9) support stuff which is not ac97-constant */

int
rep_getdev(void *arg, struct audio_device *retp)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;

       if (retp != NULL) {
               sc = arg;
               bp = sc->sc_boardp;
               strncpy(retp->name, "Repulse", sizeof(retp->name));
               snprintf(retp->version, sizeof(retp->version), "0x%x",
                       bp->rhw_version);
               strncpy(retp->config, "", sizeof(retp->config));
       }

       return 0;
}

int
rep_get_props(void *v)
{

       return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE |
           AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
}

int
rep_halt_output(void *arg)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;

       sc = arg;
       bp = sc->sc_boardp;
       bp->rhw_status &= ~(REPSTATUS_PLAYIRQENABLE|REPSTATUS_PLAY);


       return 0;
}

int
rep_halt_input(void *arg)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;

       sc = arg;
       bp = sc->sc_boardp;
       bp->rhw_status &= ~(REPSTATUS_RECIRQENABLE|REPSTATUS_RECORD);

       return 0;
}

int
rep_query_format(void *arg, audio_format_query_t *afp)
{

       return audio_query_format(&repulse_format, 1, afp);
}

/*
* XXX the following three functions need to be enhanced for the FPGA s/pdif
* mode. Generic ac97 versions for now.
*/

int
rep_get_port(void *arg, mixer_ctrl_t *cp)
{
       struct repulse_softc *sc;

       sc = arg;
       return sc->sc_codec_if->vtbl->mixer_get_port(sc->sc_codec_if, cp);
}

int
rep_set_port(void *arg, mixer_ctrl_t *cp)
{
       struct repulse_softc *sc;

       sc = arg;
       return sc->sc_codec_if->vtbl->mixer_set_port(sc->sc_codec_if, cp);
}

int
rep_query_devinfo(void *arg, mixer_devinfo_t *dip)
{
       struct repulse_softc *sc;

       sc = arg;
       return sc->sc_codec_if->vtbl->query_devinfo(sc->sc_codec_if, dip);
}

int
rep_round_blocksize(void *arg, int blk, int mode, const audio_params_t *param)
{
       int b1;

       b1 = (blk & -32);

       if (b1 > 65536 / 2 / 2 /* channels */ / 4 /* bytes per channel */)
               b1 =  65536 / 2 / 2 / 4;
       return b1;
}

void
rep_get_locks(void *opaque, kmutex_t **intr, kmutex_t **thread)
{
       struct repulse_softc *sc = opaque;

       *intr = &sc->sc_intr_lock;
       *thread = &sc->sc_lock;
}


int
rep_set_format(void *addr, int setmode,
       const audio_params_t *play, const audio_params_t *rec,
       audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
       struct repulse_softc *sc;

       sc = addr;
       /* XXX 96kHz */
       if ((setmode & AUMODE_PLAY)) {
               repac_write(sc, AC97_REG_PCM_FRONT_DAC_RATE, play->sample_rate);
       }
       if ((setmode & AUMODE_RECORD)) {
               repac_write(sc, AC97_REG_PCM_LR_ADC_RATE, rec->sample_rate);
       }

       return 0;
}


int
rep_start_output(void *addr, void *block, int blksize,
       void (*intr)(void*), void *intrarg)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;
       uint16_t status;


       sc = addr;
       bp = sc->sc_boardp;

       /* TODO: prepare hw if necessary */
       status = bp->rhw_status;
       if (!(status & REPSTATUS_PLAY))
               bp->rhw_status = status |
                   REPSTATUS_PLAY | REPSTATUS_PLAYFIFORST;

       /* copy data */
       uint16_t *q = block;
       int length = blksize;
       while (length > 0) {
               bp->rhw_fifo_lh = *q++;
               bp->rhw_fifo_rh = *q++;
               length -= 4;
       }

       /* TODO: set hw if necessary */
       if (intr) {
               bp->rhw_status |= REPSTATUS_PLAYIRQENABLE;
               bp->rhw_play_fifosz = blksize / sc->sc_playscale / 2;
               /* /2: give us time to return on the first call */
       }

       /* save callback function */
       sc->sc_playarg = intrarg;
       sc->sc_playmore = intr;

       return 0;
}

int
rep_start_input(void *addr, void *block, int blksize,
       void (*intr)(void*), void *intrarg)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;
       uint16_t status;

       sc = addr;
       bp = sc->sc_boardp;

       sc->sc_captbuf = block;
       sc->sc_captbufsz = blksize;
       sc->sc_captarg = intrarg;
       sc->sc_captmore = intr;

       status = bp->rhw_status;
       if (!(status & REPSTATUS_RECORD))
               bp->rhw_status = status | REPSTATUS_RECORD
                       | REPSTATUS_RECFIFORST;

       bp->rhw_status |= REPSTATUS_RECIRQENABLE;
       bp->rhw_capt_fifosz = blksize / sc->sc_captscale;

       return 0;
}

/* irq handler */

int
rep_intr(void *tag)
{
       struct repulse_softc *sc;
       struct repulse_hw *bp;
       int foundone;
       uint16_t status;

       foundone = 0;

       sc = tag;

       mutex_spin_enter(&sc->sc_intr_lock);

       bp = sc->sc_boardp;
       status = bp->rhw_status;

       if (status & REPSTATUS_PLAYIRQACK) {
               foundone = 1;
               status &= ~REPSTATUS_PLAYIRQENABLE;
               bp->rhw_status = status;
               (*sc->sc_playmore)(sc->sc_playarg);
       }

       if (status & REPSTATUS_RECIRQACK) {
               foundone = 1;
               status &= ~REPSTATUS_RECIRQENABLE;
               bp->rhw_status = status;
               uint16_t *q = sc->sc_captbuf;
               int length = sc->sc_captbufsz;
               while (length > 0) {
                       *q++ = bp->rhw_fifo_lh;
                       *q++ = bp->rhw_fifo_rh;
                       length -= 4;
               }
               (*sc->sc_captmore)(sc->sc_captarg);
       }

       mutex_spin_exit(&sc->sc_intr_lock);

       return foundone;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.