freebsd/sys/pci/simos.c

/*-
 * Copyright (c) 1998 Doug Rabson
 * 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 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 AUTHOR 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.
 *
 * $FreeBSD$
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#include <sys/buf.h>
#include <sys/proc.h>

#include <cam/cam.h>
#include <cam/cam_ccb.h>
#include <cam/cam_sim.h>
#include <cam/cam_xpt_sim.h>
#include <cam/cam_debug.h>

#include <cam/scsi/scsi_all.h>
#include <cam/scsi/scsi_message.h>

#include <machine/clock.h>
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>
#include <sys/kernel.h>

#include <pci/simos.h>

#include <pci/pcireg.h>
#include <pci/pcivar.h>

#ifndef COMPAT_OLDPCI
#error "The simos device requires the old pci compatibility shims"
#endif

#include <machine/alpha_cpu.h>

struct simos_softc {
	int			sc_unit;
	SimOS_SCSI*		sc_regs;

	/*
	 * SimOS only supports one pending command.
	 */
	struct cam_sim	       *sc_sim;
	struct cam_path	       *sc_path;
	struct ccb_scsiio      *sc_pending;
};

struct simos_softc* simosp[10];

static u_long simos_unit;

static const char *simos_probe __P((pcici_t tag, pcidi_t type));
static void simos_attach __P((pcici_t config_d, int unit));
static void simos_action __P((struct cam_sim *sim, union ccb *ccb));
static void simos_poll __P((struct cam_sim *sim));

struct pci_device simos_driver = {
	"simos",
	simos_probe,
	simos_attach,
	&simos_unit,
	NULL
};
COMPAT_PCI_DRIVER (simos, simos_driver);

static const char *
simos_probe(pcici_t tag, pcidi_t type)
{       
	switch (type) {
	case 0x1291|(0x1291<<16):
		return "SimOS SCSI";
	default:
		return NULL;
	}
		
}

static void    
simos_attach(pcici_t config_id, int unit)
{
	struct simos_softc* sc;
	struct cam_devq *devq;

	sc = malloc(sizeof(struct simos_softc), M_DEVBUF, M_WAITOK);
	simosp[unit] = sc;
	bzero(sc, sizeof *sc);

	sc->sc_unit = unit;
	sc->sc_regs = (SimOS_SCSI*) SIMOS_SCSI_ADDR;
	sc->sc_pending = 0;

	devq = cam_simq_alloc(/*maxopenings*/1);
	if (devq == NULL)
		return;

	sc->sc_sim = cam_sim_alloc(simos_action, simos_poll, "simos", sc, unit,
				   /*untagged*/1, /*tagged*/0, devq);
	if (sc->sc_sim == NULL) {
		cam_simq_free(devq);
		return;
	}

	if (xpt_bus_register(sc->sc_sim, /*bus*/0) != CAM_SUCCESS) {
		cam_sim_free(sc->sc_sim, /*free_devq*/TRUE);
		return;
	}

	if (xpt_create_path(&sc->sc_path, /*periph*/NULL,
			    cam_sim_path(sc->sc_sim), CAM_TARGET_WILDCARD,
			    CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
		xpt_bus_deregister(cam_sim_path(sc->sc_sim));
		cam_sim_free(sc->sc_sim, /*free_devq*/TRUE);
		return;
	}

	alpha_register_pci_scsi(config_id->bus, config_id->slot, sc->sc_sim);

	return;
}

static void
simos_start(struct simos_softc* sc, struct ccb_scsiio *csio)
{
	struct scsi_generic *cmd;
	int cmdlen;
	caddr_t data;
	int datalen;
	int s;
	u_int8_t* p;
	int i, count, target;
	vm_offset_t va;
	vm_size_t size;

	cmd = (struct scsi_generic *) &csio->cdb_io.cdb_bytes;
	cmdlen = csio->cdb_len;
	data = csio->data_ptr;
	datalen = csio->dxfer_len;

	/*
	 * Simos doesn't understand some commands
	 */
	if (cmd->opcode == START_STOP || cmd->opcode == PREVENT_ALLOW
	    || cmd->opcode == SYNCHRONIZE_CACHE) {
		csio->ccb_h.status = CAM_REQ_CMP;
		xpt_done((union ccb *) csio);
		return;
	}

	if (sc->sc_pending) {
		/*
		 * Don't think this can happen.
		 */
		printf("simos_start: can't start command while one is pending\n");
		csio->ccb_h.status = CAM_BUSY;
		xpt_done((union ccb *) csio);
		return;
	}

	s = splcam();
	
	csio->ccb_h.status |= CAM_SIM_QUEUED;
	sc->sc_pending = csio;

	target = csio->ccb_h.target_id;

	/*
	 * Copy the command into SimOS' buffer
	 */
	p = (u_int8_t*) cmd;
	count = cmdlen;
	for (i = 0; i < count; i++)
		sc->sc_regs->cmd[i] = *p++;
	sc->sc_regs->length = count;
	sc->sc_regs->target = target;
	sc->sc_regs->lun = csio->ccb_h.target_lun;

	/*
	 * Setup the segment descriptors.
	 */
	va = (vm_offset_t) data;
	size = datalen;
	i = 0;
	while (size > 0) {
		vm_size_t len = PAGE_SIZE - (va & PAGE_MASK);
		if (len > size)
			len = size;
		sc->sc_regs->sgMap[i].pAddr = vtophys(va);
		sc->sc_regs->sgMap[i].len = len;
		size -= len;
		va += len;
		i++;
	}
	sc->sc_regs->sgLen = i;

	/*
	 * Start the i/o.
	 */
	alpha_wmb();
	sc->sc_regs->startIO = 1;
	alpha_wmb();

	splx(s);
}

static void
simos_done(struct simos_softc* sc)
{
	struct ccb_scsiio* csio = sc->sc_pending;
	int s, done;

	/*
	 * Spurious interrupt caused by my bogus interrupt broadcasting.
	 */
	if (!csio)
		return;

	sc->sc_pending = 0;

	done = sc->sc_regs->done[csio->ccb_h.target_id];
	if (!done)
		return;

	s = splcam();

	if (done >> 16)
		/* Error detected */
		csio->ccb_h.status = CAM_CMD_TIMEOUT;
	else
		csio->ccb_h.status = CAM_REQ_CMP;

	/*
	 * Ack the interrupt to clear it.
	 */
	sc->sc_regs->done[csio->ccb_h.target_id] = 1;
	alpha_wmb();
	
	xpt_done((union ccb *) csio);

	splx(s);
}

static void
simos_action(struct cam_sim *sim, union ccb *ccb)
{
	struct simos_softc* sc = (struct simos_softc *)sim->softc;

	switch (ccb->ccb_h.func_code) {
	case XPT_SCSI_IO:
	{
		struct ccb_scsiio *csio;

		csio = &ccb->csio;
		simos_start(sc, csio);
		break;
	}

	case XPT_CALC_GEOMETRY:
	{
		struct	  ccb_calc_geometry *ccg;
		u_int32_t size_mb;
		u_int32_t secs_per_cylinder;

		ccg = &ccb->ccg;
		size_mb = ccg->volume_size
			/ ((1024L * 1024L) / ccg->block_size);

		ccg->heads = 64;
		ccg->secs_per_track = 32;

		secs_per_cylinder = ccg->heads * ccg->secs_per_track;
		ccg->cylinders = ccg->volume_size / secs_per_cylinder;

		ccb->ccb_h.status = CAM_REQ_CMP;
		xpt_done(ccb);
		break;
	}

	case XPT_RESET_BUS:
	{
		ccb->ccb_h.status = CAM_REQ_CMP;
		xpt_done(ccb);
		break;
	}

	case XPT_PATH_INQ:
	{
		struct ccb_pathinq *cpi = &ccb->cpi;
		
		cpi->version_num = 1; /* XXX??? */
		cpi->max_target = 2;
		cpi->max_lun = 0;
		cpi->initiator_id = 7;
		cpi->bus_id = sim->bus_id;
		cpi->base_transfer_speed = 3300;
		strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
		strncpy(cpi->hba_vid, "SimOS", HBA_IDLEN);
		strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
		cpi->unit_number = sim->unit_number;

		cpi->ccb_h.status = CAM_REQ_CMP;
		xpt_done(ccb);
		break;
	}

	default:
		ccb->ccb_h.status = CAM_REQ_INVALID;
		xpt_done(ccb);
		break;
	}
}

static void
simos_poll(struct cam_sim *sim)
{       
	simos_done(cam_sim_softc(sim));
}

void
simos_intr(int unit)
{
	/* XXX bogus */
	struct simos_softc* sc = simosp[unit];

	simos_done(sc);
}