/* $NetBSD: spc.c,v 1.9 2024/01/16 05:48:28 thorpej Exp $ */

/*-
* Copyright (c) 2003 Izumi Tsutsui.  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.
*
* 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 "opt_ddb.h"
#include "opt_useleds.h"

#include <sys/cdefs.h>                  /* RCS ID & Copyright macro defns */

__KERNEL_RCSID(0, "$NetBSD: spc.c,v 1.9 2024/01/16 05:48:28 thorpej Exp $");

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

#include <machine/autoconf.h>
#include <machine/bus.h>
#include <machine/cpu.h>
#include <machine/intr.h>

#include <hp300/dev/dioreg.h>
#include <hp300/dev/diovar.h>
#include <hp300/dev/diodevs.h>

#include <dev/scsipi/scsi_all.h>
#include <dev/scsipi/scsipi_all.h>
#include <dev/scsipi/scsi_message.h>
#include <dev/scsipi/scsiconf.h>

#include <dev/ic/mb89352reg.h>
#include <dev/ic/mb89352var.h>

#include <hp300/dev/hp98265reg.h>
#include <hp300/dev/dmareg.h>
#include <hp300/dev/dmavar.h>

#ifdef USELEDS
#include <hp300/hp300/leds.h>
#endif

static int      spc_dio_match(device_t, cfdata_t, void *);
static void     spc_dio_attach(device_t, device_t, void *);
static void     spc_dio_dmastart(struct spc_softc *, void *, size_t, int);
static void     spc_dio_dmadone(struct spc_softc *);
static void     spc_dio_dmago(void *);
static void     spc_dio_dmastop(void *);

struct spc_dio_softc {
       struct spc_softc sc_spc;        /* MI spc softc */

       /* DIO specific goo. */
       struct bus_space_tag sc_tag;    /* bus space tag with oddbyte func */
       bus_space_handle_t sc_iohsc;    /* bus space handle for HPSCSI */
       struct dmaqueue sc_dq;          /* DMA job queue */
       u_int sc_dflags;                /* DMA flags */
#define SCSI_DMA32      0x01            /* 32-bit DMA should be used */
#define SCSI_HAVEDMA    0x02            /* controller has DMA channel */
#define SCSI_DATAIN     0x04            /* DMA direction */
};

CFATTACH_DECL_NEW(spc, sizeof(struct spc_dio_softc),
   spc_dio_match, spc_dio_attach, NULL, NULL);

static int
spc_dio_match(device_t parent, cfdata_t cf, void *aux)
{
       struct dio_attach_args *da = aux;

       switch (da->da_id) {
       case DIO_DEVICE_ID_SCSI0:
       case DIO_DEVICE_ID_SCSI1:
       case DIO_DEVICE_ID_SCSI2:
       case DIO_DEVICE_ID_SCSI3:
               return 1;
       }

       return 0;
}

static void
spc_dio_attach(device_t parent, device_t self, void *aux)
{
       struct spc_dio_softc *dsc = device_private(self);
       struct spc_softc *sc = &dsc->sc_spc;
       struct dio_attach_args *da = aux;
       bus_space_tag_t iot = &dsc->sc_tag;
       bus_space_handle_t iohsc, iohspc;
       uint8_t id;

       sc->sc_dev = self;
       memcpy(iot, da->da_bst, sizeof(struct bus_space_tag));
       dio_set_bus_space_oddbyte(iot);

       if (bus_space_map(iot, da->da_addr, da->da_size, 0, &iohsc)) {
               aprint_error(": can't map SCSI registers\n");
               return;
       }

       if (bus_space_subregion(iot, iohsc, SPC_OFFSET, SPC_SIZE, &iohspc)) {
               aprint_error(": can't map SPC registers\n");
               return;
       }

       aprint_normal(": 98265A SCSI");

       bus_space_write_1(iot, iohsc, HPSCSI_ID, 0xff);
       DELAY(100);
       id = bus_space_read_1(iot, iohsc, HPSCSI_ID);
       if ((id & ID_WORD_DMA) == 0) {
               aprint_normal(", 32-bit DMA");
               dsc->sc_dflags |= SCSI_DMA32;
       }
       id &= ID_MASK;
       aprint_normal(", SCSI ID %d\n", id);

       sc->sc_iot = iot;
       sc->sc_ioh = iohspc;
       sc->sc_initiator = id;

       sc->sc_dma_start = spc_dio_dmastart;
       sc->sc_dma_done  = spc_dio_dmadone;

       dsc->sc_iohsc = iohsc;
       dsc->sc_dq.dq_softc = dsc;
       dsc->sc_dq.dq_start = spc_dio_dmago;
       dsc->sc_dq.dq_done  = spc_dio_dmastop;

       bus_space_write_1(iot, iohsc, HPSCSI_CSR, 0x00);
       bus_space_write_1(iot, iohsc, HPSCSI_HCONF, 0x00);

       dio_intr_establish(spc_intr, (void *)sc, da->da_ipl, ISRPRI_BIO);

       spc_attach(sc);

       /* Enable SPC interrupts. */
       bus_space_write_1(iot, iohsc, HPSCSI_CSR, CSR_IE);
}

static void
spc_dio_dmastart(struct spc_softc *sc, void *addr, size_t size, int datain)
{
       struct spc_dio_softc *dsc = (struct spc_dio_softc *)sc;

       dsc->sc_dq.dq_chan = DMA0 | DMA1;
       dsc->sc_dflags |= SCSI_HAVEDMA;
       if (datain)
               dsc->sc_dflags |= SCSI_DATAIN;
       else
               dsc->sc_dflags &= ~SCSI_DATAIN;

       if (dmareq(&dsc->sc_dq) != 0)
               /* DMA channel is available, so start DMA immediately */
               spc_dio_dmago(dsc);
       /* else dma start function will be called later from dmafree(). */
}

static void
spc_dio_dmago(void *arg)
{
       struct spc_dio_softc *dsc = arg;
       struct spc_softc *sc = &dsc->sc_spc;
       bus_space_tag_t iot;
       bus_space_handle_t iohsc, iohspc;
       int len, chan;
       uint32_t dmaflags;
       uint8_t cmd;

       iot = sc->sc_iot;
       iohspc = sc->sc_ioh;
       iohsc = dsc->sc_iohsc;

       bus_space_write_1(iot, iohsc, HPSCSI_HCONF, 0);

       cmd = CSR_IE;
       dmaflags = DMAGO_NOINT;
       chan = dsc->sc_dq.dq_chan;
       if ((dsc->sc_dflags & SCSI_DATAIN) != 0) {
               cmd |= CSR_DMAIN;
               dmaflags |= DMAGO_READ;
       }
       if ((dsc->sc_dflags & SCSI_DMA32) != 0 &&
           ((u_int)sc->sc_dp & 3) == 0 &&
           (sc->sc_dleft & 3) == 0) {
               cmd |= CSR_DMA32;
               dmaflags |= DMAGO_LWORD;
       } else
               dmaflags |= DMAGO_WORD;

       dmago(chan, sc->sc_dp, sc->sc_dleft, dmaflags);

       bus_space_write_1(iot, iohsc, HPSCSI_CSR, cmd);
       cmd |= (chan == 0) ? CSR_DE0 : CSR_DE1;
       bus_space_write_1(iot, iohsc, HPSCSI_CSR, cmd);

       cmd = SCMD_XFR;
       len = sc->sc_dleft;

       if ((len & (DEV_BSIZE - 1)) != 0) /* XXX ??? */ {
               cmd |= SCMD_PAD;
#if 0
               if ((dsc->sc_dflags & SCSI_DATAIN) != 0)
                       len += 2; /* XXX ??? */
#endif
       }

       bus_space_write_1(iot, iohspc, TCH, len >> 16);
       bus_space_write_1(iot, iohspc, TCM, len >>  8);
       bus_space_write_1(iot, iohspc, TCL, len);
       bus_space_write_1(iot, iohspc, PCTL, sc->sc_phase | PCTL_BFINT_ENAB);
       bus_space_write_1(iot, iohspc, SCMD, cmd);

       sc->sc_flags |= SPC_DOINGDMA;
#ifdef USELEDS
       ledcontrol(LED_DISK, 0, 0);
#endif
}

static void
spc_dio_dmadone(struct spc_softc *sc)
{
       struct spc_dio_softc *dsc = (struct spc_dio_softc *)sc;
       bus_space_tag_t iot;
       bus_space_handle_t ioh, iohsc;
       int resid, trans;
       uint8_t cmd;

       iot = sc->sc_iot;
       ioh = sc->sc_ioh;
       iohsc = dsc->sc_iohsc;

       /* wait DMA complete */
       if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) {
               int timeout = 1000; /* XXX how long? */
               while ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) {
                       if (--timeout < 0)
                               printf("%s: DMA complete timeout\n",
                                   device_xname(sc->sc_dev));
                       DELAY(1);
               }
       }

       if ((dsc->sc_dflags & SCSI_HAVEDMA) != 0) {
               dmafree(&dsc->sc_dq);
               dsc->sc_dflags &= ~SCSI_HAVEDMA;
       }

       cmd = bus_space_read_1(iot, iohsc, HPSCSI_CSR);
       cmd &= ~(CSR_DE1|CSR_DE0);
       bus_space_write_1(iot, iohsc, HPSCSI_CSR, cmd);

       resid = bus_space_read_1(iot, ioh, TCH) << 16 |
           bus_space_read_1(iot, ioh, TCM) << 8 |
           bus_space_read_1(iot, ioh, TCL);
       trans = sc->sc_dleft - resid;
       sc->sc_dp += trans;
       sc->sc_dleft -= trans;

       sc->sc_flags &= ~SPC_DOINGDMA;
#ifdef USELEDS
       ledcontrol(0, LED_DISK, 0);
#endif
}

static void
spc_dio_dmastop(void *arg)
{
       struct spc_dio_softc *dsc = arg;
       struct spc_softc *sc = &dsc->sc_spc;
       uint8_t cmd;

       /* XXX When is this function called? */
       cmd = bus_space_read_1(sc->sc_iot, dsc->sc_iohsc, HPSCSI_CSR);
       cmd &= ~(CSR_DE1|CSR_DE0);
       bus_space_write_1(sc->sc_iot, dsc->sc_iohsc, HPSCSI_CSR, cmd);

       dsc->sc_dflags &= ~SCSI_HAVEDMA;
       sc->sc_flags &= ~SPC_DOINGDMA;
#ifdef USELEDS
       ledcontrol(0, LED_DISK, 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.