/*	$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);
}
