/* SCSI.C - VMS-specific SCSI routines.
**
** TECSys Development, Inc., April 1998
**
** This module began life as a program called CDWRITE20, a CD-R control
** program for VMS. No real functionality from the original CDWRITE20
** is present in this module, but in the interest of making certain that
** proper credit is given where it may be due, the copyrights and inclusions
** from the CDWRITE20 program are included below.
**
** The portions of coding in this module ascribable to TECSys Development
** are hereby also released under the terms and conditions of version 2
** of the GNU General Public License as described below....
*/

/* The remainder of these credits are included directly from the CDWRITE20
** sources. */

/* Copyright 1994 Yggdrasil Computing, Inc. */
/* Written by Adam J. Richter (adam@yggdrasil.com) */

/* Rewritten February 1997 by Eberhard Heuser-Hofmann*/
/* using the OpenVMS generic scsi-interface */
/* see the README-file, how to setup your machine */

/*
**  Modified March 1997 by John Vottero to use overlapped, async I/O
**  and lots of buffers to help prevent buffer underruns.
**  Also improved error reporting.
*/

/* This file may be copied under the terms and conditions of version 2
   of the GNU General Public License, as published by the Free
   Software Foundation (Cambridge, Massachusetts).

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* The second notice comes from sys$examples:gktest.c (OpenVMS 7.0)*/

/*
** COPYRIGHT (c) 1993 BY
** DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS.
** ALL RIGHTS RESERVED.
**
** THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
** ONLY  IN  ACCORDANCE  OF  THE  TERMS  OF  SUCH  LICENSE  AND WITH THE
** INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR  ANY  OTHER
** COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
** OTHER PERSON.  NO TITLE TO AND  OWNERSHIP OF THE  SOFTWARE IS  HEREBY
** TRANSFERRED.
**
** THE INFORMATION IN THIS SOFTWARE IS	SUBJECT TO CHANGE WITHOUT NOTICE
** AND	SHOULD	NOT  BE  CONSTRUED  AS A COMMITMENT BY DIGITAL EQUIPMENT
** CORPORATION.
**
** DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE  OR  RELIABILITY OF ITS
** SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
*/

/*
  Define the Generic SCSI Command Descriptor.
*/

typedef struct scsi$desc
{
	unsigned int SCSI$L_OPCODE;	    /* SCSI Operation Code */
	unsigned int SCSI$L_FLAGS;	    /* SCSI Flags Bit Map */
	unsigned char *SCSI$A_CMD_ADDR;   /* ->SCSI Command Buffer */
	unsigned int SCSI$L_CMD_LEN;	    /* SCSI Command Length (bytes) */
	unsigned char *SCSI$A_DATA_ADDR;  /* ->SCSI Data Buffer */
	unsigned int SCSI$L_DATA_LEN;	    /* SCSI Data Length (bytes) */
	unsigned int SCSI$L_PAD_LEN;	    /* SCSI Pad Length (bytes) */
	unsigned int SCSI$L_PH_CH_TMOUT;  /* SCSI Phase Change Timeout (seconds) */
	unsigned int SCSI$L_DISCON_TMOUT; /* SCSI Disconnect Timeout (seconds) */
	unsigned int SCSI$L_RES_1;	    /* Reserved */
	unsigned int SCSI$L_RES_2;	    /* Reserved */
	unsigned int SCSI$L_RES_3;	    /* Reserved */
	unsigned int SCSI$L_RES_4;	    /* Reserved */
	unsigned int SCSI$L_RES_5;	    /* Reserved */
	unsigned int SCSI$L_RES_6;	    /* Reserved */
}
SCSI$DESC;


/*
  Define the SCSI Input/Output Status Block.
*/

typedef struct scsi$iosb
{
	unsigned short SCSI$W_VMS_STAT;		/* VMS Status Code */
	unsigned long SCSI$L_IOSB_TFR_CNT;	/* Actual Byte Count Transferred */
	unsigned char SCSI$B_IOSB_FILL_1;	/* Unused */
	unsigned char SCSI$B_IOSB_STS;		/* SCSI Device Status */
}
SCSI$IOSB;


/*
  Define the VMS symbolic representation for a successful SCSI command.
*/

#define SCSI$K_GOOD		0


/*
  Define the SCSI Flag Field Constants.
*/

#define SCSI$K_WRITE        	0x0 /* Data Transfer Direction: Write */
#define SCSI$K_READ         	0x1 /* Data Transfer Direction: Read */
#define SCSI$K_FL_ENAB_DIS  	0x2 /* Enable Disconnect/Reconnect */


/*
  Define DESCR_CNT.  It must be a power of two and large enough
  for the maximum concurrent usage of descriptors.
*/

#define DESCR_CNT 16


#define MK_EFN			0   /* Event Flag Number */
#define FailureStatusP(Status)	(~(Status) & 1)


static struct dsc$descriptor_s *descr(char *String)
{
	static struct dsc$descriptor_s d_descrtbl[DESCR_CNT];
	static unsigned short descridx = 0;
	struct dsc$descriptor_s *d_ret = &d_descrtbl[descridx];
	descridx = (descridx + 1) & (DESCR_CNT - 1);
	d_ret->dsc$w_length = strlen((const char *) String);
	d_ret->dsc$a_pointer = String;
	d_ret->dsc$b_class = 0;
	d_ret->dsc$b_dtype = 0;

	return d_ret;
}


static int SCSI_OpenDevice(char *DeviceName)
{
	unsigned long d_dev[2], iosb[2], Status;
	union prvdef setprivs, newprivs;
	unsigned long ismnt = 0;
	unsigned long dvcls = 0;
	unsigned long dchr2 = 0;
	int DeviceFD = 0;
	struct itmlst_3
	{
		unsigned short ilen;
		unsigned short code;
		unsigned long *returnP;
		unsigned long ignored;
	}
	dvi_itmlst[] = {
		{ 4, DVI$_MNT, 0 /*&ismnt*/, 0 },
		{ 4, DVI$_DEVCLASS, 0 /*&dvcls*/, 0 },
		{ 4, DVI$_DEVCHAR2, 0 /*&dchr2*/, 0 },
		{ 0, 0, 0, 0 }
	};

	dvi_itmlst[0].returnP = &ismnt;
	dvi_itmlst[1].returnP = &dvcls;
	dvi_itmlst[2].returnP = &dchr2;

	Status = sys$alloc(descr(DeviceName), 0, 0, 0, 0);

	if (FailureStatusP(Status))
	{
		VMS_ExitCode = Status;
		FatalError("cannot allocate device '%s' - %X\n", DeviceName, Status);
	}

	Status = sys$assign(descr(DeviceName), &DeviceFD, 0, 0);
	if (FailureStatusP(Status))
	{
		VMS_ExitCode = Status;
		FatalError("cannot open device '%s' - %X\n", DeviceName, Status);
	}

	Status = sys$getdviw(0, DeviceFD, 0, &dvi_itmlst, &iosb, 0, 0, 0);
	if (FailureStatusP(Status))
	{
		VMS_ExitCode = Status;
		FatalError("cannot $getdvi(1) on device '%s' - %X\n", DeviceName, Status);
	}

	if (FailureStatusP(Status = iosb[0]))
	{
		VMS_ExitCode = Status;
		FatalError("cannot $getdvi(2) on device '%s' - %X\n", DeviceName, Status);
	}

	if (dvcls != DC$_TAPE)
	{
		VMS_ExitCode = SS$_IVDEVNAM;
		FatalError("specified device is NOT a magtape: operation denied\n");
	}
#ifndef __DECC
#ifndef DEV$M_SCSI
#define DEV$M_SCSI 0x1000000
#endif
#endif
	if (~dchr2 & DEV$M_SCSI)
	{
		VMS_ExitCode = SS$_IVDEVNAM;
		FatalError("specified magtape is NOT a SCSI device: operation denied\n");
	}
#if USING_DEC_DRIVE | USING_LDRSET
#ifndef __DECC
#ifndef DEV$M_LDR
#define DEV$M_LDR 0x100000
#endif
#endif
	if (~dchr2 & DEV$M_LDR)
	{
		VMS_ExitCode = SS$_IVDEVNAM;
		FatalError("specified SCSI magtape does not have a loader: operation denied\n");
	}
#endif
	if (ismnt)
	{
		VMS_ExitCode = SS$_DEVMOUNT;
		FatalError("specified device is mounted: operation denied\n");
	}

	ots$move5(0, 0, 0, sizeof(newprivs), &newprivs);
	newprivs.prv$v_diagnose = 1;
	newprivs.prv$v_log_io = 1;
	newprivs.prv$v_phy_io = 1;
	Status = sys$setprv(1, &newprivs, 0, 0);

	if (FailureStatusP(Status))
	{
		VMS_ExitCode = Status;
		FatalError("error enabling privs (diagnose,log_io,phy_io): operation denied\n");
	}

	Status = sys$setprv(1, 0, 0, &setprivs);
	if (FailureStatusP(Status))
	{
		VMS_ExitCode = Status;
		FatalError("error retrieving current privs: operation denied\n");
	}

	if (!setprivs.prv$v_diagnose)
	{
		VMS_ExitCode = SS$_NODIAGNOSE;
		FatalError("DIAGNOSE privilege is required: operation denied\n");
	}

	if (!setprivs.prv$v_phy_io && !setprivs.prv$v_log_io)
	{
		VMS_ExitCode = SS$_NOPHY_IO;
		FatalError("PHY_IO or LOG_IO privilege is required: operation denied\n");
	}

	return DeviceFD;
}


static void SCSI_CloseDevice(char *DeviceName, int DeviceFD)
{
	unsigned long Status;

	Status = sys$dassgn(DeviceFD);
	if (FailureStatusP(Status))
		FatalError("cannot close SCSI device '%s' - %X\n", DeviceName, Status);
}


static int SCSI_ExecuteCommand(	int DeviceFD,
								Direction_T Direction,
								CDB_T *CDB,
								int CDB_Length,
								void *DataBuffer,
								int DataBufferLength,
								RequestSense_T *RequestSense)
{
	SCSI$DESC cmd_desc;
	SCSI$IOSB cmd_iosb;
	unsigned long Status;
	int Result;
	memset(RequestSense, 0, sizeof(RequestSense_T));
	/* Issue the QIO to send the SCSI Command. */
	ots$move5(0, 0, 0, sizeof(cmd_desc), &cmd_desc);
	cmd_desc.SCSI$L_OPCODE = 1; /* Only defined SCSI opcode... a VMS thing */
	cmd_desc.SCSI$A_CMD_ADDR = CDB;
	cmd_desc.SCSI$L_CMD_LEN = CDB_Length;
	cmd_desc.SCSI$A_DATA_ADDR = DataBuffer;
	cmd_desc.SCSI$L_DATA_LEN = DataBufferLength;
	cmd_desc.SCSI$L_PAD_LEN = 0;
	cmd_desc.SCSI$L_PH_CH_TMOUT = 180; /* SCSI Phase Change Timeout (seconds) */
	cmd_desc.SCSI$L_DISCON_TMOUT = 180; /* SCSI Disconnect Timeout (seconds) */

	switch (Direction)
	{
	/*
	NOTE: Do NOT include flag SCSI$K_FL_ENAB_SYNC.
	It does NOT work for this case.
	*/
	case Input:
		cmd_desc.SCSI$L_FLAGS = SCSI$K_READ | SCSI$K_FL_ENAB_DIS;
		break;

	case Output:
		cmd_desc.SCSI$L_FLAGS = SCSI$K_WRITE | SCSI$K_FL_ENAB_DIS;
		break;
	}

	/* Issue the SCSI Command. */
	Status = sys$qiow(MK_EFN, DeviceFD, IO$_DIAGNOSE, &cmd_iosb, 0, 0,
	&cmd_desc, sizeof(cmd_desc), 0, 0, 0, 0);
	Result = SCSI$K_GOOD;

	if (Status & 1)
		Status = cmd_iosb.SCSI$W_VMS_STAT;

	if (Status & 1)
		Result = cmd_iosb.SCSI$B_IOSB_STS;

	if (Result != SCSI$K_GOOD)
	{
		unsigned char RequestSenseCDB[6] =
			{ 0x03 /* REQUEST_SENSE */, 0, 0, 0, sizeof(RequestSense_T), 0 };

		printf("SCSI command error: %d - requesting sense data\n", Result);

		/* Execute Request Sense to determine the failure reason. */
		ots$move5(0, 0, 0, sizeof(cmd_desc), &cmd_desc);
		cmd_desc.SCSI$L_OPCODE = 1; /* Only defined SCSI opcode... a VMS thing */
		cmd_desc.SCSI$L_FLAGS = SCSI$K_READ | SCSI$K_FL_ENAB_DIS;
		cmd_desc.SCSI$A_CMD_ADDR = RequestSenseCDB;
		cmd_desc.SCSI$L_CMD_LEN = 6;
		cmd_desc.SCSI$A_DATA_ADDR = RequestSense;
		cmd_desc.SCSI$L_DATA_LEN = sizeof(RequestSense_T);
		cmd_desc.SCSI$L_PH_CH_TMOUT = 180;
		cmd_desc.SCSI$L_DISCON_TMOUT = 180;

		/* Issue the QIO to send the Request Sense Command. */
		Status = sys$qiow(MK_EFN, DeviceFD, IO$_DIAGNOSE, &cmd_iosb, 0, 0,
			&cmd_desc, sizeof(cmd_desc), 0, 0, 0, 0);
		if (FailureStatusP(Status))
		{
			printf("?Error returned from REQUEST_SENSE(1): %%X%08lX\n", Status);
			sys$exit(Status);
		}

		/* Check the VMS Status from QIO. */
		Status = cmd_iosb.SCSI$W_VMS_STAT;
		if (FailureStatusP(Status))
		{
			printf("?Error returned from REQUEST_SENSE(2): %%X%08lX\n", Status);
			sys$exit(Status);
		}
	}
	return Result;
}


static void VMS_DefineStatusSymbols(void)
{
	char SymbolName[32], SymbolValue[32];
	int StorageElementNumber;

	if (DataTransferElementFull)
	{
		/* Define MTX_DTE Symbol (environment variable) as 'FULL:n'. */
		sprintf(SymbolValue, "FULL:%d",
		DataTransferElementSourceStorageElementNumber);
		lib$set_symbol(descr("MTX_DTE"), descr(SymbolValue), &2);
	}
	else
	{
		/* Define MTX_DTE Symbol (environment variable) as 'EMPTY'. */
		lib$set_symbol(descr("MTX_DTE"), descr("EMPTY"), &2);
	}

	/* Define MTX_MSZ Symbol (environment variable) "Magazine SiZe" as 'n'. */
	sprintf(SymbolValue, "%d", StorageElementCount);
	lib$set_symbol(descr("MTX_MSZ"), descr(SymbolValue), &2);
	for (StorageElementNumber = 1;
		 StorageElementNumber <= StorageElementCount;
		 StorageElementNumber++)
	{
		sprintf(SymbolName, "MTX_STE%02d", StorageElementNumber);
		strcpy(SymbolValue,
			(StorageElementFull[StorageElementNumber] ? "FULL" : "EMPTY"));
		lib$set_symbol(descr(SymbolName), descr(SymbolValue), &2);
	}
}