/*      $NetBSD: cs4231_ebus.c,v 1.39 2019/05/08 13:40:17 isaki Exp $ */

/*
* Copyright (c) 2002 Valeriy E. Ushakov
* 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: cs4231_ebus.c,v 1.39 2019/05/08 13:40:17 isaki Exp $");

#ifdef _KERNEL_OPT
#include "opt_sparc_arch.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/device.h>
#include <sys/cpu.h>
#include <sys/kmem.h>
#include <sys/malloc.h>

#include <machine/autoconf.h>

#include <dev/ebus/ebusreg.h>
#include <dev/ebus/ebusvar.h>

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

#include <dev/ic/ad1848reg.h>
#include <dev/ic/cs4231reg.h>
#include <dev/ic/ad1848var.h>
#include <dev/ic/cs4231var.h>

#ifdef AUDIO_DEBUG
int cs4231_ebus_debug = 0;
#define DPRINTF(x)      if (cs4231_ebus_debug) printf x
#else
#define DPRINTF(x)
#endif


struct cs4231_ebus_softc {
       struct cs4231_softc sc_cs4231;

       void *sc_pint;
       void *sc_rint;
       bus_space_tag_t sc_bt;
       bus_space_handle_t sc_pdmareg; /* playback DMA */
       bus_space_handle_t sc_cdmareg; /* record DMA */
};


void    cs4231_ebus_attach(device_t, device_t, void *);
int     cs4231_ebus_match(device_t, cfdata_t, void *);

static int      cs4231_ebus_pint(void *);
static int      cs4231_ebus_rint(void *);

CFATTACH_DECL_NEW(audiocs_ebus, sizeof(struct cs4231_ebus_softc),
   cs4231_ebus_match, cs4231_ebus_attach, NULL, NULL);

/* audio_hw_if methods specific to ebus DMA */
static int      cs4231_ebus_round_blocksize(void *, int, int,
                                           const audio_params_t *);
static int      cs4231_ebus_trigger_output(void *, void *, void *, int,
                                          void (*)(void *), void *,
                                          const audio_params_t *);
static int      cs4231_ebus_trigger_input(void *, void *, void *, int,
                                         void (*)(void *), void *,
                                         const audio_params_t *);
static int      cs4231_ebus_halt_output(void *);
static int      cs4231_ebus_halt_input(void *);

const struct audio_hw_if audiocs_ebus_hw_if = {
       .open                   = cs4231_open,
       .close                  = cs4231_close,
       .query_format           = ad1848_query_format,
       .set_format             = ad1848_set_format,
       .round_blocksize        = cs4231_ebus_round_blocksize,
       .commit_settings        = ad1848_commit_settings,
       .halt_output            = cs4231_ebus_halt_output,
       .halt_input             = cs4231_ebus_halt_input,
       .getdev                 = cs4231_getdev,
       .set_port               = cs4231_set_port,
       .get_port               = cs4231_get_port,
       .query_devinfo          = cs4231_query_devinfo,
       .allocm                 = cs4231_malloc,
       .freem                  = cs4231_free,
       .get_props              = cs4231_get_props,
       .trigger_output         = cs4231_ebus_trigger_output,
       .trigger_input          = cs4231_ebus_trigger_input,
       .get_locks              = ad1848_get_locks,
};

#ifdef AUDIO_DEBUG
static void     cs4231_ebus_regdump(const char *, struct cs4231_ebus_softc *);
#endif

static int      cs4231_ebus_dma_reset(bus_space_tag_t, bus_space_handle_t);
static int      cs4231_ebus_trigger_transfer(struct cs4231_softc *,
                       struct cs_transfer *,
                       bus_space_tag_t, bus_space_handle_t,
                       int, void *, void *, int, void (*)(void *), void *,
                       const audio_params_t *);
static void     cs4231_ebus_dma_advance(struct cs_transfer *,
                                       bus_space_tag_t, bus_space_handle_t);
static int      cs4231_ebus_dma_intr(struct cs_transfer *,
                                    bus_space_tag_t, bus_space_handle_t,
                                    void *);
static int      cs4231_ebus_intr(void *);


int
cs4231_ebus_match(device_t parent, cfdata_t cf, void *aux)
{
       struct ebus_attach_args *ea;
       char *compat;
       int len, total_size;

       ea = aux;
       if (strcmp(ea->ea_name, AUDIOCS_PROM_NAME) == 0)
               return 1;

       compat = NULL;
       if (prom_getprop(ea->ea_node, "compatible", 1, &total_size, &compat) == 0) {
               do {
                       if (strcmp(compat, AUDIOCS_PROM_NAME) == 0)
                               return 1;
#ifdef __sparc__
                       /* on KRUPS compatible lists: "cs4231", "ad1848",
                        * "mwave", and "pnpPNP,b007" */
                       if (strcmp(compat, "cs4231") == 0)
                               return 1;
#endif
                       len = strlen(compat) + 1;
                       total_size -= len;
                       compat += len;
               } while (total_size > 0);
       }

       return 0;
}


void
cs4231_ebus_attach(device_t parent, device_t self, void *aux)
{
       struct cs4231_ebus_softc *ebsc;
       struct cs4231_softc *sc;
       struct ebus_attach_args *ea;
       bus_space_handle_t bh;
       int i;

       ebsc = device_private(self);
       sc = &ebsc->sc_cs4231;
       ea = aux;
       sc->sc_bustag = ebsc->sc_bt = ea->ea_bustag;
       sc->sc_dmatag = ea->ea_dmatag;

       ebsc->sc_pint = sparc_softintr_establish(IPL_VM,
           (void *)cs4231_ebus_pint, sc);
       ebsc->sc_rint = sparc_softintr_establish(IPL_VM,
           (void *)cs4231_ebus_rint, sc);

       /*
        * These are the register we get from the prom:
        *      - CS4231 registers
        *      - Playback EBus DMA controller
        *      - Capture EBus DMA controller
        *      - AUXIO audio register (codec powerdown)
        *
        * Map my registers in, if they aren't already in virtual
        * address space.
        */
       if (bus_space_map(ea->ea_bustag, EBUS_ADDR_FROM_REG(&ea->ea_reg[0]),
               ea->ea_reg[0].size, 0, &bh) != 0) {
               printf(": unable to map registers\n");
               return;
       }

       if (bus_space_map(ea->ea_bustag,
#ifdef MSIIEP           /* XXX: Krups */
                         /*
                          * XXX: map playback DMA registers
                          * (we just know where they are)
                          */
                         BUS_ADDR(0x14, 0x702000), /* XXX: magic num */
                         EBUS_DMAC_SIZE,
#else
                         EBUS_ADDR_FROM_REG(&ea->ea_reg[1]),
                         ea->ea_reg[1].size,
#endif
                         0, &ebsc->sc_pdmareg) != 0)
       {
               printf(": unable to map playback DMA registers\n");
               return;
       }

       if (bus_space_map(ea->ea_bustag,
#ifdef MSIIEP           /* XXX: Krups */
                         /*
                          * XXX: map capture DMA registers
                          * (we just know where they are)
                          */
                         BUS_ADDR(0x14, 0x704000), /* XXX: magic num */
                         EBUS_DMAC_SIZE,
#else
                         EBUS_ADDR_FROM_REG(&ea->ea_reg[2]),
                         ea->ea_reg[2].size,
#endif
                         0, &ebsc->sc_cdmareg) != 0)
       {
               printf(": unable to map capture DMA registers\n");
               return;
       }

       ad1848_init_locks(&sc->sc_ad1848, IPL_SCHED);

       /* establish interrupt channels */
       for (i = 0; i < ea->ea_nintr; ++i)
               bus_intr_establish(ea->ea_bustag,
                                  ea->ea_intr[i], IPL_SCHED,
                                  cs4231_ebus_intr, ebsc);

       cs4231_common_attach(sc, self, bh);
       printf("\n");

       /* XXX: todo: move to cs4231_common_attach, pass hw_if as arg? */
       audio_attach_mi(&audiocs_ebus_hw_if, sc, sc->sc_ad1848.sc_dev);
}


static int
cs4231_ebus_round_blocksize(void *addr, int blk, int mode,
                           const audio_params_t *param)
{
       int sz;

       /* we want to use DMA burst size of 16 words */
       sz = blk & -64;
       if (sz == 0)
               sz = 64;        /* zero is not a good blocksize */
       return sz;
}


#ifdef AUDIO_DEBUG
static void
cs4231_ebus_regdump(const char *label, struct cs4231_ebus_softc *ebsc)
{
       /* char bits[128]; */

       printf("cs4231regdump(%s): regs:", label);
       /* XXX: dump ebus DMA and aux registers */
       ad1848_dump_regs(&ebsc->sc_cs4231.sc_ad1848);
}
#endif /* AUDIO_DEBUG */


/* XXX: nothing CS4231-specific in this code... */
static int
cs4231_ebus_dma_reset(bus_space_tag_t dt, bus_space_handle_t dh)
{
       u_int32_t csr;
       int timo;

       /* reset, also clear TC, just in case */
       bus_space_write_4(dt, dh, EBUS_DMAC_DCSR, EBDMA_RESET | EBDMA_TC);

       for (timo = 50000; timo != 0; --timo) {
               csr = bus_space_read_4(dt, dh, EBUS_DMAC_DCSR);
               if ((csr & (EBDMA_CYC_PEND | EBDMA_DRAIN)) == 0)
                       break;
       }

       if (timo == 0) {
               char bits[128];
               snprintb(bits, sizeof(bits), EBUS_DCSR_BITS, csr);
               printf("cs4231_ebus_dma_reset: timed out: csr=%s\n", bits);
               return ETIMEDOUT;
       }

       bus_space_write_4(dt, dh, EBUS_DMAC_DCSR, csr & ~EBDMA_RESET);
       return 0;
}


static void
cs4231_ebus_dma_advance(struct cs_transfer *t, bus_space_tag_t dt,
                       bus_space_handle_t dh)
{
       bus_addr_t dmaaddr;
       bus_size_t dmasize;

       cs4231_transfer_advance(t, &dmaaddr, &dmasize);

       bus_space_write_4(dt, dh, EBUS_DMAC_DNBR, (u_int32_t)dmasize);
       bus_space_write_4(dt, dh, EBUS_DMAC_DNAR, (u_int32_t)dmaaddr);
}


/*
* Trigger transfer "t" using DMA controller at "dt"/"dh".
* "iswrite" defines direction of the transfer.
*/
static int
cs4231_ebus_trigger_transfer(
       struct cs4231_softc *sc,
       struct cs_transfer *t,
       bus_space_tag_t dt,
       bus_space_handle_t dh,
       int iswrite,
       void *start, void *end,
       int blksize,
       void (*intr)(void *),
       void *arg,
       const audio_params_t *param)
{
       uint32_t csr;
       bus_addr_t dmaaddr;
       bus_size_t dmasize;
       int ret;

       ret = cs4231_transfer_init(sc, t, &dmaaddr, &dmasize,
                                  start, end, blksize, intr, arg);
       if (ret != 0)
               return ret;

       ret = cs4231_ebus_dma_reset(dt, dh);
       if (ret != 0)
               return ret;

       csr = bus_space_read_4(dt, dh, EBUS_DMAC_DCSR);
       bus_space_write_4(dt, dh, EBUS_DMAC_DCSR,
                         csr | EBDMA_EN_NEXT | (iswrite ? EBDMA_WRITE : 0)
                         | EBDMA_EN_DMA | EBDMA_EN_CNT | EBDMA_INT_EN
                         | EBDMA_BURST_SIZE_16);

       /* first load: propagated to DACR/DBCR */
       bus_space_write_4(dt, dh, EBUS_DMAC_DNBR, (uint32_t)dmasize);
       bus_space_write_4(dt, dh, EBUS_DMAC_DNAR, (uint32_t)dmaaddr);

       /* next load: goes to DNAR/DNBR */
       cs4231_ebus_dma_advance(t, dt, dh);

       return 0;
}


static int
cs4231_ebus_trigger_output(void *addr, void *start, void *end, int blksize,
                          void (*intr)(void *), void *arg,
                          const audio_params_t *param)
{
       struct cs4231_ebus_softc *ebsc;
       struct cs4231_softc *sc;
       int cfg, ret;

       ebsc = addr;
       sc = &ebsc->sc_cs4231;
       ret = cs4231_ebus_trigger_transfer(sc, &sc->sc_playback,
                                          ebsc->sc_bt, ebsc->sc_pdmareg,
                                          0, /* iswrite */
                                          start, end, blksize,
                                          intr, arg, param);
       if (ret != 0)
               return ret;

       ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff);
       ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff);

       cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG);
       ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, cfg | PLAYBACK_ENABLE);

       return 0;
}


static int
cs4231_ebus_trigger_input(void *addr, void *start, void *end, int blksize,
                         void (*intr)(void *), void *arg,
                         const audio_params_t *param)
{
       struct cs4231_ebus_softc *ebsc;
       struct cs4231_softc *sc;
       int cfg, ret;

       ebsc = addr;
       sc = &ebsc->sc_cs4231;
       ret = cs4231_ebus_trigger_transfer(sc, &sc->sc_capture,
                                          ebsc->sc_bt, ebsc->sc_cdmareg,
                                          1, /* iswrite */
                                          start, end, blksize,
                                          intr, arg, param);
       if (ret != 0)
               return ret;

       ad_write(&sc->sc_ad1848, CS_LOWER_REC_CNT, 0xff);
       ad_write(&sc->sc_ad1848, CS_UPPER_REC_CNT, 0xff);

       cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG);
       ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, cfg | CAPTURE_ENABLE);

       return 0;
}


static int
cs4231_ebus_halt_output(void *addr)
{
       struct cs4231_ebus_softc *ebsc;
       struct cs4231_softc *sc;
       u_int32_t csr;
       int cfg;

       ebsc = addr;
       sc = &ebsc->sc_cs4231;
       sc->sc_playback.t_active = 0;

       csr = bus_space_read_4(ebsc->sc_bt, ebsc->sc_pdmareg, EBUS_DMAC_DCSR);
       bus_space_write_4(ebsc->sc_bt, ebsc->sc_pdmareg, EBUS_DMAC_DCSR,
                         csr & ~EBDMA_EN_DMA);

       cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG);
       ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG,
                cfg & ~PLAYBACK_ENABLE);

       return 0;
}


static int
cs4231_ebus_halt_input(void *addr)
{
       struct cs4231_ebus_softc *ebsc;
       struct cs4231_softc *sc;
       uint32_t csr;
       int cfg;

       ebsc = addr;
       sc = &ebsc->sc_cs4231;
       sc->sc_capture.t_active = 0;

       csr = bus_space_read_4(ebsc->sc_bt, ebsc->sc_cdmareg, EBUS_DMAC_DCSR);
       bus_space_write_4(ebsc->sc_bt, ebsc->sc_cdmareg, EBUS_DMAC_DCSR,
                         csr & ~EBDMA_EN_DMA);

       cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG);
       ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG,
                cfg & ~CAPTURE_ENABLE);

       return 0;
}


static int
cs4231_ebus_dma_intr(struct cs_transfer *t, bus_space_tag_t dt,
                    bus_space_handle_t dh, void *sih)
{
       uint32_t csr;
#ifdef AUDIO_DEBUG
       char bits[128];
#endif

       /* read DMA status, clear TC bit by writing it back */
       csr = bus_space_read_4(dt, dh, EBUS_DMAC_DCSR);
       bus_space_write_4(dt, dh, EBUS_DMAC_DCSR, csr);
#ifdef AUDIO_DEBUG
       snprintb(bits, sizeof(bits), EBUS_DCSR_BITS, csr);
       DPRINTF(("audiocs: %s dcsr=%s\n", t->t_name, bits));
#endif

       if (csr & EBDMA_ERR_PEND) {
               ++t->t_ierrcnt.ev_count;
               printf("audiocs: %s DMA error, resetting\n", t->t_name);
               cs4231_ebus_dma_reset(dt, dh);
               /* how to notify audio(9)??? */
               return 1;
       }

       if ((csr & EBDMA_INT_PEND) == 0)
               return 0;

       ++t->t_intrcnt.ev_count;

       if ((csr & EBDMA_TC) == 0) { /* can this happen? */
               printf("audiocs: %s INT_PEND but !TC\n", t->t_name);
               return 1;
       }

       if (!t->t_active)
               return 1;

       cs4231_ebus_dma_advance(t, dt, dh);

       /* call audio(9) framework while DMA is chugging along */
       if (t->t_intr != NULL)
               sparc_softintr_schedule(sih);
       return 1;
}


static int
cs4231_ebus_intr(void *arg)
{
       struct cs4231_ebus_softc *ebsc;
       struct cs4231_softc *sc;
       int status;
       int ret;
#ifdef AUDIO_DEBUG
       char bits[128];
#endif

       ebsc = arg;
       sc = &ebsc->sc_cs4231;
       mutex_spin_enter(&sc->sc_ad1848.sc_intr_lock);

       status = ADREAD(&sc->sc_ad1848, AD1848_STATUS);

#ifdef AUDIO_DEBUG
       if (cs4231_ebus_debug > 1)
               cs4231_ebus_regdump("audiointr", ebsc);

       snprintb(bits, sizeof(bits), AD_R2_BITS, status);
       DPRINTF(("%s: status: %s\n", device_xname(sc->sc_ad1848.sc_dev),
           bits));
#endif

       if (status & INTERRUPT_STATUS) {
#ifdef AUDIO_DEBUG
               int reason;

               reason = ad_read(&sc->sc_ad1848, CS_IRQ_STATUS);
               snprintb(bits, sizeof(bits), CS_I24_BITS, reason);
               DPRINTF(("%s: i24: %s\n", device_xname(sc->sc_ad1848.sc_dev),
                   bits));
#endif
               /* clear interrupt from ad1848 */
               ADWRITE(&sc->sc_ad1848, AD1848_STATUS, 0);
       }

       ret = 0;

       if (cs4231_ebus_dma_intr(&sc->sc_capture, ebsc->sc_bt,
           ebsc->sc_cdmareg, ebsc->sc_rint) != 0)
       {
               ++sc->sc_intrcnt.ev_count;
               ret = 1;
       }

       if (cs4231_ebus_dma_intr(&sc->sc_playback, ebsc->sc_bt,
           ebsc->sc_pdmareg, ebsc->sc_pint) != 0)
       {
               ++sc->sc_intrcnt.ev_count;
               ret = 1;
       }

       mutex_spin_exit(&sc->sc_ad1848.sc_intr_lock);

       return ret;
}

static int
cs4231_ebus_pint(void *cookie)
{
       struct cs4231_softc *sc = cookie;
       struct cs_transfer *t = &sc->sc_playback;

       mutex_spin_enter(&sc->sc_ad1848.sc_intr_lock);
       if (t->t_intr != NULL)
               (*t->t_intr)(t->t_arg);
       mutex_spin_exit(&sc->sc_ad1848.sc_intr_lock);
       return 0;
}

static int
cs4231_ebus_rint(void *cookie)
{
       struct cs4231_softc *sc = cookie;
       struct cs_transfer *t = &sc->sc_capture;

       mutex_spin_enter(&sc->sc_ad1848.sc_intr_lock);
       if (t->t_intr != NULL)
               (*t->t_intr)(t->t_arg);
       mutex_spin_exit(&sc->sc_ad1848.sc_intr_lock);
       return 0;
}