/*      $NetBSD: scsi.c,v 1.13 2024/05/09 15:11:11 tsutsui Exp $        */

/*
* This is reported to fix some odd failures when disklabeling
* SCSI disks in SYS_INST.
*/
#define SLOWSCSI

/*
* Copyright (c) 1988 University of Utah.
* Copyright (c) 1990, 1993
*      The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Van Jacobson of Lawrence Berkeley Laboratory and the Systems
* Programming Group of the University of Utah Computer Science Department.
*
* 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. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* from: Utah $Hdr: scsi.c 1.3 90/01/27$
*
*      @(#)scsi.c      8.1 (Berkeley) 6/10/93
*/

/*
* SCSI bus driver for standalone programs.
*/

#include <sys/param.h>
#include <sys/reboot.h>

#include <lib/libsa/stand.h>

#define _IOCTL_

#include <hp300/stand/common/device.h>
#include <hp300/stand/common/scsireg.h>
#include <hp300/stand/common/scsivar.h>
#include <hp300/stand/common/samachdep.h>

static void scsireset(int);
static int issue_select(volatile struct scsidevice *, uint8_t, uint8_t);
static int wait_for_select(volatile struct scsidevice *hd);
static int ixfer_start(volatile struct scsidevice *, int, uint8_t, int);
static int ixfer_out(volatile struct scsidevice *, int, uint8_t *);
static int ixfer_in(volatile struct scsidevice *hd, int, uint8_t *);
static int scsiicmd(struct scsi_softc *, int, uint8_t *, int, uint8_t *, int,
   uint8_t);

struct  scsi_softc scsi_softc[NSCSI];


int scsi_cmd_wait = 50000;      /* use the "real" driver init_wait value */
int scsi_data_wait = 50000;     /* use the "real" driver init_wait value */

void
scsiinit(void)
{
       struct hp_hw *hw;
       struct scsi_softc *hs;
       int i;
       static int waitset = 0;

       i = 0;
       for (hw = sc_table; i < NSCSI && hw < &sc_table[MAXCTLRS]; hw++) {
               if (!HW_ISSCSI(hw))
                       continue;
               hs = &scsi_softc[i];
               hs->sc_addr = hw->hw_kva;
               scsireset(i);
               if (howto & RB_ASKNAME)
                       printf("scsi%d at sc%d\n", i, hw->hw_sc);
               hw->hw_pa = (void *) i; /* XXX for autoconfig */
               hs->sc_alive = 1;
               i++;
       }
       /*
        * Adjust the wait values
        */
       if (!waitset) {
               scsi_cmd_wait *= cpuspeed;
               scsi_data_wait *= cpuspeed;
               waitset = 1;
       }
}

int
scsialive(int unit)
{

       if (unit >= NSCSI || scsi_softc[unit].sc_alive == 0)
               return 0;
       return 1;
}

static void
scsireset(int unit)
{
       volatile struct scsidevice *hd;
       struct scsi_softc *hs;
       u_int i;

       hs = &scsi_softc[unit];
       hd = (void *)hs->sc_addr;
       hd->scsi_id = 0xFF;
       DELAY(100);
       /*
        * Disable interrupts then reset the FUJI chip.
        */
       hd->scsi_csr  = 0;
       hd->scsi_sctl = SCTL_DISABLE | SCTL_CTRLRST;
       hd->scsi_scmd = 0;
       hd->scsi_tmod = 0;
       hd->scsi_pctl = 0;
       hd->scsi_temp = 0;
       hd->scsi_tch  = 0;
       hd->scsi_tcm  = 0;
       hd->scsi_tcl  = 0;
       hd->scsi_ints = 0;

       /*
        * Configure the FUJI chip with its SCSI address, all
        * interrupts enabled & appropriate parity.
        */
       i = (~hd->scsi_hconf) & 0x7;
       hs->sc_scsi_addr = 1 << i;
       hd->scsi_bdid = i;
       if (hd->scsi_hconf & HCONF_PARITY)
               hd->scsi_sctl = SCTL_DISABLE | SCTL_ABRT_ENAB |
                               SCTL_SEL_ENAB | SCTL_RESEL_ENAB |
                               SCTL_INTR_ENAB | SCTL_PARITY_ENAB;
       else
               hd->scsi_sctl = SCTL_DISABLE | SCTL_ABRT_ENAB |
                               SCTL_SEL_ENAB | SCTL_RESEL_ENAB |
                               SCTL_INTR_ENAB;
       hd->scsi_sctl &=~ SCTL_DISABLE;
}


void
scsiabort(struct scsi_softc *hs, volatile struct scsidevice *hd)
{

       printf("scsi%d error: scsiabort\n", hs - scsi_softc);

       scsireset(hs - scsi_softc);
       DELAY(1000000);
}

static int
issue_select(volatile struct scsidevice *hd, uint8_t target, uint8_t our_addr)
{

       if (hd->scsi_ssts & (SSTS_INITIATOR|SSTS_TARGET|SSTS_BUSY))
               return 1;

       if (hd->scsi_ints & INTS_DISCON)
               hd->scsi_ints = INTS_DISCON;

       hd->scsi_pctl = 0;
       hd->scsi_temp = (1 << target) | our_addr;
       /* select timeout is hardcoded to 250ms */
       hd->scsi_tch = 2;
       hd->scsi_tcm = 113;
       hd->scsi_tcl = 3;

       hd->scsi_scmd = SCMD_SELECT;
       return 0;
}

static int
wait_for_select(volatile struct scsidevice *hd)
{
       int wait;
       uint8_t ints;

       wait = scsi_data_wait;
       while ((ints = hd->scsi_ints) == 0) {
               if (--wait < 0)
                       return 1;
               DELAY(1);
       }
       hd->scsi_ints = ints;
       return !(hd->scsi_ssts & SSTS_INITIATOR);
}

static int
ixfer_start(volatile struct scsidevice *hd, int len, uint8_t phase, int wait)
{

       hd->scsi_tch = len >> 16;
       hd->scsi_tcm = len >> 8;
       hd->scsi_tcl = len;
       hd->scsi_pctl = phase;
       hd->scsi_tmod = 0; /*XXX*/
       hd->scsi_scmd = SCMD_XFR | SCMD_PROG_XFR;

       /* wait for xfer to start or svc_req interrupt */
       while ((hd->scsi_ssts & SSTS_BUSY) == 0) {
               if (hd->scsi_ints || --wait < 0)
                       return 0;
               DELAY(1);
       }
       return 1;
}

static int
ixfer_out(volatile struct scsidevice *hd, int len, uint8_t *buf)
{
       int wait = scsi_data_wait;

       for (; len > 0; --len) {
               while (hd->scsi_ssts & SSTS_DREG_FULL) {
                       if (hd->scsi_ints || --wait < 0)
                               return len;
                       DELAY(1);
               }
               hd->scsi_dreg = *buf++;
       }
       return 0;
}

static int
ixfer_in(volatile struct scsidevice *hd, int len, uint8_t *buf)
{
       int wait = scsi_data_wait;

       for (; len > 0; --len) {
               while (hd->scsi_ssts & SSTS_DREG_EMPTY) {
                       if (hd->scsi_ints || --wait < 0) {
                               while (! (hd->scsi_ssts & SSTS_DREG_EMPTY)) {
                                       *buf++ = hd->scsi_dreg;
                                       --len;
                               }
                               return len;
                       }
                       DELAY(1);
               }
               *buf++ = hd->scsi_dreg;
       }
       return len;
}

static int
scsiicmd(struct scsi_softc *hs, int target, uint8_t *cbuf, int clen,
   uint8_t *buf, int len, uint8_t xferphase)
{
       volatile struct scsidevice *hd = (void *)hs->sc_addr;
       uint8_t phase, ints;
       int wait;

       /* select the SCSI bus (it's an error if bus isn't free) */
       if (issue_select(hd, target, hs->sc_scsi_addr))
               return -2;
       if (wait_for_select(hd))
               return -2;
       /*
        * Wait for a phase change (or error) then let the device
        * sequence us through the various SCSI phases.
        */
       hs->sc_stat = -1;
       phase = CMD_PHASE;
       while (1) {
               wait = scsi_cmd_wait;
               switch (phase) {

               case CMD_PHASE:
                       if (ixfer_start(hd, clen, phase, wait))
                               if (ixfer_out(hd, clen, cbuf))
                                       goto abort;
                       phase = xferphase;
                       break;

               case DATA_IN_PHASE:
                       if (len <= 0)
                               goto abort;
                       wait = scsi_data_wait;
                       if (ixfer_start(hd, len, phase, wait) ||
                           !(hd->scsi_ssts & SSTS_DREG_EMPTY))
                               ixfer_in(hd, len, buf);
                       phase = STATUS_PHASE;
                       break;

               case DATA_OUT_PHASE:
                       if (len <= 0)
                               goto abort;
                       wait = scsi_data_wait;
                       if (ixfer_start(hd, len, phase, wait))
                               if (ixfer_out(hd, len, buf))
                                       goto abort;
                       phase = STATUS_PHASE;
                       break;

               case STATUS_PHASE:
                       wait = scsi_data_wait;
                       if (ixfer_start(hd, sizeof(hs->sc_stat), phase, wait) ||
                           !(hd->scsi_ssts & SSTS_DREG_EMPTY))
                               ixfer_in(hd, sizeof(hs->sc_stat),
                                   (uint8_t *)&hs->sc_stat);
                       phase = MESG_IN_PHASE;
                       break;

               case MESG_IN_PHASE:
                       if (ixfer_start(hd, sizeof(hs->sc_msg), phase, wait) ||
                           !(hd->scsi_ssts & SSTS_DREG_EMPTY)) {
                               ixfer_in(hd, sizeof(hs->sc_msg),
                                   (uint8_t *)&hs->sc_msg);
                               hd->scsi_scmd = SCMD_RST_ACK;
                       }
                       phase = BUS_FREE_PHASE;
                       break;

               case BUS_FREE_PHASE:
                       goto out;

               default:
                       printf("scsi%d: unexpected scsi phase %d\n",
                              hs - scsi_softc, phase);
                       goto abort;
               }
#ifdef SLOWSCSI
               /*
                * XXX we have weird transient problems with booting from
                * slow scsi disks on fast machines.  I have never been
                * able to pin the problem down, but a large delay here
                * seems to always work.
                */
               DELAY(1000);
#endif
               /* wait for last command to complete */
               while ((ints = hd->scsi_ints) == 0) {
                       if (--wait < 0)
                               goto abort;
                       DELAY(1);
               }
               hd->scsi_ints = ints;
               if (ints & INTS_SRV_REQ)
                       phase = hd->scsi_psns & PHASE;
               else if (ints & INTS_DISCON)
                       goto out;
               else if ((ints & INTS_CMD_DONE) == 0)
                       goto abort;
       }
abort:
       scsiabort(hs, hd);
out:
       return hs->sc_stat;
}

int
scsi_test_unit_rdy(int ctlr, int slave)
{
       struct scsi_softc *hs = &scsi_softc[ctlr];
       static struct scsi_cdb6 cdb = { CMD_TEST_UNIT_READY };

       return scsiicmd(hs, slave, (uint8_t *)&cdb, sizeof(cdb), NULL, 0,
           STATUS_PHASE);
}

int
scsi_request_sense(int ctlr, int slave, uint8_t *buf, unsigned int len)
{
       struct scsi_softc *hs = &scsi_softc[ctlr];
       static struct scsi_cdb6 cdb = { CMD_REQUEST_SENSE };

       cdb.len = len;
       return scsiicmd(hs, slave, (uint8_t *)&cdb, sizeof(cdb), buf, len,
           DATA_IN_PHASE);
}

int
scsi_read_capacity(int ctlr, int slave, uint8_t *buf, unsigned int len)
{
       struct scsi_softc *hs = &scsi_softc[ctlr];
       static struct scsi_cdb10 cdb = { CMD_READ_CAPACITY };

       return scsiicmd(hs, slave, (uint8_t *)&cdb, sizeof(cdb), buf, len,
           DATA_IN_PHASE);
}

#ifdef SUPPORT_CD
int
scsi_inquiry(int ctlr, int slave, uint8_t *buf, unsigned int len)
{
       struct scsi_softc *hs = &scsi_softc[ctlr];
       static struct scsi_cdb6 cdb = { CMD_INQUIRY };

       cdb.len = len;
       return scsiicmd(hs, slave, (uint8_t *)&cdb, sizeof(cdb), buf, len,
           DATA_IN_PHASE);
}
#endif

int
scsi_tt_read(int ctlr, int slave, uint8_t *buf, u_int len, daddr_t blk,
   u_int nblk)
{
       struct scsi_softc *hs = &scsi_softc[ctlr];
       struct scsi_cdb10 cdb;

       memset(&cdb, 0, sizeof(cdb));
       cdb.cmd = CMD_READ_EXT;
       cdb.lbah = blk >> 24;
       cdb.lbahm = blk >> 16;
       cdb.lbalm = blk >> 8;
       cdb.lbal = blk;
       cdb.lenh = nblk >> (8 + DEV_BSHIFT);
       cdb.lenl = nblk >> DEV_BSHIFT;
       return scsiicmd(hs, slave, (uint8_t *)&cdb, sizeof(cdb), buf, len,
           DATA_IN_PHASE);
}

int
scsi_tt_write(int ctlr, int slave, uint8_t *buf, u_int len, daddr_t blk,
   u_int nblk)
{
       struct scsi_softc *hs = &scsi_softc[ctlr];
       struct scsi_cdb10 cdb;

       memset(&cdb, 0, sizeof(cdb));
       cdb.cmd = CMD_WRITE_EXT;
       cdb.lbah = blk >> 24;
       cdb.lbahm = blk >> 16;
       cdb.lbalm = blk >> 8;
       cdb.lbal = blk;
       cdb.lenh = nblk >> (8 + DEV_BSHIFT);
       cdb.lenl = nblk >> DEV_BSHIFT;
       return scsiicmd(hs, slave, (uint8_t *)&cdb, sizeof(cdb), buf, len,
           DATA_OUT_PHASE);
}

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.