/*      $NetBSD: intio_dmac.c,v 1.40 2024/01/07 07:58:33 isaki Exp $    */

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

/*
* Hitachi HD63450 (= Motorola MC68450) DMAC driver for x68k.
*/

#include "opt_m68k_arch.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: intio_dmac.c,v 1.40 2024/01/07 07:58:33 isaki Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <uvm/uvm_extern.h>

#include <machine/bus.h>
#include <machine/cpu.h>
#include <machine/frame.h>

#include <arch/x68k/dev/intiovar.h>
#include <arch/x68k/dev/dmacvar.h>

#ifdef DMAC_DEBUG
#define DPRINTF(n,x)    if (dmacdebug>((n)&0x0f)) printf x
#define DDUMPREGS(n,x)  if (dmacdebug>((n)&0x0f)) {printf x; dmac_dump_regs();}
int dmacdebug = 0;
#else
#define DPRINTF(n,x)
#define DDUMPREGS(n,x)
#endif

static void dmac_init_channels(struct dmac_softc *);
#ifdef DMAC_ARRAYCHAIN
static int dmac_program_arraychain(device_t, struct dmac_dma_xfer *,
       u_int, u_int);
#endif
static int dmac_done(void *);
static int dmac_error(void *);

#ifdef DMAC_DEBUG
static int dmac_dump_regs(void);
#endif

/*
* autoconf stuff
*/
static int dmac_match(device_t, cfdata_t, void *);
static void dmac_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(dmac, sizeof(struct dmac_softc),
   dmac_match, dmac_attach, NULL, NULL);

static int dmac_attached;

static int
dmac_match(device_t parent, cfdata_t cf, void *aux)
{
       struct intio_attach_args *ia = aux;

       if (strcmp(ia->ia_name, "dmac") != 0)
               return (0);
       if (dmac_attached)
               return (0);

       if (ia->ia_addr == INTIOCF_ADDR_DEFAULT)
               ia->ia_addr = DMAC_ADDR;

       /* fixed address */
       if (ia->ia_addr != DMAC_ADDR)
               return (0);
       if (ia->ia_intr != INTIOCF_INTR_DEFAULT)
               return (0);

       return 1;
}

static void
dmac_attach(device_t parent, device_t self, void *aux)
{
       struct dmac_softc *sc = device_private(self);
       struct intio_attach_args *ia = aux;
       struct intio_softc *intio;
       int r __diagused;

       sc->sc_dev = self;
       dmac_attached = 1;

       ia->ia_size = DMAC_CHAN_SIZE * DMAC_NCHAN;
       r = intio_map_allocate_region(parent, ia, INTIO_MAP_ALLOCATE);
#ifdef DIAGNOSTIC
       if (r)
               panic("IO map for DMAC corruption??");
#endif

       intio = device_private(parent);
       intio->sc_dmac = self;
       sc->sc_bst = ia->ia_bst;
       bus_space_map(sc->sc_bst, ia->ia_addr, ia->ia_size, 0, &sc->sc_bht);
       dmac_init_channels(sc);

       aprint_normal(": HD63450 DMAC\n");
       aprint_normal_dev(self, "4 channels available.\n");
}

static void
dmac_init_channels(struct dmac_softc *sc)
{
       int i;

       DPRINTF(3, ("dmac_init_channels\n"));
       for (i=0; i<DMAC_NCHAN; i++) {
               sc->sc_channels[i].ch_channel = i;
               sc->sc_channels[i].ch_name[0] = 0;
               sc->sc_channels[i].ch_softc = sc;
               bus_space_subregion(sc->sc_bst, sc->sc_bht,
                                   DMAC_CHAN_SIZE*i, DMAC_CHAN_SIZE,
                                   &sc->sc_channels[i].ch_bht);
               sc->sc_channels[i].ch_xfer.dx_dmamap = 0;
               /* reset the status register */
               bus_space_write_1(sc->sc_bst, sc->sc_channels[i].ch_bht,
                                 DMAC_REG_CSR, 0xff);
       }

       return;
}


/*
* Channel initialization/deinitialization per user device.
*/
struct dmac_channel_stat *
dmac_alloc_channel(device_t self, int ch, const char *name,
   int normalv, dmac_intr_handler_t normal, void *normalarg,
   int errorv,  dmac_intr_handler_t error,  void *errorarg,
   uint8_t dcr, uint8_t ocr)
{
       struct intio_softc *intio = device_private(self);
       struct dmac_softc *dmac = device_private(intio->sc_dmac);
       struct dmac_channel_stat *chan = &dmac->sc_channels[ch];
#ifdef DMAC_ARRAYCHAIN
       int r, dummy;
#endif

       aprint_normal_dev(dmac->sc_dev, "allocating ch %d for %s.\n",
               ch, name);
       DPRINTF(3, ("dmamap=%p\n", (void *)chan->ch_xfer.dx_dmamap));
#ifdef DIAGNOSTIC
       if (ch < 0 || ch >= DMAC_NCHAN)
               panic("Invalid DMAC channel.");
       if (chan->ch_name[0])
               panic("DMAC: channel in use.");
       if (strlen(name) > 8)
               panic("DMAC: wrong user name.");
#endif

#ifdef DMAC_ARRAYCHAIN
       /* allocate the DMAC arraychaining map */
       r = bus_dmamem_alloc(intio->sc_dmat,
                            sizeof(struct dmac_sg_array) * DMAC_MAPSIZE,
                            4, 0, &chan->ch_seg[0], 1, &dummy,
                            BUS_DMA_NOWAIT);
       if (r)
               panic("DMAC: cannot alloc DMA safe memory");
       r = bus_dmamem_map(intio->sc_dmat,
                          &chan->ch_seg[0], 1,
                          sizeof(struct dmac_sg_array) * DMAC_MAPSIZE,
                          (void **) &chan->ch_map,
                          BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
       if (r)
               panic("DMAC: cannot map DMA safe memory");
#endif

       /* fill the channel status structure by the default values. */
       strcpy(chan->ch_name, name);
       chan->ch_dcr = dcr;
       chan->ch_ocr = ocr;
       chan->ch_normalv = normalv;
       chan->ch_errorv = errorv;
       chan->ch_normal = normal;
       chan->ch_error = error;
       chan->ch_normalarg = normalarg;
       chan->ch_errorarg = errorarg;
       chan->ch_xfer.dx_dmamap = 0;

       /* setup the device-specific registers */
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht,
                          DMAC_REG_DCR, chan->ch_dcr);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CPR, 0);
       /* OCR will be written at dmac_load_xfer() */

       /*
        * X68k physical user space is a subset of the kernel space;
        * the memory is always included in the physical user space,
        * while the device is not.
        */
       bus_space_write_1(dmac->sc_bst, chan->ch_bht,
                          DMAC_REG_BFCR, DMAC_FC_USER_DATA);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht,
                          DMAC_REG_MFCR, DMAC_FC_USER_DATA);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht,
                          DMAC_REG_DFCR, DMAC_FC_KERNEL_DATA);

       /* setup the interrupt handlers */
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_NIVR, normalv);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_EIVR, errorv);

       intio_intr_establish_ext(normalv, name, "dma", dmac_done, chan);
       intio_intr_establish_ext(errorv, name, "dmaerr", dmac_error, chan);

       return chan;
}

int
dmac_free_channel(device_t self, int ch, void *channel)
{
       struct intio_softc *intio = device_private(self);
       struct dmac_softc *dmac = device_private(intio->sc_dmac);
       struct dmac_channel_stat *chan = &dmac->sc_channels[ch];

       DPRINTF(3, ("dmac_free_channel, %d\n", ch));
       DPRINTF(3, ("dmamap=%p\n", (void *)chan->ch_xfer.dx_dmamap));
       if (chan != channel)
               return -1;
       if (ch != chan->ch_channel)
               return -1;

#ifdef DMAC_ARRAYCHAIN
       bus_dmamem_unmap(intio->sc_dmat, (void *)chan->ch_map,
                        sizeof(struct dmac_sg_array) * DMAC_MAPSIZE);
       bus_dmamem_free(intio->sc_dmat, &chan->ch_seg[0], 1);
#endif
       chan->ch_name[0] = 0;
       intio_intr_disestablish(chan->ch_normalv, channel);
       intio_intr_disestablish(chan->ch_errorv, channel);

       return 0;
}

/*
* Initialization / deinitialization per transfer.
*/
struct dmac_dma_xfer *
dmac_alloc_xfer(struct dmac_channel_stat *chan, bus_dma_tag_t dmat,
   bus_dmamap_t dmamap)
{
       struct dmac_dma_xfer *xf = &chan->ch_xfer;

       DPRINTF(3, ("dmac_alloc_xfer\n"));
       xf->dx_channel = chan;
       xf->dx_dmamap = dmamap;
       xf->dx_tag = dmat;
#ifdef DMAC_ARRAYCHAIN
       xf->dx_array = chan->ch_map;
       xf->dx_done = 0;
#endif
       return xf;
}

int
dmac_load_xfer(struct dmac_softc *dmac, struct dmac_dma_xfer *xf)
{
       struct dmac_channel_stat *chan = xf->dx_channel;

       DPRINTF(3, ("dmac_load_xfer\n"));

       xf->dx_ocr &= ~DMAC_OCR_CHAIN_MASK;
       if (xf->dx_dmamap->dm_nsegs == 1)
               xf->dx_ocr |= DMAC_OCR_CHAIN_DISABLED;
       else {
               xf->dx_ocr |= DMAC_OCR_CHAIN_ARRAY;
       }

       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_SCR, xf->dx_scr);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht,
                         DMAC_REG_OCR, (xf->dx_ocr | chan->ch_ocr));
       bus_space_write_4(dmac->sc_bst, chan->ch_bht,
                         DMAC_REG_DAR, (int) xf->dx_device);

       return 0;
}

struct dmac_dma_xfer *
dmac_prepare_xfer(struct dmac_channel_stat *chan, bus_dma_tag_t dmat,
   bus_dmamap_t dmamap, int dir, int scr, void *dar)
{
       struct dmac_dma_xfer *xf;
       struct dmac_softc *dmac = chan->ch_softc;

       xf = dmac_alloc_xfer(chan, dmat, dmamap);

       xf->dx_ocr = dir & DMAC_OCR_DIR_MASK;
       xf->dx_scr = scr & (DMAC_SCR_MAC_MASK|DMAC_SCR_DAC_MASK);
       xf->dx_device = dar;

       dmac_load_xfer(dmac, xf);

       return xf;
}

#ifdef DMAC_DEBUG
static struct dmac_channel_stat *debugchan = 0;
#endif

/*
* Do the actual transfer.
*/
int
dmac_start_xfer(struct dmac_softc *dmac, struct dmac_dma_xfer *xf)
{
       return dmac_start_xfer_offset(dmac, xf, 0, 0);
}

int
dmac_start_xfer_offset(struct dmac_softc *dmac, struct dmac_dma_xfer *xf,
   u_int offset, u_int size)
{
       struct dmac_channel_stat *chan = xf->dx_channel;
       struct x68k_bus_dmamap *dmamap = xf->dx_dmamap;
       int go = DMAC_CCR_STR|DMAC_CCR_INT;
       bus_addr_t paddr;
       uint8_t csr;
#ifdef DMAC_ARRAYCHAIN
       int c = 0;
#endif

       DPRINTF(3, ("dmac_start_xfer\n"));
#ifdef DMAC_DEBUG
       debugchan=chan;
#endif

       if (size == 0) {
#ifdef DIAGNOSTIC
               if (offset != 0)
                       panic("dmac_start_xfer_offset: invalid offset %x",
                              offset);
#endif
               size = dmamap->dm_mapsize;
       }

#ifdef DMAC_ARRAYCHAIN
#ifdef DIAGNOSTIC
       if (xf->dx_done)
               panic("dmac_start_xfer: DMA transfer in progress");
#endif
#endif
       DPRINTF(3, ("First program:\n"));
#ifdef DIAGNOSTIC
       if ((offset >= dmamap->dm_mapsize) ||
           (offset + size > dmamap->dm_mapsize))
               panic("dmac_start_xfer_offset: invalid offset: "
                     "offset=%d, size=%d, mapsize=%ld",
                      offset, size, dmamap->dm_mapsize);
#endif
       /* program DMAC in single block mode or array chainning mode */
       if (dmamap->dm_nsegs == 1) {
               DPRINTF(3, ("single block mode\n"));
#ifdef DIAGNOSTIC
               if (dmamap->dm_mapsize != dmamap->dm_segs[0].ds_len)
                       panic("dmac_start_xfer_offset: dmamap curruption");
#endif
               paddr = dmamap->dm_segs[0].ds_addr + offset;
               csr = bus_space_read_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CSR);
               if ((csr & DMAC_CSR_ACT) != 0) {
                       /* Use 'Continue Mode' */
                       bus_space_write_4(dmac->sc_bst, chan->ch_bht,
                           DMAC_REG_BAR, paddr);
                       bus_space_write_2(dmac->sc_bst, chan->ch_bht,
                           DMAC_REG_BTCR, (int) size);
                       go |=  DMAC_CCR_CNT;
                       go &= ~DMAC_CCR_STR;
               } else {
                       bus_space_write_4(dmac->sc_bst, chan->ch_bht,
                                         DMAC_REG_MAR, paddr);
                       bus_space_write_2(dmac->sc_bst, chan->ch_bht,
                                         DMAC_REG_MTCR, (int) size);
               }
#ifdef DMAC_ARRAYCHAIN
               xf->dx_done = 1;
#endif
       } else {
#ifdef DMAC_ARRAYCHAIN
               c = dmac_program_arraychain(dmac->sc_dev, xf, offset, size);
               bus_space_write_4(dmac->sc_bst, chan->ch_bht,
                                 DMAC_REG_BAR, (int) chan->ch_seg[0].ds_addr);
               bus_space_write_2(dmac->sc_bst, chan->ch_bht,
                                 DMAC_REG_BTCR, c);
#else
               panic("DMAC: unexpected use of arraychaining mode");
#endif
       }

       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);

       /* START!! */
       DDUMPREGS(3, ("first start\n"));

#ifdef DMAC_ARRAYCHAIN
#if defined(M68040) || defined(M68060)
       /* flush data cache for the map */
       if (dmamap->dm_nsegs != 1 && mmutype == MMU_68040 && c > 0)
               dma_cachectl((void *) xf->dx_array,
                            sizeof(struct dmac_sg_array) * c);
#endif
#endif
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CCR, go);

       return 0;
}

#ifdef DMAC_ARRAYCHAIN
static int
dmac_program_arraychain(device_t self, struct dmac_dma_xfer *xf,
   u_int offset, u_int size)
{
       struct x68k_bus_dmamap *map = xf->dx_dmamap;
       int i, j;

       /* XXX not yet!! */
       if (offset != 0 || size != map->dm_mapsize)
               panic("dmac_program_arraychain: unsupported offset/size");

       DPRINTF(3, ("dmac_program_arraychain\n"));
       for (i=0, j=xf->dx_done; i<DMAC_MAPSIZE && j<map->dm_nsegs;
            i++, j++) {
               xf->dx_array[i].da_addr = map->dm_segs[j].ds_addr;
#ifdef DIAGNOSTIC
               if (map->dm_segs[j].ds_len > DMAC_MAXSEGSZ)
                       panic("dmac_program_arraychain: wrong map: %ld",
                              map->dm_segs[j].ds_len);
#endif
               xf->dx_array[i].da_count = map->dm_segs[j].ds_len;
       }
       xf->dx_done = j;

       return i;
}
#endif

/*
* interrupt handlers.
*/
static int
dmac_done(void *arg)
{
       struct dmac_channel_stat *chan = arg;
       struct dmac_softc *sc = chan->ch_softc;
#ifdef DMAC_ARRAYCHAIN
       struct dmac_dma_xfer *xf = &chan->ch_xfer;
       struct x68k_bus_dmamap *map = xf->dx_dmamap;
       int c;
#endif

       DPRINTF(3, ("dmac_done\n"));

       bus_space_write_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);

#ifdef DMAC_ARRAYCHAIN
       if (xf->dx_done == map->dm_nsegs) {
               xf->dx_done = 0;
#endif
               /* Done */
               return (*chan->ch_normal)(chan->ch_normalarg);
#ifdef DMAC_ARRAYCHAIN
       }
#endif

#ifdef DMAC_ARRAYCHAIN
       /* Continue transfer */
       DPRINTF(3, ("reprograming\n"));
       c = dmac_program_arraychain(sc->sc_dev, xf, 0, map->dm_mapsize);

       bus_space_write_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);
       bus_space_write_4(sc->sc_bst, chan->ch_bht,
                         DMAC_REG_BAR, (int) chan->ch_map);
       bus_space_write_4(sc->sc_bst, chan->ch_bht,
                         DMAC_REG_DAR, (int) xf->dx_device);
       bus_space_write_2(sc->sc_bst, chan->ch_bht, DMAC_REG_BTCR, c);

       /* START!! */
       DDUMPREGS(3, ("restart\n"));
       bus_space_write_1(sc->sc_bst, chan->ch_bht,
                         DMAC_REG_CCR, DMAC_CCR_STR|DMAC_CCR_INT);

       return 1;
#endif
}

static int
dmac_error(void *arg)
{
       struct dmac_channel_stat *chan = arg;
       struct dmac_softc *sc = chan->ch_softc;
       uint8_t csr, cer;

       csr = bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CSR);
       cer = bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CER);

#ifndef DMAC_DEBUG
       /* Software abort (CER=0x11) could happen on normal xfer termination */
       if (cer != 0x11)
#endif
       {
               printf("DMAC transfer error CSR=%02x, CER=%02x\n", csr, cer);
       }
       DDUMPREGS(3, ("registers were:\n"));

       /* Clear the status bits */
       bus_space_write_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);

#ifdef DMAC_ARRAYCHAIN
       chan->ch_xfer.dx_done = 0;
#endif

       return (*chan->ch_error)(chan->ch_errorarg);
}

int
dmac_abort_xfer(struct dmac_softc *dmac, struct dmac_dma_xfer *xf)
{
       struct dmac_channel_stat *chan = xf->dx_channel;

       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CCR,
                         DMAC_CCR_INT | DMAC_CCR_SAB);
       bus_space_write_1(dmac->sc_bst, chan->ch_bht, DMAC_REG_CSR, 0xff);

       return 0;
}

#ifdef DMAC_DEBUG
static int
dmac_dump_regs(void)
{
       struct dmac_channel_stat *chan = debugchan;
       struct dmac_softc *sc;

       if ((chan == 0) || (dmacdebug & 0xf0))
               return 0;
       sc = chan->ch_softc;

       printf("DMAC channel %d registers\n", chan->ch_channel);
       printf("CSR=%02x, CER=%02x, DCR=%02x, OCR=%02x, SCR=%02x, "
               "CCR=%02x, CPR=%02x, GCR=%02x\n",
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CSR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CER),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_DCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_OCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_SCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_CPR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_GCR));
       printf("NIVR=%02x, EIVR=%02x, MTCR=%04x, BTCR=%04x, DFCR=%02x, "
               "MFCR=%02x, BFCR=%02x\n",
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_NIVR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_EIVR),
               bus_space_read_2(sc->sc_bst, chan->ch_bht, DMAC_REG_MTCR),
               bus_space_read_2(sc->sc_bst, chan->ch_bht, DMAC_REG_BTCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_DFCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_MFCR),
               bus_space_read_1(sc->sc_bst, chan->ch_bht, DMAC_REG_BFCR));
       printf("DAR=%08x, MAR=%08x, BAR=%08x\n",
               bus_space_read_4(sc->sc_bst, chan->ch_bht, DMAC_REG_DAR),
               bus_space_read_4(sc->sc_bst, chan->ch_bht, DMAC_REG_MAR),
               bus_space_read_4(sc->sc_bst, chan->ch_bht, DMAC_REG_BAR));

       return 0;
}
#endif

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.