Imported Upstream version 1.1.11upstream/1.1.11upstream

1 files changed, 2918 insertions, 0 deletions

diff --git a/wodim/scsi_cdr.c b/wodim/scsi_cdr.c
new file mode 100644
index 0000000..fbb8270
--- /dev/null
+++ b/wodim/scsi_cdr.c
@@ -0,0 +1,2918 @@
+/*
+ * 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_cdr.c	1.137 04/05/25 Copyright 1995-2004 J. Schilling */
+/*
+ *	SCSI command functions for cdrecord
+ *	covering pre-MMC standard functions up to MMC-2
+ *
+ *	Copyright (c) 1995-2004 J. Schilling
+ */
+/*
+ * 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.
+ */
+
+/*
+ * NOTICE:	The Philips CDD 521 has several firmware bugs.
+ *		One of them is not to respond to a SCSI selection
+ *		within 200ms if the general load on the
+ *		SCSI bus is high. To deal with this problem
+ *		most of the SCSI commands are send with the
+ *		SCG_CMD_RETRY flag enabled.
+ */
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <standard.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <fctldefs.h>
+#include <errno.h>
+#include <strdefs.h>
+#include <timedefs.h>
+
+#include <utypes.h>
+#include <btorder.h>
+#include <intcvt.h>
+#include <schily.h>
+
+#include <usal/usalcmd.h>
+#include <usal/scsidefs.h>
+#include <usal/scsireg.h>
+#include <usal/scsitransp.h>
+
+#include "scsimmc.h"
+#include "wodim.h"
+#include "scsi_scan.h"
+
+#define	strbeg(s1, s2)	(strstr((s2), (s1)) == (s2))
+
+BOOL	unit_ready(SCSI *usalp);
+BOOL	wait_unit_ready(SCSI *usalp, int secs);
+BOOL	scsi_in_progress(SCSI *usalp);
+BOOL	cdr_underrun(SCSI *usalp);
+int	test_unit_ready(SCSI *usalp);
+int	rezero_unit(SCSI *usalp);
+int	request_sense(SCSI *usalp);
+int	request_sense_b(SCSI *usalp, caddr_t bp, int cnt);
+int	inquiry(SCSI *usalp, caddr_t, int);
+int	read_capacity(SCSI *usalp);
+void	print_capacity(SCSI *usalp, FILE *f);
+int	scsi_load_unload(SCSI *usalp, int);
+int	scsi_prevent_removal(SCSI *usalp, int);
+int	scsi_start_stop_unit(SCSI *usalp, int, int, BOOL immed);
+int	scsi_set_speed(SCSI *usalp, int readspeed, int writespeed, int rotctl);
+int	scsi_get_speed(SCSI *usalp, int *readspeedp, int *writespeedp);
+int	qic02(SCSI *usalp, int);
+int	write_xscsi(SCSI *usalp, caddr_t, long, long, int);
+int	write_xg0(SCSI *usalp, caddr_t, long, long, int);
+int	write_xg1(SCSI *usalp, caddr_t, long, long, int);
+int	write_xg5(SCSI *usalp, caddr_t, long, long, int);
+int	seek_scsi(SCSI *usalp, long addr);
+int	seek_g0(SCSI *usalp, long addr);
+int	seek_g1(SCSI *usalp, long addr);
+int	scsi_flush_cache(SCSI *usalp, BOOL immed);
+int	read_buffer(SCSI *usalp, caddr_t bp, int cnt, int mode);
+int	write_buffer(SCSI *usalp, char *buffer, long length, int mode, 
+						 int bufferid, long offset);
+int	read_subchannel(SCSI *usalp, caddr_t bp, int track, int cnt, int msf, 
+							 int subq, int fmt);
+int	read_toc(SCSI *usalp, caddr_t, int, int, int, int);
+int	read_toc_philips(SCSI *usalp, caddr_t, int, int, int, int);
+int	read_header(SCSI *usalp, caddr_t, long, int, int);
+int	read_disk_info(SCSI *usalp, caddr_t, int);
+int	read_track_info(SCSI *usalp, caddr_t, int type, int addr, int cnt);
+int	read_rzone_info(SCSI *usalp, caddr_t bp, int cnt);
+int	reserve_tr_rzone(SCSI *usalp, long size);
+int	read_dvd_structure(SCSI *usalp, caddr_t bp, int cnt, int addr, int layer, 
+								 int fmt);
+int	send_dvd_structure(SCSI *usalp, caddr_t bp, int cnt, int layer, int fmt);
+int	send_opc(SCSI *usalp, caddr_t, int cnt, int doopc);
+int	read_track_info_philips(SCSI *usalp, caddr_t, int, int);
+int	scsi_close_tr_session(SCSI *usalp, int type, int track, BOOL immed);
+int	read_master_cue(SCSI *usalp, caddr_t bp, int sheet, int cnt);
+int	send_cue_sheet(SCSI *usalp, caddr_t bp, long size);
+int	read_buff_cap(SCSI *usalp, long *, long *);
+int	scsi_blank(SCSI *usalp, long addr, int blanktype, BOOL immed);
+int	scsi_format(SCSI *usalp, caddr_t addr, int size, BOOL background);
+int	scsi_set_streaming(SCSI *usalp, caddr_t addr, int size);
+BOOL	allow_atapi(SCSI *usalp, BOOL new);
+int	mode_select(SCSI *usalp, Uchar *, int, int, int);
+int	mode_sense(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+int	mode_select_sg0(SCSI *usalp, Uchar *, int, int, int);
+int	mode_sense_sg0(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+int	mode_select_g0(SCSI *usalp, Uchar *, int, int, int);
+int	mode_select_g1(SCSI *usalp, Uchar *, int, int, int);
+int	mode_sense_g0(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+int	mode_sense_g1(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+int	read_tochdr(SCSI *usalp, cdr_t *, int *, int *);
+int	read_cdtext(SCSI *usalp);
+int	read_trackinfo(SCSI *usalp, int, long *, struct msf *, int *, int *, 
+							int *);
+int	read_B0(SCSI *usalp, BOOL isbcd, long *b0p, long *lop);
+int	read_session_offset(SCSI *usalp, long *);
+int	read_session_offset_philips(SCSI *usalp, long *);
+int	sense_secsize(SCSI *usalp, int current);
+int	select_secsize(SCSI *usalp, int);
+BOOL	is_cddrive(SCSI *usalp);
+BOOL	is_unknown_dev(SCSI *usalp);
+int	read_scsi(SCSI *usalp, caddr_t, long, int);
+int	read_g0(SCSI *usalp, caddr_t, long, int);
+int	read_g1(SCSI *usalp, caddr_t, long, int);
+BOOL	getdev(SCSI *usalp, BOOL);
+void	printinq(SCSI *usalp, FILE *f);
+void	printdev(SCSI *usalp);
+BOOL	do_inquiry(SCSI *usalp, BOOL);
+BOOL	recovery_needed(SCSI *usalp, cdr_t *);
+int	scsi_load(SCSI *usalp, cdr_t *);
+int	scsi_unload(SCSI *usalp, cdr_t *);
+int	scsi_cdr_write(SCSI *usalp, caddr_t bp, long sectaddr, long size, 
+							int blocks, BOOL islast);
+struct cd_mode_page_2A * mmc_cap(SCSI *usalp, Uchar *modep);
+void	mmc_getval(struct cd_mode_page_2A *mp, BOOL *cdrrp, BOOL *cdwrp, 
+					  BOOL *cdrrwp, BOOL *cdwrwp, BOOL *dvdp, BOOL *dvdwp);
+BOOL	is_mmc(SCSI *usalp, BOOL *cdwp, BOOL *dvdwp);
+BOOL	mmc_check(SCSI *usalp, BOOL *cdrrp, BOOL *cdwrp, BOOL *cdrrwp, 
+					 BOOL *cdwrwp, BOOL *dvdp, BOOL *dvdwp);
+static	void	print_speed(char *fmt, int val);
+void	print_capabilities(SCSI *usalp);
+
+BOOL
+unit_ready(SCSI *usalp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	if (test_unit_ready(usalp) >= 0)		/* alles OK */
+		return (TRUE);
+	else if (scmd->error >= SCG_FATAL)	/* nicht selektierbar */
+		return (FALSE);
+
+	if (usal_sense_key(usalp) == SC_UNIT_ATTENTION) {
+		if (test_unit_ready(usalp) >= 0)	/* alles OK */
+			return (TRUE);
+	}
+	if ((usal_cmd_status(usalp) & ST_BUSY) != 0) {
+		/*
+		 * Busy/reservation_conflict
+		 */
+		usleep(500000);
+		if (test_unit_ready(usalp) >= 0)	/* alles OK */
+			return (TRUE);
+	}
+	if (usal_sense_key(usalp) == -1) {	/* non extended Sense */
+		if (usal_sense_code(usalp) == 4)	/* NOT_READY */
+			return (FALSE);
+		return (TRUE);
+	}
+						/* FALSE wenn NOT_READY */
+	return (usal_sense_key(usalp) != SC_NOT_READY);
+}
+
+BOOL
+wait_unit_ready(SCSI *usalp, int secs)
+{
+	int	i;
+	int	c;
+	int	k;
+	int	ret;
+
+	usalp->silent++;
+	ret = test_unit_ready(usalp);		/* eat up unit attention */
+	if (ret < 0)
+		ret = test_unit_ready(usalp);	/* got power on condition? */
+	usalp->silent--;
+
+	if (ret >= 0)				/* success that's enough */
+		return (TRUE);
+
+	usalp->silent++;
+	for (i = 0; i < secs && (ret = test_unit_ready(usalp)) < 0; i++) {
+		if (usalp->scmd->scb.busy != 0) {
+			sleep(1);
+			continue;
+		}
+		c = usal_sense_code(usalp);
+		k = usal_sense_key(usalp);
+		/*
+		 * Abort quickly if it does not make sense to wait.
+		 * 0x30 == Cannot read medium
+		 * 0x3A == Medium not present
+		 */
+		if ((k == SC_NOT_READY && (c == 0x3A || c == 0x30)) ||
+		    (k == SC_MEDIUM_ERROR)) {
+			if (usalp->silent <= 1)
+				usal_printerr(usalp);
+			usalp->silent--;
+			return (FALSE);
+		}
+		sleep(1);
+	}
+	usalp->silent--;
+	if (ret < 0)
+		return (FALSE);
+	return (TRUE);
+}
+
+BOOL
+scsi_in_progress(SCSI *usalp)
+{
+	if (usal_sense_key(usalp) == SC_NOT_READY &&
+		/*
+		 * Logigal unit not ready operation/long_write in progress
+		 */
+	    usal_sense_code(usalp) == 0x04 &&
+	    (usal_sense_qual(usalp) == 0x04 || /* CyberDr. "format in progress"*/
+	    usal_sense_qual(usalp) == 0x07 || /* "operation in progress"	    */
+	    usal_sense_qual(usalp) == 0x08)) { /* "long write in progress"    */
+		return (TRUE);
+	} else {
+		if (usalp->silent <= 1)
+			usal_printerr(usalp);
+	}
+	return (FALSE);
+}
+
+BOOL
+cdr_underrun(SCSI *usalp)
+{
+	if ((usal_sense_key(usalp) != SC_ILLEGAL_REQUEST &&
+	    usal_sense_key(usalp) != SC_MEDIUM_ERROR))
+		return (FALSE);
+
+	if ((usal_sense_code(usalp) == 0x21 &&
+	    (usal_sense_qual(usalp) == 0x00 ||	/* logical block address out of range */
+	    usal_sense_qual(usalp) == 0x02)) ||	/* invalid address for write */
+
+	    (usal_sense_code(usalp) == 0x0C &&
+	    usal_sense_qual(usalp) == 0x09)) {	/* write error - loss of streaming */
+		return (TRUE);
+	}
+	/*
+	 * XXX Bei manchen Brennern kommt mach dem der Brennvorgang bereits
+	 * XXX eine Weile gelaufen ist ein 5/24/0 Invalid field in CDB.
+	 * XXX Daher sollte man testen ob schon geschrieben wurde...
+	 */
+	return (FALSE);
+}
+
+int
+test_unit_ready(SCSI *usalp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)0;
+	scmd->size = 0;
+	scmd->flags = SCG_DISRE_ENA | (usalp->silent ? SCG_SILENT:0);
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_TEST_UNIT_READY;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "test unit ready";
+
+	return (usal_cmd(usalp));
+}
+
+int
+rezero_unit(SCSI *usalp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)0;
+	scmd->size = 0;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_REZERO_UNIT;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "rezero unit";
+
+	return (usal_cmd(usalp));
+}
+
+int
+request_sense(SCSI *usalp)
+{
+		char	sensebuf[CCS_SENSE_LEN];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = sensebuf;
+	scmd->size = sizeof (sensebuf);
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.count = CCS_SENSE_LEN;
+
+	usalp->cmdname = "request_sense";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	usal_prsense((Uchar *)sensebuf, CCS_SENSE_LEN - usal_getresid(usalp));
+	return (0);
+}
+
+int
+request_sense_b(SCSI *usalp, caddr_t bp, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.count = cnt;
+
+	usalp->cmdname = "request_sense";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+inquiry(SCSI *usalp, caddr_t bp, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes(bp, cnt, '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_INQUIRY;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.count = cnt;
+
+	usalp->cmdname = "inquiry";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	if (usalp->verbose)
+		usal_prbytes("Inquiry Data   :", (Uchar *)bp, cnt - usal_getresid(usalp));
+	return (0);
+}
+
+int
+read_capacity(SCSI *usalp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)usalp->cap;
+	scmd->size = sizeof (struct scsi_capacity);
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x25;	/* Read Capacity */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, 0); /* Full Media */
+
+	usalp->cmdname = "read capacity";
+
+	if (usal_cmd(usalp) < 0) {
+		return (-1);
+	} else {
+		long	cbsize;
+		long	cbaddr;
+
+		/*
+		 * c_bsize & c_baddr are signed Int32_t
+		 * so we use signed int conversion here.
+		 */
+		cbsize = a_to_4_byte(&usalp->cap->c_bsize);
+		cbaddr = a_to_4_byte(&usalp->cap->c_baddr);
+		usalp->cap->c_bsize = cbsize;
+		usalp->cap->c_baddr = cbaddr;
+	}
+	return (0);
+}
+
+void
+print_capacity(SCSI *usalp, FILE *f)
+{
+	long	kb;
+	long	mb;
+	long	prmb;
+	double	dkb;
+
+	dkb =  (usalp->cap->c_baddr+1.0) * (usalp->cap->c_bsize/1024.0);
+	kb = dkb;
+	mb = dkb / 1024.0;
+	prmb = dkb / 1000.0 * 1.024;
+	fprintf(f, "Capacity: %ld Blocks = %ld kBytes = %ld MBytes = %ld prMB\n",
+		(long)usalp->cap->c_baddr+1, kb, mb, prmb);
+	fprintf(f, "Sectorsize: %ld Bytes\n", (long)usalp->cap->c_bsize);
+}
+
+int
+scsi_load_unload(SCSI *usalp, int load)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xA6;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g5_cdb.addr[1] = load?3:2;
+	scmd->cdb.g5_cdb.count[2] = 0; /* slot # */
+
+	usalp->cmdname = "medium load/unload";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+scsi_prevent_removal(SCSI *usalp, int prevent)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = 0x1E;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.count = prevent & 1;
+
+	usalp->cmdname = "prevent/allow medium removal";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+
+int
+scsi_start_stop_unit(SCSI *usalp, int flg, int loej, BOOL immed)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = 0x1B;	/* Start Stop Unit */
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.count = (flg ? 1:0) | (loej ? 2:0);
+
+	if (immed)
+		scmd->cdb.cmd_cdb[1] |= 0x01;
+
+	usalp->cmdname = "start/stop unit";
+
+	return (usal_cmd(usalp));
+}
+
+int
+scsi_set_streaming(SCSI *usalp, caddr_t perf_desc, int size)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = perf_desc;
+	scmd->size = size;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xB6;
+	scmd->cdb.cmd_cdb[11] = 0;
+	scmd->cdb.cmd_cdb[10] = size;
+
+	usalp->cmdname = "set streaming";
+
+  if(usalp->verbose) 
+     fprintf(stderr, "scsi_set_streaming\n");
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+    
+int
+scsi_set_speed(SCSI *usalp, int readspeed, int writespeed, int rotctl)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xBB;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	if (readspeed < 0)
+		i_to_2_byte(&scmd->cdb.g5_cdb.addr[0], 0xFFFF);
+	else
+		i_to_2_byte(&scmd->cdb.g5_cdb.addr[0], readspeed);
+	if (writespeed < 0)
+		i_to_2_byte(&scmd->cdb.g5_cdb.addr[2], 0xFFFF);
+	else
+		i_to_2_byte(&scmd->cdb.g5_cdb.addr[2], writespeed);
+
+	scmd->cdb.cmd_cdb[1] |= rotctl & 0x03;
+
+	usalp->cmdname = "set cd speed";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+scsi_get_speed(SCSI *usalp, int *readspeedp, int *writespeedp)
+{
+	struct	cd_mode_page_2A *mp;
+	Uchar	m[256];
+	int	val;
+
+	usalp->silent++;
+	mp = mmc_cap(usalp, m); /* Get MMC capabilities in allocated mp */
+	usalp->silent--;
+	if (mp == NULL)
+		return (-1);	/* Pre SCSI-3/mmc drive		*/
+
+	val = a_to_u_2_byte(mp->cur_read_speed);
+	if (readspeedp)
+		*readspeedp = val;
+
+	if (mp->p_len >= 28)
+		val = a_to_u_2_byte(mp->v3_cur_write_speed);
+	else
+		val = a_to_u_2_byte(mp->cur_write_speed);
+	if (writespeedp)
+		*writespeedp = val;
+
+	return (0);
+}
+
+
+int
+qic02(SCSI *usalp, int cmd)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)0;
+	scmd->size = 0;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = DEF_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = 0x0D;	/* qic02 Sysgen SC4000 */
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.mid_addr = cmd;
+
+	usalp->cmdname = "qic 02";
+	return (usal_cmd(usalp));
+}
+
+#define	G0_MAXADDR	0x1FFFFFL
+
+int 
+write_xscsi(SCSI *usalp, caddr_t bp, long addr, long size, int cnt)
+{
+	if (addr <= G0_MAXADDR)
+		return (write_xg0(usalp, bp, addr, size, cnt));
+	else
+		return (write_xg1(usalp, bp, addr, size, cnt));
+}
+
+int 
+write_xg0(SCSI *usalp, 
+          caddr_t bp    /* address of buffer */, 
+          long addr     /* disk address (sector) to put */, 
+          long size     /* number of bytes to transfer */, 
+          int cnt       /* sectorcount */)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = size;
+	scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
+/*	scmd->flags = SCG_DISRE_ENA;*/
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_WRITE;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	g0_cdbaddr(&scmd->cdb.g0_cdb, addr);
+	scmd->cdb.g0_cdb.count = cnt;
+
+	usalp->cmdname = "write_g0";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (size - usal_getresid(usalp));
+}
+
+int 
+write_xg1(SCSI *usalp, 
+          caddr_t bp    /* address of buffer */, 
+          long addr     /* disk address (sector) to put */, 
+          long size     /* number of bytes to transfer */, 
+          int cnt       /* sectorcount */)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = size;
+	scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
+/*	scmd->flags = SCG_DISRE_ENA;*/
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = SC_EWRITE;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "write_g1";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (size - usal_getresid(usalp));
+}
+
+int 
+write_xg5(SCSI *usalp,
+          caddr_t bp    /* address of buffer */, 
+          long addr     /* disk address (sector) to put */, 
+          long size     /* number of bytes to transfer */, 
+          int cnt       /* sectorcount */)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = size;
+	scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
+/*	scmd->flags = SCG_DISRE_ENA;*/
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xAA;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	g5_cdbaddr(&scmd->cdb.g5_cdb, addr);
+	g5_cdblen(&scmd->cdb.g5_cdb, cnt);
+
+	usalp->cmdname = "write_g5";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (size - usal_getresid(usalp));
+}
+
+int
+seek_scsi(SCSI *usalp, long addr)
+{
+	if (addr <= G0_MAXADDR)
+		return (seek_g0(usalp, addr));
+	else
+		return (seek_g1(usalp, addr));
+}
+
+int
+seek_g0(SCSI *usalp, long addr)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = 0x0B;	/* Seek */
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	g0_cdbaddr(&scmd->cdb.g0_cdb, addr);
+
+	usalp->cmdname = "seek_g0";
+
+	return (usal_cmd(usalp));
+}
+
+int
+seek_g1(SCSI *usalp, long addr)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x2B;	/* Seek G1 */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
+
+	usalp->cmdname = "seek_g1";
+
+	return (usal_cmd(usalp));
+}
+
+int
+scsi_flush_cache(SCSI *usalp, BOOL immed)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 2 * 60;		/* Max: sizeof (CDR-cache)/150KB/s */
+	scmd->cdb.g1_cdb.cmd = 0x35;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	if (immed)
+		scmd->cdb.cmd_cdb[1] |= 0x02;
+
+	usalp->cmdname = "flush cache";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_buffer(SCSI *usalp, caddr_t bp, int cnt, int mode)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->dma_read = 1;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x3C;	/* Read Buffer */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.cmd_cdb[1] |= (mode & 7);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read buffer";
+
+	return (usal_cmd(usalp));
+}
+
+int
+write_buffer(SCSI *usalp, char *buffer, long length, int mode, int bufferid, 
+             long offset)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	char			*cdb;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = buffer;
+	scmd->size = length;
+	scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	cdb = (char *)scmd->cdb.cmd_cdb;
+
+	cdb[0] = 0x3B;
+	cdb[1] = mode & 7;
+	cdb[2] = bufferid;
+	cdb[3] = offset >> 16;
+	cdb[4] = (offset >> 8) & 0xff;
+	cdb[5] = offset & 0xff;
+	cdb[6] = length >> 16;
+	cdb[7] = (length >> 8) & 0xff;
+	cdb[8] = length & 0xff;
+
+	usalp->cmdname = "write_buffer";
+
+	if (usal_cmd(usalp) >= 0)
+		return (1);
+	return (0);
+}
+
+int
+read_subchannel(SCSI *usalp, caddr_t bp, int track, int cnt, int msf, int subq, 
+					 int fmt)
+
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x42;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	if (msf)
+		scmd->cdb.g1_cdb.res = 1;
+	if (subq)
+		scmd->cdb.g1_cdb.addr[0] = 0x40;
+	scmd->cdb.g1_cdb.addr[1] = fmt;
+	scmd->cdb.g1_cdb.res6 = track;
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read subchannel";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_toc(SCSI *usalp, caddr_t bp, int track, int cnt, int msf, int fmt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x43;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	if (msf)
+		scmd->cdb.g1_cdb.res = 1;
+	scmd->cdb.g1_cdb.addr[0] = fmt & 0x0F;
+	scmd->cdb.g1_cdb.res6 = track;
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read toc";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_toc_philips(SCSI *usalp, caddr_t bp, int track, int cnt, int msf, int fmt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 4 * 60;		/* May last  174s on a TEAC CD-R55S */
+	scmd->cdb.g1_cdb.cmd = 0x43;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	if (msf)
+		scmd->cdb.g1_cdb.res = 1;
+	scmd->cdb.g1_cdb.res6 = track;
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	if (fmt & 1)
+		scmd->cdb.g1_cdb.vu_96 = 1;
+	if (fmt & 2)
+		scmd->cdb.g1_cdb.vu_97 = 1;
+
+	usalp->cmdname = "read toc";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_header(SCSI *usalp, caddr_t bp, long addr, int cnt, int msf)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x44;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	if (msf)
+		scmd->cdb.g1_cdb.res = 1;
+	g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read header";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_disk_info(SCSI *usalp, caddr_t bp, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 4 * 60;		/* Needs up to 2 minutes */
+	scmd->cdb.g1_cdb.cmd = 0x51;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read disk info";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_track_info(SCSI *usalp, caddr_t bp, int type, int addr, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 4 * 60;		/* Needs up to 2 minutes */
+	scmd->cdb.g1_cdb.cmd = 0x52;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+/*	scmd->cdb.cmd_cdb[1] = type & 0x03;*/
+	scmd->cdb.cmd_cdb[1] = type;
+	g1_cdbaddr(&scmd->cdb.g1_cdb, addr);	/* LBA/Track/Session */
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read track info";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+reserve_track(SCSI *usalp, Ulong size)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof(*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x53;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	i_to_4_byte(&scmd->cdb.g1_cdb.addr[3], size);
+
+	usalp->cmdname = "reserve track";
+
+	if (usal_cmd(usalp) < 0) 
+		return (-1);
+
+	return (0);
+
+}
+
+int
+read_rzone_info(SCSI *usalp, caddr_t bp, int cnt)
+{
+	return (read_track_info(usalp, bp, TI_TYPE_LBA, 0, cnt));
+}
+
+int
+reserve_tr_rzone(SCSI *usalp, long size /* number of blocks */)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)0;
+	scmd->size = 0;
+	scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x53;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	i_to_4_byte(&scmd->cdb.g1_cdb.addr[3], size);
+
+	usalp->cmdname = "reserve_track_rzone";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_dvd_structure(SCSI *usalp, caddr_t bp, int cnt, int addr, int layer, 
+                   int fmt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 4 * 60;		/* Needs up to 2 minutes ??? */
+	scmd->cdb.g5_cdb.cmd = 0xAD;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	g5_cdbaddr(&scmd->cdb.g5_cdb, addr);
+	g5_cdblen(&scmd->cdb.g5_cdb, cnt);
+	scmd->cdb.g5_cdb.count[0] = layer;
+	scmd->cdb.g5_cdb.count[1] = fmt;
+
+	usalp->cmdname = "read dvd structure";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+send_dvd_structure(SCSI *usalp, caddr_t bp, int cnt, int layer, int fmt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 4 * 60;		/* Needs up to 2 minutes ??? */
+	scmd->cdb.g5_cdb.cmd = 0xBF;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	g5_cdblen(&scmd->cdb.g5_cdb, cnt);
+
+	scmd->cdb.cmd_cdb[7] = fmt;
+
+	usalp->cmdname = "send dvd structure";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+send_opc(SCSI *usalp, caddr_t bp, int cnt, int doopc)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 60;
+	scmd->cdb.g1_cdb.cmd = 0x54;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.reladr = doopc?1:0;
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "send opc";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_track_info_philips(SCSI *usalp, caddr_t bp, int track, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0xE5;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, track);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read track info";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+scsi_close_tr_session(SCSI *usalp, int type, int track, BOOL immed)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 8 * 60;		/* Needs up to 4 minutes */
+	scmd->cdb.g1_cdb.cmd = 0x5B;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.addr[0] = type;
+	scmd->cdb.g1_cdb.addr[3] = track;
+
+	if (immed)
+		scmd->cdb.g1_cdb.reladr = 1;
+/*		scmd->cdb.cmd_cdb[1] |= 0x01;*/
+#ifdef	nono
+	scmd->cdb.g1_cdb.reladr = 1;	/* IMM hack to test Mitsumi behaviour*/
+#endif
+
+	usalp->cmdname = "close track/session";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+read_master_cue(SCSI *usalp, caddr_t bp, int sheet, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x59;		/* Read master cue */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.addr[2] = sheet;
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read master cue";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+int
+send_cue_sheet(SCSI *usalp, caddr_t bp, long size)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = size;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x5D;	/* Send CUE sheet */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, size);
+
+	usalp->cmdname = "send_cue_sheet";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (size - scmd->resid);
+}
+
+int
+read_buff_cap(SCSI *usalp, long *sp, long *fp)
+{
+	char	resp[12];
+	Ulong	freespace;
+	Ulong	bufsize;
+	int	per;
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)resp;
+	scmd->size = sizeof (resp);
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x5C;		/* Read buffer cap */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, sizeof (resp));
+
+	usalp->cmdname = "read buffer cap";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	bufsize   = a_to_u_4_byte(&resp[4]);
+	freespace = a_to_u_4_byte(&resp[8]);
+	if (sp)
+		*sp = bufsize;
+	if (fp)
+		*fp = freespace;
+
+	if (usalp->verbose || (sp == 0 && fp == 0))
+		printf("BFree: %ld K BSize: %ld K\n", freespace >> 10, bufsize >> 10);
+
+	if (bufsize == 0)
+		return (0);
+	per = (100 * (bufsize - freespace)) / bufsize;
+	if (per < 0)
+		return (0);
+	if (per > 100)
+		return (100);
+	return (per);
+}
+
+int
+scsi_blank(SCSI *usalp, long addr, int blanktype, BOOL immed)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 160 * 60; /* full blank at 1x could take 80 minutes */
+	scmd->cdb.g5_cdb.cmd = 0xA1;	/* Blank */
+	scmd->cdb.g0_cdb.high_addr = blanktype;
+	g1_cdbaddr(&scmd->cdb.g5_cdb, addr);
+
+	if (immed)
+		scmd->cdb.g5_cdb.res |= 8;
+/*		scmd->cdb.cmd_cdb[1] |= 0x10;*/
+
+	usalp->cmdname = "blank unit";
+
+	return (usal_cmd(usalp));
+}
+
+int
+scsi_format(SCSI *usalp, caddr_t addr, int size, BOOL background)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	int progress=0, ret=-1, pid=-1;
+	unsigned char sense_table[18];
+	int i;
+	
+	printf("scsi_format: preparing\n");
+
+	fillbytes((caddr_t)scmd, sizeof(*scmd), '\0');
+	scmd->addr = addr;
+	scmd->size = size;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 160 * 60;     /* Do not know what to set */
+	scmd->cdb.g5_cdb.cmd = 0x04;   /* Format Unit */
+	scmd->cdb.cmd_cdb[1] = 0x11;  /* "FmtData" and "Format Code" */
+	scmd->cdb.cmd_cdb[5] = 0;
+
+	usalp->cmdname = "format unit";
+
+	printf("scsi_format: running\n");
+	ret = (usal_cmd(usalp));
+	printf("scsi_format: post processing %d\n", ret);
+	if (ret == -1) return ret;
+	if (background) {
+		if ((pid=fork()) == (pid_t)-1)
+			perror ("- [unable to fork()]");
+		else {
+			if (!pid) {
+			    while (1) {
+				if (test_unit_ready(usalp) >= 0)
+				    break;
+				sleep(1);
+			    }
+			    return ret;
+			}
+		}
+	}
+	printf("Formating in progress: 0.00 %% done.");
+	sleep(20);
+	i = 0;
+	while (progress < 0xfff0 && !(progress == 0 && i > 50)) {
+		test_unit_ready(usalp);
+		request_sense_b(usalp, (caddr_t)sense_table, 18);
+		progress = sense_table[16]<<8|sense_table[17];
+		printf("\rFormating in progress: %.2f %% done [%d].                           ", (float)(progress*100)/0x10000,progress);
+		usleep(100000);
+		i++;
+		/*for (i=0; i < 18; i++) {
+		    printf("%d ", sense_table[i]);
+		}*/
+	}
+	sleep(10);
+	printf("\rFormating in progress: 100.00 %% done.        \n");
+	if (pid) exit (0);
+	return ret;
+}
+
+/*
+ * XXX First try to handle ATAPI:
+ * XXX ATAPI cannot handle SCSI 6 byte commands.
+ * XXX We try to simulate 6 byte mode sense/select.
+ */
+static BOOL	is_atapi;
+
+BOOL
+allow_atapi(SCSI *usalp, BOOL new)
+{
+	BOOL	old = is_atapi;
+	Uchar	mode[256];
+
+	if (new == old)
+		return (old);
+
+	usalp->silent++;
+	/*
+	 * If a bad drive has been reset before, we may need to fire up two
+	 * test unit ready commands to clear status.
+	 */
+	(void) unit_ready(usalp);
+	if (new &&
+	    mode_sense_g1(usalp, mode, 8, 0x3F, 0) < 0) {	/* All pages current */
+		new = FALSE;
+	}
+	usalp->silent--;
+
+	is_atapi = new;
+	return (old);
+}
+
+int
+mode_select(SCSI *usalp, Uchar *dp, int cnt, int smp, int pf)
+{
+	if (is_atapi)
+		return (mode_select_sg0(usalp, dp, cnt, smp, pf));
+	return (mode_select_g0(usalp, dp, cnt, smp, pf));
+}
+
+int
+mode_sense(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf)
+{
+	if (is_atapi)
+		return (mode_sense_sg0(usalp, dp, cnt, page, pcf));
+	return (mode_sense_g0(usalp, dp, cnt, page, pcf));
+}
+
+/*
+ * Simulate mode select g0 with mode select g1.
+ */
+int
+mode_select_sg0(SCSI *usalp, Uchar *dp, int cnt, int smp, int pf)
+{
+	Uchar	xmode[256+4];
+	int	amt = cnt;
+
+	if (amt < 1 || amt > 255) {
+		/* XXX clear SCSI error codes ??? */
+		return (-1);
+	}
+
+	if (amt < 4) {		/* Data length. medium type & VU */
+		amt += 1;
+	} else {
+		amt += 4;
+		movebytes(&dp[4], &xmode[8], cnt-4);
+	}
+	xmode[0] = 0;
+	xmode[1] = 0;
+	xmode[2] = dp[1];
+	xmode[3] = dp[2];
+	xmode[4] = 0;
+	xmode[5] = 0;
+	i_to_2_byte(&xmode[6], (unsigned int)dp[3]);
+
+	if (usalp->verbose) usal_prbytes("Mode Parameters (un-converted)", dp, cnt);
+
+	return (mode_select_g1(usalp, xmode, amt, smp, pf));
+}
+
+/*
+ * Simulate mode sense g0 with mode sense g1.
+ */
+int
+mode_sense_sg0(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf)
+{
+	Uchar	xmode[256+4];
+	int	amt = cnt;
+	int	len;
+
+	if (amt < 1 || amt > 255) {
+		/* XXX clear SCSI error codes ??? */
+		return (-1);
+	}
+
+	fillbytes((caddr_t)xmode, sizeof (xmode), '\0');
+	if (amt < 4) {		/* Data length. medium type & VU */
+		amt += 1;
+	} else {
+		amt += 4;
+	}
+	if (mode_sense_g1(usalp, xmode, amt, page, pcf) < 0)
+		return (-1);
+
+	amt = cnt - usal_getresid(usalp);
+/*
+ * For tests: Solaris 8 & LG CD-ROM always returns resid == amt
+ */
+/*	amt = cnt;*/
+	if (amt > 4)
+		movebytes(&xmode[8], &dp[4], amt-4);
+	len = a_to_u_2_byte(xmode);
+	if (len == 0) {
+		dp[0] = 0;
+	} else if (len < 6) {
+		if (len > 2)
+			len = 2;
+		dp[0] = len;
+	} else {
+		dp[0] = len - 3;
+	}
+	dp[1] = xmode[2];
+	dp[2] = xmode[3];
+	len = a_to_u_2_byte(&xmode[6]);
+	dp[3] = len;
+
+	if (usalp->verbose) usal_prbytes("Mode Sense Data (converted)", dp, amt);
+	return (0);
+}
+
+int
+mode_select_g0(SCSI *usalp, Uchar *dp, int cnt, int smp, int pf)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)dp;
+	scmd->size = cnt;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_MODE_SELECT;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.high_addr = smp ? 1 : 0 | pf ? 0x10 : 0;
+	scmd->cdb.g0_cdb.count = cnt;
+
+	if (usalp->verbose) {
+		fprintf(stderr, "%s ", smp?"Save":"Set ");
+		usal_prbytes("Mode Parameters", dp, cnt);
+	}
+
+	usalp->cmdname = "mode select g0";
+
+	return (usal_cmd(usalp));
+}
+
+int
+mode_select_g1(SCSI *usalp, Uchar *dp, int cnt, int smp, int pf)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)dp;
+	scmd->size = cnt;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x55;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g0_cdb.high_addr = smp ? 1 : 0 | pf ? 0x10 : 0;
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	if (usalp->verbose) {
+		printf("%s ", smp?"Save":"Set ");
+		usal_prbytes("Mode Parameters", dp, cnt);
+	}
+
+	usalp->cmdname = "mode select g1";
+
+	return (usal_cmd(usalp));
+}
+
+int
+mode_sense_g0(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)dp;
+	scmd->size = 0xFF;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_MODE_SENSE;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+#ifdef	nonono
+	scmd->cdb.g0_cdb.high_addr = 1<<4;	/* DBD Disable Block desc. */
+#endif
+	scmd->cdb.g0_cdb.mid_addr = (page&0x3F) | ((pcf<<6)&0xC0);
+	scmd->cdb.g0_cdb.count = page ? 0xFF : 24;
+	scmd->cdb.g0_cdb.count = cnt;
+
+	usalp->cmdname = "mode sense g0";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	if (usalp->verbose) usal_prbytes("Mode Sense Data", dp, cnt - usal_getresid(usalp));
+	return (0);
+}
+
+int
+mode_sense_g1(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)dp;
+	scmd->size = cnt;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x5A;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+#ifdef	nonono
+	scmd->cdb.g0_cdb.high_addr = 1<<4;	/* DBD Disable Block desc. */
+#endif
+	scmd->cdb.g1_cdb.addr[0] = (page&0x3F) | ((pcf<<6)&0xC0);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "mode sense g1";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	if (usalp->verbose) usal_prbytes("Mode Sense Data", dp, cnt - usal_getresid(usalp));
+	return (0);
+}
+
+struct trackdesc {
+	Uchar	res0;
+
+#if defined(_BIT_FIELDS_LTOH)		/* Intel byteorder */
+	Ucbit	control		: 4;
+	Ucbit	adr		: 4;
+#else					/* Motorola byteorder */
+	Ucbit	adr		: 4;
+	Ucbit	control		: 4;
+#endif
+
+	Uchar	track;
+	Uchar	res3;
+	Uchar	addr[4];
+};
+
+struct diskinfo {
+	struct tocheader	hd;
+	struct trackdesc	desc[1];
+};
+
+struct siheader {
+	Uchar	len[2];
+	Uchar	finished;
+	Uchar	unfinished;
+};
+
+struct sidesc {
+	Uchar	sess_number;
+	Uchar	res1;
+	Uchar	track;
+	Uchar	res3;
+	Uchar	addr[4];
+};
+
+struct sinfo {
+	struct siheader	hd;
+	struct sidesc	desc[1];
+};
+
+struct trackheader {
+	Uchar	mode;
+	Uchar	res[3];
+	Uchar	addr[4];
+};
+#define	TRM_ZERO	0
+#define	TRM_USER_ECC	1	/* 2048 bytes user data + 288 Bytes ECC/EDC */
+#define	TRM_USER	2	/* All user data (2336 bytes) */
+
+
+int
+read_tochdr(SCSI *usalp, cdr_t *dp, int *fp, int *lp)
+{
+	struct	tocheader *tp;
+	char	xb[256];
+	int	len;
+
+	tp = (struct tocheader *)xb;
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+	if (read_toc(usalp, xb, 0, sizeof (struct tocheader), 0, FMT_TOC) < 0) {
+		if (usalp->silent == 0)
+			errmsgno(EX_BAD, "Cannot read TOC header\n");
+		return (-1);
+	}
+	len = a_to_u_2_byte(tp->len) + sizeof (struct tocheader)-2;
+	if (len >= 4) {
+		if (fp)
+			*fp = tp->first;
+		if (lp)
+			*lp = tp->last;
+		return (0);
+	}
+	return (-1);
+}
+
+int
+read_cdtext(SCSI *usalp)
+{
+	struct	tocheader *tp;
+	char	xb[256];
+	int	len;
+	char	xxb[10000];
+
+	tp = (struct tocheader *)xb;
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+	if (read_toc(usalp, xb, 0, sizeof (struct tocheader), 0, FMT_CDTEXT) < 0) {
+		if (usalp->silent == 0 || usalp->verbose > 0)
+			errmsgno(EX_BAD, "Cannot read CD-Text header\n");
+		return (-1);
+	}
+	len = a_to_u_2_byte(tp->len) + sizeof (struct tocheader)-2;
+	printf("CD-Text len: %d\n", len);
+
+	if (read_toc(usalp, xxb, 0, len, 0, FMT_CDTEXT) < 0) {
+		if (usalp->silent == 0)
+			errmsgno(EX_BAD, "Cannot read CD-Text\n");
+		return (-1);
+	}
+	{
+		FILE	*f = fileopen("cdtext.dat", "wctb");
+		filewrite(f, xxb, len);
+	}
+	return (0);
+}
+
+int
+read_trackinfo(SCSI *usalp, int track, long *offp, struct msf *msfp, int *adrp, 
+					int *controlp, int *modep)
+{
+	struct	diskinfo *dp;
+	char	xb[256];
+	int	len;
+
+	dp = (struct diskinfo *)xb;
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+	if (read_toc(usalp, xb, track, sizeof (struct diskinfo), 0, FMT_TOC) < 0) {
+		if (usalp->silent <= 0)
+			errmsgno(EX_BAD, "Cannot read TOC\n");
+		return (-1);
+	}
+	len = a_to_u_2_byte(dp->hd.len) + sizeof (struct tocheader)-2;
+	if (len <  (int)sizeof (struct diskinfo))
+		return (-1);
+
+	if (offp)
+		*offp = a_to_4_byte(dp->desc[0].addr);
+	if (adrp)
+		*adrp = dp->desc[0].adr;
+	if (controlp)
+		*controlp = dp->desc[0].control;
+
+	if (msfp) {
+		usalp->silent++;
+		if (read_toc(usalp, xb, track, sizeof (struct diskinfo), 1, FMT_TOC)
+									>= 0) {
+			msfp->msf_min = dp->desc[0].addr[1];
+			msfp->msf_sec = dp->desc[0].addr[2];
+			msfp->msf_frame = dp->desc[0].addr[3];
+		} else if (read_toc(usalp, xb, track, sizeof (struct diskinfo), 0, FMT_TOC)
+									>= 0) {
+			/*
+			 * Some drives (e.g. the Philips CDD-522) don't support
+			 * to read the TOC in MSF mode.
+			 */
+			long off = a_to_4_byte(dp->desc[0].addr);
+
+			lba_to_msf(off, msfp);
+		} else {
+			msfp->msf_min = 0;
+			msfp->msf_sec = 0;
+			msfp->msf_frame = 0;
+		}
+		usalp->silent--;
+	}
+
+	if (modep == NULL)
+		return (0);
+
+	if (track == 0xAA) {
+		*modep = -1;
+		return (0);
+	}
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+
+	usalp->silent++;
+	if (read_header(usalp, xb, *offp, 8, 0) >= 0) {
+		*modep = xb[0];
+	} else if (read_track_info_philips(usalp, xb, track, 14) >= 0) {
+		*modep = xb[0xb] & 0xF;
+	} else {
+		*modep = -1;
+	}
+	usalp->silent--;
+	return (0);
+}
+
+int
+read_B0(SCSI *usalp, BOOL isbcd, long *b0p, long *lop)
+{
+	struct	fdiskinfo *dp;
+	struct	ftrackdesc *tp;
+	char	xb[8192];
+	char	*pe;
+	int	len;
+	long	l;
+
+	dp = (struct fdiskinfo *)xb;
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+	if (read_toc_philips(usalp, xb, 1, sizeof (struct tocheader), 0, FMT_FULLTOC) < 0) {
+		return (-1);
+	}
+	len = a_to_u_2_byte(dp->hd.len) + sizeof (struct tocheader)-2;
+	if (len <  (int)sizeof (struct fdiskinfo))
+		return (-1);
+	if (read_toc_philips(usalp, xb, 1, len, 0, FMT_FULLTOC) < 0) {
+		return (-1);
+	}
+	if (usalp->verbose) {
+		usal_prbytes("TOC data: ", (Uchar *)xb,
+			len > (int)sizeof (xb) - usal_getresid(usalp) ?
+				sizeof (xb) - usal_getresid(usalp) : len);
+
+		tp = &dp->desc[0];
+		pe = &xb[len];
+
+		while ((char *)tp < pe) {
+			usal_prbytes("ENT: ", (Uchar *)tp, 11);
+			tp++;
+		}
+	}
+	tp = &dp->desc[0];
+	pe = &xb[len];
+
+	for (; (char *)tp < pe; tp++) {
+		if (tp->sess_number != dp->hd.last)
+			continue;
+		if (tp->point != 0xB0)
+			continue;
+		if (usalp->verbose)
+			usal_prbytes("B0: ", (Uchar *)tp, 11);
+		if (isbcd) {
+			l = msf_to_lba(from_bcd(tp->amin),
+				from_bcd(tp->asec),
+				from_bcd(tp->aframe), TRUE);
+		} else {
+			l = msf_to_lba(tp->amin,
+				tp->asec,
+				tp->aframe, TRUE);
+		}
+		if (b0p)
+			*b0p = l;
+
+		if (usalp->verbose)
+			printf("B0 start: %ld\n", l);
+
+		if (isbcd) {
+			l = msf_to_lba(from_bcd(tp->pmin),
+				from_bcd(tp->psec),
+				from_bcd(tp->pframe), TRUE);
+		} else {
+			l = msf_to_lba(tp->pmin,
+				tp->psec,
+				tp->pframe, TRUE);
+		}
+
+		if (usalp->verbose)
+			printf("B0 lout: %ld\n", l);
+		if (lop)
+			*lop = l;
+		return (0);
+	}
+	return (-1);
+}
+
+
+/*
+ * Return address of first track in last session (SCSI-3/mmc version).
+ */
+int
+read_session_offset(SCSI *usalp, long *offp)
+{
+	struct	diskinfo *dp;
+	char	xb[256];
+	int	len;
+
+	dp = (struct diskinfo *)xb;
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+	if (read_toc(usalp, (caddr_t)xb, 0, sizeof (struct tocheader), 0, FMT_SINFO) < 0)
+		return (-1);
+
+	if (usalp->verbose)
+		usal_prbytes("tocheader: ",
+		(Uchar *)xb, sizeof (struct tocheader) - usal_getresid(usalp));
+
+	len = a_to_u_2_byte(dp->hd.len) + sizeof (struct tocheader)-2;
+	if (len > (int)sizeof (xb)) {
+		errmsgno(EX_BAD, "Session info too big.\n");
+		return (-1);
+	}
+	if (read_toc(usalp, (caddr_t)xb, 0, len, 0, FMT_SINFO) < 0)
+		return (-1);
+
+	if (usalp->verbose)
+		usal_prbytes("tocheader: ",
+			(Uchar *)xb, len - usal_getresid(usalp));
+
+	dp = (struct diskinfo *)xb;
+	if (offp)
+		*offp = a_to_u_4_byte(dp->desc[0].addr);
+	return (0);
+}
+
+/*
+ * Return address of first track in last session (pre SCSI-3 version).
+ */
+int
+read_session_offset_philips(SCSI *usalp, long *offp)
+{
+	struct	sinfo *sp;
+	char	xb[256];
+	int	len;
+
+	sp = (struct sinfo *)xb;
+
+	fillbytes((caddr_t)xb, sizeof (xb), '\0');
+	if (read_toc_philips(usalp, (caddr_t)xb, 0, sizeof (struct siheader), 0, FMT_SINFO) < 0)
+		return (-1);
+	len = a_to_u_2_byte(sp->hd.len) + sizeof (struct siheader)-2;
+	if (len > (int)sizeof (xb)) {
+		errmsgno(EX_BAD, "Session info too big.\n");
+		return (-1);
+	}
+	if (read_toc_philips(usalp, (caddr_t)xb, 0, len, 0, FMT_SINFO) < 0)
+		return (-1);
+	/*
+	 * Old drives return the number of finished sessions in first/finished
+	 * a descriptor is returned for each session.
+	 * New drives return the number of the first and last session
+	 * one descriptor for the last finished session is returned
+	 * as in SCSI-3
+	 * In all cases the lowest session number is set to 1.
+	 */
+	sp = (struct sinfo *)xb;
+	if (offp)
+		*offp = a_to_u_4_byte(sp->desc[sp->hd.finished-1].addr);
+	return (0);
+}
+
+int
+sense_secsize(SCSI *usalp, int current)
+{
+	Uchar	mode[0x100];
+	Uchar	*p;
+	Uchar	*ep;
+	int	len;
+	int	secsize = -1;
+
+	usalp->silent++;
+	(void) unit_ready(usalp);
+	usalp->silent--;
+
+	/* XXX Quick and dirty, musz verallgemeinert werden !!! */
+
+	fillbytes(mode, sizeof (mode), '\0');
+	usalp->silent++;
+
+	len =	sizeof (struct scsi_mode_header) +
+		sizeof (struct scsi_mode_blockdesc);
+	/*
+	 * Wenn wir hier get_mode_params() nehmen bekommen wir die Warnung:
+	 * Warning: controller returns wrong page 1 for All pages page (3F).
+	 */
+	if (mode_sense(usalp, mode, len, 0x3F, current?0:2) < 0) {
+		fillbytes(mode, sizeof (mode), '\0');
+		if (mode_sense(usalp, mode, len, 0, current?0:2) < 0)	{ /* VU (block desc) */
+			usalp->silent--;
+			return (-1);
+		}
+	}
+	if (mode[3] == 8) {
+		if (usalp->debug) {
+			printf("Density: 0x%X\n", mode[4]);
+			printf("Blocks:  %ld\n", a_to_u_3_byte(&mode[5]));
+			printf("Blocklen:%ld\n", a_to_u_3_byte(&mode[9]));
+		}
+		secsize = a_to_u_3_byte(&mode[9]);
+	}
+	fillbytes(mode, sizeof (mode), '\0');
+	/*
+	 * The ACARD TECH AEC-7720 ATAPI<->SCSI adaptor
+	 * chokes if we try to transfer more than 0x40 bytes with
+	 * mode_sense of all pages. So try to avoid to run this
+	 * command if possible.
+	 */
+	if (usalp->debug &&
+	    mode_sense(usalp, mode, 0xFE, 0x3F, current?0:2) >= 0) {	/* All Pages */
+
+		ep = mode+mode[0];	/* Points to last byte of data */
+		p = &mode[4];
+		p += mode[3];
+		printf("Pages: ");
+		while (p < ep) {
+			printf("0x%X ", *p&0x3F);
+			p += p[1]+2;
+		}
+		printf("\n");
+	}
+	usalp->silent--;
+
+	return (secsize);
+}
+
+int
+select_secsize(SCSI *usalp, int secsize)
+{
+	struct scsi_mode_data md;
+	int	count = sizeof (struct scsi_mode_header) +
+			sizeof (struct scsi_mode_blockdesc);
+
+	(void) test_unit_ready(usalp);	/* clear any error situation */
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+	md.header.blockdesc_len = 8;
+	i_to_3_byte(md.blockdesc.lblen, secsize);
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+BOOL
+is_cddrive(SCSI *usalp)
+{
+	return (usalp->inq->type == INQ_ROMD || usalp->inq->type == INQ_WORM);
+}
+
+BOOL
+is_unknown_dev(SCSI *usalp)
+{
+	return (usalp->dev == DEV_UNKNOWN);
+}
+
+#ifndef	DEBUG
+#define	DEBUG
+#endif
+#ifdef	DEBUG
+
+int
+read_scsi(SCSI *usalp, caddr_t bp, long addr, int cnt)
+{
+	if (addr <= G0_MAXADDR && cnt < 256 && !is_atapi)
+		return (read_g0(usalp, bp, addr, cnt));
+	else
+		return (read_g1(usalp, bp, addr, cnt));
+}
+
+int
+read_g0(SCSI *usalp, caddr_t bp, long addr, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	if (usalp->cap->c_bsize <= 0)
+		raisecond("capacity_not_set", 0L);
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt*usalp->cap->c_bsize;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G0_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g0_cdb.cmd = SC_READ;
+	scmd->cdb.g0_cdb.lun = usal_lun(usalp);
+	g0_cdbaddr(&scmd->cdb.g0_cdb, addr);
+	scmd->cdb.g0_cdb.count = cnt;
+/*	scmd->cdb.g0_cdb.vu_56 = 1;*/
+
+	usalp->cmdname = "read_g0";
+
+	return (usal_cmd(usalp));
+}
+
+int
+read_g1(SCSI *usalp, caddr_t bp, long addr, int cnt)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	if (usalp->cap->c_bsize <= 0)
+		raisecond("capacity_not_set", 0L);
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = bp;
+	scmd->size = cnt*usalp->cap->c_bsize;
+	scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = SC_EREAD;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "read_g1";
+
+	return (usal_cmd(usalp));
+}
+#endif	/* DEBUG */
+
+BOOL
+getdev(SCSI *usalp, BOOL print)
+{
+		BOOL	got_inquiry = TRUE;
+		char	vendor_info[8+1];
+		char	prod_ident[16+1];
+		char	prod_revision[4+1];
+		int	inq_len = 0;
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	register struct scsi_inquiry *inq = usalp->inq;
+
+
+	fillbytes((caddr_t)inq, sizeof (*inq), '\0');
+	usalp->dev = DEV_UNKNOWN;
+	usalp->silent++;
+	(void) unit_ready(usalp);
+	if (scmd->error >= SCG_FATAL &&
+				!(scmd->scb.chk && scmd->sense_count > 0)) {
+		usalp->silent--;
+		return (FALSE);
+	}
+
+
+/*	if (scmd->error < SCG_FATAL || scmd->scb.chk && scmd->sense_count > 0){*/
+
+	if (inquiry(usalp, (caddr_t)inq, sizeof (*inq)) < 0) {
+		got_inquiry = FALSE;
+	} else {
+		inq_len = sizeof (*inq) - usal_getresid(usalp);
+	}
+	if (!got_inquiry) {
+		if (usalp->verbose) {
+			printf(
+		"error: %d scb.chk: %d sense_count: %d sense.code: 0x%x\n",
+				scmd->error, scmd->scb.chk,
+				scmd->sense_count, scmd->sense.code);
+		}
+			/*
+			 * Folgende Kontroller kennen das Kommando
+			 * INQUIRY nicht:
+			 *
+			 * ADAPTEC	ACB-4000, ACB-4010, ACB 4070
+			 * SYSGEN	SC4000
+			 *
+			 * Leider reagieren ACB40X0 und ACB5500 identisch
+			 * wenn drive not ready (code == not ready),
+			 * sie sind dann nicht zu unterscheiden.
+			 */
+
+		if (scmd->scb.chk && scmd->sense_count == 4) {
+			/* Test auf SYSGEN				 */
+			(void) qic02(usalp, 0x12);	/* soft lock on  */
+			if (qic02(usalp, 1) < 0) {	/* soft lock off */
+				usalp->dev = DEV_ACB40X0;
+/*				usalp->dev = acbdev();*/
+			} else {
+				usalp->dev = DEV_SC4000;
+				inq->type = INQ_SEQD;
+				inq->removable = 1;
+			}
+		}
+	} else if (usalp->verbose) {
+		int	i;
+		int	len = inq->add_len + 5;
+		Uchar	ibuf[256+5];
+		Uchar	*ip = (Uchar *)inq;
+		Uchar	c;
+
+		if (len > (int)sizeof (*inq) &&
+				inquiry(usalp, (caddr_t)ibuf, inq->add_len+5) >= 0) {
+			len = inq->add_len+5 - usal_getresid(usalp);
+			ip = ibuf;
+		} else {
+			len = sizeof (*inq);
+		}
+		printf("Inquiry Data   : ");
+		for (i = 0; i < len; i++) {
+			c = ip[i];
+			if (c >= ' ' && c < 0177)
+				printf("%c", c);
+			else
+				printf(".");
+		}
+		printf("\n");
+	}
+
+	strncpy(vendor_info, inq->vendor_info, sizeof (inq->vendor_info));
+	strncpy(prod_ident, inq->prod_ident, sizeof (inq->prod_ident));
+	strncpy(prod_revision, inq->prod_revision, sizeof (inq->prod_revision));
+
+	vendor_info[sizeof (inq->vendor_info)] = '\0';
+	prod_ident[sizeof (inq->prod_ident)] = '\0';
+	prod_revision[sizeof (inq->prod_revision)] = '\0';
+
+	switch (inq->type) {
+
+	case INQ_DASD:
+		if (inq->add_len == 0 && inq->vendor_info[0] != '\0') {
+			Uchar	*p;
+			/*
+			 * NT-4.0 creates fake inquiry data for IDE disks.
+			 * Unfortunately, it does not set add_len wo we
+			 * check if vendor_info, prod_ident and prod_revision
+			 * contains valid chars for a CCS inquiry.
+			 */
+			if (inq_len >= 36)
+				inq->add_len = 31;
+
+			for (p = (Uchar *)&inq->vendor_info[0];
+					p < (Uchar *)&inq->prod_revision[4];
+									p++) {
+				if (*p < 0x20 || *p > 0x7E) {
+					inq->add_len = 0;
+					break;
+				}
+			}
+		}
+		if (inq->add_len == 0) {
+			if (usalp->dev == DEV_UNKNOWN && got_inquiry) {
+				usalp->dev = DEV_ACB5500;
+				strcpy(inq->vendor_info,
+					"ADAPTEC ACB-5500        FAKE");
+
+			} else switch (usalp->dev) {
+
+				case DEV_ACB40X0:
+					strcpy(inq->vendor_info,
+							"ADAPTEC ACB-40X0        FAKE");
+					break;
+				case DEV_ACB4000:
+					strcpy(inq->vendor_info,
+							"ADAPTEC ACB-4000        FAKE");
+					break;
+				case DEV_ACB4010:
+					strcpy(inq->vendor_info,
+							"ADAPTEC ACB-4010        FAKE");
+					break;
+				case DEV_ACB4070:
+					strcpy(inq->vendor_info,
+							"ADAPTEC ACB-4070        FAKE");
+					break;
+			}
+		} else if (inq->add_len < 31) {
+			usalp->dev = DEV_NON_CCS_DSK;
+
+		} else if (strbeg("EMULEX", vendor_info)) {
+			if (strbeg("MD21", prod_ident))
+				usalp->dev = DEV_MD21;
+			if (strbeg("MD23", prod_ident))
+				usalp->dev = DEV_MD23;
+			else
+				usalp->dev = DEV_CCS_GENDISK;
+		} else if (strbeg("ADAPTEC", vendor_info)) {
+			if (strbeg("ACB-4520", prod_ident))
+				usalp->dev = DEV_ACB4520A;
+			if (strbeg("ACB-4525", prod_ident))
+				usalp->dev = DEV_ACB4525;
+			else
+				usalp->dev = DEV_CCS_GENDISK;
+		} else if (strbeg("SONY", vendor_info) &&
+					strbeg("SMO-C501", prod_ident)) {
+			usalp->dev = DEV_SONY_SMO;
+		} else {
+			usalp->dev = DEV_CCS_GENDISK;
+		}
+		break;
+
+	case INQ_SEQD:
+		if (usalp->dev == DEV_SC4000) {
+			strcpy(inq->vendor_info,
+				"SYSGEN  SC4000          FAKE");
+		} else if (inq->add_len == 0 &&
+					inq->removable &&
+						inq->ansi_version == 1) {
+			usalp->dev = DEV_MT02;
+			strcpy(inq->vendor_info,
+				"EMULEX  MT02            FAKE");
+		}
+		break;
+
+/*	case INQ_OPTD:*/
+	case INQ_ROMD:
+	case INQ_WORM:
+		if (strbeg("RXT-800S", prod_ident))
+			usalp->dev = DEV_RXT800S;
+
+		/*
+		 * Start of CD-Recorders:
+		 */
+		if (strbeg("ACER", vendor_info)) {
+			if (strbeg("CR-4020C", prod_ident))
+				usalp->dev = DEV_RICOH_RO_1420C;
+
+		} else if (strbeg("CREATIVE", vendor_info)) {
+			if (strbeg("CDR2000", prod_ident))
+				usalp->dev = DEV_RICOH_RO_1060C;
+
+		} else if (strbeg("GRUNDIG", vendor_info)) {
+			if (strbeg("CDR100IPW", prod_ident))
+				usalp->dev = DEV_CDD_2000;
+
+		} else if (strbeg("JVC", vendor_info)) {
+			if (strbeg("XR-W2001", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			else if (strbeg("XR-W2010", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			else if (strbeg("R2626", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+
+		} else if (strbeg("MITSBISH", vendor_info)) {
+
+#ifdef	XXXX_REALLY
+			/* It's MMC compliant */
+			if (strbeg("CDRW226", prod_ident))
+				usalp->dev = DEV_MMC_CDRW;
+#else
+			/* EMPTY */
+#endif
+
+		} else if (strbeg("MITSUMI", vendor_info)) {
+			/* Don't know any product string */
+			usalp->dev = DEV_CDD_522;
+
+		} else if (strbeg("OPTIMA", vendor_info)) {
+			if (strbeg("CD-R 650", prod_ident))
+				usalp->dev = DEV_SONY_CDU_924;
+
+		} else if (strbeg("PHILIPS", vendor_info) ||
+				strbeg("IMS", vendor_info) ||
+				strbeg("KODAK", vendor_info) ||
+				strbeg("HP", vendor_info)) {
+
+			if (strbeg("CDD521/00", prod_ident))
+				usalp->dev = DEV_CDD_521_OLD;
+			else if (strbeg("CDD521/02", prod_ident))
+				usalp->dev = DEV_CDD_521_OLD;		/* PCD 200R? */
+			else if (strbeg("CDD521", prod_ident))
+				usalp->dev = DEV_CDD_521;
+
+			if (strbeg("CDD522", prod_ident))
+				usalp->dev = DEV_CDD_522;
+			if (strbeg("PCD225", prod_ident))
+				usalp->dev = DEV_CDD_522;
+			if (strbeg("KHSW/OB", prod_ident))	/* PCD600 */
+				usalp->dev = DEV_PCD_600;
+			if (strbeg("CDR-240", prod_ident))
+				usalp->dev = DEV_CDD_2000;
+
+			if (strbeg("CDD20", prod_ident))
+				usalp->dev = DEV_CDD_2000;
+			if (strbeg("CDD26", prod_ident))
+				usalp->dev = DEV_CDD_2600;
+
+			if (strbeg("C4324/C4325", prod_ident))
+				usalp->dev = DEV_CDD_2000;
+			if (strbeg("CD-Writer 6020", prod_ident))
+				usalp->dev = DEV_CDD_2600;
+
+		} else if (strbeg("PINNACLE", vendor_info)) {
+			if (strbeg("RCD-1000", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			if (strbeg("RCD5020", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			if (strbeg("RCD5040", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			if (strbeg("RCD 4X4", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+
+		} else if (strbeg("PIONEER", vendor_info)) {
+			if (strbeg("CD-WO DW-S114X", prod_ident))
+				usalp->dev = DEV_PIONEER_DW_S114X;
+			else if (strbeg("CD-WO DR-R504X", prod_ident))	/* Reoprt from philip@merge.com */
+				usalp->dev = DEV_PIONEER_DW_S114X;
+			else if (strbeg("DVD-R DVR-S101", prod_ident))
+				usalp->dev = DEV_PIONEER_DVDR_S101;
+
+		} else if (strbeg("PLASMON", vendor_info)) {
+			if (strbeg("RF4100", prod_ident))
+				usalp->dev = DEV_PLASMON_RF_4100;
+			else if (strbeg("CDR4220", prod_ident))
+				usalp->dev = DEV_CDD_2000;
+
+		} else if (strbeg("PLEXTOR", vendor_info)) {
+			if (strbeg("CD-R   PX-R24CS", prod_ident))
+				usalp->dev = DEV_RICOH_RO_1420C;
+
+		} else if (strbeg("RICOH", vendor_info)) {
+			if (strbeg("RO-1420C", prod_ident))
+				usalp->dev = DEV_RICOH_RO_1420C;
+			if (strbeg("RO1060C", prod_ident))
+				usalp->dev = DEV_RICOH_RO_1060C;
+
+		} else if (strbeg("SAF", vendor_info)) {	/* Smart & Friendly */
+			if (strbeg("CD-R2004", prod_ident) ||
+			    strbeg("CD-R2006 ", prod_ident))
+				usalp->dev = DEV_SONY_CDU_924;
+			else if (strbeg("CD-R2006PLUS", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			else if (strbeg("CD-RW226", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+			else if (strbeg("CD-R4012", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+
+		} else if (strbeg("SANYO", vendor_info)) {
+			if (strbeg("CD-WO CRD-R24S", prod_ident))
+				usalp->dev = DEV_CDD_521;
+
+		} else if (strbeg("SONY", vendor_info)) {
+			if (strbeg("CD-R   CDU92", prod_ident) ||
+			    strbeg("CD-R   CDU94", prod_ident))
+				usalp->dev = DEV_SONY_CDU_924;
+
+		} else if (strbeg("TEAC", vendor_info)) {
+			if (strbeg("CD-R50S", prod_ident) ||
+			    strbeg("CD-R55S", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+
+		} else if (strbeg("TRAXDATA", vendor_info) ||
+				strbeg("Traxdata", vendor_info)) {
+			if (strbeg("CDR4120", prod_ident))
+				usalp->dev = DEV_TEAC_CD_R50S;
+
+		} else if (strbeg("T.YUDEN", vendor_info)) {
+			if (strbeg("CD-WO EW-50", prod_ident))
+				usalp->dev = DEV_TYUDEN_EW50;
+
+		} else if (strbeg("WPI", vendor_info)) {	/* Wearnes */
+			if (strbeg("CDR-632P", prod_ident))
+				usalp->dev = DEV_CDD_2600;
+
+		} else if (strbeg("YAMAHA", vendor_info)) {
+			if (strbeg("CDR10", prod_ident))
+				usalp->dev = DEV_YAMAHA_CDR_100;
+			if (strbeg("CDR200", prod_ident))
+				usalp->dev = DEV_YAMAHA_CDR_400;
+			if (strbeg("CDR400", prod_ident))
+				usalp->dev = DEV_YAMAHA_CDR_400;
+
+		} else if (strbeg("MATSHITA", vendor_info)) {
+			if (strbeg("CD-R   CW-7501", prod_ident))
+				usalp->dev = DEV_MATSUSHITA_7501;
+			if (strbeg("CD-R   CW-7502", prod_ident))
+				usalp->dev = DEV_MATSUSHITA_7502;
+		}
+		if (usalp->dev == DEV_UNKNOWN) {
+			/*
+			 * We do not have Manufacturer strings for
+			 * the following drives.
+			 */
+			if (strbeg("CDS615E", prod_ident))	/* Olympus */
+				usalp->dev = DEV_SONY_CDU_924;
+		}
+		if (usalp->dev == DEV_UNKNOWN && inq->type == INQ_ROMD) {
+			BOOL	cdrr	 = FALSE;
+			BOOL	cdwr	 = FALSE;
+			BOOL	cdrrw	 = FALSE;
+			BOOL	cdwrw	 = FALSE;
+			BOOL	dvd	 = FALSE;
+			BOOL	dvdwr	 = FALSE;
+
+			usalp->dev = DEV_CDROM;
+
+			if (mmc_check(usalp, &cdrr, &cdwr, &cdrrw, &cdwrw,
+								&dvd, &dvdwr))
+				usalp->dev = DEV_MMC_CDROM;
+			if (cdwr)
+				usalp->dev = DEV_MMC_CDR;
+			if (cdwrw)
+				usalp->dev = DEV_MMC_CDRW;
+			if (dvd)
+				usalp->dev = DEV_MMC_DVD;
+			if (dvdwr)
+				usalp->dev = DEV_MMC_DVD_WR;
+		}
+		break;
+
+	case INQ_PROCD:
+		if (strbeg("BERTHOLD", vendor_info)) {
+			if (strbeg("", prod_ident))
+				usalp->dev = DEV_HRSCAN;
+		}
+		break;
+
+	case INQ_SCAN:
+		usalp->dev = DEV_MS300A;
+		break;
+	}
+	usalp->silent--;
+	if (!print)
+		return (TRUE);
+
+	if (usalp->dev == DEV_UNKNOWN && !got_inquiry) {
+#ifdef	PRINT_INQ_ERR
+		usal_printerr(usalp);
+#endif
+		return (FALSE);
+	}
+
+	printinq(usalp, stdout);
+	return (TRUE);
+}
+
+void
+printinq(SCSI *usalp, FILE *f)
+{
+	register struct scsi_inquiry *inq = usalp->inq;
+
+	fprintf(f, "Device type    : ");
+	usal_fprintdev(f, inq);
+	fprintf(f, "Version        : %d\n", inq->ansi_version);
+	fprintf(f, "Response Format: %d\n", inq->data_format);
+	if (inq->data_format >= 2) {
+		fprintf(f, "Capabilities   : ");
+		if (inq->aenc)		fprintf(f, "AENC ");
+		if (inq->termiop)	fprintf(f, "TERMIOP ");
+		if (inq->reladr)	fprintf(f, "RELADR ");
+		if (inq->wbus32)	fprintf(f, "WBUS32 ");
+		if (inq->wbus16)	fprintf(f, "WBUS16 ");
+		if (inq->sync)		fprintf(f, "SYNC ");
+		if (inq->linked)	fprintf(f, "LINKED ");
+		if (inq->cmdque)	fprintf(f, "CMDQUE ");
+		if (inq->softreset)	fprintf(f, "SOFTRESET ");
+		fprintf(f, "\n");
+	}
+	if (inq->add_len >= 31 ||
+			inq->vendor_info[0] ||
+			inq->prod_ident[0] ||
+			inq->prod_revision[0]) {
+		fprintf(f, "Vendor_info    : '%.8s'\n", inq->vendor_info);
+		fprintf(f, "Identification : '%.16s'\n", inq->prod_ident);
+		fprintf(f, "Revision       : '%.4s'\n", inq->prod_revision);
+	}
+}
+
+void
+printdev(SCSI *usalp)
+{
+	printf("Device seems to be: ");
+
+	switch (usalp->dev) {
+
+	case DEV_UNKNOWN:	printf("unknown");		break;
+	case DEV_ACB40X0:	printf("Adaptec 4000/4010/4070"); break;
+	case DEV_ACB4000:	printf("Adaptec 4000");		break;
+	case DEV_ACB4010:	printf("Adaptec 4010");		break;
+	case DEV_ACB4070:	printf("Adaptec 4070");		break;
+	case DEV_ACB5500:	printf("Adaptec 5500");		break;
+	case DEV_ACB4520A:	printf("Adaptec 4520A");	break;
+	case DEV_ACB4525:	printf("Adaptec 4525");		break;
+	case DEV_MD21:		printf("Emulex MD21");		break;
+	case DEV_MD23:		printf("Emulex MD23");		break;
+	case DEV_NON_CCS_DSK:	printf("Generic NON CCS Disk");	break;
+	case DEV_CCS_GENDISK:	printf("Generic CCS Disk");	break;
+	case DEV_SONY_SMO:	printf("Sony SMO-C501");	break;
+	case DEV_MT02:		printf("Emulex MT02");		break;
+	case DEV_SC4000:	printf("Sysgen SC4000");	break;
+	case DEV_RXT800S:	printf("Maxtor RXT800S");	break;
+	case DEV_HRSCAN:	printf("Berthold HR-Scanner");	break;
+	case DEV_MS300A:	printf("Microtek MS300A");	break;
+
+	case DEV_CDROM:		printf("Generic CD-ROM");	break;
+	case DEV_MMC_CDROM:	printf("Generic mmc CD-ROM");	break;
+	case DEV_MMC_CDR:	printf("Generic mmc CD-R");	break;
+	case DEV_MMC_CDRW:	printf("Generic mmc CD-RW");	break;
+	case DEV_MMC_DVD:	printf("Generic mmc2 DVD-ROM");	break;
+	case DEV_MMC_DVD_WR:	printf("Generic mmc2 DVD-R/DVD-RW"); break;
+	case DEV_CDD_521_OLD:	printf("Philips old CDD-521");	break;
+	case DEV_CDD_521:	printf("Philips CDD-521");	break;
+	case DEV_CDD_522:	printf("Philips CDD-522");	break;
+	case DEV_PCD_600:	printf("Kodak PCD-600");	break;
+	case DEV_CDD_2000:	printf("Philips CDD-2000");	break;
+	case DEV_CDD_2600:	printf("Philips CDD-2600");	break;
+	case DEV_YAMAHA_CDR_100:printf("Yamaha CDR-100");	break;
+	case DEV_YAMAHA_CDR_400:printf("Yamaha CDR-400");	break;
+	case DEV_PLASMON_RF_4100:printf("Plasmon RF-4100");	break;
+	case DEV_SONY_CDU_924:	printf("Sony CDU-924S");	break;
+	case DEV_RICOH_RO_1060C:printf("Ricoh RO-1060C");	break;
+	case DEV_RICOH_RO_1420C:printf("Ricoh RO-1420C");	break;
+	case DEV_TEAC_CD_R50S:	printf("Teac CD-R50S");		break;
+	case DEV_MATSUSHITA_7501:printf("Matsushita CW-7501");	break;
+	case DEV_MATSUSHITA_7502:printf("Matsushita CW-7502");	break;
+
+	case DEV_PIONEER_DW_S114X: printf("Pioneer DW-S114X");	break;
+	case DEV_PIONEER_DVDR_S101:printf("Pioneer DVD-R S101"); break;
+
+	default:		printf("Missing Entry for dev %d",
+						usalp->dev);	break;
+
+	}
+	printf(".\n");
+
+}
+
+BOOL
+do_inquiry(SCSI *usalp, int print)
+{
+	if (getdev(usalp, print)) {
+		if (print)
+			printdev(usalp);
+		return (TRUE);
+	} else {
+		return (FALSE);
+	}
+}
+
+BOOL
+recovery_needed(SCSI *usalp, cdr_t *dp)
+{
+		int err;
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	usalp->silent++;
+	err = test_unit_ready(usalp);
+	usalp->silent--;
+
+	if (err >= 0)
+		return (FALSE);
+	else if (scmd->error >= SCG_FATAL)	/* nicht selektierbar */
+		return (FALSE);
+
+	if (scmd->sense.code < 0x70)		/* non extended Sense */
+		return (FALSE);
+
+						/* XXX Old Philips code */
+	return (((struct scsi_ext_sense *)&scmd->sense)->sense_code == 0xD0);
+}
+
+int
+scsi_load(SCSI *usalp, cdr_t *dp)
+{
+	int	key;
+	int	code;
+
+	if ((dp->cdr_flags & CDR_CADDYLOAD) == 0) {
+		if (scsi_start_stop_unit(usalp, 1, 1, dp && (dp->cdr_cmdflags&F_IMMED)) >= 0)
+			return (0);
+	}
+
+	if (wait_unit_ready(usalp, 60))
+		return (0);
+
+	key = usal_sense_key(usalp);
+	code = usal_sense_code(usalp);
+
+	if (key == SC_NOT_READY && (code == 0x3A || code == 0x30)) {
+		errmsgno(EX_BAD, "Cannot load media with %s drive!\n",
+			(dp->cdr_flags & CDR_CADDYLOAD) ? "caddy" : "this");
+		errmsgno(EX_BAD, "Try to load media by hand.\n");
+	}
+	return (-1);
+}
+
+int
+scsi_unload(SCSI *usalp, cdr_t *dp)
+{
+	return (scsi_start_stop_unit(usalp, 0, 1, dp && (dp->cdr_cmdflags&F_IMMED)));
+}
+
+int 
+scsi_cdr_write(SCSI *usalp, 
+               caddr_t bp       /* address of buffer */, 
+               long sectaddr    /* disk address (sector) to put */, 
+               long size        /* number of bytes to transfer */, 
+               int blocks       /* sector count */, 
+               BOOL islast      /* last write for track */)
+{
+	return (write_xg1(usalp, bp, sectaddr, size, blocks));
+}
+
+struct cd_mode_page_2A *
+mmc_cap(SCSI *usalp, Uchar *modep)
+{
+	int	len;
+	int	val;
+	Uchar	mode[0x100];
+	struct	cd_mode_page_2A *mp;
+	struct	cd_mode_page_2A *mp2;
+
+
+retry:
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	if (!get_mode_params(usalp, 0x2A, "CD capabilities",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+
+		if (usal_sense_key(usalp) == SC_NOT_READY) {
+			if (wait_unit_ready(usalp, 60))
+				goto retry;
+		}
+		return (NULL);		/* Pre SCSI-3/mmc drive		*/
+	}
+
+	if (len == 0)			/* Pre SCSI-3/mmc drive		*/
+		return (NULL);
+
+	mp = (struct cd_mode_page_2A *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	/*
+	 * Do some heuristics against pre SCSI-3/mmc VU page 2A
+	 * We should test for a minimum p_len of 0x14, but some
+	 * buggy CD-ROM readers ommit the write speed values.
+	 */
+	if (mp->p_len < 0x10)
+		return (NULL);
+
+	val = a_to_u_2_byte(mp->max_read_speed);
+	if (val != 0 && val < 176)
+		return (NULL);
+
+	val = a_to_u_2_byte(mp->cur_read_speed);
+	if (val != 0 && val < 176)
+		return (NULL);
+
+	len -= sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len;
+	if (modep)
+		mp2 = (struct cd_mode_page_2A *)modep;
+	else
+		mp2 = malloc(len);
+	if (mp2)
+		movebytes(mp, mp2, len);
+
+	return (mp2);
+}
+
+void
+mmc_getval(struct cd_mode_page_2A *mp, 
+           BOOL *cdrrp  /* CD ROM */, 
+           BOOL *cdwrp  /* CD-R writer */, 
+           BOOL *cdrrwp /* CD-RW reader */, 
+           BOOL *cdwrwp /* CD-RW writer */, 
+           BOOL *dvdp   /* DVD reader */, 
+           BOOL *dvdwp  /* DVD writer */)
+{
+	BOOL	isdvd;				/* Any DVD reader	*/
+	BOOL	isdvd_wr;			/* DVD writer (R / RAM)	*/
+	BOOL	iscd_wr;			/* CD  writer		*/
+
+	iscd_wr = (mp->cd_r_write != 0) ||	/* SCSI-3/mmc CD-R	*/
+		    (mp->cd_rw_write != 0);	/* SCSI-3/mmc CD-RW	*/
+
+	if (cdrrp)
+		*cdrrp = (mp->cd_r_read != 0);	/* SCSI-3/mmc CD	*/
+	if (cdwrp)
+		*cdwrp = (mp->cd_r_write != 0);	/* SCSI-3/mmc CD-R	*/
+
+	if (cdrrwp)
+		*cdrrwp = (mp->cd_rw_read != 0); /* SCSI-3/mmc CD	*/
+	if (cdwrwp)
+		*cdwrwp = (mp->cd_rw_write != 0); /* SCSI-3/mmc CD-RW	*/
+
+	isdvd =					/* SCSI-3/mmc2 DVD 	*/
+		(mp->dvd_ram_read + mp->dvd_r_read  +
+		    mp->dvd_rom_read) != 0;
+
+	isdvd_wr =				/* SCSI-3/mmc2 DVD writer*/
+		(mp->dvd_ram_write + mp->dvd_r_write) != 0;
+
+	if (dvdp)
+		*dvdp = isdvd;
+	if (dvdwp)
+		*dvdwp = isdvd_wr;
+}
+
+BOOL
+is_mmc(SCSI *usalp, BOOL *cdwp, BOOL *dvdwp)
+{
+	BOOL	cdwr	= FALSE;
+	BOOL	cdwrw	= FALSE;
+
+	if (cdwp)
+		*cdwp = FALSE;
+	if (dvdwp)
+		*dvdwp = FALSE;
+
+	if (!mmc_check(usalp, NULL, &cdwr, NULL, &cdwrw, NULL, dvdwp))
+		return (FALSE);
+
+	if (cdwp)
+		*cdwp = cdwr | cdwrw;
+
+	return (TRUE);
+}
+
+BOOL
+mmc_check(SCSI *usalp, 
+          BOOL *cdrrp   /* CD ROM */, 
+          BOOL *cdwrp   /* CD-R writer */, 
+          BOOL *cdrrwp  /* CD-RW reader */, 
+          BOOL *cdwrwp  /* CD-RW writer */, 
+          BOOL *dvdp    /* DVD reader */, 
+          BOOL *dvdwp   /* DVD writer */)
+{
+	Uchar	mode[0x100];
+	BOOL	was_atapi;
+	struct	cd_mode_page_2A *mp;
+
+	if (usalp->inq->type != INQ_ROMD)
+		return (FALSE);
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	was_atapi = allow_atapi(usalp, TRUE);
+	usalp->silent++;
+	mp = mmc_cap(usalp, mode);
+	usalp->silent--;
+	allow_atapi(usalp, was_atapi);
+	if (mp == NULL)
+		return (FALSE);
+
+	mmc_getval(mp, cdrrp, cdwrp, cdrrwp, cdwrwp, dvdp, dvdwp);
+
+	return (TRUE);			/* Generic SCSI-3/mmc CD	*/
+}
+
+static void
+print_speed(char *fmt, int val)
+{
+	printf("  %s: %5d kB/s", fmt, val);
+	printf(" (CD %3ux,", val/176);
+	printf(" DVD %2ux)\n", val/1385);
+}
+
+#define	DOES(what, flag)	printf("  Does %s%s\n", flag?"":"not ", what)
+#define	IS(what, flag)		printf("  Is %s%s\n", flag?"":"not ", what)
+#define	VAL(what, val)		printf("  %s: %d\n", what, val[0]*256 + val[1])
+#define	SVAL(what, val)		printf("  %s: %s\n", what, val)
+
+void
+print_capabilities(SCSI *usalp)
+{
+	BOOL	was_atapi;
+	Uchar	mode[0x100];
+	struct	cd_mode_page_2A *mp;
+static	const	char	*bclk[4] = {"32", "16", "24", "24 (I2S)"};
+static	const	char	*load[8] = {"caddy", "tray", "pop-up", "reserved(3)",
+				"disc changer", "cartridge changer",
+				"reserved(6)", "reserved(7)" };
+static	const	char	*rotctl[4] = {"CLV/PCAV", "CAV", "reserved(2)", "reserved(3)"};
+
+
+	if (usalp->inq->type != INQ_ROMD)
+		return;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	was_atapi = allow_atapi(usalp, TRUE);	/* Try to switch to 10 byte mode cmds */
+	usalp->silent++;
+	mp = mmc_cap(usalp, mode);
+	usalp->silent--;
+	allow_atapi(usalp, was_atapi);
+	if (mp == NULL)
+		return;
+
+	printf("\nDrive capabilities, per");
+	if (mp->p_len >= 28)
+		printf(" MMC-3");
+	else if (mp->p_len >= 24)
+		printf(" MMC-2");
+	else
+		printf(" MMC");
+	printf(" page 2A:\n\n");
+
+	DOES("read CD-R media", mp->cd_r_read);
+	DOES("write CD-R media", mp->cd_r_write);
+	DOES("read CD-RW media", mp->cd_rw_read);
+	DOES("write CD-RW media", mp->cd_rw_write);
+	DOES("read DVD-ROM media", mp->dvd_rom_read);
+	DOES("read DVD-R media", mp->dvd_r_read);
+	DOES("write DVD-R media", mp->dvd_r_write);
+	DOES("read DVD-RAM media", mp->dvd_ram_read);
+	DOES("write DVD-RAM media", mp->dvd_ram_write);
+	DOES("support test writing", mp->test_write);
+	printf("\n");
+	DOES("read Mode 2 Form 1 blocks", mp->mode_2_form_1);
+	DOES("read Mode 2 Form 2 blocks", mp->mode_2_form_2);
+	DOES("read digital audio blocks", mp->cd_da_supported);
+	if (mp->cd_da_supported)
+		DOES("restart non-streamed digital audio reads accurately", mp->cd_da_accurate);
+	DOES("support Buffer-Underrun-Free recording", mp->BUF);
+	DOES("read multi-session CDs", mp->multi_session);
+	DOES("read fixed-packet CD media using Method 2", mp->method2);
+	DOES("read CD bar code", mp->read_bar_code);
+	DOES("read R-W subcode information", mp->rw_supported);
+	if (mp->rw_supported)
+		DOES("return R-W subcode de-interleaved and error-corrected", mp->rw_deint_corr);
+	DOES("read raw P-W subcode data from lead in", mp->pw_in_lead_in);
+	DOES("return CD media catalog number", mp->UPC);
+	DOES("return CD ISRC information", mp->ISRC);
+	DOES("support C2 error pointers", mp->c2_pointers);
+	DOES("deliver composite A/V data", mp->composite);
+	printf("\n");
+	DOES("play audio CDs", mp->audio_play);
+	if (mp->audio_play) {
+		VAL("Number of volume control levels", mp->num_vol_levels);
+		DOES("support individual volume control setting for each channel", mp->sep_chan_vol);
+		DOES("support independent mute setting for each channel", mp->sep_chan_mute);
+		DOES("support digital output on port 1", mp->digital_port_1);
+		DOES("support digital output on port 2", mp->digital_port_2);
+		if (mp->digital_port_1 || mp->digital_port_2) {
+			DOES("send digital data LSB-first", mp->LSBF);
+			DOES("set LRCK high for left-channel data", mp->RCK);
+			DOES("have valid data on falling edge of clock", mp->BCK);
+			SVAL("Length of data in BCLKs", bclk[mp->length]);
+		}
+	}
+	printf("\n");
+	SVAL("Loading mechanism type", load[mp->loading_type]);
+	DOES("support ejection of CD via START/STOP command", mp->eject);
+	DOES("lock media on power up via prevent jumper", mp->prevent_jumper);
+	DOES("allow media to be locked in the drive via PREVENT/ALLOW command", mp->lock);
+	IS("currently in a media-locked state", mp->lock_state);
+	DOES("support changing side of disk", mp->side_change);
+	DOES("have load-empty-slot-in-changer feature", mp->sw_slot_sel);
+	DOES("support Individual Disk Present feature", mp->disk_present_rep);
+	printf("\n");
+	print_speed("Maximum read  speed", a_to_u_2_byte(mp->max_read_speed));
+	print_speed("Current read  speed", a_to_u_2_byte(mp->cur_read_speed));
+	print_speed("Maximum write speed", a_to_u_2_byte(mp->max_write_speed));
+	if (mp->p_len >= 28)
+		print_speed("Current write speed", a_to_u_2_byte(mp->v3_cur_write_speed));
+	else
+		print_speed("Current write speed", a_to_u_2_byte(mp->cur_write_speed));
+	if (mp->p_len >= 28) {
+		SVAL("Rotational control selected", rotctl[mp->rot_ctl_sel]);
+	}
+	VAL("Buffer size in KB", mp->buffer_size);
+
+	if (mp->p_len >= 24) {
+		VAL("Copy management revision supported", mp->copy_man_rev);
+	}
+
+	if (mp->p_len >= 28) {
+		struct cd_wr_speed_performance *pp;
+		Uint	ndesc;
+		Uint	i;
+		Uint	n;
+
+		ndesc = a_to_u_2_byte(mp->num_wr_speed_des);
+		pp = mp->wr_speed_des;
+		printf("  Number of supported write speeds: %d\n", ndesc);
+		for (i = 0; i < ndesc; i++, pp++) {
+			printf("  Write speed # %d:", i);
+			n = a_to_u_2_byte(pp->wr_speed_supp);
+			printf(" %5d kB/s", n);
+			printf(" %s", rotctl[pp->rot_ctl_sel]);
+			printf(" (CD %3ux,", n/176);
+			printf(" DVD %2ux)\n", n/1385);
+		}
+	}
+
+	/* Generic SCSI-3/mmc CD	*/
+}