/*	vd.c	7.1	86/01/12	*/
/*
** Stand alone driver for the VDDC controller 
**	TAHOE Version, Oct 1983.
**
*/
#include "../machine/mtpr.h"

#include "param.h"
#include "inode.h"
#include "fs.h"
#define VDGENDATA 1
#include "../tahoevba/vddcreg.h"
#undef	VDGENDATA
#include "saio.h"

#define NVD		4			/* Max number of controllers */

#define TRUE		1
#define	FALSE		0
#define VDUNIT(x)	(minor(x) & 0x3)
#define VDCTLR(x)	(minor(x) >> 2)

/*
**	MDCB
*/

fmt_mdcb	mdcb;

/*
**	DCB
*/

fmt_dcb		dcb;

/*
** Unit specific information.
*/

struct {
	char	configured;
	fs_tab	info;
}unit_info[NVD][16];

/*
** Controller specific information.
*/

struct {
	unsigned char	ctlr_type;
	char		*ctlr_name;
	unsigned char	initialized;
	unsigned char	ctlr_started;
} ctlr_info[NVD];

static char	junk[1024];


/*
**
*/

vdopen(io)
register struct iob	*io;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register int	unit = VDUNIT(io->i_unit);
	register int	i, j;

	/* Make sure controller number is in range */
	if(ctlr >= NVD) {
		printf("vd%d: Unit number can't be greater than %x!\n",
		    io->i_unit, (NVD * 4) - 1);
		_stop("");
	}
	/* check file system for validity */
	if((io->i_boff < 0) || (io->i_boff > 5)) {
		printf("vd%d: File system #%d, should be less than #6.\n",
		    io->i_unit, io->i_boff);
		_stop("");
	}
	if(!ctlr_info[ctlr].initialized) {
		vdinit(io);	/* initialize controller/drive */
		ctlr_info[ctlr].initialized = TRUE;
		for(i=0; i<NVD; i++)
			for(j=0; j<16; j++)
				unit_info[i][j].configured = FALSE;
	}
	if(!unit_info[ctlr][unit].configured) {
		vdconfigure_drive(io);
		unit_info[ctlr][unit].configured = TRUE;
	}
	io->i_boff = unit_info[ctlr][unit].info.partition[io->i_boff].par_start;
}


/*
**
*/

vdinit(io)
register struct iob	*io;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register int	unit = VDUNIT(io->i_unit);
	register cdr	*ctlr_addr = (cdr *)(vddcaddr[ctlr]+IOBASE);
	register char	*ctlr_type;

	/* Check to see if controller is really there */
	if(badaddr(ctlr_addr, 2)) {
		printf("vd%d: Controller %d is non-existant!\n",
		    io->i_unit, ctlr);
		_stop("");
	}
	/* Probe further to find what kind of controller it is */
	ctlr_addr->cdr_reset = 0xffffffff;
	DELAY(1000000);
	/* Probe further to find what kind of controller it is */
	if(ctlr_addr->cdr_reset != 0xffffffff) {
		ctlr_info[ctlr].ctlr_type = SMDCTLR;
		ctlr_info[ctlr].ctlr_name = "SMD";
		DELAY(1000000);
	}
	else {
		ctlr_info[ctlr].ctlr_type = SMD_ECTLR;
		ctlr_info[ctlr].ctlr_name = "SMD/E";
		ctlr_addr->cdr_reserved = 0x0;
		DELAY(3000000);
	}
	if(ctlr_info[ctlr].ctlr_type == SMD_ECTLR) {
		ctlr_addr->cdr_csr =  0;
		ctlr_addr->mdcb_tcf = AM_ENPDA;
		ctlr_addr->dcb_tcf = AM_ENPDA;
		ctlr_addr->trail_tcf = AM_ENPDA;
		ctlr_addr->data_tcf = AM_ENPDA;
		ctlr_addr->cdr_ccf = CCF_STS | XMD_32BIT | BSZ_16WRD |
		    CCF_ENP | CCF_EPE /* | CCF_EDE */ | CCF_ECE | CCF_ERR;
	}
	if(vdaccess_with_no_trailer(io, INIT, 8) & HRDERR) {
		vdprint_error(io->i_unit, "Initialization error",
		    dcb.operrsta,dcb.err_code);
		_stop("");
	}
	if(vdaccess_with_no_trailer(io, DIAG, 8) & HRDERR) {
		vdprint_error(io->i_unit, "Diagnostic error",
		    dcb.operrsta, dcb.err_code);
		_stop("");
	}
}


/*
**
*/

vdconfigure_drive(io)
register struct iob	*io;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register int	unit = VDUNIT(io->i_unit);
	register fs_tab	*file_sys;
	dskadr		daddr;
	register int	i;

	for(i=0; i < nvddrv; i++) {
		unit_info[ctlr][unit].info = vdst[i];
		if(ctlr_info[ctlr].ctlr_type == SMDCTLR)
			if(unit_info[ctlr][unit].info.nsec != 32)
				continue;
		vdconfigure(io, 0);
		daddr.cylinder = unit_info[ctlr][unit].info.ncyl - 2;
		daddr.track = unit_info[ctlr][unit].info.ntrak - 1;
		daddr.sector = unit_info[ctlr][unit].info.nsec - 1;
		io->i_ma = junk;
		io->i_cc = unit_info[ctlr][unit].info.secsize;
		if(!(vdaccess(io, &daddr, RD) & HRDERR))
			return;
	}
	printf("vd%d: Unrecognizable drive; controller %d, unit %d!\n",
	    io->i_unit, ctlr, unit);
	_stop("");
}


/*
**
*/

vdstart_drive(io)
register struct iob	*io;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register int	unit = VDUNIT(io->i_unit);
	register int	io_unit_save = io->i_unit;

	if(ctlr_info[ctlr].ctlr_started) {
		DELAY(5500000);
		return TRUE;
	}
	io->i_unit &= ~3;
	if(vdaccess_with_no_trailer(io, VDSTART, ((unit * 6) + 62)) & HRDERR) {
		vdprint_error(io->i_unit, "Start error",
		    dcb.operrsta, dcb.err_code);
		_stop("");
	}
	ctlr_info[ctlr].ctlr_started = TRUE;
	io->i_unit = io_unit_save;
	DELAY((unit * 5500000) + 62000000);
	return TRUE;
}


/*
**  This routine actually configures a particular drive.
**
**  If the controller is an SMD/E controller then the number of sectors per
**  track is loaded into the appropriate register, otherwise it is left 
**  alone because the old SMD controller requires a constant 32 sectors
**  per track for it's drives. (an error would be returned if the value is
**  loaded.)
**
**  In the stand-alone spirit of things the system is halted if an error
**  occurs during this operation.
*/

vdconfigure(io, pass)
register struct iob	*io;
int	pass;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register int	unit = VDUNIT(io->i_unit);
	register cdr	*ctlr_addr = (cdr *)(vddcaddr[ctlr]+IOBASE);

	dcb.opcode = RSTCFG;		/* command */
	dcb.intflg = NOINT;
	dcb.nxtdcb = (fmt_dcb *)0;	/* end of chain */
	dcb.operrsta  = 0;
	dcb.devselect = (char)unit;
	dcb.trail.rstrail.ncyl = unit_info[ctlr][unit].info.ncyl;
	dcb.trail.rstrail.nsurfaces = unit_info[ctlr][unit].info.ntrak;
	if(ctlr_info[ctlr].ctlr_type == SMD_ECTLR) {
		dcb.trailcnt = (char)4;
		dcb.trail.rstrail.nsectors = unit_info[ctlr][unit].info.nsec;
		dcb.trail.rstrail.slip_sec = unit_info[ctlr][unit].info.nslip;
	}
	else
		dcb.trailcnt = (char)2;
	mdcb.firstdcb = &dcb;
	mdcb.vddcstat = 0;
	VDDC_ATTENTION(ctlr_addr, &mdcb, ctlr_info[ctlr].ctlr_type);
	POLLTILLDONE(ctlr_addr,&dcb,5,ctlr_info[ctlr].ctlr_type);
	if(vdtimeout <= 0)
		_stop(" during drive configuration.\n");
	if(dcb.operrsta & (NOTCYLERR | DRVNRDY))
		if(!pass) {
			vdstart_drive(io);
			vdconfigure(io, 1);
		}
	if(dcb.operrsta & HRDERR) {
		vdprint_error(io->i_unit, "Configuration error",
		    dcb.operrsta, dcb.err_code);
		_stop("");
	}
}


/*
**  Strategy is called to the actual I/O to the disk drives.
**
**  Some simple checks are made to make sure we don't do anything rediculus,
**  If everything is sane then the request is issued.
**
**  If no errors occured then the original byte count is returned,
**  otherwise -1 is returned to indicate an error occured.
*/

vdstrategy(io, func)
register struct iob	*io;
register int func;
{
	dskadr		daddr;
	register int	ctlr = VDCTLR(io->i_unit);
	register int	unit = VDUNIT(io->i_unit);
	register fs_tab	*u_info = &unit_info[ctlr][unit].info;
	register int	op = (func == READ) ? RD : WD;
	register int	blk;

	if(io->i_cc == 0)
		_stop("vd: Can't transfer zero length records!\n");
	if(io->i_cc > 0xffff)
		_stop("vd: Can't transfer greater than 2 to the 16th bytes!\n");
	blk = io->i_bn * DEV_BSIZE / u_info->secsize;
	daddr.sector = blk % u_info->nsec;
	daddr.track = (blk / u_info->nsec) % u_info->ntrak;
	daddr.cylinder = (blk/u_info->nsec) / u_info->ntrak;
	if(vdaccess(io, &daddr, op) & HRDERR) {
		vdprint_error(io->i_unit,"I/O error",dcb.operrsta,dcb.err_code);
		return(-1);
	}
	mtpr(PADC, 0);
	return(io->i_cc);
}



/*
**
*/

vdprint_error(unit, str, status, smde_status)
int		unit;
char		*str;
unsigned long	status;
unsigned long	smde_status;
{
	printf("vd%d: %s; ", unit, str);
	if(status & DRVNRDY)
		printf("Drive is not ready");
	else if(status & INVDADR)
		printf("Invalid disk address issued");
	else if(status & DNEMEM)
		printf("Non-existent memory error");
	else if(status & PARERR)
		printf("Main memory parity error");
	else if(status & OPABRT) 
		printf("Program aborted operation");
	else if(status & WPTERR)
		printf("Drive is write protected");
	else if(status & DSEEKERR)
		printf("Disk seek error");
	else if(status & UCDATERR)
		printf("Uncorrectable data error");
	else if(status & CTLRERR)
		printf("Controller faulted");
	else if(status & NOTCYLERR)
		printf("Not on cylinder error");
	else if(status & INVCMD)
		printf("Invalid command issued to controller");
	else 
		printf("Controller error");
	printf("!  Status = 0x%x", status);
	if(smde_status)
		printf("  Error code = %x", smde_status);
	printf("\n");
}


/*
**
*/

vdaccess_with_no_trailer(io, function, time)
register struct iob	*io;
register int		function, time;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register cdr	*ctlr_addr = (cdr *)(vddcaddr[ctlr]+IOBASE);

	dcb.opcode = function;		/* command */
	dcb.intflg = NOINT;
	dcb.nxtdcb = (fmt_dcb *)0;	/* end of chain */
	dcb.operrsta  = 0;
	dcb.devselect = (char)VDUNIT(io->i_unit);
	dcb.trailcnt = (char)0;
	mdcb.firstdcb = &dcb;
	mdcb.vddcstat = 0;
	VDDC_ATTENTION(ctlr_addr, &mdcb, ctlr_info[ctlr].ctlr_type);
	POLLTILLDONE(ctlr_addr,&dcb,time,ctlr_info[ctlr].ctlr_type);
	if(vdtimeout <= 0)
		_stop(" during initialization operation.\n");
	return dcb.operrsta;
}


/*
**
*/

vdaccess(io, daddr, func)
register struct iob	*io;
dskadr			*daddr;
int			func;
{
	register int	ctlr = VDCTLR(io->i_unit);
	register cdr	*ctlr_addr = (cdr *)(vddcaddr[ctlr]+IOBASE);

	dcb.opcode = (short)func;		/* format sector command */
	dcb.intflg = NOINT;
	dcb.nxtdcb = (fmt_dcb *)0;	/* end of chain */
	dcb.operrsta  = 0;
	dcb.devselect = (char)VDUNIT(io->i_unit);
	dcb.trailcnt = (char)(sizeof(trrw) / 4);
	dcb.trail.rwtrail.memadr = io->i_ma; 
	dcb.trail.rwtrail.wcount = ((io->i_cc + 1) / sizeof(short));
	dcb.trail.rwtrail.disk.cylinder = daddr->cylinder;
	dcb.trail.rwtrail.disk.track = daddr->track;
	dcb.trail.rwtrail.disk.sector = daddr->sector;
	mdcb.firstdcb = &dcb;
	mdcb.vddcstat = 0;
	VDDC_ATTENTION(ctlr_addr, &mdcb, ctlr_info[ctlr].ctlr_type);
	POLLTILLDONE(ctlr_addr, &dcb, 60, ctlr_info[ctlr].ctlr_type);
	if(vdtimeout <= 0)
		_stop(" during I/O operation.\n");
	return dcb.operrsta;
}

/*
**	Print_dcb() dumps the MDCB and DCB for diagnostic purposes.  This
** routine is called whenever a fatal error is encountered.
*/

vdprintdcb(ptr)
register long	*ptr;
{
	register long	i;
	register long	trailer_count;

	printf("Dump of MDCB: ");
	for(i=0; i<4; i++)
		printf("  %lx", *(ptr+i));
	if(ptr = (long *)*ptr) {
		printf(" and DCB:");
		trailer_count = *(ptr+3) & 0xff;
		for(i=0; i<7+trailer_count; i++) {
			uncache(ptr+i);
			printf("  %lx", *(ptr+i));
		}
	}
	printf("\n");
	for(i=0; i<5000000; i++) ;
}