Imported Upstream version 1.1.11upstream/1.1.11upstream

1 files changed, 630 insertions, 0 deletions

diff --git a/libusal/scsi-os2.c b/libusal/scsi-os2.c
new file mode 100644
index 0000000..5758b8d
--- /dev/null
+++ b/libusal/scsi-os2.c
@@ -0,0 +1,630 @@
+/*
+ * This file has been modified for the cdrkit suite.
+ *
+ * The behaviour and appearence of the program code below can differ to a major
+ * extent from the version distributed by the original author(s).
+ *
+ * For details, see Changelog file distributed with the cdrkit package. If you
+ * received this file from another source then ask the distributing person for
+ * a log of modifications.
+ *
+ */
+
+/* @(#)scsi-os2.c	1.25 04/01/15 Copyright 1998 J. Schilling, C. Wohlgemuth */
+/*
+ *	Interface for the OS/2 ASPI-Router ASPIROUT.SYS ((c) D. Dorau).
+ *		This additional driver is a prerequisite for using cdrecord.
+ *		Get it from HOBBES or LEO.
+ *
+ *	Warning: you may change this source, but if you do that
+ *	you need to change the _usal_version and _usal_auth* string below.
+ *	You may not return "schily" for an SCG_AUTHOR request anymore.
+ *	Choose your name instead of "schily" and make clear that the version
+ *	string is related to a modified source.
+ *
+ *	XXX it currently uses static SRB and for this reason is not reentrant
+ *
+ *	Copyright (c) 1998 J. Schilling
+ *	Copyright (c) 1998 C. Wohlgemuth for this interface.
+ */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * 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; see the file COPYING.  If not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#undef	sense
+
+/*#define	DEBUG*/
+
+/* For AspiRouter */
+#include "usal/srb_os2.h"
+
+/*
+ *	Warning: you may change this source, but if you do that
+ *	you need to change the _usal_version and _usal_auth* string below.
+ *	You may not return "schily" for an SCG_AUTHOR request anymore.
+ *	Choose your name instead of "schily" and make clear that the version
+ *	string is related to a modified source.
+ */
+static	char	_usal_trans_version[] = "scsi-os2.c-1.25";	/* The version for this transport*/
+
+#define	FILE_OPEN			0x0001
+#define	OPEN_SHARE_DENYREADWRITE	0x0010
+#define	OPEN_ACCESS_READWRITE		0x0002
+#define	DC_SEM_SHARED			0x01
+#define	OBJ_TILE			0x0040
+#define	PAG_READ			0x0001
+#define	PAG_WRITE			0x0002
+#define	PAG_COMMIT			0x0010
+
+typedef unsigned long LHANDLE;
+typedef unsigned long ULONG;
+typedef unsigned char *PSZ;
+typedef unsigned short USHORT;
+typedef unsigned char UCHAR;
+
+typedef LHANDLE	HFILE;
+typedef ULONG	HEV;
+
+#define	MAX_SCG		16	/* Max # of SCSI controllers */
+#define	MAX_TGT		16
+#define	MAX_LUN		8
+
+struct usal_local {
+	int	dummy;
+};
+#define	usallocal(p)	((struct usal_local *)((p)->local))
+
+#define	MAX_DMA_OS2	(63*1024) /* ASPI-Router allows up to 64k */
+
+static	void	*buffer		= NULL;
+static	HFILE	driver_handle	= 0;
+static	HEV	postSema	= 0;
+
+static	BOOL	open_driver(SCSI *usalp);
+static	BOOL	close_driver(void);
+static	ULONG	wait_post(ULONG ulTimeOut);
+static	BOOL 	init_buffer(void* mem);
+static	void	exit_func(void);
+static	void	set_error(SRB *srb, struct usal_cmd *sp);
+
+
+static void
+exit_func()
+{
+	if (!close_driver())
+		fprintf(stderr, "Cannot close OS/2-ASPI-Router!\n");
+}
+
+/*
+ * Return version information for the low level SCSI transport code.
+ * This has been introduced to make it easier to trace down problems
+ * in applications.
+ */
+static char *
+usalo_version(SCSI *usalp, int what)
+{
+	if (usalp != (SCSI *)0) {
+		switch (what) {
+
+		case SCG_VERSION:
+			return (_usal_trans_version);
+		/*
+		 * If you changed this source, you are not allowed to
+		 * return "schily" for the SCG_AUTHOR request.
+		 */
+		case SCG_AUTHOR:
+			return (_usal_auth_cdrkit);
+		case SCG_SCCS_ID:
+			return (__sccsid);
+		}
+	}
+	return ((char *)0);
+}
+
+static int
+usalo_help(SCSI *usalp, FILE *f)
+{
+	__usal_help(f, "ASPI", "Generic transport independent SCSI",
+		"", "bus,target,lun", "1,2,0", TRUE, FALSE);
+	return (0);
+}
+
+static int
+usalo_open(SCSI *usalp, char *device)
+{
+	int	busno	= usal_scsibus(usalp);
+	int	tgt	= usal_target(usalp);
+	int	tlun	= usal_lun(usalp);
+
+	if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
+		errno = EINVAL;
+		if (usalp->errstr)
+			snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
+				"Illegal value for busno, target or lun '%d,%d,%d'",
+				busno, tgt, tlun);
+		return (-1);
+	}
+
+	if ((device != NULL && *device != '\0') || (busno == -2 && tgt == -2)) {
+		errno = EINVAL;
+		if (usalp->errstr)
+			snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
+				"Open by 'devname' not supported on this OS");
+		return (-1);
+	}
+
+	if (usalp->local == NULL) {
+		usalp->local = malloc(sizeof (struct usal_local));
+		if (usalp->local == NULL)
+			return (0);
+	}
+
+	if (!open_driver(usalp))	/* Try to open ASPI-Router */
+		return (-1);
+	atexit(exit_func);	/* Install Exit Function which closes the ASPI-Router */
+
+	/*
+	 * Success after all
+	 */
+	return (1);
+}
+
+static int
+usalo_close(SCSI *usalp)
+{
+	exit_func();
+	return (0);
+}
+
+static long
+usalo_maxdma(SCSI *cgp, long amt)
+{
+	long maxdma = MAX_DMA_OS2;
+	return (maxdma);
+}
+
+static void *
+usalo_getbuf(SCSI *usalp, long amt)
+{
+	ULONG rc;
+
+#ifdef DEBUG
+	fprintf((FILE *)usalp->errfile, "usalo_getbuf: %ld bytes\n", amt);
+#endif
+	rc = DosAllocMem(&buffer, amt, OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
+
+	if (rc) {
+		fprintf((FILE *)usalp->errfile, "Cannot allocate buffer.\n");
+		return ((void *)0);
+	}
+	usalp->bufbase = buffer;
+
+#ifdef DEBUG
+	fprintf((FILE *)usalp->errfile, "Buffer allocated at: 0x%x\n", usalp->bufbase);
+#endif
+
+	/* Lock memory */
+	if (init_buffer(usalp->bufbase))
+		return (usalp->bufbase);
+
+	fprintf((FILE *)usalp->errfile, "Cannot lock memory buffer.\n");
+	return ((void *)0); /* Error */
+}
+
+static void
+usalo_freebuf(SCSI *usalp)
+{
+	if (usalp->bufbase && DosFreeMem(usalp->bufbase)) {
+		fprintf((FILE *)usalp->errfile,
+		"Cannot free buffer memory for ASPI-Router!\n"); /* Free our memory buffer if not already done */
+	}
+	if (buffer == usalp->bufbase)
+		buffer = NULL;
+	usalp->bufbase = NULL;
+}
+
+static BOOL
+usalo_havebus(SCSI *usalp, int busno)
+{
+	register int	t;
+	register int	l;
+
+	if (busno < 0 || busno >= MAX_SCG)
+		return (FALSE);
+
+	return (TRUE);
+}
+
+static int
+usalo_fileno(SCSI *usalp, int busno, int tgt, int tlun)
+{
+	if (busno < 0 || busno >= MAX_SCG ||
+	    tgt < 0 || tgt >= MAX_TGT ||
+	    tlun < 0 || tlun >= MAX_LUN)
+		return (-1);
+
+	/*
+	 * Return fake
+	 */
+	return (1);
+}
+
+
+static int
+usalo_initiator_id(SCSI *usalp)
+{
+	return (-1);
+}
+
+static int
+usalo_isatapi(SCSI *usalp)
+{
+	return (FALSE);
+}
+
+
+static int
+usalo_reset(SCSI *usalp, int what)
+{
+	ULONG	rc;				/* return value */
+	ULONG	cbreturn;
+	ULONG	cbParam;
+	BOOL	success;
+static	SRB	SRBlock;			/* XXX makes it non reentrant */
+
+	if (what == SCG_RESET_NOP)
+		return (0);
+	if (what != SCG_RESET_BUS) {
+		errno = EINVAL;
+		return (-1);
+	}
+	/*
+	 * XXX Does this reset TGT or BUS ???
+	 */
+	SRBlock.cmd		= SRB_Reset;		/* reset device		*/
+	SRBlock.ha_num		= usal_scsibus(usalp);	/* host adapter number	*/
+	SRBlock.flags		= SRB_Post;		/* posting enabled	*/
+	SRBlock.u.res.target	= usal_target(usalp);	/* target id		*/
+	SRBlock.u.res.lun	= usal_lun(usalp);	/* target LUN		*/
+
+	rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof (SRB), &cbParam,
+			(void*) &SRBlock, sizeof (SRB), &cbreturn);
+	if (rc) {
+		fprintf((FILE *)usalp->errfile,
+				"DosDevIOCtl() failed in resetDevice.\n");
+		return (1);			/* DosDevIOCtl failed */
+	} else {
+		success = wait_post(40000);	/** wait for SRB being processed */
+		if (success)
+			return (2);
+	}
+	if (SRBlock.status != SRB_Done)
+		return (3);
+#ifdef DEBUG
+	fprintf((FILE *)usalp->errfile,
+		"resetDevice of host: %d target: %d lun: %d successful.\n", usal_scsibus(usalp), usal_target(usalp), usal_lun(usalp));
+	fprintf((FILE *)usalp->errfile,
+		"SRBlock.ha_status: 0x%x, SRBlock.target_status: 0x%x, SRBlock.satus: 0x%x\n",
+				SRBlock.u.cmd.ha_status, SRBlock.u.cmd.target_status, SRBlock.status);
+#endif
+	return (0);
+}
+
+/*
+ * Set error flags
+ */
+static void
+set_error(SRB *srb, struct usal_cmd *sp)
+{
+	switch (srb->status) {
+
+	case SRB_InvalidCmd:		/* 0x80 Invalid SCSI request	    */
+	case SRB_InvalidHA:		/* 0x81 Invalid host adapter number */
+	case SRB_BadDevice:		/* 0x82 SCSI device not installed   */
+		sp->error = SCG_FATAL;
+		sp->ux_errno = EINVAL;	/* Should we ever return != EIO	    */
+		sp->ux_errno = EIO;
+		break;
+
+
+	case SRB_Busy:			/* 0x00 SCSI request in progress    */
+	case SRB_Aborted:		/* 0x02 SCSI aborted by host	    */
+	case SRB_BadAbort:		/* 0x03 Unable to abort SCSI request */
+	case SRB_Error:			/* 0x04 SCSI request completed with error */
+	default:
+		sp->error = SCG_RETRYABLE;
+		sp->ux_errno = EIO;
+		break;
+	}
+}
+
+static int
+usalo_send(SCSI *usalp)
+{
+	struct usal_cmd	*sp = usalp->scmd;
+	ULONG	rc;				/* return value */
+static	SRB	SRBlock;			/* XXX makes it non reentrant */
+	Ulong	cbreturn;
+	Ulong	cbParam;
+	UCHAR*	ptr;
+
+	if (usalp->fd < 0) {			/* Set in usalo_open() */
+		sp->error = SCG_FATAL;
+		return (0);
+	}
+
+	if (sp->cdb_len > sizeof (SRBlock.u.cmd.cdb_st)) { /* commandsize too big */
+		sp->error = SCG_FATAL;
+		sp->ux_errno = EINVAL;
+		fprintf((FILE *)usalp->errfile,
+			"sp->cdb_len > SRBlock.u.cmd.cdb_st. Fatal error in usalo_send, exiting...\n");
+		return (-1);
+	}
+
+	/* clear command block */
+	fillbytes((caddr_t)&SRBlock.u.cmd.cdb_st, sizeof (SRBlock.u.cmd.cdb_st), '\0');
+	/* copy cdrecord command into SRB */
+	movebytes(&sp->cdb, &SRBlock.u.cmd.cdb_st, sp->cdb_len);
+
+	/* Build SRB command block */
+	SRBlock.cmd = SRB_Command;
+	SRBlock.ha_num = usal_scsibus(usalp);	/* host adapter number */
+
+	SRBlock.flags = SRB_Post;		/* flags */
+
+	SRBlock.u.cmd.target	= usal_target(usalp); /* Target SCSI ID */
+	SRBlock.u.cmd.lun	= usal_lun(usalp); /* Target SCSI LUN */
+	SRBlock.u.cmd.data_len	= sp->size;	/* # of bytes transferred */
+	SRBlock.u.cmd.data_ptr	= 0;		/* pointer to data buffer */
+	SRBlock.u.cmd.sense_len	= sp->sense_len; /* length of sense buffer */
+
+	SRBlock.u.cmd.link_ptr	= 0;		/* pointer to next SRB */
+	SRBlock.u.cmd.cdb_len	= sp->cdb_len;	/* SCSI command length */
+
+	/* Specify direction */
+	if (sp->flags & SCG_RECV_DATA) {
+		SRBlock.flags |= SRB_Read;
+	} else {
+		if (sp->size > 0) {
+			SRBlock.flags |= SRB_Write;
+			if (usalp->bufbase != sp->addr) { /* Copy only if data not in ASPI-Mem */
+				movebytes(sp->addr, usalp->bufbase, sp->size);
+			}
+		} else {
+			SRBlock.flags |= SRB_NoTransfer;
+		}
+	}
+	sp->error	= SCG_NO_ERROR;
+	sp->sense_count	= 0;
+	sp->u_scb.cmd_scb[0] = 0;
+	sp->resid	= 0;
+
+	/* execute SCSI	command */
+	rc = DosDevIOCtl(driver_handle, 0x92, 0x02,
+			(void*) &SRBlock, sizeof (SRB), &cbParam,
+			(void*) &SRBlock, sizeof (SRB), &cbreturn);
+
+	if (rc) {		/* An error occured */
+		fprintf((FILE *)usalp->errfile,
+				"DosDevIOCtl() in sendCommand failed.\n");
+		sp->error = SCG_FATAL;
+		sp->ux_errno = EIO;	/* Später vielleicht errno einsetzen */
+		return (rc);
+	} else {
+		/* Wait until the command is processed */
+		rc = wait_post(sp->timeout*1000);
+		if (rc) {	/* An error occured */
+			if (rc == 640) {
+				/* Timeout */
+				sp->error = SCG_TIMEOUT;
+				sp->ux_errno = EIO;
+				fprintf((FILE *)usalp->errfile,
+						"Timeout during SCSI-Command.\n");
+				return (1);
+			}
+			sp->error = SCG_FATAL;
+			sp->ux_errno = EIO;
+			fprintf((FILE *)usalp->errfile,
+					"Fatal Error during DosWaitEventSem().\n");
+			return (1);
+		}
+
+		/* The command is processed */
+		if (SRBlock.status == SRB_Done) {	/* succesful completion */
+#ifdef DEBUG
+			fprintf((FILE *)usalp->errfile,
+				"Command successful finished. SRBlock.status=0x%x\n\n", SRBlock.status);
+#endif
+			sp->sense_count = 0;
+			sp->resid = 0;
+			if (sp->flags & SCG_RECV_DATA) {	/* We read data */
+				if (sp->addr && sp->size) {
+					if (usalp->bufbase != sp->addr)	/* Copy only if data not in ASPI-Mem */
+						movebytes(usalp->bufbase, sp->addr, SRBlock.u.cmd.data_len);
+					ptr = (UCHAR*)sp->addr;
+					sp->resid = sp->size - SRBlock.u.cmd.data_len; /*nicht übertragene bytes. Korrekt berechnet???*/
+				}
+			}	/* end of if (sp->flags & SCG_RECV_DATA) */
+			if (SRBlock.u.cmd.target_status == SRB_CheckStatus) { /* Sense data valid */
+				sp->sense_count	= (int)SRBlock.u.cmd.sense_len;
+				if (sp->sense_count > sp->sense_len)
+					sp->sense_count = sp->sense_len;
+
+				ptr = (UCHAR*)&SRBlock.u.cmd.cdb_st;
+				ptr += SRBlock.u.cmd.cdb_len;
+
+				fillbytes(&sp->u_sense.Sense, sizeof (sp->u_sense.Sense), '\0');
+				movebytes(ptr, &sp->u_sense.Sense, sp->sense_len);
+
+				sp->u_scb.cmd_scb[0] = SRBlock.u.cmd.target_status;
+				sp->ux_errno = EIO;	/* Später differenzieren? */
+			}
+			return (0);
+		}
+		/* SCSI-Error occured */
+		set_error(&SRBlock, sp);
+
+		if (SRBlock.u.cmd.target_status == SRB_CheckStatus) {	/* Sense data valid */
+			sp->sense_count	= (int)SRBlock.u.cmd.sense_len;
+			if (sp->sense_count > sp->sense_len)
+				sp->sense_count = sp->sense_len;
+
+			ptr = (UCHAR*)&SRBlock.u.cmd.cdb_st;
+			ptr += SRBlock.u.cmd.cdb_len;
+
+			fillbytes(&sp->u_sense.Sense, sizeof (sp->u_sense.Sense), '\0');
+			movebytes(ptr, &sp->u_sense.Sense, sp->sense_len);
+
+			sp->u_scb.cmd_scb[0] = SRBlock.u.cmd.target_status;
+		}
+		if (sp->flags & SCG_RECV_DATA) {
+			if (sp->addr && sp->size) {
+				if (usalp->bufbase != sp->addr)	/* Copy only if data not in ASPI-Mem */
+					movebytes(usalp->bufbase, sp->addr, SRBlock.u.cmd.data_len);
+			}
+		}
+#ifdef	really
+		sp->resid	= SRBlock.u.cmd.data_len; /* XXXXX Got no Data ????? */
+#else
+		sp->resid	= sp->size - SRBlock.u.cmd.data_len;
+#endif
+		return (1);
+	}
+}
+
+/***************************************************************************
+ *									   *
+ *  BOOL open_driver()							   *
+ *									   *
+ *  Opens the ASPI Router device driver and sets device_handle.		   *
+ *  Returns:								   *
+ *    TRUE - Success							   *
+ *    FALSE - Unsuccessful opening of device driver			   *
+ *									   *
+ *  Preconditions: ASPI Router driver has be loaded			   *
+ *									   *
+ ***************************************************************************/
+static BOOL
+open_driver(SCSI *usalp)
+{
+	ULONG	rc;			/* return value */
+	ULONG	ActionTaken;		/* return value	*/
+	USHORT	openSemaReturn;		/* return value	*/
+	ULONG	cbreturn;
+	ULONG	cbParam;
+
+	if (driver_handle)		/* ASPI-Router already opened	*/
+		return (TRUE);
+
+	rc = DosOpen((PSZ) "aspirou$",	/* open driver*/
+			&driver_handle,
+			&ActionTaken,
+			0,
+			0,
+			FILE_OPEN,
+			OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE,
+			NULL);
+	if (rc) {
+		fprintf((FILE *)usalp->errfile,
+				"Cannot open ASPI-Router!\n");
+
+		return (FALSE);		/* opening failed -> return false*/
+	}
+
+	/* Init semaphore */
+	if (DosCreateEventSem(NULL, &postSema,	/* create event semaphore */
+				DC_SEM_SHARED, 0)) {
+		DosClose(driver_handle);
+		fprintf((FILE *)usalp->errfile,
+				"Cannot create event semaphore!\n");
+
+		return (FALSE);
+	}
+	rc = DosDevIOCtl(driver_handle, 0x92, 0x03,	/* pass semaphore handle */
+			(void*) &postSema, sizeof (HEV), /* to driver		 */
+			&cbParam, (void*) &openSemaReturn,
+			sizeof (USHORT), &cbreturn);
+
+	if (rc||openSemaReturn) {			/* Error */
+		DosCloseEventSem(postSema);
+		DosClose(driver_handle);
+		return (FALSE);
+	}
+	return (TRUE);
+}
+
+/***************************************************************************
+ *									   *
+ *  BOOL close_driver()							   *
+ *									   *
+ *  Closes the device driver						   *
+ *  Returns:								   *
+ *    TRUE - Success							   *
+ *    FALSE - Unsuccessful closing of device driver			   *
+ *									   *
+ *  Preconditions: ASPI Router driver has be opened with open_driver	   *
+ *									   *
+ ***************************************************************************/
+static BOOL
+close_driver()
+{
+	ULONG rc;				/* return value */
+
+	if (driver_handle) {
+		rc = DosClose(driver_handle);
+		if (rc)
+			return (FALSE);		/* closing failed -> return false */
+		driver_handle = 0;
+		if (DosCloseEventSem(postSema))
+			fprintf(stderr, "Cannot close event semaphore!\n");
+		if (buffer && DosFreeMem(buffer)) {
+			fprintf(stderr,
+			"Cannot free buffer memory for ASPI-Router!\n"); /* Free our memory buffer if not already done */
+		}
+		buffer = NULL;
+	}
+	return (TRUE);
+}
+
+static ULONG
+wait_post(ULONG ulTimeOut)
+{
+	ULONG count = 0;
+	ULONG rc;					/* return value */
+
+/*	rc = DosWaitEventSem(postSema, -1);*/		/* wait forever*/
+	rc = DosWaitEventSem(postSema, ulTimeOut);
+	DosResetEventSem(postSema, &count);
+	return (rc);
+}
+
+static BOOL
+init_buffer(void *mem)
+{
+	ULONG	rc;					/* return value */
+	USHORT lockSegmentReturn;			/* return value */
+	Ulong	cbreturn;
+	Ulong	cbParam;
+
+	rc = DosDevIOCtl(driver_handle, 0x92, 0x04,	/* pass buffers pointer */
+			(void*) mem, sizeof (void*),	/* to driver */
+			&cbParam, (void*) &lockSegmentReturn,
+			sizeof (USHORT), &cbreturn);
+	if (rc)
+		return (FALSE);				/* DosDevIOCtl failed */
+	if (lockSegmentReturn)
+		return (FALSE);				/* Driver could not lock segment */
+	return (TRUE);
+}
+#define	sense	u_sense.Sense