Imported Upstream version 1.1.11upstream/1.1.11upstream

48 files changed, 30911 insertions, 0 deletions

diff --git a/wodim/CMakeLists.txt b/wodim/CMakeLists.txt
new file mode 100644
index 0000000..d6245c9
--- /dev/null
+++ b/wodim/CMakeLists.txt
@@ -0,0 +1,37 @@
+PROJECT (CDRECORD C)
+INCLUDE_DIRECTORIES(../include ../libedc ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/include)
+INCLUDE(../include/AddScgBits.cmake)
+include(../include/AddSchilyBits.cmake)
+
+#AUX_SOURCE_DIRECTORY(. CDRECORD_SRCS)
+SET(CDRECORD_SRCS wodim.c audiosize.c auinfo.c  cdr_drv.c cdtext.c clone.c crc16.c cue.c  diskid.c drv_7501.c drv_jvc.c drv_mmc.c drv_philips.c drv_simul.c drv_sony.c fifo.c  isosize.c scsi_cdr_mmc4.c scsi_mmc4.c sector.c subchan.c wm_packet.c wm_session.c wm_track.c xio.c)
+SET(CDRECORD_COMMON_SRCS cd_misc.c defaults.c getnum.c misc.c modes.c movesect.c scsi_cdr.c scsi_mmc.c scsi_scan.c)
+
+INCLUDE(CheckIncludeFiles)
+
+#force libcap usage on Linux
+CHECK_INCLUDE_FILES("sys/capability.h" HAVE_SYS_CAPABILITY_H)
+IF(HAVE_SYS_CAPABILITY_H)
+	LIST(APPEND EXTRA_LIBS cap)
+ELSE(HAVE_SYS_CAPABILITY_H)
+   IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
+      MESSAGE(FATAL_ERROR "Error: found a Linux system but no libcap header. Install libcap-dev.")
+   ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
+ENDIF(HAVE_SYS_CAPABILITY_H)
+
+LINK_DIRECTORIES(../librols ../libusal  ../libedc)
+
+ADD_DEFINITIONS(-DHAVE_LIB_EDC_ECC -DCLONE_WRITE -DDRV_DVD -DFIFO -DAUINFO -DUSE_LARGEFILES )
+
+
+ADD_EXECUTABLE (wodim ${CDRECORD_SRCS})
+ADD_LIBRARY (wodimstuff STATIC ${CDRECORD_COMMON_SRCS})
+LIST(APPEND EXTRA_LIBS wodimstuff)
+
+TARGET_LINK_LIBRARIES(wodim ${EXTRA_LIBS}  edc)
+SET_TARGET_PROPERTIES(wodim PROPERTIES SKIP_BUILD_RPATH TRUE)
+
+INSTALL(TARGETS wodim DESTINATION bin)
+INSTALL(FILES 
+   wodim.1
+DESTINATION ${MANSUBDIR}/man1)
diff --git a/wodim/audiosize.c b/wodim/audiosize.c
new file mode 100644
index 0000000..2cdad97
--- /dev/null
+++ b/wodim/audiosize.c
@@ -0,0 +1,289 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)audiosize.c	1.19 04/03/01 Copyright 1998-2004 J. Schilling */
+/*
+ *	Copyright (c) 1998-2004 J. Schilling
+ *
+ *	First .vaw implementation made by Dave Platt <dplatt@iq.nc.com>
+ *	Current .wav implementation with additional help from Heiko Eißfeld.
+ */
+/*
+ * 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.
+ */
+
+#include <mconfig.h>
+#include <statdefs.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <utypes.h>
+#include <strdefs.h>
+#include <intcvt.h>
+#include <schily.h>
+
+#include <usal/usalcmd.h>
+#include "auheader.h"
+
+typedef struct {
+	Uchar	magic[4];
+	Uchar	hdr_size[4];
+	Uchar	data_size[4];
+	Uchar	encoding[4];
+	Uchar	sample_rate[4];
+	Uchar	channels[4];
+} sun_au_t;
+
+#define	SUN_AU_MAGIC		".snd"
+#define	SUN_AU_UNKNOWN_LEN	((Uint)~0)
+#define	SUN_AU_ULAW8		1		/* American ISDN Telephonie */
+#define	SUN_AU_LINEAR8		2		/* Linear PCM 8 bit/channel  */
+#define	SUN_AU_LINEAR16		3		/* Linear PCM 16 bit/channel */
+#define	SUN_AU_LINEAR24		4		/* Linear PCM 24 bit/channel */
+#define	SUN_AU_LINEAR32		5		/* Linear PCM 32 bit/channel */
+#define	SUN_AU_FLOAT		6		/* 32 bit IEEE floatingpoint */
+#define	SUN_AU_DOUBLE		7		/* 64 bit IEEE floatingpoint */
+#define	SUN_AU_G721		23		/* 4 bit CCITT G.721 ADPCM  */
+#define	SUN_AU_G722		24		/* CCITT G.722 ADPCM	    */
+#define	SUN_AU_G723_3		25		/* 3 bit CCITT G.723 ADPCM  */
+#define	SUN_AU_G723_5		26		/* 5 bit CCITT G.723 ADPCM  */
+#define	SUN_AU_ALAW8		27		/* International ISDN Tel.  */
+
+typedef struct {
+	Uchar	ckid[4];
+	Uchar	cksize[4];
+} chunk_t;
+
+typedef struct {
+	Uchar	wave[4];
+} riff_chunk;
+
+typedef struct {
+	Uchar	fmt_tag[2];
+	Uchar	channels[2];
+	Uchar	sample_rate[4];
+	Uchar	av_byte_rate[4];
+	Uchar	block_size[2];
+	Uchar	bits_per_sample[2];
+} fmt_chunk;
+
+#define	WAV_RIFF_MAGIC		"RIFF"		/* Magic for file format    */
+#define	WAV_WAVE_MAGIC		"WAVE"		/* Magic for Waveform Audio */
+#define	WAV_FMT_MAGIC		"fmt "		/* Start of Waveform format */
+#define	WAV_DATA_MAGIC		"data"		/* Start of data chunk	    */
+#define	WAV_FORMAT_PCM		0x0001		/* Linear PCM format	    */
+#define	WAV_FORMAT_ULAW		0x0101		/* American ISDN Telephonie */
+#define	WAV_FORMAT_ALAW		0x0102		/* International ISDN Tel.  */
+#define	WAV_FORMAT_ADPCM	0x0103		/* ADPCM format		    */
+
+#define	le_a_to_u_short(a)	((unsigned short) \
+				((((unsigned char *)a)[0]	& 0xFF) | \
+				(((unsigned char *)a)[1] << 8	& 0xFF00)))
+
+#ifdef	__STDC__
+#define	le_a_to_u_long(a)	((unsigned long) \
+				((((unsigned char *)a)[0]	& 0xFF) | \
+				(((unsigned  char *)a)[1] << 8	& 0xFF00) | \
+				(((unsigned  char *)a)[2] << 16	& 0xFF0000) | \
+				(((unsigned  char *)a)[3] << 24	& 0xFF000000UL)))
+#else
+#define	le_a_to_u_long(a)	((unsigned long) \
+				((((unsigned char *)a)[0]	& 0xFF) | \
+				(((unsigned  char *)a)[1] << 8	& 0xFF00) | \
+				(((unsigned  char *)a)[2] << 16	& 0xFF0000) | \
+				(((unsigned  char *)a)[3] << 24	& 0xFF000000)))
+#endif
+
+BOOL	is_auname(const char *name);
+off_t	ausize(int f);
+BOOL	is_wavname(const char *name);
+off_t	wavsize(int f);
+
+BOOL 
+is_auname(const char *name)
+{
+	const	char	*p;
+
+	if ((p = strrchr(name, '.')) == NULL)
+		return (FALSE);
+	return (streql(p, ".au"));
+}
+
+/*
+ * Read Sun audio header, leave file seek pointer past auheader.
+ */
+off_t 
+ausize(int f)
+{
+	sun_au_t	hdr;
+	struct stat	sb;
+	mode_t		mode;
+	off_t		size;
+	Int32_t		val;
+	long		ret = AU_BAD_HEADER;
+
+	/*
+	 * First check if a bad guy tries to call ausize()
+	 * with an unappropriate file descriptor.
+	 * return -1 in this case.
+	 */
+	if (isatty(f))
+		return (-1L);
+	if (fstat(f, &sb) < 0)
+		return (-1L);
+	mode = sb.st_mode & S_IFMT;
+	if (!S_ISREG(mode) && !S_ISBLK(mode) && !S_ISCHR(mode))
+		return (-1L);
+
+	if (read(f, &hdr, sizeof (hdr)) != sizeof (hdr))
+		goto err;
+
+	if (strncmp((char *)hdr.magic, SUN_AU_MAGIC, 4) != 0)
+		goto err;
+
+	ret = AU_BAD_CODING;
+
+	val = a_to_u_4_byte(hdr.encoding);
+	if (val != SUN_AU_LINEAR16)
+		goto err;
+
+	val = a_to_u_4_byte(hdr.channels);
+	if (val != 2)
+		goto err;
+
+	val = a_to_u_4_byte(hdr.sample_rate);
+	if (val != 44100)
+		goto err;
+
+	size = (off_t)a_to_u_4_byte(hdr.hdr_size);
+	if (size < (off_t)sizeof (hdr) || size > 512)
+		goto err;
+	lseek(f, size, SEEK_SET);
+
+	/*
+	 * Most .au files don't seem to honor the data_size field,
+	 * so we use the whole file size without the header.
+	 */
+	size = sb.st_size - size;
+	return (size);
+
+err:
+	lseek(f, (off_t)0L, SEEK_SET);
+	return ((off_t)ret);
+}
+
+BOOL 
+is_wavname(const char *name)
+{
+	const	char	*p;
+
+	if ((p = strrchr(name, '.')) == NULL)
+		return (FALSE);
+	return (streql(p, ".wav") || streql(p, ".WAV"));
+}
+
+/*
+ * Read WAV header, leave file seek pointer past WAV header.
+ */
+off_t 
+wavsize(int f)
+{
+	chunk_t		chunk;
+	riff_chunk	riff;
+	fmt_chunk	fmt;
+	struct stat	sb;
+	off_t		cursor;
+	BOOL		gotFormat;
+	mode_t		mode;
+	off_t		size;
+	long		ret = AU_BAD_HEADER;
+
+	/*
+	 * First check if a bad guy tries to call wavsize()
+	 * with an unappropriate file descriptor.
+	 * return -1 in this case.
+	 */
+
+	if (isatty(f))
+		return (-1L);
+	if (fstat(f, &sb) < 0)
+		return (-1L);
+	mode = sb.st_mode & S_IFMT;
+	if (!S_ISREG(mode) && !S_ISBLK(mode) && !S_ISCHR(mode))
+		return (-1L);
+
+	cursor = (off_t)0;
+	gotFormat = FALSE;
+
+	for (;;) {
+		if (read(f, &chunk, sizeof (chunk)) != sizeof (chunk))
+			goto err;
+		size = (off_t)le_a_to_u_long(chunk.cksize);
+
+		if (strncmp((char *)chunk.ckid, WAV_RIFF_MAGIC, 4) == 0) {
+			/*
+			 * We found (first) RIFF header. Check if a WAVE
+			 * magic follows. Set up size to be able to skip
+			 * past this header.
+			 */
+			if (read(f, &riff, sizeof (riff)) != sizeof (riff))
+				goto err;
+			if (strncmp((char *)riff.wave, WAV_WAVE_MAGIC, 4) != 0)
+				goto err;
+			size = (off_t)sizeof (riff);
+
+		} else if (strncmp((char *)chunk.ckid, WAV_FMT_MAGIC, 4) == 0) {
+			/*
+			 * We found WAVE "fmt " header. Check size (if it is
+			 * valid for a WAVE file) and coding whether it is
+			 * useable for a CD.
+			 */
+			if (size < (off_t)sizeof (fmt)) goto err;
+			if (sizeof (fmt) != read(f, &fmt, sizeof (fmt))) goto err;
+			if (le_a_to_u_short(fmt.channels) != 2 ||
+			    le_a_to_u_long(fmt.sample_rate) != 44100 ||
+			    le_a_to_u_short(fmt.bits_per_sample) != 16) {
+				ret = AU_BAD_CODING;
+				goto err;
+			}
+			gotFormat = TRUE;
+
+		} else if (strncmp((char *)chunk.ckid, WAV_DATA_MAGIC, 4) == 0) {
+			/*
+			 * We found WAVE "data" header. This contains the
+			 * size value of the audio part.
+			 */
+			if (!gotFormat) {
+				ret = AU_BAD_CODING;
+				goto err;
+			}
+			if ((cursor + size + sizeof (chunk)) > sb.st_size)
+				size = sb.st_size - (cursor  + sizeof (chunk));
+			return (size);
+		}
+		cursor += size + sizeof (chunk);
+		lseek(f, cursor, SEEK_SET);	/* Skip over current chunk */
+	}
+err:
+	lseek(f, (off_t)0L, SEEK_SET);
+	return (ret);
+}
diff --git a/wodim/auheader.h b/wodim/auheader.h
new file mode 100644
index 0000000..3bfe932
--- /dev/null
+++ b/wodim/auheader.h
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)auheader.h	1.2 98/05/09 Copyright 1998 J. Schilling */
+/*
+ *	Copyright (c) 1998 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.
+ */
+
+#ifndef	_AUHEADER_H
+#define	_AUHEADER_H
+
+#define	AU_BAD		-1
+#define	AU_BAD_HEADER	-2
+#define	AU_BAD_CODING	-3
+
+
+#endif	/* _AUHEADER_H */
diff --git a/wodim/auinfo.c b/wodim/auinfo.c
new file mode 100644
index 0000000..8cf8aef
--- /dev/null
+++ b/wodim/auinfo.c
@@ -0,0 +1,525 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)auinfo.c	1.23 04/03/01 Copyright 1998-2004 J. Schilling */
+/*
+ *	Copyright (c) 1998-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.
+ */
+
+#include <mconfig.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <statdefs.h>
+#include <stdio.h>
+#include <standard.h>
+#include <strdefs.h>
+#include <deflts.h>
+#include <utypes.h>
+#include <schily.h>
+
+#include "cdtext.h"
+#include "wodim.h"
+
+extern	int	debug;
+extern	int	xdebug;
+
+BOOL			auinfosize(char *name, track_t *trackp);
+void			auinfo(char *name, int track, track_t *trackp);
+textptr_t 	*gettextptr(int track, track_t *trackp);
+static char *savestr(char *name);
+static char *readtag(char *name);
+static char *readtstr(char *name);
+void			setmcn(char *mcn, track_t *trackp);
+static void	isrc_illchar(char *isrc, int c);
+void			setisrc(char *isrc, track_t *trackp);
+void			setindex(char *tindex, track_t *trackp);
+
+#ifdef	XXX
+int 
+main(int argc, char *argv[])
+{
+/*	auinfo("/etc/default/cdrecord");*/
+/*	auinfo("/mnt2/CD3/audio_01.inf");*/
+	auinfo("/mnt2/CD3/audio_01.wav");
+}
+#endif
+
+BOOL 
+auinfosize(char *name, track_t *trackp)
+{
+	const	char	*p;
+	const	char	*tlp;
+	struct stat	sb;
+	long		secs;
+	long		nsamples;
+	Llong		tracksize;
+
+	if (!is_audio(trackp))
+		return (FALSE);
+
+	if ((trackp->flags & TI_USEINFO) == 0)
+		return (FALSE);
+
+	if ((p = strrchr(name, '.')) == NULL)
+		return (FALSE);
+	if (!streql(p, ".inf") && !streql(p, ".INF"))
+		return (FALSE);
+
+	/*
+	 * First check if a bad guy tries to call auinfosize()
+	 * while STDIN_FILENO is a TTY.
+	 */
+	if (isatty(STDIN_FILENO)) {
+		errmsgno(EX_BAD,
+			"WARNING: Stdin is connected to a terminal.\n");
+		return (FALSE);
+	}
+
+	if (stat(name, &sb) < 0)	/* *.inf file not found		*/
+		return (FALSE);
+
+	if (sb.st_size > 10000)		/* Too large for a *.inf file	*/
+		return (FALSE);
+
+	if (cfg_open(name) < 0)	/* Cannot open *.inf file	*/
+		return (FALSE);
+
+	tlp = p = readtag("Tracklength");
+	if (p == NULL) {		/* Tracklength= Tag not found	*/
+		errmsgno(EX_BAD,
+			"WARNING: %s does not contain a 'Tracklength=' tag.\n",
+			name);
+		cfg_close();
+		return (FALSE);
+	}
+
+	p = astol(p, &secs);
+	if (*p != '\0' && *p != ',') {
+		errmsgno(EX_BAD,
+			"WARNING: %s: 'Tracklength=' contains illegal parameter '%s'.\n",
+			name, tlp);
+		cfg_close();
+		return (FALSE);
+	}
+	if (*p == ',')
+		p++;
+	p = astol(p, &nsamples);
+	if (*p != '\0') {
+		errmsgno(EX_BAD,
+			"WARNING: %s: 'Tracklength=' contains illegal parameter '%s'.\n",
+			name, tlp);
+		cfg_close();
+		return (FALSE);
+	}
+	tracksize = (secs * 2352) + (nsamples * 4);
+	if (xdebug > 0) {
+		fprintf(stderr, "%s: Tracksize %lld bytes (%ld sectors, %ld samples)\n",
+			name, tracksize, secs, nsamples);
+	}
+	trackp->itracksize = tracksize;
+	cfg_close();
+	return (TRUE);
+}
+
+void 
+auinfo(char *name, int track, track_t *trackp)
+{
+	char	infname[1024];
+	char	*p;
+	track_t	*tp = &trackp[track];
+	textptr_t *txp;
+	long	l;
+	long	tno = -1;
+	BOOL	isdao = !is_tao(&trackp[0]);
+
+	strncpy(infname, name, sizeof (infname)-1);
+	infname[sizeof (infname)-1] = '\0';
+	p = strrchr(infname, '.');
+	if (p != 0 && &p[4] < &name[sizeof (infname)]) {
+		strcpy(&p[1], "inf");
+	}
+
+	if (cfg_open(infname) == 0) {
+
+		p = readtstr("CDINDEX_DISCID");
+		p = readtag("CDDB_DISKID");
+
+		p = readtag("MCN");
+		if (p && *p) {
+			setmcn(p, &trackp[0]);
+			txp = gettextptr(0, trackp); /* MCN is isrc for trk 0*/
+			txp->tc_isrc = savestr(p);
+		}
+
+		p = readtag("ISRC");
+		if (p && *p) {
+			setisrc(p, &trackp[track]);
+			txp = gettextptr(track, trackp);
+			txp->tc_isrc = savestr(p);
+		}
+
+		p = readtstr("Albumperformer");
+		if (p && *p) {
+			txp = gettextptr(0, trackp); /* Album perf. in trk 0*/
+			txp->tc_performer = savestr(p);
+		}
+		p = readtstr("Performer");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_performer = savestr(p);
+		}
+		p = readtstr("Albumtitle");
+		if (p && *p) {
+			txp = gettextptr(0, trackp); /* Album title in trk 0*/
+			txp->tc_title = savestr(p);
+		}
+		p = readtstr("Tracktitle");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_title = savestr(p);
+		}
+		p = readtstr("Songwriter");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_songwriter = savestr(p);
+		}
+		p = readtstr("Composer");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_composer = savestr(p);
+		}
+		p = readtstr("Arranger");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_arranger = savestr(p);
+		}
+		p = readtstr("Message");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_message = savestr(p);
+		}
+		p = readtstr("Diskid");
+		if (p && *p) {
+			txp = gettextptr(0, trackp); /* Disk id is in trk 0*/
+			txp->tc_title = savestr(p);
+		}
+		p = readtstr("Closed_info");
+		if (p && *p) {
+			txp = gettextptr(track, trackp);
+			txp->tc_closed_info = savestr(p);
+		}
+
+		p = readtag("Tracknumber");
+		if (p && isdao)
+			astol(p, &tno);
+
+		p = readtag("Trackstart");
+		if (p && isdao) {
+			l = -1L;
+			astol(p, &l);
+			if (track == 1 && tno == 1 && l > 0) {
+				trackp[1].pregapsize = 150 + l;
+				printf("Track1 Start: '%s' (%ld)\n", p, l);
+			}
+		}
+
+		p = readtag("Tracklength");
+
+		p = readtag("Pre-emphasis");
+		if (p && *p) {
+			if (strncmp(p, "yes", 3) == 0) {
+				tp->flags |= TI_PREEMP;
+				if ((tp->tracktype & TOC_MASK) == TOC_DA)
+					tp->sectype = SECT_AUDIO_PRE;
+
+			} else if (strncmp(p, "no", 2) == 0) {
+				tp->flags &= ~TI_PREEMP;
+				if ((tp->tracktype & TOC_MASK) == TOC_DA)
+					tp->sectype = SECT_AUDIO_NOPRE;
+			}
+		}
+
+		p = readtag("Channels");
+		p = readtag("Copy_permitted");
+		if (p && *p) {
+			/*
+			 * -useinfo always wins
+			 */
+			tp->flags &= ~(TI_COPY|TI_SCMS);
+
+			if (strncmp(p, "yes", 3) == 0)
+				tp->flags |= TI_COPY;
+			else if (strncmp(p, "no", 2) == 0)
+				tp->flags |= TI_SCMS;
+			else if (strncmp(p, "once", 2) == 0)
+				tp->flags &= ~(TI_COPY|TI_SCMS);
+		}
+		p = readtag("Endianess");
+		p = readtag("Index");
+		if (p && *p && isdao)
+			setindex(p, &trackp[track]);
+
+		p = readtag("Index0");
+		if (p && isdao) {
+			Llong ts;
+			Llong ps;
+
+			l = -2L;
+			astol(p, &l);
+			if (l == -1) {
+				trackp[track+1].pregapsize = 0;
+			} else if (l > 0) {
+				ts = tp->itracksize / tp->isecsize;
+				ps = ts - l;
+				if (ps > 0)
+					trackp[track+1].pregapsize = ps;
+			}
+		}
+	}
+
+}
+
+textptr_t *
+gettextptr(int track, track_t *trackp)
+{
+	register textptr_t *txp;
+
+	txp = (textptr_t *)trackp[track].text;
+	if (txp == NULL) {
+		txp = malloc(sizeof (textptr_t));
+		if (txp == NULL)
+			comerr("Cannot malloc CD-Text structure.\n");
+		fillbytes(txp, sizeof (textptr_t), '\0');
+		trackp[track].text = txp;
+	}
+	return (txp);
+}
+
+static char *
+savestr(char *str)
+{
+	char	*ret;
+
+	ret = malloc(strlen(str)+1);
+	if (ret)
+		strcpy(ret, str);
+	else
+		comerr("Cannot malloc auinfo string.\n");
+	return (ret);
+}
+
+static char *
+readtag(char *name)
+{
+	register char	*p;
+
+  p = cfg_get(name);
+  if (debug)
+     printf("%s	'%s'\n", name, p);
+  return (p);
+}
+
+static char *
+readtstr(char *name)
+{
+	register char	*p;
+	register char	*p2;
+
+	p = readtag(name);
+	if (p && *p == '\'') {
+		p2 = ++p;
+		while (*p2 != '\0')
+			p2++;
+		while (p2 > p && *p2 != '\'')
+			p2--;
+		*p2 = '\0';
+		if (debug)
+			printf("%s	'%s'\n", name, p);
+	}
+	return (p);
+}
+
+/*
+ * Media catalog number is a 13 digit number.
+ */
+void 
+setmcn(char *mcn, track_t *trackp)
+{
+	register char	*p;
+
+	if (strlen(mcn) != 13)
+		comerrno(EX_BAD, "MCN '%s' has illegal length.\n", mcn);
+
+	for (p = mcn; *p; p++) {
+		if (*p < '0' || *p > '9')
+			comerrno(EX_BAD, "MCN '%s' contains illegal character '%c'.\n", mcn, *p);
+	}
+	p = malloc(14);
+	strcpy(p, mcn);
+	trackp->isrc = p;
+
+	if (debug)
+		printf("Track %d MCN: '%s'\n", (int)trackp->trackno, trackp->isrc);
+}
+
+static	char	upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+static void 
+isrc_illchar(char *isrc, int c)
+{
+	errmsgno(EX_BAD, "ISRC '%s' contains illegal character '%c'.\n", isrc, c);
+}
+
+/*
+ * ISRC is 12 Byte:
+ *
+ *	Country code   'C' (alpha)	  2 Bytes
+ *	Owner code     'O' (alphanumeric) 3 Bytes
+ *	Year of record 'Y' (numeric)	  2 Bytes
+ *	Serial number  'S' (numeric)	  5 Bytes
+ *
+ *	CC-OOO-YY-SSSSS
+ */
+void 
+setisrc(char *isrc, track_t *trackp)
+{
+	char	ibuf[13];
+	char	*ip;
+	char	*p;
+	int	i;
+	int	len;
+
+	if ((len = strlen(isrc)) != 12) {
+		for (p = isrc, i = 0; *p; p++) {
+			if (*p == '-')
+				i++;
+		}
+		if (((len - i) != 12) || i > 3)
+			comerrno(EX_BAD, "ISRC '%s' has illegal length.\n", isrc);
+	}
+
+	/*
+	 * The country code.
+	 */
+	for (p = isrc, ip = ibuf, i = 0; i < 2; p++, i++) {
+		*ip++ = *p;
+		if (!strchr(upper, *p)) {
+/*			goto illchar;*/
+			/*
+			 * Flag numbers but accept them.
+			 */
+			isrc_illchar(isrc, *p);
+			if (*p >= '0' && *p <= '9')
+				continue;
+			exit(EX_BAD);
+		}
+	}
+	if (*p == '-')
+		p++;
+
+	/*
+	 * The owner code.
+	 */
+	for (i = 0; i < 3; p++, i++) {
+		*ip++ = *p;
+		if (strchr(upper, *p))
+			continue;
+		if (*p >= '0' && *p <= '9')
+			continue;
+		goto illchar;
+	}
+	if (*p == '-')
+		p++;
+
+	/*
+	 * The Year and the recording number (2 + 5 numbers).
+	 */
+	for (i = 0; i < 7; p++, i++) {
+		*ip++ = *p;
+		if (*p >= '0' && *p <= '9')
+			continue;
+		if (*p == '-' && i == 2) {
+			ip--;
+			i--;
+			continue;
+		}
+		goto illchar;
+	}
+	*ip = '\0';
+	p = malloc(13);
+	strcpy(p, ibuf);
+	trackp->isrc = p;
+
+	if (debug)
+		printf("Track %d ISRC: '%s'\n", (int)trackp->trackno, trackp->isrc);
+	return;
+illchar:
+	isrc_illchar(isrc, *p);
+	exit(EX_BAD);
+}
+
+void 
+setindex(char *tindex, track_t *trackp)
+{
+	char	*p;
+	int	i;
+	int	nindex;
+	long	idx;
+	long	*idxlist;
+
+	idxlist = malloc(100*sizeof (long));
+	p = tindex;
+	idxlist[0] = 0;
+	i = 0;
+	while (*p) {
+		p = astol(p, &idx);
+		if (*p != '\0' && *p != ' ' && *p != '\t' && *p != ',')
+			goto illchar;
+		i++;
+		if (i > 99)
+			comerrno(EX_BAD, "Too many indices for track %d\n", (int)trackp->trackno);
+		idxlist[i] = idx;
+		if (*p == ',')
+			p++;
+		while (*p == ' ' || *p == '\t')
+			p++;
+	}
+	nindex = i;
+
+	if (debug)
+		printf("Track %d %d Index: '%s'\n", (int)trackp->trackno, i, tindex);
+
+	if (debug) {
+		for (i = 0; i <= nindex; i++)
+			printf("%d: %ld\n", i, idxlist[i]);
+	}
+
+	trackp->nindex = nindex;
+	trackp->tindex = idxlist;
+	return;
+illchar:
+	comerrno(EX_BAD, "Index '%s' contains illegal character '%c'.\n", tindex, *p);
+}
diff --git a/wodim/cd_misc.c b/wodim/cd_misc.c
new file mode 100644
index 0000000..b9970bb
--- /dev/null
+++ b/wodim/cd_misc.c
@@ -0,0 +1,144 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cd_misc.c	1.10 01/10/29 Copyright 1997 J. Schilling */
+/*
+ *	Misc CD support routines
+ *
+ *	Copyright (c) 1997 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.
+ */
+
+#include <mconfig.h>
+#include <standard.h>
+#include <utypes.h>	/* Includes <sys/types.h> for caddr_t */
+#include <stdio.h>
+#include <schily.h>
+
+#include "wodim.h"
+
+int	from_bcd(int b);
+int	to_bcd(int i);
+long	msf_to_lba(int m, int s, int f, BOOL force_positive);
+BOOL	lba_to_msf(long lba, msf_t *mp);
+void	sec_to_msf(long sec, msf_t *mp);
+void	print_min_atip(long li, long lo);
+
+int 
+from_bcd(int b)
+{
+	return ((b & 0x0F) + 10 * (((b)>> 4) & 0x0F));
+}
+
+int 
+to_bcd(int i)
+{
+	return (i % 10 | ((i / 10) % 10) << 4);
+}
+
+long 
+msf_to_lba(int m, int s, int f, BOOL force_positive)
+{
+	long	ret = m * 60 + s;
+
+	ret *= 75;
+	ret += f;
+	if (m < 90 || force_positive)
+		ret -= 150;
+	else
+		ret -= 450150;
+	return (ret);
+}
+
+BOOL 
+lba_to_msf(long lba, msf_t *mp)
+{
+	int	m;
+	int	s;
+	int	f;
+
+#ifdef	__follow_redbook__
+	if (lba >= -150 && lba < 405000) {	/* lba <= 404849 */
+#else
+	if (lba >= -150) {
+#endif
+		m = (lba + 150) / 60 / 75;
+		s = (lba + 150 - m*60*75)  / 75;
+		f = (lba + 150 - m*60*75 - s*75);
+
+	} else if (lba >= -45150 && lba <= -151) {
+		m = (lba + 450150) / 60 / 75;
+		s = (lba + 450150 - m*60*75)  / 75;
+		f = (lba + 450150 - m*60*75 - s*75);
+
+	} else {
+		mp->msf_min   = -1;
+		mp->msf_sec   = -1;
+		mp->msf_frame = -1;
+
+		return (FALSE);
+	}
+	mp->msf_min   = m;
+	mp->msf_sec   = s;
+	mp->msf_frame = f;
+
+	if (lba > 404849)			/* 404850 -> 404999: lead out */
+		return (FALSE);
+	return (TRUE);
+}
+
+void 
+sec_to_msf(long sec, msf_t *mp)
+{
+	int	m;
+	int	s;
+	int	f;
+
+	m = (sec) / 60 / 75;
+	s = (sec - m*60*75)  / 75;
+	f = (sec - m*60*75 - s*75);
+
+	mp->msf_min   = m;
+	mp->msf_sec   = s;
+	mp->msf_frame = f;
+}
+
+void 
+print_min_atip(long li, long lo)
+{
+	msf_t	msf;
+
+	if (li < 0) {
+		lba_to_msf(li, &msf);
+
+		printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)\n",
+			li, msf.msf_min, msf.msf_sec, msf.msf_frame);
+	}
+	if (lo > 0) {
+		lba_to_msf(lo, &msf);
+		printf("  ATIP start of lead out: %ld (%02d:%02d/%02d)\n",
+			lo, msf.msf_min, msf.msf_sec, msf.msf_frame);
+	}
+}
diff --git a/wodim/cdr_drv.c b/wodim/cdr_drv.c
new file mode 100644
index 0000000..a40afa3
--- /dev/null
+++ b/wodim/cdr_drv.c
@@ -0,0 +1,318 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cdr_drv.c	1.36 04/03/02 Copyright 1997-2004 J. Schilling */
+/*
+ *	CDR device abstraction layer
+ *
+ *	Copyright (c) 1997-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>	/* Include sys/types.h to make off_t available */
+#include <standard.h>
+#include <schily.h>
+
+#include <usal/scsidefs.h>
+#include <usal/scsireg.h>
+#include <usal/scsitransp.h>
+
+#include "wodim.h"
+
+extern	int	xdebug;
+
+extern	cdr_t	cdr_oldcd;
+extern	cdr_t	cdr_cd;
+extern	cdr_t	cdr_mmc;
+extern  cdr_t   cdr_mdvd;
+extern	cdr_t	cdr_mmc_sony;
+extern	cdr_t	cdr_cd_dvd;
+extern	cdr_t	cdr_philips_cdd521O;
+extern	cdr_t	cdr_philips_dumb;
+extern	cdr_t	cdr_philips_cdd521;
+extern	cdr_t	cdr_philips_cdd522;
+extern	cdr_t	cdr_tyuden_ew50;
+extern	cdr_t	cdr_kodak_pcd600;
+extern	cdr_t	cdr_pioneer_dw_s114x;
+extern	cdr_t	cdr_plasmon_rf4100;
+extern	cdr_t	cdr_yamaha_cdr100;
+extern	cdr_t	cdr_sony_cdu924;
+extern	cdr_t	cdr_ricoh_ro1060;
+extern	cdr_t	cdr_ricoh_ro1420;
+extern	cdr_t	cdr_teac_cdr50;
+extern	cdr_t	cdr_cw7501;
+extern	cdr_t	cdr_cdr_simul;
+extern	cdr_t	cdr_dvd_simul;
+
+cdr_t 	*drive_identify(SCSI *usalp, cdr_t *, struct scsi_inquiry *ip);
+int	drive_attach(SCSI *usalp, cdr_t *);
+int	attach_unknown(void);
+int	blank_dummy(SCSI *usalp, cdr_t *, long addr, int blanktype);
+int	format_dummy(SCSI *usalp, cdr_t *, int fmtflags);
+int	drive_getdisktype(SCSI *usalp, cdr_t *dp);
+int	cmd_ill(SCSI *usalp);
+int	cmd_dummy(SCSI *usalp, cdr_t *);
+int	no_sendcue(SCSI *usalp, cdr_t *, track_t *trackp);
+int	buf_dummy(SCSI *usalp, long *sp, long *fp);
+BOOL	set_cdrcmds(char *name, cdr_t **dpp);
+cdr_t	*get_cdrcmds(SCSI *usalp);
+
+/*
+ * List of CD-R drivers
+ */
+cdr_t	*drivers[] = {
+	&cdr_cd_dvd,
+	&cdr_mmc,
+        &cdr_mdvd,
+	&cdr_mmc_sony,
+	&cdr_cd,
+	&cdr_oldcd,
+	&cdr_philips_cdd521O,
+	&cdr_philips_dumb,
+	&cdr_philips_cdd521,
+	&cdr_philips_cdd522,
+	&cdr_tyuden_ew50,
+	&cdr_kodak_pcd600,
+	&cdr_pioneer_dw_s114x,
+	&cdr_plasmon_rf4100,
+	&cdr_yamaha_cdr100,
+	&cdr_ricoh_ro1060,
+	&cdr_ricoh_ro1420,
+	&cdr_sony_cdu924,
+	&cdr_teac_cdr50,
+	&cdr_cw7501,
+	&cdr_cdr_simul,
+	&cdr_dvd_simul,
+	(cdr_t *)NULL,
+};
+
+cdr_t *
+drive_identify(SCSI *usalp, cdr_t *dp, struct scsi_inquiry *ip)
+{
+	return (dp);
+}
+
+int 
+drive_attach(SCSI *usalp, cdr_t *dp)
+{
+	return (0);
+}
+
+int 
+attach_unknown()
+{
+	errmsgno(EX_BAD, "Unsupported drive type\n");
+	return (-1);
+}
+
+int 
+blank_dummy(SCSI *usalp, cdr_t *dp, long addr, int blanktype)
+{
+	printf("This drive or media does not support the 'BLANK media' command\n");
+	return (-1);
+}
+
+int 
+format_dummy(SCSI *usalp, cdr_t *dp, int fmtflags)
+{
+	printf("This drive or media does not support the 'FORMAT media' command\n");
+	return (-1);
+}
+
+int 
+drive_getdisktype(SCSI *usalp, cdr_t *dp)
+{
+/*	dstat_t	*dsp = dp->cdr_dstat;*/
+	return (0);
+}
+
+int 
+cmd_ill(SCSI *usalp)
+{
+	errmsgno(EX_BAD, "Unspecified command not implemented for this drive.\n");
+	return (-1);
+}
+
+int 
+cmd_dummy(SCSI *usalp, cdr_t *dp)
+{
+	return (0);
+}
+
+int 
+no_sendcue(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	errmsgno(EX_BAD, "SAO writing not available or not implemented for this drive.\n");
+	return (-1);
+}
+
+int 
+buf_dummy(SCSI *usalp, long *sp, long *fp)
+{
+	return (-1);
+}
+
+BOOL 
+set_cdrcmds(char *name, cdr_t **dpp)
+{
+	cdr_t	**d;
+	int	n;
+
+	for (d = drivers; *d != (cdr_t *)NULL; d++) {
+		if (streql((*d)->cdr_drname, name)) {
+			if (dpp != NULL)
+				*dpp = *d;
+			return (TRUE);
+		}
+	}
+	if (dpp == NULL)
+		return (FALSE);
+
+	if (!streql("help", name))
+		fprintf(stderr, "Illegal driver type '%s'.\n", name);
+
+	fprintf(stderr, "Driver types:\n");
+	for (d = drivers; *d != (cdr_t *)NULL; d++) {
+		fprintf(stderr, "%s%n",
+			(*d)->cdr_drname, &n);
+		fprintf(stderr, "%*s%s\n",
+			20-n, "",
+			(*d)->cdr_drtext);
+	}
+	if (streql("help", name))
+		exit(0);
+	exit(EX_BAD);
+	return (FALSE);		/* Make lint happy */
+}
+
+cdr_t *
+get_cdrcmds(SCSI *usalp)
+{
+	cdr_t	*dp = (cdr_t *)0;
+	cdr_t	*odp = (cdr_t *)0;
+	BOOL	is_wr = FALSE;
+	BOOL	is_cd = FALSE;
+	BOOL	is_dvd = FALSE;
+	BOOL	is_dvdplus = FALSE;
+	BOOL	is_ddcd = FALSE;
+	BOOL	is_cdwr = FALSE;
+	BOOL	is_dvdwr = FALSE;
+	BOOL	is_dvdpluswr = FALSE;
+	BOOL	is_ddcdwr = FALSE;
+
+	/*
+	 * First check for SCSI-3/mmc-3 drives.
+	 */
+	if (get_proflist(usalp, &is_wr, &is_cd, &is_dvd,
+						&is_dvdplus, &is_ddcd) >= 0) {
+
+		get_wproflist(usalp, &is_cdwr, &is_dvdwr,
+						&is_dvdpluswr, &is_ddcdwr);
+		if (xdebug) {
+			fprintf(stderr, 
+			"Found MMC-3 %s CD: %s/%s DVD-: %s/%s DVD+: %s/%s DDCD: %s/%s.\n",
+					is_wr ? "writer": "reader",
+					is_cd?"r":"-",
+					is_cdwr?"w":"-",
+					is_dvd?"r":"-",
+					is_dvdwr?"w":"-",
+					is_dvdplus?"r":"-",
+					is_dvdpluswr?"w":"-",
+					is_ddcd?"r":"-",
+					is_ddcdwr?"w":"-");
+		}
+		if (!is_wr) {
+			dp = &cdr_cd;
+		} else {
+			dp = &cdr_cd_dvd;
+		}
+	} else
+	/*
+	 * First check for SCSI-3/mmc drives.
+	 */
+	if (is_mmc(usalp, &is_cdwr, &is_dvdwr)) {
+		if (xdebug) {
+			fprintf(stderr, "Found MMC drive CDWR: %d DVDWR: %d.\n",
+							is_cdwr, is_dvdwr);
+		}
+
+		if (is_cdwr && is_dvdwr)
+			dp = &cdr_cd_dvd;
+		else
+			dp = &cdr_mmc;
+
+	} else switch (usalp->dev) {
+
+	case DEV_CDROM:		dp = &cdr_oldcd;		break;
+	case DEV_MMC_CDROM:	dp = &cdr_cd;			break;
+	case DEV_MMC_CDR:	dp = &cdr_mmc;			break;
+	case DEV_MMC_CDRW:	dp = &cdr_mmc;			break;
+	case DEV_MMC_DVD_WR:	dp = &cdr_cd_dvd;		break;
+
+	case DEV_CDD_521_OLD:	dp = &cdr_philips_cdd521O;	break;
+	case DEV_CDD_521:	dp = &cdr_philips_cdd521;	break;
+	case DEV_CDD_522:
+	case DEV_CDD_2000:
+	case DEV_CDD_2600:	dp = &cdr_philips_cdd522;	break;
+	case DEV_TYUDEN_EW50:	dp = &cdr_tyuden_ew50;		break;
+	case DEV_PCD_600:	dp = &cdr_kodak_pcd600;		break;
+	case DEV_YAMAHA_CDR_100:dp = &cdr_yamaha_cdr100;	break;
+	case DEV_MATSUSHITA_7501:dp = &cdr_cw7501;		break;
+	case DEV_MATSUSHITA_7502:
+	case DEV_YAMAHA_CDR_400:dp = &cdr_mmc;			break;
+	case DEV_PLASMON_RF_4100:dp = &cdr_plasmon_rf4100;	break;
+	case DEV_SONY_CDU_924:	dp = &cdr_sony_cdu924;		break;
+	case DEV_RICOH_RO_1060C:dp = &cdr_ricoh_ro1060;		break;
+	case DEV_RICOH_RO_1420C:dp = &cdr_ricoh_ro1420;		break;
+	case DEV_TEAC_CD_R50S:	dp = &cdr_teac_cdr50;		break;
+
+	case DEV_PIONEER_DW_S114X: dp = &cdr_pioneer_dw_s114x;	break;
+
+	default:		dp = &cdr_mmc;
+	}
+	odp = dp;
+
+	if (xdebug) {
+		fprintf(stderr, "Using driver '%s' for identify.\n",
+			dp != NULL ?
+			dp->cdr_drname :
+			"<no driver>");
+	}
+
+	if (dp != (cdr_t *)0)
+		dp = dp->cdr_identify(usalp, dp, usalp->inq);
+
+	if (xdebug && dp != odp) {
+		fprintf(stderr, "Identify set driver to '%s'.\n",
+			dp != NULL ?
+			dp->cdr_drname :
+			"<no driver>");
+	}
+
+	return (dp);
+}
diff --git a/wodim/cdtext.c b/wodim/cdtext.c
new file mode 100644
index 0000000..40df2a5
--- /dev/null
+++ b/wodim/cdtext.c
@@ -0,0 +1,546 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cdtext.c	1.10 04/03/01 Copyright 1999-2004 J. Schilling */
+/*
+ *	Generic CD-Text support functions
+ *
+ *	Copyright (c) 1999-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>	/* Include sys/types.h to make off_t available */
+#include <standard.h>
+#include <utypes.h>
+#include <strdefs.h>
+#include <schily.h>
+
+#include <usal/scsitransp.h>	/* For write_leadin() */
+
+#include "cdtext.h"
+#include "wodim.h"
+#include "crc16.h"
+
+#define	PTI_TITLE	0x80	/* Album name and Track titles */
+#define	PTI_PERFORMER	0x81	/* Singer/player/conductor/orchestra */
+#define	PTI_SONGWRITER	0x82	/* Name of the songwriter */
+#define	PTI_COMPOSER	0x83	/* Name of the composer */
+#define	PTI_ARRANGER	0x84	/* Name of the arranger */
+#define	PTI_MESSAGE	0x85	/* Message from content provider or artist */
+#define	PTI_DISK_ID	0x86	/* Disk identification information */
+#define	PTI_GENRE	0x87	/* Genre identification / information */
+#define	PTI_TOC		0x88	/* TOC information */
+#define	PTI_TOC2	0x89	/* Second TOC */
+#define	PTI_RES_8A	0x8A	/* Reserved 8A */
+#define	PTI_RES_8B	0x8B	/* Reserved 8B */
+#define	PTI_RES_8C	0x8C	/* Reserved 8C */
+#define	PTI_CLOSED_INFO	0x8D	/* For internal use by content provider */
+#define	PTI_ISRC	0x8E	/* UPC/EAN code of album and ISRC for tracks */
+#define	PTI_SIZE	0x8F	/* Size information of the block */
+
+extern	int	xdebug;
+
+typedef struct textpack {
+	Uchar	pack_type;	/* Pack Type indicator	*/
+	char	track_no;	/* Track Number (0..99)	*/
+	char	seq_number;	/* Sequence Number	*/
+	char	block_number;	/* Block # / Char pos	*/
+	char	text[12];	/* CD-Text Data field	*/
+	char	crc[2];		/* CRC 16		*/
+} txtpack_t;
+
+#define	EXT_DATA 0x80		/* Extended data indicator in track_no */
+#define	DBCC	 0x80		/* Double byte char indicator in block */
+
+/*
+ *	CD-Text size example:
+ *
+ *	0  1  2  3  00 01 02 03 04 05 06 07 08 09 10 11 CRC16
+ *
+ *	8F 00 2B 00 01 01 0D 03 0C 0C 00 00 00 00 01 00 7B 3D
+ *	8F 01 2C 00 00 00 00 00 00 00 12 03 2D 00 00 00 DA B7
+ *	8F 02 2D 00 00 00 00 00 09 00 00 00 00 00 00 00 6A 24
+ *
+ *	charcode 1
+ *	first tr 1
+ *	last tr  13
+ *	Copyr	 3
+ *	Pack Count 80= 12, 81 = 12, 86 = 1, 8e = 18, 8f = 3
+ *	last seq   0 = 2d
+ *	languages  0 = 9
+ */
+
+typedef struct textsizes {
+	char	charcode;
+	char	first_track;
+	char	last_track;
+	char	copyr_flags;
+	char	pack_count[16];
+	char	last_seqnum[8];
+	char	language_codes[8];
+} txtsize_t;
+
+typedef struct textargs {
+	txtpack_t	*tp;
+	char		*p;
+	txtsize_t	*tsize;
+	int		seqno;
+} txtarg_t;
+
+
+Uchar	*textsub;
+int	textlen;
+
+BOOL			checktextfile(char *fname);
+static void	setuptextdata(Uchar *bp, int len);
+static BOOL	cdtext_crc_ok(struct textpack *p);
+void			packtext(int tracks, track_t *trackp);
+static BOOL	anytext(int pack_type, int tracks, track_t *trackp);
+static void	fillup_pack(txtarg_t *ap);
+static void	fillpacks(txtarg_t *ap, char *from, int len, int track_no, int pack_type);
+int			write_cdtext(SCSI *usalp, cdr_t *dp, long startsec);
+static void	eight2six(Uchar *in, Uchar *out);
+static void	six2eight(Uchar *in, Uchar *out);
+
+
+BOOL checktextfile(char *fname)
+{
+	FILE	*f;
+	Uchar	hbuf[4];
+	Uchar	*bp;
+	struct textpack *tp;
+	int	len;
+	int	crc;
+	int	n;
+	int	j;
+	off_t	fs;
+
+	if ((f = fileopen(fname, "rb")) == NULL) {
+		errmsg("Cannot open '%s'.\n", fname);
+		return (FALSE);
+	}
+	fs = filesize(f);
+	j = fs % sizeof (struct textpack);
+	if (j == 4) {
+		n = fileread(f, hbuf, 4);
+		if (n != 4) {
+			if (n < 0)
+				errmsg("Cannot read '%s'.\n", fname);
+			else
+				errmsgno(EX_BAD, "File '%s' is too small for CD-Text.\n", fname);
+			return (FALSE);
+		}
+		len = hbuf[0] * 256 + hbuf[1];
+		len -= 2;
+		n = fs - 4;
+		if (n != len) {
+			errmsgno(EX_BAD, "Inconsistent CD-Text file '%s' length should be %d but is %lld\n",
+				fname, len+4, (Llong)fs);
+			return (FALSE);
+		}
+	} else if (j != 0) {
+		errmsgno(EX_BAD, "Inconsistent CD-Text file '%s' not a multiple of pack length\n",
+			fname);
+		return (FALSE);
+	} else {
+		len = fs;
+	}
+	printf("Text len: %d\n", len);
+	bp = malloc(len);
+	if (bp == NULL) {
+		errmsg("Cannot malloc CD-Text read buffer.\n");
+		return (FALSE);
+	}
+	n = fileread(f, bp, len);
+
+	tp = (struct textpack *)bp;
+	for (n = 0; n < len; n += sizeof (struct textpack), tp++) {
+		if (tp->pack_type < 0x80 || tp->pack_type > 0x8F) {
+			errmsgno(EX_BAD, "Illegal pack type 0x%02X pack #%ld in CD-Text file '%s'.\n",
+				tp->pack_type, (long)(n/sizeof (struct textpack)), fname);
+			return (FALSE);
+		}
+		crc = (tp->crc[0] & 0xFF) << 8 | (tp->crc[1] & 0xFF);
+		crc ^= 0xFFFF;
+		if (crc != calcCRC((Uchar *)tp, sizeof (*tp)-2)) {
+			if (cdtext_crc_ok(tp)) {
+				errmsgno(EX_BAD,
+				"Corrected CRC ERROR in pack #%ld (offset %d-%ld) in CD-Text file '%s'.\n",
+				(long)(n/sizeof (struct textpack)),
+				n+j, (long)(n+j+sizeof (struct textpack)),
+				fname);
+			} else {
+			errmsgno(EX_BAD, "CRC ERROR in pack #%ld (offset %d-%ld) in CD-Text file '%s'.\n",
+				(long)(n/sizeof (struct textpack)),
+				n+j, (long)(n+j+sizeof (struct textpack)),
+				fname);
+			return (FALSE);
+			}
+		}
+	}
+	setuptextdata(bp, len);
+	free(bp);
+
+	return (TRUE);
+}
+
+static void setuptextdata(Uchar *bp, int len)
+{
+	int	n;
+	int	i;
+	int	j;
+	Uchar	*p;
+
+	if (xdebug) {
+		printf("%ld packs %% 4 = %ld\n",
+			(long)(len/sizeof (struct textpack)),
+			(long)(len/sizeof (struct textpack)) % 4);
+	}
+	i = (len/sizeof (struct textpack)) % 4;
+	if (i == 0) {
+		n = len;
+	} else if (i == 2) {
+		n = 2 * len;
+	} else {
+		n = 4 * len;
+	}
+	n = (n * 4) / 3;
+	p = malloc(n);
+	if (p == NULL) {
+		errmsg("Cannot malloc CD-Text write buffer.\n");
+	}
+	for (i = 0, j = 0; j < n; ) {
+		eight2six(&bp[i%len], &p[j]);
+		i += 3;
+		j += 4;
+	}
+	textsub = p;
+	textlen = n;
+
+#ifdef	DEBUG
+	{
+	Uchar	sbuf[10000];
+	struct textpack *tp;
+	FILE		*f;
+	int		crc;
+
+	tp = (struct textpack *)bp;
+	p = sbuf;
+	for (n = 0; n < len; n += sizeof (struct textpack), tp++) {
+		crc = (tp->crc[0] & 0xFF) << 8 | (tp->crc[1] & 0xFF);
+		crc ^= 0xFFFF;
+
+		printf("Pack:%3d ", n/ sizeof (struct textpack));
+		printf("Pack type: %02X ", tp->pack_type & 0xFF);
+		printf("Track #: %2d ", tp->track_no & 0xFF);
+		printf("Sequence #:%3d ", tp->seq_number & 0xFF);
+		printf("Block #:%3d ", tp->block_number & 0xFF);
+		printf("CRC: %04X (%04X) ", crc, calcCRC((Uchar *)tp, sizeof (*tp)-2));
+		printf("Text: '%.12s'\n", tp->text);
+		movebytes(tp->text, p, 12);
+		p += 12;
+	}
+	printf("len total: %d\n", n);
+	f = fileopen("cdtext.out", "wctb");
+	if (f) {
+		filewrite(f, sbuf, p - sbuf);
+		fflush(f);
+		fclose(f);
+	}
+	}
+#endif
+}
+
+static BOOL cdtext_crc_ok(struct textpack *p)
+{
+	int		crc;
+	struct textpack	new;
+
+	movebytes(p, &new, sizeof (struct textpack));
+	new.crc[0] ^= 0xFF;
+	new.crc[1] ^= 0xFF;
+	crc = calcCRC((Uchar *)&new, sizeof (struct textpack));
+	crc = flip_crc_error_corr((Uchar *)&new, sizeof (struct textpack), crc);
+	new.crc[0] ^= 0xFF;
+	new.crc[1] ^= 0xFF;
+	if (crc == 0)
+		movebytes(&new, p, 18);
+
+	return (crc == 0);
+}
+
+
+void packtext(int tracks, track_t *trackp)
+{
+	int	type;
+	int	i;
+	struct textpack *tp;
+	struct textsizes tsize;
+	txtarg_t targ;
+	char	sbuf[256*18];
+
+	fillbytes(sbuf, sizeof (sbuf), 0);
+	fillbytes(&tsize, sizeof (tsize), 0);
+
+	tsize.charcode		= CC_8859_1;		/* ISO-8859-1	    */
+	tsize.first_track	= trackp[1].trackno;
+	tsize.last_track	= trackp[1].trackno + tracks - 1;
+#ifdef	__FOUND_ON_COMMERCIAL_CD__
+	tsize.copyr_flags	= 3;			/* for titles/names */
+#else
+	tsize.copyr_flags	= 0;			/* no Copyr. limitat. */
+#endif
+	tsize.pack_count[0x0F]	= 3;			/* 3 size packs	    */
+	tsize.last_seqnum[0]	= 0;			/* Start value only */
+	tsize.language_codes[0]	= LANG_ENGLISH;		/* English	    */
+
+	tp = (struct textpack *)sbuf;
+
+	targ.tp = tp;
+	targ.p = NULL;
+	targ.tsize = &tsize;
+	targ.seqno = 0;
+
+	for (type = 0; type <= 0x0E; type++) {
+		register int	maxtrk;
+		register char	*s;
+
+		if (!anytext(type, tracks, trackp))
+			continue;
+		maxtrk = tsize.last_track;
+		if (type == 6) {
+			maxtrk = 0;
+		}
+		for (i = 0; i <= maxtrk; i++) {
+			s = trackp[i].text;
+			if (s)
+				s = ((textptr_t *)s)->textcodes[type];
+			if (s)
+				fillpacks(&targ, s, strlen(s)+1, i, 0x80| type);
+			else
+				fillpacks(&targ, "", 1, i, 0x80| type);
+
+		}
+		fillup_pack(&targ);
+	}
+
+	/*
+	 * targ.seqno overshoots by one and we add 3 size packs...
+	 */
+	tsize.last_seqnum[0] = targ.seqno + 2;
+
+	for (i = 0; i < 3; i++) {
+		fillpacks(&targ, &((char *)(&tsize))[i*12], 12, i, 0x8f);
+	}
+
+	setuptextdata((Uchar *)sbuf, targ.seqno*18);
+
+#ifdef	DEBUG
+	{	FILE	*f;
+
+	f = fileopen("cdtext.new", "wctb");
+	if (f) {
+		filewrite(f, sbuf, targ.seqno*18);
+		fflush(f);
+		fclose(f);
+	}
+	}
+#endif
+}
+
+static BOOL anytext(int pack_type, int tracks, track_t *trackp)
+{
+	register int	i;
+	register char	*p;
+
+	for (i = 0; i <= tracks; i++) {
+		if (trackp[i].text == NULL)
+			continue;
+		p = ((textptr_t *)(trackp[i].text))->textcodes[pack_type];
+		if (p != NULL && *p != '\0')
+			return (TRUE);
+	}
+	return (FALSE);
+}
+
+static void fillup_pack(register txtarg_t *ap)
+{
+	if (ap->p) {
+		fillbytes(ap->p, &ap->tp->text[12] - ap->p, '\0');
+		fillcrc((Uchar *)ap->tp, sizeof (*ap->tp));
+		ap->p  = 0;
+		ap->tp++;
+	}
+}
+
+static void fillpacks(register txtarg_t *ap, register char *from, int len, 
+          				 int track_no, int pack_type)
+{
+	register int		charpos;
+	register char		*p;
+	register txtpack_t	*tp;
+
+	tp = ap->tp;
+	p  = ap->p;
+	charpos = 0;
+	do {
+		if (p == 0) {
+			p = tp->text;
+			tp->pack_type = pack_type;
+			if (pack_type != 0x8f)
+				ap->tsize->pack_count[pack_type & 0x0F]++;
+			tp->track_no = track_no;
+			tp->seq_number = ap->seqno++;
+			if (charpos < 15)
+				tp->block_number = charpos;
+			else
+				tp->block_number = 15;
+		}
+		for (; --len >= 0 && p < &tp->text[12]; charpos++) {
+			*p++ = *from++;
+		}
+		len++;	/* Overshoot compensation */
+
+		if (p >= &tp->text[12]) {
+			fillcrc((Uchar *)tp, sizeof (*tp));
+			p = 0;
+			tp++;
+		}
+	} while (len > 0);
+
+	ap->tp = tp;
+	ap->p = p;
+}
+
+int write_cdtext(SCSI *usalp, cdr_t *dp, long startsec)
+{
+	char	*bp = (char *)textsub;
+	int	buflen = textlen;
+	long	amount;
+	long	bytes = 0;
+	long	end = -150;
+	int	secspt = textlen / 96;
+	int	bytespt = textlen;
+	long	maxdma = usalp->maxbuf;
+	int	idx;
+	int	secs;
+	int	nbytes;
+
+/*maxdma = 4320;*/
+	if (maxdma >= (2*textlen)) {
+		/*
+		 * Try to make each CD-Text transfer use as much data
+		 * as possible.
+		 */
+		bp = usalp->bufptr;
+		for (idx = 0; (idx + textlen) <= maxdma; idx += textlen)
+			movebytes(textsub, &bp[idx], textlen);
+		buflen = idx;
+		secspt = buflen / 96;
+		bytespt = buflen;
+/*printf("textlen: %d buflen: %d secspt: %d\n", textlen, buflen, secspt);*/
+	} else if (maxdma < buflen) {
+		/*
+		 * We have more CD-Text data than we may transfer at once.
+		 */
+		secspt = maxdma / 96;
+		bytespt = secspt * 96;
+	}
+	while (startsec < end) {
+		if ((end - startsec) < secspt) {
+			secspt = end - startsec;
+			bytespt = secspt * 96;
+		}
+		idx = 0;
+		secs = secspt;
+		nbytes = bytespt;
+		do {			/* loop over CD-Text data buffer */
+
+			if ((idx + nbytes) > buflen) {
+				nbytes = buflen - idx;
+				secs = nbytes / 96;
+			}
+/*printf("idx: %d nbytes: %d secs: %d startsec: %ld\n",*/
+/*idx, nbytes, secs, startsec);*/
+			amount = write_secs(usalp, dp,
+				(char *)&bp[idx], startsec, nbytes, secs, FALSE);
+			if (amount < 0) {
+				printf("write CD-Text data: error after %ld bytes\n",
+						bytes);
+				return (-1);
+			}
+			bytes += amount;
+			idx += amount;
+			startsec += secs;
+		} while (idx < buflen && startsec < end);
+	}
+	return (0);
+}
+
+
+/*
+ * 3 input bytes (8 bit based) are converted into 4 output bytes (6 bit based).
+ */
+static void eight2six(register Uchar *in, register Uchar *out)
+{
+	register int	c;
+
+	c = in[0];
+	out[0]  = (c >> 2) & 0x3F;
+	out[1]  = (c & 0x03) << 4;
+
+	c = in[1];
+	out[1] |= (c & 0xF0) >> 4;
+	out[2]  = (c & 0x0F) << 2;
+
+	c = in[2];
+	out[2] |= (c & 0xC0) >> 6;
+	out[3]  = c & 0x3F;
+}
+
+/*
+ * 4 input bytes (6 bit based) are converted into 3 output bytes (8 bit based).
+ */
+static void six2eight(register Uchar *in, register Uchar *out)
+{
+	register int	c;
+
+	c = in[0] & 0x3F;
+	out[0]  = c << 2;
+
+	c = in[1] & 0x3F;
+	out[0] |= c >> 4;
+	out[1]  = c << 4;
+
+	c = in[2] & 0x3F;
+	out[1] |= c >> 2;
+	out[2]  = c << 6;
+
+	c = in[3] & 0x3F;
+	out[2] |= c;
+}
diff --git a/wodim/cdtext.h b/wodim/cdtext.h
new file mode 100644
index 0000000..89808c6
--- /dev/null
+++ b/wodim/cdtext.h
@@ -0,0 +1,143 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cdtext.h	1.5 04/03/02 Copyright 1999-2004 J. Schilling */
+/*
+ *	Generic CD-Text support definitions
+ *
+ *	Copyright (c) 1999-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.
+ */
+
+#ifndef	CDTEXT_H
+#define	CDTEXT_H
+
+/*
+ * Strings for the CD-Text Pack Type indicators 0x80...0x8F
+ * We cannot use a plain structure here because we like to loop
+ * over all members.
+ */
+typedef struct textcodes {
+	char	*textcodes[16];
+} textptr_t;
+
+#define	tc_title	textcodes[0x00]
+#define	tc_performer	textcodes[0x01]
+#define	tc_songwriter	textcodes[0x02]
+#define	tc_composer	textcodes[0x03]
+#define	tc_arranger	textcodes[0x04]
+#define	tc_message	textcodes[0x05]
+#define	tc_diskid	textcodes[0x06]
+#define	tc_genre	textcodes[0x07]
+#define	tc_toc		textcodes[0x08]
+#define	tc_toc2		textcodes[0x09]
+
+#define	tc_closed_info	textcodes[0x0d]
+#define	tc_isrc		textcodes[0x0e]
+
+/*
+ *	binaere Felder sind
+ *	Disc ID			(Wirklich ???)
+ *	Genre ID
+ *	TOC
+ *	Second TOC
+ *	Size information
+ */
+
+/*
+ * Genre codes from Enhanced CD Specification page 21
+ */
+#define	GENRE_UNUSED		0	/* not used			    */
+#define	GENRE_UNDEFINED		1	/* not defined			    */
+#define	GENRE_ADULT_CONTEMP	2	/* Adult Contemporary		    */
+#define	GENRE_ALT_ROCK		3	/* Alternative Rock		    */
+#define	GENRE_CHILDRENS		4	/* Childrens Music		    */
+#define	GENRE_CLASSIC		5	/* Classical			    */
+#define	GENRE_CHRIST_CONTEMP	6	/* Contemporary Christian	    */
+#define	GENRE_COUNTRY		7	/* Country			    */
+#define	GENRE_DANCE		8	/* Dance			    */
+#define	GENRE_EASY_LISTENING	9	/* Easy Listening		    */
+#define	GENRE_EROTIC		10	/* Erotic			    */
+#define	GENRE_FOLK		11	/* Folk				    */
+#define	GENRE_GOSPEL		12	/* Gospel			    */
+#define	GENRE_HIPHOP		13	/* Hip Hop			    */
+#define	GENRE_JAZZ		14	/* Jazz				    */
+#define	GENRE_LATIN		15	/* Latin			    */
+#define	GENRE_MUSICAL		16	/* Musical			    */
+#define	GENRE_NEWAGE		17	/* New Age			    */
+#define	GENRE_OPERA		18	/* Opera			    */
+#define	GENRE_OPERETTA		19	/* Operetta			    */
+#define	GENRE_POP		20	/* Pop Music			    */
+#define	GENRE_RAP		21	/* RAP				    */
+#define	GENRE_REGGAE		22	/* Reggae			    */
+#define	GENRE_ROCK		23	/* Rock Music			    */
+#define	GENRE_RYTHMANDBLUES	24	/* Rhythm & Blues		    */
+#define	GENRE_SOUNDEFFECTS	25	/* Sound Effects		    */
+#define	GENRE_SPOKEN_WORD	26	/* Spoken Word			    */
+#define	GENRE_WORLD_MUSIC	28	/* World Music			    */
+#define	GENRE_RESERVED		29	/* Reserved is 29..32767	    */
+#define	GENRE_RIAA		32768	/* Registration by RIAA 32768..65535 */
+
+/*
+ * Character codings used in CD-Text data.
+ * Korean and Mandarin Chinese to be defined in sept 1996
+ */
+#define	CC_8859_1	0x00		/* ISO 8859-1			*/
+#define	CC_ASCII	0x01		/* ISO 646, ASCII (7 bit)	*/
+#define	CC_RESERVED_02	0x02		/* Reserved codes 0x02..0x7f	*/
+#define	CC_KANJI	0x80		/* Music Shift-JIS Kanji	*/
+#define	CC_KOREAN	0x81		/* Korean			*/
+#define	CC_CHINESE	0x82		/* Mandarin Chinese		*/
+#define	CC_RESERVED_83	0x83		/* Reserved codes 0x83..0xFF	*/
+
+
+/*
+ * The language code is encoded as specified in ANNEX 1 to part 5 of EBU
+ * Tech 32 58 -E (1991).
+ *
+ * The current language codes are guessed
+ */
+#define	LANG_CZECH	 6		/* 0x06				*/
+#define	LANG_DANISH	 7		/* 0x07				*/
+#define	LANG_GERMAN	 8		/* 0x08				*/
+#define	LANG_ENGLISH	 9		/* 0x09				*/
+#define	LANG_SPANISH	10		/* 0x0A				*/
+#define	LANG_FRENCH	15		/* 0x0F				*/
+#define	LANG_ITALIAN	21		/* 0x15				*/
+#define	LANG_HUNGARIAN	27		/* 0x1B				*/
+#define	LANG_DUTCH	29		/* 0x1D				*/
+#define	LANG_NORWEGIAN	30		/* 0x1E				*/
+#define	LANG_POLISH	32		/* 0x20				*/
+#define	LANG_PORTUGUESE	33		/* 0x21				*/
+#define	LANG_SLOVENE	38		/* 0x26				*/
+#define	LANG_FINNISH	39		/* 0x27				*/
+#define	LANG_SWEDISH	40		/* 0x28				*/
+#define	LANG_RUSSIAN	86		/* 0x56				*/
+#define	LANG_KOREAN	101		/* 0x65				*/
+#define	LANG_JAPANESE	105		/* 0x69				*/
+#define	LANG_GREEK	112		/* 0x70				*/
+#define	LANG_CHINESE	117		/* 0x75				*/
+
+#endif
diff --git a/wodim/clone.c b/wodim/clone.c
new file mode 100644
index 0000000..da8fb91
--- /dev/null
+++ b/wodim/clone.c
@@ -0,0 +1,270 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)clone.c	1.7 04/03/02 Copyright 2001-2004 J. Schilling */
+/*
+ *	Clone Subchannel processing
+ *
+ *	Copyright (c) 2001-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <fctldefs.h>
+#include <strdefs.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <btorder.h>
+#include <utypes.h>
+#include <schily.h>
+
+#include <usal/usalcmd.h>
+#include <usal/scsitransp.h>
+
+#include "wodim.h"
+#include "crc16.h"
+
+#include <usal/scsireg.h>
+#include "scsimmc.h"
+
+/*#define	SAO_RAW*/
+
+void	clone_toc(track_t *trackp);
+void	clone_tracktype(track_t *trackp);
+
+extern	int	lverbose;
+extern	int	xdebug;
+
+extern	Uchar	_subq[110][12];
+extern	int	_nsubh;
+
+
+static	int	ctrl_first;
+static	int	ctrl_last;
+static	int	sectype_first;
+static	int	sectype_last;
+static	int	disktype;
+static	long	loutstart;
+
+/*
+ * Read Clone TOC description from full toc file.
+ */
+void clone_toc(track_t *trackp)
+{
+	char	filename[1024];
+	msf_t	m;
+	msf_t	mr;
+	struct	tocheader *tp;
+	struct	ftrackdesc *fp;
+	int	f;
+	char	buf[2048];
+	int	amt;
+	int	len;
+	int	i;
+	int	j;
+	int	ctrladr;
+	Uint	first = 100;
+	Uint	last = 0;
+
+	len = strlen(trackp[1].filename);
+	if (len > (sizeof (filename)-5)) {
+		len = sizeof (filename)-5;
+	}
+	snprintf(filename, sizeof (filename), "%.*s.toc", len, trackp[1].filename);
+
+	f = open(filename, O_RDONLY|O_BINARY);
+	if (f < 0)
+		comerr("Cannot open '%s'.\n", filename);
+	amt = read(f, buf, sizeof (buf));
+
+	if (amt == sizeof (buf))
+		comerrno(EX_BAD, "TOC too large.\n");
+	close(f);
+	tp = (struct tocheader *)buf;
+	len = a_to_u_2_byte(tp->len) + sizeof (struct tocheader)-2;
+
+	if (xdebug) {
+		printf("Read %d bytes TOC len: %d first session: %d last session: %d\n",
+			amt, len, tp->first, tp->last);
+	}
+
+	fp = (struct ftrackdesc *)&buf[4];
+
+	for (i = 4, j = 0; i < len; i += 11) {
+		fp = (struct ftrackdesc *)&buf[i];
+		if (xdebug)
+			usal_prbytes("FT", (Uchar *)&buf[i], 11);
+		if (fp->sess_number != 1)
+			comerrno(EX_BAD, "Can only copy session # 1.\n");
+
+		if (fp->adr == 1) {
+			if (fp->point < first) {
+				first = fp->point;
+				ctrl_first = fp->control;
+			}
+			if (fp->point <= 99 && fp->point > last) {
+				last = fp->point;
+				ctrl_last = fp->control;
+			}
+		}
+		if (fp->adr != 1) {
+			switch (fp->point) {
+
+			case 0xB0:
+			case 0xC0:
+			case 0xC1:
+				break;
+			default:
+				continue;
+			}
+		}
+		m.msf_min    = fp->amin;
+		m.msf_sec    = fp->asec;
+		m.msf_frame  = fp->aframe;
+
+		mr.msf_min   = fp->pmin;
+		mr.msf_sec   = fp->psec;
+		mr.msf_frame = fp->pframe;
+
+		if (fp->point == 0xA0) {
+			disktype = mr.msf_sec;
+			mr.msf_sec = from_bcd(mr.msf_sec);		/* convert to BCD */
+		}
+
+		if (fp->point == 0xA2)
+			loutstart = msf_to_lba(fp->pmin, fp->psec, fp->pframe, TRUE);
+		ctrladr = fp->control << 4;
+		ctrladr |= fp->adr;
+
+		filltpoint(_subq[j], ctrladr, fp->point, &mr);
+		fillttime(_subq[j], &m);
+		_subq[j][6] = fp->res7;
+		if (fp->point == 0xC0 || fp->point == 0xC1) {
+			_subq[j][3] = m.msf_min;
+			_subq[j][4] = m.msf_sec;
+			_subq[j][5] = m.msf_frame;
+		}
+		if (fp->point == 0xC1) {
+			_subq[j][7] = mr.msf_min;
+			_subq[j][8] = mr.msf_sec;
+			_subq[j][9] = mr.msf_frame;
+		}
+		if (xdebug)
+			usal_prbytes("TOC  ", _subq[j], 12);
+		j++;
+	}
+	_nsubh = j;
+	if (xdebug) {
+		printf("nsubheader %d lout: %ld track 1 secs: %ld\n", j, loutstart, trackp[1].tracksecs);
+		printf("first %u last %u ctrl first: %X ctrl last %X\n", first, last, ctrl_first, ctrl_last);
+	}
+	if (trackp->tracks != 1)
+		comerrno(EX_BAD, "Clone writing currently supports only one file argument.\n");
+	if (loutstart > trackp[1].tracksecs)
+		comerrno(EX_BAD, "Clone writing TOC length %ld does not match track length %ld\n",
+			loutstart, trackp[1].tracksecs);
+
+	if (amt > len) {
+		sectype_first = buf[len];
+		sectype_last = buf[len+1];
+		if (xdebug) {
+			printf("sectype first: %X sectype last %X\n",
+				sectype_first, sectype_last);
+		}
+	}
+}
+
+
+/*
+ * Set tracktypes for track 0 (lead-in) & track AA (lead-out)
+ *
+ * Control 0 = audio
+ * Control 1 = audio preemp
+ * Control 2 = audio copy
+ * Control 3 = audio copy preemp
+ * Control 4 = data
+ * Control 5 = packet data
+ */
+void clone_tracktype(track_t *trackp)
+{
+	int	tracks = trackp->tracks;
+	int	sectype;
+
+	sectype = SECT_ROM;
+	if ((ctrl_first & TM_DATA) == 0) {
+		sectype = SECT_AUDIO;
+
+		if ((ctrl_first & TM_PREEM) != 0) {
+			trackp[0].flags |= TI_PREEMP;
+		} else {
+			trackp[0].flags &= ~TI_PREEMP;
+			sectype |= ST_PREEMPMASK;
+		}
+		if ((ctrl_first & TM_ALLOW_COPY) != 0) {
+			trackp[0].flags |= TI_COPY;
+		} else {
+			trackp[0].flags &= ~TI_COPY;
+		}
+/* XXX ???	flags |= TI_SCMS; */
+	} else {
+		if ((ctrl_first & TM_INCREMENTAL) != 0) {
+			trackp[0].flags |= TI_PACKET;
+		} else {
+			trackp[0].flags &= ~TI_PACKET;
+		}
+		if (sectype_first != 0)
+			sectype = sectype_first;
+	}
+	trackp[0].sectype = sectype;
+
+	sectype = SECT_ROM;
+
+	if ((ctrl_last & TM_DATA) == 0) {
+		sectype = SECT_AUDIO;
+
+		if ((ctrl_last & TM_PREEM) != 0) {
+			trackp[tracks+1].flags |= TI_PREEMP;
+		} else {
+			trackp[tracks+1].flags &= ~TI_PREEMP;
+			sectype |= ST_PREEMPMASK;
+		}
+		if ((ctrl_last & TM_ALLOW_COPY) != 0) {
+			trackp[tracks+1].flags |= TI_COPY;
+		} else {
+			trackp[tracks+1].flags &= ~TI_COPY;
+		}
+/* XXX ???	flags |= TI_SCMS; */
+	} else {
+		if ((ctrl_first & TM_INCREMENTAL) != 0) {
+			trackp[0].flags |= TI_PACKET;
+		} else {
+			trackp[0].flags &= ~TI_PACKET;
+			if (sectype_last != 0)
+				sectype = sectype_last;
+		}
+	}
+	trackp[tracks+1].sectype = sectype;
+}
diff --git a/wodim/crc16.c b/wodim/crc16.c
new file mode 100644
index 0000000..8eecf04
--- /dev/null
+++ b/wodim/crc16.c
@@ -0,0 +1,160 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)crc16.c	1.6 04/03/02 Copyright 1998-2004 J. Schilling */
+/*
+ *	Q-subchannel CRC subroutines
+ *
+ *	Polynom is: p(x) = x ** 16 + x ** 12 + x ** 5 + 1
+ *	If computed over 12 bytes, the result must be zero.
+ *	On the disk the CRC bits are inverted.
+ *
+ *	Copyright (c) 1998-2003 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.
+ */
+
+#include <mconfig.h>
+#include <standard.h>
+#include <utypes.h>
+#include "crc16.h"
+
+static	UInt16_t	updcrc(Uint p_crc, UInt8_t *cp, Uint cnt);
+UInt16_t	calcCRC(Uchar *buf, Uint bsize);
+UInt16_t	fillcrc(Uchar *buf, Uint bsize);
+UInt16_t	flip_crc_error_corr(Uchar *b, Uint bsize, Uint p_crc);
+
+
+	/* number of bits in CRC: don't change it. */
+#define	BPW	16
+
+	/* this the number of bits per char: don't change it. */
+#define	BPB	8
+
+static UInt16_t crctab[1<<BPB] = {
+    0x0000,  0x1021,  0x2042,  0x3063,  0x4084,  0x50a5,  0x60c6,  0x70e7,
+    0x8108,  0x9129,  0xa14a,  0xb16b,  0xc18c,  0xd1ad,  0xe1ce,  0xf1ef,
+    0x1231,  0x0210,  0x3273,  0x2252,  0x52b5,  0x4294,  0x72f7,  0x62d6,
+    0x9339,  0x8318,  0xb37b,  0xa35a,  0xd3bd,  0xc39c,  0xf3ff,  0xe3de,
+    0x2462,  0x3443,  0x0420,  0x1401,  0x64e6,  0x74c7,  0x44a4,  0x5485,
+    0xa56a,  0xb54b,  0x8528,  0x9509,  0xe5ee,  0xf5cf,  0xc5ac,  0xd58d,
+    0x3653,  0x2672,  0x1611,  0x0630,  0x76d7,  0x66f6,  0x5695,  0x46b4,
+    0xb75b,  0xa77a,  0x9719,  0x8738,  0xf7df,  0xe7fe,  0xd79d,  0xc7bc,
+    0x48c4,  0x58e5,  0x6886,  0x78a7,  0x0840,  0x1861,  0x2802,  0x3823,
+    0xc9cc,  0xd9ed,  0xe98e,  0xf9af,  0x8948,  0x9969,  0xa90a,  0xb92b,
+    0x5af5,  0x4ad4,  0x7ab7,  0x6a96,  0x1a71,  0x0a50,  0x3a33,  0x2a12,
+    0xdbfd,  0xcbdc,  0xfbbf,  0xeb9e,  0x9b79,  0x8b58,  0xbb3b,  0xab1a,
+    0x6ca6,  0x7c87,  0x4ce4,  0x5cc5,  0x2c22,  0x3c03,  0x0c60,  0x1c41,
+    0xedae,  0xfd8f,  0xcdec,  0xddcd,  0xad2a,  0xbd0b,  0x8d68,  0x9d49,
+    0x7e97,  0x6eb6,  0x5ed5,  0x4ef4,  0x3e13,  0x2e32,  0x1e51,  0x0e70,
+    0xff9f,  0xefbe,  0xdfdd,  0xcffc,  0xbf1b,  0xaf3a,  0x9f59,  0x8f78,
+    0x9188,  0x81a9,  0xb1ca,  0xa1eb,  0xd10c,  0xc12d,  0xf14e,  0xe16f,
+    0x1080,  0x00a1,  0x30c2,  0x20e3,  0x5004,  0x4025,  0x7046,  0x6067,
+    0x83b9,  0x9398,  0xa3fb,  0xb3da,  0xc33d,  0xd31c,  0xe37f,  0xf35e,
+    0x02b1,  0x1290,  0x22f3,  0x32d2,  0x4235,  0x5214,  0x6277,  0x7256,
+    0xb5ea,  0xa5cb,  0x95a8,  0x8589,  0xf56e,  0xe54f,  0xd52c,  0xc50d,
+    0x34e2,  0x24c3,  0x14a0,  0x0481,  0x7466,  0x6447,  0x5424,  0x4405,
+    0xa7db,  0xb7fa,  0x8799,  0x97b8,  0xe75f,  0xf77e,  0xc71d,  0xd73c,
+    0x26d3,  0x36f2,  0x0691,  0x16b0,  0x6657,  0x7676,  0x4615,  0x5634,
+    0xd94c,  0xc96d,  0xf90e,  0xe92f,  0x99c8,  0x89e9,  0xb98a,  0xa9ab,
+    0x5844,  0x4865,  0x7806,  0x6827,  0x18c0,  0x08e1,  0x3882,  0x28a3,
+    0xcb7d,  0xdb5c,  0xeb3f,  0xfb1e,  0x8bf9,  0x9bd8,  0xabbb,  0xbb9a,
+    0x4a75,  0x5a54,  0x6a37,  0x7a16,  0x0af1,  0x1ad0,  0x2ab3,  0x3a92,
+    0xfd2e,  0xed0f,  0xdd6c,  0xcd4d,  0xbdaa,  0xad8b,  0x9de8,  0x8dc9,
+    0x7c26,  0x6c07,  0x5c64,  0x4c45,  0x3ca2,  0x2c83,  0x1ce0,  0x0cc1,
+    0xef1f,  0xff3e,  0xcf5d,  0xdf7c,  0xaf9b,  0xbfba,  0x8fd9,  0x9ff8,
+    0x6e17,  0x7e36,  0x4e55,  0x5e74,  0x2e93,  0x3eb2,  0x0ed1,  0x1ef0,
+};
+
+#define	SUBSIZE	96	/* 12 bytes with 8 bits */
+
+static UInt16_t 
+updcrc(Uint p_crc, register UInt8_t *cp, register Uint cnt)
+{
+	register UInt16_t	crc = p_crc;
+
+	while (cnt-- > 0) {
+		crc = (crc<<BPB) ^ crctab[(crc>>(BPW-BPB)) ^ (*cp++)];
+	}
+	return (crc);
+}
+
+/*static UInt16_t*/
+UInt16_t 
+calcCRC(Uchar *buf, Uint bsize)
+{
+	return (updcrc(0x0000, (UInt8_t *)buf, bsize));
+}
+
+/*
+ * CRC für Q-Sub füllen
+ */
+UInt16_t 
+fillcrc(Uchar *buf, Uint bsize)
+{
+	UInt16_t	crc = calcCRC(buf, bsize-2);
+
+	/*
+	 * Invert CRC bits for RED Book compliance.
+	 */
+	crc = crc ^ 0xFFFF;
+
+	buf[bsize-2] = (crc >> 8) & 0xFF;
+	buf[bsize-1] = crc & 0xFF;
+	return (crc);
+}
+
+static UInt8_t fliptab[BPB] = {
+	0x01,
+	0x02,
+	0x04,
+	0x08,
+	0x10,
+	0x20,
+	0x40,
+	0x80,
+};
+
+UInt16_t 
+flip_crc_error_corr(Uchar *b, Uint bsize, Uint p_crc)
+{
+	register UInt16_t	crc = p_crc;
+	register Uint		btsize = bsize * BPB;
+
+	if (crc != 0) {
+		int	i;
+
+		for (i = 0; i < btsize; i++) {
+			UInt8_t	c;
+
+			c = fliptab[i % BPB];
+			b[i / BPB] ^= c;
+			if ((crc = calcCRC(b, bsize)) == 0) {
+				return (crc);
+			}
+			b[i / BPB] ^= c;
+		}
+	}
+	return (crc & 0xffff);
+}
diff --git a/wodim/crc16.h b/wodim/crc16.h
new file mode 100644
index 0000000..c8f425c
--- /dev/null
+++ b/wodim/crc16.h
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)crc16.h	1.3 02/03/04 Copyright 1998-2002 J. Schilling */
+/*
+ *	Q-subchannel CRC definitions
+ *
+ *	Copyright (c) 1998-2002 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.
+ */
+
+#ifndef	_CRC16_H
+#define	_CRC16_H
+
+extern	UInt16_t	calcCRC(Uchar *buf, Uint bsize);
+extern	UInt16_t	fillcrc(Uchar *buf, Uint bsize);
+extern	UInt16_t	flip_crc_error_corr(Uchar *b, Uint bsize, Uint p_crc);
+
+#endif
diff --git a/wodim/cue.c b/wodim/cue.c
new file mode 100644
index 0000000..0eb88b3
--- /dev/null
+++ b/wodim/cue.c
@@ -0,0 +1,1198 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cue.c	1.20 04/03/02 Copyright 2001-2004 J. Schilling */
+/*
+ *	Cue sheet parser
+ *
+ *	Copyright (c) 2001-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <fctldefs.h>
+#include <statdefs.h>
+#include <vadefs.h>
+#include <schily.h>
+#include <strdefs.h>
+#include <utypes.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "xio.h"
+#include "cdtext.h"
+#include "wodim.h"
+#include "auheader.h"
+#include "libport.h"
+
+typedef struct state {
+	char	*filename;
+	void	*xfp;
+	Llong	trackoff;
+	Llong	filesize;
+	int	filetype;
+	int	tracktype;
+	int	sectype;
+	int	dbtype;
+	int	secsize;
+	int	dataoff;
+	int	state;
+	int	track;
+	int	index;
+	long	index0;
+	long	index1;		/* Current index 1 value	*/
+	long	secoff;		/* Old index 1 value		*/
+	long	pregapsize;
+	long	postgapsize;
+	int	flags;
+} state_t;
+
+static	char	linebuf[4096];
+static	char	*fname;
+static	char	*linep;
+static	char	*wordendp;
+static	char	wordendc;
+static	int	olinelen;
+static	int	linelen;
+static	int	lineno;
+
+static	char	worddelim[] = "=:,/";
+static	char	nulldelim[] = "";
+
+#define	STATE_NONE	0
+#define	STATE_POSTGAP	1
+#define	STATE_TRACK	2
+#define	STATE_FLAGS	3
+#define	STATE_INDEX0	4
+#define	STATE_INDEX1	5
+
+typedef struct keyw {
+	char	*k_name;
+	int	k_type;
+} keyw_t;
+
+/*
+ *	Keywords (first word on line):
+ *		CATALOG		- global	CATALOG		<MCN>
+ *		CDTEXTFILE	- global	CDTEXTFILE	<fname>
+ *		FILE		- track static	FILE		<fame> <type>
+ *		FLAGS		- track static	FLAGS		<flag> ...
+ *		INDEX		- track static	INDEX		<#> <mm:ss:ff>
+ *		ISRC		- track static	ISRC		<ISRC>
+ *		PERFORMER	- global/static	PERFORMER	<string>
+ *		POSTGAP		- track locak	POSTGAP		<mm:ss:ff>
+ *		PREGAP		- track static	PREGAP		<mm:ss:ff>
+ *		REM		- anywhere	REM		<comment>
+ *		SONGWRITER	- global/static	SONGWRITER	<string>
+ *		TITLE		- global/static	TITLE		<string>
+ *		TRACK		- track static	TRACK		<#> <datatype>
+ *
+ *	Order of keywords:
+ *		CATALOG
+ *		CDTEXTFILE
+ *		PERFORMER | SONGWRITER | TITLE		Doc says past FILE...
+ *		FILE					Must be past CATALOG
+ *		------- Repeat the following:		mehrere FILE Commands?
+ *		TRACK
+ *		FLAGS | ISRC | PERFORMER | PREGAP | SONGWRITER | TITLE
+ *		INDEX
+ *		POSTGAP
+ */
+
+#define	K_G		0x10000		/* Global			*/
+#define	K_T		0x20000		/* Track static			*/
+#define	K_A		(K_T | K_G)	/* Global & Track static		*/
+
+#define	K_MCN		(0 | K_G)	/* Media catalog number 	*/
+#define	K_TEXTFILE	(1 | K_G)	/* CD-Text binary file		*/
+#define	K_FILE		(2 | K_T)	/* Input data file		*/
+#define	K_FLAGS		(3 | K_T)	/* Flags for ctrl nibble	*/
+#define	K_INDEX		(4 | K_T)	/* Index marker for track	*/
+#define	K_ISRC		(5 | K_T)	/* ISRC string for track	*/
+#define	K_PERFORMER	(6 | K_A)	/* CD-Text Performer		*/
+#define	K_POSTGAP	(7 | K_T)	/* Post gap for track (autogen)	*/
+#define	K_PREGAP	(8 | K_T)	/* Pre gap for track (autogen)	*/
+#define	K_REM		(9 | K_A)	/* Remark (Comment)		*/
+#define	K_SONGWRITER	(10| K_A)	/* CD-Text Songwriter		*/
+#define	K_TITLE		(11| K_A)	/* CD-Text Title		*/
+#define	K_TRACK		(12| K_T)	/* Track marker			*/
+
+
+static keyw_t	keywords[] = {
+	{ "CATALOG",	K_MCN },
+	{ "CDTEXTFILE",	K_TEXTFILE },
+	{ "FILE",	K_FILE },
+	{ "FLAGS",	K_FLAGS },
+	{ "INDEX",	K_INDEX },
+	{ "ISRC",	K_ISRC },
+	{ "PERFORMER",	K_PERFORMER },
+	{ "POSTGAP",	K_POSTGAP },
+	{ "PREGAP",	K_PREGAP },
+	{ "REM",	K_REM },
+	{ "SONGWRITER",	K_SONGWRITER },
+	{ "TITLE",	K_TITLE },
+	{ "TRACK",	K_TRACK },
+	{ NULL,		0 },
+};
+
+
+/*
+ *	Filetypes - argument to FILE Keyword (one only):
+ *
+ *		BINARY		- Intel binary file (least significant byte first)
+ *		MOTOTOLA	- Motorola binary file (most significant byte first)
+ *		AIFF		- Audio AIFF file
+ *		AU		- Sun Audio file
+ *		WAVE		- Audio WAVE file
+ *		MP3		- Audio MP3 file
+ */
+#define	K_BINARY	100
+#define	K_MOTOROLA	101
+#define	K_AIFF		102
+#define	K_AU		103
+#define	K_WAVE		104
+#define	K_MP3		105
+#define	K_OGG		106
+
+static keyw_t	filetypes[] = {
+	{ "BINARY",	K_BINARY },
+	{ "MOTOROLA",	K_MOTOROLA },
+	{ "AIFF",	K_AIFF },
+	{ "AU",		K_AU },
+	{ "WAVE",	K_WAVE },
+	{ "MP3",	K_MP3 },
+	{ "OGG",	K_OGG },
+	{ NULL,		0 },
+};
+
+/*
+ *	Flags - argument to FLAGS Keyword (more than one allowed):
+ *		DCP		- Digital copy permitted
+ *		4CH		- Four channel audio
+ *		PRE		- Pre-emphasis enabled (audio tracks only)
+ *		SCMS		- Serial copy management system (not supported by all recorders)
+ */
+#define	K_DCP		1000
+#define	K_4CH		1001
+#define	K_PRE		1002
+#define	K_SCMS		1003
+
+static keyw_t	flags[] = {
+	{ "DCP",	K_DCP },
+	{ "4CH",	K_4CH },
+	{ "PRE",	K_PRE },
+	{ "SCMS",	K_SCMS },
+	{ NULL,		0 },
+};
+
+/*
+ *	Datatypes - argument to TRACK Keyword (one only):
+ *		AUDIO		- Audio/Music (2352)
+ *		CDG		- Karaoke CD+G (2448)
+ *		MODE1/2048	- CDROM Mode1 Data (cooked)
+ *		MODE1/2352	- CDROM Mode1 Data (raw)
+ *		MODE2/2336	- CDROM-XA Mode2 Data
+ *		MODE2/2352	- CDROM-XA Mode2 Data
+ *		CDI/2336	- CDI Mode2 Data
+ *		CDI/2352	- CDI Mode2 Data
+ */
+#define	K_AUDIO		10000
+#define	K_CDG		10001
+#define	K_MODE1		10002
+#define	K_MODE2		10003
+#define	K_CDI		10004
+
+static keyw_t	dtypes[] = {
+	{ "AUDIO",	K_AUDIO },
+	{ "CDG",	K_CDG },
+	{ "MODE1",	K_MODE1 },
+	{ "MODE2",	K_MODE2 },
+	{ "CDI",	K_CDI },
+	{ NULL,		0 },
+};
+
+
+int	parsecue(char *cuefname, track_t trackp[]);
+void	fparsecue(FILE *f, track_t trackp[]);
+static	void	parse_mcn(track_t trackp[], state_t *sp);
+static	void	parse_textfile(track_t trackp[], state_t *sp);
+static	void	parse_file(track_t trackp[], state_t *sp);
+static	void	parse_flags(track_t trackp[], state_t *sp);
+static	void	parse_index(track_t trackp[], state_t *sp);
+static	void	parse_isrc(track_t trackp[], state_t *sp);
+static	void	parse_performer(track_t trackp[], state_t *sp);
+static	void	parse_postgap(track_t trackp[], state_t *sp);
+static	void	parse_pregap(track_t trackp[], state_t *sp);
+static	void	parse_songwriter(track_t trackp[], state_t *sp);
+static	void	parse_title(track_t trackp[], state_t *sp);
+static	void	parse_track(track_t trackp[], state_t *sp);
+static	void	parse_offset(long *lp);
+static	void	newtrack(track_t trackp[], state_t *sp);
+
+static	keyw_t	*lookup(char *word, keyw_t table[]);
+static	void	wdebug(void);
+static	FILE	*cueopen(char *name);
+static	char	*cuename(void);
+static	char	*nextline(FILE *f);
+static	void	ungetline(void);
+static	char	*skipwhite(const char *s);
+static	char	*peekword(void);
+static	char	*lineend(void);
+static	char	*markword(char *delim);
+static	char	*getnextitem(char *delim);
+static	char	*neednextitem(char *delim);
+static	char	*nextword(void);
+static	char	*needword(void);
+static	char	*curword(void);
+static	char	*nextitem(void);
+static	char	*needitem(void);
+static	void	checkextra(void);
+static	void	cueabort(const char *fmt, ...);
+
+#ifdef	CUE_MAIN
+int	debug;
+int	xdebug = 1;
+
+int write_secs(void);
+int write_secs() { return (-1); }
+
+int 
+main(int argc, char *argv[])
+{
+	int	i;
+	track_t	track[MAX_TRACK+2];	/* Max tracks + track 0 + track AA */
+
+	save_args(argc, argv);
+
+	fillbytes(track, sizeof (track), '\0');
+	for (i = 0; i < MAX_TRACK+2; i++)
+		track[i].track = track[i].trackno = i;
+	track[0].tracktype = TOC_MASK;
+
+
+	parsecue(argv[1], track);
+	return (0);
+}
+#else
+extern	int	xdebug;
+#endif
+
+int 
+parsecue(char *cuefname, track_t trackp[])
+{
+	FILE	*f = cueopen(cuefname);
+
+	fparsecue(f, trackp);
+	return (0);
+}
+
+void 
+fparsecue(FILE *f, track_t trackp[])
+{
+	char	*word;
+	struct keyw *kp;
+	BOOL	isglobal = TRUE;
+	state_t	state;
+
+	state.filename	= NULL;
+	state.xfp	= NULL;
+	state.trackoff	= 0;
+	state.filesize	= 0;
+	state.filetype	= 0;
+	state.tracktype	= 0;
+	state.sectype	= 0;
+	state.dbtype	= 0;
+	state.secsize	= 0;
+	state.dataoff	= 0;
+	state.state	= STATE_NONE;
+	state.track	= 0;
+	state.index	= -1;
+	state.index0	= -1;
+	state.index1	= -1;
+	state.secoff	= 0;
+	state.pregapsize = -1;
+	state.postgapsize = -1;
+	state.flags	= 0;
+
+	if (xdebug > 1)
+		printf("---> Entering CUE Parser...\n");
+	do {
+		if (nextline(f) == NULL) {
+			/*
+			 * EOF on CUE File
+			 * Do post processing here
+			 */
+			if (state.state < STATE_INDEX1)
+				cueabort("Incomplete CUE file");
+			if (state.xfp)
+				xclose(state.xfp);
+			if (xdebug > 1) {
+				printf("---> CUE Parser got EOF, found %d tracks.\n",
+								state.track);
+			}
+			return;
+		}
+		word = nextitem();
+		if (*word == '\0')	/* empty line */
+			continue;
+
+		if (xdebug > 1)
+			printf("\nKEY: '%s'     %s\n", word, peekword());
+		kp = lookup(word, keywords);
+		if (kp == NULL)
+			cueabort("Unknown CUE keyword '%s'", word);
+
+		if ((kp->k_type & K_G) == 0) {
+			if (isglobal)
+				isglobal = FALSE;
+		}
+		if ((kp->k_type & K_T) == 0) {
+			if (!isglobal)
+				cueabort("Badly placed CUE keyword '%s'", word);
+		}
+/*		printf("%s-", isglobal ? "G" : "T");*/
+/*		wdebug();*/
+
+		switch (kp->k_type) {
+
+		case K_MCN:	   parse_mcn(trackp, &state);		break;
+		case K_TEXTFILE:   parse_textfile(trackp, &state);	break;
+		case K_FILE:	   parse_file(trackp, &state);		break;
+		case K_FLAGS:	   parse_flags(trackp, &state);		break;
+		case K_INDEX:	   parse_index(trackp, &state);		break;
+		case K_ISRC:	   parse_isrc(trackp, &state);		break;
+		case K_PERFORMER:  parse_performer(trackp, &state);	break;
+		case K_POSTGAP:	   parse_postgap(trackp, &state);	break;
+		case K_PREGAP:	   parse_pregap(trackp, &state);	break;
+		case K_REM:						break;
+		case K_SONGWRITER: parse_songwriter(trackp, &state);	break;
+		case K_TITLE:	   parse_title(trackp, &state);		break;
+		case K_TRACK:	   parse_track(trackp, &state);		break;
+
+		default:
+			cueabort("Panic: unknown CUE command '%s'", word);
+		}
+	} while (1);
+}
+
+static void 
+parse_mcn(track_t trackp[], state_t *sp)
+{
+	char	*word;
+	textptr_t *txp;
+
+	if (sp->track != 0)
+		cueabort("CATALOG keyword must be before first TRACK");
+
+	word = needitem();
+	setmcn(word, &trackp[0]);
+	txp = gettextptr(0, trackp); /* MCN is isrc for trk 0 */
+	txp->tc_isrc = strdup(word);
+
+	checkextra();
+}
+
+static void 
+parse_textfile(track_t trackp[], state_t *sp)
+{
+	char	*word;
+
+	if (sp->track != 0)
+		cueabort("CDTEXTFILE keyword must be before first TRACK");
+
+	word = needitem();
+
+	if (trackp[MAX_TRACK+1].flags & TI_TEXT) {
+		if (!checktextfile(word)) {
+			comerrno(EX_BAD,
+				"Cannot use '%s' as CD-Text file.\n",
+				word);
+		}
+		trackp[0].flags |= TI_TEXT;
+	} else {
+		errmsgno(EX_BAD, "Ignoring CDTEXTFILE '%s'.\n", word);
+		errmsgno(EX_BAD, "If you like to write CD-Text, call wodim -text.\n");
+	}
+
+	checkextra();
+}
+
+static void 
+parse_file(track_t trackp[], state_t *sp)
+{
+	char	cname[1024];
+	char	newname[1024];
+	struct keyw *kp;
+	char	*word;
+	char	*filetype;
+	struct stat	st;
+#ifdef	hint
+	Llong		lsize;
+#endif
+
+	if (sp->filename != NULL)
+		cueabort("Only one FILE allowed");
+
+	word = needitem();
+	if (sp->xfp)
+		xclose(sp->xfp);
+	sp->xfp = xopen(word, O_RDONLY|O_BINARY, 0);
+	if (sp->xfp == NULL && geterrno() == ENOENT) {
+		char	*p;
+
+		if (strchr(word, '/') == 0 &&
+		    strchr(cuename(), '/') != 0) {
+			snprintf(cname, sizeof (cname),
+				"%s", cuename());
+			p = strrchr(cname, '/');
+			if (p)
+				*p = '\0';
+			snprintf(newname, sizeof (newname),
+				"%s/%s", cname, word);
+			word = newname;
+			sp->xfp = xopen(word, O_RDONLY|O_BINARY, 0);
+		}
+	}
+	if (sp->xfp == NULL)
+		comerr("Cannot open FILE '%s'.\n", word);
+
+	sp->filename	 = strdup(word);
+	sp->trackoff	 = 0;
+	sp->filesize	 = 0;
+	sp->flags	&= ~TI_SWAB;	/* Reset what we might set for FILE */
+
+	filetype = needitem();
+	kp = lookup(filetype, filetypes);
+	if (kp == NULL)
+		cueabort("Unknown filetype '%s'", filetype);
+
+	switch (kp->k_type) {
+
+	case K_BINARY:
+	case K_MOTOROLA:
+			if (fstat(xfileno(sp->xfp), &st) >= 0 &&
+			    S_ISREG(st.st_mode)) {
+				sp->filesize = st.st_size;
+			} else {
+				cueabort("Unknown file size for FILE '%s'",
+								sp->filename);
+			}
+			break;
+	case K_AIFF:
+			cueabort("Unsupported filetype '%s'", kp->k_name);
+			break;
+	case K_AU:
+			sp->filesize = ausize(xfileno(sp->xfp));
+			break;
+	case K_WAVE:
+			sp->filesize = wavsize(xfileno(sp->xfp));
+			sp->flags |= TI_SWAB;
+			break;
+	case K_MP3:
+	case K_OGG:
+			cueabort("Unsupported filetype '%s'", kp->k_name);
+			break;
+
+	default:	cueabort("Panic: unknown filetype '%s'", filetype);
+	}
+
+	if (sp->filesize == AU_BAD_CODING) {
+		cueabort("Inappropriate audio coding in '%s'",
+							sp->filename);
+	}
+	if (xdebug > 0)
+		printf("Track %d File '%s' Filesize %lld\n",
+			sp->track, sp->filename, sp->filesize);
+
+	sp->filetype = kp->k_type;
+
+	checkextra();
+
+
+#ifdef	hint
+		trackp->itracksize = lsize;
+		if (trackp->itracksize != lsize)
+			comerrno(EX_BAD, "This OS cannot handle large audio images.\n");
+#endif
+}
+
+static void 
+parse_flags(track_t trackp[], state_t *sp)
+{
+	struct keyw *kp;
+	char	*word;
+
+	if ((sp->state < STATE_TRACK) ||
+	    (sp->state >= STATE_INDEX0))
+		cueabort("Badly placed FLAGS keyword");
+	sp->state = STATE_FLAGS;
+
+	do {
+		word = needitem();
+		kp = lookup(word, flags);
+		if (kp == NULL)
+			cueabort("Unknown flag '%s'", word);
+
+		switch (kp->k_type) {
+
+		case K_DCP:	sp->flags |= TI_COPY;	break;
+		case K_4CH:	sp->flags |= TI_QUADRO;	break;
+		case K_PRE:	sp->flags |= TI_PREEMP;	break;
+		case K_SCMS:	sp->flags |= TI_SCMS;	break;
+		default:	cueabort("Panic: unknown FLAG '%s'", word);
+		}
+
+	} while (peekword() < lineend());
+
+	if (xdebug > 0)
+		printf("Track %d flags 0x%08X\n", sp->track, sp->flags);
+}
+
+static void 
+parse_index(track_t trackp[], state_t *sp)
+{
+	char	*word;
+	long	l;
+	int	track = sp->track;
+
+	if (sp->state < STATE_TRACK)
+		cueabort("Badly placed INDEX keyword");
+
+
+	word = needitem();
+	if (*astolb(word, &l, 10) != '\0')
+		cueabort("Not a number '%s'", word);
+	if (l < 0 || l > 99)
+		cueabort("Illegal index '%s'", word);
+
+	if ((sp->index < l) &&
+	    (((sp->index + 1) == l) || l == 1))
+		sp->index = l;
+	else
+		cueabort("Badly placed INDEX %ld number", l);
+
+	if (l > 0)
+		sp->state = STATE_INDEX1;
+	else
+		sp->state = STATE_INDEX0;
+
+	parse_offset(&l);
+
+	if (xdebug > 1)
+		printf("Track %d Index %d %ld\n", sp->track, sp->index, l);
+
+	if (sp->index == 0)
+		sp->index0 = l;
+	if (sp->index == 1) {
+		sp->index1 = l;
+		trackp[track].nindex = 1;
+		newtrack(trackp, sp);
+
+		if (xdebug > 1) {
+			printf("Track %d pregapsize %ld\n",
+				sp->track, trackp[track].pregapsize);
+		}
+	}
+	if (sp->index == 2) {
+		trackp[track].tindex = malloc(100*sizeof (long));
+		trackp[track].tindex[1] = 0;
+		trackp[track].tindex[2] = l - sp->index1;
+		trackp[track].nindex = 2;
+	}
+	if (sp->index > 2) {
+		trackp[track].tindex[sp->index] = l - sp->index1;
+		trackp[track].nindex = sp->index;
+	}
+
+	checkextra();
+}
+
+static void 
+parse_isrc(track_t trackp[], state_t *sp)
+{
+	char	*word;
+	textptr_t *txp;
+	int	track = sp->track;
+
+	if (track == 0)
+		cueabort("ISRC keyword must be past first TRACK");
+
+	if ((sp->state < STATE_TRACK) ||
+	    (sp->state >= STATE_INDEX0))
+		cueabort("Badly placed ISRC keyword");
+	sp->state = STATE_FLAGS;
+
+	word = needitem();
+	setisrc(word, &trackp[track]);
+	txp = gettextptr(track, trackp);
+	txp->tc_isrc = strdup(word);
+
+	checkextra();
+}
+
+static void 
+parse_performer(track_t trackp[], state_t *sp)
+{
+	char	*word;
+	textptr_t *txp;
+
+	word = needitem();
+	txp = gettextptr(sp->track, trackp);
+	txp->tc_performer = strdup(word);
+
+	checkextra();
+}
+
+static void 
+parse_postgap(track_t trackp[], state_t *sp)
+{
+	long	l;
+
+	if (sp->state < STATE_INDEX1)
+		cueabort("Badly placed POSTGAP keyword");
+	sp->state = STATE_POSTGAP;
+
+	parse_offset(&l);
+	sp->postgapsize = l;
+
+	checkextra();
+}
+
+static void 
+parse_pregap(track_t trackp[], state_t *sp)
+{
+	long	l;
+
+	if ((sp->state < STATE_TRACK) ||
+	    (sp->state >= STATE_INDEX0))
+		cueabort("Badly placed PREGAP keyword");
+	sp->state = STATE_FLAGS;
+
+	parse_offset(&l);
+	sp->pregapsize = l;
+
+	checkextra();
+}
+
+static void 
+parse_songwriter(track_t trackp[], state_t *sp)
+{
+	char	*word;
+	textptr_t *txp;
+
+	word = needitem();
+	txp = gettextptr(sp->track, trackp);
+	txp->tc_songwriter = strdup(word);
+
+	checkextra();
+}
+
+static void 
+parse_title(track_t trackp[], state_t *sp)
+{
+	char	*word;
+	textptr_t *txp;
+
+	word = needitem();
+	txp = gettextptr(sp->track, trackp);
+	txp->tc_title = strdup(word);
+
+	checkextra();
+}
+
+static void 
+parse_track(track_t trackp[], state_t *sp)
+{
+	struct keyw *kp;
+	char	*word;
+	long	l;
+	long	secsize = -1;
+
+	if ((sp->state >= STATE_TRACK) &&
+	    (sp->state < STATE_INDEX1))
+		cueabort("Badly placed TRACK keyword");
+	sp->state = STATE_TRACK;
+	sp->index = -1;
+
+	word = needitem();
+	if (*astolb(word, &l, 10) != '\0')
+		cueabort("Not a number '%s'", word);
+	if (l <= 0 || l > 99)
+		cueabort("Illegal TRACK number '%s'", word);
+
+	if ((sp->track < l) &&
+	    (((sp->track + 1) == l) || sp->track == 0))
+		sp->track = l;
+	else
+		cueabort("Badly placed TRACK %ld number", l);
+
+	word = needword();
+	kp = lookup(word, dtypes);
+	if (kp == NULL)
+		cueabort("Unknown filetype '%s'", word);
+
+	if (wordendc == '/') {
+		word = needitem();
+		if (*astol(++word, &secsize) != '\0')
+			cueabort("Not a number '%s'", word);
+	}
+
+	/*
+	 * Reset all flags that may be set in TRACK & FLAGS lines
+	 */
+	sp->flags &= ~(TI_AUDIO|TI_COPY|TI_QUADRO|TI_PREEMP|TI_SCMS);
+
+	if (kp->k_type == K_AUDIO)
+		sp->flags |= TI_AUDIO;
+
+	switch (kp->k_type) {
+
+	case K_CDG:
+		if (secsize < 0)
+			secsize = 2448;
+	case K_AUDIO:
+		if (secsize < 0)
+			secsize = 2352;
+
+		sp->tracktype = TOC_DA;
+		sp->sectype = SECT_AUDIO;
+		sp->dbtype = DB_RAW;
+		sp->secsize = secsize;
+		sp->dataoff = 0;
+		if (secsize != 2352)
+			cueabort("Unsupported sector size %ld for audio", secsize);
+		break;
+
+	case K_MODE1:
+		if (secsize < 0)
+			secsize = 2048;
+
+		sp->tracktype = TOC_ROM;
+		sp->sectype = SECT_ROM;
+		sp->dbtype = DB_ROM_MODE1;
+		sp->secsize = secsize;
+		sp->dataoff = 16;
+		/*
+		 * XXX Sector Size == 2352 ???
+		 * XXX It seems that there exist bin/cue pairs with this value
+		 */
+		if (secsize != 2048)
+			cueabort("Unsupported sector size %ld for data", secsize);
+		break;
+
+	case K_MODE2:
+	case K_CDI:
+		sp->tracktype = TOC_ROM;
+		sp->sectype = SECT_MODE_2;
+		sp->dbtype = DB_ROM_MODE2;
+		sp->secsize = secsize;
+		sp->dataoff = 16;
+		if (secsize == 2352) {
+			sp->tracktype = TOC_XA2;
+			sp->sectype = SECT_MODE_2_MIX;
+			sp->sectype |= ST_MODE_RAW;
+			sp->dbtype = DB_RAW;
+			sp->dataoff = 0;
+		} else if (secsize != 2336)
+			cueabort("Unsupported sector size %ld for mode2", secsize);
+		if (kp->k_type == K_CDI)
+			sp->tracktype = TOC_CDI;
+		break;
+
+	default:	cueabort("Panic: unknown datatype '%s'", word);
+	}
+
+	if (sp->flags & TI_PREEMP)
+		sp->sectype |= ST_PREEMPMASK;
+	sp->secsize = secsize;
+
+	if (xdebug > 1) {
+		printf("Track %d Tracktype %s/%d\n",
+			sp->track, kp->k_name, sp->secsize);
+	}
+
+	checkextra();
+}
+
+static void 
+parse_offset(long *lp)
+{
+	char	*word;
+	char	*p;
+	long	m = -1;
+	long	s = -1;
+	long	f = -1;
+
+	word = needitem();
+
+	if (strchr(word, ':') == NULL) {
+		if (*astol(word, lp) != '\0')
+			cueabort("Not a number '%s'", word);
+		return;
+	}
+	if (*(p = astolb(word, &m, 10)) != ':')
+		cueabort("Not a number '%s'", word);
+	if (m < 0 || m >= 160)
+		cueabort("Illegal minute value in '%s'", word);
+	p++;
+	if (*(p = astolb(p, &s, 10)) != ':')
+		cueabort("Not a number '%s'", p);
+	if (s < 0 || s >= 60)
+		cueabort("Illegal second value in '%s'", word);
+	p++;
+	if (*(p = astolb(p, &f, 10)) != '\0')
+		cueabort("Not a number '%s'", p);
+	if (f < 0 || f >= 75)
+		cueabort("Illegal frame value in '%s'", word);
+
+	m = m * 60 + s;
+	m = m * 75 + f;
+	*lp = m;
+}
+
+/*--------------------------------------------------------------------------*/
+static void 
+newtrack(track_t trackp[], state_t *sp)
+{
+	register int	i;
+	register int	track = sp->track;
+		Llong	tracksize;
+
+	if (xdebug > 1)
+		printf("-->Newtrack %d\n", track);
+	if (track > 1) {
+		tracksize = (sp->index1 - sp->secoff) * trackp[track-1].secsize;
+
+		if (xdebug > 1)
+			printf("    trackoff %lld filesize %lld index1 %ld size %ld/%lld\n",
+				sp->trackoff, sp->filesize, sp->index1,
+				sp->index1 - sp->secoff,
+				tracksize);
+
+		trackp[track-1].itracksize = tracksize;
+		trackp[track-1].tracksize = tracksize;
+		trackp[track-1].tracksecs = sp->index1 - sp->secoff;
+
+		sp->trackoff += tracksize;
+		sp->secoff = sp->index1;
+	}
+	/*
+	 * Make 'tracks' immediately usable in track structure.
+	 */
+	for (i = 0; i < MAX_TRACK+2; i++)
+		trackp[i].tracks = track;
+
+	trackp[track].filename = sp->filename;
+	trackp[track].xfp = xopen(sp->filename, O_RDONLY|O_BINARY, 0);
+	trackp[track].trackstart = 0L;
+/*
+SEtzen wenn tracksecs bekannt sind
+d.h. mit Index0 oder Index 1 vom nächsten track
+
+	trackp[track].itracksize = tracksize;
+	trackp[track].tracksize = tracksize;
+	trackp[track].tracksecs = -1L;
+*/
+	tracksize = sp->filesize - sp->trackoff;
+
+	trackp[track].itracksize = tracksize;
+	trackp[track].tracksize = tracksize;
+	trackp[track].tracksecs = (tracksize + sp->secsize - 1) / sp->secsize;
+
+	if (xdebug > 1)
+		printf("    Remaining Filesize %lld (%lld secs)\n",
+			(sp->filesize-sp->trackoff),
+			(sp->filesize-sp->trackoff +sp->secsize - 1) / sp->secsize);
+
+	if (sp->pregapsize >= 0) {
+/*		trackp[track].flags &= ~TI_PREGAP;*/
+		sp->flags &= ~TI_PREGAP;
+		trackp[track].pregapsize = sp->pregapsize;
+	} else {
+/*		trackp[track].flags |= TI_PREGAP;*/
+		if (track > 1)
+			sp->flags |= TI_PREGAP;
+		if (track == 1)
+			trackp[track].pregapsize = sp->index1 + 150;
+		else if (sp->index0 < 0)
+			trackp[track].pregapsize = -1;
+		else
+			trackp[track].pregapsize = sp->index1 - sp->index0;
+	}
+/*	trackp[track].padsecs = xxx*/
+
+	trackp[track].isecsize = sp->secsize;
+	trackp[track].secsize = sp->secsize;
+	trackp[track].flags = sp->flags | trackp[0].flags;
+
+	trackp[track].secspt = 0;	/* transfer size is set up in set_trsizes() */
+/*	trackp[track].pktsize = pktsize; */
+	trackp[track].pktsize = 0;
+	trackp[track].trackno = sp->track;
+	trackp[track].sectype = sp->sectype;
+
+	trackp[track].dataoff = sp->dataoff;
+	trackp[track].tracktype = sp->tracktype;
+	trackp[track].dbtype = sp->dbtype;
+
+	if (track == 1) {
+		trackp[0].tracktype &= ~TOC_MASK;
+		trackp[0].tracktype |= sp->tracktype;
+
+		if (xdebug > 1) {
+			printf("Track %d Tracktype %X\n",
+					0, trackp[0].tracktype);
+		}
+	}
+	if (xdebug > 1) {
+		printf("Track %d Tracktype %X\n",
+				track, trackp[track].tracktype);
+	}
+	trackp[track].nindex = 1;
+	trackp[track].tindex = 0;
+
+	if (xdebug > 1) {
+		printf("Track %d flags 0x%08X\n", 0, trackp[0].flags);
+		printf("Track %d flags 0x%08X\n", track, trackp[track].flags);
+	}
+}
+
+/*--------------------------------------------------------------------------*/
+static keyw_t *
+lookup(char *word, keyw_t table[])
+{
+	register keyw_t	*kp = table;
+
+	while (kp->k_name) {
+		if (streql(kp->k_name, word))
+			return (kp);
+		kp++;
+	}
+	return (NULL);
+}
+
+/*--------------------------------------------------------------------------*/
+/*
+ * Parser low level functions start here...
+ */
+
+static void 
+wdebug()
+{
+/*		printf("WORD: '%s' rest '%s'\n", word, peekword());*/
+		printf("WORD: '%s' rest '%s'\n", linep, peekword());
+		printf("linep %lX peekword %lX end %lX\n",
+			(long)linep, (long)peekword(), (long)&linebuf[linelen]);
+}
+
+static FILE *
+cueopen(char *name)
+{
+	FILE	*f;
+
+	f = fileopen(name, "r");
+	if (f == NULL)
+		comerr("Cannot open '%s'.\n", name);
+
+	fname = name;
+	return (f);
+}
+
+static char *
+cuename()
+{
+	return (fname);
+}
+
+static char *
+nextline(FILE *f)
+{
+	register int	len;
+
+	do {
+		fillbytes(linebuf, sizeof (linebuf), '\0');
+		len = rols_fgetline(f, linebuf, sizeof (linebuf));
+		if (len < 0)
+			return (NULL);
+		if (len > 0 && linebuf[len-1] == '\r') {
+			linebuf[len-1] = '\0';
+			len--;
+		}
+		linelen = len;
+		lineno++;
+	} while (linebuf[0] == '#');
+
+	olinelen = linelen;
+	linep = linebuf;
+	wordendp = linep;
+	wordendc = *linep;
+
+	return (linep);
+}
+
+static void 
+ungetline()
+{
+	linelen = olinelen;
+	linep = linebuf;
+	*wordendp = wordendc;
+	wordendp = linep;
+	wordendc = *linep;
+}
+
+static char *
+skipwhite(const char *s)
+{
+	register const Uchar	*p = (const Uchar *)s;
+
+	while (*p) {
+		if (!isspace(*p))
+			break;
+		p++;
+	}
+	return ((char *)p);
+}
+
+static char *
+peekword()
+{
+	return (&wordendp[1]);
+}
+
+static char *
+lineend()
+{
+	return (&linebuf[linelen]);
+}
+
+static char *
+markword(char *delim)
+{
+	register	BOOL	quoted = FALSE;
+	register	Uchar	c;
+	register	Uchar	*s;
+	register	Uchar	*from;
+	register	Uchar	*to;
+
+	for (s = (Uchar *)linep; (c = *s) != '\0'; s++) {
+		if (c == '"') {
+			quoted = !quoted;
+/*			strcpy((char *)s, (char *)&s[1]);*/
+			for (to = s, from = &s[1]; *from; ) {
+				c = *from++;
+				if (c == '\\' && quoted && (*from == '\\' || *from == '"'))
+					c = *from++;
+				*to++ = c;
+			}
+			*to = '\0';
+			c = *s;
+linelen--;
+		}
+		if (!quoted && isspace(c))
+			break;
+		if (!quoted && strchr(delim, c) && s > (Uchar *)linep)
+			break;
+	}
+	wordendp = (char *)s;
+	wordendc = (char)*s;
+	*s = '\0';
+
+	return (linep);
+}
+
+static char *
+getnextitem(char *delim)
+{
+	*wordendp = wordendc;
+
+	linep = skipwhite(wordendp);
+	return (markword(delim));
+}
+
+static char *
+neednextitem(char *delim)
+{
+	char	*olinep = linep;
+	char	*nlinep;
+
+	nlinep = getnextitem(delim);
+
+	if ((olinep == nlinep) || (*nlinep == '\0'))
+		cueabort("Missing text");
+
+	return (nlinep);
+}
+
+static char *
+nextword()
+{
+	return (getnextitem(worddelim));
+}
+
+static char *
+needword()
+{
+	return (neednextitem(worddelim));
+}
+
+static char *
+curword()
+{
+	return (linep);
+}
+
+static char *
+nextitem()
+{
+	return (getnextitem(nulldelim));
+}
+
+static char *
+needitem()
+{
+	return (neednextitem(nulldelim));
+}
+
+static void 
+checkextra()
+{
+	if (peekword() < lineend())
+		cueabort("Extra text '%s'", peekword());
+}
+
+/* VARARGS1 */
+static void cueabort(const char *fmt, ...)
+{
+	va_list	args;
+  va_start(args, fmt);
+  vfprintf(stderr, fmt, args);
+	va_end(args);
+  fprintf(stderr, " on line %d in '%s'.\n", lineno, fname);
+  exit(EXIT_FAILURE);
+}
diff --git a/wodim/defaults.c b/wodim/defaults.c
new file mode 100644
index 0000000..a09da6c
--- /dev/null
+++ b/wodim/defaults.c
@@ -0,0 +1,139 @@
+/* 
+ * Copyright 2006 Eduard Bloch 
+ *
+ * This code emulates the interface of the original defaults.c file. However,
+ * it improves its behaviour and deals with corner cases: prepended and
+ * trailing spaces on variable and value, no requirement for using TABs
+ * anymore. No requirements to insert dummy values like -1 or "".
+ *
+ */
+/*
+ * 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.
+ */
+
+#include <mconfig.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <deflts.h>
+#include <ctype.h>
+#include <string.h>
+
+#define CFGPATH "/etc/wodim.conf"
+/* The better way would be exporting the meta functions to getnum.h or so */
+extern int	getnum(char *arg, long *valp);
+
+void 
+cdr_defaults(char **p_dev_name, int *p_speed, long *p_fifosize, 
+					char **p_drv_opts)
+{
+	char *t; /* tmp */
+	int wc=0;
+	char loc[256], sSpeed[11], sFs[11], sOpts[81];
+	char *devcand=NULL;
+
+  cfg_open(CFGPATH);
+
+	if(p_dev_name && *p_dev_name)
+		devcand=*p_dev_name;
+	else if(NULL!=(t=getenv("CDR_DEVICE")))
+		devcand=t;
+	else if(NULL!=(t=cfg_get("CDR_DEVICE")))
+		devcand=strdup(t); /* needs to use it as a key later, same stat. memory */
+
+	if(devcand && NULL != (t=cfg_get(devcand))) {
+		/* extract them now, may be used later */
+		wc=sscanf(t, "%255s %10s %10s %80s", loc, sSpeed, sFs, sOpts);
+	}
+
+	if(p_dev_name) {
+		if(wc>0)
+			*p_dev_name = strdup(loc);
+		else if(devcand) /* small mem. leak possible, does not matter, checks for that would require more code size than we loose */
+			*p_dev_name=strdup(devcand);
+	}
+	if(p_speed) { /* sth. to write back */
+		char *bad;
+		int cfg_speed=-1;
+
+		/* that value may be used twice */
+		if(NULL!=(t=cfg_get("CDR_SPEED"))) {
+			cfg_speed=strtol(t,&bad,10);
+			if(*bad || cfg_speed<-1) {
+				fprintf(stderr, "Bad default CDR_SPEED setting (%s).\n", t);
+				exit(EXIT_FAILURE);
+			}
+		}
+
+		if(*p_speed>0) { 
+			/* ok, already set by the program arguments */
+		}
+		else if(NULL!=(t=getenv("CDR_SPEED"))) {
+			*p_speed=strtol(t,&bad,10);
+			if(*bad || *p_speed<-1) {
+				fprintf(stderr, "Bad CDR_SPEED environment (%s).\n", t);
+				exit(EXIT_FAILURE);
+			}
+		}
+		else if(wc>1 && *sSpeed) {
+			*p_speed=strtol(sSpeed, &bad, 10);
+			if(*bad || *p_speed<-1) {
+				fprintf(stderr, "Bad speed (%s) in the config, drive description.\n", sSpeed);
+				exit(EXIT_FAILURE);
+			}
+			if(*p_speed==-1) 
+				/* that's autodetect, use the config default as last ressort */
+				*p_speed=cfg_speed;
+		}
+		else 
+			*p_speed=cfg_speed;
+	}
+	if(p_fifosize) { /* sth. to write back */
+		if(*p_fifosize>0) { 
+			/* ok, already set by the user */
+		}
+		else if(NULL!=(t=getenv("CDR_FIFOSIZE"))) {
+			if(getnum(t, p_fifosize)!=1 || *p_fifosize<-1) {
+				fprintf(stderr, "Bad CDR_FIFOSIZE environment (%s).\n", t);
+				exit(EXIT_FAILURE);
+			}
+		}
+		else if(wc>2 && *sFs && strcmp("-1", sFs)) {
+			if(getnum(sFs, p_fifosize)!=1 || *p_fifosize<-1) {
+				fprintf(stderr, "Bad fifo size (%s) in the config, device description.\n", sFs);
+				exit(EXIT_FAILURE);
+			}
+		}
+		else if(NULL!=(t=cfg_get("CDR_FIFOSIZE"))) {
+			if(getnum(t, p_fifosize)!=1 || *p_fifosize<-1) {
+				fprintf(stderr, "Bad speed default setting (%s).\n", t);
+				exit(EXIT_FAILURE);
+			}
+		}
+		if(NULL!=(t=cfg_get("CDR_MAXFIFOSIZE"))) {
+			long max;
+			if(getnum(t, &max)!=1 || *p_fifosize<-1) {
+				fprintf(stderr, "Bad CDR_MAXFIFOSIZE setting (%s).\n", t);
+				exit(EXIT_FAILURE);
+			}
+			if(*p_fifosize>max)
+				*p_fifosize=max;
+		}
+	}
+
+	if(p_drv_opts && !*p_drv_opts && wc>3 && strcmp(sOpts, "\"\""))
+		*p_drv_opts=strdup(sOpts);
+
+  cfg_close();
+
+}
diff --git a/wodim/defaults.h b/wodim/defaults.h
new file mode 100644
index 0000000..3a5c8f8
--- /dev/null
+++ b/wodim/defaults.h
@@ -0,0 +1,14 @@
+/* 
+ * Copyright 2006 Eduard Bloch 
+ *
+ * This code emulates the interface of the original defaults.c file. However,
+ * it improves its behaviour and deals with corner cases: prepended and
+ * trailing spaces on variable and value, no requirement for using TABs
+ * anymore. No requirements to insert dummy values like -1 or "".
+ *
+ */
+#ifndef _DEFAULTS_H_
+#define _DEFAULTS_H_
+extern int	getnum(char *arg, long *valp);
+void cdr_defaults(char **p_dev_name, int *p_speed, long *p_fifosize, char **p_drv_opts);
+#endif
diff --git a/wodim/diskid.c b/wodim/diskid.c
new file mode 100644
index 0000000..70675a3
--- /dev/null
+++ b/wodim/diskid.c
@@ -0,0 +1,522 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)diskid.c	1.37 04/03/02 Copyright 1998-2004 J. Schilling */
+/*
+ *	Disk Idientification Method
+ *
+ *	Copyright (c) 1998-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.
+ */
+
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <standard.h>
+#include <utypes.h>
+
+#include "wodim.h"
+
+void	pr_manufacturer(msf_t *mp, BOOL rw, BOOL audio);
+static	struct disk_man *man_ptr(msf_t *mp);
+int	manufacturer_id(msf_t *mp);
+long	disk_rcap(msf_t *mp, long maxblock, BOOL rw, BOOL audio);
+
+struct disk_man {
+	msf_t	mi_msf;
+	char	mi_num;
+	char	*mi_name;
+};
+
+/*
+ * Illegal (old) Manufacturer.
+ */
+static	char	m_ill[]   = "Unknown old Manufacturer code";
+static	char	m_illrw[] = "Illegal Manufacturer code";
+
+/*
+ * Permanent codes.
+ */
+static	char	m_kingpro[]	= "King Pro Mediatek Inc.";
+static	char	m_custpo[]	= "Customer Pressing Oosterhout";
+static	char	m_taeil[]	= "Taeil Media Co.,Ltd.";
+static	char	m_doremi[]	= "Doremi Media Co., Ltd.";
+static	char	m_xcitec[]	= "Xcitec Inc.";
+static	char	m_leaddata[]	= "Lead Data Inc.";
+static	char	m_fuji[]	= "FUJI Photo Film Co., Ltd.";
+static	char	m_hitachi[]	= "Hitachi Maxell, Ltd.";
+static	char	m_kodakjp[]	= "Kodak Japan Limited";
+static	char	m_mitsui[]	= "Mitsui Chemicals, Inc.";
+static	char	m_pioneer[]	= "Pioneer Video Corporation";
+static	char	m_plasmon[]	= "Plasmon Data systems Ltd.";
+static	char	m_princo[]	= "Princo Corporation";
+static	char	m_ricoh[]	= "Ricoh Company Limited";
+static	char	m_skc[]		= "SKC Co., Ltd.";
+static	char	m_tyuden[]	= "Taiyo Yuden Company Limited";
+static	char	m_tdk[]		= "TDK Corporation";
+static	char	m_mitsubishi[]	= "Mitsubishi Chemical Corporation";
+static	char	m_auvistar[]	= "Auvistar Industry Co.,Ltd.";
+static	char	m_gigastore[]	= "GIGASTORAGE CORPORATION";
+static	char	m_fornet[]	= "FORNET INTERNATIONAL PTE LTD.";
+static	char	m_cmc[]		= "CMC Magnetics Corporation";
+static	char	m_odm[]		= "Optical Disc Manufacturing Equipment";
+static	char	m_ritek[]	= "Ritek Co.";
+
+/*
+ * Tentative codes.
+ */
+static	char	m_bestdisk[]	= "Bestdisc Technology Corporation";
+static	char	m_wealth_fair[]	= "WEALTH FAIR INVESTMENT LIMITED";
+static	char	m_general_mag[]	= "General Magnetics Ld";
+static	char	m_mpo[]		= "MPO";
+static	char	m_jvc[]		= "VICTOR COMPANY OF JAPAN, LIMITED";
+static	char	m_vivistar[]	= "VIVASTAR AG";
+static	char	m_taroko[]	= "TAROKO INTERNATIONAL CO.,LTD.";
+static	char	m_unidisc[]	= "UNIDISC TECHNOLOGY CO.,LTD";
+static	char	m_hokodig[]	= "Hong Kong Digital Technology Co., Ltd.";
+static	char	m_viva[]	= "VIVA MAGNETICS LIMITED";
+static	char	m_hile[]	= "Hile Optical Disc Technology Corp.";
+static	char	m_friendly[]	= "Friendly CD-Tek Co.";
+static	char	m_soundsound[]	= "Sound Sound Multi-Media Development Limited";
+static	char	m_kdg[]		= "kdg mediatech AG";
+static	char	m_seantram[]	= "Seantram Technology Inc.";
+static	char	m_eximpo[]	= "EXIMPO";
+static	char	m_delphi[]	= "DELPHI TECHNOLOGY INC.";
+static	char	m_harmonic[]	= "Harmonic Hall Optical Disc Ltd.";
+static	char	m_guannyinn[]	= "Guann Yinn Co.,Ltd.";
+static	char	m_optime[]	= "Opti.Me.S. S.p.A.";
+static	char	m_nacar[]	= "Nacar Media srl";
+static	char	m_optrom[]	= "OPTROM.INC.";
+static	char	m_audiodis[]	= "AUDIO DISTRIBUTORS CO., LTD.";
+static	char	m_acer[]	= "Acer Media Technology, Inc.";
+static	char	m_woongjin[]	= "Woongjin Media corp";
+static	char	m_infodisk[]	= "INFODISC Technology Co., Ltd.";
+static	char	m_unitech[]	= "UNITECH JAPAN INC.";
+static	char	m_ams[]		= "AMS Technology Inc.";
+static	char	m_vanguard[]	= "Vanguard Disc Inc.";
+static	char	m_grandadv[]	= "Grand Advance Technology Ltd.";
+static	char	m_digitalstor[]	= "DIGITAL STORAGE TECHNOLOGY CO.,LTD";
+static	char	m_matsushita[]	= "Matsushita Electric Industrial Co.,Ltd.";
+static	char	m_albrechts[]	= "CDA Datenträger Albrechts GmbH.";
+static	char	m_xalbrechts[]	= "??? CDA Datenträger Albrechts GmbH.";
+
+static	char	m_prodisc[]	= "Prodisc Technology Inc.";
+static	char	m_postech[]	= "POSTECH Corporation";
+#ifdef	used
+static	char	m_ncolumbia[]	= "NIPPON COLUMBIA CO.,LTD.";
+#endif
+static	char	m_odc[]		= "OPTICAL DISC CORPRATION";
+static	char	m_sony[]	= "SONY Corporation";
+static	char	m_cis[]		= "CIS Technology Inc.";
+static	char	m_csitaly[]	= "Computer Support Italy s.r.l.";
+static	char	m_mmmm[]	= "Multi Media Masters & Machinary SA";
+
+/*
+ * Guessed codes.
+ */
+/*static	char	m_seantram[]	= "Seantram Technology Inc.";*/
+static	char	m_advanced[]	= "Advanced Digital Media";
+static	char	m_moser[]	= "Moser Baer India Limited";
+static	char	m_nanya[]	= "NAN-YA Plastics Corporation";
+static	char	m_shenzen[]	= "SHENZEN SG&GAST DIGITAL OPTICAL DISCS";
+
+static	struct disk_man notable =
+	{{00, 00, 00},  -1, "unknown (not in table)" };
+
+/*
+ * Old (illegal) code table. It lists single specific codes (97:xx:yy).
+ */
+static	struct disk_man odman[] = {
+	/*
+	 * Illegal (old) codes.
+	 */
+	{{97, 25, 00}, 80, "ILLEGAL OLD CODE: TDK ???" },
+	{{97, 25, 15},  0, m_ill },
+	{{97, 27, 00}, 81, "ILLEGAL OLD CODE: Old Ritek Co.???" },
+	{{97, 27, 25},  0, m_ill },
+	{{97, 30, 00},  0, m_ill },
+	{{97, 33, 00}, 82, "ILLEGAL OLD CODE: Old CDA Datenträger Albrechts GmbH." },
+	{{97, 35, 44},  0, m_ill },
+	{{97, 39, 00},  0, m_ill },
+	{{97, 45, 36}, 83, "ILLEGAL OLD CODE: Old Kodak Photo CD" },
+	{{97, 47, 00},  0, m_ill },
+	{{97, 47, 30},  0, m_ill },
+	{{97, 48, 14},  0, m_ill },
+	{{97, 48, 33},  0, m_ill },
+	{{97, 49, 00},  0, m_ill },
+	{{97, 54, 00},  0, m_ill },
+	{{97, 55, 06},  0, m_ill },
+	{{97, 57, 00},  0, m_ill },
+	/*
+	 * List end marker
+	 */
+	{{00, 00, 00}, 0, NULL },
+};
+
+#define	noman	(sizeof (oman)/sizeof (oman[0]))
+
+/*
+ * Actual code table. It lists code ranges (97:xx:y0 - 97:xx:y9).
+ *
+ * Note that dp->mi_msf.msf_frame needs to be always rounded down
+ * to 0 even for media that has e.g. 97:27/01 in the official table.
+ */
+static	struct disk_man dman[] = {
+	/*
+	 * Permanent codes.
+	 */
+
+	{{97, 22, 10}, 53, m_seantram },
+	{{97, 15, 00}, 26, m_tdk },
+	{{97, 49, 30}, 47, m_optime },
+	{{97, 28, 00}, 47, m_optime },
+	{{97, 28, 40}, 36, m_kingpro },
+	{{97, 23, 60}, 49, m_custpo },
+	{{97, 29, 00}, 37, m_taeil },
+	{{97, 26, 10}, 19, m_postech },
+	{{97, 47, 40}, 19, m_postech },
+	{{97, 24, 10}, 24, m_sony },
+/*	{{97, 46, 10}, 24, m_sony },*/
+	{{97, 23, 10}, 33, m_doremi },
+	{{97, 25, 60}, 30, m_xcitec },
+	{{97, 45, 60}, 30, m_xcitec },
+	{{97, 26, 50}, 10, m_leaddata },
+	{{97, 48, 60}, 10, m_leaddata },
+	{{97, 26, 40},  6, m_fuji },
+	{{97, 46, 40},  6, m_fuji },
+	{{97, 25, 20},  8, m_hitachi },
+	{{97, 47, 10},  8, m_hitachi },
+	{{97, 27, 40},  9, m_kodakjp },
+	{{97, 48, 10},  9, m_kodakjp },
+	{{97, 27, 50}, 12, m_mitsui },
+	{{97, 48, 50}, 12, m_mitsui },
+	{{97, 27, 30}, 17, m_pioneer },
+	{{97, 48, 30}, 17, m_pioneer },
+	{{97, 27, 10}, 18, m_plasmon },
+	{{97, 48, 20}, 18, m_plasmon },
+	{{97, 27, 20}, 20, m_princo },
+	{{97, 47, 20}, 20, m_princo },
+	{{97, 27, 60}, 21, m_ricoh },
+	{{97, 48, 00}, 21, m_ricoh },
+	{{97, 26, 20}, 23, m_skc },
+	{{97, 24, 00}, 25, m_tyuden },
+	{{97, 46, 00}, 25, m_tyuden },
+	{{97, 32, 00}, 26, m_tdk },
+	{{97, 49, 00}, 26, m_tdk },
+	{{97, 34, 20}, 11, m_mitsubishi },
+	{{97, 50, 20}, 11, m_mitsubishi },
+	{{97, 28, 30},  1, m_auvistar },
+	{{97, 46, 50},  1, m_auvistar },
+	{{97, 28, 10},  7, m_gigastore },
+	{{97, 49, 10},  7, m_gigastore },
+	{{97, 26, 00},  5, m_fornet },
+	{{97, 45, 00},  5, m_fornet },
+	{{97, 26, 60},  3, m_cmc },
+	{{97, 46, 60},  3, m_cmc },
+	{{97, 21, 40}, 16, m_odm },
+	{{97, 31, 00}, 22, m_ritek },
+	{{97, 47, 50}, 22, m_ritek },
+	{{97, 28, 20}, 13, m_mmmm },
+	{{97, 46, 20}, 13, m_mmmm },
+	{{97, 32, 10}, 27, m_prodisc },
+
+	/*
+	 * Tentative codes.
+	 */
+	{{97, 21, 30}, 67, m_bestdisk },
+	{{97, 18, 10}, 66, m_wealth_fair },
+	{{97, 29, 50}, 65, m_general_mag },
+	{{97, 25, 00}, 64, m_mpo },		/* in reality 25/01    */
+	{{97, 49, 40}, 63, m_jvc },
+	{{97, 23, 40}, 63, m_jvc },
+	{{97, 25, 40}, 62, m_vivistar },
+	{{97, 18, 60}, 61, m_taroko },
+	{{97, 29, 20}, 60, m_unidisc },
+	{{97, 46, 10}, 59, m_hokodig },		/* XXX was m_sony */
+	{{97, 22, 50}, 59, m_hokodig },
+	{{97, 29, 40}, 58, m_viva },
+	{{97, 29, 30}, 57, m_hile },
+	{{97, 51, 50}, 57, m_hile },
+	{{97, 28, 60}, 56, m_friendly },
+	{{97, 21, 50}, 55, m_soundsound },
+	{{97, 24, 40}, 54, m_kdg },
+	{{97, 22, 30}, 52, m_eximpo },
+	{{97, 28, 50}, 51, m_delphi },
+	{{97, 29, 00}, 50, m_harmonic },
+	{{97, 15, 10}, 22, m_ritek },
+	{{97, 45, 50}, 48, m_guannyinn },
+	{{97, 24, 50}, 48, m_guannyinn },
+	{{97, 23, 20}, 46, m_nacar },
+	{{97, 23, 50}, 45, m_optrom },
+	{{97, 23, 30}, 44, m_audiodis },
+	{{97, 22, 60}, 43, m_acer },
+	{{97, 45, 20}, 43, m_acer },
+	{{97, 15, 20}, 11, m_mitsubishi },
+	{{97, 22, 00}, 39, m_woongjin },
+	{{97, 25, 30}, 40, m_infodisk },
+	{{97, 51, 20}, 40, m_infodisk },
+	{{97, 24, 30}, 41, m_unitech },
+	{{97, 25, 50}, 42, m_ams },
+	{{97, 29, 10}, 38, m_vanguard },
+	{{97, 50, 10}, 38, m_vanguard },
+	{{97, 16, 30}, 35, m_grandadv },
+	{{97, 31, 30}, 35, m_grandadv },
+	{{97, 51, 10}, 35, m_grandadv },
+	{{97, 49, 20}, 36, m_kingpro },
+	{{97, 27, 00}, 34, m_digitalstor },	/* in reality 27/01    */
+	{{97, 48, 40}, 34, m_digitalstor },	/* XXX was m_ncolumbia */
+	{{97, 23, 00}, 31, m_matsushita },
+	{{97, 49, 60}, 31, m_matsushita },
+	{{97, 30, 10}, 32, m_albrechts },	/* XXX was m_ncolumbia */
+	{{97, 50, 30}, 32, m_albrechts },
+	{{97, 47, 60}, 27, m_prodisc },
+/*	{{97, 30, 10}, 14, m_ncolumbia },*/
+/*	{{97, 48, 40}, 14, m_ncolumbia },*/
+	{{97, 26, 30}, 15, m_odc },
+	{{97, 22, 40},  2, m_cis },
+	{{97, 45, 40},  2, m_cis },
+	{{97, 24, 20},  4, m_csitaly },
+	{{97, 46, 30},  4, m_csitaly },
+
+	/*
+	 * Guessed codes.
+	 */
+	{{97, 20, 10}, 32, m_xalbrechts },			/* XXX guess */
+/*	{{97, 23, 40}, 32, m_xalbrechts },*/			/* Really is JVC */
+
+	/*
+	 * New guessed codes (2002 ff.).
+	 * Id code >= 68 referres to a new manufacturer.
+	 */
+#define	I_GUESS	105
+	{{97, 22, 20}, 68, m_advanced },
+	{{97, 42, 20}, 68, m_advanced },
+	{{97, 24, 60}, 50, m_harmonic },
+	{{97, 17, 00}, 69, m_moser },
+	{{97, 15, 30}, 70, m_nanya },
+	{{97, 16, 20}, 71, m_shenzen },
+	{{97, 45, 10}, 41, m_unitech },
+
+	/*
+	 * List end marker
+	 */
+	{{00, 00, 00},  0, NULL },
+};
+
+#define	ndman	(sizeof (dman)/sizeof (dman[0]))
+
+static struct disk_man *
+man_ptr(msf_t *mp)
+{
+	struct disk_man * dp;
+	int	frame;
+	int	type;
+
+	type = mp->msf_frame % 10;
+	frame = mp->msf_frame - type;
+
+	dp = odman;
+	while (dp->mi_msf.msf_min != 0) {
+		if (mp->msf_min == dp->mi_msf.msf_min &&
+				mp->msf_sec == dp->mi_msf.msf_sec &&
+				mp->msf_frame == dp->mi_msf.msf_frame) {
+			return (dp);
+		}
+		dp++;
+	}
+	dp = dman;
+	while (dp->mi_msf.msf_min != 0) {
+		if (mp->msf_min == dp->mi_msf.msf_min &&
+				mp->msf_sec == dp->mi_msf.msf_sec &&
+				frame == dp->mi_msf.msf_frame) {
+			/*
+			 * Note that dp->mi_msf.msf_frame is always rounded
+			 * down to 0 even for media that has 97:27/01 in the
+			 * official table.
+			 */
+			return (dp);
+		}
+		dp++;
+	}
+	return (NULL);
+}
+
+void pr_manufacturer(msf_t *mp, BOOL rw, BOOL audio)
+{
+	struct disk_man * dp;
+	struct disk_man xdman;
+	int	type;
+	char	*tname;
+
+/*	printf("pr_manufacturer rw: %d audio: %d\n", rw, audio);*/
+
+	type = mp->msf_frame % 10;
+	if (type < 5) {
+		tname = "Long strategy type (Cyanine, AZO or similar)";
+	} else {
+		tname = "Short strategy type (Phthalocyanine or similar)";
+	}
+	if (rw) {
+		tname = "Phase change";
+	}
+
+	dp = man_ptr(mp);
+	if (dp != NULL) {
+		if (dp->mi_num == 0 || dp->mi_num >= 80) {
+			if (!rw) {
+				tname = "unknown dye (old id code)";
+			} else {
+				xdman = *dp;
+				dp = &xdman;
+				dp->mi_num = 0;
+				dp->mi_name = m_illrw;
+			}
+		}
+	} else {
+		tname = "unknown dye (reserved id code)";
+		dp = &notable;
+	}
+	printf("Disk type:    %s\n", tname);
+	printf("Manuf. index: %d\n", dp->mi_num);
+	printf("Manufacturer: %s\n", dp->mi_name);
+
+	if (mp->msf_min != 97)	/* This may be garbage ATIP from a DVD */
+		return;
+
+	if (dp >= &dman[I_GUESS] && dp < &dman[ndman]) {
+		printf("Manufacturer is guessed because of the orange forum embargo.\n");
+		printf("The orange forum likes to get money for recent information.\n");
+		printf("The information for this media may not be correct.\n");
+	}
+	if (dp == &notable) {
+		printf("Manufacturer is unknown because of the orange forum embargo.\n");
+		printf("As the orange forum likes to get money for recent information,\n");
+		printf("it may be that this media does not use illegal manufacturer coding.\n");
+	}
+}
+
+int manufacturer_id(msf_t *mp)
+{
+	struct disk_man * dp;
+
+	dp = man_ptr(mp);
+	if (dp != NULL)
+		return (dp->mi_num);
+	return (-1);
+}
+
+struct disk_rcap {
+	msf_t	ci_msf;				/* Lead in start time	    */
+	long	ci_cap;				/* Lead out start time	    */
+	long	ci_rcap;			/* Abs max lead out start   */
+};
+
+static	struct disk_rcap rcap[] = {
+
+#ifdef	__redbook_only__
+	{{97, 35, 44}, 359849, 404700 },	/*! Unknown 99 min (89:58/00)*/
+#endif
+	{{97, 35, 44}, 359849, 449700 },	/*! Unknown 99 min (99:58/00) */
+	{{97, 31, 00}, 359849, 368923 },	/*! Arita CD-R 80	    */
+	{{97, 26, 50}, 359849, 369096 },	/*! Lead Data CD-R 80	    */
+	{{97, 26, 12}, 359849, 368000 },	/*X POSTECH 80 Min	    */
+	{{97, 25, 00}, 359849, 374002 },	/* TDK 80 Minuten	    */
+	{{97, 20, 14}, 359700, 376386 },	/*! Albrechts DataFile Plus */
+	{{97, 35, 44}, 359100, 368791 },	/*! NoName BC-1 700 Mb/80 Min */
+
+	{{97, 26, 60}, 337350, 349030 },	/* Koch grün CD-R74PRO	    */
+	{{97, 26, 50}, 337050, 351205 },	/* Saba			    */
+	{{97, 26, 00}, 337050, 351411 },	/*!DGN (FORNET)		    */
+	{{97, 22, 40}, 336631, 349971 },	/* Targa grün CD-R74	    */
+	{{97, 26, 50}, 336631, 351727 },	/*! Sunstar (Lead Data)	    */
+	{{97, 26, 55}, 336631, 350474 },	/*! NoName ZAP (Lead Data)  */
+
+	{{97, 27, 28}, 336601, 346489 },	/*! BTC CD-R (Princo)	    */
+	{{97, 27, 30}, 336601, 351646 },	/*! Pioneer blau CDM-W74S   */
+	{{97, 27, 31}, 336601, 351379 },	/* Pioneer blau CDM-W74S    */
+	{{97, 27, 33}, 336601, 347029 },	/*! Pioneer braun CDM-V74S  */
+	{{97, 26, 40}, 336225, 346210 },	/* Fuji Silver Disk	    */
+	{{97, 28, 10}, 336225, 348757 },	/*!GigaStorage Cursor CD-R  */
+	{{97, 31, 00}, 336225, 345460 },	/* Arita grün		    */
+	{{97, 25, 28}, 336075, 352879 },	/* Maxell gold CD-R74G	    */
+	{{97, 24, 01}, 336075, 346856 },	/*!Philips Premium Silver   */
+	{{97, 24, 00}, 336075, 346741 },	/* Philips grün CD-R74	    */
+
+	{{97, 22, 41}, 335206, 349385 },	/* Octek grün		    */
+	{{97, 34, 20}, 335100, 342460 },	/* Verbatim DataLifePlus    */
+	{{97, 33, 00}, 335100, 344634 },	/*!ITS Singapore (braun/grün) */
+	{{97, 32, 19}, 335100, 343921 },	/*!Prodisc silber/silber    */
+	{{97, 25, 21}, 335100, 346013 },	/* Maxell grün CD-R74XL	    */
+	{{97, 27, 00}, 335100, 353448 },	/* TDK grün CD-RXG74	    */
+	{{97, 27, 31}, 335100, 351862 },	/*!Maxell CD-R74MU (Musik)  */
+	{{97, 27, 33}, 335100, 351336 },	/* Pioneer RDD-74A	    */
+
+	{{97, 26, 60}, 334259, 349036 },	/* BASF grün		    */
+	{{97, 28, 21}, 333976, 348217 },	/*! Noname-B (MMMM)	    */
+	{{97, 28, 20}, 333976, 346485 },	/* Koch  grün  CD-R74 PRO   */
+	{{97, 32, 00}, 333975, 345736 },	/* Imation 3M		    */
+	{{97, 32, 00}, 333975, 348835 },	/* TDK Reflex X	    CD-R74  */
+	{{97, 30, 18}, 333899, 344857 },	/* HiSpace  grün	    */
+	{{97, 27, 66}, 333750, 352726 },	/*!Philips Megalife (Musik) */
+	{{97, 28, 43}, 333750, 345344 },	/*!MMore CD-R		    */
+	{{97, 27, 65}, 333750, 348343 },	/* Ricoh gold		    */
+
+	{{97, 27, 00}, 333750, 336246 },	/* BestMedia grün   CD-R74  */
+	{{97, 27, 28}, 333491, 347473 },	/* Fuji grün (alt)	    */
+	{{97, 24, 48}, 333491, 343519 },	/* BASF (alt)		    */
+	{{97, 27, 55}, 333235, 343270 },	/* Teac gold CD-R74	    */
+	{{97, 27, 45}, 333226, 343358 },	/* Kodak gold		    */
+	{{97, 28, 20}, 333226, 346483 },	/* SAST grün		    */
+	{{97, 27, 45}, 333226, 343357 },	/* Mitsumi gold		    */
+	{{97, 28, 25}, 333226, 346481 },	/* Cedar Grün		    */
+	{{97, 23, 00}, 333226, 346206 },	/* Fuji grün (alt)	    */
+	{{97, 33, 00}, 333225, 349623 },	/* DataFile Albrechts	    */
+	{{97, 24, 24}, 333198, 342536 },	/*!SUN CD Recordable	    */
+
+	{{97, 27, 19}, 332850, 348442 },	/* Plasmon gold PCD-R74	    */
+	{{97, 32, 00}, 96600,  106502 },	/* TDK 80mm (for music only) */
+
+	/*
+	 * List end marker
+	 */
+	{{00, 00, 00}, 0L, 0L },
+};
+
+long 
+disk_rcap(msf_t *mp, long maxblock, BOOL rw, BOOL audio)
+{
+	struct disk_rcap * dp;
+
+	dp = rcap;
+	while (dp->ci_msf.msf_min != 0) {
+		if (mp->msf_min == dp->ci_msf.msf_min &&
+				mp->msf_sec == dp->ci_msf.msf_sec &&
+				mp->msf_frame == dp->ci_msf.msf_frame &&
+				maxblock == dp->ci_cap)
+			return (dp->ci_rcap);
+		dp++;
+	}
+	return (0L);
+}
diff --git a/wodim/drv_7501.c b/wodim/drv_7501.c
new file mode 100644
index 0000000..5083750
--- /dev/null
+++ b/wodim/drv_7501.c
@@ -0,0 +1,1030 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)drv_7501.c	1.16 05/05/16 Copyright 2003-2005 J. Schilling */
+/*
+ *	Device driver for the Masushita CW-7501
+ *
+ *	Copyright (c) 2003-2005 J. Schilling
+ *
+ * Mode Pages:
+ *	0x01	error recovery		Seite 100
+ *	0x02	disconnect/reconnect	Seite 107
+ *	0x0D	CD-ROM device parameter	Seite 110
+ *	0x0E	CD-ROM Audio control	Seite 112
+ *	0x20	Speed & Tray position	Seite 115
+ *	0x21	Media catalog number	Seite 124
+ *	0x22	ISRC			Seite 125
+ *	0x23	Dummy/Write Information	Seite 126
+ *	0x24	CD-R disk information	Seite 127
+ */
+/*
+ * 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.
+ */
+
+#ifndef	DEBUG
+#define	DEBUG
+#endif
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <standard.h>
+#include <stdxlib.h>
+#include <unixstd.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 <libport.h>
+
+#include "wodim.h"
+
+extern	int	silent;
+extern	int	debug;
+extern	int	verbose;
+extern	int	lverbose;
+extern	int	xdebug;
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct cw7501_mode_page_20 {	/* Speed control */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	speed;
+	Ucbit	res		: 7;
+	Ucbit	traypos		: 1;
+};
+
+#else				/* Motorola byteorder */
+
+struct cw7501_mode_page_20 {	/* Speed control */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	speed;
+	Ucbit	traypos		: 1;
+	Ucbit	res		: 7;
+};
+#endif
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct cw7501_mode_page_21 {	/* MCN */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x12 = 20 Bytes */
+	Ucbit	control		: 4;
+	Ucbit	addr		: 4;
+	Uchar	res_3;
+	Uchar	res_4;
+	Uchar	mcn[15];
+};
+
+#else				/* Motorola byteorder */
+
+struct cw7501_mode_page_21 {	/* MCN */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x12 = 20 Bytes */
+	Ucbit	addr		: 4;
+	Ucbit	control		: 4;
+	Uchar	res_3;
+	Uchar	res_4;
+	Uchar	mcn[15];
+};
+#endif
+
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct cw7501_mode_page_22 {	/* ISRC */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x12 = 20 Bytes */
+	Ucbit	control		: 4;
+	Ucbit	addr		: 4;
+	Uchar	trackno;
+	Uchar	res_4;
+	Uchar	isrc[15];
+};
+
+#else				/* Motorola byteorder */
+
+struct cw7501_mode_page_22 {	/* ISRC */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x12 = 20 Bytes */
+	Ucbit	addr		: 4;
+	Ucbit	control		: 4;
+	Uchar	trackno;
+	Uchar	res_4;
+	Uchar	isrc[15];
+};
+#endif
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct cw7501_mode_page_23 {	/* Dummy / Write information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	res;
+	Ucbit	autopg		: 1;
+	Ucbit	dummy		: 1;
+	Ucbit	res3_72		: 6;
+};
+
+#else				/* Motorola byteorder */
+
+struct cw7501_mode_page_23 {	/* Dummy / Write information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	res;
+	Ucbit	res3_72		: 6;
+	Ucbit	dummy		: 1;
+	Ucbit	autopg		: 1;
+};
+#endif
+
+struct cw7501_mode_page_24 {	/* CD-R Disk information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x0A = 12 Bytes */
+	Uchar	disktype;
+	Uchar	res;
+	Uchar	appl_code[4];
+	Uchar	disk_id[4];
+};
+
+struct cw7501_mode_data {
+	struct scsi_mode_header	header;
+	union cdd_pagex	{
+		struct cw7501_mode_page_20	page20;
+		struct cw7501_mode_page_21	page21;
+		struct cw7501_mode_page_22	page22;
+		struct cw7501_mode_page_23	page23;
+		struct cw7501_mode_page_24	page24;
+	} pagex;
+};
+
+/*
+ * Mode for read track information
+ */
+#define	TI_TRACKINFO_R	0
+#define	TI_NWA		1
+#define	TI_PMA		2
+#define	TI_TRACKINFO	3
+
+struct cw7501_nwa {
+	Uchar	nwa_length[2];
+	Uchar	nwa_res;
+	Uchar	nwa_trackno;
+	Uchar	nwa_nwa[4];
+	Uchar	nwa_freeblocks[4];
+};
+
+struct cw7501_cue {
+	Uchar	cs_ctladr;		/* CTL/ADR for this track	*/
+	Uchar	cs_tno;			/* This track number		*/
+	Uchar	cs_index;		/* Index within this track	*/
+	Uchar	cs_dataform;		/* Data form 			*/
+					/* Bit 0..3 Physical Format	*/
+					/* Bit 4 Alt Copy (SCMS)	*/
+					/* Bit 5 SubC Audio + RAW96 sub */
+	Uchar	cs_extension;		/* Reserved or MCN/ISRC		*/
+	Uchar	cs_min;			/* Absolute time minutes	*/
+	Uchar	cs_sec;			/* Absolute time seconds	*/
+	Uchar	cs_frame;		/* Absolute time frames		*/
+};
+
+
+static	int	cw7501_attach(SCSI *usalp, cdr_t *dp);
+static	int	cw7501_init(SCSI *usalp, cdr_t *dp);
+static	int	cw7501_getdisktype(SCSI *usalp, cdr_t *dp);
+static	int	cw7501_speed_select(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	cw7501_next_wr_addr(SCSI *usalp, track_t *trackp, long *ap);
+static	int	cw7501_write(SCSI *usalp, caddr_t bp, long sectaddr, long size, 
+									 int blocks, BOOL islast);
+static	int	cw7501_write_leadin(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	cw7501_open_track(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	cw7501_close_track(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	cw7501_open_session(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	cw7501_gen_cue(track_t *trackp, void *vcuep, BOOL needgap);
+static	void	fillcue(struct cw7501_cue *cp, int ca, int tno, int idx, 
+							  int dataform, int scms, msf_t *mp);
+static	int	cw7501_send_cue(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	cw7501_fixate(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	cw7501_rezero(SCSI *usalp, int reset, int dwreset);
+static	int	cw7501_read_trackinfo(SCSI *usalp, Uchar *bp, int count, 
+												 int track, int mode);
+static	int	cw7501_write_dao(SCSI *usalp, Uchar *bp, int len, int disktype);
+static	int	cw7501_reserve_track(SCSI *usalp, unsigned long);
+static	int	cw7501_set_mode(SCSI *usalp, int phys_form, int control,
+						int subc, int alt, int trackno, int tindex,
+						int packet_size, int write_mode);
+static	int	cw7501_finalize(SCSI *usalp, int pad, int fixed);
+
+
+cdr_t	cdr_cw7501 = {
+	0, 0,
+	/*
+	 * Prinzipiell geht auch: CDR_PACKET & CDR_SRAW96R
+	 */
+	CDR_TAO|CDR_SAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"cw_7501",
+	"driver for Matsushita/Panasonic CW-7501",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	cw7501_attach,
+	cw7501_init,
+	cw7501_getdisktype,
+	scsi_load,
+	scsi_unload,
+	buf_dummy,				/* RD buffer cap not supp. */
+	cmd_dummy,					/* recovery_needed */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	cw7501_speed_select,
+	select_secsize,
+	cw7501_next_wr_addr,
+	cw7501_reserve_track,
+	cw7501_write,
+	cw7501_gen_cue,
+	cw7501_send_cue,
+	cw7501_write_leadin,
+	cw7501_open_track,
+	cw7501_close_track,
+	cw7501_open_session,
+	cmd_dummy,				/* close seession	*/
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	cw7501_fixate,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+static const char *sd_cw7501_error_str[] = {
+	"\100\201diagnostic failure on ROM",			/* 40 81 */
+	"\100\202diagnostic failure on CPU internal RAM",	/* 40 82 */
+	"\100\203diagnostic failure on BUFFER RAM",		/* 40 83 */
+	"\100\204diagnostic failure on internal SCSI controller",	/* 40 84 */
+	"\100\205diagnostic failure on system mechanism",	/* 40 85 */
+
+	"\210\000Illegal Que Sheet (DAO parameter)",		/* 88 00 */
+	"\211\000Inappropriate command",			/* 89 00 */
+
+	"\250\000Audio Play operation Not in Progress",		/* A8 00 */
+	"\251\000Buffer Overrun",				/* A9 00 */
+
+	"\300\000Unrecordable Disk",				/* C0 00 */
+	"\301\000Illegal Track Status",				/* C1 00 */
+	"\302\000Reserved track Status",			/* C2 00 */
+	"\304\000Illegal Reserve Length for Reserve Track Command",	/* C4 00 */
+	"\304\001Illegal Data Form for Reserve Track Command",	/* C4 01 */
+	"\304\002Unable to Reserve Track, Because Track Mode has been Changed",	/* C4 02 */
+
+	"\305\000Buffer error during recording",		/* C5 00 */
+	"\307\000Disk Style mismatch",				/* C7 00 */
+	"\312\000Power Calibration error",			/* CA 00 */
+	"\313\000Write error (Fatal Error/Time out)",		/* CB 00 */
+	"\314\000Not enough space (Leadin/Leadout space)",	/* CC 00 */
+	"\315\000No track present to finalize",			/* CD 00 */
+	"\317\000Unable to recover damaged disk",		/* CF 00 */
+
+	"\320\000PMA area full (1000 blocks)",			/* D0 00 */
+	"\321\000PCA area full (100 counts)",			/* D1 00 */
+	"\322\000Recovery failed",				/* D2 00 */
+	"\323\000Recovery needed",				/* D3 00 */
+	NULL
+};
+
+static int 
+cw7501_attach(SCSI *usalp, cdr_t *dp)
+{
+	usal_setnonstderrs(usalp, sd_cw7501_error_str);
+	return (0);
+}
+
+static int 
+cw7501_init(SCSI *usalp, cdr_t *dp)
+{
+	return (cw7501_speed_select(usalp, dp, NULL));
+}
+
+static int 
+cw7501_getdisktype(SCSI *usalp, cdr_t *dp)
+{
+	Ulong	maxb = 0;
+	Uchar	buf[256];
+	int	ret;
+	dstat_t	*dsp = dp->cdr_dstat;
+
+	if (xdebug > 0) {
+		usalp->silent++;
+		fillbytes((caddr_t)buf, sizeof (buf), '\0');
+		ret = cw7501_read_trackinfo(usalp, buf, 32, 0, 0);
+		if (ret >= 0)
+		usal_prbytes("TI EXIST-R   (0): ", buf, 32 -usal_getresid(usalp));
+
+		fillbytes((caddr_t)buf, sizeof (buf), '\0');
+		ret = cw7501_read_trackinfo(usalp, buf, 32, 0, 1);
+		if (ret >= 0)
+		usal_prbytes("TI NWA       (1): ", buf, 32 -usal_getresid(usalp));
+
+		fillbytes((caddr_t)buf, sizeof (buf), '\0');
+		ret = cw7501_read_trackinfo(usalp, buf, 32, 0, 2);
+		if (ret >= 0)
+		usal_prbytes("TI PMA       (2): ", buf, 32 -usal_getresid(usalp));
+
+		fillbytes((caddr_t)buf, sizeof (buf), '\0');
+		ret = cw7501_read_trackinfo(usalp, buf, 32, 0, 3);
+		if (ret >= 0)
+		usal_prbytes("TI EXIST-ROM (3): ", buf, 32 -usal_getresid(usalp));
+		usalp->silent--;
+	}
+
+	fillbytes((caddr_t)buf, sizeof (buf), '\0');
+
+	usalp->silent++;
+	ret = cw7501_read_trackinfo(usalp, buf, 12, 0, TI_NWA);
+	if (ret < 0 &&
+			(dsp->ds_cdrflags & (RF_WRITE|RF_BLANK)) == RF_WRITE) {
+
+		/*
+		 * Try to clear the dummy bit to reset the virtual
+		 * drive status. Not all drives support it even though
+		 * it is mentioned in the MMC standard.
+		 */
+		if (lverbose)
+			printf("Trying to clear drive status.\n");
+		cw7501_rezero(usalp, 0, 1);
+		wait_unit_ready(usalp, 60);
+		ret = cw7501_read_trackinfo(usalp, buf, 12, 0, TI_NWA);
+	}
+	usalp->silent--;
+
+	if (ret >= 0) {
+		maxb = a_to_u_4_byte(&buf[8]);
+		if (maxb != 0)
+			maxb -= 150;
+	}
+	dsp->ds_maxblocks = maxb;
+
+	return (drive_getdisktype(usalp, dp));
+}
+
+
+static int 
+cw7501_speed_select(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	struct	scsi_mode_page_header	*mp;
+	char				mode[256];
+	int				len = 20;
+	int				page = 0x20;
+	struct cw7501_mode_page_20	*xp20;
+	struct cw7501_mode_data		md;
+	int				count;
+	int				speed = 1;
+	BOOL				dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp) {
+		speed = *speedp;
+	} else {
+		fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+		if (!get_mode_params(usalp, page, "Speed information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+			return (-1);
+		}
+		if (len == 0)
+			return (-1);
+
+		mp = (struct scsi_mode_page_header *)
+			(mode + sizeof (struct scsi_mode_header) +
+			((struct scsi_mode_header *)mode)->blockdesc_len);
+
+		xp20  = (struct cw7501_mode_page_20 *)mp;
+		speed = xp20->speed;
+	}
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct cw7501_mode_page_20);
+
+	md.pagex.page20.p_code = 0x20;
+	md.pagex.page20.p_len =  0x02;
+	md.pagex.page20.speed = speed;
+
+	if (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2) < 0)
+		return (-1);
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct cw7501_mode_page_23);
+
+	md.pagex.page23.p_code = 0x23;
+	md.pagex.page23.p_len =  0x02;
+	md.pagex.page23.dummy = dummy?1:0;
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+cw7501_next_wr_addr(SCSI *usalp, track_t *trackp, long *ap)
+{
+	struct cw7501_nwa	*nwa;
+	Uchar	buf[256];
+	long	next_addr;
+	int	result = -1;
+
+
+	/*
+	 * Reading info for current track may require doing the read_track_info
+	 * with either the track number (if the track is currently being written)
+	 * or with 0 (if the track hasn't been started yet and is invisible
+	 */
+	nwa = (struct cw7501_nwa *)buf;
+
+	if (trackp != 0 && trackp->track > 0 && is_packet(trackp)) {
+		fillbytes((caddr_t)buf, sizeof (buf), '\0');
+
+		usalp->silent++;
+		result = cw7501_read_trackinfo(usalp, buf, sizeof (*nwa),
+							trackp->trackno,
+							TI_NWA);
+		usalp->silent--;
+	}
+
+	if (result < 0) {
+		if (cw7501_read_trackinfo(usalp, buf, sizeof (*nwa),
+							0, TI_NWA) < 0)
+			return (-1);
+	}
+	if (usalp->verbose)
+		usal_prbytes("track info:", buf,
+				12-usal_getresid(usalp));
+	next_addr = a_to_4_byte(&nwa->nwa_nwa);
+	/*
+	 * XXX Für TAO definitiv notwendig.
+	 * XXX ABhängig von Auto-Pregap?
+	 */
+	/* XXX */ next_addr += 150;
+	if (ap)
+		*ap = next_addr;
+	return (0);
+}
+
+static int 
+cw7501_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 */)
+{
+	if (lverbose > 1 && islast)
+		printf("\nWriting last record for this track.\n");
+
+	return (write_xg0(usalp, bp, 0, size, blocks));
+}
+
+static int 
+cw7501_write_leadin(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uint	i;
+	long	startsec = 0L;
+
+	if (wm_base(dp->cdr_dstat->ds_wrmode) == WM_SAO) {
+		if (debug || lverbose) {
+			printf("Sending CUE sheet...\n");
+			flush();
+		}
+		if ((*dp->cdr_send_cue)(usalp, dp, trackp) < 0) {
+			errmsgno(EX_BAD, "Cannot send CUE sheet.\n");
+			return (-1);
+		}
+
+		/*
+		 * Next writable address function does not work in DAO
+		 * mode for this writer, so we just assume -150.
+		 */
+		startsec = -150;
+		if (debug)
+			printf("SAO startsec: %ld\n", startsec);
+
+		if (trackp[0].flags & TI_TEXT) {
+			errmsgno(EX_BAD, "CD-Text unsupported in CW-7501 - ignoring.\n");
+		} else for (i = 1; i <= trackp->tracks; i++) {
+			trackp[i].trackstart += startsec +150;
+		}
+	}
+	return (0);
+}
+
+static Uchar	db2phys[] = {
+	0x00,			/*  0 2352 bytes of raw data			*/
+	0xFF,			/*  1 2368 bytes (raw data + P/Q Subchannel)	*/
+	0xFF,			/*  2 2448 bytes (raw data + P-W Subchannel)	*/
+	0xFF,			/*  3 2448 bytes (raw data + P-W raw Subchannel)*/
+	0xFF,			/*  4 -    Reserved				*/
+	0xFF,			/*  5 -    Reserved				*/
+	0xFF,			/*  6 -    Reserved				*/
+	0xFF,			/*  7 -    Vendor specific			*/
+	0x02,			/*  8 2048 bytes Mode 1 (ISO/IEC 10149)		*/
+	0x03,			/*  9 2336 bytes Mode 2 (ISO/IEC 10149)		*/
+	0xFF,			/* 10 2048 bytes Mode 2 (CD-ROM XA form 1)	*/
+	0x04,			/* 11 2056 bytes Mode 2 (CD-ROM XA form 1)	*/
+	0xFF,			/* 12 2324 bytes Mode 2 (CD-ROM XA form 2)	*/
+	0x08,			/* 13 2332 bytes Mode 2 (CD-ROM XA 1/2+subhdr)	*/
+	0xFF,			/* 14 -    Reserved				*/
+	0xFF,			/* 15 -    Vendor specific			*/
+};
+
+static int 
+cw7501_open_track(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	struct	scsi_mode_page_header	*mp;
+	Uchar				mode[256];
+	int				len = 0;
+	int				page = 0x23;
+	struct cw7501_mode_page_23	*xp23;
+
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		if (trackp->pregapsize > 0 && (trackp->flags & TI_PREGAP) == 0) {
+			if (lverbose) {
+				printf("Writing pregap for track %d at %ld\n",
+					(int)trackp->trackno,
+					trackp->trackstart-trackp->pregapsize);
+			}
+			/*
+			 * XXX Do we need to check isecsize too?
+			 */
+			pad_track(usalp, dp, trackp,
+				trackp->trackstart-trackp->pregapsize,
+				(Llong)trackp->pregapsize*trackp->secsize,
+					FALSE, 0);
+		}
+		return (0);
+	}
+
+	if (select_secsize(usalp, trackp->secsize) < 0)
+		return (-1);
+
+	if (!get_mode_params(usalp, page, "Dummy/autopg information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		return (-1);
+	}
+	if (len == 0)
+		return (-1);
+
+	mp = (struct scsi_mode_page_header *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	xp23  = (struct cw7501_mode_page_23 *)mp;
+	xp23->autopg = 1;
+	if (!set_mode_params(usalp, "Dummy/autopg page", mode, len, 0, trackp->secsize))
+		return (-1);
+
+	/*
+	 * Set write modes for next track.
+	 */
+	if (cw7501_set_mode(usalp, db2phys[trackp->dbtype & 0x0F],
+			st2mode[trackp->sectype&ST_MASK] | (is_copy(trackp) ? TM_ALLOW_COPY : 0),
+			0, is_scms(trackp) ? 1 : 0,
+			trackp->trackno, 1, 0,
+			/* write mode TAO */ 0x01) < 0)
+		return (-1);
+
+	return (0);
+}
+
+
+static int 
+cw7501_close_track(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		return (0);
+	}
+	return (scsi_flush_cache(usalp, FALSE));
+}
+
+static int 
+cw7501_open_session(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	struct cw7501_mode_data		md;
+	int				count;
+
+	if (select_secsize(usalp, 2048) < 0)
+		return (-1);
+
+	/*
+	 * Disable Auto Pregap when writing in SAO mode.
+	 */
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		struct	scsi_mode_page_header	*mp;
+		Uchar				mode[256];
+		int				len = 0;
+		int				page = 0x23;
+		struct cw7501_mode_page_23	*xp23;
+
+		if (!get_mode_params(usalp, page, "Dummy/autopg information",
+				(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+			return (-1);
+		}
+		if (len == 0)
+			return (-1);
+
+		mp = (struct scsi_mode_page_header *)
+			(mode + sizeof (struct scsi_mode_header) +
+			((struct scsi_mode_header *)mode)->blockdesc_len);
+
+		xp23  = (struct cw7501_mode_page_23 *)mp;
+		xp23->autopg = 0;
+		if (!set_mode_params(usalp, "Dummy/autopg page", mode, len, 0, trackp->secsize))
+			return (-1);
+
+		return (0);
+	}
+
+	/*
+	 * Set Disk Type and Disk ID.
+	 */
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct cw7501_mode_page_24);
+
+	md.pagex.page24.p_code = 0x24;
+	md.pagex.page24.p_len =  0x0A;
+	md.pagex.page24.disktype = toc2sess[track_base(trackp)->tracktype & TOC_MASK];
+	i_to_4_byte(&md.pagex.page24.disk_id, 0x12345);
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+cw7501_fixate(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		return (scsi_flush_cache(usalp, FALSE));
+	}
+	/*
+	 * 0x00	Finalize Disk (not appendable)
+	 * 0x01	Finalize Session (allow next session)
+	 * 0x10	Finalize track (variable packet writing) - Must fluch cache before
+	 */
+	return (cw7501_finalize(usalp, 0, (track_base(trackp)->tracktype & TOCF_MULTI) ? 0x01 : 0x00));
+}
+
+/*--------------------------------------------------------------------------*/
+
+static int 
+cw7501_gen_cue(track_t *trackp, void *vcuep, BOOL needgap)
+{
+	int	tracks = trackp->tracks;
+	int	i;
+	struct cw7501_cue	**cuep = vcuep;
+	struct cw7501_cue	*cue;
+	struct cw7501_cue	*cp;
+	int	ncue = 0;
+	int	icue = 0;
+	int	pgsize;
+	msf_t	m;
+	int	ctl;
+	int	df;
+	int	scms;
+
+	cue = malloc(1);
+
+	for (i = 0; i <= tracks; i++) {
+		ctl = (st2mode[trackp[i].sectype & ST_MASK]) << 4;
+		if (is_copy(&trackp[i]))
+			ctl |= TM_ALLOW_COPY << 4;
+		df = db2phys[trackp[i].dbtype & 0x0F];
+
+		if (trackp[i].isrc) {	/* MCN or ISRC */
+			ncue += 2;
+			cue = realloc(cue, ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			if (i == 0) {
+				cp->cs_ctladr = 0x02;
+				movebytes(&trackp[i].isrc[0], &cp->cs_tno, 7);
+				cp = &cue[icue++];
+				cp->cs_ctladr = 0x02;
+				movebytes(&trackp[i].isrc[7], &cp->cs_tno, 7);
+			} else {
+				cp->cs_ctladr = 0x03;
+				cp->cs_tno = i;
+				movebytes(&trackp[i].isrc[0], &cp->cs_index, 6);
+				cp = &cue[icue++];
+				cp->cs_ctladr = 0x03;
+				cp->cs_tno = i;
+				movebytes(&trackp[i].isrc[6], &cp->cs_index, 6);
+			}
+		}
+		if (i == 0) {	/* Lead in */
+			lba_to_msf(-150, &m);
+			cue = realloc(cue, ++ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			fillcue(cp, ctl|0x01, i, 0, df, 0, &m);
+		} else {
+			scms = 0;
+
+			if (is_scms(&trackp[i]))
+				scms = 0x80;
+			pgsize = trackp[i].pregapsize;
+			if (pgsize == 0 && needgap)
+				pgsize++;
+			lba_to_msf(trackp[i].trackstart-pgsize, &m);
+			cue = realloc(cue, ++ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			fillcue(cp, ctl|0x01, i, 0, df, scms, &m);
+
+			if (trackp[i].nindex == 1) {
+				lba_to_msf(trackp[i].trackstart, &m);
+				cue = realloc(cue, ++ncue * sizeof (*cue));
+				cp = &cue[icue++];
+				fillcue(cp, ctl|0x01, i, 1, df, scms, &m);
+			} else {
+				int	idx;
+				long	*idxlist;
+
+				ncue += trackp[i].nindex;
+				idxlist = trackp[i].tindex;
+				cue = realloc(cue, ncue * sizeof (*cue));
+
+				for (idx = 1; idx <= trackp[i].nindex; idx++) {
+					lba_to_msf(trackp[i].trackstart + idxlist[idx], &m);
+					cp = &cue[icue++];
+					fillcue(cp, ctl|0x01, i, idx, df, scms, &m);
+				}
+			}
+		}
+	}
+	/* Lead out */
+	ctl = (st2mode[trackp[tracks+1].sectype & ST_MASK]) << 4;
+	df = db2phys[trackp[tracks+1].dbtype & 0x0F];
+	lba_to_msf(trackp[tracks+1].trackstart, &m);
+	cue = realloc(cue, ++ncue * sizeof (*cue));
+	cp = &cue[icue++];
+	fillcue(cp, ctl|0x01, 0xAA, 1, df, 0, &m);
+
+	if (lverbose > 1) {
+		for (i = 0; i < ncue; i++) {
+			usal_prbytes("", (Uchar *)&cue[i], 8);
+		}
+	}
+	if (cuep)
+		*cuep = cue;
+	else
+		free(cue);
+	return (ncue);
+}
+
+static void 
+fillcue(struct cw7501_cue *cp	/* The target cue entry */, 
+        int ca					/* Control/adr for this entry */, 
+        int tno					/* Track number for this entry */, 
+        int idx					/* Index for this entry */, 
+        int dataform			/* Data format for this entry */, 
+        int scms					/* Serial copy management */, 
+        msf_t *mp				/* MSF value for this entry */)
+{
+	cp->cs_ctladr = ca;
+	if (tno <= 99)
+		cp->cs_tno = to_bcd(tno);
+	else
+		cp->cs_tno = tno;
+	cp->cs_index = to_bcd(idx);
+	if (scms != 0)
+		dataform |= 0x10;
+	cp->cs_dataform = dataform;
+	cp->cs_extension = 0;
+	cp->cs_min = to_bcd(mp->msf_min);
+	cp->cs_sec = to_bcd(mp->msf_sec);
+	cp->cs_frame = to_bcd(mp->msf_frame);
+}
+
+static int 
+cw7501_send_cue(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	struct cw7501_cue *cp;
+	int		ncue;
+	int		ret;
+	Uint		i;
+	struct timeval starttime;
+	struct timeval stoptime;
+	int		disktype;
+
+	disktype = toc2sess[track_base(trackp)->tracktype & TOC_MASK];
+
+	for (i = 1; i <= trackp->tracks; i++) {
+		if (trackp[i].tracksize < (tsize_t)0) {
+			errmsgno(EX_BAD, "Track %d has unknown length.\n", i);
+			return (-1);
+		}
+	}
+	ncue = (*dp->cdr_gen_cue)(trackp, &cp, FALSE);
+
+	starttime.tv_sec = 0;
+	starttime.tv_usec = 0;
+	stoptime = starttime;
+	gettimeofday(&starttime, (struct timezone *)0);
+
+	usalp->silent++;
+	ret = cw7501_write_dao(usalp, (Uchar *)cp, ncue*8, disktype);
+	usalp->silent--;
+	free(cp);
+	if (ret < 0) {
+		errmsgno(EX_BAD, "CUE sheet not accepted. Retrying with minimum pregapsize = 1.\n");
+		ncue = (*dp->cdr_gen_cue)(trackp, &cp, TRUE);
+		ret  = cw7501_write_dao(usalp, (Uchar *)cp, ncue*8, disktype);
+		free(cp);
+	}
+	if (ret >= 0 && lverbose) {
+		gettimeofday(&stoptime, (struct timezone *)0);
+		prtimediff("Write Lead-in time: ", &starttime, &stoptime);
+	}
+	return (ret);
+}
+
+/*--------------------------------------------------------------------------*/
+static int 
+cw7501_rezero(SCSI *usalp, int reset, int dwreset)
+{
+	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);
+	scmd->cdb.cmd_cdb[5] |= reset ? 0x80 : 0;
+	scmd->cdb.cmd_cdb[5] |= dwreset ? 0x40 : 0;
+
+	usalp->cmdname = "cw7501 rezero";
+
+	return (usal_cmd(usalp));
+}
+
+
+static int
+cw7501_read_trackinfo(SCSI *usalp, Uchar *bp, int count, int track, int mode)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t) scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)bp;
+	scmd->size = count;
+	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 = 0xE9;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.cmd_cdb[6] = track;
+	g1_cdblen(&scmd->cdb.g1_cdb, count);
+	scmd->cdb.cmd_cdb[9] = (mode & 3) << 6;
+
+	usalp->cmdname = "cw7501 read_track_information";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int 
+cw7501_write_dao(SCSI *usalp, Uchar *bp, int len, int disktype)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)bp;
+	scmd->size = len;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0xE6;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.cmd_cdb[2] = disktype;
+	g1_cdblen(&scmd->cdb.g1_cdb, len);
+
+	usalp->cmdname = "cw7501 write_dao";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+/*
+ * XXX CW-7501 also needs "control", so we need to make a different
+ * XXX driver interface.
+ */
+static int 
+cw7501_reserve_track(SCSI *usalp, unsigned long len)
+{
+	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 = 0xE7;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+/*	scmd->cdb.cmd_cdb[2] = control & 0x0F;*/
+	i_to_4_byte(&scmd->cdb.cmd_cdb[5], len);
+
+	usalp->cmdname = "cw7501 reserve_track";
+
+	comerrno(EX_BAD, "Control (as in set mode) missing.\n");
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+cw7501_set_mode(SCSI *usalp, int phys_form, int control, int subc, 
+						int alt, int trackno, int tindex, int packet_size, 
+						int write_mode)
+{
+	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 = 0xE2;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.cmd_cdb[2] = phys_form & 0x0F;
+	scmd->cdb.cmd_cdb[3] = (control & 0x0F) << 4;
+	scmd->cdb.cmd_cdb[3] |= subc ? 2 : 0;
+	scmd->cdb.cmd_cdb[3] |= alt ? 1 : 0;
+	scmd->cdb.cmd_cdb[4] = trackno;
+	scmd->cdb.cmd_cdb[5] = tindex;
+	i_to_3_byte(&scmd->cdb.cmd_cdb[6], packet_size);
+	scmd->cdb.cmd_cdb[9] = (write_mode & 0x03) << 6;
+
+	usalp->cmdname = "cw7501 set_mode";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+cw7501_finalize(SCSI *usalp, int pad, int fixed)
+{
+	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 = 0xE3;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.cmd_cdb[1] = pad ? 1 : 0;
+	scmd->cdb.cmd_cdb[8] = fixed & 0x03;
+
+	usalp->cmdname = "cw7501 finalize";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
diff --git a/wodim/drv_jvc.c b/wodim/drv_jvc.c
new file mode 100644
index 0000000..ee2bcc2
--- /dev/null
+++ b/wodim/drv_jvc.c
@@ -0,0 +1,1433 @@
+/*
+ * 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.
+ *
+ */
+
+/** @(#)drv_jvc.c	1.82 05/05/16 Copyright 1997-2005 J. Schilling */
+/*
+ *	CDR device implementation for
+ *	JVC/TEAC
+ *
+ *	Copyright (c) 1997-2005 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.
+ */
+/*#define	XXDEBUG*/
+/*#define	XXBUFFER*/
+
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <standard.h>
+#include <fctldefs.h>
+#include <errno.h>
+#include <strdefs.h>
+#include <unixstd.h>
+#ifdef	XXDEBUG
+#include <stdxlib.h>
+#endif
+
+#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 "wodim.h"
+
+/* just a hack */
+long	lba_addr;
+BOOL	last_done;
+
+/*
+ * macros for building MSF values from LBA
+ */
+#define	LBA_MIN(x)	((x)/(60*75))
+#define	LBA_SEC(x)	(((x)%(60*75))/75)
+#define	LBA_FRM(x)	((x)%75)
+#define	MSF_CONV(a)	((((a)%(unsigned)100)/10)*16 + ((a)%(unsigned)10))
+
+extern	int	lverbose;
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+struct teac_mode_page_21 {		/* teac dummy selection */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x01 = 1 Byte */
+	Ucbit	dummy		: 2;
+	Ucbit	res		: 6;
+};
+#else
+struct teac_mode_page_21 {		/* teac dummy selection */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x01 = 1 Byte */
+	Ucbit	res		: 6;
+	Ucbit	dummy		: 2;
+};
+#endif
+
+struct teac_mode_page_31 {		/* teac speed selection */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Byte */
+	Uchar	speed;
+	Uchar	res;
+};
+
+struct cdd_52x_mode_data {
+	struct scsi_mode_header	header;
+	union cdd_pagex	{
+		struct teac_mode_page_21	teac_page21;
+		struct teac_mode_page_31	teac_page31;
+	} pagex;
+};
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct pgm_subcode {		/* subcode for progam area */
+	Uchar	subcode;
+	Ucbit	addr		: 4;
+	Ucbit	control		: 4;
+	Uchar	track;
+	Uchar	index;
+};
+
+#else
+
+struct pgm_subcode {		/* subcode for progam area */
+	Uchar	subcode;
+	Ucbit	control		: 4;
+	Ucbit	addr		: 4;
+	Uchar	track;
+	Uchar	index;
+};
+
+#endif
+
+#define	set_pgm_subcode(sp, t, c, a, tr, idx)		(\
+			(sp)->subcode = (t),		 \
+			(sp)->control = (c),		 \
+			(sp)->addr = (a),		 \
+			(sp)->track = MSF_CONV(tr),	 \
+			(sp)->index = (idx))
+
+#define	SC_P		1	/* Subcode defines pre-gap (Pause)	*/
+#define	SC_TR		0	/* Subcode defines track data		*/
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+typedef struct lin_subcode {	/* subcode for lead in area */
+	Ucbit	addr		: 4;
+	Ucbit	control		: 4;
+	Uchar	track;
+	Uchar	msf[3];
+} lsc_t;
+
+#else
+
+typedef struct lin_subcode {	/* subcode for lead in area */
+	Ucbit	control		: 4;
+	Ucbit	addr		: 4;
+	Uchar	track;
+	Uchar	msf[3];
+} lsc_t;
+
+#endif
+
+#define	set_toc_subcode(sp, c, a, tr, bno)				(\
+			((lsc_t *)sp)->control = (c),			 \
+			((lsc_t *)sp)->addr = (a),			 \
+			((lsc_t *)sp)->track = MSF_CONV(tr),		 \
+			((lsc_t *)sp)->msf[0] = MSF_CONV(LBA_MIN(bno)),	 \
+			((lsc_t *)sp)->msf[1] = MSF_CONV(LBA_SEC(bno)),	 \
+			((lsc_t *)sp)->msf[2] = MSF_CONV(LBA_FRM(bno)),	 \
+			&((lsc_t *)sp)->msf[3])
+
+#define	set_lin_subcode(sp, c, a, pt, min, sec, frm)			(\
+			((lsc_t *)sp)->control = (c),			 \
+			((lsc_t *)sp)->addr = (a),			 \
+			((lsc_t *)sp)->track = (pt),			 \
+			((lsc_t *)sp)->msf[0] = (min),			 \
+			((lsc_t *)sp)->msf[1] = (sec),			 \
+			((lsc_t *)sp)->msf[2] = (frm),			 \
+			&((lsc_t *)sp)->msf[3])
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct upc_subcode {		/* subcode for upc/bar code */
+	Uchar	res;
+	Ucbit	addr		: 4;
+	Ucbit	control		: 4;
+	Uchar	upc[13];
+};
+
+#else
+
+struct upc_subcode {		/* subcode for upc/bar code */
+	Uchar	res;
+	Ucbit	control		: 4;
+	Ucbit	addr		: 4;
+	Uchar	upc[13];
+};
+
+#endif
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct isrc_subcode {		/* subcode for ISRC code */
+	Uchar	res;
+	Ucbit	addr		: 4;
+	Ucbit	control		: 4;
+	Uchar	isrc[12];
+	Uchar	res14;
+};
+
+#else
+
+struct isrc_subcode {		/* subcode for ISRC code */
+	Uchar	res;
+	Ucbit	control		: 4;
+	Ucbit	addr		: 4;
+	Uchar	isrc[12];
+	Uchar	res14;
+};
+
+#endif
+
+
+static	int	teac_attach(SCSI *usalp, cdr_t *dp);
+static	int	teac_init(SCSI *usalp, cdr_t *dp);
+static	int	teac_getdisktype(SCSI *usalp, cdr_t *dp);
+static	int	speed_select_teac(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	select_secsize_teac(SCSI *usalp, track_t *trackp);
+static	int	next_wr_addr_jvc(SCSI *usalp, track_t *, long *ap);
+static	int	write_teac_xg1(SCSI *usalp, caddr_t, long, long, int, BOOL);
+static	int	cdr_write_teac(SCSI *usalp, caddr_t bp, long sectaddr, long size, 
+										int blocks, BOOL islast);
+static	int	open_track_jvc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	teac_fixation(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	close_track_teac(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	teac_open_session(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	initsub_teac(SCSI *usalp, int toctype, int multi);
+static	int	teac_doopc(SCSI *usalp);
+static	int	teac_opc(SCSI *usalp, caddr_t, int cnt, int doopc);
+static	int	opt_power_judge(SCSI *usalp, int judge);
+static	int	clear_subcode(SCSI *usalp);
+static	int	set_limits(SCSI *usalp, long lba, long length);
+static	int	set_subcode(SCSI *usalp, Uchar *subcode_data, int length);
+static	int	read_disk_info_teac(SCSI *usalp, Uchar *data, int length, 
+											  int type);
+static	int	teac_freeze(SCSI *usalp, int bp_flag);
+static	int	teac_wr_pma(SCSI *usalp);
+static	int	teac_rd_pma(SCSI *usalp);
+static	int	next_wr_addr_teac(SCSI *usalp, long start_lba, long last_lba);
+static	int	blank_jvc(SCSI *usalp, cdr_t *dp, long addr, int blanktype);
+static	int	buf_cap_teac(SCSI *usalp, long *sp, long *fp);
+static	long	read_peak_buffer_cap_teac(SCSI *usalp);
+static	int	buffer_inquiry_teac(SCSI *usalp, int fmt);
+#ifdef	XXBUFFER
+static	void	check_buffer_teac(SCSI *usalp);
+#endif
+#ifdef	XXDEBUG
+static	void	xxtest_teac(SCSI *usalp);
+#endif
+
+
+cdr_t	cdr_teac_cdr50 = {
+	0, 0,
+/*	CDR_TAO|CDR_SAO|CDR_SWABAUDIO|CDR_NO_LOLIMIT,*/
+	CDR_TAO|CDR_SWABAUDIO|CDR_NO_LOLIMIT,
+	CDR_CDRW_ALL,
+	2, 4,
+	"teac_cdr50",
+	"driver for Teac CD-R50S, Teac CD-R55S, JVC XR-W2010, Pinnacle RCD-5020",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	teac_attach,
+	teac_init,
+	teac_getdisktype,
+	scsi_load,
+	scsi_unload,
+	buf_cap_teac,
+	cmd_dummy,					/* recovery_needed */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_teac,
+	select_secsize,
+	next_wr_addr_jvc,
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	cdr_write_teac,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_jvc,
+	close_track_teac,
+	teac_open_session,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	teac_fixation,
+	cmd_dummy,					/* stats	*/
+/*	blank_dummy,*/
+	blank_jvc,
+	format_dummy,
+	teac_opc,
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+static int 
+teac_init(SCSI *usalp, cdr_t *dp)
+{
+	return (speed_select_teac(usalp, dp, NULL));
+}
+
+static int 
+teac_getdisktype(SCSI *usalp, cdr_t *dp)
+{
+	dstat_t	*dsp = dp->cdr_dstat;
+	struct scsi_mode_data md;
+	int	count = sizeof (struct scsi_mode_header) +
+			sizeof (struct scsi_mode_blockdesc);
+	int	len;
+	int	page = 0;
+	long	l;
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	(void) test_unit_ready(usalp);
+	if (mode_sense(usalp, (Uchar *)&md, count, page, 0) < 0) {	/* Page n current */
+		return (-1);
+	} else {
+		len = ((struct scsi_mode_header *)&md)->sense_data_len + 1;
+	}
+	if (((struct scsi_mode_header *)&md)->blockdesc_len < 8)
+		return (-1);
+
+	l = a_to_u_3_byte(md.blockdesc.nlblock);
+	dsp->ds_maxblocks = l;
+	return (drive_getdisktype(usalp, dp));
+}
+
+static int 
+speed_select_teac(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	struct cdd_52x_mode_data md;
+	int	count;
+	int	status;
+	int	speed = 1;
+	BOOL	dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp)
+		speed = *speedp;
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct teac_mode_page_21);
+
+	md.pagex.teac_page21.p_code = 0x21;
+	md.pagex.teac_page21.p_len =  0x01;
+	md.pagex.teac_page21.dummy = dummy?3:0;
+
+	status = mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2);
+	if (status < 0)
+		return (status);
+
+	if (speedp == 0)
+		return (0);
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct teac_mode_page_31);
+
+	speed >>= 1;
+	md.pagex.teac_page31.p_code = 0x31;
+	md.pagex.teac_page31.p_len =  0x02;
+	md.pagex.teac_page31.speed = speed;
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+select_secsize_teac(SCSI *usalp, track_t *trackp)
+{
+	struct scsi_mode_data md;
+	int	count = sizeof (struct scsi_mode_header) +
+			sizeof (struct scsi_mode_blockdesc);
+	int	len;
+	int	page = 0;
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	(void) test_unit_ready(usalp);
+	if (mode_sense(usalp, (Uchar *)&md, count, page, 0) < 0) {	/* Page n current */
+		return (-1);
+	} else {
+		len = ((struct scsi_mode_header *)&md)->sense_data_len + 1;
+	}
+	if (((struct scsi_mode_header *)&md)->blockdesc_len < 8)
+		return (-1);
+
+	md.header.sense_data_len = 0;
+	md.header.blockdesc_len = 8;
+
+	md.blockdesc.density = 1;
+	if (trackp->secsize == 2352)
+		md.blockdesc.density = 4;
+	i_to_3_byte(md.blockdesc.lblen, trackp->secsize);
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+next_wr_addr_jvc(SCSI *usalp, track_t *trackp, long *ap)
+{
+	if (trackp != 0 && trackp->track > 0) {
+		*ap = lba_addr;
+	} else {
+		long	nwa;
+
+		if (read_B0(usalp, TRUE, &nwa, NULL) < 0)
+			return (-1);
+
+		*ap = nwa + 150;
+	}
+	return (0);
+}
+
+static int 
+write_teac_xg1(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 extwr       /* is an extended write */)
+{
+	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, sectaddr);
+	g1_cdblen(&scmd->cdb.g1_cdb, blocks);
+	scmd->cdb.g1_cdb.vu_97 = extwr;
+
+	usalp->cmdname = "write_teac_g1";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (size - usal_getresid(usalp));
+}
+
+static int 
+cdr_write_teac(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 */)
+{
+	int	ret;
+
+	if (islast)
+		last_done = TRUE;
+
+	ret = write_teac_xg1(usalp, bp, sectaddr, size, blocks, !islast);
+	if (ret < 0)
+		return (ret);
+
+	lba_addr = sectaddr + blocks;
+#ifdef	XXBUFFER
+	check_buffer_teac(usalp);
+#endif
+	return (ret);
+}
+
+static int 
+open_track_jvc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	status;
+	long	blocks;
+	long	pregapsize;
+	struct	pgm_subcode	sc;
+
+	last_done = FALSE;
+
+	if (select_secsize_teac(usalp, trackp) < 0)
+		return (-1);
+
+	status = clear_subcode(usalp);
+/*next_wr_addr_teac(usalp);*/
+	if (status < 0)
+		return (status);
+
+if (trackp->pregapsize != 0) {
+	if (lverbose > 1) {
+		printf("set_limits(%ld, %ld)-> %ld\n",
+		lba_addr, trackp->pregapsize, lba_addr + trackp->pregapsize);
+	}
+
+	status = set_limits(usalp, lba_addr, trackp->pregapsize);
+	if (status < 0)
+		return (status);
+
+	/*
+	 * Set pre-gap (pause - index 0)
+	 */
+	set_pgm_subcode(&sc, SC_P,
+			st2mode[trackp->sectype&ST_MASK], ADR_POS, trackp->trackno, 0);
+
+	if (lverbose > 1)
+		usal_prbytes("Subcode:", (Uchar *)&sc, sizeof (sc));
+
+	status = set_subcode(usalp, (Uchar *)&sc, sizeof (sc));
+	if (status < 0)
+		return (status);
+
+	pregapsize = trackp->pregapsize;
+	if (!is_audio(trackp)) {
+		lba_addr += 5;	/* link & run in blocks */
+		pregapsize -= 5;
+	}
+	if (lverbose > 1) {
+		printf("pad_track(%ld, %ld)-> %ld\n",
+			lba_addr, pregapsize, lba_addr + pregapsize);
+	}
+	/*
+	 * XXX Do we need to check isecsize too?
+	 */
+	if (pad_track(usalp, dp, trackp,
+			lba_addr, (Llong)pregapsize*trackp->secsize,
+			FALSE, (Llong *)0) < 0)
+		return (-1);
+}
+
+	blocks = trackp->tracksize/trackp->secsize +
+		    (trackp->tracksize%trackp->secsize?1:0);
+	blocks += trackp->padsecs;
+	if (blocks < 300)
+		blocks = 300;
+	if (!is_audio(trackp))
+		blocks += 2;
+if (!is_last(trackp) && trackp[1].pregapsize == 0)
+		blocks -= 150;
+
+	/*
+	 * set the limits for the new subcode - seems to apply to all
+	 * of the data track.
+	 * Unknown tracksize is handled in open_session.
+	 * We definitely need to know the tracksize in this driver.
+	 */
+	if (lverbose > 1) {
+		printf("set_limits(%ld, %ld)-> %ld\n",
+			lba_addr, blocks, lba_addr + blocks);
+	}
+	status = set_limits(usalp, lba_addr, blocks);
+	if (status < 0)
+		return (status);
+
+	/*
+	 * Set track start (index 1)
+	 */
+	set_pgm_subcode(&sc, SC_TR,
+			st2mode[trackp->sectype&ST_MASK], ADR_POS, trackp->trackno, 1);
+
+	if (lverbose > 1)
+		usal_prbytes("Subcode:", (Uchar *)&sc, sizeof (sc));
+
+	status = set_subcode(usalp, (Uchar *)&sc, sizeof (sc));
+	if (status < 0)
+		return (status);
+
+if (!is_last(trackp) && trackp[1].pregapsize == 0) {
+	blocks += lba_addr;
+	pregapsize = 150;
+
+	if (lverbose > 1) {
+		printf("set_limits(%ld, %ld)-> %ld\n",
+		blocks, pregapsize, blocks + pregapsize);
+	}
+
+	status = set_limits(usalp, blocks, pregapsize);
+	if (status < 0)
+		return (status);
+
+	/*
+	 * Set pre-gap (pause - index 0)
+	 */
+	trackp++;
+	set_pgm_subcode(&sc, SC_P,
+			st2mode[trackp->sectype&ST_MASK], ADR_POS, trackp->trackno, 0);
+
+	if (lverbose > 1)
+		usal_prbytes("Subcode:", (Uchar *)&sc, sizeof (sc));
+
+	status = set_subcode(usalp, (Uchar *)&sc, sizeof (sc));
+	if (status < 0)
+		return (status);
+}
+	return (status);
+}
+
+static	char	sector[3000];
+
+static int 
+close_track_teac(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	ret = 0;
+
+	if (!last_done) {
+		printf("WARNING: adding dummy block to close track.\n");
+		/*
+		 * need read sector size
+		 * XXX do we really need this ?
+		 * XXX if we need this can we set blocks to 0 ?
+		 */
+		ret =  write_teac_xg1(usalp, sector, lba_addr, 2352, 1, FALSE);
+		lba_addr++;
+	}
+	if (!is_audio(trackp))
+		lba_addr += 2;
+	teac_wr_pma(usalp);
+	return (ret);
+}
+
+
+
+static const char *sd_teac50_error_str[] = {
+	"\100\200diagnostic failure on component parts",	/* 40 80 */
+	"\100\201diagnostic failure on memories",		/* 40 81 */
+	"\100\202diagnostic failure on cd-rom ecc circuit",	/* 40 82 */
+	"\100\203diagnostic failure on gate array",		/* 40 83 */
+	"\100\204diagnostic failure on internal SCSI controller",	/* 40 84 */
+	"\100\205diagnostic failure on servo processor",	/* 40 85 */
+	"\100\206diagnostic failure on program rom",		/* 40 86 */
+	"\100\220thermal sensor failure",			/* 40 90 */
+	"\200\000controller prom error",			/* 80 00 */	/* JVC */
+	"\201\000no disk present - couldn't get focus",		/* 81 00 */	/* JVC */
+	"\202\000no cartridge present",				/* 82 00 */	/* JVC */
+	"\203\000unable to spin up",				/* 83 00 */	/* JVC */
+	"\204\000addr exceeded the last valid block addr",	/* 84 00 */	/* JVC */
+	"\205\000sync error",					/* 85 00 */	/* JVC */
+	"\206\000address can't find or not data track",		/* 86 00 */	/* JVC */
+	"\207\000missing track",				/* 87 00 */	/* JVC */
+	"\213\000cartridge could not be ejected",		/* 8B 00 */	/* JVC */
+	"\215\000audio not playing",				/* 8D 00 */	/* JVC */
+	"\216\000read toc error",				/* 8E 00 */	/* JVC */
+	"\217\000a blank disk is detected by read toc",		/* 8F 00 */
+	"\220\000pma less disk - not a recordable disk",	/* 90 00 */
+	"\223\000mount error",					/* 93 00 */	/* JVC */
+	"\224\000toc less disk",				/* 94 00 */
+	"\225\000disc information less disk",			/* 95 00 */	/* JVC */
+	"\226\000disc information read error",			/* 96 00 */	/* JVC */
+	"\227\000linear velocity measurement error",		/* 97 00 */	/* JVC */
+	"\230\000drive sequence stop",				/* 98 00 */	/* JVC */
+	"\231\000actuator velocity control error",		/* 99 00 */	/* JVC */
+	"\232\000slider velocity control error",		/* 9A 00 */	/* JVC */
+	"\233\000opc initialize error",				/* 9B 00 */
+	"\233\001power calibration not executed",		/* 9B 01 */
+	"\234\000opc execution eror",				/* 9C 00 */
+	"\234\001alpc error - opc execution",			/* 9C 01 */
+	"\234\002opc execution timeout",			/* 9C 02 */
+	"\245\000disk application code does not match host application code",	/* A5 00 */
+	"\255\000completed preview write",			/* AD 00 */
+	"\256\000invalid B0 value",				/* AE 00 */	/* JVC */
+	"\257\000pca area full",				/* AF 00 */
+	"\260\000efm isn't detected",				/* B0 00 */	/* JVC */
+	"\263\000no logical sector",				/* B3 00 */	/* JVC */
+	"\264\000full pma area",				/* B4 00 */
+	"\265\000read address is atip area - blank",		/* B5 00 */
+	"\266\000write address is efm area - aleady written",	/* B6 00 */
+	"\271\000abnormal spinning - servo irq",		/* B9 00 */	/* JVC */
+	"\272\000no write data - buffer empty",			/* BA 00 */
+	"\273\000write emergency occurred",			/* BB 00 */
+	"\274\000read timeout",					/* BC 00 */	/* JVC */
+	"\277\000abnormal spin - nmi",				/* BF 00 */	/* JVC */
+	"\301\0004th run-in block detected",			/* C1 00 */
+	"\302\0003rd run-in block detected",			/* C2 00 */
+	"\303\0002nd run-in block detected",			/* C3 00 */
+	"\304\0001st run-in block detected",			/* C4 00 */
+	"\305\000link block detected",				/* C5 00 */
+	"\306\0001st run-out block detected",			/* C6 00 */
+	"\307\0002nd run-out block detected",			/* C7 00 */
+	"\314\000write request means mixed data mode",		/* CC 00 */
+	"\315\000unable to ensure reliable writing with the inserted disk - unsupported disk",	 /* CD 00 */
+	"\316\000unable to ensure reliable writing as the inserted disk does not support speed", /* CE 00 */
+	"\317\000unable to ensure reliable writing as the inserted disk has no char id code",	 /* CF 00 */
+	NULL
+};
+
+static int 
+teac_attach(SCSI *usalp, cdr_t *dp)
+{
+	usal_setnonstderrs(usalp, sd_teac50_error_str);
+#ifdef	XXDEBUG
+	xxtest_teac(usalp);
+	exit(0);
+#endif
+	return (0);
+}
+
+static int 
+teac_fixation(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	long	lba;
+	int	status;
+	Uchar	*sp;
+	Uint	i;
+extern	char	*buf;
+
+	if (trackp->tracks < 1) {
+		/*
+		 * We come here if wodim isonly called with the -fix option.
+		 * As long as we cannot read and interpret the PMA, we must
+		 * abort here.
+		 */
+		teac_rd_pma(usalp);
+/*		errmsgno(EX_BAD, "Cannot fixate zero track disk.\n");*/
+		errmsgno(EX_BAD, "Cannot fixate without track list (not yet implemented).\n");
+		return (-1);
+	}
+	sp = (Uchar *)buf;
+
+	sleep(1);
+
+	status = clear_subcode(usalp);
+	sleep(1);
+	if (status < 0)
+		return (status);
+
+	sp[0] = 0;		/* reserved */
+	sp[1] = 0;		/* reserved */
+	sp[2] = 0;		/* Q TNO */
+
+	sp = &sp[3];		/* point past header */
+
+	/*
+	 * Set up TOC entries for all tracks
+	 */
+	for (i = 1; i <= trackp->tracks; i++) {
+		lba = trackp[i].trackstart+150;	/* MSF=00:02:00 is LBA=0 */
+
+		sp = set_toc_subcode(sp,
+				/* ctrl/adr for this track */
+				st2mode[trackp[i].sectype&ST_MASK], ADR_POS,
+					trackp[i].trackno, lba);
+	}
+
+	/*
+	 * Set first track on disk
+	 *
+	 * XXX We set the track type for the lead-in to the track type
+	 * XXX of the first track. The TEAC manual states that we should use
+	 * XXX audio if the disk contains both, audio and data tracks.
+	 */
+	sp = set_lin_subcode(sp,
+		/* ctrl/adr for first track */
+		st2mode[trackp[1].sectype&ST_MASK], ADR_POS,
+		0xA0,				/* Point A0 */
+		trackp[1].trackno,		/* first track # */
+		toc2sess[track_base(trackp)->tracktype & TOC_MASK],	/* disk type */
+		0);				/* reserved */
+
+	/*
+	 * Set last track on disk
+	 */
+	sp = set_lin_subcode(sp,
+		/* ctrl/adr for first track */
+		st2mode[trackp[1].sectype&ST_MASK], ADR_POS,
+		0xA1,				/* Point A1 */
+		MSF_CONV(trackp[trackp->tracks].trackno), /* last track # */
+		0,				/* reserved */
+		0);				/* reserved */
+
+	/*
+	 * Set start of lead out area in MSF
+	 * MSF=00:02:00 is LBA=0
+	 */
+	lba = lba_addr + 150;
+	if (lverbose > 1)
+	printf("lba: %ld lba_addr: %ld\n", lba, lba_addr);
+
+	if (lverbose > 1)
+	printf("Lead out start: (%02d:%02d/%02d)\n",
+			minutes(lba*2352),
+			seconds(lba*2352),
+			frames(lba*2352));
+
+	sp = set_lin_subcode(sp,
+		/* ctrl/adr for first track */
+		st2mode[trackp[1].sectype&ST_MASK], ADR_POS,
+		0xA2,				/* Point A2 */
+		MSF_CONV(LBA_MIN(lba)),
+		MSF_CONV(LBA_SEC(lba)),
+		MSF_CONV(LBA_FRM(lba)));
+
+	status = sp - ((Uchar *)buf);
+	if (lverbose > 1) {
+		printf("Subcode len: %d\n", status);
+		usal_prbytes("Subcode:", (Uchar *)buf, status);
+	}
+	status = set_subcode(usalp, (Uchar *)buf, status);
+	sleep(1);
+	if (status < 0)
+		return (status);
+
+	/*
+	 * now write the toc
+	 */
+	status = teac_freeze(usalp, (track_base(trackp)->tracktype & TOCF_MULTI) == 0);
+	return (status);
+
+}
+
+static int 
+teac_open_session(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uint	i;
+
+	for (i = 1; i <= trackp->tracks; i++) {
+		if (trackp[i].tracksize < (tsize_t)0) {
+			/*
+			 * XXX How about setting the subcode range to infinity.
+			 * XXX and correct it in clode track before writing
+			 * XXX the PMA?
+			 */
+			errmsgno(EX_BAD, "Track %d has unknown length.\n", i);
+			return (-1);
+		}
+	}
+	return (initsub_teac(usalp, track_base(trackp)->tracktype & TOC_MASK,
+				track_base(trackp)->tracktype & TOCF_MULTI));
+}
+
+static int 
+initsub_teac(SCSI *usalp, int toctype, int multi)
+{
+	int	status;
+
+	usalp->silent++;
+	if (read_B0(usalp, TRUE, &lba_addr, NULL) < 0)
+		lba_addr = -150;
+	usalp->silent--;
+
+	status = clear_subcode(usalp);
+	if (status < 0)
+		return (status);
+
+	return (0);
+}
+
+static int 
+teac_doopc(SCSI *usalp)
+{
+	int	status;
+
+	if (lverbose) {
+		fprintf(stdout, "Judging disk...");
+		flush();
+	}
+	status = opt_power_judge(usalp, 1);
+	if (status < 0) {
+		printf("\n");
+		return (status);
+	}
+	if (lverbose) {
+		fprintf(stdout, "done.\nCalibrating laser...");
+		flush();
+	}
+
+	status = opt_power_judge(usalp, 0);
+	if (lverbose) {
+		fprintf(stdout, "done.\n");
+	}
+	/*
+	 * Check for error codes 0xCD ... 0xCF
+	 */
+	usalp->silent++;
+	if (next_wr_addr_teac(usalp, -1, -1) < 0) {
+		if (usalp->verbose == 0 && usal_sense_key(usalp) != SC_ILLEGAL_REQUEST)
+			usal_printerr(usalp);
+	}
+	usalp->silent--;
+	return (status);
+}
+
+static int 
+teac_opc(SCSI *usalp, caddr_t bp, int cnt, int doopc)
+{
+	int	status;
+	int	count = 0;
+
+	do {
+		status = teac_doopc(usalp);
+	} while (++count <= 1 && status < 0);
+
+	return (status);
+}
+
+/*--------------------------------------------------------------------------*/
+#define	SC_SET_LIMITS		0xb3		/* teac 12 byte command */
+#define	SC_SET_SUBCODE		0xc2		/* teac 10 byte command */
+#define	SC_READ_PMA		0xc4		/* teac 10 byte command */
+#define	SC_READ_DISK_INFO	0xc7		/* teac 10 byte command */
+#define	SC_BUFFER_INQUIRY	0xe0		/* teac 12 byte command */
+
+#define	SC_WRITE_PMA		0xe1		/* teac 12 byte command */
+#define	SC_FREEZE		0xe3		/* teac 12 byte command */
+#define	SC_OPC_EXECUTE		0xec		/* teac 12 byte command */
+#define	SC_CLEAR_SUBCODE	0xe4		/* teac 12 byte command */
+#define	SC_NEXT_WR_ADDRESS	0xe6		/* teac 12 byte command */
+
+#define	SC_READ_PEAK_BUF_CAP	0xef		/* teac 12 byte command */
+
+/*
+ * Optimum power calibration for Teac Drives.
+ */
+static int 
+opt_power_judge(SCSI *usalp, int judge)
+{
+	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_RECV_DATA|SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 60;
+
+	scmd->cdb.g5_cdb.cmd = SC_OPC_EXECUTE;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g5_cdb.reladr = judge; /* Judge the Disc */
+
+	usalp->cmdname = "opt_power_judge";
+
+	return (usal_cmd(usalp));
+}
+
+/*
+ * Clear subcodes for Teac Drives.
+ */
+static int 
+clear_subcode(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_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = SC_CLEAR_SUBCODE;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g5_cdb.addr[3] = 0x80;
+
+	usalp->cmdname = "clear subcode";
+
+	return (usal_cmd(usalp));
+}
+
+/*
+ * Set limits for command linking for Teac Drives.
+ */
+static int 
+set_limits(SCSI *usalp, long lba, long length)
+{
+	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_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = SC_SET_LIMITS;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	i_to_4_byte(&scmd->cdb.g5_cdb.addr[0], lba);
+	i_to_4_byte(&scmd->cdb.g5_cdb.count[0], length);
+
+	usalp->cmdname = "set limits";
+
+	return (usal_cmd(usalp));
+}
+
+/*
+ * Set subcode for Teac Drives.
+ */
+static int 
+set_subcode(SCSI *usalp, Uchar *subcode_data, int length)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)subcode_data;
+	scmd->size = length;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g1_cdb.cmd = SC_SET_SUBCODE;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, length);
+
+	usalp->cmdname = "set subcode";
+
+	return (usal_cmd(usalp));
+}
+
+static int 
+read_disk_info_teac(SCSI *usalp, Uchar *data, int length, int type)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)data;
+	scmd->size = length;
+	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_READ_DISK_INFO;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	scmd->cdb.g1_cdb.reladr = type & 1;
+	scmd->cdb.g1_cdb.res    = (type & 2) >> 1;
+
+	usalp->cmdname = "read disk info teac";
+
+	return (usal_cmd(usalp));
+}
+
+/*
+ * Perform the freeze command for Teac Drives.
+ */
+static int 
+teac_freeze(SCSI *usalp, int bp_flag)
+{
+	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_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->timeout = 8 * 60;		/* Needs up to 4 minutes */
+
+	scmd->cdb.g5_cdb.cmd = SC_FREEZE;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g5_cdb.addr[3] = bp_flag ? 0x80 : 0;
+
+	usalp->cmdname = "teac_freeze";
+
+	return (usal_cmd(usalp));
+}
+
+static int 
+teac_wr_pma(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_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = SC_WRITE_PMA;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "teac_write_pma";
+
+	return (usal_cmd(usalp));
+}
+
+/*
+ * Read PMA for Teac Drives.
+ */
+static int 
+teac_rd_pma(SCSI *usalp)
+{
+	unsigned char	xx[256];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)xx, sizeof (xx), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)xx;
+	scmd->size = sizeof (xx);
+	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_READ_PMA;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	g1_cdblen(&scmd->cdb.g1_cdb, sizeof (xx));
+
+	usalp->cmdname = "teac_read_pma";
+
+/*	return (usal_cmd(usalp));*/
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (usalp->verbose) {
+		usal_prbytes("PMA Data", xx, sizeof (xx) - usal_getresid(usalp));
+	}
+	if (lverbose) {
+		unsigned i;
+		Uchar	*p;
+
+		usal_prbytes("PMA Header: ", xx, 4);
+		i = xx[2];
+		p = &xx[4];
+		for (; i <= xx[3]; i++) {
+			usal_prbytes("PMA: ", p, 10);
+			p += 10;
+		}
+	}
+	return (0);
+}
+
+/*
+ * Next writable address for Teac Drives.
+ */
+static int 
+next_wr_addr_teac(SCSI *usalp, long start_lba, long last_lba)
+{
+	unsigned char	xx[256];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)xx, sizeof (xx), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)xx;
+	scmd->size = sizeof (xx);
+	scmd->flags = SCG_RECV_DATA |SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = SC_NEXT_WR_ADDRESS;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	i_to_4_byte(&scmd->cdb.g5_cdb.addr[0], start_lba);
+	i_to_4_byte(&scmd->cdb.g5_cdb.count[0], last_lba);
+
+	if (usalp->verbose)
+		printf("start lba: %ld last lba: %ld\n",
+					start_lba, last_lba);
+
+	usalp->cmdname = "next writable address";
+
+/*	return (usal_cmd(usalp));*/
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (usalp->verbose) {
+		usal_prbytes("WRa Data", xx, sizeof (xx) - usal_getresid(usalp));
+		printf("NWA: %ld\n", a_to_4_byte(xx));
+	}
+	return (0);
+}
+
+static int 
+blank_jvc(SCSI *usalp, cdr_t *dp, long addr, int blanktype)
+{
+	extern	char	*blank_types[];
+
+	if (lverbose) {
+		printf("Blanking %s\n", blank_types[blanktype & 0x07]);
+		flush();
+	}
+
+	return (scsi_blank(usalp, addr, blanktype, FALSE));
+}
+
+static int 
+buf_cap_teac(SCSI *usalp, long *sp, long *fp)
+{
+	Ulong	freespace;
+	Ulong	bufsize;
+	long	ret;
+	int	per;
+
+	ret = read_peak_buffer_cap_teac(usalp);
+	if (ret < 0)
+		return (-1);
+	bufsize = ret;
+	freespace = 0;
+	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);
+}
+
+static long 
+read_peak_buffer_cap_teac(SCSI *usalp)
+{
+	Uchar	xx[4];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)xx, sizeof (xx), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)xx;
+	scmd->size = sizeof (xx);
+	scmd->flags = SCG_RECV_DATA |SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = SC_READ_PEAK_BUF_CAP;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "read peak buffer capacity";
+
+#define	BDEBUG
+#ifndef	BDEBUG
+	return (usal_cmd(usalp));
+#else
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (usalp->verbose) {
+		usal_prbytes("WRa Data", xx, sizeof (xx) - usal_getresid(usalp));
+		printf("Buffer cap: %ld\n", a_to_u_3_byte(&xx[1]));
+	}
+	return (a_to_u_3_byte(&xx[1]));
+/*	return (0);*/
+#endif
+}
+
+#define	BI_ONE_BYTE	0xC0
+#define	BI_448_BYTE	0x40
+#define	BI_APP_CODE	0x10
+
+static int 
+buffer_inquiry_teac(SCSI *usalp, int fmt)
+{
+	Uchar	xx[448];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)xx, sizeof (xx), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)xx;
+	scmd->size = sizeof (xx);
+	scmd->size = 448;
+	scmd->flags = SCG_RECV_DATA |SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = SC_BUFFER_INQUIRY;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	if (fmt > 0) {
+		scmd->cdb.g5_cdb.addr[3] = fmt;
+		if (fmt == BI_ONE_BYTE)
+			scmd->size = 1;
+	} else {
+		scmd->cdb.g5_cdb.addr[3] = BI_448_BYTE;
+/*		scmd->cdb.g5_cdb.addr[3] = BI_APP_CODE;*/
+	}
+
+	usalp->cmdname = "buffer inquiry";
+
+#define	BDEBUG
+#ifndef	BDEBUG
+	return (usal_cmd(usalp));
+#else
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (usalp->verbose) {
+/*		usal_prbytes("WRa Data", xx, sizeof (xx) - usal_getresid(usalp));*/
+/*		usal_prbytes("WRa Data", xx, 1);*/
+
+		if (fmt > 0) printf("fmt: %X ", fmt);
+		usal_prbytes("WRa Data", xx, 9);
+		printf("%d\n", xx[8] - xx[1]);
+/*		printf("Buffer cap: %ld\n", a_to_u_3_byte(&xx[1]));*/
+	}
+	return (0);
+#endif
+}
+
+#ifdef	XXBUFFER
+static void 
+check_buffer_teac(SCSI *usalp)
+{
+	printf("-------\n");
+	buffer_inquiry_teac(usalp, 0);
+#ifdef	SL
+	usleep(40000);
+	buffer_inquiry_teac(usalp, 0);
+#endif
+	read_peak_buffer_cap_teac(usalp);
+}
+#endif
+/*--------------------------------------------------------------------------*/
+#ifdef	XXDEBUG
+#include "scsimmc.h"
+
+static	int	g7_teac(SCSI *usalp);
+static	int	g6_teac(SCSI *usalp);
+
+static int 
+g7_teac(SCSI *usalp)
+{
+	Uchar	xx[2048];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)xx, sizeof (xx), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)xx;
+	scmd->size = sizeof (xx);
+	scmd->flags = SCG_RECV_DATA |SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+
+	scmd->cdb.g5_cdb.cmd = 0xDf;
+/*	scmd->cdb.g5_cdb.cmd = 0xE5;*/
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+/*	scmd->cdb.g5_cdb.addr[3] = BI_ONE_BYTE;*/
+/*	scmd->size = 1;*/
+
+/*	scmd->cdb.g5_cdb.addr[3] = BI_448_BYTE;*/
+/*	scmd->cdb.g5_cdb.addr[3] = BI_APP_CODE;*/
+
+	usalp->cmdname = "g7 teac";
+
+/*	return (usal_cmd(usalp));*/
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+/*	if (usalp->verbose) {*/
+		usal_prbytes("WRa Data", xx, sizeof (xx) - usal_getresid(usalp));
+/*		usal_prbytes("WRa Data", xx, 1);*/
+/*		usal_prbytes("WRa Data", xx, 9);*/
+/*printf("%d\n", xx[8] - xx[1]);*/
+/*		printf("Buffer cap: %ld\n", a_to_u_3_byte(&xx[1]));*/
+/*	}*/
+	return (0);
+}
+
+static int 
+g6_teac(SCSI *usalp)
+{
+	Uchar	xx[2048];
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)xx, sizeof (xx), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)xx;
+	scmd->size = sizeof (xx);
+	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 = 0xC1;
+	scmd->cdb.g1_cdb.cmd = 0xC3;
+	scmd->cdb.g1_cdb.cmd = 0xC6;
+	scmd->cdb.g1_cdb.cmd = 0xC7;	/* Read TOC */
+	scmd->cdb.g1_cdb.cmd = 0xCe;
+	scmd->cdb.g1_cdb.cmd = 0xCF;
+	scmd->cdb.g1_cdb.cmd = 0xC7;	/* Read TOC */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "g6 teac";
+
+/*	return (usal_cmd(usalp));*/
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+/*	if (usalp->verbose) {*/
+		usal_prbytes("WRa Data", xx, sizeof (xx) - usal_getresid(usalp));
+/*		usal_prbytes("WRa Data", xx, 1);*/
+/*		usal_prbytes("WRa Data", xx, 9);*/
+/*printf("%d\n", xx[8] - xx[1]);*/
+/*		printf("Buffer cap: %ld\n", a_to_u_3_byte(&xx[1]));*/
+/*	}*/
+	return (0);
+}
+
+static void 
+xxtest_teac(SCSI *usalp)
+{
+	read_peak_buffer_cap_teac(usalp);
+
+/*#define	XDI*/
+#ifdef	XDI
+	{
+		Uchar cbuf[512];
+
+/*		read_disk_info_teac(usalp, data, length, type)*/
+/*		read_disk_info_teac(usalp, cbuf, 512, 2);*/
+/*		read_disk_info_teac(usalp, cbuf, 512, 2);*/
+		read_disk_info_teac(usalp, cbuf, 512, 3);
+		usal_prbytes("DI Data", cbuf, sizeof (cbuf) - usal_getresid(usalp));
+	}
+#endif	/* XDI */
+
+	buffer_inquiry_teac(usalp, -1);
+
+/*#define	XBU*/
+#ifdef	XBU
+	{
+		int i;
+
+		for (i = 0; i < 63; i++) {
+			usalp->silent++;
+			buffer_inquiry_teac(usalp, i<<2);
+			usalp->silent--;
+		}
+	}
+#endif	/* XBU */
+
+/*	printf("LLLL\n");*/
+/*	g7_teac(usalp);*/
+/*	g6_teac(usalp);*/
+}
+#endif	/* XXDEBUG */
diff --git a/wodim/drv_mmc.c b/wodim/drv_mmc.c
new file mode 100644
index 0000000..b075889
--- /dev/null
+++ b/wodim/drv_mmc.c
@@ -0,0 +1,4362 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)drv_mmc.c	1.163 06/01/12 Copyright 1997-2006 J. Schilling */
+/*
+ *	CDR device implementation for
+ *	SCSI-3/mmc conforming drives
+ *	e.g. Yamaha CDR-400, Ricoh MP6200
+ *
+ *	Copyright (c) 1997-2006 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.
+ */
+
+/*#define	DEBUG*/
+#define	PRINT_ATIP
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <standard.h>
+#include <fctldefs.h>
+#include <errno.h>
+#include <strdefs.h>
+#include <stdxlib.h>
+#include <unixstd.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 "mmcvendor.h"
+#include "wodim.h"
+#include "scsi_scan.h"
+
+extern	char	*driveropts;
+
+extern	int	debug;
+extern	int	lverbose;
+extern	int	xdebug;
+
+static	int	curspeed = 1;
+
+static	char	clv_to_speed[16] = {
+/*		0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 */
+		0, 2, 4, 6, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static	char	hs_clv_to_speed[16] = {
+/*		0  1  2  3  4  5  6  7   8  9 10 11 12 13 14 15 */
+		0, 2, 4, 6, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static	char	us_clv_to_speed[16] = {
+/*		0  1  2  3  4  5   6  7  8   9   10  11 12 13 14 15 */
+		0, 2, 4, 8, 0, 0, 16, 0, 24, 32, 40, 48, 0, 0, 0, 0
+};
+
+#ifdef	__needed__
+static	int	mmc_load(SCSI *usalp, cdr_t *dp);
+static	int	mmc_unload(SCSI *usalp, cdr_t *dp);
+#endif
+void				mmc_opthelp(cdr_t *dp, int excode);
+char				*hasdrvopt(char *optstr, char *optname);
+static	cdr_t	*identify_mmc(SCSI *usalp, cdr_t *, struct scsi_inquiry *);
+static	int	attach_mmc(SCSI *usalp, cdr_t *);
+static   int   attach_mdvd(SCSI *usalp, cdr_t *);
+int				check_writemodes_mmc(SCSI *usalp, cdr_t *dp);
+int     			check_writemodes_mdvd(SCSI *usalp, cdr_t *dp);
+static	int	deflt_writemodes_mmc(SCSI *usalp, BOOL reset_dummy);
+static   int   deflt_writemodes_mdvd(SCSI *usalp, BOOL reset_dummy);
+static	int	get_diskinfo(SCSI *usalp, struct disk_info *dip);
+static	void	di_to_dstat(struct disk_info *dip, dstat_t *dsp);
+static	int	get_atip(SCSI *usalp, struct atipinfo *atp);
+#ifdef	PRINT_ATIP
+static	int	get_pma(SCSI *usalp);
+#endif
+static	int	init_mmc(SCSI *usalp, cdr_t *dp);
+static	int	getdisktype_mmc(SCSI *usalp, cdr_t *dp);
+static  int   getdisktype_mdvd(SCSI *usalp, cdr_t *dp);
+static	int	speed_select_mmc(SCSI *usalp, cdr_t *dp, int *speedp);
+static  int   speed_select_mdvd(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	mmc_set_speed(SCSI *usalp, int readspeed, int writespeed, 
+									  int rotctl);
+static	int	next_wr_addr_mmc(SCSI *usalp, track_t *trackp, long *ap);
+static  int   next_wr_addr_mdvd(SCSI *usalp, track_t *trackp, long *ap);
+static	int	write_leadin_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	open_track_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static  int   open_track_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	close_track_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static  int   close_track_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp); 
+static	int	open_session_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static  int   open_session_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	waitfix_mmc(SCSI *usalp, int secs);
+static	int	fixate_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static  int   fixate_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	blank_mmc(SCSI *usalp, cdr_t *dp, long addr, int blanktype);
+static	int	format_mdvd(SCSI *usalp, cdr_t *dp, int formattype);
+static	int	send_opc_mmc(SCSI *usalp, caddr_t, int cnt, int doopc);
+static	int	opt1_mmc(SCSI *usalp, cdr_t *dp);
+static	int	opt1_mdvd(SCSI *usalp, cdr_t *dp);
+static	int	opt2_mmc(SCSI *usalp, cdr_t *dp);
+static	int	scsi_sony_write(SCSI *usalp, caddr_t bp, long sectaddr, long size, 
+										 int blocks, BOOL islast);
+static	int	gen_cue_mmc(track_t *trackp, void *vcuep, BOOL needgap);
+static	void	fillcue(struct mmc_cue *cp, int ca, int tno, int idx, int dataform,
+							 int scms, msf_t *mp);
+static	int	send_cue_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static 	int	stats_mmc(SCSI *usalp, cdr_t *dp);
+static 	BOOL	mmc_isplextor(SCSI *usalp);
+static 	BOOL	mmc_isyamaha(SCSI *usalp);
+static 	void	do_varirec_plextor(SCSI *usalp);
+static 	int	do_gigarec_plextor(SCSI *usalp);
+static 	int	drivemode_plextor(SCSI *usalp, caddr_t bp, int cnt, int modecode, 
+											void *modeval);
+static 	int	drivemode2_plextor(SCSI *usalp, caddr_t bp, int cnt, int modecode, 
+											 void *modeval);
+static 	int	check_varirec_plextor(SCSI *usalp);
+static 	int	check_gigarec_plextor(SCSI *usalp);
+static 	int	varirec_plextor(SCSI *usalp, BOOL on, int val);
+static 	int	gigarec_plextor(SCSI *usalp, int val);
+static 	Int32_t	gigarec_mult(int code, Int32_t	val);
+static 	int	check_ss_hide_plextor(SCSI *usalp);
+static 	int	check_speed_rd_plextor(SCSI *usalp);
+static 	int	check_powerrec_plextor(SCSI *usalp);
+static 	int	ss_hide_plextor(SCSI *usalp, BOOL do_ss, BOOL do_hide);
+static 	int	speed_rd_plextor(SCSI *usalp, BOOL do_speedrd);
+static 	int	powerrec_plextor(SCSI *usalp, BOOL do_powerrec);
+static 	int	get_speeds_plextor(SCSI *usalp, int *selp, int *maxp, int *lastp);
+static 	int	bpc_plextor(SCSI *usalp, int mode, int *bpp);
+static 	int	set_audiomaster_yamaha(SCSI *usalp, cdr_t *dp, BOOL keep_mode);
+
+struct 	ricoh_mode_page_30 * get_justlink_ricoh(SCSI *usalp, Uchar *mode);
+static 	int	force_speed_yamaha(SCSI *usalp, int readspeed, int writespeed);
+static 	BOOL	get_tattoo_yamaha(SCSI *usalp, BOOL print, Int32_t *irp, 
+										Int32_t *orp);
+static 	int	do_tattoo_yamaha(SCSI *usalp, FILE *f);
+static 	int	yamaha_write_buffer(SCSI *usalp, int mode, int bufferid, long offset,
+										  long parlen, void *buffer, long buflen);
+static	int	dvd_dual_layer_split(SCSI *usalp, cdr_t *dp, long tsize);
+
+extern int 	reserve_track(SCSI *usalp, Ulong size); /* FIXME */
+extern int 	scsi_format(SCSI *usalp, caddr_t addr, int size, BOOL background); /* FIXME */
+
+#ifdef	__needed__
+static int 
+mmc_load(SCSI *usalp, cdr_t *dp)
+{
+	return (scsi_load_unload(usalp, 1));
+}
+
+static int 
+mmc_unload(SCSI *usalp, cdr_t *dp)
+{
+	return (scsi_load_unload(usalp, 0));
+}
+#endif
+
+/*
+ * MMC CD-writer
+ */
+cdr_t	cdr_mmc = {
+	0, 0,
+	CDR_SWABAUDIO,
+	CDR_CDRW_ALL,
+	372, 372,
+	"mmc_cdr",
+	"generic SCSI-3/mmc   CD-R/CD-RW driver",
+	0,
+	(dstat_t *)0,
+	identify_mmc,
+	attach_mmc,
+	init_mmc,
+	getdisktype_mmc,
+	scsi_load,
+	scsi_unload,
+	read_buff_cap,
+	cmd_dummy,					/* check_recovery */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_mmc,
+	select_secsize,
+	next_wr_addr_mmc,
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	scsi_cdr_write,
+	gen_cue_mmc,
+	send_cue_mmc,
+	write_leadin_mmc,
+	open_track_mmc,
+	close_track_mmc,
+	open_session_mmc,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	fixate_mmc,
+	stats_mmc,
+	blank_mmc,
+	format_dummy,
+	send_opc_mmc,
+	opt1_mmc,
+	opt2_mmc,
+};
+
+cdr_t   cdr_mdvd = {
+	0, 0,
+	CDR_SWABAUDIO,
+	CDR_CDRW_ALL,
+	370,370,
+	"mmc_mdvd",
+	"generic SCSI-3/mmc DVD-R(W) driver",
+	0,
+	(dstat_t *)0,
+	identify_mmc,
+	attach_mdvd,
+	init_mmc,
+	getdisktype_mdvd,
+	scsi_load,
+	scsi_unload,
+	read_buff_cap,
+	cmd_dummy,                                       /* check_recovery */
+	(int(*)__PR((SCSI *, cdr_t *, int)))cmd_dummy,   /* recover     */
+	speed_select_mdvd,
+	select_secsize,
+	next_wr_addr_mdvd,
+	(int(*)(SCSI *, Ulong))cmd_ill,   /* reserve_track        */
+	scsi_cdr_write,
+	(int(*)__PR((track_t *, void *, BOOL)))cmd_dummy, /* gen_cue */
+	(int(*)__PR((SCSI *usalp, cdr_t *, track_t *)))cmd_dummy, /* send_cue */
+	write_leadin_mmc,
+	open_track_mdvd,
+	close_track_mdvd,
+	open_session_mdvd,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	fixate_mdvd,
+	stats_mmc,
+	blank_mmc,
+	format_mdvd,
+	send_opc_mmc,
+	opt1_mdvd,
+	opt2_mmc,
+	dvd_dual_layer_split,
+};
+
+/*
+ * Sony MMC CD-writer
+ */
+cdr_t	cdr_mmc_sony = {
+	0, 0,
+	CDR_SWABAUDIO,
+	CDR_CDRW_ALL,
+	372, 372,
+	"mmc_cdr_sony",
+	"generic SCSI-3/mmc   CD-R/CD-RW driver (Sony 928 variant)",
+	0,
+	(dstat_t *)0,
+	identify_mmc,
+	attach_mmc,
+	init_mmc,
+	getdisktype_mmc,
+	scsi_load,
+	scsi_unload,
+	read_buff_cap,
+	cmd_dummy,					/* check_recovery */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_mmc,
+	select_secsize,
+	next_wr_addr_mmc,
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	scsi_sony_write,
+	gen_cue_mmc,
+	send_cue_mmc,
+	write_leadin_mmc,
+	open_track_mmc,
+	close_track_mmc,
+	open_session_mmc,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	fixate_mmc,
+	cmd_dummy,				/* stats		*/
+	blank_mmc,
+	format_dummy,
+	send_opc_mmc,
+	opt1_mmc,
+	opt2_mmc,
+};
+
+/*
+ * SCSI-3/mmc conformant CD-ROM drive
+ */
+cdr_t	cdr_cd = {
+	0, 0,
+	CDR_ISREADER|CDR_SWABAUDIO,
+	CDR_CDRW_NONE,
+	372, 372,
+	"mmc_cd",
+	"generic SCSI-3/mmc   CD-ROM driver",
+	0,
+	(dstat_t *)0,
+	identify_mmc,
+	attach_mmc,
+	cmd_dummy,
+	drive_getdisktype,
+	scsi_load,
+	scsi_unload,
+	read_buff_cap,
+	cmd_dummy,					/* check_recovery */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_mmc,
+	select_secsize,
+	(int(*)(SCSI *usalp, track_t *, long *))cmd_ill,	/* next_wr_addr		*/
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	scsi_cdr_write,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_mmc,
+	close_track_mmc,
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy,	/* fixation */
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+/*
+ * Old pre SCSI-3/mmc CD drive
+ */
+cdr_t	cdr_oldcd = {
+	0, 0,
+	CDR_ISREADER,
+	CDR_CDRW_NONE,
+	372, 372,
+	"scsi2_cd",
+	"generic SCSI-2       CD-ROM driver",
+	0,
+	(dstat_t *)0,
+	identify_mmc,
+	drive_attach,
+	cmd_dummy,
+	drive_getdisktype,
+	scsi_load,
+	scsi_unload,
+	buf_dummy,
+	cmd_dummy,					/* check_recovery */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_mmc,
+	select_secsize,
+	(int(*)(SCSI *usal, track_t *, long *))cmd_ill,	/* next_wr_addr		*/
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	scsi_cdr_write,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_mmc,
+	close_track_mmc,
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy,	/* fixation */
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+/*
+ * SCSI-3/mmc conformant CD or DVD writer
+ * Checks the current medium and then returns either cdr_mmc or cdr_dvd
+ */
+cdr_t	cdr_cd_dvd = {
+	0, 0,
+	CDR_SWABAUDIO,
+	CDR_CDRW_ALL,
+	372, 372,
+	"mmc_cd_dvd",
+	"generic SCSI-3/mmc   CD/DVD driver (checks media)",
+	0,
+	(dstat_t *)0,
+	identify_mmc,
+	attach_mmc,
+	cmd_dummy,
+	drive_getdisktype,
+	scsi_load,
+	scsi_unload,
+	read_buff_cap,
+	cmd_dummy,					/* check_recovery */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_mmc,
+	select_secsize,
+	(int(*)(SCSI *usalp, track_t *, long *))cmd_ill,	/* next_wr_addr		*/
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	scsi_cdr_write,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_mmc,
+	close_track_mmc,
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy,	/* fixation */
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+void 
+mmc_opthelp(cdr_t *dp, int excode)
+{
+	BOOL	haveopts = FALSE;
+
+	fprintf(stderr, "Driver options:\n");
+	if (dp->cdr_flags & CDR_BURNFREE) {
+		fprintf(stderr, "burnfree	Prepare writer to use BURN-Free technology\n");
+		fprintf(stderr, "noburnfree	Disable using BURN-Free technology\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_VARIREC) {
+		fprintf(stderr, "varirec=val	Set VariRec Laserpower to -2, -1, 0, 1, 2\n");
+		fprintf(stderr, "		Only works for audio and if speed is set to 4\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_GIGAREC) {
+		fprintf(stderr, "gigarec=val	Set GigaRec capacity ratio to 0.6, 0.7, 0.8, 1.0, 1.2, 1.3, 1.4\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_AUDIOMASTER) {
+		fprintf(stderr, "audiomaster	Turn Audio Master feature on (SAO CD-R Audio/Data only)\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_FORCESPEED) {
+		fprintf(stderr, "forcespeed	Tell the drive to force speed even for low quality media\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_SPEEDREAD) {
+		fprintf(stderr, "speedread	Tell the drive to read as fast as possible\n");
+		fprintf(stderr, "nospeedread	Disable to read as fast as possible\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_DISKTATTOO) {
+		fprintf(stderr, "tattooinfo	Print image size info for DiskT@2 feature\n");
+		fprintf(stderr, "tattoofile=name	Use 'name' as DiskT@2 image file\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_SINGLESESS) {
+		fprintf(stderr, "singlesession	Tell the drive to behave as single session only drive\n");
+		fprintf(stderr, "nosinglesession	Disable single session only mode\n");
+		haveopts = TRUE;
+	}
+	if (dp->cdr_flags & CDR_HIDE_CDR) {
+		fprintf(stderr, "hidecdr		Tell the drive to hide CD-R media\n");
+		fprintf(stderr, "nohidecdr	Disable hiding CD-R media\n");
+		haveopts = TRUE;
+	}
+	if (!haveopts) {
+		fprintf(stderr, "None supported for this drive.\n");
+	}
+	exit(excode);
+}
+
+char *
+hasdrvopt(char *optstr, char *optname)
+{
+	char	*ep;
+	char	*np;
+	char	*ret = NULL;
+	int	optnamelen;
+	int	optlen;
+	BOOL	not = FALSE;
+
+	if (optstr == NULL)
+		return (ret);
+
+	optnamelen = strlen(optname);
+
+	while (*optstr) {
+		not = FALSE;			/* Reset before every token */
+		if ((ep = strchr(optstr, ',')) != NULL) {
+			optlen = ep - optstr;
+			np = &ep[1];
+		} else {
+			optlen = strlen(optstr);
+			np = &optstr[optlen];
+		}
+		if ((ep = strchr(optstr, '=')) != NULL) {
+			if (ep < np)
+				optlen = ep - optstr;
+		}
+		if (optstr[0] == '!') {
+			optstr++;
+			optlen--;
+			not = TRUE;
+		}
+		if (strncmp(optstr, "no", 2) == 0) {
+			optstr += 2;
+			optlen -= 2;
+			not = TRUE;
+		}
+		if (strncmp(optstr, optname, optlen) == 0) {
+			ret = &optstr[optlen];
+			break;
+		}
+		optstr = np;
+	}
+	if (ret != NULL) {
+		if (*ret == ',' || *ret == '\0') {
+			if (not)
+				return ("0");
+			return ("1");
+		}
+		if (*ret == '=') {
+			if (not)
+				return (NULL);
+			return (++ret);
+		}
+	}
+	return (ret);
+}
+
+static cdr_t *
+identify_mmc(SCSI *usalp, cdr_t *dp, struct scsi_inquiry *ip)
+{
+	BOOL	cdrr	 = FALSE;	/* Read CD-R	*/
+	BOOL	cdwr	 = FALSE;	/* Write CD-R	*/
+	BOOL	cdrrw	 = FALSE;	/* Read CD-RW	*/
+	BOOL	cdwrw	 = FALSE;	/* Write CD-RW	*/
+	BOOL	dvdwr	 = FALSE;	/* DVD writer	*/
+	BOOL	is_dvd	 = FALSE;	/* use DVD driver*/
+	Uchar	mode[0x100];
+	struct	cd_mode_page_2A *mp;
+	int	profile;
+
+	if (ip->type != INQ_WORM && ip->type != INQ_ROMD)
+		return ((cdr_t *)0);
+
+	allow_atapi(usalp, TRUE); /* Try to switch to 10 byte mode cmds */
+
+	usalp->silent++;
+	mp = mmc_cap(usalp, mode);	/* Get MMC capabilities */
+	usalp->silent--;
+	if (mp == NULL)
+		return (&cdr_oldcd);	/* Pre SCSI-3/mmc drive		*/
+
+	/*
+	 * At this point we know that we have a SCSI-3/mmc compliant drive.
+	 * Unfortunately ATAPI drives violate the SCSI spec in returning
+	 * a response data format of '1' which from the SCSI spec would
+	 * tell us not to use the "PF" bit in mode select. As ATAPI drives
+	 * require the "PF" bit to be set, we 'correct' the inquiry data.
+	 *
+	 * XXX xxx_identify() should not have any side_effects ??
+	 */
+	if (ip->data_format < 2)
+		ip->data_format = 2;
+
+	/*
+	 * First handle exceptions....
+	 */
+	if (strncmp(ip->vendor_info, "SONY", 4) == 0 &&
+	    strncmp(ip->prod_ident, "CD-R   CDU928E", 14) == 0) {
+		return (&cdr_mmc_sony);
+	}
+
+	/*
+	 * Now try to do it the MMC-3 way....
+	 */
+	profile = get_curprofile(usalp);
+	if (xdebug)
+		printf("Current profile: 0x%04X\n", profile);
+	if (profile == 0) {
+		if (xdebug)
+			print_profiles(usalp);
+		/*
+		 * If the current profile is 0x0000, then the
+		 * drive does not know about the media. First
+		 * close the tray and then try to issue the
+		 * get_curprofile() command again.
+		 */
+		usalp->silent++;
+		load_media(usalp, dp, FALSE);
+		usalp->silent--;
+		profile = get_curprofile(usalp);
+		scsi_prevent_removal(usalp, 0);
+		if (xdebug)
+			printf("Current profile: 0x%04X\n", profile);
+	}
+	if (profile >= 0) {
+		if (lverbose)
+			print_profiles(usalp);
+		if (profile == 0 || (profile >= 0x10 && profile <= 0x15) || profile > 0x19) {
+		    /*
+		     * 10h DVD-ROM
+		     * 11h DVD-R
+		     * 12h DVD-RAM
+		     * 13h DVD-RW (Restricted overwrite)
+		     * 14h DVD-RW (Sequential recording)
+		     * 1Ah DVD+RW
+		     * 1Bh DVD+R
+		     * 2Bh DVD+R DL
+		     * 
+		     */
+		    if (profile == 0x11 || profile == 0x13 || profile == 0x14 || profile == 0x1A || profile == 0x1B || profile == 0x2B) {
+			is_dvd = TRUE;
+			dp = &cdr_mdvd;
+		    } else {
+			is_dvd = FALSE;
+			dp = &cdr_cd;
+
+			if (profile == 0) {		/* No Medium */
+				BOOL	is_cdr = FALSE;
+
+				/*
+				 * Check for CD-writer
+				 */
+				get_wproflist(usalp, &is_cdr, NULL,
+							NULL, NULL);
+				if (is_cdr)
+					return (&cdr_mmc);
+				/*
+				 * Other MMC-3 drive without media
+				 */
+				return (dp);
+			} if (profile == 0x12) {	/* DVD-RAM */
+				errmsgno(EX_BAD,
+				"Found unsupported DVD-RAM media.\n");
+				return (dp);
+			}
+		    }
+		}
+	} else {
+		if (xdebug)
+			printf("Drive is pre MMC-3\n");
+	}
+
+	mmc_getval(mp, &cdrr, &cdwr, &cdrrw, &cdwrw, NULL, &dvdwr);
+
+	if (!cdwr && !cdwrw) {	/* SCSI-3/mmc CD drive		*/
+		/*
+		 * If the drive does not support to write CD's, we select the
+		 * CD-ROM driver here. If we have DVD-R/DVD-RW support compiled
+		 * in, we may later decide to switch to the DVD driver.
+		 */
+		dp = &cdr_cd;
+	} else {
+		/*
+		 * We need to set the driver to cdr_mmc because we may come
+		 * here with driver set to cdr_cd_dvd which is not a driver
+		 * that may be used for actual CD/DVD writing.
+		 */
+		dp = &cdr_mmc;
+	}
+
+/*#define	DVD_DEBUG*/
+#ifdef	DVD_DEBUG
+	if (1) {	/* Always check for DVD media in debug mode */
+#else
+	if ((cdwr || cdwrw) && dvdwr) {
+#endif
+		char	xb[32];
+
+#ifndef	DVD_DEBUG
+		usalp->silent++;
+#else
+		fprintf(stderr, "identify_dvd: checking for DVD media\n");
+#endif
+		if (read_dvd_structure(usalp, (caddr_t)xb, 32, 0, 0, 0) >= 0) {
+			/*
+			 * If read DVD structure is supported and works, then
+			 * we must have a DVD media in the drive. Signal to
+			 * use the DVD driver.
+			 */
+			is_dvd = TRUE;
+		} else {
+			if (usal_sense_key(usalp) == SC_NOT_READY) {
+				/*
+				 * If the SCSI sense key is NOT READY, then the
+				 * drive does not know about the media. First
+				 * close the tray and then try to issue the
+				 * read_dvd_structure() command again.
+				 */
+				load_media(usalp, dp, FALSE);
+				if (read_dvd_structure(usalp, (caddr_t)xb, 32, 0, 0, 0) >= 0) {
+					is_dvd = TRUE;
+				}
+				scsi_prevent_removal(usalp, 0);
+			}
+		}
+#ifndef	DVD_DEBUG
+		usalp->silent--;
+#else
+		fprintf(stderr, "identify_dvd: is_dvd: %d\n", is_dvd);
+#endif
+	}
+	if (is_dvd) {
+     if(lverbose>2) 
+        fprintf(stderr, "Found DVD media: using cdr_mdvd.\n");  
+     dp = &cdr_mdvd; 
+	}
+	dp->profile = profile;
+	dp->is_dvd = is_dvd;
+	return (dp);
+}
+
+static int 
+attach_mmc(SCSI *usalp, cdr_t *dp)
+{
+	int	ret;
+	Uchar	mode[0x100];
+	struct	cd_mode_page_2A *mp;
+	struct	ricoh_mode_page_30 *rp = NULL;
+
+	allow_atapi(usalp, TRUE); /* Try to switch to 10 byte mode cmds */
+
+	usalp->silent++;
+	mp = mmc_cap(usalp, NULL); /* Get MMC capabilities in allocated mp */
+	usalp->silent--;
+	if (mp == NULL)
+		return (-1);	/* Pre SCSI-3/mmc drive		*/
+
+	dp->cdr_cdcap = mp;	/* Store MMC cap pointer	*/
+
+	dp->cdr_dstat->ds_dr_max_rspeed = a_to_u_2_byte(mp->max_read_speed)/176;
+	if (dp->cdr_dstat->ds_dr_max_rspeed == 0)
+		dp->cdr_dstat->ds_dr_max_rspeed = 372;
+	dp->cdr_dstat->ds_dr_cur_rspeed = a_to_u_2_byte(mp->cur_read_speed)/176;
+	if (dp->cdr_dstat->ds_dr_cur_rspeed == 0)
+		dp->cdr_dstat->ds_dr_cur_rspeed = 372;
+
+	dp->cdr_dstat->ds_dr_max_wspeed = a_to_u_2_byte(mp->max_write_speed)/176;
+	if (mp->p_len >= 28)
+		dp->cdr_dstat->ds_dr_cur_wspeed = a_to_u_2_byte(mp->v3_cur_write_speed)/176;
+	else
+		dp->cdr_dstat->ds_dr_cur_wspeed = a_to_u_2_byte(mp->cur_write_speed)/176;
+
+	if (dp->cdr_speedmax > dp->cdr_dstat->ds_dr_max_wspeed)
+		dp->cdr_speedmax = dp->cdr_dstat->ds_dr_max_wspeed;
+
+	if (dp->cdr_speeddef > dp->cdr_speedmax)
+		dp->cdr_speeddef = dp->cdr_speedmax;
+
+	rp = get_justlink_ricoh(usalp, mode);
+
+	if (mp->p_len >= 28)
+		dp->cdr_flags |= CDR_MMC3;
+	if (mp->p_len >= 24)
+		dp->cdr_flags |= CDR_MMC2;
+	dp->cdr_flags |= CDR_MMC;
+
+	if (mp->loading_type == LT_TRAY)
+		dp->cdr_flags |= CDR_TRAYLOAD;
+	else if (mp->loading_type == LT_CADDY)
+		dp->cdr_flags |= CDR_CADDYLOAD;
+
+	if (mp->BUF != 0) {
+		dp->cdr_flags |= CDR_BURNFREE;
+	} else if (rp) {
+		if ((dp->cdr_cmdflags & F_DUMMY) && rp->TWBFS && rp->BUEFS)
+			dp->cdr_flags |= CDR_BURNFREE;
+
+		if (rp->BUEFS)
+			dp->cdr_flags |= CDR_BURNFREE;
+	}
+
+	if (mmc_isplextor(usalp)) {
+		if (check_varirec_plextor(usalp) >= 0)
+			dp->cdr_flags |= CDR_VARIREC;
+
+		if (check_gigarec_plextor(usalp) >= 0)
+			dp->cdr_flags |= CDR_GIGAREC;
+
+		if (check_ss_hide_plextor(usalp) >= 0)
+			dp->cdr_flags |= CDR_SINGLESESS|CDR_HIDE_CDR;
+
+		if (check_powerrec_plextor(usalp) >= 0)
+			dp->cdr_flags |= CDR_FORCESPEED;
+
+		if (check_speed_rd_plextor(usalp) >= 0)
+			dp->cdr_flags |= CDR_SPEEDREAD;
+	}
+	if (mmc_isyamaha(usalp)) {
+		if (set_audiomaster_yamaha(usalp, dp, FALSE) >= 0)
+			dp->cdr_flags |= CDR_AUDIOMASTER;
+
+		/*
+		 * Starting with CRW 2200 / CRW 3200
+		 */
+		if ((mp->p_len+2) >= (unsigned)28)
+			dp->cdr_flags |= CDR_FORCESPEED;
+
+		if (get_tattoo_yamaha(usalp, FALSE, 0, 0))
+			dp->cdr_flags |= CDR_DISKTATTOO;
+	}
+
+	if (rp && rp->AWSCS)
+		dp->cdr_flags |= CDR_FORCESPEED;
+
+#ifdef	FUTURE_ROTCTL
+	if (mp->p_len >= 28) {
+		int	val;
+
+		val = dp->cdr_dstat->ds_dr_cur_wspeed;
+		if (val == 0)
+			val = 372;
+
+		usalp->verbose++;
+		if (scsi_set_speed(usalp, -1, val, ROTCTL_CAV) < 0) {
+			fprintf(stderr, "XXX\n");
+		}
+		usalp->verbose--;
+	}
+#endif
+
+	check_writemodes_mmc(usalp, dp);
+
+	/* Enable Burnfree by default, it can be disabled later */
+	if ((dp->cdr_flags & CDR_BURNFREE) != 0)
+		dp->cdr_dstat->ds_cdrflags |= RF_BURNFREE;
+
+	if (driveropts != NULL) {
+		char	*p;
+
+		if (strcmp(driveropts, "help") == 0) {
+			mmc_opthelp(dp, 0);
+		}
+
+		p = hasdrvopt(driveropts, "varirec");
+		if (p != NULL && (dp->cdr_flags & CDR_VARIREC) != 0) {
+			dp->cdr_dstat->ds_cdrflags |= RF_VARIREC;
+		}
+
+		p = hasdrvopt(driveropts, "gigarec");
+		if (p != NULL && (dp->cdr_flags & CDR_GIGAREC) != 0) {
+			dp->cdr_dstat->ds_cdrflags |= RF_GIGAREC;
+		}
+
+		p = hasdrvopt(driveropts, "audiomaster");
+		if (p != NULL && *p == '1' && (dp->cdr_flags & CDR_AUDIOMASTER) != 0) {
+			dp->cdr_dstat->ds_cdrflags |= RF_AUDIOMASTER;
+			dp->cdr_dstat->ds_cdrflags &= ~RF_BURNFREE;
+		}
+		p = hasdrvopt(driveropts, "forcespeed");
+		if (p != NULL && *p == '1' && (dp->cdr_flags & CDR_FORCESPEED) != 0) {
+			dp->cdr_dstat->ds_cdrflags |= RF_FORCESPEED;
+		}
+		p = hasdrvopt(driveropts, "tattooinfo");
+		if (p != NULL && *p == '1' && (dp->cdr_flags & CDR_DISKTATTOO) != 0) {
+			get_tattoo_yamaha(usalp, TRUE, 0, 0);
+		}
+		p = hasdrvopt(driveropts, "tattoofile");
+		if (p != NULL && (dp->cdr_flags & CDR_DISKTATTOO) != 0) {
+			FILE	*f;
+
+			if ((f = fileopen(p, "rb")) == NULL)
+				comerr("Cannot open '%s'.\n", p);
+
+			if (do_tattoo_yamaha(usalp, f) < 0)
+				errmsgno(EX_BAD, "Cannot do DiskT@2.\n");
+			fclose(f);
+		}
+		p = hasdrvopt(driveropts, "singlesession");
+		if (p != NULL && (dp->cdr_flags & CDR_SINGLESESS) != 0) {
+			if (*p == '1') {
+				dp->cdr_dstat->ds_cdrflags |= RF_SINGLESESS;
+			} else if (*p == '0') {
+				dp->cdr_dstat->ds_cdrflags &= ~RF_SINGLESESS;
+			}
+		}
+		p = hasdrvopt(driveropts, "hidecdr");
+		if (p != NULL && (dp->cdr_flags & CDR_HIDE_CDR) != 0) {
+			if (*p == '1') {
+				dp->cdr_dstat->ds_cdrflags |= RF_HIDE_CDR;
+			} else if (*p == '0') {
+				dp->cdr_dstat->ds_cdrflags &= ~RF_HIDE_CDR;
+			}
+		}
+		p = hasdrvopt(driveropts, "speedread");
+		if (p != NULL && (dp->cdr_flags & CDR_SPEEDREAD) != 0) {
+			if (*p == '1') {
+				dp->cdr_dstat->ds_cdrflags |= RF_SPEEDREAD;
+			} else if (*p == '0') {
+				dp->cdr_dstat->ds_cdrflags &= ~RF_SPEEDREAD;
+			}
+		}
+	}
+
+	if ((ret = get_supported_cdrw_media_types(usalp)) < 0) {
+		dp->cdr_cdrw_support = CDR_CDRW_ALL;
+		return (0);
+	}
+	dp->cdr_cdrw_support = ret;
+	if (lverbose > 1)
+		printf("Supported CD-RW media types: %02X\n", dp->cdr_cdrw_support);
+
+	return (0);
+}
+
+static int 
+attach_mdvd(SCSI *usalp, cdr_t *dp)
+{
+	struct  cd_mode_page_2A *mp;
+
+
+	allow_atapi(usalp, TRUE);/* Try to switch to 10 byte mode cmds */
+
+	usalp->silent++;
+	mp = mmc_cap(usalp, NULL);/* Get MMC capabilities in allocated mp */
+	usalp->silent--;
+	if (mp == NULL)
+		return (-1);    /* Pre SCSI-3/mmc drive         */
+
+	dp->cdr_cdcap = mp;     /* Store MMC cap pointer        */
+
+	dp->cdr_dstat->ds_dr_max_rspeed = a_to_u_2_byte(mp->max_read_speed)/1385;
+	if (dp->cdr_dstat->ds_dr_max_rspeed == 0)
+		dp->cdr_dstat->ds_dr_max_rspeed = 1385;
+	dp->cdr_dstat->ds_dr_cur_rspeed = a_to_u_2_byte(mp->cur_read_speed)/1385;
+	if (dp->cdr_dstat->ds_dr_cur_rspeed == 0)
+		dp->cdr_dstat->ds_dr_cur_rspeed = 1385;
+
+	dp->cdr_dstat->ds_dr_max_wspeed = a_to_u_2_byte(mp->max_write_speed)/1385;
+	if (mp->p_len >= 28)
+		dp->cdr_dstat->ds_dr_cur_wspeed = a_to_u_2_byte(mp->v3_cur_write_speed)/1385;
+	else
+		dp->cdr_dstat->ds_dr_cur_wspeed = a_to_u_2_byte(mp->cur_write_speed)/1385;
+
+	if (dp->cdr_speedmax > dp->cdr_dstat->ds_dr_max_wspeed)
+		dp->cdr_speedmax = dp->cdr_dstat->ds_dr_max_wspeed;
+
+	if (dp->cdr_speeddef > dp->cdr_speedmax)
+		dp->cdr_speeddef = dp->cdr_speedmax;
+
+
+        if (mp->loading_type == LT_TRAY)
+                dp->cdr_flags |= CDR_TRAYLOAD;
+        else if (mp->loading_type == LT_CADDY)
+                dp->cdr_flags |= CDR_CADDYLOAD;
+
+        if (mp->BUF != 0)
+                dp->cdr_flags |= CDR_BURNFREE;
+
+        check_writemodes_mdvd(usalp, dp);
+
+        if (driveropts != NULL) {
+                if (strcmp(driveropts, "help") == 0) {
+                        mmc_opthelp(dp, 0);
+                }
+        }
+
+        return (0);
+}
+
+int 
+check_writemodes_mmc(SCSI *usalp, cdr_t *dp)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	if (xdebug)
+		printf("Checking possible write modes: ");
+
+	/*
+	 * Reset mp->test_write (-dummy) here.
+	 */
+	deflt_writemodes_mmc(usalp, TRUE);
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		usalp->silent--;
+		return (-1);
+	}
+	if (len == 0) {
+		usalp->silent--;
+		return (-1);
+	}
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+
+	/*
+	 * mp->test_write has already been reset in deflt_writemodes_mmc()
+	 * Do not reset mp->test_write (-dummy) here. It should be set
+	 * only at one place and only one time.
+	 */
+
+	mp->write_type = WT_TAO;
+	mp->track_mode = TM_DATA;
+	mp->dbtype = DB_ROM_MODE1;
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_TAO;
+		if (xdebug)
+			printf("TAO ");
+	} else
+		dp->cdr_flags &= ~CDR_TAO;
+
+	mp->write_type = WT_PACKET;
+	mp->track_mode |= TM_INCREMENTAL;
+/*	mp->fp = (trackp->pktsize > 0) ? 1 : 0;*/
+/*	i_to_4_byte(mp->packet_size, trackp->pktsize);*/
+	mp->fp = 0;
+	i_to_4_byte(mp->packet_size, 0);
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_PACKET;
+		if (xdebug)
+			printf("PACKET ");
+	} else
+		dp->cdr_flags &= ~CDR_PACKET;
+	mp->fp = 0;
+	i_to_4_byte(mp->packet_size, 0);
+	mp->track_mode = TM_DATA;
+	mp->write_type = WT_SAO;
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_SAO;
+		if (xdebug)
+			printf("SAO ");
+	} else
+		dp->cdr_flags &= ~CDR_SAO;
+
+	if (dp->cdr_flags & CDR_SAO) {
+		mp->dbtype = DB_RAW_PQ;
+
+#ifdef	__needed__
+		if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+			dp->cdr_flags |= CDR_SRAW16;
+			if (xdebug)
+				printf("SAO/R16 ");
+		}
+#endif
+
+		mp->dbtype = DB_RAW_PW;
+
+		if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+			dp->cdr_flags |= CDR_SRAW96P;
+			if (xdebug)
+				printf("SAO/R96P ");
+		}
+
+		mp->dbtype = DB_RAW_PW_R;
+
+		if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+			dp->cdr_flags |= CDR_SRAW96R;
+			if (xdebug)
+				printf("SAO/R96R ");
+		}
+	}
+
+	mp->write_type = WT_RAW;
+	mp->dbtype = DB_RAW_PQ;
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_RAW;
+		dp->cdr_flags |= CDR_RAW16;
+		if (xdebug)
+			printf("RAW/R16 ");
+	}
+
+	mp->dbtype = DB_RAW_PW;
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_RAW;
+		dp->cdr_flags |= CDR_RAW96P;
+		if (xdebug)
+			printf("RAW/R96P ");
+	}
+
+	mp->dbtype = DB_RAW_PW_R;
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_RAW;
+		dp->cdr_flags |= CDR_RAW96R;
+		if (xdebug)
+			printf("RAW/R96R ");
+	}
+
+	if (xdebug)
+		printf("\n");
+
+	/*
+	 * Reset mp->test_write (-dummy) here.
+	 */
+	deflt_writemodes_mmc(usalp, TRUE);
+	usalp->silent--;
+
+	return (0);
+}
+
+int 
+check_writemodes_mdvd(SCSI *usalp, cdr_t *dp)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	if (xdebug)
+		printf("Checking possible write modes: ");
+
+	deflt_writemodes_mdvd(usalp, FALSE);
+
+	fillbytes((caddr_t)mode, sizeof(mode), '\0');
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x05, "DVD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		usalp->silent--;
+		return (-1);
+	}
+	if (len == 0) {
+		usalp->silent--;
+		return (-1);
+	}
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof(struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	mp->test_write = 0;
+
+	/*We only check for PACKET and SAO since these are the only supported modes for DVD */
+	/*XXX these checks are irrelevant because they are not medium sensitive. ie the device returns 
+	  error only when it does not support a given mode for ALL mediums. It should check using 
+	  GET CONFIGURATION command.*/
+
+	mp->write_type = WT_PACKET;
+	mp->fp = 0;
+	i_to_4_byte(mp->packet_size, 0);
+
+	if (set_mode_params(usalp, "DVD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_PACKET;
+		if (xdebug)
+		  printf("PACKET ");
+	} else
+	  dp->cdr_flags &= ~CDR_PACKET;
+	mp->fp = 0;
+	i_to_4_byte(mp->packet_size, 0);
+	mp->track_mode = TM_DATA; 
+
+
+	mp->write_type = WT_SAO;
+
+	if (set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+		dp->cdr_flags |= CDR_SAO;
+		if (xdebug)
+			printf("SAO ");
+	} else
+		dp->cdr_flags &= ~CDR_SAO;
+
+
+	if (xdebug)
+		printf("\n");
+
+	deflt_writemodes_mdvd(usalp, TRUE);
+	usalp->silent--;
+	return (0);
+}
+
+static int 
+deflt_writemodes_mmc(SCSI *usalp, BOOL reset_dummy)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		usalp->silent--;
+		return (-1);
+	}
+	if (len == 0) {
+		usalp->silent--;
+		return (-1);
+	}
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+	fprintf(stderr, "Audio pause len: %d\n", a_to_2_byte(mp->audio_pause_len));
+#endif
+
+	/*
+	 * This is the only place where we reset mp->test_write (-dummy)
+	 */
+	if (reset_dummy)
+		mp->test_write = 0;
+
+	/*
+	 * Set default values:
+	 * Write type = 01 (track at once)
+	 * Track mode = 04 (CD-ROM)
+	 * Data block type = 08 (CD-ROM)
+	 * Session format = 00 (CD-ROM)
+	 *
+	 * XXX Note:	the same code appears in check_writemodes_mmc() and
+	 * XXX		in speed_select_mmc().
+	 */
+	mp->write_type = WT_TAO;
+	mp->track_mode = TM_DATA;
+	mp->dbtype = DB_ROM_MODE1;
+	mp->session_format = SES_DA_ROM; /* Matsushita has illegal def. value */
+
+	i_to_2_byte(mp->audio_pause_len, 150);	/* LG has illegal def. value */
+
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+
+		mp->write_type	= WT_SAO;
+		mp->LS_V	= 0;
+		mp->copy	= 0;
+		mp->fp		= 0;
+		mp->multi_session  = MS_NONE;
+		mp->host_appl_code = 0;
+
+		if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, -1)) {
+			usalp->silent--;
+			return (-1);
+		}
+	}
+	usalp->silent--;
+	return (0);
+}
+
+static int 
+deflt_writemodes_mdvd(SCSI *usalp, BOOL reset_dummy)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	fillbytes((caddr_t)mode, sizeof(mode), '\0');
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x05, "DVD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		usalp->silent--;
+		return (-1);
+	}
+	if (len == 0) {
+		usalp->silent--;
+		return (-1);
+	}
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof(struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	mp->test_write = 0;
+	/*
+	 * This is the only place where we reset mp->test_write (-dummy) for DVD
+	 */
+	if (reset_dummy)
+		mp->test_write = 0;
+
+	/*
+	 * Set default values:
+	 * Write type = 02 (session at once)
+	 *
+	 * XXX Note:	the same code appears in check_writemodes_mmc() and
+	 * XXX		in speed_select_mmc().
+	 */
+	mp->write_type = WT_SAO;
+	mp->track_mode = TM_DATA; 
+	mp->dbtype = DB_ROM_MODE1;
+	mp->session_format = SES_DA_ROM;
+
+
+	if (set_mode_params(usalp, "DVD write parameter", mode, len, 0, -1) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+	return (0);
+}
+
+#ifdef	PRINT_ATIP
+static	void	print_di(struct disk_info *dip);
+static	void	atip_printspeed(char *fmt, int speedindex, char speedtab[]);
+static	void	print_atip(SCSI *usalp, struct atipinfo *atp);
+#endif	/* PRINT_ATIP */
+
+static int 
+get_diskinfo(SCSI *usalp, struct disk_info *dip)
+{
+	int	len;
+	int	ret;
+
+	fillbytes((caddr_t)dip, sizeof (*dip), '\0');
+
+	/*
+	 * Used to be 2 instead of 4 (now). But some Y2k ATAPI drives as used
+	 * by IOMEGA create a DMA overrun if we try to transfer only 2 bytes.
+	 */
+/*	if (read_disk_info(usalp, (caddr_t)dip, 2) < 0)*/
+	if (read_disk_info(usalp, (caddr_t)dip, 4) < 0)
+		return (-1);
+	len = a_to_u_2_byte(dip->data_len);
+	len += 2;
+	ret = read_disk_info(usalp, (caddr_t)dip, len);
+
+#ifdef	DEBUG
+	usal_prbytes("Disk info:", (Uchar *)dip,
+				len-usal_getresid(usalp));
+#endif
+	return (ret);
+}
+
+static void 
+di_to_dstat(struct disk_info *dip, dstat_t *dsp)
+{
+	dsp->ds_diskid = a_to_u_4_byte(dip->disk_id);
+	if (dip->did_v)
+		dsp->ds_flags |= DSF_DID_V;
+	dsp->ds_disktype = dip->disk_type;
+	dsp->ds_diskstat = dip->disk_status;
+	dsp->ds_sessstat = dip->sess_status;
+	if (dip->erasable)
+		dsp->ds_flags |= DSF_ERA;
+
+	dsp->ds_trfirst	   = dip->first_track;
+	dsp->ds_trlast	   = dip->last_track_ls;
+	dsp->ds_trfirst_ls = dip->first_track_ls;
+
+	dsp->ds_maxblocks = msf_to_lba(dip->last_lead_out[1],
+					dip->last_lead_out[2],
+					dip->last_lead_out[3], TRUE);
+	/*
+	 * Check for 0xFF:0xFF/0xFF which is an indicator for a complete disk
+	 */
+	if (dsp->ds_maxblocks == 1166730)
+		dsp->ds_maxblocks = -1L;
+
+	dsp->ds_first_leadin = msf_to_lba(dip->last_lead_in[1],
+					dip->last_lead_in[2],
+					dip->last_lead_in[3], FALSE);
+	if (dsp->ds_first_leadin > 0)
+		dsp->ds_first_leadin = 0;
+
+	if (dsp->ds_last_leadout == 0 && dsp->ds_maxblocks >= 0)
+		dsp->ds_last_leadout = dsp->ds_maxblocks;
+	dsp->ds_trfirst=dip->first_track; 
+	dsp->ds_trlast=dip->last_track_ls;
+	dsp->ds_trfirst_ls=dip->first_track_ls;
+}
+
+static int 
+get_atip(SCSI *usalp, struct atipinfo *atp)
+{
+	int	len;
+	int	ret;
+
+	fillbytes((caddr_t)atp, sizeof (*atp), '\0');
+
+	/*
+	 * Used to be 2 instead of sizeof (struct tocheader), but all
+	 * other places in the code use sizeof (struct tocheader) too and
+	 * some Y2k ATAPI drives as used by IOMEGA create a DMA overrun if we
+	 * try to transfer only 2 bytes.
+	 */
+	if (read_toc(usalp, (caddr_t)atp, 0, sizeof (struct tocheader), 0, FMT_ATIP) < 0)
+		return (-1);
+	len = a_to_u_2_byte(atp->hd.len);
+	len += 2;
+	ret = read_toc(usalp, (caddr_t)atp, 0, len, 0, FMT_ATIP);
+
+#ifdef	DEBUG
+	usal_prbytes("ATIP info:", (Uchar *)atp,
+				len-usal_getresid(usalp));
+#endif
+	/*
+	 * Yamaha sometimes returns zeroed ATIP info for disks without ATIP
+	 */
+	if (atp->desc.lead_in[1] == 0 &&
+			atp->desc.lead_in[2] == 0 &&
+			atp->desc.lead_in[3] == 0 &&
+			atp->desc.lead_out[1] == 0 &&
+			atp->desc.lead_out[2] == 0 &&
+			atp->desc.lead_out[3] == 0)
+		return (-1);
+
+	if (atp->desc.lead_in[1] >= 0x90 && debug) {
+		/*
+		 * Only makes sense with buggy Ricoh firmware.
+		 */
+		errmsgno(EX_BAD, "Converting ATIP from BCD\n");
+		atp->desc.lead_in[1] = from_bcd(atp->desc.lead_in[1]);
+		atp->desc.lead_in[2] = from_bcd(atp->desc.lead_in[2]);
+		atp->desc.lead_in[3] = from_bcd(atp->desc.lead_in[3]);
+
+		atp->desc.lead_out[1] = from_bcd(atp->desc.lead_out[1]);
+		atp->desc.lead_out[2] = from_bcd(atp->desc.lead_out[2]);
+		atp->desc.lead_out[3] = from_bcd(atp->desc.lead_out[3]);
+	}
+
+	return (ret);
+}
+
+#ifdef	PRINT_ATIP
+
+static int 
+get_pma(SCSI *usalp)
+{
+	int	len;
+	int	ret;
+	char	atp[1024];
+
+	fillbytes((caddr_t)atp, sizeof (*atp), '\0');
+
+	/*
+	 * Used to be 2 instead of sizeof (struct tocheader), but all
+	 * other places in the code use sizeof (struct tocheader) too and
+	 * some Y2k ATAPI drives as used by IOMEGA create a DMA overrun if we
+	 * try to transfer only 2 bytes.
+	 */
+/*	if (read_toc(usalp, (caddr_t)atp, 0, 2, 1, FMT_PMA) < 0)*/
+/*	if (read_toc(usalp, (caddr_t)atp, 0, 2, 0, FMT_PMA) < 0)*/
+	if (read_toc(usalp, (caddr_t)atp, 0, sizeof (struct tocheader), 0, FMT_PMA) < 0)
+		return (-1);
+/*	len = a_to_u_2_byte(atp->hd.len);*/
+	len = a_to_u_2_byte(atp);
+	len += 2;
+/*	ret = read_toc(usalp, (caddr_t)atp, 0, len, 1, FMT_PMA);*/
+	ret = read_toc(usalp, (caddr_t)atp, 0, len, 0, FMT_PMA);
+
+#ifdef	DEBUG
+	usal_prbytes("PMA:", (Uchar *)atp,
+				len-usal_getresid(usalp));
+#endif
+	ret = read_toc(usalp, (caddr_t)atp, 0, len, 1, FMT_PMA);
+
+#ifdef	DEBUG
+	usal_prbytes("PMA:", (Uchar *)atp,
+				len-usal_getresid(usalp));
+#endif
+	return (ret);
+}
+
+#endif	/* PRINT_ATIP */
+
+static int 
+init_mmc(SCSI *usalp, cdr_t *dp)
+{
+	return (speed_select_mmc(usalp, dp, NULL));
+}
+
+static int 
+getdisktype_mdvd(SCSI *usalp, cdr_t *dp)
+{
+	int ret = 0;
+	dstat_t	*dsp = dp->cdr_dstat;
+
+	struct track_info track_info;
+    if(lverbose)
+        printf("HINT: use dvd+rw-mediainfo from dvd+rw-tools for information extraction.\n");
+	/* if(getdisktype_mmc(usalp, dp)<0)
+		return -1;
+		*/
+
+	/* read rzone info to get the space left on disk */
+	/*ds_trlast is the last rzone on disk, can be invisible */
+	if(read_rzone_info(usalp, (caddr_t)&track_info, sizeof(track_info))>=0)
+		dsp->ds_maxblocks=a_to_u_4_byte(track_info.free_blocks)+a_to_4_byte(track_info.next_writable_addr);
+
+	dsp->ds_disktype&= ~DT_CD;
+	dsp->ds_disktype|= DT_DVD;
+
+	return (ret);
+
+}
+
+static int 
+getdisktype_mmc(SCSI *usalp, cdr_t *dp)
+{
+extern	char	*buf;
+	dstat_t	*dsp = dp->cdr_dstat;
+	struct disk_info *dip;
+	Uchar	mode[0x100];
+	msf_t	msf;
+	BOOL	did_atip = FALSE;
+	BOOL	did_dummy = FALSE;
+	int 	rplus;
+
+	msf.msf_min = msf.msf_sec = msf.msf_frame = 0;
+
+	/*
+	 * It seems that there are drives that do not support to
+	 * read ATIP (e.g. HP 7100)
+	 * Also if a NON CD-R media is inserted, this will never work.
+	 * For this reason, make a failure non-fatal.
+	 */
+	usalp->silent++;
+	if (get_atip(usalp, (struct atipinfo *)mode) >= 0) {
+		struct atipinfo *atp = (struct atipinfo *)mode;
+
+		msf.msf_min =		mode[8];
+		msf.msf_sec =		mode[9];
+		msf.msf_frame =		mode[10];
+		if (atp->desc.erasable) {
+			dsp->ds_flags |= DSF_ERA;
+			if (atp->desc.sub_type == 1)
+				dsp->ds_flags |= DSF_HIGHSP_ERA;
+			else if (atp->desc.sub_type == 2)
+				dsp->ds_flags |= DSF_ULTRASP_ERA;
+			else if (atp->desc.sub_type == 3)
+				dsp->ds_flags |= DSF_ULTRASP_ERA | DSF_ULTRASPP_ERA;
+		}
+		if (atp->desc.a1_v) {
+			if (atp->desc.clv_low != 0)
+				dsp->ds_at_min_speed = clv_to_speed[atp->desc.clv_low];
+			if (atp->desc.clv_high != 0)
+				dsp->ds_at_max_speed = clv_to_speed[atp->desc.clv_high];
+
+			if (atp->desc.erasable && atp->desc.sub_type == 1) {
+				if (atp->desc.clv_high != 0)
+					dsp->ds_at_max_speed = hs_clv_to_speed[atp->desc.clv_high];
+			}
+		}
+		if (atp->desc.a2_v && atp->desc.erasable && (atp->desc.sub_type == 2 || atp->desc.sub_type == 3)) {
+			Uint	vlow;
+			Uint	vhigh;
+
+			vlow = (atp->desc.a2[0] >> 4) & 0x07;
+			vhigh = atp->desc.a2[0] & 0x0F;
+			if (vlow != 0)
+				dsp->ds_at_min_speed = us_clv_to_speed[vlow];
+			if (vhigh != 0)
+				dsp->ds_at_max_speed = us_clv_to_speed[vhigh];
+		}
+		did_atip = TRUE;
+	}
+	usalp->silent--;
+
+#ifdef	PRINT_ATIP
+	if ((dp->cdr_dstat->ds_cdrflags & RF_PRATIP) != 0 && did_atip) {
+		print_atip(usalp, (struct atipinfo *)mode);
+		pr_manufacturer(&msf,
+			((struct atipinfo *)mode)->desc.erasable,
+			((struct atipinfo *)mode)->desc.uru);
+	}
+#endif
+again:
+	dip = (struct disk_info *)buf;
+	if (get_diskinfo(usalp, dip) < 0)
+		return (-1);
+
+	/*
+	 * Check for non writable disk first.
+	 */
+	
+	/* DVD+RW does not need to be blanked */
+	rplus = dsp->ds_cdrflags;
+	if (dp->profile == 0x1A) rplus = RF_BLANK;
+	
+	if (dip->disk_status == DS_COMPLETE &&
+			(rplus & dsp->ds_cdrflags & (RF_WRITE|RF_BLANK)) == RF_WRITE) {
+		if (!did_dummy) {
+			int	xspeed = 0xFFFF;
+			int	oflags = dp->cdr_cmdflags;
+
+			/*
+			 * Try to clear the dummy bit to reset the virtual
+			 * drive status. Not all drives support it even though
+			 * it is mentioned in the MMC standard.
+			 */
+			if (lverbose)
+				printf("Trying to clear drive status.\n");
+
+			dp->cdr_cmdflags &= ~F_DUMMY;
+			speed_select_mmc(usalp, dp, &xspeed);
+			dp->cdr_cmdflags = oflags;
+			did_dummy = TRUE;
+			goto again;
+		}
+		/*
+		 * Trying to clear drive status did not work...
+		 */
+		reload_media(usalp, dp);
+	}
+	if (get_diskinfo(usalp, dip) < 0)
+		return (-1);
+	di_to_dstat(dip, dsp);
+	if (!did_atip && dsp->ds_first_leadin < 0)
+		lba_to_msf(dsp->ds_first_leadin, &msf);
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_PRATIP) != 0 && !did_atip) {
+		print_min_atip(dsp->ds_first_leadin, dsp->ds_last_leadout);
+		if (dsp->ds_first_leadin < 0)
+				pr_manufacturer(&msf,
+				dip->erasable,
+				dip->uru);
+	}
+	dsp->ds_maxrblocks = disk_rcap(&msf, dsp->ds_maxblocks,
+				dip->erasable,
+				dip->uru);
+
+
+#ifdef	PRINT_ATIP
+#ifdef	DEBUG
+	if (get_atip(usalp, (struct atipinfo *)mode) < 0)
+		return (-1);
+	/*
+	 * Get pma gibt Ärger mit CW-7502
+	 * Wenn Die Disk leer ist, dann stuerzt alles ab.
+	 * Firmware 4.02 kann nicht get_pma
+	 */
+	if (dip->disk_status != DS_EMPTY) {
+/*		get_pma();*/
+	}
+	printf("ATIP lead in:  %ld (%02d:%02d/%02d)\n",
+		msf_to_lba(mode[8], mode[9], mode[10], FALSE),
+		mode[8], mode[9], mode[10]);
+	printf("ATIP lead out: %ld (%02d:%02d/%02d)\n",
+		msf_to_lba(mode[12], mode[13], mode[14], TRUE),
+		mode[12], mode[13], mode[14]);
+	print_di(dip);
+	print_atip(usalp, (struct atipinfo *)mode);
+#endif
+#endif	/* PRINT_ATIP */
+	return (drive_getdisktype(usalp, dp));
+}
+
+#ifdef	PRINT_ATIP
+
+#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);
+
+static void 
+print_di(struct disk_info *dip)
+{
+	static	char *ds_name[] = { "empty", "incomplete/appendable", "complete", "illegal" };
+	static	char *ss_name[] = { "empty", "incomplete/appendable", "illegal", "complete", };
+
+	IS("erasable", dip->erasable);
+	printf("disk status: %s\n", ds_name[dip->disk_status]);
+	printf("session status: %s\n", ss_name[dip->sess_status]);
+	printf("first track: %d number of sessions: %d first track in last sess: %d last track in last sess: %d\n",
+		dip->first_track,
+		dip->numsess,
+		dip->first_track_ls,
+		dip->last_track_ls);
+	IS("unrestricted", dip->uru);
+	printf("Disk type: ");
+	switch (dip->disk_type) {
+
+	case SES_DA_ROM:	printf("CD-DA or CD-ROM");	break;
+	case SES_CDI:		printf("CDI");			break;
+	case SES_XA:		printf("CD-ROM XA");		break;
+	case SES_UNDEF:		printf("undefined");		break;
+	default:		printf("reserved");		break;
+	}
+	printf("\n");
+	if (dip->did_v)
+		printf("Disk id: 0x%lX\n", a_to_u_4_byte(dip->disk_id));
+
+	printf("last start of lead in: %ld\n",
+		msf_to_lba(dip->last_lead_in[1],
+		dip->last_lead_in[2],
+		dip->last_lead_in[3], FALSE));
+	printf("last start of lead out: %ld\n",
+		msf_to_lba(dip->last_lead_out[1],
+		dip->last_lead_out[2],
+		dip->last_lead_out[3], TRUE));
+
+	if (dip->dbc_v)
+		printf("Disk bar code: 0x%lX%lX\n",
+			a_to_u_4_byte(dip->disk_barcode),
+			a_to_u_4_byte(&dip->disk_barcode[4]));
+
+	if (dip->num_opc_entries > 0) {
+		printf("OPC table:\n");
+	}
+}
+
+char	*cdr_subtypes[] = {
+	"Normal Rewritable (CLV) media",
+	"High speed Rewritable (CAV) media",
+	"Medium Type A, low Beta category (A-)",
+	"Medium Type A, high Beta category (A+)",
+	"Medium Type B, low Beta category (B-)",
+	"Medium Type B, high Beta category (B+)",
+	"Medium Type C, low Beta category (C-)",
+	"Medium Type C, high Beta category (C+)",
+};
+
+char	*cdrw_subtypes[] = {
+	"Normal Rewritable (CLV) media",
+	"High speed Rewritable (CAV) media",
+	"Ultra High speed Rewritable media",
+	"Ultra High speed+ Rewritable media",
+	"Medium Type B, low Beta category (B-)",
+	"Medium Type B, high Beta category (B+)",
+	"Medium Type C, low Beta category (C-)",
+	"Medium Type C, high Beta category (C+)",
+};
+
+static void 
+atip_printspeed(char *fmt, int speedindex, char speedtab[])
+{
+	printf("%s:", fmt);
+	if (speedtab[speedindex] == 0) {
+		printf(" %2d (reserved val %2d)",
+			speedtab[speedindex], speedindex);
+	} else {
+		printf(" %2d", speedtab[speedindex]);
+	}
+}
+
+static void 
+print_atip(SCSI *usalp, struct atipinfo *atp)
+{
+	char	*sub_type;
+	char	*speedvtab = clv_to_speed;
+
+	if (usalp->verbose)
+		usal_prbytes("ATIP info: ", (Uchar *)atp, sizeof (*atp));
+
+	printf("ATIP info from disk:\n");
+	printf("  Indicated writing power: %d\n", atp->desc.ind_wr_power);
+	if (atp->desc.erasable || atp->desc.ref_speed)
+		printf("  Reference speed: %d\n", clv_to_speed[atp->desc.ref_speed]);
+	IS("unrestricted", atp->desc.uru);
+/*	printf("  Disk application code: %d\n", atp->desc.res5_05);*/
+	IS("erasable", atp->desc.erasable);
+	if (atp->desc.erasable)
+		sub_type = cdrw_subtypes[atp->desc.sub_type];
+	else
+		sub_type = cdr_subtypes[atp->desc.sub_type];
+	if (atp->desc.sub_type)
+		printf("  Disk sub type: %s (%d)\n", sub_type, atp->desc.sub_type);
+	printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)\n",
+		msf_to_lba(atp->desc.lead_in[1],
+		atp->desc.lead_in[2],
+		atp->desc.lead_in[3], FALSE),
+		atp->desc.lead_in[1],
+		atp->desc.lead_in[2],
+		atp->desc.lead_in[3]);
+	printf("  ATIP start of lead out: %ld (%02d:%02d/%02d)\n",
+		msf_to_lba(atp->desc.lead_out[1],
+		atp->desc.lead_out[2],
+		atp->desc.lead_out[3], TRUE),
+		atp->desc.lead_out[1],
+		atp->desc.lead_out[2],
+		atp->desc.lead_out[3]);
+	if (atp->desc.a1_v) {
+		if (atp->desc.erasable && atp->desc.sub_type == 1) {
+			speedvtab = hs_clv_to_speed;
+		}
+		if (atp->desc.a2_v && (atp->desc.sub_type == 2 || atp->desc.sub_type == 3)) {
+			speedvtab = us_clv_to_speed;
+		}
+		if (atp->desc.clv_low != 0 || atp->desc.clv_high != 0) {
+			atip_printspeed("  1T speed low",
+				atp->desc.clv_low, speedvtab);
+			atip_printspeed(" 1T speed high",
+				atp->desc.clv_high, speedvtab);
+			printf("\n");
+		}
+	}
+	if (atp->desc.a2_v) {
+		Uint	vlow;
+		Uint	vhigh;
+
+		vlow = (atp->desc.a2[0] >> 4) & 0x07;
+		vhigh = atp->desc.a2[0] & 0x0F;
+
+		if (vlow != 0 || vhigh != 0) {
+			atip_printspeed("  2T speed low",
+					vlow, speedvtab);
+			atip_printspeed(" 2T speed high",
+					vhigh, speedvtab);
+			printf("\n");
+		}
+	}
+	if (atp->desc.a1_v) {
+		printf("  power mult factor: %d %d\n", atp->desc.power_mult, atp->desc.tgt_y_pow);
+		if (atp->desc.erasable)
+			printf("  recommended erase/write power: %d\n", atp->desc.rerase_pwr_ratio);
+	}
+	if (atp->desc.a1_v) {
+		printf("  A1 values: %02X %02X %02X\n",
+				(&atp->desc.res15)[1],
+				(&atp->desc.res15)[2],
+				(&atp->desc.res15)[3]);
+	}
+	if (atp->desc.a2_v) {
+		printf("  A2 values: %02X %02X %02X\n",
+				atp->desc.a2[0],
+				atp->desc.a2[1],
+				atp->desc.a2[2]);
+	}
+	if (atp->desc.a3_v) {
+		printf("  A3 values: %02X %02X %02X\n",
+				atp->desc.a3[0],
+				atp->desc.a3[1],
+				atp->desc.a3[2]);
+	}
+}
+#endif	/* PRINT_ATIP */
+
+static int 
+speed_select_mmc(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	Uchar	mode[0x100];
+	Uchar	moder[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+	struct	ricoh_mode_page_30 *rp = NULL;
+	int	val;
+	BOOL	forcespeed = FALSE;
+	BOOL	dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp)
+		curspeed = *speedp;
+
+	/*
+	 * Do not reset mp->test_write (-dummy) here.
+	 */
+	deflt_writemodes_mmc(usalp, FALSE);
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len))
+		return (-1);
+	if (len == 0)
+		return (-1);
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+
+    if(dummy) {
+        mp->test_write = 1;
+        /* but it does not work on DVD+RW and -RAM, also bail out on other
+         * types that have not been tested yet */
+        int profile=get_curprofile(usalp);
+        switch(profile) {
+            case(0x12):
+            case(0x1a):
+            case(0x2a):
+            case(0x43):
+            case(0x52):
+                {
+                    fprintf(stderr, 
+                            "Dummy mode not possible with %s.\n",
+                            mmc_obtain_profile_name(profile) );
+                    exit(EXIT_FAILURE);
+                }
+        }
+    }
+    else
+        mp->test_write = 0;
+
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, -1))
+		return (-1);
+
+	/*
+	 * Neither set nor get speed.
+	 */
+	if (speedp == 0)
+		return (0);
+
+
+	rp = get_justlink_ricoh(usalp, moder);
+	if (mmc_isyamaha(usalp)) {
+		forcespeed = FALSE;
+	} else if (mmc_isplextor(usalp) && (dp->cdr_flags & CDR_FORCESPEED) != 0) {
+		int	pwr;
+
+		pwr = check_powerrec_plextor(usalp);
+		if (pwr >= 0)
+			forcespeed = (pwr == 0);
+	} else if ((dp->cdr_flags & CDR_FORCESPEED) != 0) {
+		forcespeed = rp && rp->AWSCD != 0;
+	}
+
+	if (lverbose && (dp->cdr_flags & CDR_FORCESPEED) != 0)
+		printf("Forcespeed is %s.\n", forcespeed?"ON":"OFF");
+
+	if (!forcespeed && (dp->cdr_dstat->ds_cdrflags & RF_FORCESPEED) != 0) {
+		printf("Turning forcespeed on\n");
+		forcespeed = TRUE;
+	}
+	if (forcespeed && (dp->cdr_dstat->ds_cdrflags & RF_FORCESPEED) == 0) {
+		printf("Turning forcespeed off\n");
+		forcespeed = FALSE;
+	}
+	if (mmc_isplextor(usalp) && (dp->cdr_flags & CDR_FORCESPEED) != 0) {
+		powerrec_plextor(usalp, !forcespeed);
+	}
+	if (!mmc_isyamaha(usalp) && (dp->cdr_flags & CDR_FORCESPEED) != 0) {
+
+		if (rp) {
+			rp->AWSCD = forcespeed?1:0;
+			set_mode_params(usalp, "Ricoh Vendor Page", moder, moder[0]+1, 0, -1);
+			rp = get_justlink_ricoh(usalp, moder);
+		}
+	}
+
+	/*
+	 * 44100 * 2 * 2 =  176400 bytes/s
+	 *
+	 * The right formula would be:
+	 * tmp = (((long)curspeed) * 1764) / 10;
+	 *
+	 * But the standard is rounding the wrong way.
+	 * Furtunately rounding down is guaranteed.
+	 */
+	val = curspeed*177;
+	if (val > 0xFFFF)
+		val = 0xFFFF;
+	if (mmc_isyamaha(usalp) && forcespeed) {
+		if (force_speed_yamaha(usalp, -1, val) < 0)
+			return (-1);
+	} else if (mmc_set_speed(usalp, -1, val, ROTCTL_CLV) < 0) {
+		return (-1);
+	}
+
+	if (scsi_get_speed(usalp, 0, &val) >= 0) {
+		if (val > 0) {
+		        fprintf(stderr, "Speed set to %d KB/s\n", val); 
+			curspeed = val / 176;
+			*speedp = curspeed;
+		}
+	}
+	return (0);
+}
+
+/*
+ * Some drives do not round up when writespeed is e.g. 1 and
+ * the minimum write speed of the drive is higher. Try to increment
+ * the write speed unti it gets accepted by the drive.
+ */
+static int 
+mmc_set_speed(SCSI *usalp, int readspeed, int writespeed, int rotctl)
+{
+	int	rs;
+	int	ws;
+	int	ret = -1;
+	int	c;
+	int	k;
+
+	if (scsi_get_speed(usalp, &rs, &ws) >= 0) {
+		if (readspeed < 0)
+			readspeed = rs;
+		if (writespeed < 0)
+			writespeed = ws;
+	}
+	if (writespeed < 0 || writespeed > 0xFFFF)
+		return (ret);
+
+	usalp->silent++;
+	while (writespeed <= 0xFFFF) {
+		ret = scsi_set_speed(usalp, readspeed, writespeed, rotctl);
+		if (ret >= 0)
+			break;
+		c = usal_sense_code(usalp);
+		k = usal_sense_key(usalp);
+		/*
+		 * Abort quickly if it does not make sense to repeat.
+		 * 0x24 == Invalid field in cdb
+		 * 0x24 means illegal speed.
+		 */
+		if ((k != SC_ILLEGAL_REQUEST) || (c != 0x24)) {
+			if (usalp->silent <= 1)
+				usal_printerr(usalp);
+			usalp->silent--;
+			return (-1);
+		}
+		writespeed += 177;
+	}
+	if (ret < 0 && usalp->silent <= 1)
+		usal_printerr(usalp);
+	usalp->silent--;
+
+	return (ret);
+}
+
+static int 
+speed_select_mdvd(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+  int retcode;
+  char perf_desc[28];
+  int write_speed = *speedp * 1385;
+   
+  /* For the moment we just divide the CD speed by 7*/
+
+  if(speedp!=NULL)
+     (*speedp)=(*speedp)*8;
+  
+  memset(perf_desc, 0, sizeof(perf_desc));
+
+  /* Write Rotation Control = ROTCTL_CLV 
+   * | Restore Logical Unit Defaults = 0 
+   * | Exact = 0 
+   * | Random Access = 0) 
+   */
+  perf_desc[0]= ROTCTL_CLV << 3 | 0 << 2 | 0 << 1 | 0; 
+  /* Start LBA to 0 */
+  perf_desc[4] = 0;
+  perf_desc[5] = 0;
+  perf_desc[6] = 0;
+  perf_desc[7] = 0;
+  /* End LBA set to 0 (setting to 0xffffffff failed on my LG burner
+   */
+  perf_desc[8] = 0;
+  perf_desc[9] = 0;
+  perf_desc[10] = 0;
+  perf_desc[11] = 0;
+  /* Read Speed = 0xFFFF */
+  perf_desc[12] = 0;
+  perf_desc[13] = 0;
+  perf_desc[14] = 0xFF;
+  perf_desc[15] = 0xFF;
+  /* Read Time = 1s */
+  perf_desc[18] = 1000 >> 8;
+  perf_desc[19] = 1000 & 0xFF;   
+  /* Write Speed */
+  perf_desc[20] = write_speed >> 24;
+  perf_desc[21] = write_speed >> 16 & 0xFF;
+  perf_desc[22] = write_speed >> 8 & 0xFF;
+  perf_desc[23] = write_speed & 0xFF;
+  /* Write Time = 1s */
+  perf_desc[26] = 1000 >> 8;
+  perf_desc[27] = 1000 & 0xFF;  
+  
+  /* retcode = scsi_set_streaming(usalp, NULL, 0); */
+  retcode = scsi_set_streaming(usalp, perf_desc, sizeof(perf_desc));
+  if (retcode == -1) return retcode;
+  retcode = speed_select_mmc(usalp, dp, speedp);
+  if(speedp!=NULL)
+     (*speedp)=(*speedp)/7;
+   return retcode;
+}
+
+static int 
+next_wr_addr_mmc(SCSI *usalp, track_t *trackp, long *ap)
+{
+	struct	track_info	track_info;
+	long	next_addr;
+	int	result = -1;
+
+
+	/*
+	 * Reading info for current track may require doing the read_track_info
+	 * with either the track number (if the track is currently being written)
+	 * or with 0xFF (if the track hasn't been started yet and is invisible
+	 */
+
+	if (trackp != 0 && trackp->track > 0 && is_packet(trackp)) {
+		usalp->silent++;
+		result = read_track_info(usalp, (caddr_t)&track_info, TI_TYPE_TRACK,
+							trackp->trackno,
+							sizeof (track_info));
+		usalp->silent--;
+	}
+
+	if (result < 0) {
+		if (read_track_info(usalp, (caddr_t)&track_info, TI_TYPE_TRACK, 0xFF,
+						sizeof (track_info)) < 0) {
+			errmsgno(EX_BAD, "Cannot get next writable address for 'invisible' track.\n");
+			errmsgno(EX_BAD, "This means that we are checking recorded media.\n");
+			errmsgno(EX_BAD, "This media cannot be written in streaming mode anymore.\n");
+			errmsgno(EX_BAD, "If you like to write to 'preformatted' RW media, try to blank the media first.\n");
+			return (-1);
+		}
+	}
+	if (usalp->verbose)
+		usal_prbytes("track info:", (Uchar *)&track_info,
+				sizeof (track_info)-usal_getresid(usalp));
+	next_addr = a_to_4_byte(track_info.next_writable_addr);
+	if (ap)
+		*ap = next_addr;
+	return (0);
+}
+
+static int 
+write_leadin_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uint	i;
+	long	startsec = 0L;
+
+/*	if (flags & F_SAO) {*/
+	if (wm_base(dp->cdr_dstat->ds_wrmode) == WM_SAO) {
+		if (debug || lverbose) {
+			printf("Sending CUE sheet...\n");
+			flush();
+		}
+		if ((*dp->cdr_send_cue)(usalp, dp, trackp) < 0) {
+			errmsgno(EX_BAD, "Cannot send CUE sheet.\n");
+			return (-1);
+		}
+
+		(*dp->cdr_next_wr_address)(usalp, &trackp[0], &startsec);
+		if (trackp[0].flags & TI_TEXT) {
+			startsec = dp->cdr_dstat->ds_first_leadin;
+			printf("SAO startsec: %ld\n", startsec);
+		} else if (startsec <= 0 && startsec != -150) {
+			if(lverbose>2)
+				fprintf(stderr, "WARNING: Drive returns wrong startsec (%ld) using -150\n",
+					startsec);
+			startsec = -150;
+		}
+		if (debug)
+			printf("SAO startsec: %ld\n", startsec);
+
+		if (trackp[0].flags & TI_TEXT) {
+			if (startsec > 0) {
+				errmsgno(EX_BAD, "CD-Text must be in first session.\n");
+				return (-1);
+			}
+			if (debug || lverbose)
+				printf("Writing lead-in...\n");
+			if (write_cdtext(usalp, dp, startsec) < 0)
+				return (-1);
+
+			dp->cdr_dstat->ds_cdrflags |= RF_LEADIN;
+		} else for (i = 1; i <= trackp->tracks; i++) {
+			trackp[i].trackstart += startsec +150;
+		}
+#ifdef	XXX
+		if (debug || lverbose)
+			printf("Writing lead-in...\n");
+
+		pad_track(usalp, dp, &trackp[1], -150, (Llong)0,
+					FALSE, 0);
+#endif
+	}
+/*	if (flags & F_RAW) {*/
+    if (wm_base(dp->cdr_dstat->ds_wrmode) == WM_RAW) {
+        /*
+		 * In RAW write mode, we now write the lead in (TOC).
+		 */
+		(*dp->cdr_next_wr_address)(usalp, &trackp[0], &startsec);
+		if (startsec > -4500) {
+			/*
+			 * There must be at least 1 minute lead-in.
+			 */
+			errmsgno(EX_BAD, "WARNING: Drive returns wrong startsec (%ld) using %ld from ATIP\n",
+					startsec, (long)dp->cdr_dstat->ds_first_leadin);
+			startsec = dp->cdr_dstat->ds_first_leadin;
+		}
+		if (startsec > -4500) {
+			errmsgno(EX_BAD, "Illegal startsec (%ld)\n", startsec);
+			return (-1);
+		}
+		if (debug || lverbose)
+			printf("Writing lead-in at sector %ld\n", startsec);
+		if (write_leadin(usalp, dp, trackp, startsec) < 0)
+			return (-1);
+		dp->cdr_dstat->ds_cdrflags |= RF_LEADIN;
+	}
+	return (0);
+}
+
+int	st2mode[] = {
+	0,		/* 0			*/
+	TM_DATA,	/* 1 ST_ROM_MODE1	*/
+	TM_DATA,	/* 2 ST_ROM_MODE2	*/
+	0,		/* 3			*/
+	0,		/* 4 ST_AUDIO_NOPRE	*/
+	TM_PREEM,	/* 5 ST_AUDIO_PRE	*/
+	0,		/* 6			*/
+	0,		/* 7			*/
+};
+
+static int 
+next_wr_addr_mdvd(SCSI *usalp, track_t *trackp, long *ap)
+{
+	int     track=0;
+	struct	track_info	track_info;
+	long	next_addr;
+	int	result = -1;
+	struct  disk_info disk_info;
+	if (trackp){
+	    track = trackp->trackno;
+	}
+
+	if (trackp != 0 && track > 0 && is_packet(trackp)) {
+		usalp->silent++;
+		result = read_track_info(usalp, (caddr_t)&track_info, TI_TYPE_SESS, track, sizeof(track_info));
+		usalp->silent--;
+		if (scsi_in_progress(usalp)){
+		  return -1;
+		}
+		
+	}
+
+	if (result < 0) {
+	  /* Get the last rzone*/
+	        if(read_disk_info(usalp,(caddr_t)&disk_info,8)<0)
+		  return (-1);
+	     
+		/* if (read_track_info(usalp, (caddr_t)&track_info, TI_TYPE_SESS, 0xFF, sizeof(track_info)) < 0) */
+		    if (read_rzone_info(usalp, (caddr_t)&track_info, sizeof(track_info)) < 0)
+			return (-1);
+	}
+	if (usalp->verbose)
+		usal_prbytes("track info:", (Uchar *)&track_info,
+				sizeof(track_info)-usal_getresid(usalp));
+	next_addr = a_to_4_byte(track_info.next_writable_addr);
+	if (ap)
+		*ap = next_addr;
+	return (0);
+}
+
+static int 
+open_track_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		if (trackp->pregapsize > 0 && (trackp->flags & TI_PREGAP) == 0) {
+			if (lverbose) {
+				printf("Writing pregap for track %d at %ld\n",
+					(int)trackp->trackno,
+					trackp->trackstart-trackp->pregapsize);
+			}
+			/*
+			 * XXX Do we need to check isecsize too?
+			 */
+			pad_track(usalp, dp, trackp,
+				trackp->trackstart-trackp->pregapsize,
+				(Llong)trackp->pregapsize*trackp->secsize,
+					FALSE, 0);
+		}
+		return (0);
+	}
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len))
+		return (-1);
+	if (len == 0)
+		return (-1);
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+
+/*	mp->track_mode = ???;*/
+	mp->track_mode = st2mode[trackp->sectype & ST_MASK];
+/*	mp->copy = ???;*/
+	mp->dbtype = trackp->dbtype;
+
+/*i_to_short(mp->audio_pause_len, 300);*/
+/*i_to_short(mp->audio_pause_len, 150);*/
+/*i_to_short(mp->audio_pause_len, 0);*/
+
+	if (is_packet(trackp)) {
+		mp->write_type = WT_PACKET;
+		mp->track_mode |= TM_INCREMENTAL;
+		mp->fp = (trackp->pktsize > 0) ? 1 : 0;
+		i_to_4_byte(mp->packet_size, trackp->pktsize);
+	} else if (is_tao(trackp)) {
+		mp->write_type = WT_TAO;
+		mp->fp = 0;
+		i_to_4_byte(mp->packet_size, 0);
+	} else {
+		errmsgno(EX_BAD, "Unknown write mode.\n");
+		return (-1);
+	}
+	if (trackp->isrc) {
+		mp->ISRC[0] = 0x80;	/* Set ISRC valid */
+		strncpy((char *)&mp->ISRC[1], trackp->isrc, 12);
+
+	} else {
+		fillbytes(&mp->ISRC[0], sizeof (mp->ISRC), '\0');
+	}
+
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, trackp->secsize))
+		return (-1);
+
+	return (0);
+}
+
+static int 
+open_track_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	if (is_packet(trackp)) {
+	       fillbytes((caddr_t)mode, sizeof(mode), '\0');
+	  
+	       if (!get_mode_params(usalp, 0x05, "DVD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len))
+	              return (-1);
+	       if (len == 0)
+		      return (-1);
+
+	        mp = (struct cd_mode_page_05 *)
+	              (mode + sizeof(struct scsi_mode_header) +
+		      ((struct scsi_mode_header *)mode)->blockdesc_len);
+
+		mp->write_type = WT_PACKET;
+		mp->LS_V = 1;
+		/*For now we set the link size to 0x10(32k) because Pioneer-A03 only support this */
+		mp->link_size=0x10;
+		mp->fp = 1;
+		i_to_4_byte(mp->packet_size, trackp->pktsize);
+	} else {
+	     return 0;
+	}
+ 
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, trackp->secsize))
+		return (-1);
+
+	return (0);
+}
+
+static int 
+close_track_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	ret;
+
+	if (!is_tao(trackp) && !is_packet(trackp))
+		return (0);
+
+	if (scsi_flush_cache(usalp, (dp->cdr_cmdflags&F_IMMED) != 0) < 0) {
+		printf("Trouble flushing the cache\n");
+		return (-1);
+	}
+	wait_unit_ready(usalp, 300);		/* XXX Wait for ATAPI */
+	if (is_packet(trackp) && !is_noclose(trackp)) {
+			/* close the incomplete track */
+		ret = scsi_close_tr_session(usalp, CL_TYPE_TRACK, 0xFF,
+				(dp->cdr_cmdflags&F_IMMED) != 0);
+		wait_unit_ready(usalp, 300);	/* XXX Wait for ATAPI */
+		return (ret);
+	}
+	return (0);
+}
+
+static int 
+close_track_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	ret;
+	if (!is_packet(trackp))
+	     return (0);
+
+	if (scsi_flush_cache(usalp, (dp->cdr_cmdflags&F_IMMED) != 0) < 0) {
+		printf("Trouble flushing the cache\n");
+		return -1;
+	}
+	wait_unit_ready(usalp, 300);		/* XXX Wait for ATAPI */
+	if (is_packet(trackp) && !is_noclose(trackp)) {
+			/* close the incomplete track */
+		ret = scsi_close_tr_session(usalp, 1, 0xFF, (dp->cdr_cmdflags&F_IMMED) != 0);
+		wait_unit_ready(usalp, 300);	/* XXX Wait for ATAPI */
+		return (ret);
+	}
+	return (0);
+}
+
+int	toc2sess[] = {
+	SES_DA_ROM,	/* CD-DA		 */
+	SES_DA_ROM,	/* CD-ROM		 */
+	SES_XA,		/* CD-ROM XA mode 1	 */
+	SES_XA,		/* CD-ROM XA MODE 2	 */
+	SES_CDI,	/* CDI			 */
+	SES_DA_ROM,	/* Invalid - use default */
+	SES_DA_ROM,	/* Invalid - use default */
+};
+
+static int 
+open_session_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uchar	mode[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len))
+		return (-1);
+	if (len == 0)
+		return (-1);
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	mp->write_type = WT_TAO; /* fix to allow DAO later */
+	/*
+	 * We need to set the right dbtype here because Sony drives
+	 * don't like multi session in to be set with DB_ROM_MODE1
+	 * which is set by us at the beginning as default as some drives
+	 * have illegal default values.
+	 */
+	mp->track_mode = st2mode[trackp[0].sectype & ST_MASK];
+	mp->dbtype = trackp[0].dbtype;
+
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		mp->write_type = WT_SAO;
+		if (dp->cdr_dstat->ds_cdrflags & RF_AUDIOMASTER)
+			mp->write_type = 8;
+		mp->track_mode = 0;
+		mp->dbtype = DB_RAW;
+	}
+	if (is_raw(trackp)) {
+		mp->write_type = WT_RAW;
+		mp->track_mode = 0;
+
+		if (is_raw16(trackp)) {
+			mp->dbtype = DB_RAW_PQ;
+		} else if (is_raw96r(trackp)) {
+			mp->dbtype = DB_RAW_PW_R;
+		} else {
+			mp->dbtype = DB_RAW_PW;
+		}
+	}
+
+	mp->multi_session = (track_base(trackp)->tracktype & TOCF_MULTI) ?
+				MS_MULTI : MS_NONE;
+	mp->session_format = toc2sess[track_base(trackp)->tracktype & TOC_MASK];
+
+	if (trackp->isrc) {
+		mp->media_cat_number[0] = 0x80;	/* Set MCN valid */
+		strncpy((char *)&mp->media_cat_number[1], trackp->isrc, 13);
+
+	} else {
+		fillbytes(&mp->media_cat_number[0], sizeof (mp->media_cat_number), '\0');
+	}
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, -1))
+		return (-1);
+
+	return (0);
+}
+
+static int 
+open_session_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uchar	mode[0x100];
+	int	tracks = trackp->tracks;
+
+	int	len;
+	struct	cd_mode_page_05 *mp;
+	Ulong totalsize;
+	int i;
+	int profile;
+
+	fillbytes((caddr_t)mode, sizeof(mode), '\0');
+
+	if (!get_mode_params(usalp, 0x05, "DVD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len))
+		return (-1);
+	if (len == 0)
+		return (-1);
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof(struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+	if(is_packet(trackp)){
+	  mp->write_type=WT_PACKET;
+	  mp->fp=0;
+	  mp->BUFE=1;
+	  mp->track_mode=1;
+	}else{
+	  mp->write_type = WT_SAO; 
+	}
+
+	mp->multi_session = (track_base(trackp)->tracktype & TOCF_MULTI) ?
+				MS_MULTI : MS_NONE;
+	mp->session_format = toc2sess[track_base(trackp)->tracktype & TOC_MASK];
+
+	/* Enable Burnfree by default, allow to disable. XXX Sucks, duplicated functionality. */
+	if (dp->cdr_cdcap->BUF != 0) {
+		if (lverbose > 2)
+			fprintf(stderr, 
+					"BURN-Free is %s.\n"
+					"Turning BURN-Free on\n",
+					mp->BUFE?"ON":"OFF");
+		mp->BUFE = 1;
+	}
+	if (driveropts != NULL) {
+		if ((strcmp(driveropts, "noburnproof") == 0 ||
+					strcmp(driveropts, "noburnfree") == 0)) {
+			if(lverbose>1)
+				fprintf(stderr, "Turning BURN-Free off\n");
+			mp->BUFE = 0;
+		}
+		else if ((strcmp(driveropts, "burnproof") == 0 ||
+					strcmp(driveropts, "burnfree") == 0)) {
+			/* a NOP, we enable burnfree by default */
+			if(lverbose>2)
+				fprintf(stderr, "Found burnproof/burnfree in driveropts, those options are enabled by default now.");
+		}
+		else if (strcmp(driveropts, "help") == 0) {
+			mmc_opthelp(dp, 0);
+		} 
+		else {
+			errmsgno(EX_BAD, "Bad driver opts '%s'.\n", driveropts);
+			mmc_opthelp(dp, EX_BAD);
+		}
+	}
+
+
+	if (!set_mode_params(usalp, "DVD write parameter", mode, len, 0, -1))
+		return (-1);
+
+		
+	totalsize=0;
+	for(i=1;i<=tracks;i++) {
+	  totalsize+=trackp[i].tracksecs;
+	}
+       
+	profile = get_curprofile(usalp);
+	if(!is_packet(trackp) && profile != 0x1A){
+	  /* in DAO mode we need to reserve space for the track*/
+	  if(reserve_track(usalp, totalsize)<0)
+	    return (-1);
+	  }
+	return (0);
+}
+
+static int 
+waitfix_mmc(SCSI *usalp, int secs)
+{
+	char	dibuf[16];
+	int	i;
+	int	key;
+#define	W_SLEEP	2
+
+	usalp->silent++;
+	for (i = 0; i < secs/W_SLEEP; i++) {
+		if (read_disk_info(usalp, dibuf, sizeof (dibuf)) >= 0) {
+			usalp->silent--;
+			return (0);
+		}
+		key = usal_sense_key(usalp);
+		if (key != SC_UNIT_ATTENTION && key != SC_NOT_READY)
+			break;
+		sleep(W_SLEEP);
+	}
+	usalp->silent--;
+	return (-1);
+#undef	W_SLEEP
+}
+
+static int 
+fixate_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	ret = 0;
+	int	key = 0;
+	int	code = 0;
+	struct timeval starttime;
+	struct timeval stoptime;
+	int	dummy = (track_base(trackp)->tracktype & TOCF_DUMMY) != 0;
+
+	if(debug)
+		 printf("fixate_mmc\n");
+	starttime.tv_sec = 0;
+	starttime.tv_usec = 0;
+	stoptime = starttime;
+	gettimeofday(&starttime, (struct timezone *)0);
+
+	if (dummy && lverbose)
+		printf("WARNING: Some drives don't like fixation in dummy mode.\n");
+
+	usalp->silent++;
+	if(debug)
+		 printf("is_tao: %d,is_packet: %d\n", is_tao(trackp), is_packet(trackp));
+	if (is_tao(trackp) || is_packet(trackp)) {
+		ret = scsi_close_tr_session(usalp, CL_TYPE_SESSION, 0,
+				(dp->cdr_cmdflags&F_IMMED) != 0);
+	} else {
+		if (scsi_flush_cache(usalp, (dp->cdr_cmdflags&F_IMMED) != 0) < 0) {
+			if (!scsi_in_progress(usalp))
+				printf("Trouble flushing the cache\n");
+		}
+	}
+	usalp->silent--;
+	key = usal_sense_key(usalp);
+	code = usal_sense_code(usalp);
+
+	usalp->silent++;
+	if (debug && !unit_ready(usalp)) {
+		fprintf(stderr, "Early return from fixating. Ret: %d Key: %d, Code: %d\n", ret, key, code);
+	}
+	usalp->silent--;
+
+	if (ret >= 0) {
+		wait_unit_ready(usalp, 420/curspeed);	/* XXX Wait for ATAPI */
+		waitfix_mmc(usalp, 420/curspeed);	/* XXX Wait for ATAPI */
+		return (ret);
+	}
+
+	if ((dummy != 0 && (key != SC_ILLEGAL_REQUEST)) ||
+		/*
+		 * Try to suppress messages from drives that don't like fixation
+		 * in -dummy mode.
+		 */
+		((dummy == 0) &&
+		(((key != SC_UNIT_ATTENTION) && (key != SC_NOT_READY)) ||
+				((code != 0x2E) && (code != 0x04))))) {
+		/*
+		 * UNIT ATTENTION/2E seems to be a magic for old Mitsumi ATAPI drives
+		 * NOT READY/ code 4 qual 7 (logical unit not ready, operation in progress)
+		 * seems to be a magic for newer Mitsumi ATAPI drives
+		 * NOT READY/ code 4 qual 8 (logical unit not ready, long write in progress)
+		 * seems to be a magic for SONY drives
+		 * when returning early from fixating.
+		 * Try to supress the error message in this case to make
+		 * simple minded users less confused.
+		 */
+		usal_printerr(usalp);
+		usal_printresult(usalp);	/* XXX restore key/code in future */
+	}
+
+	if (debug && !unit_ready(usalp)) {
+		fprintf(stderr, "Early return from fixating. Ret: %d Key: %d, Code: %d\n", ret, key, code);
+	}
+
+	wait_unit_ready(usalp, 420);	 /* XXX Wait for ATAPI */
+	waitfix_mmc(usalp, 420/curspeed); /* XXX Wait for ATAPI */
+
+	if (!dummy &&
+		(ret >= 0 || (key == SC_UNIT_ATTENTION && code == 0x2E))) {
+		/*
+		 * Some ATAPI drives (e.g. Mitsumi) imply the
+		 * IMMED bit in the SCSI cdb. As there seems to be no
+		 * way to properly check for the real end of the
+		 * fixating process we wait for the expected time.
+		 */
+		gettimeofday(&stoptime, (struct timezone *)0);
+		timevaldiff(&starttime, &stoptime);
+		if (stoptime.tv_sec < (220 / curspeed)) {
+			unsigned secs;
+
+			if (lverbose) {
+				printf("Actual fixating time: %ld seconds\n",
+							(long)stoptime.tv_sec);
+			}
+			secs = (280 / curspeed) - stoptime.tv_sec;
+			if (lverbose) {
+				printf("ATAPI early return: sleeping %d seconds.\n",
+								secs);
+			}
+			sleep(secs);
+		}
+	}
+	return (ret);
+}
+
+static int 
+fixate_mdvd(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int ret;
+	if (scsi_flush_cache(usalp, (dp->cdr_cmdflags&F_IMMED) != 0) < 0) {
+		printf("Trouble flushing the cache\n");
+		return -1;
+	}
+	wait_unit_ready(usalp, 300);		/* XXX Wait for ATAPI */
+      /*set a really BIG timeout and call fixate_mmc
+	 The BIG timeout is needed in case there was a very short rzone to write at the 
+	 beginning of the disk, because lead-out needs to be at some distance.
+      */
+	if(debug)
+		printf("fixate_mdvd\n");
+      usal_settimeout(usalp, 1000);
+      if(is_packet(trackp) || dp->profile == 0x1B){
+	  scsi_close_tr_session(usalp, CL_TYPE_SESSION, 0, FALSE);
+      }
+      ret = fixate_mmc(usalp, dp, trackp);
+      if (dp->profile == 0x2B) {
+	  scsi_close_tr_session(usalp, CL_TYPE_OPEN_SESSION, 0, FALSE);
+	  scsi_close_tr_session(usalp, CL_TYPE_FINALISE_MINRAD, 0, FALSE);
+      }
+      usal_settimeout(usalp, 200);
+
+      return ret;
+}
+
+char	*blank_types[] = {
+	"entire disk",
+	"PMA, TOC, pregap",
+	"incomplete track",
+	"reserved track",
+	"tail of track",
+	"closing of last session",
+	"last session",
+	"reserved blanking type",
+};
+
+char	*format_types[] = {
+	"full format",
+	"background format",
+	"forced format",
+};
+
+static int 
+blank_mmc(SCSI *usalp, cdr_t *dp, long addr, int blanktype)
+{
+	BOOL	cdrr	 = FALSE;	/* Read CD-R	*/
+	BOOL	cdwr	 = FALSE;	/* Write CD-R	*/
+	BOOL	cdrrw	 = FALSE;	/* Read CD-RW	*/
+	BOOL	cdwrw	 = FALSE;	/* Write CD-RW	*/
+	int	ret;
+
+	mmc_check(usalp, &cdrr, &cdwr, &cdrrw, &cdwrw, NULL, NULL);
+	if (!cdwrw)
+		return (blank_dummy(usalp, dp, addr, blanktype));
+
+	if (dp->profile == 0x1A) {
+		printf("Error: this media does not support blanking, ignoring.\n");
+		return (blank_dummy(usalp, dp, addr, blanktype));
+	}
+	if (lverbose) {
+		printf("Blanking %s\n", blank_types[blanktype & 0x07]);
+		flush();
+	}
+
+	ret = scsi_blank(usalp, addr, blanktype, (dp->cdr_cmdflags&F_IMMED) != 0);
+	if (ret < 0)
+		return (ret);
+
+	wait_unit_ready(usalp, 90*60/curspeed);	/* XXX Wait for ATAPI */
+	waitfix_mmc(usalp, 90*60/curspeed);	/* XXX Wait for ATAPI */
+	return (ret);
+}
+
+static int format_mdvd(SCSI *usalp, cdr_t *dp, int formattype)
+{
+extern	char	*buf;
+	BOOL	dvdwr	 = FALSE;	/* Write DVD	*/
+	int	ret;
+	int 	profile;
+	char	addr[12];
+	struct disk_info *dip;
+
+	if (debug || lverbose > 2)
+		printf("format_mdvd\n");
+	mmc_check(usalp, NULL, NULL, NULL, NULL, NULL, &dvdwr);
+	if (!dvdwr)
+		return (format_dummy(usalp, dp, formattype));
+
+	if (debug || lverbose > 2)
+		printf("format_mdvd: drive is a dvd burner.\n");
+	profile = get_curprofile(usalp);
+	if (profile != 0x1A) {
+		printf("Error: only support DVD+RW formating, ignoring.\n");
+	        return (format_dummy(usalp, dp, formattype));
+	}
+	dip = (struct disk_info *)buf;
+	if (get_diskinfo(usalp, dip) < 0)
+		return -1;
+	
+	if (dip->disk_status & 3 && formattype != FORCE_FORMAT) {
+		printf("Error: disk already formated, ignoring.\n");
+	        return -1;
+        }
+	addr[0] = 0;           /* "Reserved" */
+	addr[1] = 2;           /* "IMMED" flag */
+	addr[2] = 0;           /* "Descriptor Length" (MSB) */
+	addr[3] = 8;           /* "Descriptor Length" (LSB) */
+	addr[4+0] = 0xff;
+	addr[4+1] = 0xff;
+	addr[4+2] = 0xff;
+	addr[4+3] = 0xff;
+	addr[4+4] = 0x26<<2;
+	addr[4+5] = 0;
+	addr[4+6] = 0;
+	addr[4+7] = 0;
+	if (formattype == FORCE_FORMAT) {
+	    printf("format_mdvd: forcing reformat.\n"); 
+	    formattype = FULL_FORMAT;
+	    addr[4+0] = 0;
+	    addr[4+1] = 0;
+	    addr[4+2] = 0;
+	    addr[4+3] = 0;
+	    addr[4+7] = 1;
+	} else {
+	    printf("format_mdvd: media is unformated.\n"); 
+	}
+
+	if (lverbose) {
+		printf("Formating %s\n", format_types[formattype & 0x07]);
+		flush();
+	}
+	if (formattype == FULL_FORMAT) {
+		ret = scsi_format(usalp, (caddr_t)&addr, sizeof(addr), FALSE);
+	} else {
+		ret = scsi_format(usalp, (caddr_t)&addr, sizeof(addr), TRUE);
+	}
+	if (ret < 0)
+		return (ret);
+
+	wait_unit_ready(usalp, 90*60/curspeed);	/* XXX Wait for ATAPI */
+	waitfix_mmc(usalp, 90*60/curspeed);	/* XXX Wait for ATAPI */
+	return (ret);
+}
+
+static int 
+send_opc_mmc(SCSI *usalp, caddr_t bp, int cnt, int doopc)
+{
+	int	ret;
+
+	usalp->silent++;
+	ret = send_opc(usalp, bp, cnt, doopc);
+	usalp->silent--;
+
+	if (ret >= 0)
+		return (ret);
+
+	/* BEGIN CSTYLED */
+	/*
+	 * Hack for a mysterioys drive ....
+	 * Device type    : Removable CD-ROM
+	 * Version        : 0
+	 * Response Format: 1
+	 * Vendor_info    : 'RWD     '
+	 * Identifikation : 'RW2224          '
+	 * Revision       : '2.53'
+	 * Device seems to be: Generic mmc CD-RW.
+	 *
+	 * Performing OPC...
+	 * CDB:  54 01 00 00 00 00 00 00 00 00
+	 * Sense Bytes: 70 00 06 00 00 00 00 0A 00 00 00 00 5A 03 00 00
+	 * Sense Key: 0x6 Unit Attention, Segment 0
+	 * Sense Code: 0x5A Qual 0x03 (operator selected write permit) Fru 0x0
+	 * Sense flags: Blk 0 (not valid)
+	 */
+	/* END CSTYLED */
+	if (usal_sense_key(usalp) == SC_UNIT_ATTENTION &&
+	    usal_sense_code(usalp) == 0x5A &&
+	    usal_sense_qual(usalp) == 0x03)
+		return (0);
+
+	/*
+	 * Do not make the condition:
+	 * "Power calibration area almost full" a fatal error.
+	 * It just flags that we have a single and last chance to write now.
+	 */
+	if ((usal_sense_key(usalp) == SC_RECOVERABLE_ERROR ||
+	    usal_sense_key(usalp) == SC_MEDIUM_ERROR) &&
+	    usal_sense_code(usalp) == 0x73 &&
+	    usal_sense_qual(usalp) == 0x01)
+		return (0);
+
+	/*
+	 * Send OPC is optional.
+	 */
+	if (usal_sense_key(usalp) != SC_ILLEGAL_REQUEST) {
+		if (usalp->silent <= 0)
+			usal_printerr(usalp);
+		return (ret);
+	}
+	return (0);
+}
+
+static int 
+opt1_mmc(SCSI *usalp, cdr_t *dp)
+{
+	int	oflags = dp->cdr_dstat->ds_cdrflags;
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_AUDIOMASTER) != 0) {
+		printf("Turning Audio Master Q. R. on\n");
+		if (set_audiomaster_yamaha(usalp, dp, TRUE) < 0)
+			return (-1);
+		if (!debug && lverbose <= 1)
+			dp->cdr_dstat->ds_cdrflags &= ~RF_PRATIP;
+		if (getdisktype_mmc(usalp, dp) < 0) {
+			dp->cdr_dstat->ds_cdrflags = oflags;
+			return (-1);
+		}
+		dp->cdr_dstat->ds_cdrflags = oflags;
+		if (oflags & RF_PRATIP) {
+			msf_t   msf;
+			lba_to_msf(dp->cdr_dstat->ds_first_leadin, &msf);
+			printf("New start of lead in: %ld (%02d:%02d/%02d)\n",
+				(long)dp->cdr_dstat->ds_first_leadin,
+				msf.msf_min,
+				msf.msf_sec,
+				msf.msf_frame);
+			lba_to_msf(dp->cdr_dstat->ds_maxblocks, &msf);
+			printf("New start of lead out: %ld (%02d:%02d/%02d)\n",
+				(long)dp->cdr_dstat->ds_maxblocks,
+				msf.msf_min,
+				msf.msf_sec,
+				msf.msf_frame);
+		}
+	}
+	if (mmc_isplextor(usalp)) {
+		int	gcode;
+
+		if ((dp->cdr_flags & (CDR_SINGLESESS|CDR_HIDE_CDR)) != 0) {
+			if (ss_hide_plextor(usalp,
+			    (dp->cdr_dstat->ds_cdrflags & RF_SINGLESESS) != 0,
+			    (dp->cdr_dstat->ds_cdrflags & RF_HIDE_CDR) != 0) < 0)
+				return (-1);
+		}
+
+		if ((dp->cdr_flags & CDR_SPEEDREAD) != 0) {
+			if (speed_rd_plextor(usalp,
+			    (dp->cdr_dstat->ds_cdrflags & RF_SPEEDREAD) != 0) < 0)
+				return (-1);
+		}
+
+		if ((dp->cdr_cmdflags & F_SETDROPTS) ||
+		    (wm_base(dp->cdr_dstat->ds_wrmode) == WM_SAO) ||
+		    (wm_base(dp->cdr_dstat->ds_wrmode) == WM_RAW))
+			gcode = do_gigarec_plextor(usalp);
+		else
+			gcode = gigarec_plextor(usalp, 0);
+		if (gcode != 0) {
+			msf_t   msf;
+
+			dp->cdr_dstat->ds_first_leadin =
+					gigarec_mult(gcode, dp->cdr_dstat->ds_first_leadin);
+			dp->cdr_dstat->ds_maxblocks =
+					gigarec_mult(gcode, dp->cdr_dstat->ds_maxblocks);
+
+			if (oflags & RF_PRATIP) {
+				lba_to_msf(dp->cdr_dstat->ds_first_leadin, &msf);
+				printf("New start of lead in: %ld (%02d:%02d/%02d)\n",
+					(long)dp->cdr_dstat->ds_first_leadin,
+					msf.msf_min,
+					msf.msf_sec,
+					msf.msf_frame);
+				lba_to_msf(dp->cdr_dstat->ds_maxblocks, &msf);
+				printf("New start of lead out: %ld (%02d:%02d/%02d)\n",
+					(long)dp->cdr_dstat->ds_maxblocks,
+					msf.msf_min,
+					msf.msf_sec,
+					msf.msf_frame);
+			}
+		}
+	}
+	return (0);
+}
+
+static int 
+opt2_mmc(SCSI *usalp, cdr_t *dp)
+{
+	Uchar	mode[0x100];
+	Uchar	moder[0x100];
+	int	len;
+	struct	cd_mode_page_05 *mp;
+	struct	ricoh_mode_page_30 *rp = NULL;
+	BOOL	burnfree = FALSE;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len))
+		return (-1);
+	if (len == 0)
+		return (-1);
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+
+	rp = get_justlink_ricoh(usalp, moder);
+
+	if (dp->cdr_cdcap->BUF != 0) {
+		burnfree = (mp->BUFE != 0);
+	} else if ((dp->cdr_flags & CDR_BURNFREE) != 0) {
+		burnfree = (rp && (rp->BUEFE != 0));
+	}
+
+	if (lverbose>2 && (dp->cdr_flags & CDR_BURNFREE) != 0)
+		printf("BURN-Free is %s.\n", burnfree?"ON":"OFF");
+
+	if (!burnfree && (dp->cdr_dstat->ds_cdrflags & RF_BURNFREE) != 0) {
+		if(lverbose>2)
+			printf("Turning BURN-Free on\n");
+		burnfree = TRUE;
+	}
+	if (burnfree && (dp->cdr_dstat->ds_cdrflags & RF_BURNFREE) == 0) {
+		if(lverbose>2)
+			printf("Turning BURN-Free off\n");
+		burnfree = FALSE;
+	}
+	if (dp->cdr_cdcap->BUF != 0) {
+		mp->BUFE = burnfree?1:0;
+	} 
+    else if ((dp->cdr_flags & CDR_BURNFREE) != 0) {
+
+		if (rp)
+			rp->BUEFE = burnfree?1:0;
+	}
+	if (rp) {
+		/*
+		 * Clear Just-Link counter
+		 */
+		i_to_2_byte(rp->link_counter, 0);
+		if (xdebug)
+			usal_prbytes("Mode Select Data ", moder, moder[0]+1);
+
+		if (!set_mode_params(usalp, "Ricoh Vendor Page", moder, moder[0]+1, 0, -1))
+			return (-1);
+		rp = get_justlink_ricoh(usalp, moder);
+	}
+
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, -1))
+		return (-1);
+
+	if (mmc_isplextor(usalp)) {
+		/*
+		 * Clear Burn-Proof counter
+		 */
+		usalp->silent++;
+		bpc_plextor(usalp, 1, NULL);
+		usalp->silent--;
+
+		do_varirec_plextor(usalp);
+	}
+
+	return (0);
+}
+
+static int 
+opt1_mdvd(SCSI *usalp, cdr_t *dp)
+{
+	int	oflags = dp->cdr_dstat->ds_cdrflags;
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_AUDIOMASTER) != 0) {
+		printf("Turning Audio Master Q. R. on\n");
+		if (set_audiomaster_yamaha(usalp, dp, TRUE) < 0)
+			return (-1);
+		if (!debug && lverbose <= 1)
+			dp->cdr_dstat->ds_cdrflags &= ~RF_PRATIP;
+		if (getdisktype_mdvd(usalp, dp) < 0) {
+			dp->cdr_dstat->ds_cdrflags = oflags;
+			return (-1);
+		}
+		dp->cdr_dstat->ds_cdrflags = oflags;
+		if (oflags & RF_PRATIP) {
+			msf_t   msf;
+			lba_to_msf(dp->cdr_dstat->ds_first_leadin, &msf);
+			printf("New start of lead in: %ld (%02d:%02d/%02d)\n",
+				(long)dp->cdr_dstat->ds_first_leadin,
+		                msf.msf_min,
+        		        msf.msf_sec,
+                		msf.msf_frame);
+			lba_to_msf(dp->cdr_dstat->ds_maxblocks, &msf);
+			printf("New start of lead out: %ld (%02d:%02d/%02d)\n",
+				(long)dp->cdr_dstat->ds_maxblocks,
+		                msf.msf_min,
+        		        msf.msf_sec,
+                		msf.msf_frame);
+		}
+	}
+	return (0);
+}
+
+static int
+scsi_sony_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_xg5(usalp, bp, sectaddr, size, blocks));
+}
+
+Uchar	db2df[] = {
+	0x00,			/*  0 2352 bytes of raw data			*/
+	0xFF,			/*  1 2368 bytes (raw data + P/Q Subchannel)	*/
+	0xFF,			/*  2 2448 bytes (raw data + P-W Subchannel)	*/
+	0xFF,			/*  3 2448 bytes (raw data + P-W raw Subchannel)*/
+	0xFF,			/*  4 -    Reserved				*/
+	0xFF,			/*  5 -    Reserved				*/
+	0xFF,			/*  6 -    Reserved				*/
+	0xFF,			/*  7 -    Vendor specific			*/
+	0x10,			/*  8 2048 bytes Mode 1 (ISO/IEC 10149)		*/
+	0x30,			/*  9 2336 bytes Mode 2 (ISO/IEC 10149)		*/
+	0xFF,			/* 10 2048 bytes Mode 2! (CD-ROM XA form 1)	*/
+	0xFF,			/* 11 2056 bytes Mode 2 (CD-ROM XA form 1)	*/
+	0xFF,			/* 12 2324 bytes Mode 2 (CD-ROM XA form 2)	*/
+	0xFF,			/* 13 2332 bytes Mode 2 (CD-ROM XA 1/2+subhdr)	*/
+	0xFF,			/* 14 -    Reserved				*/
+	0xFF,			/* 15 -    Vendor specific			*/
+};
+
+static int 
+gen_cue_mmc(track_t *trackp, void *vcuep, BOOL needgap)
+{
+	int	tracks = trackp->tracks;
+	int	i;
+	struct mmc_cue	**cuep = vcuep;
+	struct mmc_cue	*cue;
+	struct mmc_cue	*cp;
+	int	ncue = 0;
+	int	icue = 0;
+	int	pgsize;
+	msf_t	m;
+	int	ctl;
+	int	df;
+	int	scms;
+
+	cue = malloc(1);
+
+	for (i = 0; i <= tracks; i++) {
+		ctl = (st2mode[trackp[i].sectype & ST_MASK]) << 4;
+		if (is_copy(&trackp[i]))
+			ctl |= TM_ALLOW_COPY << 4;
+		if (is_quadro(&trackp[i]))
+			ctl |= TM_QUADRO << 4;
+		df = db2df[trackp[i].dbtype & 0x0F];
+		if (trackp[i].tracktype == TOC_XA2 &&
+		    trackp[i].sectype   == (SECT_MODE_2_MIX|ST_MODE_RAW)) {
+			/*
+			 * Hack for CUE with MODE2/CDI and
+			 * trackp[i].dbtype == DB_RAW
+			 */
+			df = 0x21;
+		}
+
+		if (trackp[i].isrc) {	/* MCN or ISRC */
+			ncue += 2;
+			cue = realloc(cue, ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			if (i == 0) {
+				cp->cs_ctladr = 0x02;
+				movebytes(&trackp[i].isrc[0], &cp->cs_tno, 7);
+				cp = &cue[icue++];
+				cp->cs_ctladr = 0x02;
+				movebytes(&trackp[i].isrc[7], &cp->cs_tno, 7);
+			} else {
+				cp->cs_ctladr = 0x03;
+				cp->cs_tno = i;
+				movebytes(&trackp[i].isrc[0], &cp->cs_index, 6);
+				cp = &cue[icue++];
+				cp->cs_ctladr = 0x03;
+				cp->cs_tno = i;
+				movebytes(&trackp[i].isrc[6], &cp->cs_index, 6);
+			}
+		}
+		if (i == 0) {	/* Lead in */
+			df &= ~7;	/* Mask off data size & nonRAW subch */
+			if (df < 0x10)
+				df |= 1;
+			else
+				df |= 4;
+			if (trackp[0].flags & TI_TEXT)	/* CD-Text in Lead-in*/
+				df |= 0x40;
+			lba_to_msf(-150, &m);
+			cue = realloc(cue, ++ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			fillcue(cp, ctl|0x01, i, 0, df, 0, &m);
+		} else {
+			scms = 0;
+
+			if (is_scms(&trackp[i]))
+				scms = 0x80;
+			pgsize = trackp[i].pregapsize;
+			if (pgsize == 0 && needgap)
+				pgsize++;
+			lba_to_msf(trackp[i].trackstart-pgsize, &m);
+			cue = realloc(cue, ++ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			fillcue(cp, ctl|0x01, i, 0, df, scms, &m);
+
+			if (trackp[i].nindex == 1) {
+				lba_to_msf(trackp[i].trackstart, &m);
+				cue = realloc(cue, ++ncue * sizeof (*cue));
+				cp = &cue[icue++];
+				fillcue(cp, ctl|0x01, i, 1, df, scms, &m);
+			} else {
+				int	idx;
+				long	*idxlist;
+
+				ncue += trackp[i].nindex;
+				idxlist = trackp[i].tindex;
+				cue = realloc(cue, ncue * sizeof (*cue));
+
+				for (idx = 1; idx <= trackp[i].nindex; idx++) {
+					lba_to_msf(trackp[i].trackstart + idxlist[idx], &m);
+					cp = &cue[icue++];
+					fillcue(cp, ctl|0x01, i, idx, df, scms, &m);
+				}
+			}
+		}
+	}
+	/* Lead out */
+	ctl = (st2mode[trackp[tracks+1].sectype & ST_MASK]) << 4;
+	if (is_copy(&trackp[i]))
+		ctl |= TM_ALLOW_COPY << 4;
+	if (is_quadro(&trackp[i]))
+		ctl |= TM_QUADRO << 4;
+	df = db2df[trackp[tracks+1].dbtype & 0x0F];
+	if (trackp[i].tracktype == TOC_XA2 &&
+	    trackp[i].sectype   == (SECT_MODE_2_MIX|ST_MODE_RAW)) {
+		/*
+		 * Hack for CUE with MODE2/CDI and
+		 * trackp[i].dbtype == DB_RAW
+		 */
+		df = 0x21;
+	}
+	df &= ~7;	/* Mask off data size & nonRAW subch */
+	if (df < 0x10)
+		df |= 1;
+	else
+		df |= 4;
+	lba_to_msf(trackp[tracks+1].trackstart, &m);
+	cue = realloc(cue, ++ncue * sizeof (*cue));
+	cp = &cue[icue++];
+	fillcue(cp, ctl|0x01, 0xAA, 1, df, 0, &m);
+
+	if (lverbose > 1) {
+		for (i = 0; i < ncue; i++) {
+			usal_prbytes("", (Uchar *)&cue[i], 8);
+		}
+	}
+	if (cuep)
+		*cuep = cue;
+	else
+		free(cue);
+	return (ncue);
+}
+
+static void 
+fillcue(struct mmc_cue *cp  /* The target cue entry */, 
+        int ca              /* Control/adr for this entry */, 
+        int tno             /* Track number for this entry */, 
+        int idx             /* Index for this entry */, 
+        int dataform        /* Data format for this entry */, 
+        int scms            /* Serial copy management */, 
+        msf_t *mp           /* MSF value for this entry */)
+{
+	cp->cs_ctladr = ca;		/* XXX wie lead in */
+	cp->cs_tno = tno;
+	cp->cs_index = idx;
+	cp->cs_dataform = dataform;	/* XXX wie lead in */
+	cp->cs_scms = scms;
+	cp->cs_min = mp->msf_min;
+	cp->cs_sec = mp->msf_sec;
+	cp->cs_frame = mp->msf_frame;
+}
+
+static int 
+send_cue_mmc(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	struct mmc_cue	*cp;
+	int		ncue;
+	int		ret;
+	Uint		i;
+
+	for (i = 1; i <= trackp->tracks; i++) {
+		if (trackp[i].tracksize < (tsize_t)0) {
+			errmsgno(EX_BAD, "Track %d has unknown length.\n", i);
+			return (-1);
+		}
+	}
+	ncue = (*dp->cdr_gen_cue)(trackp, &cp, FALSE);
+
+	usalp->silent++;
+	ret = send_cue_sheet(usalp, (caddr_t)cp, ncue*8);
+	usalp->silent--;
+	free(cp);
+	if (ret < 0) {
+		errmsgno(EX_BAD, "CUE sheet not accepted. Retrying with minimum pregapsize = 1.\n");
+		ncue = (*dp->cdr_gen_cue)(trackp, &cp, TRUE);
+		ret = send_cue_sheet(usalp, (caddr_t)cp, ncue*8);
+		if (ret < 0) {
+			errmsgno(EX_BAD,
+			"CUE sheet still not accepted. Please try to write in RAW (-raw96r) mode.\n");
+		}
+		free(cp);
+	}
+	return (ret);
+}
+
+static int 
+stats_mmc(SCSI *usalp, cdr_t *dp)
+{
+	Uchar mode[256];
+	struct	ricoh_mode_page_30 *rp;
+	UInt32_t count;
+
+	if (mmc_isplextor(usalp) && lverbose) {
+		int	sels;
+		int	maxs;
+		int	lasts;
+
+		/*
+		 * Run it in silent mode as old drives do not support it.
+		 * As this function looks to be a part of the PowerRec
+		 * features, we may want to check
+		 * dp->cdr_flags & CDR_FORCESPEED
+		 */
+		usalp->silent++;
+		if (get_speeds_plextor(usalp, &sels, &maxs, &lasts) >= 0) {
+			printf("Last selected write speed: %dx\n",
+						sels / 176);
+			printf("Max media write speed:     %dx\n",
+						maxs / 176);
+			printf("Last actual write speed:   %dx\n",
+						lasts / 176);
+		}
+		usalp->silent--;
+	}
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_BURNFREE) == 0)
+		return (0);
+
+	if (mmc_isplextor(usalp)) {
+		int	i = 0;
+		int	ret;
+
+		/*
+		 * Read Burn-Proof counter
+		 */
+		usalp->silent++;
+		ret = bpc_plextor(usalp, 2, &i);
+		usalp->silent--;
+		if (ret < 0)
+			return (-1);
+		count = i;
+		/*
+		 * Clear Burn-Proof counter
+		 */
+		bpc_plextor(usalp, 1, NULL);
+	} else {
+		rp = get_justlink_ricoh(usalp, mode);
+		if (rp)
+			count = a_to_u_2_byte(rp->link_counter);
+		else
+			return (-1);
+	}
+	if (lverbose) {
+		if (count == 0)
+			printf("BURN-Free was never needed.\n");
+		else
+			printf("BURN-Free was %d times used.\n",
+				(int)count);
+	}
+	return (0);
+}
+/*--------------------------------------------------------------------------*/
+static BOOL 
+mmc_isplextor(SCSI *usalp)
+{
+	if (usalp->inq != NULL &&
+			strncmp(usalp->inq->vendor_info, "PLEXTOR", 7) == 0) {
+		return (TRUE);
+	}
+	return (FALSE);
+}
+
+static BOOL 
+mmc_isyamaha(SCSI *usalp)
+{
+	if (usalp->inq != NULL &&
+			strncmp(usalp->inq->vendor_info, "YAMAHA", 6) == 0) {
+		return (TRUE);
+	}
+	return (FALSE);
+}
+
+static void 
+do_varirec_plextor(SCSI *usalp)
+{
+	char	*p;
+	int	voff;
+
+	p = hasdrvopt(driveropts, "varirec=");
+	if (p == NULL || curspeed != 4) {
+		if (check_varirec_plextor(usalp) >= 0)
+			varirec_plextor(usalp, FALSE, 0);
+	} else {
+		if (*astoi(p, &voff) != '\0')
+			comerrno(EX_BAD,
+				"Bad varirec value '%s'.\n", p);
+		if (check_varirec_plextor(usalp) < 0)
+			comerrno(EX_BAD, "Drive does not support VariRec.\n");
+		varirec_plextor(usalp, TRUE, voff);
+	}
+}
+
+/*
+ * GigaRec value table
+ */
+struct gr {
+	Uchar	val;
+	char	vadd;
+	char	*name;
+} gr[] = {
+	{ 0x00,	0,  "off", },
+	{ 0x00,	0,  "1.0", },
+	{ 0x01,	2,  "1.2", },
+	{ 0x02,	3,  "1.3", },
+	{ 0x03,	4,  "1.4", },
+	{ 0x81,	-2, "0.8", },
+	{ 0x82,	-3, "0.7", },
+	{ 0x83,	-4, "0.6", },
+	{ 0x00,	0,  NULL, },
+};
+
+static int 
+do_gigarec_plextor(SCSI *usalp)
+{
+	char	*p;
+	int	val = 0;	/* Make silly GCC happy */
+
+	p = hasdrvopt(driveropts, "gigarec=");
+	if (p == NULL) {
+		if (check_gigarec_plextor(usalp) >= 0)
+			gigarec_plextor(usalp, 0);
+	} else {
+		struct gr *gp = gr;
+
+		for (; gp->name != NULL; gp++) {
+			if (streql(p, gp->name)) {
+				val = gp->val;
+				break;
+			}
+		}
+		if (gp->name == NULL)
+			comerrno(EX_BAD,
+				"Bad gigarec value '%s'.\n", p);
+		if (check_gigarec_plextor(usalp) < 0)
+			comerrno(EX_BAD, "Drive does not support GigaRec.\n");
+		return (gigarec_plextor(usalp, val));
+	}
+	return (0);
+}
+
+static int 
+drivemode_plextor(SCSI *usalp, caddr_t bp, int cnt, int modecode, void *modeval)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	if (modeval == NULL) {
+		scmd->flags |= SCG_RECV_DATA;
+		scmd->addr = bp;
+		scmd->size = cnt;
+	} else {
+		scmd->cdb.g5_cdb.res = 0x08;
+	}
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xE9;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.addr[0] = modecode;
+	if (modeval)
+		movebytes(modeval, &scmd->cdb.g1_cdb.addr[1], 6);
+	else
+		i_to_2_byte(&scmd->cdb.g1_cdb.count[2], cnt);
+
+	usalp->cmdname = "plextor drive mode";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+/*
+ * #defines for drivemode_plextor()...
+ */
+#define	MODE_CODE_SH	0x01	/* Mode code for Single Session & Hide-CDR */
+#define	MB1_SS		0x01	/* Single Session Mode			   */
+#define	MB1_HIDE_CDR	0x02	/* Hide CDR Media			   */
+
+#define	MODE_CODE_VREC	0x02	/* Mode code for Vari Rec		   */
+
+#define	MODE_CODE_GREC	0x04	/* Mode code for Giga Rec		   */
+
+#define	MODE_CODE_SPEED	0xbb	/* Mode code for Speed Read		   */
+#define	MBbb_SPEAD_READ	0x01	/* Spead Read				   */
+				/* Danach Speed auf 0xFFFF 0xFFFF setzen   */
+
+static int 
+drivemode2_plextor(SCSI *usalp, caddr_t bp, int cnt, int modecode, void *modeval)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	if (modeval == NULL) {
+		scmd->flags |= SCG_RECV_DATA;
+		scmd->addr = bp;
+		scmd->size = cnt;
+	} else {
+		scmd->cdb.g5_cdb.res = 0x08;
+	}
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xED;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.addr[0] = modecode;
+	if (modeval)
+		scmd->cdb.g5_cdb.reladr = *(char *)modeval != 0 ? 1 : 0;
+	else
+		i_to_2_byte(&scmd->cdb.g1_cdb.count[1], cnt);
+
+	usalp->cmdname = "plextor drive mode2";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int 
+check_varirec_plextor(SCSI *usalp)
+{
+	int	modecode = 2;
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	return (0);
+}
+
+static int 
+check_gigarec_plextor(SCSI *usalp)
+{
+	int	modecode = 4;
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	return (0);
+}
+
+static int 
+varirec_plextor(SCSI *usalp, BOOL on, int val)
+{
+	int	modecode = 2;
+	Uchar	setmode[8];
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+
+	fillbytes(setmode, sizeof (setmode), '\0');
+	setmode[0] = on?1:0;
+	if (on) {
+		if (val < -2 || val > 2)
+			comerrno(EX_BAD, "Bad VariRec offset %d\n", val);
+		printf("Turning Varirec on.\n");
+		printf("Varirec offset is %d.\n", val);
+
+		if (val > 0) {
+			setmode[1] = val & 0x7F;
+		} else {
+			setmode[1] = (-val) & 0x7F;
+			setmode[1] |= 0x80;
+		}
+	}
+
+	if (drivemode_plextor(usalp, NULL, 0, modecode, setmode) < 0)
+		return (-1);
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0)
+		return (-1);
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+	return (0);
+}
+
+static int 
+gigarec_plextor(SCSI *usalp, int val)
+{
+	int	modecode = 4;
+	Uchar	setmode[8];
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+
+	fillbytes(setmode, sizeof (setmode), '\0');
+	setmode[1] = val;
+
+	if (drivemode_plextor(usalp, NULL, 0, modecode, setmode) < 0)
+		return (-1);
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0)
+		return (-1);
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+	{
+		struct gr *gp = gr;
+
+		for (; gp->name != NULL; gp++) {
+			if (getmode[3] == gp->val)
+				break;
+		}
+		if (gp->name == NULL)
+			printf("Unknown GigaRec value 0x%X.\n", getmode[3]);
+		else
+			printf("GigaRec %sis %s.\n", gp->val?"value ":"", gp->name);
+	}
+	return (getmode[3]);
+}
+
+static Int32_t 
+gigarec_mult(int code, Int32_t val)
+{
+	Int32_t	add;
+	struct gr *gp = gr;
+
+	for (; gp->name != NULL; gp++) {
+		if (code == gp->val)
+			break;
+	}
+	if (gp->vadd == 0)
+		return (val);
+
+	add = val * gp->vadd / 10;
+	return (val + add);
+}
+
+static int 
+check_ss_hide_plextor(SCSI *usalp)
+{
+	int	modecode = 1;
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	return (getmode[2] & 0x03);
+}
+
+static int 
+check_speed_rd_plextor(SCSI *usalp)
+{
+	int	modecode = 0xBB;
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	return (getmode[2] & 0x01);
+}
+
+static int 
+check_powerrec_plextor(SCSI *usalp)
+{
+	int	modecode = 0;
+	Uchar	getmode[8];
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode2_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	if (getmode[2] & 1)
+		return (1);
+
+	return (0);
+}
+
+static int 
+ss_hide_plextor(SCSI *usalp, BOOL do_ss, BOOL do_hide)
+{
+	int	modecode = 1;
+	Uchar	setmode[8];
+	Uchar	getmode[8];
+	BOOL	is_ss;
+	BOOL	is_hide;
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+
+	is_ss = (getmode[2] & MB1_SS) != 0;
+	is_hide = (getmode[2] & MB1_HIDE_CDR) != 0;
+
+	if (lverbose > 0) {
+		printf("Single session is %s.\n", is_ss ? "ON":"OFF");
+		printf("Hide CDR is %s.\n", is_hide ? "ON":"OFF");
+	}
+
+	fillbytes(setmode, sizeof (setmode), '\0');
+	setmode[0] = getmode[2];		/* Copy over old values */
+	if (do_ss >= 0) {
+		if (do_ss)
+			setmode[0] |= MB1_SS;
+		else
+			setmode[0] &= ~MB1_SS;
+	}
+	if (do_hide >= 0) {
+		if (do_hide)
+			setmode[0] |= MB1_HIDE_CDR;
+		else
+			setmode[0] &= ~MB1_HIDE_CDR;
+	}
+
+	if (do_ss >= 0 && do_ss != is_ss)
+		printf("Turning single session %s.\n", do_ss?"on":"off");
+	if (do_hide >= 0 && do_hide != is_hide)
+		printf("Turning hide CDR %s.\n", do_hide?"on":"off");
+
+	if (drivemode_plextor(usalp, NULL, 0, modecode, setmode) < 0)
+		return (-1);
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0)
+		return (-1);
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+	return (0);
+}
+
+static int 
+speed_rd_plextor(SCSI *usalp, BOOL do_speedrd)
+{
+	int	modecode = 0xBB;
+	Uchar	setmode[8];
+	Uchar	getmode[8];
+	BOOL	is_speedrd;
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+
+	is_speedrd = (getmode[2] & MBbb_SPEAD_READ) != 0;
+
+	if (lverbose > 0)
+		printf("Speed-Read is %s.\n", is_speedrd ? "ON":"OFF");
+
+	fillbytes(setmode, sizeof (setmode), '\0');
+	setmode[0] = getmode[2];		/* Copy over old values */
+	if (do_speedrd >= 0) {
+		if (do_speedrd)
+			setmode[0] |= MBbb_SPEAD_READ;
+		else
+			setmode[0] &= ~MBbb_SPEAD_READ;
+	}
+
+	if (do_speedrd >= 0 && do_speedrd != is_speedrd)
+		printf("Turning Speed-Read %s.\n", do_speedrd?"on":"off");
+
+	if (drivemode_plextor(usalp, NULL, 0, modecode, setmode) < 0)
+		return (-1);
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	if (drivemode_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0)
+		return (-1);
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+	/*
+	 * Set current read speed to new max value.
+	 */
+	if (do_speedrd >= 0 && do_speedrd != is_speedrd)
+		scsi_set_speed(usalp, 0xFFFF, -1, ROTCTL_CAV);
+
+	return (0);
+}
+
+static int 
+powerrec_plextor(SCSI *usalp, BOOL do_powerrec)
+{
+	int	modecode = 0;
+	Uchar	setmode[8];
+	Uchar	getmode[8];
+	BOOL	is_powerrec;
+	int	speed;
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	usalp->silent++;
+	if (drivemode2_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0) {
+		usalp->silent--;
+		return (-1);
+	}
+	usalp->silent--;
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+
+	is_powerrec = (getmode[2] & 1) != 0;
+
+	speed = a_to_u_2_byte(&getmode[4]);
+
+	if (lverbose > 0) {
+		printf("Power-Rec is %s.\n", is_powerrec ? "ON":"OFF");
+		printf("Power-Rec write speed:     %dx (recommended)\n", speed / 176);
+	}
+
+	fillbytes(setmode, sizeof (setmode), '\0');
+	setmode[0] = getmode[2];		/* Copy over old values */
+	if (do_powerrec >= 0) {
+		if (do_powerrec)
+			setmode[0] |= 1;
+		else
+			setmode[0] &= ~1;
+	}
+
+	if (do_powerrec >= 0 && do_powerrec != is_powerrec)
+		printf("Turning Power-Rec %s.\n", do_powerrec?"on":"off");
+
+	if (drivemode2_plextor(usalp, NULL, 0, modecode, setmode) < 0)
+		return (-1);
+
+	fillbytes(getmode, sizeof (getmode), '\0');
+	if (drivemode2_plextor(usalp, (caddr_t)getmode, sizeof (getmode), modecode, NULL) < 0)
+		return (-1);
+
+	if (lverbose > 1)
+		usal_prbytes("Modes", getmode, sizeof (getmode));
+
+	return (0);
+}
+
+static int 
+get_speeds_plextor(SCSI *usalp, int *selp, int *maxp, int *lastp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	char	buf[10];
+	int	i;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	fillbytes((caddr_t)buf, sizeof (buf), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->flags |= SCG_RECV_DATA;
+	scmd->addr = buf;
+	scmd->size = sizeof (buf);
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xEB;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	i_to_2_byte(&scmd->cdb.g1_cdb.count[1], sizeof (buf));
+
+	usalp->cmdname = "plextor get speedlist";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	i = a_to_u_2_byte(&buf[4]);
+	if (selp)
+		*selp = i;
+
+	i = a_to_u_2_byte(&buf[6]);
+	if (maxp)
+		*maxp = i;
+
+	i = a_to_u_2_byte(&buf[8]);
+	if (lastp)
+		*lastp = i;
+
+	return (0);
+}
+
+static int 
+bpc_plextor(SCSI *usalp, int mode, int *bpp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	char	buf[4];
+	int	i;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	fillbytes((caddr_t)buf, sizeof (buf), '\0');
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->flags |= SCG_RECV_DATA;
+	scmd->addr = buf;
+	scmd->size = sizeof (buf);
+	scmd->cdb_len = SC_G5_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g5_cdb.cmd = 0xF5;
+	scmd->cdb.g5_cdb.lun = usal_lun(usalp);
+
+	scmd->cdb.g5_cdb.addr[1] = 0x08;
+	scmd->cdb.g5_cdb.addr[2] = mode;
+
+	i_to_2_byte(&scmd->cdb.g1_cdb.count[1], sizeof (buf));
+
+	usalp->cmdname = "plextor read bpc";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (usal_getresid(usalp) > 2)
+		return (0);
+
+	i = a_to_u_2_byte(buf);
+	if (bpp)
+		*bpp = i;
+
+	return (0);
+}
+
+static int 
+set_audiomaster_yamaha(SCSI *usalp, cdr_t *dp, BOOL keep_mode)
+{
+	Uchar	mode[0x100];
+	int	len;
+	int	ret = 0;
+	struct	cd_mode_page_05 *mp;
+
+	if (xdebug && !keep_mode)
+		printf("Checking for Yamaha Audio Master feature: ");
+
+	/*
+	 * Do not reset mp->test_write (-dummy) here.
+	 */
+	deflt_writemodes_mmc(usalp, FALSE);
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x05, "CD write parameter",
+			mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		usalp->silent--;
+		return (-1);
+	}
+	if (len == 0) {
+		usalp->silent--;
+		return (-1);
+	}
+
+	mp = (struct cd_mode_page_05 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+#ifdef	DEBUG
+	usal_prbytes("CD write parameter:", (Uchar *)mode, len);
+#endif
+
+	/*
+	 * Do not set mp->test_write (-dummy) here. It should be set
+	 * only at one place and only one time.
+	 */
+	mp->BUFE = 0;
+
+	mp->write_type = 8;
+	mp->track_mode = 0;
+	mp->dbtype = DB_RAW;
+
+	if (!set_mode_params(usalp, "CD write parameter", mode, len, 0, -1))
+		ret = -1;
+
+	/*
+	 * Do not reset mp->test_write (-dummy) here.
+	 */
+	if (!keep_mode || ret < 0)
+		deflt_writemodes_mmc(usalp, FALSE);
+	usalp->silent--;
+
+	return (ret);
+}
+
+struct 
+ricoh_mode_page_30 *get_justlink_ricoh(SCSI *usalp, Uchar *mode)
+{
+	Uchar	modec[0x100];
+	int	len;
+	struct	ricoh_mode_page_30 *mp;
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x30, "Ricoh Vendor Page", mode, modec, NULL, NULL, &len)) {
+		usalp->silent--;
+		return ((struct ricoh_mode_page_30 *)0);
+	}
+	usalp->silent--;
+
+	/*
+	 * SCSI mode header + 6 bytes mode page 30.
+	 * This is including the Burn-Free counter.
+	 */
+	if (len < 10)
+		return ((struct ricoh_mode_page_30 *)0);
+
+	if (xdebug) {
+		fprintf(stderr, "Mode len: %d\n", len);
+		usal_prbytes("Mode Sense Data ", mode, len);
+		usal_prbytes("Mode Sence CData", modec, len);
+	}
+
+	mp = (struct ricoh_mode_page_30 *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	/*
+	 * 6 bytes mode page 30.
+	 * This is including the Burn-Free counter.
+	 */
+	if ((len - ((Uchar *)mp - mode) -1) < 5)
+		return ((struct ricoh_mode_page_30 *)0);
+
+	if (xdebug) {
+		fprintf(stderr, "Burnfree counter: %d\n", a_to_u_2_byte(mp->link_counter));
+	}
+	return (mp);
+}
+
+static int 
+force_speed_yamaha(SCSI *usalp, int readspeed, int writespeed)
+{
+	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[11] = 0x80;
+
+	usalp->cmdname = "yamaha force cd speed";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static BOOL
+get_tattoo_yamaha(SCSI *usalp, BOOL print, Int32_t *irp, Int32_t *orp)
+{
+	Uchar	mode[0x100];
+	int	len;
+	UInt32_t ival;
+	UInt32_t oval;
+	Uchar	*mp;
+
+	usalp->silent++;
+	if (!get_mode_params(usalp, 0x31, "Yamaha Tattoo Page", mode, NULL, NULL, NULL, &len)) {
+		usalp->silent--;
+		return (FALSE);
+	}
+	usalp->silent--;
+
+	/*
+	 * SCSI mode header + 16 bytes mode page 31.
+	 * This is including the Burn-Free counter.
+	 */
+	if (len < 20)
+		return (FALSE);
+
+	mp = (Uchar *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	/*
+	 * 10 bytes mode page 31.
+	 * This is including the Burn-Free counter.
+	 */
+	if ((len - ((Uchar *)mp - mode) -1) < 10)
+		return (FALSE);
+
+	ival = a_to_u_3_byte(&mp[4]);
+	oval = a_to_u_3_byte(&mp[7]);
+
+	if (irp)
+		*irp = ival;
+	if (orp)
+		*orp = oval;
+
+	if (print && ival > 0 && oval > 0) {
+		printf("DiskT@2 inner r: %d\n", (int)ival);
+		printf("DiskT@2 outer r: %d\n", (int)oval);
+		printf("DiskT@2 image size: 3744 x %d pixel.\n",
+						(int)(oval-ival)+1);
+	}
+
+	return (TRUE);
+}
+
+static int 
+do_tattoo_yamaha(SCSI *usalp, FILE *f)
+{
+	Int32_t ival = 0;
+	Int32_t oval = 0;
+	Int32_t	lines;
+	off_t	fsize;
+	char	*buf = usalp->bufptr;
+	long	bufsize = usalp->maxbuf;
+	long	nsecs;
+	long	amt;
+
+	nsecs = bufsize / 2048;
+	bufsize = nsecs * 2048;
+
+	if (!get_tattoo_yamaha(usalp, FALSE, &ival, &oval)) {
+		errmsgno(EX_BAD, "Cannot get DiskT@2 info.\n");
+		return (-1);
+	}
+
+	if (ival == 0 || oval == 0) {
+		errmsgno(EX_BAD, "DiskT@2 info not valid.\n");
+		return (-1);
+	}
+
+	lines = oval - ival + 1;
+	fsize = filesize(f);
+	if ((fsize % 3744) != 0 || fsize < (lines*3744)) {
+		errmsgno(EX_BAD, "Illegal DiskT@2 file size.\n");
+		return (-1);
+	}
+	if (fsize > (lines*3744))
+		fsize = lines*3744;
+
+	if (lverbose)
+		printf("Starting to write DiskT@2 data.\n");
+	fillbytes(buf, bufsize, '\0');
+	if ((amt = fileread(f, buf, bufsize)) <= 0) {
+		errmsg("DiskT@2 file read error.\n");
+		return (-1);
+	}
+
+	if (yamaha_write_buffer(usalp, 1, 0, ival, amt/2048, buf, amt) < 0) {
+		errmsgno(EX_BAD, "DiskT@2 1st write error.\n");
+		return (-1);
+	}
+	amt = (amt+2047) / 2048 * 2048;
+	fsize -= amt;
+
+	while (fsize > 0) {
+		fillbytes(buf, bufsize, '\0');
+		if ((amt = fileread(f, buf, bufsize)) <= 0) {
+			errmsg("DiskT@2 file read error.\n");
+			return (-1);
+		}
+		amt = (amt+2047) / 2048 * 2048;
+		fsize -= amt;
+		if (yamaha_write_buffer(usalp, 1, 0, 0, amt/2048, buf, amt) < 0) {
+			errmsgno(EX_BAD, "DiskT@2 write error.\n");
+			return (-1);
+		}
+	}
+
+	if (yamaha_write_buffer(usalp, 1, 0, oval, 0, buf, 0) < 0) {
+		errmsgno(EX_BAD, "DiskT@2 final error.\n");
+		return (-1);
+	}
+
+	wait_unit_ready(usalp, 1000);	/* Wait for DiskT@2 */
+	waitfix_mmc(usalp, 1000);	/* Wait for DiskT@2 */
+
+	return (0);
+}
+
+/*
+ * Yamaha specific version of 'write buffer' that offers an additional
+ * Parameter Length 'parlen' parameter.
+ */
+static int 
+yamaha_write_buffer(SCSI *usalp, int mode, int bufferid, long offset,
+                    long parlen, void *buffer, long buflen)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+		Uchar	*CDB;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = buffer;
+	scmd->size = buflen;
+	scmd->flags = SCG_DISRE_ENA;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0x3B;
+
+	CDB    = (Uchar *)scmd->cdb.cmd_cdb;
+	CDB[1] = mode & 7;
+	CDB[2] = bufferid;
+	i_to_3_byte(&CDB[3], offset);
+	i_to_3_byte(&CDB[6], parlen);
+
+	usalp->cmdname = "write_buffer";
+
+	if (usal_cmd(usalp) >= 0)
+		return (1);
+	return (0);
+}
+
+static int 
+dvd_dual_layer_split(SCSI *usalp, cdr_t *dp, long tsize)
+{
+    unsigned char	xb[12];
+    long 	l0_size;
+    
+    /* Get the Layer 0 defined data zone*/
+    if (read_dvd_structure(usalp, (caddr_t)xb, 12, 0, 0, 0x20) >= 0) {
+	if ((xb[1] | xb[0] << 8) < 13) {
+	    fprintf(stderr, "dvd_dual_layer_split: read_dvd_structure returns invalid data\n");
+	    return 1;
+	}
+	if (xb[4] & 0x80) {
+	    printf("L0 zone size already set\n");
+	    return 1;
+	}
+	l0_size = xb[11] | xb[10] << 8 | xb[9] << 16 | xb[8] << 24;
+	if (tsize < l0_size) {
+	    fprintf(stderr, "track size smaller than one layer, use --force to force burning.");
+	    return 0;
+	}
+	printf("L0 size: %ld (track size %ld)\n", l0_size, tsize);
+	l0_size = tsize / 2;
+	l0_size = l0_size - 1 + 16 - (l0_size - 1) % 16;
+	printf("New L0 size: %ld\n", l0_size);
+
+	memset (xb, 0, sizeof(xb));
+	xb[1]  = sizeof(xb) - 2;
+	xb[8]  = l0_size >> 24;
+	xb[9]  = l0_size >> 16;
+	xb[10] = l0_size >> 8;
+	xb[11] = l0_size;
+	if (send_dvd_structure(usalp, (caddr_t)xb, 12, 0, 0x20)) {
+	    fprintf(stderr, "dvd_dual_layer_split: send_dvd_structure failed, could not set middle zone location.\n");
+	    return 0;
+	}
+    }
+   return 1;
+}
diff --git a/wodim/drv_philips.c b/wodim/drv_philips.c
new file mode 100644
index 0000000..13cf8ed
--- /dev/null
+++ b/wodim/drv_philips.c
@@ -0,0 +1,1346 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)drv_philips.c	1.69 05/05/16 Copyright 1997-2005 J. Schilling */
+/*
+ *	CDR device implementation for
+ *	Philips/Yamaha/Ricoh/Plasmon
+ *
+ *	Copyright (c) 1997-2005 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.
+ */
+
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <unixstd.h>	/* Include sys/types.h to make off_t available */
+#include <standard.h>
+#include <intcvt.h>
+#include <schily.h>
+
+#include <usal/scsireg.h>
+#include <usal/scsitransp.h>
+#include <usal/usalcmd.h>
+#include <usal/scsidefs.h>	/* XXX Only for DEV_RICOH_RO_1060C */
+
+#include "wodim.h"
+
+extern	int	debug;
+extern	int	lverbose;
+
+static	int	load_unload_philips(SCSI *usalp, int);
+static	int	philips_load(SCSI *usalp, cdr_t *dp);
+static	int	philips_unload(SCSI *usalp, cdr_t *dp);
+static	int	philips_dumbload(SCSI *usalp, cdr_t *dp);
+static	int	philips_dumbunload(SCSI *usalp, cdr_t *dp);
+static	int	plasmon_buf(SCSI *, long *, long *);
+static	int	recover_philips(SCSI *usalp, cdr_t *dp, int);
+static	int	speed_select_yamaha(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	speed_select_philips(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	speed_select_oldphilips(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	speed_select_dumbphilips(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	speed_select_pioneer(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	philips_init(SCSI *usalp, cdr_t *dp);
+static	int	philips_getdisktype(SCSI *usalp, cdr_t *dp);
+static	BOOL	capacity_philips(SCSI *usalp, long *lp);
+static	int	first_writable_addr_philips(SCSI *usalp, long *, int, int, int, 
+														 int);
+static	int	next_wr_addr_philips(SCSI *usalp, track_t *trackp, long *ap);
+static	int	reserve_track_philips(SCSI *usalp, unsigned long);
+static	int	scsi_cdr_write_philips(SCSI *usalp, caddr_t bp, long sectaddr, 
+												  long size, int blocks, BOOL islast);
+static	int	write_track_info_philips(SCSI *usalp, int);
+static	int	write_track_philips(SCSI *usalp, long, int);
+static	int	open_track_philips(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	open_track_plasmon(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	open_track_oldphilips(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	open_track_yamaha(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	close_track_philips(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	fixation_philips(SCSI *usalp, cdr_t *dp, track_t *trackp);
+
+static	int	philips_attach(SCSI *usalp, cdr_t *);
+static	int	plasmon_attach(SCSI *usalp, cdr_t *);
+static	int	ricoh_attach(SCSI *usalp, cdr_t *);
+static	int	philips_getlilo(SCSI *usalp, long *lilenp, long *lolenp);
+
+
+struct cdd_52x_mode_page_21 {	/* write track information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x0E = 14 Bytes */
+	Uchar	res_2;
+	Uchar	sectype;
+	Uchar	track;
+	Uchar	ISRC[9];
+	Uchar	res[2];
+};
+
+struct cdd_52x_mode_page_23 {	/* speed selection */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x06 = 6 Bytes */
+	Uchar	speed;
+	Uchar	dummy;
+	Uchar	res[4];
+
+};
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct yamaha_mode_page_31 {	/* drive configuration */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	res;
+	Ucbit	dummy		: 4;
+	Ucbit	speed		: 4;
+};
+
+#else				/* Motorola byteorder */
+
+struct yamaha_mode_page_31 {	/* drive configuration */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	res;
+	Ucbit	speed		: 4;
+	Ucbit	dummy		: 4;
+};
+#endif
+
+struct cdd_52x_mode_data {
+	struct scsi_mode_header	header;
+	union cdd_pagex	{
+		struct cdd_52x_mode_page_21	page21;
+		struct cdd_52x_mode_page_23	page23;
+		struct yamaha_mode_page_31	page31;
+	} pagex;
+};
+
+
+cdr_t	cdr_philips_cdd521O = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"philips_cdd521_old",
+	"driver for Philips old CDD-521",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_load,
+	philips_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_oldphilips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_oldphilips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_philips_dumb = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"philips_dumb",
+	"driver for Philips CDD-521 with pessimistic assumptions",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_dumbload,
+	philips_dumbunload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_dumbphilips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_oldphilips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_philips_cdd521 = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"philips_cdd521",
+	"driver for Philips CDD-521",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_load,
+	philips_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_philips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_philips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_philips_cdd522 = {
+	0, 0,
+/*	CDR_TAO|CDR_SAO|CDR_TRAYLOAD,*/
+	CDR_TAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"philips_cdd522",
+	"driver for Philips CDD-522",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_load,
+	philips_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_philips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_philips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_tyuden_ew50 = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD|CDR_SWABAUDIO,
+	CDR_CDRW_NONE,
+	2, 2,
+	"tyuden_ew50",
+	"driver for Taiyo Yuden EW-50",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_load,
+	philips_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_philips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_philips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_kodak_pcd600 = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	6, 6,
+	"kodak_pcd_600",
+	"driver for Kodak PCD-600",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_load,
+	philips_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_philips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_oldphilips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_plasmon_rf4100 = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD,
+	CDR_CDRW_NONE,
+	2, 4,
+	"plasmon_rf4100",
+	"driver for Plasmon RF 4100",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	plasmon_attach,
+	philips_init,
+	philips_getdisktype,
+	philips_load,
+	philips_unload,
+	plasmon_buf,
+	recovery_needed,
+	recover_philips,
+	speed_select_philips,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_plasmon,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_pioneer_dw_s114x = {
+	0, 0,
+	CDR_TAO|CDR_TRAYLOAD|CDR_SWABAUDIO,
+	CDR_CDRW_NONE,
+	2, 4,
+	"pioneer_dws114x",
+	"driver for Pioneer DW-S114X",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	philips_getdisktype,
+	scsi_load,
+	scsi_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_pioneer,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+/*	open_track_yamaha,*/
+/*???*/	open_track_oldphilips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_yamaha_cdr100 = {
+	0, 0,
+/*	CDR_TAO|CDR_SAO|CDR_CADDYLOAD|CDR_SWABAUDIO,*/
+	CDR_TAO|CDR_CADDYLOAD|CDR_SWABAUDIO,
+	CDR_CDRW_NONE,
+	2, 4,
+	"yamaha_cdr100",
+	"driver for Yamaha CDR-100 / CDR-102",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	philips_attach,
+	philips_init,
+	drive_getdisktype,
+	scsi_load,
+	philips_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_yamaha,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_yamaha,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_ricoh_ro1060 = {
+	0, 0,
+/*	CDR_TAO|CDR_SAO|CDR_CADDYLOAD,*/
+	CDR_TAO|CDR_CADDYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"ricoh_ro1060c",
+	"driver for Ricoh RO-1060C",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	ricoh_attach,
+	philips_init,
+	philips_getdisktype,
+	scsi_load,
+	scsi_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_yamaha,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_philips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_ricoh_ro1420 = {
+	0, 0,
+/*	CDR_TAO|CDR_SAO|CDR_CADDYLOAD,*/
+	CDR_TAO|CDR_CADDYLOAD,
+	CDR_CDRW_NONE,
+	2, 2,
+	"ricoh_ro1420c",
+	"driver for Ricoh RO-1420C",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	ricoh_attach,
+	philips_init,
+	philips_getdisktype,
+	scsi_load,
+	scsi_unload,
+	buf_dummy,
+	recovery_needed,
+	recover_philips,
+	speed_select_yamaha,
+	select_secsize,
+	next_wr_addr_philips,
+	reserve_track_philips,
+	scsi_cdr_write_philips,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	no_sendcue,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_philips,
+	close_track_philips,
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset_philips,
+	fixation_philips,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+
+static int load_unload_philips(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_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0xE7;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.count[1] = !load;
+
+	usalp->cmdname = "philips medium load/unload";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+philips_load(SCSI *usalp, cdr_t *dp)
+{
+	return (load_unload_philips(usalp, 1));
+}
+
+static int 
+philips_unload(SCSI *usalp, cdr_t *dp)
+{
+	return (load_unload_philips(usalp, 0));
+}
+
+static int 
+philips_dumbload(SCSI *usalp, cdr_t *dp)
+{
+	int	ret;
+
+	usalp->silent++;
+	ret = load_unload_philips(usalp, 1);
+	usalp->silent--;
+	if (ret < 0)
+		return (scsi_load(usalp, dp));
+	return (0);
+}
+
+static int 
+philips_dumbunload(SCSI *usalp, cdr_t *dp)
+{
+	int	ret;
+
+	usalp->silent++;
+	ret = load_unload_philips(usalp, 0);
+	usalp->silent--;
+	if (ret < 0)
+		return (scsi_unload(usalp, dp));
+	return (0);
+}
+
+static int 
+plasmon_buf(SCSI *usalp, 
+            long *sp /* Size pointer */, 
+            long *fp /* Free space pointer */)
+{
+	/*
+	 * There's no way to obtain these values from the
+	 * Plasmon RF41xx devices.  This function stub is only
+	 * present to prevent cdrecord.c from calling the READ BUFFER
+	 * SCSI cmd which is implemented non standard compliant in
+	 * the Plasmon drive. Calling READ BUFFER would only jam the Plasmon
+	 * as the non standard implementation in the Plasmon firmware
+	 * expects different parameters.
+	 */
+
+	if (sp)
+		*sp = 0L;
+	if (fp)
+		*fp = 0L;
+
+	return (100);	/* 100 % */
+}
+
+static int 
+recover_philips(SCSI *usalp, cdr_t *dp, int track)
+{
+	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 = 0xEC;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "philips recover";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+speed_select_yamaha(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	struct	scsi_mode_page_header	*mp;
+	char				mode[256];
+	int				len = 16;
+	int				page = 0x31;
+	struct yamaha_mode_page_31	*xp;
+	struct cdd_52x_mode_data md;
+	int	count;
+	int	speed = 1;
+	BOOL	dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp) {
+		speed = *speedp;
+	} else {
+		fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+		if (!get_mode_params(usalp, page, "Speed/Dummy information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+			return (-1);
+		}
+		if (len == 0)
+			return (-1);
+
+		mp = (struct scsi_mode_page_header *)
+			(mode + sizeof (struct scsi_mode_header) +
+			((struct scsi_mode_header *)mode)->blockdesc_len);
+
+		xp = (struct yamaha_mode_page_31 *)mp;
+		speed = xp->speed;
+	}
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct yamaha_mode_page_31);
+
+	speed >>= 1;
+	md.pagex.page31.p_code = 0x31;
+	md.pagex.page31.p_len =  0x02;
+	md.pagex.page31.speed = speed;
+	md.pagex.page31.dummy = dummy?1:0;
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+speed_select_philips(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	struct	scsi_mode_page_header	*mp;
+	char				mode[256];
+	int				len = 20;
+	int				page = 0x23;
+	struct cdd_52x_mode_page_23	*xp;
+	struct cdd_52x_mode_data	md;
+	int				count;
+	int				speed = 1;
+	BOOL				dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp) {
+		speed = *speedp;
+	} else {
+		fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+		if (!get_mode_params(usalp, page, "Speed/Dummy information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+			return (-1);
+		}
+		if (len == 0)
+			return (-1);
+
+		mp = (struct scsi_mode_page_header *)
+			(mode + sizeof (struct scsi_mode_header) +
+			((struct scsi_mode_header *)mode)->blockdesc_len);
+
+		xp = (struct cdd_52x_mode_page_23 *)mp;
+		speed = xp->speed;
+	}
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct cdd_52x_mode_page_23);
+
+	md.pagex.page23.p_code = 0x23;
+	md.pagex.page23.p_len =  0x06;
+	md.pagex.page23.speed = speed;
+	md.pagex.page23.dummy = dummy?1:0;
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+speed_select_pioneer(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	if (speedp != 0 && *speedp < 2) {
+		*speedp = 2;
+		if (lverbose)
+			printf("WARNING: setting to minimum speed (2).\n");
+	}
+	return (speed_select_philips(usalp, dp, speedp));
+}
+
+static int 
+speed_select_oldphilips(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	BOOL	dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (lverbose)
+		printf("WARNING: ignoring selected speed.\n");
+	if (dummy) {
+		errmsgno(EX_BAD, "Cannot set dummy writing for this device.\n");
+		return (-1);
+	}
+	return (0);
+}
+
+static int 
+speed_select_dumbphilips(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	if (speed_select_philips(usalp, dp, speedp) < 0)
+		return (speed_select_oldphilips(usalp, dp, speedp));
+	return (0);
+}
+
+static int 
+philips_init(SCSI *usalp, cdr_t *dp)
+{
+	return ((*dp->cdr_set_speed_dummy)(usalp, dp, NULL));
+}
+
+
+#define	IS(what, flag)	printf("  Is %s%s\n", flag?"":"not ", what);
+
+static int 
+philips_getdisktype(SCSI *usalp, cdr_t *dp)
+{
+	dstat_t	*dsp = dp->cdr_dstat;
+	char	sbuf[16];
+	long	dummy;
+	long	lilen;
+	long	lolen;
+	msf_t	msf;
+	int	audio = -1;
+
+	usalp->silent++;
+	dummy = (*dp->cdr_next_wr_address)(usalp, (track_t *)0, &lilen);
+	usalp->silent--;
+
+	/*
+	 * Check for "Command sequence error" first.
+	 */
+	if ((dsp->ds_cdrflags & RF_WRITE) != 0 &&
+	    dummy < 0 &&
+	    (usal_sense_key(usalp) != SC_ILLEGAL_REQUEST ||
+						usal_sense_code(usalp) != 0x2C)) {
+		reload_media(usalp, dp);
+	}
+
+	usalp->silent++;
+	if (read_subchannel(usalp, sbuf, 0, 12, 0, 1, 0xf0) >= 0) {
+		if (sbuf[2] == 0 && sbuf[3] == 8)
+			audio = (sbuf[7] & 0x40) != 0;
+	}
+	usalp->silent--;
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_PRATIP) != 0 &&
+						dummy >= 0 && lilen == 0) {
+		usalp->silent++;
+		dummy = philips_getlilo(usalp, &lilen, &lolen);
+		usalp->silent--;
+
+		if (dummy >= 0) {
+/*			printf("lead-in len: %d lead-out len: %d\n", lilen, lolen);*/
+			lba_to_msf(-150 - lilen, &msf);
+
+			printf("ATIP info from disk:\n");
+			if (audio >= 0)
+				IS("unrestricted", audio);
+			if (audio == 1 || (audio == 0 && (sbuf[7] & 0x3F) != 0x3F))
+				printf("  Disk application code: %d\n", sbuf[7] & 0x3F);
+			printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)\n",
+				-150 - lilen, msf.msf_min, msf.msf_sec, msf.msf_frame);
+
+			if (capacity_philips(usalp, &lolen)) {
+				lba_to_msf(lolen, &msf);
+				printf(
+				"  ATIP start of lead out: %ld (%02d:%02d/%02d)\n",
+				lolen, msf.msf_min, msf.msf_sec, msf.msf_frame);
+			}
+			lba_to_msf(-150 - lilen, &msf);
+			pr_manufacturer(&msf,
+					FALSE,		/* Always not erasable */
+					audio > 0);	/* Audio from read subcode */
+		}
+	}
+
+	if (capacity_philips(usalp, &lolen)) {
+		dsp->ds_maxblocks = lolen;
+		dsp->ds_maxrblocks = disk_rcap(&msf, dsp->ds_maxblocks,
+					FALSE,		/* Always not erasable */
+					audio > 0);	/* Audio from read subcode */
+	}
+	usalp->silent++;
+	/*read_subchannel(usalp, bp, track, cnt, msf, subq, fmt); */
+
+	if (read_subchannel(usalp, sbuf, 0, 14, 0, 0, 0xf1) >= 0)
+		usal_prbytes("Disk bar code:", (Uchar *)sbuf, 14 - usal_getresid(usalp));
+	usalp->silent--;
+
+	return (drive_getdisktype(usalp, dp));
+}
+
+static BOOL 
+capacity_philips(SCSI *usalp, long *lp)
+{
+	long	l = 0L;
+	BOOL	succeed = TRUE;
+
+	usalp->silent++;
+	if (read_B0(usalp, FALSE, NULL, &l) >= 0) {
+		if (debug)
+			printf("lead out B0: %ld\n", l);
+		*lp = l;
+	} else if (read_trackinfo(usalp, 0xAA, &l, NULL, NULL, NULL, NULL) >= 0) {
+		if (debug)
+			printf("lead out AA: %ld\n", l);
+		*lp = l;
+	} if (read_capacity(usalp) >= 0) {
+		l = usalp->cap->c_baddr + 1;
+		if (debug)
+			printf("lead out capacity: %ld\n", l);
+	} else {
+		succeed = FALSE;
+	}
+	*lp = l;
+	usalp->silent--;
+	return (succeed);
+}
+
+struct	fwa {
+	char	len;
+	char	addr[4];
+	char	res;
+};
+
+static int 
+first_writable_addr_philips(SCSI *usalp, long *ap, int track, int isaudio, 
+										int preemp, int npa)
+{
+	struct	fwa	fwa;
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)&fwa, sizeof (fwa), '\0');
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = (caddr_t)&fwa;
+	scmd->size = sizeof (fwa);
+	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 = 0xE2;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.addr[0] = track;
+	scmd->cdb.g1_cdb.addr[1] = isaudio ? (preemp ? 5 : 4) : 1;
+
+	scmd->cdb.g1_cdb.count[0] = npa?1:0;
+	scmd->cdb.g1_cdb.count[1] = sizeof (fwa);
+
+	usalp->cmdname = "first writeable address philips";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (ap)
+		*ap = a_to_4_byte(fwa.addr);
+	return (0);
+}
+
+static int 
+next_wr_addr_philips(SCSI *usalp, track_t *trackp, long *ap)
+{
+
+/*	if (first_writable_addr_philips(usalp, ap, 0, 0, 0, 1) < 0)*/
+	if (first_writable_addr_philips(usalp, ap, 0, 0, 0, 0) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+reserve_track_philips(SCSI *usalp, unsigned long len)
+{
+	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 = 0xE4;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	i_to_4_byte(&scmd->cdb.g1_cdb.addr[3], len);
+
+	usalp->cmdname = "philips reserve_track";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+scsi_cdr_write_philips(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_xg0(usalp, bp, 0, size, blocks));
+}
+
+static int 
+write_track_info_philips(SCSI *usalp, int sectype)
+{
+	struct cdd_52x_mode_data md;
+	int	count = sizeof (struct scsi_mode_header) +
+			sizeof (struct cdd_52x_mode_page_21);
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+	md.pagex.page21.p_code = 0x21;
+	md.pagex.page21.p_len =  0x0E;
+				/* is sectype ok ??? */
+	md.pagex.page21.sectype = sectype & ST_MASK;
+	md.pagex.page21.track = 0;	/* 0 : create new track */
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, usalp->inq->data_format >= 2));
+}
+
+static int 
+write_track_philips(SCSI *usalp, 
+							long track /* track number 0 == new track */, 
+                    	int sectype)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	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 = 0xE6;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, track);
+	scmd->cdb.g1_cdb.res6 = sectype & ST_MASK;
+
+	usalp->cmdname = "philips write_track";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int 
+open_track_philips(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (select_secsize(usalp, trackp->secsize) < 0)
+		return (-1);
+
+	if (write_track_info_philips(usalp, trackp->sectype) < 0)
+		return (-1);
+
+	if (write_track_philips(usalp, 0, trackp->sectype) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int 
+open_track_plasmon(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (select_secsize(usalp, trackp->secsize) < 0)
+		return (-1);
+
+	if (write_track_info_philips(usalp, trackp->sectype) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int 
+open_track_oldphilips(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (write_track_philips(usalp, 0, trackp->sectype) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int 
+open_track_yamaha(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (select_secsize(usalp, trackp->secsize) < 0)
+		return (-1);
+
+	if (write_track_philips(usalp, 0, trackp->sectype) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int 
+close_track_philips(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	return (scsi_flush_cache(usalp, FALSE));
+}
+
+static int fixation_philips(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	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 = 0xE9;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.count[1] =
+			((track_base(trackp)->tracktype & TOCF_MULTI) ? 8 : 0) |
+			(track_base(trackp)->tracktype & TOC_MASK);
+
+	usalp->cmdname = "philips fixation";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static const char *sd_cdd_521_error_str[] = {
+	"\003\000tray out",				/* 0x03 */
+	"\062\000write data error with CU",		/* 0x32 */	/* Yamaha */
+	"\063\000monitor atip error",			/* 0x33 */
+	"\064\000absorbtion control error",		/* 0x34 */
+#ifdef	YAMAHA_CDR_100
+	/* Is this the same ??? */
+	"\120\000write operation in progress",		/* 0x50 */
+#endif
+	"\127\000unable to read TOC/PMA/Subcode/ATIP",	/* 0x57 */
+	"\132\000operator medium removal request",	/* 0x5a */
+	"\145\000verify failed",			/* 0x65 */
+	"\201\000illegal track number",			/* 0x81 */
+	"\202\000command now not valid",		/* 0x82 */
+	"\203\000medium removal is prevented",		/* 0x83 */
+	"\204\000tray out",				/* 0x84 */
+	"\205\000track at one not in PMA",		/* 0x85 */
+	"\240\000stopped on non data block",		/* 0xa0 */
+	"\241\000invalid start adress",			/* 0xa1 */
+	"\242\000attampt to cross track-boundary",	/* 0xa2 */
+	"\243\000illegal medium",			/* 0xa3 */
+	"\244\000disk write protected",			/* 0xa4 */
+	"\245\000application code conflict",		/* 0xa5 */
+	"\246\000illegal blocksize for command",	/* 0xa6 */
+	"\247\000blocksize conflict",			/* 0xa7 */
+	"\250\000illegal transfer length",		/* 0xa8 */
+	"\251\000request for fixation failed",		/* 0xa9 */
+	"\252\000end of medium reached",		/* 0xaa */
+#ifdef	REAL_CDD_521
+	"\253\000non reserved reserved track",		/* 0xab */
+#else
+	"\253\000illegal track number",			/* 0xab */
+#endif
+	"\254\000data track length error",		/* 0xac */
+	"\255\000buffer under run",			/* 0xad */
+	"\256\000illegal track mode",			/* 0xae */
+	"\257\000optical power calibration error",	/* 0xaf */
+	"\260\000calibration area almost full",		/* 0xb0 */
+	"\261\000current program area empty",		/* 0xb1 */
+	"\262\000no efm at search address",		/* 0xb2 */
+	"\263\000link area encountered",		/* 0xb3 */
+	"\264\000calibration area full",		/* 0xb4 */
+	"\265\000dummy data blocks added",		/* 0xb5 */
+	"\266\000block size format conflict",		/* 0xb6 */
+	"\267\000current command aborted",		/* 0xb7 */
+	"\270\000program area not empty",		/* 0xb8 */
+#ifdef	YAMAHA_CDR_100
+	/* Used while writing lead in in DAO */
+	"\270\000write leadin in progress",		/* 0xb8 */
+#endif
+	"\271\000parameter list too large",		/* 0xb9 */
+	"\277\000buffer overflow",			/* 0xbf */	/* Yamaha */
+	"\300\000no barcode available",			/* 0xc0 */
+	"\301\000barcode reading error",		/* 0xc1 */
+	"\320\000recovery needed",			/* 0xd0 */
+	"\321\000cannot recover track",			/* 0xd1 */
+	"\322\000cannot recover pma",			/* 0xd2 */
+	"\323\000cannot recover leadin",		/* 0xd3 */
+	"\324\000cannot recover leadout",		/* 0xd4 */
+	"\325\000cannot recover opc",			/* 0xd5 */
+	"\326\000eeprom failure",			/* 0xd6 */
+	"\340\000laser current over",			/* 0xe0 */	/* Yamaha */
+	"\341\000servo adjustment over",		/* 0xe0 */	/* Yamaha */
+	NULL
+};
+
+static const char *sd_ro1420_error_str[] = {
+	"\004\000logical unit is in process of becoming ready", /* 04 00 */
+	"\011\200radial skating error",				/* 09 80 */
+	"\011\201sledge servo failure",				/* 09 81 */
+	"\011\202pll no lock",					/* 09 82 */
+	"\011\203servo off track",				/* 09 83 */
+	"\011\204atip sync error",				/* 09 84 */
+	"\011\205atip/subcode jumped error",			/* 09 85 */
+	"\127\300subcode not found",				/* 57 C0 */
+	"\127\301atip not found",				/* 57 C1 */
+	"\127\302no atip or subcode",				/* 57 C2 */
+	"\127\303pma error",					/* 57 C3 */
+	"\127\304toc read error",				/* 57 C4 */
+	"\127\305disk informatoion error",			/* 57 C5 */
+	"\144\200read in leadin",				/* 64 80 */
+	"\144\201read in leadout",				/* 64 81 */
+	"\201\000illegal track",				/* 81 00 */
+	"\202\000command not now valid",			/* 82 00 */
+	"\220\000reserve track check error",			/* 90 00 */
+	"\220\001verify blank error",				/* 90 01 */
+	"\221\001mode of last track error",			/* 91 01 */
+	"\222\000header search error",				/* 92 00 */
+	"\230\001header monitor error",				/* 98 01 */
+	"\230\002edc error",					/* 98 02 */
+	"\230\003read link, run-in run-out",			/* 98 03 */
+	"\230\004last one block error",				/* 98 04 */
+	"\230\005illegal blocksize",				/* 98 05 */
+	"\230\006not all data transferred",			/* 98 06 */
+	"\230\007cdbd over run error",				/* 98 07 */
+	"\240\000stopped on non_data block",			/* A0 00 */
+	"\241\000invalid start address",			/* A1 00 */
+	"\243\000illegal medium",				/* A3 00 */
+	"\246\000illegal blocksize for command",		/* A6 00 */
+	"\251\000request for fixation failed",			/* A9 00 */
+	"\252\000end of medium reached",			/* AA 00 */
+	"\253\000illegal track number",				/* AB 00 */
+	"\255\000buffer underrun",				/* AD 00 */
+	"\256\000illegal track mode",				/* AE 00 */
+	"\257\200power range error",				/* AF 80 */
+	"\257\201moderation error",				/* AF 81 */
+	"\257\202beta upper range error",			/* AF 82 */
+	"\257\203beta lower range error",			/* AF 83 */
+	"\257\204alpha upper range error",			/* AF 84 */
+	"\257\205alpha lower range error",			/* AF 85 */
+	"\257\206alpha and power range error",			/* AF 86 */
+	"\260\000calibration area almost full",			/* B0 00 */
+	"\261\000current program area empty",			/* B1 00 */
+	"\262\000no efm at search address",			/* B2 00 */
+	"\264\000calibration area full",			/* B4 00 */
+	"\265\000dummy blocks added",				/* B5 00 */
+	"\272\000write audio on reserved track",		/* BA 00 */
+	"\302\200syscon rom error",				/* C2 80 */
+	"\302\201syscon ram error",				/* C2 81 */
+	"\302\220efm encoder error",				/* C2 90 */
+	"\302\221efm decoder error",				/* C2 91 */
+	"\302\222servo ic error",				/* C2 92 */
+	"\302\223motor controller error",			/* C2 93 */
+	"\302\224dac error",					/* C2 94 */
+	"\302\225syscon eeprom error",				/* C2 95 */
+	"\302\240block decoder communication error",		/* C2 A0 */
+	"\302\241block encoder communication error",		/* C2 A1 */
+	"\302\242block encoder/decoder path error",		/* C2 A2 */
+	"\303\000CD-R engine selftest error",			/* C3 xx */
+	"\304\000buffer parity error",				/* C4 00 */
+	"\305\000data transfer error",				/* C5 00 */
+	"\340\00012V failure",					/* E0 00 */
+	"\341\000undefined syscon error",			/* E1 00 */
+	"\341\001syscon communication error",			/* E1 01 */
+	"\341\002unknown syscon error",				/* E1 02 */
+	"\342\000syscon not ready",				/* E2 00 */
+	"\343\000command rejected",				/* E3 00 */
+	"\344\000command not accepted",				/* E4 00 */
+	"\345\000verify error at beginning of track",		/* E5 00 */
+	"\345\001verify error at ending of track",		/* E5 01 */
+	"\345\002verify error at beginning of lead-in",		/* E5 02 */
+	"\345\003verify error at ending of lead-in",		/* E5 03 */
+	"\345\004verify error at beginning of lead-out",	/* E5 04 */
+	"\345\005verify error at ending of lead-out",		/* E5 05 */
+	"\377\000command phase timeout error",			/* FF 00 */
+	"\377\001data in phase timeout error",			/* FF 01 */
+	"\377\002data out phase timeout error",			/* FF 02 */
+	"\377\003status phase timeout error",			/* FF 03 */
+	"\377\004message in phase timeout error",		/* FF 04 */
+	"\377\005message out phase timeout error",		/* FF 05 */
+	NULL
+};
+
+static int 
+philips_attach(SCSI *usalp, cdr_t *dp)
+{
+	usal_setnonstderrs(usalp, sd_cdd_521_error_str);
+	return (0);
+}
+
+static int 
+plasmon_attach(SCSI *usalp, cdr_t *dp)
+{
+	usalp->inq->data_format = 1;	/* Correct the ly */
+
+	usal_setnonstderrs(usalp, sd_cdd_521_error_str);
+	return (0);
+}
+
+static int 
+ricoh_attach(SCSI *usalp, cdr_t *dp)
+{
+	if (dp == &cdr_ricoh_ro1060) {
+		errmsgno(EX_BAD, "No support for Ricoh RO-1060C\n");
+		return (-1);
+	}
+	usal_setnonstderrs(usalp, sd_ro1420_error_str);
+	return (0);
+}
+
+static int 
+philips_getlilo(SCSI *usalp, long *lilenp, long *lolenp)
+{
+	char	buf[4];
+	long	li, lo;
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\0');
+	scmd->addr = buf;
+	scmd->size = sizeof (buf);
+	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 = 0xEE;	/* Read session info */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, sizeof (buf));
+
+	usalp->cmdname = "philips read session info";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	if (usalp->verbose)
+		usal_prbytes("Session info data: ", (Uchar *)buf, sizeof (buf) - usal_getresid(usalp));
+
+	li = a_to_u_2_byte(buf);
+	lo = a_to_u_2_byte(&buf[2]);
+
+	if (lilenp)
+		*lilenp = li;
+	if (lolenp)
+		*lolenp = lo;
+
+	return (0);
+}
diff --git a/wodim/drv_simul.c b/wodim/drv_simul.c
new file mode 100644
index 0000000..f7f7e06
--- /dev/null
+++ b/wodim/drv_simul.c
@@ -0,0 +1,393 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)drv_simul.c	1.48 05/05/16 Copyright 1998-2005 J. Schilling */
+/*
+ *	Simulation device driver
+ *
+ *	Copyright (c) 1998-2005 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.
+ */
+
+#ifndef	DEBUG
+#define	DEBUG
+#endif
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <standard.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <errno.h>
+#include <strdefs.h>
+#include <timedefs.h>
+#include <utypes.h>
+#include <btorder.h>
+#include <schily.h>
+
+/*#include <usalio.h>*/
+#include <usal/scsidefs.h>
+#include <usal/scsireg.h>
+#include <usal/scsitransp.h>
+
+#include <libport.h>
+
+#include "wodim.h"
+
+extern	int	silent;
+extern	int	verbose;
+extern	int	lverbose;
+
+static	int	simul_load(SCSI *usalp, cdr_t *);
+static	int	simul_unload(SCSI *usalp, cdr_t *);
+static	cdr_t	*identify_simul(SCSI *usalp, cdr_t *, struct scsi_inquiry *);
+static	int	init_simul(SCSI *usalp, cdr_t *dp);
+static	int	getdisktype_simul(SCSI *usalp, cdr_t *dp);
+static	int	speed_select_simul(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	next_wr_addr_simul(SCSI *usalp, track_t *trackp, long *ap);
+static	int	cdr_write_simul(SCSI *usalp, caddr_t bp, long sectaddr, long size, 
+										 int blocks, BOOL islast);
+static	int	open_track_simul(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	close_track_simul(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	open_session_simul(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	fixate_simul(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	void	tv_sub(struct timeval *tvp1, struct timeval *tvp2);
+
+static int simul_load(SCSI *usalp, cdr_t *dp)
+{
+	return (0);
+}
+
+static int simul_unload(SCSI *usalp, cdr_t *dp)
+{
+	return (0);
+}
+
+cdr_t	cdr_cdr_simul = {
+	0, 0,
+	CDR_TAO|CDR_SAO|CDR_PACKET|CDR_RAW|CDR_RAW16|CDR_RAW96P|CDR_RAW96R|CDR_SRAW96P|CDR_SRAW96R|CDR_TRAYLOAD|CDR_SIMUL,
+	CDR_CDRW_ALL,
+	40, 372,
+	"cdr_simul",
+	"simulation CD-R driver for timing/speed tests",
+	0,
+	(dstat_t *)0,
+	identify_simul,
+	drive_attach,
+	init_simul,
+	getdisktype_simul,
+	simul_load,
+	simul_unload,
+	buf_dummy,
+	cmd_dummy,					/* recovery_needed */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_simul,
+	select_secsize,
+	next_wr_addr_simul,
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	cdr_write_simul,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy, /* send_cue */
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_simul,
+	close_track_simul,
+	open_session_simul,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	fixate_simul,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+cdr_t	cdr_dvd_simul = {
+	0, 0,
+	CDR_TAO|CDR_SAO|CDR_PACKET|CDR_RAW|CDR_RAW16|CDR_RAW96P|CDR_RAW96R|CDR_SRAW96P|CDR_SRAW96R|CDR_DVD|CDR_TRAYLOAD|CDR_SIMUL,
+	CDR_CDRW_ALL,
+	2, 1000,
+	"dvd_simul",
+	"simulation DVD-R driver for timing/speed tests",
+	0,
+	(dstat_t *)0,
+	identify_simul,
+	drive_attach,
+	init_simul,
+	getdisktype_simul,
+	simul_load,
+	simul_unload,
+	buf_dummy,
+	cmd_dummy,					/* recovery_needed */
+	(int(*)(SCSI *, cdr_t *, int))cmd_dummy,	/* recover	*/
+	speed_select_simul,
+	select_secsize,
+	next_wr_addr_simul,
+	(int(*)(SCSI *, Ulong))cmd_ill,	/* reserve_track	*/
+	cdr_write_simul,
+	(int(*)(track_t *, void *, BOOL))cmd_dummy,	/* gen_cue */
+	(int(*)(SCSI *usalp, cdr_t *, track_t *))cmd_dummy, /* send_cue */
+	(int(*)(SCSI *, cdr_t *, track_t *))cmd_dummy, /* leadin */
+	open_track_simul,
+	close_track_simul,
+	open_session_simul,
+	cmd_dummy,
+	cmd_dummy,					/* abort	*/
+	read_session_offset,
+	fixate_simul,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+static cdr_t *
+identify_simul(SCSI *usalp, cdr_t *dp, struct scsi_inquiry *ip)
+{
+	return (dp);
+}
+
+static	long	simul_nwa;
+static	int	simul_speed = 1;
+static	int	simul_dummy;
+static	int	simul_isdvd;
+static	int	simul_bufsize = 1024;
+static	Uint	sleep_rest;
+static	Uint	sleep_max;
+static	Uint	sleep_min;
+
+static int
+init_simul(SCSI *usalp, cdr_t *dp)
+{
+	return (speed_select_simul(usalp, dp, NULL));
+}
+
+static int
+getdisktype_simul(SCSI *usalp, cdr_t *dp)
+{
+	dstat_t	*dsp = dp->cdr_dstat;
+
+	if (strcmp(dp->cdr_drname, cdr_cdr_simul.cdr_drname) == 0) {
+		dsp->ds_maxblocks = 333000;
+		simul_isdvd = FALSE;
+	} else {
+		dsp->ds_maxblocks = 2464153;	/* 4.7 GB  */
+/*		dsp->ds_maxblocks = 1927896;*/	/* 3.95 GB */
+		dsp->ds_flags |= DSF_DVD;
+		simul_isdvd = TRUE;
+	}
+	return (drive_getdisktype(usalp, dp));
+}
+
+
+static int
+speed_select_simul(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	long	val;
+	char	*p;
+	BOOL	dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp)
+		simul_speed = *speedp;
+	simul_dummy = dummy;
+
+	if ((p = getenv("CDR_SIMUL_BUFSIZE")) != NULL) {
+		if (getnum(p, &val) == 1)
+			simul_bufsize = val / 1024;
+	}
+
+	/*
+	 * sleep_max is the time to empty the drive's buffer in µs.
+	 * sector size is from 2048 bytes to 2352 bytes.
+	 * If sector size is 2048 bytes, 1k takes 6.666 ms.
+	 * If sector size is 2352 bytes, 1k takes 5.805 ms.
+	 * We take the 6 ms as an average between both values.
+	 * simul_bufsize is the number of kilobytes in drive buffer.
+	 */
+	sleep_max = 6 * 1000 * simul_bufsize / simul_speed;
+
+	/*
+	 * DVD single speed is 1385 * 1000 Bytes/s (676.27 sectors/s)
+	 */
+	if ((dp->cdr_flags & CDR_DVD) != 0)
+		sleep_max = 739 * simul_bufsize / simul_speed;
+
+	if (lverbose) {
+		printf("Simulation drive buffer size: %d KB\n", simul_bufsize);
+		printf("Maximum reserve time in drive buffer: %d.%3.3d ms for speed %dx\n",
+					sleep_max / 1000,
+					sleep_max % 1000,
+					simul_speed);
+	}
+	return (0);
+}
+
+static int
+next_wr_addr_simul(SCSI *usalp, track_t *trackp, long *ap)
+{
+	/*
+	 * This will most likely not 100% correct for TAO CDs
+	 * but it is better than returning 0 in all cases.
+	 */
+	if (ap)
+		*ap = simul_nwa;
+	return (0);
+}
+
+
+static int
+cdr_write_simul(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 */)
+{
+	Uint	sleep_time;
+	Uint	sleep_diff;
+
+	struct timeval	tv1;
+    static	struct timeval	tv2;
+
+	if (lverbose > 1 && islast)
+		printf("\nWriting last record for this track.\n");
+
+	simul_nwa += blocks;
+
+	gettimeofday(&tv1, (struct timezone *)0);
+	if (tv2.tv_sec != 0) {		/* Already did gettimeofday(&tv2) */
+		tv_sub(&tv1, &tv2);
+		if (sleep_rest != 0) {
+			sleep_diff = tv1.tv_sec * 1000000 + tv1.tv_usec;
+
+			if (sleep_min > (sleep_rest - sleep_diff))
+				sleep_min = (sleep_rest - sleep_diff);
+
+			if (sleep_diff > sleep_rest) {
+				printf("Buffer underrun: actual delay was %d.%3.3d ms, max delay was %d.%3.3d ms.\n",
+						sleep_diff / 1000,
+						sleep_diff % 1000,
+						sleep_rest / 1000,
+						sleep_rest % 1000);
+				if (!simul_dummy)
+					return (-1);
+			}
+			/*
+			 * If we spent time outside the write function
+			 * subtract this time.
+			 */
+			sleep_diff = tv1.tv_sec * 1000000 + tv1.tv_usec;
+			if (sleep_rest >= sleep_diff)
+				sleep_rest -= sleep_diff;
+			else
+				sleep_rest = 0;
+		}
+	}
+	/*
+	 * Speed 1 ist 150 Sektoren/s
+	 * Bei DVD 767.27 Sektoren/s
+	 */
+	sleep_time = 1000000 * blocks / 75 / simul_speed;
+	if (simul_isdvd)
+		sleep_time = 1000000 * blocks / 676 / simul_speed;
+
+	sleep_time += sleep_rest;
+
+	if (sleep_time > sleep_max) {
+		int	mod;
+		long	rsleep;
+
+		sleep_rest = sleep_max;
+		sleep_time -= sleep_rest;
+		mod = sleep_time % 20000;
+		sleep_rest += mod;
+		sleep_time -= mod;
+		if (sleep_time > 0) {
+			gettimeofday(&tv1, (struct timezone *)0);
+			usleep(sleep_time);
+			gettimeofday(&tv2, (struct timezone *)0);
+			tv2.tv_sec -= tv1.tv_sec;
+			tv2.tv_usec -= tv1.tv_usec;
+			rsleep = tv2.tv_sec * 1000000 + tv2.tv_usec;
+			sleep_rest -= rsleep - sleep_time;
+		}
+	} else {
+		sleep_rest = sleep_time;
+	}
+
+	gettimeofday(&tv2, (struct timezone *)0);
+	return (size);
+}
+
+static int
+open_track_simul(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	sleep_min = 999 * 1000000;
+	return (0);
+}
+
+static int
+close_track_simul(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (lverbose) {
+		printf("Remaining reserve time in drive buffer: %d.%3.3d ms\n",
+					sleep_rest / 1000,
+					sleep_rest % 1000);
+		printf("Minimum reserve time in drive buffer: %d.%3.3d ms\n",
+					sleep_min / 1000,
+					sleep_min % 1000);
+	}
+	usleep(sleep_rest);
+	sleep_rest = 0;
+	return (0);
+}
+
+static int
+open_session_simul(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	simul_nwa = 0L;
+	return (0);
+}
+
+static int
+fixate_simul(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	return (0);
+}
+
+static void
+tv_sub(struct timeval *tvp1, struct timeval *tvp2)
+{
+	tvp1->tv_sec -= tvp2->tv_sec;
+	tvp1->tv_usec -= tvp2->tv_usec;
+
+	while (tvp1->tv_usec < 0) {
+		tvp1->tv_usec += 1000000;
+		tvp1->tv_sec -= 1;
+	}
+}
diff --git a/wodim/drv_sony.c b/wodim/drv_sony.c
new file mode 100644
index 0000000..af8af68
--- /dev/null
+++ b/wodim/drv_sony.c
@@ -0,0 +1,1364 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)drv_sony.c	1.72 05/05/16 Copyright 1997-2005 J. Schilling */
+/*
+ *	CDR device implementation for
+ *	Sony
+ *
+ *	Copyright (c) 1997-2005 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.
+ */
+
+/*#define	SONY_DEBUG*/
+
+#include <mconfig.h>
+
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>	/* Include sys/types.h to make off_t available */
+#include <standard.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 "wodim.h"
+
+#ifdef	SONY_DEBUG
+#	define		inc_verbose()	usalp->verbose++
+#	define		dec_verbose()	usalp->verbose--
+#else
+#	define		inc_verbose()
+#	define		dec_verbose()
+#endif
+
+extern	int	debug;
+extern	int	lverbose;
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+
+struct sony_924_mode_page_20 {	/* mastering information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x06 = 6 Bytes */
+	Uchar	subcode_header_off;
+	Ucbit	res3_0		: 1;
+	Ucbit	speudo		: 1;
+	Ucbit	res3_2		: 1;
+	Ucbit	c2po		: 1;
+	Ucbit	subcode_ecc	: 1;
+	Ucbit	res3_567	: 3;
+	Uchar	res_4;
+	Uchar	cue_sheet_opt;
+	Uchar	res[2];
+};
+
+#else				/* Motorola byteorder */
+
+struct sony_924_mode_page_20 {	/* mastering information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x06 = 6 Bytes */
+	Uchar	subcode_header_off;
+	Ucbit	res3_567	: 3;
+	Ucbit	subcode_ecc	: 1;
+	Ucbit	c2po		: 1;
+	Ucbit	res3_2		: 1;
+	Ucbit	speudo		: 1;
+	Ucbit	res3_0		: 1;
+	Uchar	res_4;
+	Uchar	cue_sheet_opt;
+	Uchar	res[2];
+};
+#endif
+
+struct sony_924_mode_page_22 {	/* disk information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x1E = 30 Bytes */
+	Uchar	disk_style;
+	Uchar	disk_type;
+	Uchar	first_track;
+	Uchar	last_track;
+	Uchar	numsess;
+	Uchar	res_7;
+	Uchar	disk_appl_code[4];
+	Uchar	last_start_time[4];
+	Uchar	disk_status;
+	Uchar	num_valid_nra;
+	Uchar	track_info_track;
+	Uchar	post_gap;
+	Uchar	disk_id_code[4];
+	Uchar	lead_in_start[4];
+	Uchar	res[4];
+};
+
+struct sony_924_mode_page_23 {	/* track information */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x22 = 34 Bytes */
+	Uchar	res_2;
+	Uchar	track_num;
+	Uchar	data_form;
+	Uchar	write_method;
+	Uchar	session;
+	Uchar	track_status;
+	Uchar	start_lba[4];
+	Uchar	next_recordable_addr[4];
+	Uchar	blank_area_cap[4];
+	Uchar	fixed_packet_size[4];
+	Uchar	res_24;
+	Uchar	starting_msf[3];
+	Uchar	res_28;
+	Uchar	ending_msf[3];
+	Uchar	res_32;
+	Uchar	next_rec_time[3];
+};
+
+struct sony_924_mode_page_31 {	/* drive speed */
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0x02 = 2 Bytes */
+	Uchar	speed;
+	Uchar	res;
+};
+
+struct cdd_52x_mode_data {
+	struct scsi_mode_header	header;
+	union cdd_pagex	{
+		struct sony_924_mode_page_20	page_s20;
+		struct sony_924_mode_page_22	page_s22;
+		struct sony_924_mode_page_23	page_s23;
+		struct sony_924_mode_page_31	page_s31;
+	} pagex;
+};
+
+struct sony_write_parameter {
+	Uchar	res0;			/* Reserved (must be zero)	*/
+	Uchar	len;			/* Parameter length 0x32 == 52	*/
+	Uchar	res2;			/* Reserved (must be zero)	*/
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+	Ucbit	res3_05		: 6;	/* Reserved			*/
+	Ucbit	ms		: 2;	/* Multi session mode		*/
+#else				/* Motorola byteorder */
+	Ucbit	ms		: 2;	/* Multi session mode		*/
+	Ucbit	res3_05		: 6;	/* Reserved			*/
+#endif
+	Uchar	resx[12];
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+	Ucbit	res16_06	: 7;	/* Reserved			*/
+	Ucbit	mcval		: 1;	/* MCN valid			*/
+#else				/* Motorola byteorder */
+	Ucbit	mcval		: 1;	/* MCN valid			*/
+	Ucbit	res16_06	: 7;	/* Reserved			*/
+#endif
+	Uchar	mcn[15];
+#if defined(_BIT_FIELDS_LTOH)	/* Intel byteorder */
+	Ucbit	res32_06	: 7;	/* Reserved			*/
+	Ucbit	icval		: 1;	/* ISRC valid			*/
+#else				/* Motorola byteorder */
+	Ucbit	icval		: 1;	/* ISRC valid			*/
+	Ucbit	res32_06	: 7;	/* Reserved			*/
+#endif
+	Uchar	isrc[15];
+	Uchar	subheader[4];
+};
+
+struct sony_cue {
+	Uchar	cs_ctladr;		/* CTL/ADR for this track	*/
+	Uchar	cs_tno;			/* This track number		*/
+	Uchar	cs_index;		/* Index within this track	*/
+	Uchar	cs_dataform;		/* Data form 			*/
+					/* Bit 0..5 Main channel Format	*/
+					/* Bit 6..7 SubChannel format	*/
+	Uchar	cs_zero;		/* Reserved or MCN/ISRC		*/
+	Uchar	cs_min;			/* Absolute time minutes	*/
+	Uchar	cs_sec;			/* Absolute time seconds	*/
+	Uchar	cs_frame;		/* Absolute time frames		*/
+};
+
+
+#define	strbeg(s1, s2)	(strstr((s2), (s1)) == (s2))
+
+static	int	write_start_sony(SCSI *usalp, caddr_t bp, int size);
+static	int	write_continue_sony(SCSI *usalp, caddr_t bp, long sectaddr, 
+											  long size, int blocks, BOOL islast);
+static	int	discontinue_sony(SCSI *usalp);
+static	int	write_track_sony(SCSI *usalp, long track, int sectype);
+static	int	close_track_sony(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	flush_sony(SCSI *usalp, int track);
+static	int	finalize_sony(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	recover_sony(SCSI *usalp, cdr_t *dp, int track);
+static	int	set_wr_parameter_sony(SCSI *usalp, caddr_t bp, int size);
+static	int	next_wr_addr_sony(SCSI *usalp, track_t *trackp, long *ap);
+static	int	reserve_track_sony(SCSI *usalp, unsigned long len);
+static	int	init_sony(SCSI *usalp, cdr_t *dp);
+static	int	getdisktype_sony(SCSI *usalp, cdr_t *dp);
+static	void	di_to_dstat_sony(struct sony_924_mode_page_22 *dip, 
+										  dstat_t *dsp);
+static	int	speed_select_sony(SCSI *usalp, cdr_t *dp, int *speedp);
+static	int	next_writable_address_sony(SCSI *usalp, long *ap, int track, 
+														int sectype, int tracktype);
+static	int	new_track_sony(SCSI *usalp, int track, int sectype, 
+										int tracktype);
+static	int	open_track_sony(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	open_session_sony(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	abort_session_sony(SCSI *usalp, cdr_t *dp);
+static	int	get_page22_sony(SCSI *usalp, char *mode);
+static	int	gen_cue_sony(track_t *trackp, void *vcuep, BOOL needgap);
+static	void	fillcue(struct sony_cue *cp, int ca, int tno, int idx, int dataform, int scms, msf_t *mp);
+static	int	send_cue_sony(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	write_leadin_sony(SCSI *usalp, cdr_t *dp, track_t *trackp);
+static	int	sony_attach(SCSI *usalp, cdr_t *dp);
+#ifdef	SONY_DEBUG
+static	void	print_sony_mp22(struct sony_924_mode_page_22 *xp, int len);
+static	void	print_sony_mp23(struct sony_924_mode_page_23 *xp, int len);
+#endif
+static	int	buf_cap_sony(SCSI *usalp, long *, long *);
+
+cdr_t	cdr_sony_cdu924 = {
+	0, 0,
+	CDR_TAO|CDR_SAO|CDR_CADDYLOAD|CDR_SWABAUDIO,
+	CDR_CDRW_NONE,
+	2, 4,
+	"sony_cdu924",
+	"driver for Sony CDU-924 / CDU-948",
+	0,
+	(dstat_t *)0,
+	drive_identify,
+	sony_attach,
+	init_sony,
+	getdisktype_sony,
+	scsi_load,
+	scsi_unload,
+	buf_cap_sony,
+	cmd_dummy,					/* recovery_needed */
+	recover_sony,
+	speed_select_sony,
+	select_secsize,
+	next_wr_addr_sony,
+	reserve_track_sony,
+	write_continue_sony,
+	gen_cue_sony,
+	send_cue_sony,
+	write_leadin_sony,
+	open_track_sony,
+	close_track_sony,
+	open_session_sony,
+	cmd_dummy,
+	abort_session_sony,
+	read_session_offset_philips,
+	finalize_sony,
+	cmd_dummy,					/* stats	*/
+	blank_dummy,
+	format_dummy,
+	(int(*)(SCSI *, caddr_t, int, int))NULL,	/* no OPC	*/
+	cmd_dummy,					/* opt1		*/
+	cmd_dummy,					/* opt2		*/
+};
+
+static int
+write_start_sony(SCSI *usalp, caddr_t bp, int 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|SCG_CMD_RETRY;
+	scmd->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->sense_len = 26;
+	scmd->cdb.g1_cdb.cmd = 0xE0;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g0_cdbaddr(&scmd->cdb.g0_cdb, size); /* Hack, but Sony is silly */
+
+	usalp->cmdname = "write_start";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+write_continue_sony(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 */)
+{
+	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->cdb_len = SC_G1_CDBLEN;
+	scmd->sense_len = CCS_SENSE_LEN;
+	scmd->cdb.g1_cdb.cmd = 0xE1;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g0_cdbaddr(&scmd->cdb.g0_cdb, size); /* Hack, but Sony is silly */
+
+	usalp->cmdname = "write_continue";
+
+	if (usal_cmd(usalp) < 0) {
+		/*
+		 * XXX This seems to happen only sometimes.
+		 */
+		if (usal_sense_code(usalp) != 0x80)
+			return (-1);
+	}
+	return (size - usal_getresid(usalp));
+}
+
+static int
+discontinue_sony(SCSI *usalp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\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 = 0xE2;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "discontinue";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+write_track_sony(SCSI *usalp, 
+                 long track     /* track number 0 == new track */, 
+                 int sectype    /* no sectype for Sony write track */)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+
+	fillbytes((caddr_t)scmd, sizeof (*scmd), '\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 = 0xF5;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, track);
+
+	usalp->cmdname = "write_track";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+/* XXX NOCH NICHT FERTIG */
+static int
+close_track_sony(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	int	track = 0;
+
+	if (!is_tao(trackp) && !is_packet(trackp))
+		return (0);
+
+	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 = 0xF0;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdbaddr(&scmd->cdb.g1_cdb, track);
+/* XXX Padding ??? (bit 0 in addr[0] / CDB[2]) */
+
+	usalp->cmdname = "close_track";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	/*
+	 * Clear the silly "error situation" from Sony´ dummy write end
+	 * but notify if real errors occurred.
+	 */
+	usalp->silent++;
+	if (test_unit_ready(usalp) < 0 && usal_sense_code(usalp) != 0xD4) {
+		usalp->cmdname = "close_track/test_unit_ready";
+		usal_printerr(usalp);
+	}
+	usalp->silent--;
+
+	return (0);
+}
+
+static int
+finalize_sony(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	register struct	usal_cmd	*scmd = usalp->scmd;
+	int	dummy = track_base(trackp)->tracktype & TOCF_DUMMY;
+
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		wait_unit_ready(usalp, 240);
+		return (0);
+	}
+	if (dummy) {
+		printf("Fixating is not possible in dummy write mode.\n");
+		return (0);
+	}
+	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 = 0xF1;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.count[1] = ((track_base(trackp)->tracktype & TOCF_MULTI) ? 1 : 0);
+/* XXX Padding ??? (bit 0 in addr[0] / CDB[2]) */
+
+	usalp->cmdname = "finalize";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+flush_sony(SCSI *usalp, int track)
+{
+	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 = 0xF2;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.cmd_cdb[5] = track;
+/* XXX POE ???	   (bit 1 in addr[0] / CDB[2]) */
+/* XXX Padding ??? (bit 0 in addr[0] / CDB[2]) */
+/* XXX Partial flush ??? (CDB[3]) */
+
+	usalp->cmdname = "flush";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+recover_sony(SCSI *usalp, cdr_t *dp, int track)
+{
+	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 = 0xF6;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	scmd->cdb.g1_cdb.addr[3] = track;
+
+	usalp->cmdname = "recover";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+set_wr_parameter_sony(SCSI *usalp, caddr_t bp, int 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 = 0xF8;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	g1_cdblen(&scmd->cdb.g1_cdb, size);
+
+	usalp->cmdname = "set_write_parameter";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+next_wr_addr_sony(SCSI *usalp, track_t *trackp, long *ap)
+{
+	if (next_writable_address_sony(usalp, ap, 0, 0, 0) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+reserve_track_sony(SCSI *usalp, unsigned long len)
+{
+	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 = 0xF3;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	i_to_4_byte(&scmd->cdb.g1_cdb.addr[3], len);
+
+	usalp->cmdname = "reserve_track";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+	return (0);
+}
+
+static int
+init_sony(SCSI *usalp, cdr_t *dp)
+{
+	return (speed_select_sony(usalp, dp, NULL));
+}
+
+
+#define	IS(what, flag)	printf("  Is %s%s\n", flag?"":"not ", what);
+
+static int
+getdisktype_sony(SCSI *usalp, cdr_t *dp)
+{
+	dstat_t	*dsp = dp->cdr_dstat;
+	long	dummy;
+	long	lst;
+	msf_t	msf;
+
+	char			mode[256];
+	struct scsi_mode_page_header	*mp;
+	struct sony_924_mode_page_22	*xp;
+
+	dummy = get_page22_sony(usalp, mode);
+	if (dummy >= 0) {
+		mp = (struct scsi_mode_page_header *)
+			(mode + sizeof (struct scsi_mode_header) +
+			((struct scsi_mode_header *)mode)->blockdesc_len);
+
+		xp = (struct sony_924_mode_page_22 *)mp;
+
+		if (xp->disk_appl_code[0] == 0xFF)
+			dummy = -1;
+	} else {
+		return (drive_getdisktype(usalp, dp));
+	}
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_PRATIP) != 0 && dummy >= 0) {
+
+		printf("ATIP info from disk:\n");
+		printf("  Indicated writing power: %d\n",
+				(unsigned)(xp->disk_appl_code[1] & 0x70) >> 4);
+		IS("unrestricted", xp->disk_appl_code[2] & 0x40);
+		printf("  Disk application code: %d\n", xp->disk_appl_code[2] & 0x3F);
+		msf.msf_min = xp->lead_in_start[1];
+		msf.msf_sec = xp->lead_in_start[2];
+		msf.msf_frame = xp->lead_in_start[3];
+		lst = msf_to_lba(msf.msf_min, msf.msf_sec, msf.msf_frame, FALSE);
+		if (lst  < -150) {
+			/*
+			 * The Sony CDU 920 seems to deliver 00:00/00 for
+			 * lead-in start time, dont use it.
+			 */
+			printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)\n",
+				msf_to_lba(msf.msf_min, msf.msf_sec, msf.msf_frame, FALSE),
+				msf.msf_min, msf.msf_sec, msf.msf_frame);
+		}
+		msf.msf_min = xp->last_start_time[1];
+		msf.msf_sec = xp->last_start_time[2];
+		msf.msf_frame = xp->last_start_time[3];
+		printf("  ATIP start of lead out: %ld (%02d:%02d/%02d)\n",
+			msf_to_lba(msf.msf_min, msf.msf_sec, msf.msf_frame, TRUE),
+			msf.msf_min, msf.msf_sec, msf.msf_frame);
+		if (lst  < -150) {
+			/*
+			 * The Sony CDU 920 seems to deliver 00:00/00 for
+			 * lead-in start time, dont use it.
+			 */
+			msf.msf_min = xp->lead_in_start[1];
+			msf.msf_sec = xp->lead_in_start[2];
+			msf.msf_frame = xp->lead_in_start[3];
+			pr_manufacturer(&msf,
+					FALSE,	/* Always not erasable */
+					(xp->disk_appl_code[2] & 0x40) != 0);
+		}
+	}
+	if (dummy >= 0)
+		di_to_dstat_sony(xp, dsp);
+	return (drive_getdisktype(usalp, dp));
+}
+
+static void
+di_to_dstat_sony(struct sony_924_mode_page_22 *dip, dstat_t *dsp)
+{
+	msf_t	msf;
+
+	dsp->ds_diskid = a_to_u_4_byte(dip->disk_id_code);
+#ifdef	PROTOTYPES
+	if (dsp->ds_diskid != 0xFFFFFFFFUL)
+#else
+	if (dsp->ds_diskid != (Ulong)0xFFFFFFFF)
+#endif
+		dsp->ds_flags |= DSF_DID_V;
+	dsp->ds_diskstat = (dip->disk_status >> 6) & 0x03;
+#ifdef	XXX
+	/*
+	 * There seems to be no MMC equivalent...
+	 */
+	dsp->ds_sessstat = dip->sess_status;
+#endif
+
+	dsp->ds_maxblocks = msf_to_lba(dip->last_start_time[1],
+					dip->last_start_time[2],
+					dip->last_start_time[3], TRUE);
+	/*
+	 * Check for 0xFF:0xFF/0xFF which is an indicator for a complete disk
+	 */
+	if (dsp->ds_maxblocks == 716730)
+		dsp->ds_maxblocks = -1L;
+
+	if (dsp->ds_first_leadin == 0) {
+		dsp->ds_first_leadin = msf_to_lba(dip->lead_in_start[1],
+						dip->lead_in_start[2],
+						dip->lead_in_start[3], FALSE);
+		/*
+		 * Check for illegal values (> 0)
+		 * or for empty field (-150) with CDU-920.
+		 */
+		if (dsp->ds_first_leadin > 0 || dsp->ds_first_leadin == -150)
+			dsp->ds_first_leadin = 0;
+	}
+
+	if (dsp->ds_last_leadout == 0 && dsp->ds_maxblocks >= 0)
+		dsp->ds_last_leadout = dsp->ds_maxblocks;
+
+	msf.msf_min = dip->lead_in_start[1];
+	msf.msf_sec = dip->lead_in_start[2];
+	msf.msf_frame = dip->lead_in_start[3];
+	dsp->ds_maxrblocks = disk_rcap(&msf, dsp->ds_maxblocks,
+					FALSE,	/* Always not erasable */
+					(dip->disk_appl_code[2] & 0x40) != 0);
+}
+
+
+int	sony_speeds[] = {
+		-1,		/* Speed null is not allowed */
+		0,		/* Single speed */
+		1,		/* Double speed */
+		-1,		/* Three times */
+		3,		/* Quad speed */
+};
+
+static int
+speed_select_sony(SCSI *usalp, cdr_t *dp, int *speedp)
+{
+	struct cdd_52x_mode_data md;
+	int	count;
+	int	err;
+	int	speed = 1;
+	BOOL	dummy = (dp->cdr_cmdflags & F_DUMMY) != 0;
+
+	if (speedp) {
+		speed = *speedp;
+		if (speed < 1 || speed > 4 || sony_speeds[speed] < 0)
+			return (-1);
+	}
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct sony_924_mode_page_20);
+
+	md.pagex.page_s20.p_code = 0x20;
+	md.pagex.page_s20.p_len =  0x06;
+	md.pagex.page_s20.speudo = dummy?1:0;
+
+	/*
+	 * Set Cue sheet option. This is documented for the 924 and
+	 * seems to be supported for the 948 too.
+	 */
+	md.pagex.page_s20.cue_sheet_opt = 0x03;
+
+	err = mode_select(usalp, (Uchar *)&md, count, 0, 1);
+	if (err < 0)
+		return (err);
+
+	if (speedp == 0)
+		return (0);
+
+	fillbytes((caddr_t)&md, sizeof (md), '\0');
+
+	count  = sizeof (struct scsi_mode_header) +
+		sizeof (struct sony_924_mode_page_31);
+
+	md.pagex.page_s31.p_code = 0x31;
+	md.pagex.page_s31.p_len =  0x02;
+	md.pagex.page_s31.speed = sony_speeds[speed];
+
+	return (mode_select(usalp, (Uchar *)&md, count, 0, 1));
+}
+
+static int
+next_writable_address_sony(SCSI *usalp, long *ap, int track, int sectype, 
+                           int tracktype)
+{
+	struct	scsi_mode_page_header *mp;
+	char			mode[256];
+	int			len = 0x30;
+	int			page = 0x23;
+	struct sony_924_mode_page_23	*xp;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	inc_verbose();
+	if (!get_mode_params(usalp, page, "CD track information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		dec_verbose();
+		return (-1);
+	}
+	dec_verbose();
+	if (len == 0)
+		return (-1);
+
+	mp = (struct scsi_mode_page_header *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+
+	xp = (struct sony_924_mode_page_23 *)mp;
+
+#ifdef	SONY_DEBUG
+	print_sony_mp23(xp, len);
+#endif
+	if (ap)
+		*ap = a_to_4_byte(xp->next_recordable_addr);
+	return (0);
+}
+
+
+static int
+new_track_sony(SCSI *usalp, int track, int sectype, int tracktype)
+{
+	struct	scsi_mode_page_header *mp;
+	char			mode[256];
+	int			len = 0x30;
+	int			page = 0x23;
+	struct sony_924_mode_page_23	*xp;
+	int	i;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+	get_page22_sony(usalp, mode);
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	inc_verbose();
+	if (!get_mode_params(usalp, page, "CD track information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		dec_verbose();
+		return (-1);
+	}
+	dec_verbose();
+	if (len == 0)
+		return (-1);
+
+	mp = (struct scsi_mode_page_header *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+
+	xp = (struct sony_924_mode_page_23 *)mp;
+
+#ifdef	SONY_DEBUG
+	print_sony_mp23(xp, len);
+#endif
+
+	xp->write_method = 0;	/* Track at one recording */
+
+	if (sectype & ST_AUDIOMASK) {
+		xp->data_form = (sectype & ST_MASK) == ST_AUDIO_PRE ? 0x02 : 0x00;
+	} else {
+		if (tracktype == TOC_ROM) {
+			xp->data_form = (sectype & ST_MASK) == ST_ROM_MODE1 ? 0x10 : 0x11;
+		} else if (tracktype == TOC_XA1) {
+			xp->data_form = 0x12;
+		} else if (tracktype == TOC_XA2) {
+			xp->data_form = 0x12;
+		} else if (tracktype == TOC_CDI) {
+			xp->data_form = 0x12;
+		}
+	}
+
+	((struct scsi_modesel_header *)mode)->sense_data_len	= 0;
+	((struct scsi_modesel_header *)mode)->res2		= 0;
+
+	i = ((struct scsi_mode_header *)mode)->blockdesc_len;
+	if (i > 0) {
+		i_to_3_byte(
+			((struct scsi_mode_data *)mode)->blockdesc.nlblock,
+								0);
+	}
+
+	if (mode_select(usalp, (Uchar *)mode, len, 0, usalp->inq->data_format >= 2) < 0) {
+		return (-1);
+	}
+
+	return (0);
+}
+
+static int
+open_track_sony(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	if (!is_tao(trackp) && !is_packet(trackp)) {
+		if (trackp->pregapsize > 0 && (trackp->flags & TI_PREGAP) == 0) {
+			if (lverbose) {
+				printf("Writing pregap for track %d at %ld\n",
+					(int)trackp->trackno,
+					trackp->trackstart-trackp->pregapsize);
+			}
+			/*
+			 * XXX Do we need to check isecsize too?
+			 */
+			pad_track(usalp, dp, trackp,
+				trackp->trackstart-trackp->pregapsize,
+				(Llong)trackp->pregapsize*trackp->secsize,
+					FALSE, 0);
+		}
+		return (0);
+	}
+
+	if (select_secsize(usalp, trackp->secsize) < 0)
+		return (-1);
+
+	if (new_track_sony(usalp, trackp->trackno, trackp->sectype, trackp->tracktype & TOC_MASK) < 0)
+		return (-1);
+
+	if (write_track_sony(usalp, 0L, trackp->sectype) < 0)
+		return (-1);
+
+	return (0);
+}
+
+static int
+open_session_sony(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	struct	scsi_mode_page_header *mp;
+	char			mode[256];
+	int	i;
+	int	len = 0x30;
+	struct sony_924_mode_page_22	*xp;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	if ((len = get_page22_sony(usalp, mode)) < 0)
+		return (-1);
+
+	mp = (struct scsi_mode_page_header *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	xp = (struct sony_924_mode_page_22 *)mp;
+
+	xp->disk_type = toc2sess[track_base(trackp)->tracktype & TOC_MASK];
+
+	if (is_tao(track_base(trackp))) {
+#ifdef	__needed__
+		if ((track_base(trackp)->tracktype & TOC_MASK) == TOC_DA)
+			xp->disk_style = 0x80;
+		else
+			xp->disk_style = 0xC0;
+#endif
+	} else if (is_sao(track_base(trackp))) {
+		/*
+		 * We may only change this value if the disk is empty.
+		 * i.e. when disk_status & 0xC0 == 0x00
+		 */
+		if ((xp->disk_status & 0xC0) != 0) {
+			if (xp->disk_style != 0x00)
+				errmsgno(EX_BAD, "Cannot change disk stile for recorded disk.\n");
+		}
+		xp->disk_style = 0x00;
+	}
+
+	((struct scsi_modesel_header *)mode)->sense_data_len	= 0;
+	((struct scsi_modesel_header *)mode)->res2		= 0;
+
+	i = ((struct scsi_mode_header *)mode)->blockdesc_len;
+	if (i > 0) {
+		i_to_3_byte(
+			((struct scsi_mode_data *)mode)->blockdesc.nlblock,
+								0);
+	}
+
+	if (mode_select(usalp, (Uchar *)mode, len, 0, usalp->inq->data_format >= 2) < 0) {
+		return (-1);
+	}
+/*
+ * XXX set write parameter für SAO mit Multi Session (948 only?)
+ * XXX set_wr_parameter_sony(usalp, bp, size);
+ */
+	return (0);
+}
+
+static int
+abort_session_sony(SCSI *usalp, cdr_t *dp)
+{
+	return (discontinue_sony(usalp));
+}
+
+static int
+get_page22_sony(SCSI *usalp, char *mode)
+{
+	struct	scsi_mode_page_header *mp;
+	int	len = 0x30;
+	int	page = 0x22;
+	struct sony_924_mode_page_22	*xp;
+
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+
+	inc_verbose();
+	if (!get_mode_params(usalp, page, "CD disk information",
+			(Uchar *)mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
+		dec_verbose();
+		return (-1);
+	}
+	dec_verbose();
+	if (len == 0)
+		return (-1);
+
+	mp = (struct scsi_mode_page_header *)
+		(mode + sizeof (struct scsi_mode_header) +
+		((struct scsi_mode_header *)mode)->blockdesc_len);
+
+	xp = (struct sony_924_mode_page_22 *)mp;
+
+#ifdef	SONY_DEBUG
+	print_sony_mp22(xp, len);
+#endif
+	return (len);
+}
+
+/*--------------------------------------------------------------------------*/
+
+static Uchar	db2df[] = {
+	0x01,			/*  0 2352 bytes of raw data			*/
+	0xFF,			/*  1 2368 bytes (raw data + P/Q Subchannel)	*/
+	0xFF,			/*  2 2448 bytes (raw data + P-W Subchannel)	*/
+	0xFF,			/*  3 2448 bytes (raw data + P-W raw Subchannel)*/
+	0xFF,			/*  4 -    Reserved				*/
+	0xFF,			/*  5 -    Reserved				*/
+	0xFF,			/*  6 -    Reserved				*/
+	0xFF,			/*  7 -    Vendor specific			*/
+	0x11,			/*  8 2048 bytes Mode 1 (ISO/IEC 10149)		*/
+	0xFF,			/*  9 2336 bytes Mode 2 (ISO/IEC 10149)		*/
+	0xFF,			/* 10 2048 bytes Mode 2! (CD-ROM XA form 1)	*/
+	0xFF,			/* 11 2056 bytes Mode 2 (CD-ROM XA form 1)	*/
+	0xFF,			/* 12 2324 bytes Mode 2 (CD-ROM XA form 2)	*/
+	0xFF,			/* 13 2332 bytes Mode 2 (CD-ROM XA 1/2+subhdr)	*/
+	0xFF,			/* 14 -    Reserved				*/
+	0xFF,			/* 15 -    Vendor specific			*/
+};
+
+static int
+gen_cue_sony(track_t *trackp, void *vcuep, BOOL needgap)
+{
+	int	tracks = trackp->tracks;
+	int	i;
+	struct sony_cue	**cuep = vcuep;
+	struct sony_cue	*cue;
+	struct sony_cue	*cp;
+	int	ncue = 0;
+	int	icue = 0;
+	int	pgsize;
+	msf_t	m;
+	int	ctl;
+	int	df;
+	int	scms;
+
+	cue = malloc(1);
+
+	for (i = 0; i <= tracks; i++) {
+		ctl = (st2mode[trackp[i].sectype & ST_MASK]) << 4;
+		if (is_copy(&trackp[i]))
+			ctl |= TM_ALLOW_COPY << 4;
+		df = db2df[trackp[i].dbtype & 0x0F];
+
+#ifdef	__supported__
+		if (trackp[i].isrc) {	/* MCN or ISRC */
+			ncue += 2;
+			cue = realloc(cue, ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			if (i == 0) {
+				cp->cs_ctladr = 0x02;
+				movebytes(&trackp[i].isrc[0], &cp->cs_tno, 7);
+				cp = &cue[icue++];
+				cp->cs_ctladr = 0x02;
+				movebytes(&trackp[i].isrc[7], &cp->cs_tno, 7);
+			} else {
+				cp->cs_ctladr = 0x03;
+				cp->cs_tno = i;
+				movebytes(&trackp[i].isrc[0], &cp->cs_index, 6);
+				cp = &cue[icue++];
+				cp->cs_ctladr = 0x03;
+				cp->cs_tno = i;
+				movebytes(&trackp[i].isrc[6], &cp->cs_index, 6);
+			}
+		}
+#endif
+		if (i == 0) {	/* Lead in */
+			df &= ~7;
+			if (trackp[0].flags & TI_TEXT)	/* CD-Text in Lead-in*/
+				df |= 0xC0;
+			lba_to_msf(-150, &m);
+			cue = realloc(cue, ++ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			fillcue(cp, ctl|0x01, i, 0, df, 0, &m);
+		} else {
+			scms = 0;
+
+			if (is_scms(&trackp[i]))
+				scms = 0x80;
+			pgsize = trackp[i].pregapsize;
+			if (pgsize == 0 && needgap)
+				pgsize++;
+			lba_to_msf(trackp[i].trackstart-pgsize, &m);
+			cue = realloc(cue, ++ncue * sizeof (*cue));
+			cp = &cue[icue++];
+			fillcue(cp, ctl|0x01, i, 0, df, scms, &m);
+
+			if (trackp[i].nindex == 1) {
+				lba_to_msf(trackp[i].trackstart, &m);
+				cue = realloc(cue, ++ncue * sizeof (*cue));
+				cp = &cue[icue++];
+				fillcue(cp, ctl|0x01, i, 1, df, scms, &m);
+			} else {
+				int	idx;
+				long	*idxlist;
+
+				ncue += trackp[i].nindex;
+				idxlist = trackp[i].tindex;
+				cue = realloc(cue, ncue * sizeof (*cue));
+
+				for (idx = 1; idx <= trackp[i].nindex; idx++) {
+					lba_to_msf(trackp[i].trackstart + idxlist[idx], &m);
+					cp = &cue[icue++];
+					fillcue(cp, ctl|0x01, i, idx, df, scms, &m);
+				}
+			}
+		}
+	}
+	/* Lead out */
+	ctl = (st2mode[trackp[tracks+1].sectype & ST_MASK]) << 4;
+	df = db2df[trackp[tracks+1].dbtype & 0x0F];
+	df &= ~7;
+	lba_to_msf(trackp[tracks+1].trackstart, &m);
+	cue = realloc(cue, ++ncue * sizeof (*cue));
+	cp = &cue[icue++];
+	fillcue(cp, ctl|0x01, 0xAA, 1, df, 0, &m);
+
+	if (lverbose > 1) {
+		for (i = 0; i < ncue; i++) {
+			usal_prbytes("", (Uchar *)&cue[i], 8);
+		}
+	}
+	if (cuep)
+		*cuep = cue;
+	else
+		free(cue);
+	return (ncue);
+}
+
+
+static void
+fillcue(struct sony_cue *cp     /* The target cue entry */, 
+        int ca                  /* Control/adr for this entry */, 
+        int tno                 /* Track number for this entry */, 
+        int idx                 /* Index for this entry */, 
+        int dataform            /* Data format for this entry */, 
+        int scms                /* Serial copy management */, 
+        msf_t *mp               /* MSF value for this entry */)
+{
+	cp->cs_ctladr = ca;
+	if (tno <= 99)
+		cp->cs_tno = to_bcd(tno);
+	else
+		cp->cs_tno = tno;
+	cp->cs_index = to_bcd(idx);
+	cp->cs_dataform = dataform;
+	cp->cs_zero = scms;
+	cp->cs_min = to_bcd(mp->msf_min);
+	cp->cs_sec = to_bcd(mp->msf_sec);
+	cp->cs_frame = to_bcd(mp->msf_frame);
+}
+
+static int
+send_cue_sony(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	struct sony_cue *cp;
+	int		ncue;
+	int		ret;
+	Uint		i;
+	struct timeval starttime;
+	struct timeval stoptime;
+	int		disktype;
+
+	disktype = toc2sess[track_base(trackp)->tracktype & TOC_MASK];
+
+	for (i = 1; i <= trackp->tracks; i++) {
+		if (trackp[i].tracksize < (tsize_t)0) {
+			errmsgno(EX_BAD, "Track %d has unknown length.\n", i);
+			return (-1);
+		}
+	}
+	ncue = (*dp->cdr_gen_cue)(trackp, &cp, FALSE);
+
+	starttime.tv_sec = 0;
+	starttime.tv_usec = 0;
+	stoptime = starttime;
+	gettimeofday(&starttime, (struct timezone *)0);
+
+	usalp->silent++;
+	ret  = write_start_sony(usalp, (caddr_t)cp, ncue*8);
+	usalp->silent--;
+	free(cp);
+	if (ret < 0) {
+		errmsgno(EX_BAD, "CUE sheet not accepted. Retrying with minimum pregapsize = 1.\n");
+		ncue = (*dp->cdr_gen_cue)(trackp, &cp, TRUE);
+		ret  = write_start_sony(usalp, (caddr_t)cp, ncue*8);
+		free(cp);
+	}
+	if (ret >= 0 && lverbose) {
+		gettimeofday(&stoptime, (struct timezone *)0);
+		prtimediff("Write Lead-in time: ", &starttime, &stoptime);
+	}
+	return (ret);
+}
+
+static int
+write_leadin_sony(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	Uint	i;
+	long	startsec = 0L;
+
+/*	if (flags & F_SAO) {*/
+	if (wm_base(dp->cdr_dstat->ds_wrmode) == WM_SAO) {
+		if (debug || lverbose) {
+			printf("Sending CUE sheet...\n");
+			flush();
+		}
+		if (trackp[0].flags & TI_TEXT) {
+			if (dp->cdr_speeddef != 4) {
+				errmsgno(EX_BAD,
+				"The CDU-924 does not support CD-Text, disabling.\n");
+
+				trackp[0].flags &= ~TI_TEXT;
+			}
+		}
+		if ((*dp->cdr_send_cue)(usalp, dp, trackp) < 0) {
+			errmsgno(EX_BAD, "Cannot send CUE sheet.\n");
+			return (-1);
+		}
+
+		if (trackp[0].flags & TI_TEXT) {
+			startsec = dp->cdr_dstat->ds_first_leadin;
+			printf("SAO startsec: %ld\n", startsec);
+		} else {
+			startsec = -150;
+		}
+		if (debug)
+			printf("SAO startsec: %ld\n", startsec);
+
+		if (trackp[0].flags & TI_TEXT) {
+			if (startsec > 0) {
+				errmsgno(EX_BAD, "CD-Text must be in first session.\n");
+				return (-1);
+			}
+			if (debug || lverbose)
+				printf("Writing lead-in...\n");
+			if (write_cdtext(usalp, dp, startsec) < 0)
+				return (-1);
+
+			dp->cdr_dstat->ds_cdrflags |= RF_LEADIN;
+		} else for (i = 1; i <= trackp->tracks; i++) {
+			trackp[i].trackstart += startsec +150;
+		}
+	}
+	return (0);
+}
+
+/*--------------------------------------------------------------------------*/
+
+static const char *sd_cdu_924_error_str[] = {
+
+	"\200\000write complete",				/* 80 00 */
+	"\201\000logical unit is reserved",			/* 81 00 */
+	"\205\000audio address not valid",			/* 85 00 */
+	"\210\000illegal cue sheet",				/* 88 00 */
+	"\211\000inappropriate command",			/* 89 00 */
+
+	"\266\000media load mechanism failed",			/* B6 00 */
+	"\271\000audio play operation aborted",			/* B9 00 */
+	"\277\000buffer overflow for read all subcodes command", /* BF 00 */
+	"\300\000unrecordable disk",				/* C0 00 */
+	"\301\000illegal track status",				/* C1 00 */
+	"\302\000reserved track present",			/* C2 00 */
+	"\303\000buffer data size error",			/* C3 00 */
+	"\304\001illegal data form for reserve track command",	/* C4 01 */
+	"\304\002unable to reserve track, because track mode has been changed",	/* C4 02 */
+	"\305\000buffer error during at once recording",	/* C5 00 */
+	"\306\001unwritten area encountered",			/* C6 01 */
+	"\306\002link blocks encountered",			/* C6 02 */
+	"\306\003nonexistent block encountered",		/* C6 03 */
+	"\307\000disk style mismatch",				/* C7 00 */
+	"\310\000no table of contents",				/* C8 00 */
+	"\311\000illegal block length for write command",	/* C9 00 */
+	"\312\000power calibration error",			/* CA 00 */
+	"\313\000write error",					/* CB 00 */
+	"\313\001write error track recovered",			/* CB 01 */
+	"\314\000not enough space",				/* CC 00 */
+	"\315\000no track present to finalize",			/* CD 00 */
+	"\316\000unrecoverable track descriptor encountered",	/* CE 00 */
+	"\317\000damaged track present",			/* CF 00 */
+	"\320\000pma area full",				/* D0 00 */
+	"\321\000pca area full",				/* D1 00 */
+	"\322\000unrecoverable damaged track cause too small writing area",	/* D2 00 */
+	"\323\000no bar code",					/* D3 00 */
+	"\323\001not enough bar code margin",			/* D3 01 */
+	"\323\002no bar code start pattern",			/* D3 02 */
+	"\323\003illegal bar code length",			/* D3 03 */
+	"\323\004illegal bar code format",			/* D3 04 */
+	"\324\000exit from pseudo track at once recording",	/* D4 00 */
+	NULL
+};
+
+static int
+sony_attach(SCSI *usalp, cdr_t *dp)
+{
+	if (usalp->inq != NULL) {
+		if (strbeg("CD-R   CDU94", usalp->inq->prod_ident)) {
+			dp->cdr_speeddef = 4;
+		}
+	}
+	usal_setnonstderrs(usalp, sd_cdu_924_error_str);
+	return (0);
+}
+
+#ifdef	SONY_DEBUG
+static void
+print_sony_mp22(struct sony_924_mode_page_22 *xp, int len)
+{
+	printf("disk style: %X\n", xp->disk_style);
+	printf("disk type: %X\n", xp->disk_type);
+	printf("first track: %X\n", xp->first_track);
+	printf("last track: %X\n", xp->last_track);
+	printf("numsess:    %X\n", xp->numsess);
+	printf("disk appl code: %lX\n", a_to_u_4_byte(xp->disk_appl_code));
+	printf("last start time: %lX\n", a_to_u_4_byte(xp->last_start_time));
+	printf("disk status: %X\n", xp->disk_status);
+	printf("num valid nra: %X\n", xp->num_valid_nra);
+	printf("track info track: %X\n", xp->track_info_track);
+	printf("post gap: %X\n", xp->post_gap);
+	printf("disk id code: %lX\n", a_to_u_4_byte(xp->disk_id_code));
+	printf("lead in start: %lX\n", a_to_u_4_byte(xp->lead_in_start));
+}
+
+static void
+print_sony_mp23(struct sony_924_mode_page_23 *xp, int len)
+{
+	printf("len: %d\n", len);
+
+	printf("track num: %X\n", xp->track_num);
+	printf("data form: %X\n", xp->data_form);
+	printf("write method: %X\n", xp->write_method);
+	printf("session: %X\n", xp->session);
+	printf("track status: %X\n", xp->track_status);
+
+/*
+ * XXX Check for signed/unsigned a_to_*() conversion.
+ */
+	printf("start lba: %lX\n", a_to_4_byte(xp->start_lba));
+	printf("next recordable addr: %lX\n", a_to_4_byte(xp->next_recordable_addr));
+	printf("blank area cap: %lX\n", a_to_u_4_byte(xp->blank_area_cap));
+	printf("fixed packet size: %lX\n", a_to_u_4_byte(xp->fixed_packet_size));
+	printf("starting msf: %lX\n", a_to_u_4_byte(xp->starting_msf));
+	printf("ending msf: %lX\n", a_to_u_4_byte(xp->ending_msf));
+	printf("next rec time: %lX\n", a_to_u_4_byte(xp->next_rec_time));
+}
+#endif
+
+static int
+buf_cap_sony(SCSI *usalp, long *sp, long *fp)
+{
+	char	resp[8];
+	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 = 0xEC;		/* Read buffer cap */
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+
+	usalp->cmdname = "read buffer cap sony";
+
+	if (usal_cmd(usalp) < 0)
+		return (-1);
+
+	bufsize   = a_to_u_3_byte(&resp[1]);
+	freespace = a_to_u_3_byte(&resp[5]);
+	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);
+}
diff --git a/wodim/fifo.c b/wodim/fifo.c
new file mode 100644
index 0000000..2f70f5b
--- /dev/null
+++ b/wodim/fifo.c
@@ -0,0 +1,878 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)fifo.c	1.49 06/02/08 Copyright 1989,1997-2006 J. Schilling */
+/*
+ *	A "fifo" that uses shared memory between two processes
+ *
+ *	The actual code is a mixture of borrowed code from star's fifo.c
+ *	and a proposal from Finn Arne Gangstad <finnag@guardian.no>
+ *	who had the idea to use a ring buffer to handle average size chunks.
+ *
+ *	Copyright (c) 1989,1997-2006 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.
+ */
+
+#ifndef	DEBUG
+#define	DEBUG
+#endif
+/*#define	XDEBUG*/
+#include <mconfig.h>
+
+  /* We always wish FIFO unless it is disabled below */
+#ifndef FIFO
+#define FIFO
+#endif
+
+#if	defined(HAVE_OS_H) && \
+	defined(HAVE_CLONE_AREA) && defined(HAVE_CREATE_AREA) && \
+	defined(HAVE_DELETE_AREA)
+#include <OS.h>
+#	define	HAVE_BEOS_AREAS	/* BeOS/Zeta */
+#endif
+#if	!defined(HAVE_SMMAP) && !defined(HAVE_USGSHM) && \
+	!defined(HAVE_DOSALLOCSHAREDMEM) && !defined(HAVE_BEOS_AREAS)
+#undef	FIFO			/* We cannot have a FIFO on this platform */
+#endif
+#if	!defined(HAVE_FORK)
+#undef	FIFO			/* We cannot have a FIFO on this platform */
+#endif
+#ifdef	FIFO
+#if !defined(USE_MMAP) && !defined(USE_USGSHM)
+#define	USE_MMAP
+#endif
+#ifndef	HAVE_SMMAP
+#	undef	USE_MMAP
+#	define	USE_USGSHM	/* now SYSV shared memory is the default*/
+#endif
+#ifdef	USE_MMAP		/* Only want to have one implementation */
+#	undef	USE_USGSHM	/* mmap() is preferred			*/
+#endif
+
+#ifdef	HAVE_DOSALLOCSHAREDMEM	/* This is for OS/2 */
+#	undef	USE_MMAP
+#	undef	USE_USGSHM
+#	define	USE_OS2SHM
+#endif
+
+#ifdef	HAVE_BEOS_AREAS		/* This is for BeOS/Zeta */
+#	undef	USE_MMAP
+#	undef	USE_USGSHM
+#	undef	USE_OS2SHM
+#	define	USE_BEOS_AREAS
+#endif
+
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>	/* includes <sys/types.h> */
+#include <utypes.h>
+#include <fctldefs.h>
+#if defined(HAVE_SMMAP) && defined(USE_MMAP)
+#include <mmapdefs.h>
+#endif
+#include <waitdefs.h>
+#include <standard.h>
+#include <errno.h>
+#include <signal.h>
+#include <libport.h>
+#include <schily.h>
+
+#include "wodim.h"
+#include "xio.h"
+
+#ifdef DEBUG
+#ifdef XDEBUG
+FILE	*ef;
+#define	USDEBUG1	if (debug) {if (s == owner_reader) fprintf(ef, "r"); else fprintf(ef, "w"); fflush(ef); }
+#define	USDEBUG2	if (debug) {if (s == owner_reader) fprintf(ef, "R"); else fprintf(ef, "W"); fflush(ef); }
+#else
+#define	USDEBUG1
+#define	USDEBUG2
+#endif
+#define EDEBUG(a)   if (debug) schily_error a
+#else
+#define	EDEBUG(a)
+#define	USDEBUG1
+#define	USDEBUG2
+#endif
+
+#define	palign(x, a)	(((char *)(x)) + ((a) - 1 - (((UIntptr_t)((x)-1))%(a))))
+
+typedef enum faio_owner {
+	owner_none,		/* Unused in real life			    */
+	owner_writer,		/* owned by process that writes into FIFO   */
+	owner_faio,		/* Intermediate state when buf still in use */
+	owner_reader		/* owned by process that reads from FIFO    */
+} fowner_t;
+
+char	*onames[] = {
+	"none",
+	"writer",
+	"faio",
+	"reader",
+};
+
+typedef struct faio {
+	int	len;
+	volatile fowner_t owner;
+	volatile int users;
+	short	fd;
+	short	saved_errno;
+	char	*bufp;
+} faio_t;
+
+struct faio_stats {
+	long	puts;
+	long	gets;
+	long	empty;
+	long	full;
+	long	done;
+	long	cont_low;
+	int	users;
+} *sp;
+
+#define	MIN_BUFFERS	3
+
+#define	MSECS	1000
+#define	SECS	(1000*MSECS)
+
+/*
+ * Note: WRITER_MAXWAIT & READER_MAXWAIT need to be greater than the SCSI
+ * timeout for commands that write to the media. This is currently 200s
+ * if we are in SAO mode.
+ */
+/* microsecond delay between each buffer-ready probe by writing process */
+#define	WRITER_DELAY	(20*MSECS)
+#define	WRITER_MAXWAIT	(240*SECS)	/* 240 seconds max wait for data */
+
+/* microsecond delay between each buffer-ready probe by reading process */
+#define	READER_DELAY	(80*MSECS)
+#define	READER_MAXWAIT	(240*SECS)	/* 240 seconds max wait for reader */
+
+static	char	*buf;
+static	char	*bufbase;
+static	char	*bufend;
+static	long	buflen;			/* The size of the FIFO buffer */
+
+extern	int	debug;
+extern	int	lverbose;
+
+void	init_fifo(long);
+#ifdef	USE_MMAP
+static	char	*mkshare(int size);
+#endif
+#ifdef	USE_USGSHM
+static	char	*mkshm(int size);
+#endif
+#ifdef	USE_OS2SHM
+static	char	*mkos2shm(int size);
+#endif
+#ifdef	USE_BEOS_AREAS
+static	char	*mkbeosshm(int size);
+static	void	beosshm_child(void);
+#endif
+
+BOOL	init_faio(track_t *trackp, int);
+BOOL	await_faio(void);
+void	kill_faio(void);
+int	wait_faio(void);
+static	void	faio_reader(track_t *trackp);
+static	void	faio_read_track(track_t *trackp);
+static	void	faio_wait_on_buffer(faio_t *f, fowner_t s, unsigned long delay,
+											  unsigned long max_wait);
+static	int	faio_read_segment(int fd, faio_t *f, track_t *track, long secno, 
+											int len);
+static	faio_t	*faio_ref(int n);
+int	faio_read_buf(int f, char *bp, int size);
+int	faio_get_buf(int f, char **bpp, int size);
+void	fifo_stats(void);
+int	fifo_percent(BOOL addone);
+
+
+void
+init_fifo(long fs)
+{
+	int	pagesize;
+
+	if (fs == 0L)
+		return;
+
+	pagesize = getpagesize();
+	buflen = roundup(fs, pagesize) + pagesize;
+	EDEBUG(("fs: %ld buflen: %ld\n", fs, buflen));
+
+#if	defined(USE_MMAP)
+	buf = mkshare(buflen);
+#endif
+#if	defined(USE_USGSHM)
+	buf = mkshm(buflen);
+#endif
+#if	defined(USE_OS2SHM)
+	buf = mkos2shm(buflen);
+#endif
+#if	defined(USE_BEOS_AREAS)
+	buf = mkbeosshm(buflen);
+#endif
+
+	bufbase = buf;
+	bufend = buf + buflen;
+	EDEBUG(("buf: %p bufend: %p, buflen: %ld\n", buf, bufend, buflen));
+	buf = palign(buf, pagesize);
+	buflen -= buf - bufbase;
+	EDEBUG(("buf: %p bufend: %p, buflen: %ld (align %ld)\n", buf, bufend, buflen, (long)(buf - bufbase)));
+
+	/*
+	 * Dirty the whole buffer. This can die with various signals if
+	 * we're trying to lock too much memory
+	 */
+	fillbytes(buf, buflen, '\0');
+
+#ifdef	XDEBUG
+	if (debug)
+		ef = fopen("/tmp/ef", "w");
+#endif
+}
+
+#ifdef	USE_MMAP
+static char *
+mkshare(int size)
+{
+	int	f;
+	char	*addr;
+
+#ifdef	MAP_ANONYMOUS	/* HP/UX */
+	f = -1;
+	addr = mmap(0, mmap_sizeparm(size),
+			PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, f, 0);
+#else
+	if ((f = open("/dev/zero", O_RDWR)) < 0)
+		comerr("Cannot open '/dev/zero'.\n");
+	addr = mmap(0, mmap_sizeparm(size),
+			PROT_READ|PROT_WRITE, MAP_SHARED, f, 0);
+#endif
+	if (addr == (char *)-1)
+		comerr("Cannot get mmap for %d Bytes on /dev/zero.\n", size);
+	if (f >= 0)
+		close(f);
+
+	if (debug) errmsgno(EX_BAD, "shared memory segment attached at: %p size %d\n",
+				(void *)addr, size);
+
+	return (addr);
+}
+#endif
+
+#ifdef	USE_USGSHM
+#include <sys/ipc.h>
+#include <sys/shm.h>
+static char *
+mkshm(int size)
+{
+	int	id;
+	char	*addr;
+	/*
+	 * Unfortunately, a declaration of shmat() is missing in old
+	 * implementations such as AT&T SVr0 and SunOS.
+	 * We cannot add this definition here because the return-type
+	 * changed on newer systems.
+	 *
+	 * We will get a warning like this:
+	 *
+	 * warning: assignment of pointer from integer lacks a cast
+	 * or
+	 * warning: illegal combination of pointer and integer, op =
+	 */
+/*	extern	char *shmat();*/
+
+	if ((id = shmget(IPC_PRIVATE, size, IPC_CREAT|0600)) == -1)
+		comerr("shmget failed\n");
+
+	if (debug) errmsgno(EX_BAD, "shared memory segment allocated: %d\n", id);
+
+	if ((addr = shmat(id, (char *)0, 0600)) == (char *)-1)
+		comerr("shmat failed\n");
+
+	if (debug) errmsgno(EX_BAD, "shared memory segment attached at: %p size %d\n",
+				(void *)addr, size);
+
+	if (shmctl(id, IPC_RMID, 0) < 0)
+		comerr("shmctl failed to detach shared memory segment\n");
+
+#ifdef	SHM_LOCK
+	/*
+	 * Although SHM_LOCK is standard, it seems that all versions of AIX
+	 * ommit this definition.
+	 */
+	if (shmctl(id, SHM_LOCK, 0) < 0)
+		comerr("shmctl failed to lock shared memory segment\n");
+#endif
+
+	return (addr);
+}
+#endif
+
+#ifdef	USE_OS2SHM
+static char *
+mkos2shm(int size)
+{
+	char	*addr;
+
+	/*
+	 * The OS/2 implementation of shm (using shm.dll) limits the size of one shared
+	 * memory segment to 0x3fa000 (aprox. 4MBytes). Using OS/2 native API we have
+	 * no such restriction so I decided to use it allowing fifos of arbitrary size.
+	 */
+	if (DosAllocSharedMem(&addr, NULL, size, 0X100L | 0x1L | 0x2L | 0x10L))
+		comerr("DosAllocSharedMem() failed\n");
+
+	if (debug) errmsgno(EX_BAD, "shared memory allocated attached at: %p size %d\n",
+				(void *)addr, size);
+
+	return (addr);
+}
+#endif
+
+#ifdef	USE_BEOS_AREAS
+static	area_id	faio_aid;
+static	void	*faio_addr;
+static	char	faio_name[32];
+
+static char *
+mkbeosshm(int size)
+{
+	snprintf(faio_name, sizeof (faio_name), "cdrecord FIFO %lld",
+		(Llong)getpid());
+
+	faio_aid = create_area(faio_name, &faio_addr,
+			B_ANY_ADDRESS,
+			size,
+			B_NO_LOCK, B_READ_AREA|B_WRITE_AREA);
+	if (faio_addr == NULL) {
+		comerrno(faio_aid,
+			"Cannot get create_area for %d Bytes FIFO.\n", size);
+	}
+	if (debug) errmsgno(EX_BAD, "shared memory allocated attached at: %p size %d\n",
+				(void *)faio_addr, size);
+	return (faio_addr);
+}
+
+static void
+beosshm_child()
+{
+	/*
+	 * Delete the area created by fork that is copy-on-write.
+	 */
+	delete_area(area_for(faio_addr));
+	/*
+	 * Clone (share) the original one.
+	 */
+	faio_aid = clone_area(faio_name, &faio_addr,
+			B_ANY_ADDRESS, B_READ_AREA|B_WRITE_AREA,
+			faio_aid);
+	if (bufbase != faio_addr) {
+		errmsgno(EX_BAD, "Panic FIFO addr.\n");
+		return (FALSE);
+	}
+}
+#endif
+
+static	int	faio_buffers;
+static	int	faio_buf_size;
+static	int	buf_idx = 0;		/* Initialize to fix an Amiga bug   */
+static	int	buf_idx_reader = 0;	/* Separate var to allow vfork()    */
+					/* buf_idx_reader is for the process */
+					/* that fills the FIFO		    */
+static	pid_t	faio_pid = -1;
+static	BOOL	faio_didwait;
+
+#ifdef AMIGA
+/*
+ * On Amiga fork will be replaced by the speciall vfork() like call ix_vfork,
+ * which lets the parent asleep. The child process later wakes up the parent
+ * process by calling ix_fork_resume().
+ */
+#define	fork()		 ix_vfork()
+#define	__vfork_resume() ix_vfork_resume()
+
+#else	/* !AMIGA */
+#define	__vfork_resume()
+#endif
+
+
+/*#define	faio_ref(n)	(&((faio_t *)buf)[n])*/
+
+
+BOOL
+init_faio(track_t *trackp, int bufsize)
+{
+	int	n;
+	faio_t	*f;
+	int	pagesize;
+	char	*base;
+
+	if (buflen == 0L)
+		return (FALSE);
+
+	pagesize = getpagesize();
+	faio_buf_size = bufsize;
+	f = (faio_t *)buf;
+
+	/*
+	 * Compute space for buffer headers.
+	 * Round bufsize up to pagesize to make each FIFO segment
+	 * properly page aligned.
+	 */
+	bufsize = roundup(bufsize, pagesize);
+	faio_buffers = (buflen - sizeof (*sp)) / bufsize;
+	EDEBUG(("bufsize: %d buffers: %d hdrsize %ld\n", bufsize, faio_buffers, (long)faio_buffers * sizeof (struct faio)));
+
+	/*
+	 * Reduce buffer space by header space.
+	 */
+	n = sizeof (*sp) + faio_buffers * sizeof (struct faio);
+	n = roundup(n, pagesize);
+	faio_buffers = (buflen-n) / bufsize;
+	EDEBUG(("bufsize: %d buffers: %d hdrsize %ld\n", bufsize, faio_buffers, (long)faio_buffers * sizeof (struct faio)));
+
+	if (faio_buffers < MIN_BUFFERS) {
+		errmsgno(EX_BAD,
+			"write-buffer too small, minimum is %dk. Disabling.\n",
+						MIN_BUFFERS*bufsize/1024);
+		return (FALSE);
+	}
+
+	if (debug)
+		printf("Using %d buffers of %d bytes.\n", faio_buffers, faio_buf_size);
+
+	f = (faio_t *)buf;
+	base = buf + roundup(sizeof (*sp) + faio_buffers * sizeof (struct faio),
+				pagesize);
+
+	for (n = 0; n < faio_buffers; n++, f++, base += bufsize) {
+		/* Give all the buffers to the file reader process */
+		f->owner = owner_writer;
+		f->users = 0;
+		f->bufp = base;
+		f->fd = -1;
+	}
+	sp = (struct faio_stats *)f;	/* point past headers */
+	sp->gets = sp->puts = sp->done = 0L;
+	sp->users = 1;
+
+	faio_pid = fork();
+	if (faio_pid < 0)
+		comerr("fork(2) failed");
+
+	if (faio_pid == 0) {
+		/*
+		 * child (background) process that fills the FIFO.
+		 */
+		raisepri(1);		/* almost max priority */
+
+#ifdef USE_OS2SHM
+		DosGetSharedMem(buf, 3); /* PAG_READ|PAG_WRITE */
+#endif
+#ifdef	USE_BEOS_AREAS
+		beosshm_child();
+#endif
+		/* Ignoring SIGALRM cures the SCO usleep() bug */
+/*		signal(SIGALRM, SIG_IGN);*/
+		__vfork_resume();	/* Needed on some platforms */
+		faio_reader(trackp);
+		/* NOTREACHED */
+	} else {
+#ifdef	__needed__
+		Uint	t;
+#endif
+
+		faio_didwait = FALSE;
+
+		/*
+		 * XXX We used to close all track files in the foreground
+		 * XXX process. This was not correct before we used "xio"
+		 * XXX and with "xio" it will start to fail because we need
+		 * XXX the fd handles for the faio_get_buf() function.
+		 */
+#ifdef	__needed__
+		/* close all file-descriptors that only the child will use */
+		for (t = 1; t <= trackp->tracks; t++) {
+			if (trackp[t].xfp != NULL)
+				xclose(trackp[t].xfp);
+		}
+#endif
+	}
+
+	return (TRUE);
+}
+
+BOOL
+await_faio()
+{
+	int	n;
+	int	lastfd = -1;
+	faio_t	*f;
+
+	/*
+	 * Wait until the reader is active and has filled the buffer.
+	 */
+	if (lverbose || debug) {
+		printf("Waiting for reader process to fill input buffer ... ");
+		flush();
+	}
+
+	faio_wait_on_buffer(faio_ref(faio_buffers - 1), owner_reader,
+			    500*MSECS, 0);
+
+	if (lverbose || debug)
+		printf("input buffer ready.\n");
+
+	sp->empty = sp->full = 0L;	/* set correct stat state */
+	sp->cont_low = faio_buffers;	/* set cont to max value  */
+
+	f = faio_ref(0);
+	for (n = 0; n < faio_buffers; n++, f++) {
+		if (f->fd != lastfd &&
+			f->fd == STDIN_FILENO && f->len == 0) {
+			errmsgno(EX_BAD, "Premature EOF on stdin.\n");
+			kill(faio_pid, SIGKILL);
+			return (FALSE);
+		}
+		lastfd = f->fd;
+	}
+	return (TRUE);
+}
+
+void
+kill_faio()
+{
+	if (faio_pid > 0)
+		kill(faio_pid, SIGKILL);
+  faio_pid=-1;
+}
+
+int
+wait_faio()
+{
+	if (faio_pid > 0 && !faio_didwait)
+		return (wait(0));
+	faio_didwait = TRUE;
+	return (0);
+}
+
+static void
+faio_reader(track_t *trackp)
+{
+	/* This function should not return, but _exit. */
+	Uint	trackno;
+
+	if (debug)
+		printf("\nfaio_reader starting\n");
+
+	for (trackno = 1; trackno <= trackp->tracks; trackno++) {
+		if (debug)
+			printf("\nfaio_reader reading track %u\n", trackno);
+		faio_read_track(&trackp[trackno]);
+	}
+	sp->done++;
+	if (debug)
+		printf("\nfaio_reader all tracks read, exiting\n");
+
+	/* Prevent hang if buffer is larger than all the tracks combined */
+	if (sp->gets == 0)
+		faio_ref(faio_buffers - 1)->owner = owner_reader;
+
+#ifdef	USE_OS2SHM
+	DosFreeMem(buf);
+	sleep(30000);	/* XXX If calling _exit() here the parent process seems to be blocked */
+			/* XXX This should be fixed soon */
+#endif
+	if (debug)
+		fprintf(stderr, "\nfaio_reader _exit(0)\n");
+	_exit(0);
+}
+
+#ifndef	faio_ref
+static faio_t *
+faio_ref(int n)
+{
+	return (&((faio_t *)buf)[n]);
+}
+#endif
+
+
+static void
+faio_read_track(track_t *trackp)
+{
+	int	fd = -1;
+	int	bytespt = trackp->secsize * trackp->secspt;
+	int	secspt = trackp->secspt;
+	int	l;
+	long	secno = trackp->trackstart;
+	tsize_t	tracksize = trackp->tracksize;
+	tsize_t	bytes_read = (tsize_t)0;
+	long	bytes_to_read;
+
+	if (trackp->xfp != NULL)
+		fd = xfileno(trackp->xfp);
+
+	if (bytespt > faio_buf_size) {
+		comerrno(EX_BAD,
+		"faio_read_track fatal: secsize %d secspt %d, bytespt(%d) > %d !!\n",
+			trackp->secsize, trackp->secspt, bytespt,
+			faio_buf_size);
+	}
+
+	do {
+		bytes_to_read = bytespt;
+		if (tracksize > 0) {
+			if ((tracksize - bytes_read) > bytespt) {
+				bytes_to_read = bytespt;
+			} else {
+				bytes_to_read = tracksize - bytes_read;
+			}
+		}
+		l = faio_read_segment(fd, faio_ref(buf_idx_reader), trackp, secno, bytes_to_read);
+		if (++buf_idx_reader >= faio_buffers)
+			buf_idx_reader = 0;
+		if (l <= 0)
+			break;
+		bytes_read += l;
+		secno += secspt;
+	} while (tracksize < 0 || bytes_read < tracksize);
+
+	xclose(trackp->xfp);	/* Don't keep files open longer than neccesary */
+}
+
+static void
+#ifdef	PROTOTYPES
+faio_wait_on_buffer(faio_t *f, fowner_t s,
+			unsigned long delay,
+			unsigned long max_wait)
+#else
+faio_wait_on_buffer(faio_t *f, fowner_t *s, unsigned long delay, unsigned long max_wait)
+#endif
+{
+	unsigned long max_loops;
+
+	if (f->owner == s)
+		return;		/* return immediately if the buffer is ours */
+
+	if (s == owner_reader)
+		sp->empty++;
+	else
+		sp->full++;
+
+	max_loops = max_wait / delay + 1;
+
+	while (max_wait == 0 || max_loops--) {
+		USDEBUG1;
+		usleep(delay);
+		USDEBUG2;
+
+		if (f->owner == s)
+			return;
+	}
+	if (debug) {
+		errmsgno(EX_BAD,
+		"%lu microseconds passed waiting for %d current: %d idx: %ld\n",
+		max_wait, s, f->owner, (long)(f - faio_ref(0))/sizeof (*f));
+	}
+	comerrno(EX_BAD, "faio_wait_on_buffer for %s timed out.\n",
+	(s > owner_reader || s < owner_none) ? "bad_owner" : onames[s-owner_none]);
+}
+
+static int
+faio_read_segment(int fd, faio_t *f, track_t *trackp, long secno, int len)
+{
+	int l;
+
+	faio_wait_on_buffer(f, owner_writer, WRITER_DELAY, WRITER_MAXWAIT);
+
+	f->fd = fd;
+	l = fill_buf(fd, trackp, secno, f->bufp, len);
+	f->len = l;
+	f->saved_errno = geterrno();
+	f->owner = owner_reader;
+	f->users = sp->users;
+
+	sp->puts++;
+
+	return (l);
+}
+
+int
+faio_read_buf(int fd, char *bp, int size)
+{
+	char *bufp;
+
+	int len = faio_get_buf(fd, &bufp, size);
+	if (len > 0) {
+		movebytes(bufp, bp, len);
+	}
+	return (len);
+}
+
+int
+faio_get_buf(int fd, char **bpp, int size)
+{
+	faio_t	*f;
+	int	len;
+
+again:
+	f = faio_ref(buf_idx);
+	if (f->owner == owner_faio) {
+		f->owner = owner_writer;
+		if (++buf_idx >= faio_buffers)
+			buf_idx = 0;
+		f = faio_ref(buf_idx);
+	}
+
+	if ((sp->puts - sp->gets) < sp->cont_low && sp->done == 0) {
+		EDEBUG(("gets: %ld puts: %ld cont: %ld low: %ld\n", sp->gets, sp->puts, sp->puts - sp->gets, sp->cont_low));
+		sp->cont_low = sp->puts - sp->gets;
+	}
+	faio_wait_on_buffer(f, owner_reader, READER_DELAY, READER_MAXWAIT);
+	len = f->len;
+
+	if (f->fd != fd) {
+		if (f->len == 0) {
+			/*
+			 * If the tracksize for this track was known, and
+			 * the tracksize is 0 mod bytespt, this happens.
+			 */
+			goto again;
+		}
+		comerrno(EX_BAD,
+		"faio_get_buf fatal: fd=%d, f->fd=%d, f->len=%d f->errno=%d\n",
+		fd, f->fd, f->len, f->saved_errno);
+	}
+	if (size < len) {
+		comerrno(EX_BAD,
+		"unexpected short read-attempt in faio_get_buf. size = %d, len = %d\n",
+		size, len);
+	}
+
+	if (len < 0)
+		seterrno(f->saved_errno);
+
+	sp->gets++;
+
+	*bpp = f->bufp;
+	if (--f->users <= 0)
+		f->owner = owner_faio;
+	return (len);
+}
+
+void
+fifo_stats()
+{
+	if (sp == NULL)	/* We might not use a FIFO */
+		return;
+
+	errmsgno(EX_BAD, "fifo had %ld puts and %ld gets.\n",
+		sp->puts, sp->gets);
+	errmsgno(EX_BAD, "fifo was %ld times empty and %ld times full, min fill was %ld%%.\n",
+		sp->empty, sp->full, (100L*sp->cont_low)/faio_buffers);
+}
+
+int
+fifo_percent(BOOL addone)
+{
+	int	percent;
+
+	if (sp == NULL)	/* We might not use a FIFO */
+		return (-1);
+
+	if (sp->done)
+		return (100);
+	percent = (100*(sp->puts + 1 - sp->gets)/faio_buffers);
+	if (percent > 100)
+		return (100);
+	return (percent);
+}
+#else	/* FIFO */
+
+#include <standard.h>
+#include <utypes.h>	/* includes sys/types.h */
+#include <schily.h>
+
+#include "wodim.h"
+
+void	init_fifo(long);
+BOOL	init_faio(track_t *track, int);
+BOOL	await_faio(void);
+void	kill_faio(void);
+int	wait_faio(void);
+int	faio_read_buf(int f, char *bp, int size);
+int	faio_get_buf(int f, char **bpp, int size);
+void	fifo_stats(void);
+int	fifo_percent(BOOL addone);
+
+
+void init_fifo(long fs)
+{
+	errmsgno(EX_BAD, "Fifo not supported.\n");
+}
+
+BOOL init_faio(track_t *track, 
+               int bufsize /* The size of a single transfer buffer */)
+{
+	return (FALSE);
+}
+
+BOOL await_faio()
+{
+	return (TRUE);
+}
+
+void kill_faio()
+{
+}
+
+int wait_faio()
+{
+	return (0);
+}
+
+int faio_read_buf(int fd, char *bp, int size)
+{
+	return (0);
+}
+
+int faio_get_buf(int fd, char **bpp, int size)
+{
+	return (0);
+}
+
+void fifo_stats()
+{
+}
+
+int fifo_percent(BOOL addone)
+{
+	return (-1);
+}
+
+#endif	/* FIFO */
diff --git a/wodim/getnum.c b/wodim/getnum.c
new file mode 100644
index 0000000..ed13df9
--- /dev/null
+++ b/wodim/getnum.c
@@ -0,0 +1,123 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)getnum.c	1.2 04/03/02 Copyright 1984-2002, 2004 J. Schilling */
+/*
+ *	Number conversion routines to implement 'dd' like options.
+ *
+ *	Copyright (c) 1984-2002, 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.
+ */
+
+#include <mconfig.h>
+#include <standard.h>
+#include <utypes.h>
+#include <schily.h>
+
+static	Llong	number(char *arg, int *retp);
+int	getnum(char *arg, long *valp);
+int	getllnum(char *arg, Llong *lvalp);
+
+static Llong
+number(register char *arg, int *retp)
+{
+	Llong	val	= 0;
+
+	if (*retp != 1)
+		return (val);
+	if (*arg == '\0') {
+		*retp = -1;
+	} else if (*(arg = astoll(arg, &val))) {
+		if (*arg == 'p' || *arg == 'P') {
+			val *= (1024*1024);
+			val *= (1024*1024*1024);
+			arg++;
+
+		} else if (*arg == 't' || *arg == 'T') {
+			val *= (1024*1024);
+			val *= (1024*1024);
+			arg++;
+
+		} else if (*arg == 'g' || *arg == 'G') {
+			val *= (1024*1024*1024);
+			arg++;
+
+		} else if (*arg == 'm' || *arg == 'M') {
+			val *= (1024*1024);
+			arg++;
+
+		} else if (*arg == 'f' || *arg == 'F') {
+			val *= 2352;
+			arg++;
+
+		} else if (*arg == 's' || *arg == 'S') {
+			val *= 2048;
+			arg++;
+
+		} else if (*arg == 'k' || *arg == 'K') {
+			val *= 1024;
+			arg++;
+
+		} else if (*arg == 'b' || *arg == 'B') {
+			val *= 512;
+			arg++;
+
+		} else if (*arg == 'w' || *arg == 'W') {
+			val *= 2;
+			arg++;
+		}
+		if (*arg == '*' || *arg == 'x')
+			val *= number(++arg, retp);
+		else if (*arg != '\0')
+			*retp = -1;
+	}
+	return (val);
+}
+
+int
+getnum(char *arg, long *valp)
+{
+	Llong	llval;
+	int	ret = 1;
+
+	llval = number(arg, &ret);
+	*valp = llval;
+	if (*valp != llval) {
+		errmsgno(EX_BAD,
+			"Value %lld is too large for data type 'long'.\n",
+									llval);
+		ret = -1;
+	}
+	return (ret);
+}
+
+int
+getllnum(char *arg, Llong *lvalp)
+{
+	int	ret = 1;
+
+	*lvalp = number(arg, &ret);
+	return (ret);
+}
diff --git a/wodim/iso9660.h b/wodim/iso9660.h
new file mode 100644
index 0000000..efcb212
--- /dev/null
+++ b/wodim/iso9660.h
@@ -0,0 +1,180 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)iso9660.h	1.5 04/03/02 Copyright 1996, 2004 J. Schilling */
+/*
+ *	Copyright (c) 1996, 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.
+ */
+
+#define	_delta(from, to)	((to) - (from) + 1)
+
+#define	VD_BOOT		0
+#define	VD_PRIMARY	1
+#define	VD_SUPPLEMENT	2
+#define	VD_PARTITION	3
+#define	VD_TERM		255
+
+#define	VD_ID		"CD001"
+
+struct	iso9660_voldesc {
+	char	vd_type		[_delta(1, 1)];
+	char	vd_id		[_delta(2, 6)];
+	char	vd_version	[_delta(7, 7)];
+	char	vd_fill		[_delta(8, 2048)];
+};
+
+struct	iso9660_boot_voldesc {
+	char	vd_type		[_delta(1, 1)];
+	char	vd_id		[_delta(2, 6)];
+	char	vd_version	[_delta(7, 7)];
+	char	vd_bootsys	[_delta(8, 39)];
+	char	vd_bootid	[_delta(40, 71)];
+	char	vd_bootcode	[_delta(72, 2048)];
+};
+
+struct	iso9660_pr_voldesc {
+	char	vd_type			[_delta(1,	1)];
+	char	vd_id			[_delta(2,	6)];
+	char	vd_version		[_delta(7,	7)];
+	char	vd_unused1		[_delta(8,	8)];
+	char	vd_system_id		[_delta(9,	40)];
+	char	vd_volume_id		[_delta(41,	72)];
+	char	vd_unused2		[_delta(73,	80)];
+	char	vd_volume_space_size	[_delta(81,	88)];
+	char	vd_unused3		[_delta(89,	120)];
+	char	vd_volume_set_size	[_delta(121,	124)];
+	char	vd_volume_seq_number	[_delta(125,	128)];
+	char	vd_lbsize		[_delta(129,	132)];
+	char	vd_path_table_size	[_delta(133,	140)];
+	char	vd_pos_path_table_l	[_delta(141,	144)];
+	char	vd_opt_pos_path_table_l	[_delta(145,	148)];
+	char	vd_pos_path_table_m	[_delta(149,	152)];
+	char	vd_opt_pos_path_table_m	[_delta(153,	156)];
+	char	vd_root_dir		[_delta(157,	190)];
+	char	vd_volume_set_id	[_delta(191,	318)];
+	char	vd_publisher_id		[_delta(319,	446)];
+	char	vd_data_preparer_id	[_delta(447,	574)];
+	char	vd_application_id	[_delta(575,	702)];
+	char	vd_copyr_file_id	[_delta(703,	739)];
+	char	vd_abstr_file_id	[_delta(740,	776)];
+	char	vd_bibl_file_id		[_delta(777,	813)];
+	char	vd_create_time		[_delta(814,	830)];
+	char	vd_mod_time		[_delta(831,	847)];
+	char	vd_expiry_time		[_delta(848,	864)];
+	char	vd_effective_time	[_delta(865,	881)];
+	char	vd_file_struct_vers	[_delta(882,	882)];
+	char	vd_reserved1		[_delta(883,	883)];
+	char	vd_application_use	[_delta(884,	1395)];
+	char	vd_fill			[_delta(1396,	2048)];
+};
+
+struct	iso9660_dir {
+	char	dr_len			[_delta(1,	1)];
+	char	dr_eattr_len		[_delta(2,	2)];
+	char	dr_eattr_pos		[_delta(3,	10)];
+	char	dr_data_len		[_delta(11,	18)];
+	char	dr_recording_time	[_delta(19,	25)];
+	char	dr_file_flags		[_delta(26,	26)];
+	char	dr_file_unit_size	[_delta(27,	27)];
+	char	dr_interleave_gap	[_delta(28,	28)];
+	char	dr_volume_seq_number	[_delta(29,	32)];
+	char	dr_file_name_len	[_delta(33,	33)];
+	char	dr_file_name		[_delta(34,	34)];
+};
+
+struct	iso9660_dtime {
+	unsigned char	dt_year;
+	unsigned char	dt_month;
+	unsigned char	dt_day;
+	unsigned char	dt_hour;
+	unsigned char	dt_minute;
+	unsigned char	dt_second;
+		char	dt_gmtoff;
+};
+
+struct	iso9660_ltime {
+	char	lt_year			[_delta(1,	4)];
+	char	lt_month		[_delta(5,	6)];
+	char	lt_day			[_delta(7,	8)];
+	char	lt_hour			[_delta(9,	10)];
+	char	lt_minute		[_delta(11,	12)];
+	char	lt_second		[_delta(13,	14)];
+	char	lt_hsecond		[_delta(15,	16)];
+	char	lt_gmtoff		[_delta(17,	17)];
+};
+
+struct iso9660_path_table {
+	char	pt_di_len		[_delta(1,	1)];
+	char	pt_eattr_len		[_delta(2,	2)];
+	char	pt_eattr_pos		[_delta(3,	6)];
+	char	pt_di_parent		[_delta(7,	8)];
+	char	pt_name			[_delta(9,	9)];
+};
+
+struct iso9660_eattr {
+	char	ea_owner		[_delta(1,	4)];
+	char	ea_group		[_delta(5,	8)];
+	char	ea_perm			[_delta(9,	10)];
+	char	ea_ctime		[_delta(11,	27)];
+	char	ea_mtime		[_delta(28,	44)];
+	char	ea_extime		[_delta(45,	61)];
+	char	ea_eftime		[_delta(62,	78)];
+	char	ea_record_format	[_delta(79,	79)];
+	char	ea_record_attr		[_delta(80,	80)];
+	char	ea_record_len		[_delta(81,	84)];
+	char	ea_system_id		[_delta(85,	116)];
+	char	ea_system_use		[_delta(117,	180)];
+	char	ea_version		[_delta(181,	181)];
+	char	ea_esc_seq_len		[_delta(182,	182)];
+	char	ea_reserved1		[_delta(183,	246)];
+	char	ea_appl_use_len		[_delta(247,	250)];
+	char	ea_appl_use		[_delta(251,	251)];	/* actually more */
+/*	char	ea_esc_seq		[_delta(xxx,	xxx)];	*/
+
+};
+
+#define	PERM_MB_ONE	0xAAAA
+
+#define	PERM_RSYS	0x0001
+#define	PERM_XSYS	0x0004
+
+#define	PERM_RUSR	0x0010
+#define	PERM_XUSR	0x0040
+
+#define	PERM_RGRP	0x0100
+#define	PERM_XGRP	0x0400
+
+#define	PERM_ROTH	0x1000
+#define	PERM_XOTH	0x4000
+
+
+#define	GET_UBYTE(a)	a_to_u_byte(a)
+#define	GET_SBYTE(a)	a_to_byte(a)
+#define	GET_SHORT(a)	a_to_u_2_byte(&((unsigned char *) (a))[0])
+#define	GET_BSHORT(a)	a_to_u_2_byte(&((unsigned char *) (a))[2])
+#define	GET_INT(a)	a_to_4_byte(&((unsigned char *) (a))[0])
+#define	GET_LINT(a)	la_to_4_byte(&((unsigned char *) (a))[0])
+#define	GET_BINT(a)	a_to_4_byte(&((unsigned char *) (a))[4])
diff --git a/wodim/isosize.c b/wodim/isosize.c
new file mode 100644
index 0000000..b3f6624
--- /dev/null
+++ b/wodim/isosize.c
@@ -0,0 +1,86 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)isosize.c	1.9 04/03/02 Copyright 1996, 2001-2004 J. Schilling */
+/*
+ *	Copyright (c) 1996, 2001-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.
+ */
+
+#include <mconfig.h>
+#include <statdefs.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <utypes.h>
+#include <intcvt.h>
+
+#include "iso9660.h"
+#include "wodim.h"	/* to verify isosize() prototype */
+
+Llong	isosize(int f);
+
+Llong
+isosize(int f)
+{
+	struct iso9660_voldesc		vd;
+	struct iso9660_pr_voldesc	*vp;
+	Llong				isize;
+	struct stat			sb;
+	mode_t				mode;
+
+	/*
+	 * First check if a bad guy tries to call isosize()
+	 * with an unappropriate file descriptor.
+	 * return -1 in this case.
+	 */
+	if (isatty(f))
+		return ((Llong)-1);
+	if (fstat(f, &sb) < 0)
+		return ((Llong)-1);
+	mode = sb.st_mode & S_IFMT;
+	if (!S_ISREG(mode) && !S_ISBLK(mode) && !S_ISCHR(mode))
+		return ((Llong)-1);
+
+	if (lseek(f, (off_t)(16L * 2048L), SEEK_SET) == -1)
+		return ((Llong)-1);
+
+	vp = (struct iso9660_pr_voldesc *) &vd;
+
+	do {
+		read(f, &vd, sizeof (vd)); /* FIXME: check return value */
+		if (GET_UBYTE(vd.vd_type) == VD_PRIMARY)
+			break;
+
+	} while (GET_UBYTE(vd.vd_type) != VD_TERM);
+
+	lseek(f, (off_t)0L, SEEK_SET);
+
+	if (GET_UBYTE(vd.vd_type) != VD_PRIMARY)
+		return (-1L);
+
+	isize = (Llong)GET_BINT(vp->vd_volume_space_size);
+	isize *= GET_BSHORT(vp->vd_lbsize);
+	return (isize);
+}
diff --git a/wodim/misc.c b/wodim/misc.c
new file mode 100644
index 0000000..ada60a4
--- /dev/null
+++ b/wodim/misc.c
@@ -0,0 +1,82 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)misc.c	1.4 04/03/02 Copyright 1998, 2001-2004 J. Schilling */
+/*
+ *	Misc support functions
+ *
+ *	Copyright (c) 1998, 2001-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.
+ */
+
+#include <mconfig.h>
+#include <timedefs.h>
+#include <stdio.h>
+#include <standard.h>
+#include <schily.h>
+
+void	timevaldiff(struct timeval *start, struct timeval *stop);
+void	prtimediff(const char *fmt, struct timeval *start, struct timeval *stop);
+
+void
+timevaldiff(struct timeval *start, struct timeval *stop)
+{
+	struct timeval tv;
+
+	tv.tv_sec = stop->tv_sec - start->tv_sec;
+	tv.tv_usec = stop->tv_usec - start->tv_usec;
+	while (tv.tv_usec > 1000000) {
+		tv.tv_usec -= 1000000;
+		tv.tv_sec += 1;
+	}
+	while (tv.tv_usec < 0) {
+		tv.tv_usec += 1000000;
+		tv.tv_sec -= 1;
+	}
+	*stop = tv;
+}
+
+void
+prtimediff(const char *fmt, struct timeval *start, struct timeval *stop)
+{
+	struct timeval tv;
+
+	tv.tv_sec = stop->tv_sec - start->tv_sec;
+	tv.tv_usec = stop->tv_usec - start->tv_usec;
+	while (tv.tv_usec > 1000000) {
+		tv.tv_usec -= 1000000;
+		tv.tv_sec += 1;
+	}
+	while (tv.tv_usec < 0) {
+		tv.tv_usec += 1000000;
+		tv.tv_sec -= 1;
+	}
+	/*
+	 * We need to cast timeval->* to long because
+	 * of the broken sys/time.h in Linux.
+	 */
+	printf("%s%4ld.%03lds\n", fmt, (long)tv.tv_sec, (long)tv.tv_usec/1000);
+	flush();
+}
diff --git a/wodim/mmcvendor.h b/wodim/mmcvendor.h
new file mode 100644
index 0000000..3c71afc
--- /dev/null
+++ b/wodim/mmcvendor.h
@@ -0,0 +1,87 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)mmcvendor.h	1.3 04/03/01 Copyright 2002-2004 J. Schilling */
+/*
+ *	Copyright (c) 2002-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.
+ */
+
+#ifndef	_MMCVENDOR_H
+#define	_MMCVENDOR_H
+
+#include <utypes.h>
+#include <btorder.h>
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct ricoh_mode_page_30 {
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0xE = 14 Bytes */
+	Ucbit	BUEFS		:1;	/* Burn-Free supported	*/
+	Ucbit	TWBFS		:1;	/* Test Burn-Free sup.	*/
+	Ucbit	res_2_23	:2;
+	Ucbit	ARSCS		:1;	/* Auto read speed control supp. */
+	Ucbit	AWSCS		:1;	/* Auto write speed control supp. */
+	Ucbit	res_2_67	:2;
+	Ucbit	BUEFE		:1;	/* Burn-Free enabled	*/
+	Ucbit	res_2_13	:3;
+	Ucbit	ARSCE		:1;	/* Auto read speed control enabled */
+	Ucbit	AWSCD		:1;	/* Auto write speed control disabled */
+	Ucbit	res_3_67	:2;
+	Uchar	link_counter[2];	/* Burn-Free link counter */
+	Uchar	res[10];		/* Padding up to 16 bytes */
+};
+
+#else				/* Motorola bitorder */
+
+struct ricoh_mode_page_30 {
+		MP_P_CODE;		/* parsave & pagecode */
+	Uchar	p_len;			/* 0xE = 14 Bytes */
+	Ucbit	res_2_67	:2;
+	Ucbit	AWSCS		:1;	/* Auto write speed control supp. */
+	Ucbit	ARSCS		:1;	/* Auto read speed control supp. */
+	Ucbit	res_2_23	:2;
+	Ucbit	TWBFS		:1;	/* Test Burn-Free sup.	*/
+	Ucbit	BUEFS		:1;	/* Burn-Free supported	*/
+	Ucbit	res_3_67	:2;
+	Ucbit	AWSCD		:1;	/* Auto write speed control disabled */
+	Ucbit	ARSCE		:1;	/* Auto read speed control enabled */
+	Ucbit	res_2_13	:3;
+	Ucbit	BUEFE		:1;	/* Burn-Free enabled	*/
+	Uchar	link_counter[2];	/* Burn-Free link counter */
+	Uchar	res[10];		/* Padding up to 16 bytes */
+};
+#endif
+
+struct cd_mode_vendor {
+	struct scsi_mode_header header;
+	union cd_v_pagex {
+		struct ricoh_mode_page_30 page30;
+	} pagex;
+};
+
+
+#endif	/* _MMCVENDOR_H */
diff --git a/wodim/modes.c b/wodim/modes.c
new file mode 100644
index 0000000..6718352
--- /dev/null
+++ b/wodim/modes.c
@@ -0,0 +1,289 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)modes.c	1.25 04/03/02 Copyright 1988, 1997-2001, 2004 J. Schilling */
+/*
+ *	SCSI mode page handling
+ *
+ *	Copyright (c) 1988, 1997-2001, 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.
+ */
+
+#include <mconfig.h>
+#include <utypes.h>
+#include <standard.h>
+#include <schily.h>
+#include <usal/usalcmd.h>
+#include <usal/scsireg.h>
+#include <usal/scsitransp.h>
+
+#include "wodim.h"
+
+int	scsi_compliant;
+
+static	BOOL	has_mode_page(SCSI *usalp, int page, char *pagename, int *lenp);
+BOOL	get_mode_params(SCSI *usalp, int page, char *pagename, Uchar *modep, 
+							 Uchar *cmodep, Uchar *dmodep, Uchar *smodep, int *lenp);
+BOOL	set_mode_params(SCSI *usalp, char *pagename, Uchar *modep, int len, 
+							 int save, int secsize);
+
+#define	XXX
+
+#ifdef	XXX
+static BOOL
+has_mode_page(SCSI *usalp, int page, char *pagename, int *lenp)
+{
+	Uchar	mode[0x100];
+	int	hdlen;
+	int	len = 1;				/* Nach SCSI Norm */
+	int	try = 0;
+	struct	scsi_mode_page_header *mp;
+
+	/*
+	 * ATAPI drives (used e.g. by IOMEGA) from y2k have the worst firmware
+	 * I've seen. They create DMA buffer overruns if we request less than
+	 * 3 bytes with 6 byte mode sense which equals 4 byte with 10 byte mode
+	 * sense. In order to prevent repeated bus resets, we remember this
+	 * bug.
+	 *
+	 * IOMEGA claims that they are using Philips clone drives but a Philips
+	 * drive I own does not have the problem.
+	 */
+	if ((usalp->dflags & DRF_MODE_DMA_OVR) != 0)
+		len = sizeof (struct scsi_mode_header);
+again:
+	fillbytes((caddr_t)mode, sizeof (mode), '\0');
+	if (lenp)
+		*lenp = 0;
+
+	usalp->silent++;
+	(void) unit_ready(usalp);
+/* Maxoptix bringt Aborted cmd 0x0B mit code 0x4E (overlapping cmds)*/
+
+	/*
+	 * The Matsushita CW-7502 will sometimes deliver a zeroed
+	 * mode page 2A if "Page n default" is used instead of "current".
+	 */
+	if (mode_sense(usalp, mode, len, page, 0) < 0) {	/* Page n current */
+		usalp->silent--;
+		if (len < (int)sizeof (struct scsi_mode_header) && try == 0) {
+			len = sizeof (struct scsi_mode_header);
+			goto again;
+		}
+		return (FALSE);
+	} else {
+		if (len > 1 && try == 0) {
+			/*
+			 * If we come here, we got a hard failure with the
+			 * fist try. Remember this (IOMEGA USB) firmware bug.
+			 */
+			if ((usalp->dflags & DRF_MODE_DMA_OVR) == 0) {
+				/* XXX if (!nowarn) */
+				errmsgno(EX_BAD,
+				"Warning: controller creates hard SCSI failure when retrieving %s page.\n",
+								pagename);
+				usalp->dflags |= DRF_MODE_DMA_OVR;
+			}
+		}
+		len = ((struct scsi_mode_header *)mode)->sense_data_len + 1;
+	}
+	/*
+	 * ATAPI drives as used by IOMEGA may receive a SCSI bus device reset
+	 * in between these two mode sense commands.
+	 */
+	(void) unit_ready(usalp);
+	if (mode_sense(usalp, mode, len, page, 0) < 0) {	/* Page n current */
+		usalp->silent--;
+		return (FALSE);
+	}
+	usalp->silent--;
+
+	if (usalp->verbose)
+		usal_prbytes("Mode Sense Data", mode, len - usal_getresid(usalp));
+	hdlen = sizeof (struct scsi_mode_header) +
+			((struct scsi_mode_header *)mode)->blockdesc_len;
+	mp = (struct scsi_mode_page_header *)(mode + hdlen);
+	if (usalp->verbose)
+		usal_prbytes("Mode Page  Data", (Uchar *)mp, mp->p_len+2);
+
+	if (mp->p_len == 0) {
+		if (!scsi_compliant && try == 0) {
+			len = hdlen;
+			/*
+			 * add sizeof page header (page # + len byte)
+			 * (should normaly result in len == 14)
+			 * this allowes to work with:
+			 * 	Quantum Q210S	(wants at least 13)
+			 * 	MD2x		(wants at least 4)
+			 */
+			len += 2;
+			try++;
+			goto again;
+		}
+		/* XXX if (!nowarn) */
+		errmsgno(EX_BAD,
+			"Warning: controller returns zero sized %s page.\n",
+								pagename);
+	}
+	if (!scsi_compliant &&
+	    (len < (int)(mp->p_len + hdlen + 2))) {
+		len = mp->p_len + hdlen + 2;
+
+		/* XXX if (!nowarn) */
+		errmsgno(EX_BAD,
+			"Warning: controller returns wrong size for %s page.\n",
+								pagename);
+	}
+	if (mp->p_code != page) {
+		/* XXX if (!nowarn) */
+		errmsgno(EX_BAD,
+			"Warning: controller returns wrong page %X for %s page (%X).\n",
+						mp->p_code, pagename, page);
+		return (FALSE);
+	}
+
+	if (lenp)
+		*lenp = len;
+	return (mp->p_len > 0);
+}
+#endif
+
+BOOL
+get_mode_params(SCSI *usalp, int page, char *pagename, Uchar *modep, 
+                Uchar *cmodep, Uchar *dmodep, Uchar *smodep, int *lenp)
+{
+	int	len;
+	BOOL	ret = TRUE;
+
+#ifdef	XXX
+	if (lenp)
+		*lenp = 0;
+	if (!has_mode_page(usalp, page, pagename, &len)) {
+		if (!usalp->silent) errmsgno(EX_BAD,
+			"Warning: controller does not support %s page.\n",
+								pagename);
+		return (FALSE);
+	}
+	if (lenp)
+		*lenp = len;
+#else
+	if (lenp == 0)
+		len = 0xFF;
+#endif
+
+	if (modep) {
+		fillbytes(modep, 0x100, '\0');
+		usalp->silent++;
+		(void) unit_ready(usalp);
+		usalp->silent--;
+		if (mode_sense(usalp, modep, len, page, 0) < 0) { /* Page x current */
+			errmsgno(EX_BAD, "Cannot get %s data.\n", pagename);
+			ret = FALSE;
+		} else if (usalp->verbose) {
+			usal_prbytes("Mode Sense Data", modep, len - usal_getresid(usalp));
+		}
+	}
+
+	if (cmodep) {
+		fillbytes(cmodep, 0x100, '\0');
+		usalp->silent++;
+		(void) unit_ready(usalp);
+		usalp->silent--;
+		if (mode_sense(usalp, cmodep, len, page, 1) < 0) { /* Page x change */
+			errmsgno(EX_BAD, "Cannot get %s mask.\n", pagename);
+			ret = FALSE;
+		} else if (usalp->verbose) {
+			usal_prbytes("Mode Sense Data", cmodep, len - usal_getresid(usalp));
+		}
+	}
+
+	if (dmodep) {
+		fillbytes(dmodep, 0x100, '\0');
+		usalp->silent++;
+		(void) unit_ready(usalp);
+		usalp->silent--;
+		if (mode_sense(usalp, dmodep, len, page, 2) < 0) { /* Page x default */
+			errmsgno(EX_BAD, "Cannot get default %s data.\n",
+								pagename);
+			ret = FALSE;
+		} else if (usalp->verbose) {
+			usal_prbytes("Mode Sense Data", dmodep, len - usal_getresid(usalp));
+		}
+	}
+
+	if (smodep) {
+		fillbytes(smodep, 0x100, '\0');
+		usalp->silent++;
+		(void) unit_ready(usalp);
+		usalp->silent--;
+		if (mode_sense(usalp, smodep, len, page, 3) < 0) { /* Page x saved */
+			errmsgno(EX_BAD, "Cannot get saved %s data.\n", pagename);
+			ret = FALSE;
+		} else if (usalp->verbose) {
+			usal_prbytes("Mode Sense Data", smodep, len - usal_getresid(usalp));
+		}
+	}
+
+	return (ret);
+}
+
+BOOL
+set_mode_params(SCSI *usalp, char *pagename, Uchar *modep, int len, int save, 
+                int secsize)
+{
+	int	i;
+
+	((struct scsi_modesel_header *)modep)->sense_data_len	= 0;
+	((struct scsi_modesel_header *)modep)->res2		= 0;
+
+	i = ((struct scsi_mode_header *)modep)->blockdesc_len;
+	if (i > 0) {
+		i_to_3_byte(
+			((struct scsi_mode_data *)modep)->blockdesc.nlblock,
+								0);
+		if (secsize >= 0)
+		i_to_3_byte(((struct scsi_mode_data *)modep)->blockdesc.lblen,
+							secsize);
+	}
+
+	usalp->silent++;
+	(void) unit_ready(usalp);
+	usalp->silent--;
+	if (save == 0 || mode_select(usalp, modep, len, save, usalp->inq->data_format >= 2) < 0) {
+		usalp->silent++;
+		(void) unit_ready(usalp);
+		usalp->silent--;
+		if (mode_select(usalp, modep, len, 0, usalp->inq->data_format >= 2) < 0) {
+			if (usalp->silent == 0) {
+				errmsgno(EX_BAD,
+					"Warning: using default %s data.\n",
+					pagename);
+				usal_prbytes("Mode Select Data", modep, len);
+			}
+			return (FALSE);
+		}
+	}
+	return (TRUE);
+}
diff --git a/wodim/movesect.c b/wodim/movesect.c
new file mode 100644
index 0000000..ef4bc70
--- /dev/null
+++ b/wodim/movesect.c
@@ -0,0 +1,104 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)movesect.c	1.3 04/03/02 Copyright 2001, 2004 J. Schilling */
+/*
+ *	Copyright (c) 2001, 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.
+ */
+
+#include <mconfig.h>
+#include <standard.h>
+#include <utypes.h>
+#include <schily.h>
+
+#include "wodim.h"
+#include "movesect.h"
+
+void	scatter_secs(track_t *trackp, char *bp, int nsecs);
+
+/*
+ * Scatter input sector size records over buffer to make them
+ * output sector size.
+ *
+ * If input sector size is less than output sector size,
+ *
+ *	| sector_0 || sector_1 || ... || sector_n ||
+ *
+ * will be convterted into:
+ *
+ *	| sector_0 |grass|| sector_1 |grass|| ... || sector_n |grass||
+ *
+ *	Sector_n must me moved n * grass_size forward,
+ *	Sector_1 must me moved 1 * grass_size forward
+ *
+ *
+ * If output sector size is less than input sector size,
+ *
+ *	| sector_0 |grass|| sector_1 |grass|| ... || sector_n |grass||
+ *
+ * will be convterted into:
+ *
+ *	| sector_0 || sector_1 || ... || sector_n ||
+ *
+ *	Sector_1 must me moved 1 * grass_size backward,
+ *	Sector_n must me moved n * grass_size backward,
+ *
+ *	Sector_0 must never be moved.
+ */
+void
+scatter_secs(track_t *trackp, char *bp, int nsecs)
+{
+	char	*from;
+	char	*to;
+	int	isecsize = trackp->isecsize;
+	int	secsize = trackp->secsize;
+	int	i;
+
+	if (secsize == isecsize)
+		return;
+
+	nsecs -= 1;	/* we do not move sector # 0 */
+
+	if (secsize < isecsize) {
+		from = bp + isecsize;
+		to   = bp + secsize;
+
+		for (i = nsecs; i > 0; i--) {
+			movebytes(from, to, secsize);
+			from += isecsize;
+			to   += secsize;
+		}
+	} else {
+		from = bp + (nsecs * isecsize);
+		to   = bp + (nsecs * secsize);
+
+		for (i = nsecs; i > 0; i--) {
+			movebytes(from, to, isecsize);
+			from -= isecsize;
+			to   -= secsize;
+		}
+	}
+}
diff --git a/wodim/movesect.h b/wodim/movesect.h
new file mode 100644
index 0000000..64f09b7
--- /dev/null
+++ b/wodim/movesect.h
@@ -0,0 +1,45 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)movesect.h	1.1 01/06/02 Copyright 2001 J. Schilling */
+/*
+ *	Copyright (c) 2001 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.
+ */
+
+#ifndef	_MOVESECT_H
+#define	_MOVESECT_H
+
+#define	move2352(from, to)	movebytes(from, to, 2352)
+#define	move2336(from, to)	movebytes(from, to, 2336)
+#define	move2048(from, to)	movebytes(from, to, 2048)
+
+#define	fill2352(p, val)	fillbytes(p, 2352, val)
+#define	fill2048(p, val)	fillbytes(p, 2048, val)
+#define	fill96(p, val)		fillbytes(p, 96, val)
+
+extern	void	scatter_secs(track_t *trackp, char *bp, int nsecs);
+
+#endif
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	*/
+}
diff --git a/wodim/scsi_cdr_mmc4.c b/wodim/scsi_cdr_mmc4.c
new file mode 100644
index 0000000..cb0958a
--- /dev/null
+++ b/wodim/scsi_cdr_mmc4.c
@@ -0,0 +1,80 @@
+/*
+ * 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_mmc4.c	1.1 05/05/16 Copyright 1995-2005 J. Schilling */
+/*
+ *	SCSI command functions for cdrecord
+ *	covering MMC-4
+ *
+ *	Copyright (c) 1995-2005 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.
+ */
+
+#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"
+
+void	print_capabilities_mmc4(SCSI *usalp);
+
+#define	DOES(what, flag)	printf("  Does %s%s\n", flag?"":"not ", what)
+
+
+void
+print_capabilities_mmc4(SCSI *usalp)
+{
+	int	cdrw_types;
+
+	if (usalp->inq->type != INQ_ROMD)
+		return;
+
+	cdrw_types = get_supported_cdrw_media_types(usalp);
+	if (cdrw_types != -1) {
+		printf("\nSupported CD-RW media types according to MMC-4 feature 0x37:\n");
+		DOES("write multi speed       CD-RW media", (cdrw_types & CDR_CDRW_MULTI));
+		DOES("write high  speed       CD-RW media", (cdrw_types & CDR_CDRW_HIGH));
+		DOES("write ultra high speed  CD-RW media", (cdrw_types & CDR_CDRW_ULTRA));
+		DOES("write ultra high speed+ CD-RW media", (cdrw_types & CDR_CDRW_ULTRAP));
+	}
+}
diff --git a/wodim/scsi_mmc.c b/wodim/scsi_mmc.c
new file mode 100644
index 0000000..f8baa1f
--- /dev/null
+++ b/wodim/scsi_mmc.c
@@ -0,0 +1,411 @@
+/*
+ * 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_mmc.c	1.13 05/05/16 Copyright 2002-2005 J. Schilling */
+/*
+ *	SCSI command functions for cdrecord
+ *	covering MMC-3 level and above
+ *
+ *	Copyright (c) 2002-2005 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.
+ */
+
+/*
+Includes code from http://libburnia.pykix.org/browser/libburn/trunk/libburn/mmc.c?format=txt 
+*/
+
+/*#define	DEBUG*/
+
+#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"
+
+extern	int	xdebug;
+
+
+
+int	get_configuration(SCSI *usalp, caddr_t bp, int cnt, int st_feature, 
+								int rt);
+static	int	get_conflen(SCSI *usalp, int st_feature, int rt);
+int	get_curprofile(SCSI *usalp);
+static	int	get_profiles(SCSI *usalp, caddr_t bp, int cnt);
+int	print_profiles(SCSI *usalp);
+int	get_proflist(SCSI *usalp, BOOL *wp, BOOL *cdp, BOOL *dvdp, BOOL *dvdplusp,
+						 BOOL *ddcdp);
+int	get_wproflist(SCSI *usalp, BOOL *cdp, BOOL *dvdp, BOOL *dvdplusp, 
+						  BOOL *ddcdp);
+
+/*
+ * Get feature codes
+ */
+int
+get_configuration(SCSI *usalp, caddr_t bp, int cnt, int st_feature, int rt)
+{
+	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 = 0x46;
+	scmd->cdb.g1_cdb.lun = usal_lun(usalp);
+	if (rt & 1)
+		scmd->cdb.g1_cdb.reladr  = 1;
+	if (rt & 2)
+		scmd->cdb.g1_cdb.res  = 1;
+
+	i_to_2_byte(scmd->cdb.g1_cdb.addr, st_feature);
+	g1_cdblen(&scmd->cdb.g1_cdb, cnt);
+
+	usalp->cmdname = "get_configuration";
+
+	return (usal_cmd(usalp));
+}
+
+/*
+ * Retrieve feature code list length
+ */
+static int
+get_conflen(SCSI *usalp, int st_feature, int rt)
+{
+	Uchar	cbuf[8];
+	int	flen;
+	int	i;
+
+	fillbytes(cbuf, sizeof (cbuf), '\0');
+	usalp->silent++;
+	i = get_configuration(usalp, (char *)cbuf, sizeof (cbuf), st_feature, rt);
+	usalp->silent--;
+	if (i < 0)
+		return (-1);
+	i = sizeof (cbuf) - usal_getresid(usalp);
+	if (i < 4)
+		return (-1);
+
+	flen = a_to_u_4_byte(cbuf);
+	if (flen < 4)
+		return (-1);
+	return (flen);
+}
+
+int
+get_curprofile(SCSI *usalp)
+{
+	Uchar	cbuf[8];
+	int	amt;
+	int	flen;
+	int	profile;
+	int	i;
+
+	fillbytes(cbuf, sizeof (cbuf), '\0');
+	usalp->silent++;
+	i = get_configuration(usalp, (char *)cbuf, sizeof (cbuf), 0, 0);
+	usalp->silent--;
+	if (i < 0)
+		return (-1);
+
+	amt = sizeof (cbuf) - usal_getresid(usalp);
+	if (amt < 8)
+		return (-1);
+	flen = a_to_u_4_byte(cbuf);
+	if (flen < 4)
+		return (-1);
+
+	profile = a_to_u_2_byte(&cbuf[6]);
+
+	if (xdebug > 1)
+		usal_prbytes("Features: ", cbuf, amt);
+
+	if (xdebug > 0)
+		printf("feature len: %d current profile 0x%04X (%s) len %d\n",
+				flen, profile,
+				mmc_obtain_profile_name(profile), amt);
+
+	return (profile);
+}
+
+static int
+get_profiles(SCSI *usalp, caddr_t bp, int cnt)
+{
+	int	amt;
+	int	flen;
+	int	i;
+
+	flen = get_conflen(usalp, 0, 0);
+	if (flen < 0)
+		return (-1);
+	if (cnt < flen)
+		flen = cnt;
+
+	fillbytes(bp, cnt, '\0');
+	usalp->silent++;
+	i = get_configuration(usalp, (char *)bp, flen, 0, 0);
+	usalp->silent--;
+	if (i < 0)
+		return (-1);
+	amt = flen - usal_getresid(usalp);
+
+	flen = a_to_u_4_byte(bp);
+	if ((flen+4) < amt)
+		amt = flen+4;
+
+	return (amt);
+}
+
+int
+print_profiles(SCSI *usalp)
+{
+	Uchar	cbuf[1024];
+	Uchar	*p;
+	int	flen;
+	int	curprofile;
+	int	profile;
+	int	i;
+	int	n;
+
+	flen = get_profiles(usalp, (caddr_t)cbuf, sizeof (cbuf));
+	if (flen < 0)
+		return (-1);
+
+	p = cbuf;
+	if (xdebug > 1)
+		usal_prbytes("Features: ", cbuf, flen);
+
+	curprofile = a_to_u_2_byte(&p[6]);
+	if (xdebug > 0)
+		printf("feature len: %d current profile 0x%04X (%s)\n",
+				flen, curprofile,
+				mmc_obtain_profile_name(curprofile));
+
+	printf("Current: 0x%04X (%s)\n", curprofile,
+			mmc_obtain_profile_name(curprofile));
+
+	p += 8;		/* Skip feature header	*/
+	n = p[3];	/* Additional length	*/
+	n /= 4;
+	p += 4;
+
+	for (i = 0; i < n; i++) {
+		profile = a_to_u_2_byte(p);
+		if (xdebug > 0)
+			printf("Profile: 0x%04X (%s)", profile,
+					mmc_obtain_profile_name(profile));
+		else
+			printf("Profile: ");
+		printf("0x%04X (%s) %s\n", profile,
+				mmc_obtain_profile_name(profile), 
+				p[2] & 1 ? "(current)":"");
+		p += 4;
+	}
+	return (curprofile);
+}
+
+int
+get_proflist(SCSI *usalp, BOOL *wp, BOOL *cdp, BOOL *dvdp, BOOL *dvdplusp, 
+             BOOL *ddcdp)
+{
+	Uchar	cbuf[1024];
+	Uchar	*p;
+	int	flen;
+	int	curprofile;
+	int	profile;
+	int	i;
+	int	n;
+	BOOL	wr	= FALSE;
+	BOOL	cd	= FALSE;
+	BOOL	dvd	= FALSE;
+	BOOL	dvdplus	= FALSE;
+	BOOL	ddcd	= FALSE;
+
+	flen = get_profiles(usalp, (caddr_t)cbuf, sizeof (cbuf));
+	if (flen < 0)
+		return (-1);
+
+	p = cbuf;
+	if (xdebug > 1)
+		usal_prbytes("Features: ", cbuf, flen);
+
+	curprofile = a_to_u_2_byte(&p[6]);
+	if (xdebug > 0)
+		printf("feature len: %d current profile 0x%04X (%s)\n",
+				flen, curprofile, 
+				mmc_obtain_profile_name(curprofile));
+
+	p += 8;		/* Skip feature header	*/
+	n = p[3];	/* Additional length	*/
+	n /= 4;
+	p += 4;
+
+	for (i = 0; i < n; i++) {
+		profile = a_to_u_2_byte(p);
+		p += 4;
+		if (profile >= 0x0008 && profile < 0x0010)
+			cd = TRUE;
+		if (profile > 0x0008 && profile < 0x0010)
+			wr = TRUE;
+
+		if (profile >= 0x0010 && profile < 0x0018)
+			dvd = TRUE;
+		if (profile > 0x0010 && profile < 0x0018)
+			wr = TRUE;
+
+		if (profile >= 0x0018 && profile < 0x0020)
+			dvdplus = TRUE;
+		if (profile > 0x0018 && profile < 0x0020)
+			wr = TRUE;
+
+		if (profile >= 0x0020 && profile < 0x0028)
+			ddcd = TRUE;
+		if (profile > 0x0020 && profile < 0x0028)
+			wr = TRUE;
+	}
+	if (wp)
+		*wp	= wr;
+	if (cdp)
+		*cdp	= cd;
+	if (dvdp)
+		*dvdp	= dvd;
+	if (dvdplusp)
+		*dvdplusp = dvdplus;
+	if (ddcdp)
+		*ddcdp	= ddcd;
+
+	return (curprofile);
+}
+
+int
+get_wproflist(SCSI *usalp, BOOL *cdp, BOOL *dvdp, BOOL *dvdplusp, BOOL *ddcdp)
+{
+	Uchar	cbuf[1024];
+	Uchar	*p;
+	int	flen;
+	int	curprofile;
+	int	profile;
+	int	i;
+	int	n;
+	BOOL	cd	= FALSE;
+	BOOL	dvd	= FALSE;
+	BOOL	dvdplus	= FALSE;
+	BOOL	ddcd	= FALSE;
+
+	flen = get_profiles(usalp, (caddr_t)cbuf, sizeof (cbuf));
+	if (flen < 0)
+		return (-1);
+	p = cbuf;
+	curprofile = a_to_u_2_byte(&p[6]);
+
+	p += 8;		/* Skip feature header	*/
+	n = p[3];	/* Additional length	*/
+	n /= 4;
+	p += 4;
+
+	for (i = 0; i < n; i++) {
+		profile = a_to_u_2_byte(p);
+		p += 4;
+		if (profile > 0x0008 && profile < 0x0010)
+			cd = TRUE;
+		if (profile > 0x0010 && profile < 0x0018)
+			dvd = TRUE;
+		if (profile > 0x0018 && profile < 0x0020)
+			dvdplus = TRUE;
+		if (profile > 0x0020 && profile < 0x0028)
+			ddcd = TRUE;
+	}
+	if (cdp)
+		*cdp	= cd;
+	if (dvdp)
+		*dvdp	= dvd;
+	if (dvdplusp)
+		*dvdplusp = dvdplus;
+	if (ddcdp)
+		*ddcdp	= ddcd;
+
+	return (curprofile);
+}
+
+
+char *mmc_obtain_profile_name(int profile_number) {
+  static char *texts[0x53] = {NULL};
+  static char *reserved="Reserved/Unknown";
+  int i, max_pno = 0x53;
+  
+  if (texts[0] == NULL) {
+    for (i = 0; i<max_pno; i++)
+      texts[i] = reserved;
+    /* mmc5r04c.pdf , Table 88, human readable profile names */
+    texts[0x01] = "Non-removable disk";
+    texts[0x02] = "Removable disk";
+    texts[0x03] = "MO erasable";
+    texts[0x04] = "Optical write once";
+    texts[0x05] = "AS-MO";
+    texts[0x08] = "CD-ROM";
+    texts[0x09] = "CD-R";
+    texts[0x0a] = "CD-RW";
+    texts[0x10] = "DVD-ROM";
+    texts[0x11] = "DVD-R sequential recording";
+    texts[0x12] = "DVD-RAM";
+    texts[0x13] = "DVD-RW restricted overwrite";
+    texts[0x14] = "DVD-RW sequential recording";
+    texts[0x15] = "DVD-R/DL sequential recording";
+    texts[0x16] = "DVD-R/DL layer jump recording";
+    texts[0x1a] = "DVD+RW";
+    texts[0x1b] = "DVD+R";
+    texts[0x2a] = "DVD+RW/DL";
+    texts[0x2b] = "DVD+R/DL";
+    texts[0x40] = "BD-ROM";
+    texts[0x41] = "BD-R sequential recording";
+    texts[0x42] = "BD-R random recording";
+    texts[0x43] = "BD-RE";
+    texts[0x50] = "HD-DVD-ROM";
+    texts[0x51] = "HD-DVD-R";
+    texts[0x52] = "HD-DVD-RAM";
+  }
+  if (profile_number<0 || profile_number>=max_pno)
+    return "";
+  return texts[profile_number];
+}
+
diff --git a/wodim/scsi_mmc4.c b/wodim/scsi_mmc4.c
new file mode 100644
index 0000000..1257093
--- /dev/null
+++ b/wodim/scsi_mmc4.c
@@ -0,0 +1,83 @@
+/*
+ * 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_mmc4.c	1.1 05/05/16 Copyright 2002-2005 J. Schilling */
+/*
+ *	SCSI command functions for cdrecord
+ *	covering MMC-4 level and above
+ *
+ *	Copyright (c) 2002-2005 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.
+ */
+
+/* #define	DEBUG */
+#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"
+
+ int	get_supported_cdrw_media_types(SCSI *usalp);
+
+/*
+ * Retrieve list of supported cd-rw media types (feature 0x37)
+ */
+int
+get_supported_cdrw_media_types(SCSI *usalp)
+{
+	Uchar   cbuf[16];
+	int	ret;
+	fillbytes(cbuf, sizeof (cbuf), '\0');
+
+	usalp->silent++;
+	ret = get_configuration(usalp, (char *)cbuf, sizeof (cbuf), 0x37, 2);
+	usalp->silent--;
+
+	if (ret < 0)
+		return (-1);
+
+	if (cbuf[3] < 12)	/* Couldn't retrieve feature 0x37	*/
+		return (-1);
+
+	return (int)(cbuf[13]);
+}
diff --git a/wodim/scsi_scan.c b/wodim/scsi_scan.c
new file mode 100644
index 0000000..218d23f
--- /dev/null
+++ b/wodim/scsi_scan.c
@@ -0,0 +1,379 @@
+/*
+ * 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_scan.c	1.19 04/04/16 Copyright 1997-2004 J. Schilling */
+/*
+ *	Scan SCSI Bus.
+ *	Stolen from sformat. Need a more general form to
+ *	re-use it in sformat too.
+ *
+ *	Copyright (c) 1997-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <errno.h>
+#include <schily.h>
+
+#include <usal/usalcmd.h>
+#include <usal/scsidefs.h>
+#include <usal/scsireg.h>
+#include <usal/scsitransp.h>
+
+#include "scsi_scan.h"
+#include "wodim.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+
+static	void	print_product(FILE *f, struct scsi_inquiry *ip);
+int	select_target(SCSI *usalp, FILE *f);
+
+#define MAXDEVCOUNT (256+26)
+
+extern BOOL check_linux_26();
+
+static void print_product(FILE *f, struct  scsi_inquiry *ip) {
+	fprintf(f, "'%.8s' ", ip->vendor_info);
+	fprintf(f, "'%.16s' ", ip->prod_ident);
+	fprintf(f, "'%.4s' ", ip->prod_revision);
+	if (ip->add_len < 31) {
+		fprintf(f, "NON CCS ");
+	}
+	usal_fprintdev(f, ip);
+}
+
+SCSI * open_auto(int64_t need_size, int debug, int lverbose) {
+	int res;
+	SCSI * usalp = NULL;
+	char  errstr[80];
+	
+#ifdef __linux__
+	/* quick-and-dirty code but should do what is supposed to, more quickly */
+
+		/*
+		 * For Linux, try these strategies, in order:
+		 * 1. stat /dev/cdrw or /dev/dvdrw, depending on size we need.
+		 * 2. Read /proc/sys/dev/cdrom/info, look for a CD-R/DVD-R.
+		 *    Will fail for kernel 2.4 or if cdrom module not loaded.
+		 * 3. stat /dev/cdrom, just assume that it can write media.
+
+     An example for procfs file contents, beware of the TABs
+
+---
+CD-ROM information, Id: cdrom.c 3.20 2003/12/17
+
+drive name:		hdc     hda
+drive speed:		40      40
+drive # of slots:       1       1
+Can close tray:         1       1
+Can open tray:          1       1
+Can lock tray:          1       1
+Can change speed:       1       1
+Can select disk:        0       0
+Can read multisession:  1       1
+Can read MCN:           1       1
+Reports media changed:  1       1
+Can play audio:         1       1
+Can write CD-R:		0       1
+Can write CD-RW:        0       1
+Can read DVD:           1       1
+Can write DVD-R:        0       1
+Can write DVD-RAM:      0       1
+Can read MRW:           0       1
+Can write MRW:          0       1
+Can write RAM:          0       1
+
+---
+*/
+	struct stat statbuf;
+	/* XXX Good guess? BD-RE recorders may not support CDRW anymore... */
+	char *type="CD-R", *key="Can write CD-R:", *guessdev="/dev/cdrw", *result=NULL;
+	FILE *fh;
+
+	if( need_size > 360000*2048 ) {
+		type="DVD-R";
+		guessdev="/dev/dvdrw";
+		key="Can write DVD-R:";
+	}
+
+	if(need_size>10240) /* don't bother with weird numbers */
+		fprintf(stderr, "Looking for a %s drive to store %.2f MiB...\n", type, (float)need_size/1048576.0);
+	if(0==stat(guessdev, &statbuf))
+		result=guessdev;
+	else if(0!= (fh = fopen("/proc/sys/dev/cdrom/info", "r")) ) {
+		/* ok, going the hard way */
+		char *nameline=NULL;
+		static char buf[256];
+		int kn = strlen(key);
+
+		buf[255]='\0';
+
+		while(fgets(buf, sizeof(buf), fh)) {
+			if(0==strncmp(buf, "drive name:", 11))
+				nameline=strdup(buf);
+			if(nameline && 0==strncmp(buf, key, kn)) {
+				int p=kn;
+				char *descptr=nameline+11; /* start at the known whitespace */
+				while(p<sizeof(buf) && buf[p]) {
+					if(buf[p]=='1' || buf[p]=='0') {
+						/* find the beginning of the descriptor */
+						for(;isspace((Uchar) *descptr);descptr++)
+							;
+					}
+					if(buf[p]=='1') {
+						result=descptr-5;
+						/* terminate on space/newline and stop there */
+						for(;*descptr;descptr++) {
+							if(isspace((Uchar) *descptr))
+								*(descptr--)='\0';
+						}
+						strncpy(result, "/dev/", 5);
+						break;
+					}
+					else { /* no hit, move to after word ending */
+						for(; *descptr && ! isspace((Uchar) *descptr); descptr++)
+							;
+					}
+					p++;
+				}
+			}
+
+		}
+		fclose(fh);
+	}
+
+	if(result)
+		fprintf(stderr, "Detected %s drive: %s\n", type, result);
+	if (0==stat("/dev/cdrom", &statbuf)) {
+		result = "/dev/cdrom";
+		fprintf(stderr, "Using /dev/cdrom of unknown capabilities\n");
+	}
+	if(result)
+		return usal_open(result, errstr, sizeof(errstr), debug, lverbose);
+#endif /* __linux__ */
+
+	usalp = usal_open(NULL, errstr, sizeof(errstr), debug, lverbose);
+	if(!usalp)
+		return NULL;
+	res = list_devices(usalp, stdout, 1);
+	if(res>0)
+		return usalp;
+	else
+		usal_close(usalp);
+	return NULL;
+}
+
+int list_devices(SCSI *usalp, FILE *f, int pickup_first) {
+	int	initiator;
+	int	i;
+	int	bus;
+	int	tgt;
+	int	lun = 0;
+	BOOL	have_tgt;
+
+	int fd, ndevs=0;
+  	struct stat statbuf;
+	char *lines[MAXDEVCOUNT];
+	char buf[256], perms[8];
+
+
+	usalp->silent++;
+
+	/* XXX should be done before opening usal fprintf(stderr, "Beginning native device scan. This may take a while if devices are busy...\n"); */
+
+	for (bus = 0; bus < 1256; bus++) {
+		usal_settarget(usalp, bus, 0, 0);
+
+		if (!usal_havebus(usalp, bus))
+			continue;
+
+		initiator = usal_initiator_id(usalp);
+		//fprintf(f, "scsibus%d:\n", bus);
+
+		for (tgt = 0; tgt < 16; tgt++) {
+			usal_settarget(usalp, bus, tgt, lun);
+			have_tgt = unit_ready(usalp) || usalp->scmd->error != SCG_FATAL;
+
+			if (!have_tgt && tgt > 7) {
+				if (usalp->scmd->ux_errno == EINVAL)
+					break;
+				continue;
+			}
+
+			fd=usal_fileno(usalp, bus, tgt, lun);
+			strcpy(perms,"------");
+			if(fd>=0 && 0==fstat(fd, &statbuf)) {
+				if(statbuf.st_mode&S_IRUSR) perms[0]= 'r';
+				if(statbuf.st_mode&S_IWUSR) perms[1]= 'w';
+				if(statbuf.st_mode&S_IRGRP) perms[2]= 'r';
+				if(statbuf.st_mode&S_IWGRP) perms[3]= 'w';
+				if(statbuf.st_mode&S_IROTH) perms[4]= 'r';
+				if(statbuf.st_mode&S_IWOTH) perms[5]= 'w';
+			}
+			getdev(usalp, FALSE);
+			if(usalp->inq->type == INQ_ROMD || usalp->inq->type == INQ_WORM) {
+				char *p;
+
+				for(p=usalp->inq->vendor_info + 7 ; p >= usalp->inq->vendor_info; p--) {
+					if(isspace((unsigned char)*p))
+						*p='\0';
+					else
+						break;
+				}
+				for(p=usalp->inq->prod_ident + 15 ; p >= usalp->inq->prod_ident; p--) {
+					if(isspace((unsigned char)*p))
+						*p='\0';
+					else
+						break;
+				}
+				snprintf(buf, sizeof(buf), "%2d  dev='%s'\t%s : '%.8s' '%.16s'\n", ndevs, usal_natname(usalp, bus, tgt, lun), perms, usalp->inq->vendor_info, usalp->inq->prod_ident);
+				/* alternative use, only select the first device */
+				if(pickup_first) {
+					printf("Using drive: %s\n", usal_natname(usalp, bus, tgt, lun));
+					return 1;
+				}
+				lines[ndevs++]=strdup(buf);
+			}
+
+		}
+	}
+	usalp->silent--;
+
+	/* should have been returned before if there was a recorder */
+	if(pickup_first)
+		return 0;
+
+	/* now start the output */
+
+	fprintf(stdout, "%s: Overview of accessible drives (%d found) :\n"
+			"-------------------------------------------------------------------------\n",
+			get_progname(), ndevs);
+	for(i=0;i<ndevs;i++) {
+		fprintf(stdout, "%s", lines[i]);
+		free(lines[i]);
+	}
+	fprintf(stdout,	"-------------------------------------------------------------------------\n");
+
+	return ndevs;
+}
+
+int select_target(SCSI *usalp, FILE *f) {
+	int	initiator;
+#ifdef	FMT
+	int	cscsibus = usal_scsibus(usalp);
+	int	ctarget  = usal_target(usalp);
+	int	clun	 = usal_lun(usalp);
+#endif
+	int	n;
+	int	low	= -1;
+	int	high	= -1;
+	int	amt	= 0;
+	int	bus;
+	int	tgt;
+	int	lun = 0;
+	BOOL	have_tgt;
+
+	usalp->silent++;
+
+	for (bus = 0; bus < 1256; bus++) {
+		usal_settarget(usalp, bus, 0, 0);
+
+		if (!usal_havebus(usalp, bus))
+			continue;
+
+		initiator = usal_initiator_id(usalp);
+		fprintf(f, "scsibus%d:\n", bus);
+
+		for (tgt = 0; tgt < 16; tgt++) {
+			n = bus*100 + tgt;
+
+			usal_settarget(usalp, bus, tgt, lun);
+			have_tgt = unit_ready(usalp) || usalp->scmd->error != SCG_FATAL;
+
+			if (!have_tgt && tgt > 7) {
+				if (usalp->scmd->ux_errno == EINVAL)
+					break;
+				continue;
+			}
+
+#ifdef	FMT
+			if (print_disknames(bus, tgt, -1) < 8)
+				fprintf(f, "\t");
+			else
+				fprintf(f, " ");
+#else
+			fprintf(f, "\t");
+#endif
+			if (fprintf(f, "%d,%d,%d", bus, tgt, lun) < 8)
+				fprintf(f, "\t");
+			else
+				fprintf(f, " ");
+			fprintf(f, "%3d) ", n);
+			if (tgt == initiator) {
+				fprintf(f, "HOST ADAPTOR\n");
+				continue;
+			}
+			if (!have_tgt) {
+				/*
+				 * Hack: fd -> -2 means no access
+				 */
+				fprintf(f, "%c\n", usalp->fd == -2 ? '?':'*');
+				continue;
+			}
+			amt++;
+			if (low < 0)
+				low = n;
+			high = n;
+
+			getdev(usalp, FALSE);
+			print_product(f, usalp->inq);
+		}
+	}
+	usalp->silent--;
+
+	if (low < 0) {
+		errmsgno(EX_BAD, "No target found.\n");
+		return (0);
+	}
+	n = -1;
+#ifdef	FMT
+	getint("Select target", &n, low, high);
+	bus = n/100;
+	tgt = n%100;
+	usal_settarget(usalp, bus, tgt, lun);
+	return (select_unit(usalp));
+
+	usal_settarget(usalp, cscsibus, ctarget, clun);
+#endif
+	return (amt);
+}
+
diff --git a/wodim/scsi_scan.h b/wodim/scsi_scan.h
new file mode 100644
index 0000000..b1e055b
--- /dev/null
+++ b/wodim/scsi_scan.h
@@ -0,0 +1,44 @@
+/*
+ * 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_scan.h	1.3 01/03/12 Copyright 1997 J. Schilling */
+/*
+ *	Interface to scan SCSI Bus.
+ *
+ *	Copyright (c) 1997 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.
+ */
+
+#ifndef	_SCSI_SCAN_H
+#define	_SCSI_SCAN_H
+
+#include <usal/scsitransp.h>
+
+extern	int	select_target(SCSI *usalp, FILE *f);
+extern int list_devices(SCSI *usalp, FILE *f, int pickup_type);
+extern SCSI * open_auto(int64_t need_size, int debug, int lverbose);
+extern int       scsi_set_streaming(SCSI *usalp, caddr_t addr, int size);
+
+#endif	/* _SCSI_SCAN_H */
diff --git a/wodim/scsimmc.h b/wodim/scsimmc.h
new file mode 100644
index 0000000..a0092fc
--- /dev/null
+++ b/wodim/scsimmc.h
@@ -0,0 +1,593 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)scsimmc.h	1.11 04/03/01 Copyright 1997-2004 J. Schilling */
+/*
+ *	Definitions for SCSI/mmc compliant drives
+ *
+ *	Copyright (c) 1997-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.
+ */
+
+#ifndef	_SCSIMMC_H
+#define	_SCSIMMC_H
+
+#include <utypes.h>
+#include <btorder.h>
+
+typedef struct opc {
+	Uchar	opc_speed[2];
+	Uchar	opc_val[6];
+} opc_t;
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct disk_info {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Ucbit	disk_status	: 2;	/* Status of the disk		*/
+	Ucbit	sess_status	: 2;	/* Status of last session	*/
+	Ucbit	erasable	: 1;	/* Disk is erasable		*/
+	Ucbit	res2		: 3;	/* Reserved			*/
+	Uchar	first_track;		/* # of first track on disk	*/
+	Uchar	numsess;		/* # of sessions		*/
+	Uchar	first_track_ls;		/* First track in last sessaion	*/
+	Uchar	last_track_ls;		/* Last track in last sessaion	*/
+	Ucbit	bg_format_stat	: 2;	/* Background format status	*/
+	Ucbit	dbit		: 1;	/* Dirty Bit of defect table	*/
+	Ucbit	res7_34		: 2;	/* Reserved			*/
+	Ucbit	uru		: 1;	/* This is an unrestricted disk	*/
+	Ucbit	dbc_v		: 1;	/* Disk bar code valid		*/
+	Ucbit	did_v		: 1;	/* Disk id valid		*/
+	Uchar	disk_type;		/* Disk type			*/
+	Uchar	res9[3];		/* Reserved			*/
+	Uchar	disk_id[4];		/* Disk identification		*/
+	Uchar	last_lead_in[4];	/* Last session lead in time	*/
+	Uchar	last_lead_out[4];	/* Last session lead out time	*/
+	Uchar	disk_barcode[8];	/* Disk bar code		*/
+	Uchar	res32;			/* Reserved			*/
+	Uchar	num_opc_entries;	/* # of OPC table entries	*/
+	opc_t	opc_table[1];		/* OPC table 			*/
+};
+
+#else				/* Motorola bitorder */
+
+struct disk_info {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Ucbit	res2		: 3;	/* Reserved			*/
+	Ucbit	erasable	: 1;	/* Disk is erasable		*/
+	Ucbit	sess_status	: 2;	/* Status of last session	*/
+	Ucbit	disk_status	: 2;	/* Status of the disk		*/
+	Uchar	first_track;		/* # of first track on disk	*/
+	Uchar	numsess;		/* # of sessions		*/
+	Uchar	first_track_ls;		/* First track in last sessaion	*/
+	Uchar	last_track_ls;		/* Last track in last sessaion	*/
+	Ucbit	did_v		: 1;	/* Disk id valid		*/
+	Ucbit	dbc_v		: 1;	/* Disk bar code valid		*/
+	Ucbit	uru		: 1;	/* This is an unrestricted disk	*/
+	Ucbit	res7_34		: 2;	/* Reserved			*/
+	Ucbit	dbit		: 1;	/* Dirty Bit of defect table	*/
+	Ucbit	bg_format_stat	: 2;	/* Background format status	*/
+	Uchar	disk_type;		/* Disk type			*/
+	Uchar	res9[3];		/* Reserved			*/
+	Uchar	disk_id[4];		/* Disk identification		*/
+	Uchar	last_lead_in[4];	/* Last session lead in time	*/
+	Uchar	last_lead_out[4];	/* Last session lead out time	*/
+	Uchar	disk_barcode[8];	/* Disk bar code		*/
+	Uchar	res32;			/* Reserved			*/
+	Uchar	num_opc_entries;	/* # of OPC table entries	*/
+	opc_t	opc_table[1];		/* OPC table 			*/
+};
+
+#endif
+
+struct cd_mode_data {
+	struct scsi_mode_header	header;
+	union cd_pagex	{
+		struct cd_mode_page_05	page05;
+		struct cd_mode_page_2A	page2A;
+	} pagex;
+};
+
+struct tocheader {
+	Uchar	len[2];
+	Uchar	first;
+	Uchar	last;
+};
+
+/*
+ * Full TOC entry
+ */
+struct ftrackdesc {
+	Uchar	sess_number;
+
+#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	point;
+	Uchar	amin;
+	Uchar	asec;
+	Uchar	aframe;
+	Uchar	res7;
+	Uchar	pmin;
+	Uchar	psec;
+	Uchar	pframe;
+};
+
+struct fdiskinfo {
+	struct tocheader	hd;
+	struct ftrackdesc	desc[1];
+};
+
+
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct atipdesc {
+	Ucbit	ref_speed	: 3;	/* Reference speed		*/
+	Ucbit	res4_3		: 1;	/* Reserved			*/
+	Ucbit	ind_wr_power	: 3;	/* Indicative tgt writing power	*/
+	Ucbit	res4_7		: 1;	/* Reserved (must be "1")	*/
+	Ucbit	res5_05		: 6;	/* Reserved			*/
+	Ucbit	uru		: 1;	/* Disk is for unrestricted use	*/
+	Ucbit	res5_7		: 1;	/* Reserved (must be "0")	*/
+	Ucbit	a3_v		: 1;	/* A 3 Values valid		*/
+	Ucbit	a2_v		: 1;	/* A 2 Values valid		*/
+	Ucbit	a1_v		: 1;	/* A 1 Values valid		*/
+	Ucbit	sub_type	: 3;	/* Disc sub type		*/
+	Ucbit	erasable	: 1;	/* Disk is erasable		*/
+	Ucbit	res6_7		: 1;	/* Reserved (must be "1")	*/
+	Uchar	lead_in[4];		/* Lead in time			*/
+	Uchar	lead_out[4];		/* Lead out time		*/
+	Uchar	res15;			/* Reserved			*/
+	Ucbit	clv_high	: 4;	/* Highes usable CLV recording speed */
+	Ucbit	clv_low		: 3;	/* Lowest usable CLV recording speed */
+	Ucbit	res16_7		: 1;	/* Reserved (must be "0")	*/
+	Ucbit	res17_0		: 1;	/* Reserved			*/
+	Ucbit	tgt_y_pow	: 3;	/* Tgt y val of the power mod fun */
+	Ucbit	power_mult	: 3;	/* Power multiplication factor	*/
+	Ucbit	res17_7		: 1;	/* Reserved (must be "0")	*/
+	Ucbit	res_18_30	: 4;	/* Reserved			*/
+	Ucbit	rerase_pwr_ratio: 3;	/* Recommended erase/write power*/
+	Ucbit	res18_7		: 1;	/* Reserved (must be "1")	*/
+	Uchar	res19;			/* Reserved			*/
+	Uchar	a2[3];			/* A 2 Values			*/
+	Uchar	res23;			/* Reserved			*/
+	Uchar	a3[3];			/* A 3 Vaules			*/
+	Uchar	res27;			/* Reserved			*/
+};
+
+#else				/* Motorola bitorder */
+
+struct atipdesc {
+	Ucbit	res4_7		: 1;	/* Reserved (must be "1")	*/
+	Ucbit	ind_wr_power	: 3;	/* Indicative tgt writing power	*/
+	Ucbit	res4_3		: 1;	/* Reserved			*/
+	Ucbit	ref_speed	: 3;	/* Reference speed		*/
+	Ucbit	res5_7		: 1;	/* Reserved (must be "0")	*/
+	Ucbit	uru		: 1;	/* Disk is for unrestricted use	*/
+	Ucbit	res5_05		: 6;	/* Reserved			*/
+	Ucbit	res6_7		: 1;	/* Reserved (must be "1")	*/
+	Ucbit	erasable	: 1;	/* Disk is erasable		*/
+	Ucbit	sub_type	: 3;	/* Disc sub type		*/
+	Ucbit	a1_v		: 1;	/* A 1 Values valid		*/
+	Ucbit	a2_v		: 1;	/* A 2 Values valid		*/
+	Ucbit	a3_v		: 1;	/* A 3 Values valid		*/
+	Uchar	lead_in[4];		/* Lead in time			*/
+	Uchar	lead_out[4];		/* Lead out time		*/
+	Uchar	res15;			/* Reserved			*/
+	Ucbit	res16_7		: 1;	/* Reserved (must be "0")	*/
+	Ucbit	clv_low		: 3;	/* Lowest usable CLV recording speed */
+	Ucbit	clv_high	: 4;	/* Highes usable CLV recording speed */
+	Ucbit	res17_7		: 1;	/* Reserved (must be "0")	*/
+	Ucbit	power_mult	: 3;	/* Power multiplication factor	*/
+	Ucbit	tgt_y_pow	: 3;	/* Tgt y val of the power mod fun */
+	Ucbit	res17_0		: 1;	/* Reserved			*/
+	Ucbit	res18_7		: 1;	/* Reserved (must be "1")	*/
+	Ucbit	rerase_pwr_ratio: 3;	/* Recommended erase/write power*/
+	Ucbit	res_18_30	: 4;	/* Reserved			*/
+	Uchar	res19;			/* Reserved			*/
+	Uchar	a2[3];			/* A 2 Values			*/
+	Uchar	res23;			/* Reserved			*/
+	Uchar	a3[3];			/* A 3 Vaules			*/
+	Uchar	res27;			/* Reserved			*/
+};
+
+#endif
+
+struct atipinfo {
+	struct tocheader	hd;
+	struct atipdesc		desc;
+};
+
+/*
+ * XXX Check how we may merge Track_info & Rzone_info
+ */
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct track_info {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	track_number;		/* Track number for this info	*/
+	Uchar	session_number;		/* Session number for this info	*/
+	Uchar	res4;			/* Reserved			*/
+	Ucbit	track_mode	: 4;	/* Track mode (Q-sub control)	*/
+	Ucbit	copy		: 1;	/* This track is a higher copy	*/
+	Ucbit	damage		: 1;	/* if 1 & nwa_valid 0: inc track*/
+	Ucbit	res5_67		: 2;	/* Reserved			*/
+	Ucbit	data_mode	: 4;	/* Data mode of this track	*/
+	Ucbit	fp		: 1;	/* This is a fixed packet track	*/
+	Ucbit	packet		: 1;	/* This track is in packet mode	*/
+	Ucbit	blank		: 1;	/* This is an invisible track	*/
+	Ucbit	rt		: 1;	/* This is a reserved track	*/
+	Ucbit	nwa_valid	: 1;	/* Next writable addr valid	*/
+	Ucbit	res7_17		: 7;	/* Reserved			*/
+	Uchar	track_start[4];		/* Track start address		*/
+	Uchar	next_writable_addr[4];	/* Next writable address	*/
+	Uchar	free_blocks[4];		/* Free usr blocks in this track*/
+	Uchar	packet_size[4];		/* Packet size if in fixed mode	*/
+	Uchar	track_size[4];		/* # of user data blocks in trk	*/
+};
+
+#else				/* Motorola bitorder */
+
+struct track_info {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	track_number;		/* Track number for this info	*/
+	Uchar	session_number;		/* Session number for this info	*/
+	Uchar	res4;			/* Reserved			*/
+	Ucbit	res5_67		: 2;	/* Reserved			*/
+	Ucbit	damage		: 1;	/* if 1 & nwa_valid 0: inc track*/
+	Ucbit	copy		: 1;	/* This track is a higher copy	*/
+	Ucbit	track_mode	: 4;	/* Track mode (Q-sub control)	*/
+	Ucbit	rt		: 1;	/* This is a reserved track	*/
+	Ucbit	blank		: 1;	/* This is an invisible track	*/
+	Ucbit	packet		: 1;	/* This track is in packet mode	*/
+	Ucbit	fp		: 1;	/* This is a fixed packet track	*/
+	Ucbit	data_mode	: 4;	/* Data mode of this track	*/
+	Ucbit	res7_17		: 7;	/* Reserved			*/
+	Ucbit	nwa_valid	: 1;	/* Next writable addr valid	*/
+	Uchar	track_start[4];		/* Track start address		*/
+	Uchar	next_writable_addr[4];	/* Next writable address	*/
+	Uchar	free_blocks[4];		/* Free usr blocks in this track*/
+	Uchar	packet_size[4];		/* Packet size if in fixed mode	*/
+	Uchar	track_size[4];		/* # of user data blocks in trk	*/
+};
+
+#endif
+
+/*
+ * XXX Check how we may merge Track_info & Rzone_info
+ */
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct rzone_info {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	rzone_num_lsb;		/* RZone number LSB		*/
+	Uchar	border_num_lsb;		/* Border number LSB		*/
+	Uchar	res_4;			/* Reserved			*/
+	Ucbit	res5_04		: 5;	/* Reserved			*/
+	Ucbit	damage		: 1;	/* Damaged RZone		*/
+	Ucbit	res5_67		: 2;	/* Reserved			*/
+	Ucbit	res6_04		: 5;	/* Reserved			*/
+	Ucbit	incremental	: 1;	/* RZone is to be written incremental */
+	Ucbit	blank		: 1;	/* RZone is blank		*/
+	Ucbit	rt		: 1;	/* RZone is reserved		*/
+	Ucbit	nwa_v		: 1;	/* Next WR address is valid	*/
+	Ucbit	lra_v		: 1;	/* Last rec address is valid	*/
+	Ucbit	res7_27		: 6;	/* Reserved			*/
+	Uchar	rzone_start[4];		/* RZone start address		*/
+	Uchar	next_recordable_addr[4]; /* Next recordable address	*/
+	Uchar	free_blocks[4];		/* Free blocks in RZone		*/
+	Uchar	block_factor[4];	/* # of sectors of disc acc unit */
+	Uchar	rzone_size[4];		/* RZone size			*/
+	Uchar	last_recorded_addr[4];	/* Last Recorded addr in RZone	*/
+	Uchar	rzone_num_msb;		/* RZone number MSB		*/
+	Uchar	border_num_msb;		/* Border number MSB		*/
+	Uchar	res_34_35[2];		/* Reserved			*/
+};
+
+#else				/* Motorola bitorder */
+
+struct rzone_info {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	rzone_num_lsb;		/* RZone number LSB		*/
+	Uchar	border_num_lsb;		/* Border number LSB		*/
+	Uchar	res_4;			/* Reserved			*/
+	Ucbit	res5_67		: 2;	/* Reserved			*/
+	Ucbit	damage		: 1;	/* Damaged RZone		*/
+	Ucbit	res5_04		: 5;	/* Reserved			*/
+	Ucbit	rt		: 1;	/* RZone is reserved		*/
+	Ucbit	blank		: 1;	/* RZone is blank		*/
+	Ucbit	incremental	: 1;	/* RZone is to be written incremental */
+	Ucbit	res6_04		: 5;	/* Reserved			*/
+	Ucbit	res7_27		: 6;	/* Reserved			*/
+	Ucbit	lra_v		: 1;	/* Last rec address is valid	*/
+	Ucbit	nwa_v		: 1;	/* Next WR address is valid	*/
+	Uchar	rzone_start[4];		/* RZone start address		*/
+	Uchar	next_recordable_addr[4]; /* Next recordable address	*/
+	Uchar	free_blocks[4];		/* Free blocks in RZone		*/
+	Uchar	block_factor[4];	/* # of sectors of disc acc unit */
+	Uchar	rzone_size[4];		/* RZone size			*/
+	Uchar	last_recorded_addr[4];	/* Last Recorded addr in RZone	*/
+	Uchar	rzone_num_msb;		/* RZone number MSB		*/
+	Uchar	border_num_msb;		/* Border number MSB		*/
+	Uchar	res_34_35[2];		/* Reserved			*/
+};
+
+#endif
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct dvd_structure_00 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Ucbit	book_version	: 4;	/* DVD Book version		*/
+	Ucbit	book_type	: 4;	/* DVD Book type		*/
+	Ucbit	minimum_rate	: 4;	/* Minimum data rate (coded)	*/
+	Ucbit	disc_size	: 4;	/* Disc size (coded)		*/
+	Ucbit	layer_type	: 4;	/* Layer type			*/
+	Ucbit	track_path	: 1;	/* 0 = parallel, 1 = opposit dir*/
+	Ucbit	numlayers	: 2;	/* Number of Layers (0 == 1)	*/
+	Ucbit	res2_7		: 1;	/* Reserved			*/
+	Ucbit	track_density	: 4;	/* Track density (coded)	*/
+	Ucbit	linear_density	: 4;	/* Linear data density (coded)	*/
+	Uchar	res8;			/* Reserved			*/
+	Uchar	phys_start[3];		/* Starting Physical sector #	*/
+	Uchar	res12;			/* Reserved			*/
+	Uchar	phys_end[3];		/* End physical data sector #	*/
+	Uchar	res16;			/* Reserved			*/
+	Uchar	end_layer0[3];		/* End sector # in layer	*/
+	Ucbit	res20		: 7;	/* Reserved			*/
+	Ucbit	bca		: 1;	/* BCA flag bit			*/
+};
+
+#else				/* Motorola bitorder */
+
+struct dvd_structure_00 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Ucbit	book_type	: 4;	/* DVD Book type		*/
+	Ucbit	book_version	: 4;	/* DVD Book version		*/
+	Ucbit	disc_size	: 4;	/* Disc size (coded)		*/
+	Ucbit	minimum_rate	: 4;	/* Minimum data rate (coded)	*/
+	Ucbit	res2_7		: 1;	/* Reserved			*/
+	Ucbit	numlayers	: 2;	/* Number of Layers (0 == 1)	*/
+	Ucbit	track_path	: 1;	/* 0 = parallel, 1 = opposit dir*/
+	Ucbit	layer_type	: 4;	/* Layer type			*/
+	Ucbit	linear_density	: 4;	/* Linear data density (coded)	*/
+	Ucbit	track_density	: 4;	/* Track density (coded)	*/
+	Uchar	res8;			/* Reserved			*/
+	Uchar	phys_start[3];		/* Starting Physical sector #	*/
+	Uchar	res12;			/* Reserved			*/
+	Uchar	phys_end[3];		/* End physical data sector #	*/
+	Uchar	res16;			/* Reserved			*/
+	Uchar	end_layer0[3];		/* End sector # in layer	*/
+	Ucbit	bca		: 1;	/* BCA flag bit			*/
+	Ucbit	res20		: 7;	/* Reserved			*/
+};
+
+#endif
+
+struct dvd_structure_01 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	copyr_prot_type;	/* Copyright prot system type	*/
+	Uchar	region_mgt_info;	/* Region management info	*/
+	Uchar	res67[2];		/* Reserved			*/
+};
+
+struct dvd_structure_02 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	key_data[2048];		/* Disc Key data		*/
+};
+
+struct dvd_structure_03 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	bca_info[1];		/* BCA information (12-188 bytes)*/
+};
+
+struct dvd_structure_04 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	man_info[2048];		/* Disc manufacturing info	*/
+};
+
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+
+struct dvd_structure_05 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Ucbit	res4_03		: 4;	/* Reserved			*/
+	Ucbit	cgms		: 2;	/* CGMS (see below)		*/
+	Ucbit	res4_6		: 1;	/* Reserved			*/
+	Ucbit	cpm		: 1;	/* This is copyrighted material	*/
+	Uchar	res57[3];		/* Reserved			*/
+};
+
+#else				/* Motorola bitorder */
+
+struct dvd_structure_05 {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Ucbit	cpm		: 1;	/* This is copyrighted material	*/
+	Ucbit	res4_6		: 1;	/* Reserved			*/
+	Ucbit	cgms		: 2;	/* CGMS (see below)		*/
+	Ucbit	res4_03		: 4;	/* Reserved			*/
+	Uchar	res57[3];		/* Reserved			*/
+};
+
+#endif
+
+#define	CGMS_PERMITTED		0	/* Unlimited copy permitted	*/
+#define	CGMS_RES		1	/* Reserved			*/
+#define	CGMS_ONE_COPY		2	/* One copy permitted		*/
+#define	CGMS_NO_COPY		3	/* No copy permitted		*/
+
+struct dvd_structure_0D {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	last_rma_sector[2];	/* Last recorded RMA sector #	*/
+	Uchar	rmd_bytes[1];		/* Content of Record man area	*/
+};
+
+struct dvd_structure_0E {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	field_id;		/* Field ID (1)			*/
+	Uchar	application_code;	/* Disc Application code	*/
+	Uchar	phys_data;		/* Disc Phisical Data		*/
+	Uchar	last_recordable_addr[3]; /* Last addr of recordable area */
+	Uchar	res_a[2];		/* Reserved			*/
+	Uchar	field_id_2;		/* Field ID (2)			*/
+	Uchar	ind_wr_power;		/* Recommended writing power	*/
+	Uchar	ind_wavelength;		/* Wavelength for ind_wr_power	*/
+	Uchar	opt_wr_strategy[4];	/* Optimum write Strategy	*/
+	Uchar	res_b[1];		/* Reserved			*/
+	Uchar	field_id_3;		/* Field ID (3)			*/
+	Uchar	man_id[6];		/* Manufacturer ID		*/
+	Uchar	res_m1;			/* Reserved			*/
+	Uchar	field_id_4;		/* Field ID (4)			*/
+	Uchar	man_id2[6];		/* Manufacturer ID		*/
+	Uchar	res_m2;			/* Reserved			*/
+};
+
+struct dvd_structure_0F {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	res45[2];		/* Reserved			*/
+	Uchar	random[2];		/* Random number		*/
+	Uchar	year[4];		/* Year (ascii)			*/
+	Uchar	month[2];		/* Month (ascii)		*/
+	Uchar	day[2];			/* Day (ascii)			*/
+	Uchar	hour[2];		/* Hour (ascii)			*/
+	Uchar	minute[2];		/* Minute (ascii)		*/
+	Uchar	second[2];		/* Second (ascii)		*/
+};
+
+struct dvd_structure_0F_w {
+	Uchar	data_len[2];		/* Data len without this info	*/
+	Uchar	res23[2];		/* Reserved			*/
+	Uchar	res45[2];		/* Reserved			*/
+	Uchar	year[4];		/* Year (ascii)			*/
+	Uchar	month[2];		/* Month (ascii)		*/
+	Uchar	day[2];			/* Day (ascii)			*/
+	Uchar	hour[2];		/* Hour (ascii)			*/
+	Uchar	minute[2];		/* Minute (ascii)		*/
+	Uchar	second[2];		/* Second (ascii)		*/
+};
+
+struct mmc_cue {
+	Uchar	cs_ctladr;		/* CTL/ADR for this track	*/
+	Uchar	cs_tno;			/* This track number		*/
+	Uchar	cs_index;		/* Index within this track	*/
+	Uchar	cs_dataform;		/* Data form 			*/
+	Uchar	cs_scms;		/* Serial copy management	*/
+	Uchar	cs_min;			/* Absolute time minutes	*/
+	Uchar	cs_sec;			/* Absolute time seconds	*/
+	Uchar	cs_frame;		/* Absolute time frames		*/
+};
+
+struct mmc_performance_header {
+	Uchar	p_datalen[4];		/* Performance Data length	*/
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+	Ucbit	p_exept		:1;	/* Nominal vs. Exept. conditions*/
+	Ucbit	p_write		:1;	/* Write vs. Read performance	*/
+	Ucbit	p_res_4		:6;	/* Reserved bits...		*/
+#else				/* Motorola bitorder */
+	Ucbit	p_res_4		:6;	/* Reserved bits...		*/
+	Ucbit	p_write		:1;	/* Write vs. Read performance	*/
+	Ucbit	p_exept		:1;	/* Nominal vs. Exept. conditions*/
+#endif
+	Uchar	p_res[3];		/* Reserved bytes		*/
+};
+
+
+struct mmc_performance {		/* Type == 00 (nominal)		*/
+	Uchar	start_lba[4];		/* Starting LBA			*/
+	Uchar	start_perf[4];		/* Start Performance		*/
+	Uchar	end_lba[4];		/* Ending LBA			*/
+	Uchar	end_perf[4];		/* Ending Performance		*/
+};
+
+struct mmc_exceptions {			/* Type == 00 (execptions)	*/
+	Uchar	lba[4];			/* LBA				*/
+	Uchar	time[2];		/* Time				*/
+};
+
+struct mmc_write_speed {		/* Type == 00 (write speed)	*/
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+	Ucbit	p_mrw		:1;	/* Suitable for mixed read/write*/
+	Ucbit	p_exact		:1;	/* Speed count for whole media	*/
+	Ucbit	p_rdd		:1;	/* Media rotational control	*/
+	Ucbit	p_wrc		:2;	/* Write rotational control	*/
+	Ucbit	p_res		:3;	/* Reserved bits...		*/
+#else				/* Motorola bitorder */
+	Ucbit	p_res		:3;	/* Reserved bits...		*/
+	Ucbit	p_wrc		:2;	/* Write rotational control	*/
+	Ucbit	p_rdd		:1;	/* Media rotational control	*/
+	Ucbit	p_exact		:1;	/* Speed count for whole media	*/
+	Ucbit	p_mrw		:1;	/* Suitable for mixed read/write*/
+#endif
+	Uchar	res[3];			/* Reserved Bytes		*/
+	Uchar	end_lba[4];		/* Ending LBA			*/
+	Uchar	read_speed[4];		/* Read Speed			*/
+	Uchar	write_speed[4];		/* Write Speed			*/
+};
+
+#define	WRC_DEF_RC	0		/* Media default rotational control */
+#define	WRC_CAV		1		/* CAV				    */
+
+
+struct mmc_streaming {			/* Performance for set streaming*/
+#if defined(_BIT_FIELDS_LTOH)	/* Intel bitorder */
+	Ucbit	p_ra		:1;	/* Random Acess			*/
+	Ucbit	p_exact		:1;	/* Set values exactly		*/
+	Ucbit	p_rdd		:1;	/* Restore unit defaults	*/
+	Ucbit	p_wrc		:2;	/* Write rotational control	*/
+	Ucbit	p_res		:3;	/* Reserved bits...		*/
+#else				/* Motorola bitorder */
+	Ucbit	p_res		:3;	/* Reserved bits...		*/
+	Ucbit	p_wrc		:2;	/* Write rotational control	*/
+	Ucbit	p_rdd		:1;	/* Restore unit defaults	*/
+	Ucbit	p_exact		:1;	/* Set values exactly		*/
+	Ucbit	p_ra		:1;	/* Random Acess			*/
+#endif
+	Uchar	res[3];			/* Reserved Bytes		*/
+	Uchar	start_lba[4];		/* Starting LBA			*/
+	Uchar	end_lba[4];		/* Ending LBA			*/
+	Uchar	read_size[4];		/* Read Size			*/
+	Uchar	read_time[4];		/* Read Time			*/
+	Uchar	write_size[4];		/* Write Size			*/
+	Uchar	write_time[4];		/* Write Time			*/
+};
+
+#endif	/* _SCSIMMC_H */
diff --git a/wodim/sector.c b/wodim/sector.c
new file mode 100644
index 0000000..2c253d6
--- /dev/null
+++ b/wodim/sector.c
@@ -0,0 +1,263 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)sector.c	1.13 04/03/01 Copyright 2001-2004 J. Schilling */
+/*
+ *	Functions needed to use libedc_ecc from cdrecord
+ *
+ *	Copyright (c) 2001-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <standard.h>
+#include <utypes.h>
+#include <timedefs.h>
+#include <schily.h>
+
+#include "wodim.h"
+#include "movesect.h"
+
+#ifdef	HAVE_LIB_EDC_ECC
+
+
+#define	LAYER2
+#define	EDC_LAYER2
+#define	ENCODER
+#define	EDC_ENCODER
+#include <ecc.h>
+
+#ifdef	DO8
+#define	HAVE_NEW_LIB_EDC
+#endif
+
+int	encspeed(BOOL be_verbose);
+void	encsectors(track_t *trackp, Uchar *bp, int address, int nsecs);
+void	scrsectors(track_t *trackp, Uchar *bp, int address, int nsecs);
+void	encodesector(Uchar *sp, int sectype, int address);
+void	fillsector(Uchar *sp, int sectype, int address);
+
+/*
+ * Sector types known by lib libedc_ecc:
+ */
+#ifdef	__comment__
+				/*   MMC					*/
+#define	MODE_0		0	/* -> XX  12+4+2336	(12+4uuu von libedc)	*/
+#define	MODE_1		1	/* -> 8   12+4+2048+288 (124+4uuu+288 von libedc)*/
+#define	MODE_2		2	/* -> 9	  12+4+2336	(12+4uuu von libedc)	*/
+#define	MODE_2_FORM_1	3	/* -> 10/11 12+4+8+2048+280 (12+4hhhuuu+280 von libedc)*/
+#define	MODE_2_FORM_2	4	/* -> 12 (eher 13!) 12+4+8+2324+4 (12+4hhhuuu+4 von libedc)*/
+#define	AUDIO		5
+#define	UNKNOWN		6
+#endif
+
+/*
+ * known sector types
+ */
+#ifndef	EDC_MODE_0
+#define	EDC_MODE_0	MODE_0
+#endif
+#ifndef	EDC_MODE_1
+#define	EDC_MODE_1	MODE_1
+#endif
+#ifndef	EDC_MODE_2
+#define	EDC_MODE_2	MODE_2
+#endif
+#ifndef	EDC_MODE_2_FORM_1
+#define	EDC_MODE_2_FORM_1	MODE_2_FORM_1
+#endif
+#ifndef	EDC_MODE_2_FORM_2
+#define	EDC_MODE_2_FORM_2	MODE_2_FORM_2
+#endif
+#ifndef	EDC_AUDIO
+#define	EDC_AUDIO	AUDIO
+#endif
+#ifndef	EDC_UNKNOWN
+#define	EDC_UNKNOWN	UNKNOWN
+#endif
+
+/*
+ * Compute max sector encoding speed
+ */
+int
+encspeed(BOOL be_verbose)
+{
+	track_t	t[1];
+	Uchar	sect[2352];
+	int	i;
+	struct	timeval tv;
+	struct	timeval tv2;
+
+	t[0].sectype = ST_MODE_1;
+
+	/*
+	 * Encoding speed is content dependant.
+	 * Set up a known non-null pattern in the sector before; to make
+	 * the result of this test independant of the current stack content.
+	 */
+	for (i = 0; i < 2352; ) {
+		sect[i++] = 'J';
+		sect[i++] = 'S';
+	}
+	gettimeofday(&tv, (struct timezone *)0);
+	for (i = 0; i < 75000; i++) {		/* Goes up to 1000x */
+		encsectors(t, sect, 12345, 1);
+		gettimeofday(&tv2, (struct timezone *)0);
+		if (tv2.tv_sec >= (tv.tv_sec+1) &&
+		    tv2.tv_usec >= tv.tv_usec)
+			break;
+	}
+	if (be_verbose) {
+		printf("Encoding speed : %dx (%d sectors/s) for libedc from Heiko Eißfeldt\n",
+				(i+74)/75, i);
+	}
+	return ((i+74)/75);
+}
+
+/*
+ * Encode sectors according to trackp->sectype
+ */
+void
+encsectors(track_t *trackp, Uchar *bp, int address, int nsecs)
+{
+	int	sectype = trackp->sectype;
+
+	if ((sectype & ST_MODE_MASK) == ST_MODE_AUDIO)
+		return;
+
+	while (--nsecs >= 0) {
+		encodesector(bp, sectype, address);
+		address++;
+		bp += trackp->secsize;
+	}
+}
+
+
+#ifdef	CLONE_WRITE
+
+#define	IS_SECHDR(p)	((p)[0] == 0 &&				\
+			(p)[1] == 0xFF && (p)[2] == 0xFF &&	\
+			(p)[3] == 0xFF && (p)[4] == 0xFF &&	\
+			(p)[5] == 0xFF && (p)[6] == 0xFF &&	\
+			(p)[7] == 0xFF && (p)[8] == 0xFF &&	\
+			(p)[9] == 0xFF && (p)[10] == 0xFF &&	\
+			(p)[11] == 0)
+/*
+ * Scramble data sectors without coding (needed for clone writing)
+ */
+void
+scrsectors(track_t *trackp, Uchar *bp, int address, int nsecs)
+{
+	/*
+	 * In Clone write mode, we cannot expect that the sector type
+	 * of a "track" which really is a file holding the whole disk
+	 * is flagged with something that makes sense.
+	 *
+	 * For this reason, we check each sector if it's a data sector
+	 * and needs scrambling.
+	 */
+	while (--nsecs >= 0) {
+		if (IS_SECHDR(bp))
+			scramble_L2(bp);
+		bp += trackp->secsize;
+	}
+}
+#else
+void
+scrsectors(track_t *trackp, Uchar *bp, int address, int nsecs)
+{
+	comerrno(EX_BAD, "Cannot write in clone RAW mode.\n");
+}
+#endif
+
+/*
+ * Encode one sector according to trackp->sectype
+ */
+void
+encodesector(Uchar *sp, int sectype, int address)
+{
+	if (address < -150)
+		address += 450150;
+	else
+		address += 150;
+#define	_address address
+
+
+	switch (sectype & ST_MODE_MASK) {
+
+	case	ST_MODE_0:
+		do_encode_L2(sp, EDC_MODE_0, _address);
+		break;
+
+	case	ST_MODE_1:
+		do_encode_L2(sp, EDC_MODE_1, _address);
+		break;
+
+	case	ST_MODE_2:
+		do_encode_L2(sp, EDC_MODE_2, _address);
+		break;
+
+	case	ST_MODE_2_FORM_1:
+		sp[16+2]   &= ~0x20;	/* Form 1 sector */
+		sp[16+4+2] &= ~0x20;	/* Form 1 sector 2nd copy */
+		/* FALLTHROUGH */
+
+	case	ST_MODE_2_MIXED:
+		do_encode_L2(sp, EDC_MODE_2_FORM_1, _address);
+		break;
+
+	case	ST_MODE_2_FORM_2:
+		sp[16+2]   |= 0x20;	/* Form 2 sector */
+		sp[16+4+2] |= 0x20;	/* Form 2 sector 2nd copy */
+
+		do_encode_L2(sp, EDC_MODE_2_FORM_2, _address);
+		break;
+
+	case	ST_MODE_AUDIO:
+		return;
+	default:
+		fill2352(sp, '\0');
+		return;
+	}
+	if ((sectype & ST_NOSCRAMBLE) == 0) {
+		scramble_L2(sp);
+#ifndef	EDC_SCRAMBLE_NOSWAP
+		swabbytes(sp, 2352);
+#endif
+	}
+}
+
+/*
+ * Create one zero filles encoded sector (according to trackp->sectype)
+ */
+void
+fillsector(Uchar *sp, int sectype, int address)
+{
+	fill2352(sp, '\0');
+	encodesector(sp, sectype, address);
+}
+
+#endif	/* HAVE_LIB_EDC_ECC */
diff --git a/wodim/subchan.c b/wodim/subchan.c
new file mode 100644
index 0000000..7195992
--- /dev/null
+++ b/wodim/subchan.c
@@ -0,0 +1,997 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)subchan.c	1.20 05/06/11 Copyright 2000-2004 J. Schilling */
+/*
+ *	Subchannel processing
+ *
+ *	Copyright (c) 2000-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <utypes.h>
+#include <schily.h>
+
+#include <usal/scsitransp.h>
+
+#include "wodim.h"
+#include "crc16.h"
+
+int	do_leadin(track_t *trackp);
+int	write_leadin(SCSI *usalp, cdr_t *dp, track_t *trackp, int leadinstart);
+int	write_leadout(SCSI *usalp, cdr_t *dp, track_t *trackp);
+void	fillsubch(track_t *trackp, Uchar *sp, int secno, int nsecs);
+void	filltpoint(Uchar *sub, int ctrl_adr, int point, msf_t *mp);
+void	fillttime(Uchar *sub, msf_t *mp);
+static	void	filldsubq(Uchar *sub, int ca, int t, int i, msf_t *mrp, 
+								 msf_t *mp);
+static	void	fillmcn(Uchar *sub, Uchar *mcn);
+static	void	fillisrc(Uchar *sub, Uchar *isrc);
+static	int	ascii2q(int c);
+static	void	qpto16(Uchar *sub, Uchar *subq, int dop);
+void	qpto96(Uchar *sub, Uchar *subq, int dop);
+void	addrw(Uchar *sub, Uchar	*subrwptr);
+void	qwto16(Uchar *subq, Uchar *subptr);
+void	subrecodesecs(track_t *trackp, Uchar *bp, int address, int nsecs);
+static	void	subinterleave(Uchar *sub);
+
+/*#define	TEST_CRC*/
+#ifdef	TEST_CRC
+static	void	testcrc(void);
+#endif
+
+/*Die 96 Bits == 12 Bytes haben folgendes Aussehen:*/
+
+struct q {
+	Uchar ctrl_adr;	/*  0 (ctrl << 4) | adr		 */
+	Uchar track;	/*  1 current track #		 */
+	Uchar index;	/*  2 current index #		 */
+	Uchar pmin;	/*  3 Relative time minutes part */
+	Uchar psec;	/*  4 Relative time seconds part */
+	Uchar pframe;	/*  5 Relative time frames part  */
+	Uchar zero;	/*  6 */
+	Uchar amin;	/*  7 Absolute time minutes part */
+	Uchar asec;	/*  8 Absolute time seconds part */
+	Uchar aframe;	/*  9 Absolute time frames part  */
+	Uchar crc1;	/* 10	all bits inverted. Polynom is	*/
+	Uchar crc2;	/* 11	X^16 + X^12 + X^5 + 1		*/
+};
+
+Uchar	_subq[110][12];
+int	_nsubh;
+
+extern	int	lverbose;
+extern	int	xdebug;
+
+/*
+ * Prepare master sunchannel data for RAW TOC.
+ */
+int
+do_leadin(track_t *trackp)
+{
+	int	tracks = trackp->tracks;
+	msf_t	m;
+	int	ctrl;
+	int	i;
+	int	toctype = trackp[0].tracktype & TOC_MASK;
+
+	if (_nsubh) {
+		if (xdebug)
+			printf("Using CLONE TOC....\n");
+		return (0);
+	}
+	if (xdebug)
+		printf("Leadin TOC Type: %d\n", trackp[0].tracktype & TOC_MASK);
+	if (lverbose > 1) {
+		for (i = 1; i <= tracks+1; i++)
+			printf("Track %d start %ld\n", i, trackp[i].trackstart);
+	}
+
+#ifdef	TEST_CRC
+	testcrc();
+/*	exit(1);*/
+#endif
+
+	fillbytes(_subq, sizeof (_subq), '\0');
+
+	/*
+	 * Fill in point 0xA0 for first track # on disk
+	 */
+	ctrl = (st2mode[trackp[0].sectype & ST_MASK]) << 4;
+	if (is_copy(&trackp[0]))
+		ctrl |= TM_ALLOW_COPY << 4;
+	m.msf_min = trackp[1].trackno;
+	/*
+	 * Disk Type: 0 = AUDIO/DATA, 0x10 = CDI, 0x20 = XA mode 2
+	 */
+	m.msf_sec = toc2sess[toctype & TOC_MASK];
+	m.msf_sec = from_bcd(m.msf_sec);		/* convert to BCD */
+	m.msf_frame = 0;
+	filltpoint(_subq[0], ctrl|0x01, 0xA0, &m);
+	if (lverbose > 2)
+		usal_prbytes("", _subq[0], 12);
+
+	/*
+	 * Fill in point 0xA1 for last track # on disk
+	 */
+	ctrl = (st2mode[trackp[tracks].sectype & ST_MASK]) << 4;
+	if (is_copy(&trackp[tracks]))
+		ctrl |= TM_ALLOW_COPY << 4;
+	m.msf_min = trackp[tracks].trackno;
+	m.msf_sec = 0;
+	m.msf_frame = 0;
+	filltpoint(_subq[1], ctrl|0x01, 0xA1, &m);
+	if (lverbose > 2)
+		usal_prbytes("", _subq[1], 12);
+
+	/*
+	 * Fill in point 0xA2 for lead out start time on disk
+	 */
+	lba_to_msf(trackp[tracks+1].trackstart, &m);
+	ctrl = (st2mode[trackp[tracks].sectype & ST_MASK]) << 4;
+	if (is_copy(&trackp[tracks]))
+		ctrl |= TM_ALLOW_COPY << 4;
+	filltpoint(_subq[2], ctrl|0x01, 0xA2, &m);
+	if (lverbose > 2)
+		usal_prbytes("", _subq[2], 12);
+
+	/*
+	 * Fill in track start times.
+	 */
+	for (i = 1; i <= tracks; i++) {
+		lba_to_msf(trackp[i].trackstart, &m);
+		ctrl = (st2mode[trackp[i].sectype & ST_MASK]) << 4;
+		if (is_copy(&trackp[i]))
+			ctrl |= TM_ALLOW_COPY << 4;
+		filltpoint(_subq[i-1+3], ctrl|0x01, to_bcd(trackp[i].trackno), &m);	/* track n */
+		if (lverbose > 2)
+			usal_prbytes("", _subq[i-1+3], 12);
+	}
+	return (0);
+}
+
+/*
+ * Write TOC (lead-in)
+ *
+ * Use previously prepared master subchannel data to create the
+ * subchannel frames for the lead-in.
+ */
+int
+write_leadin(SCSI *usalp, cdr_t *dp, track_t *trackp, int leadinstart)
+{
+	msf_t	m;
+	int	i;
+	Uint	j;
+	Uchar	*bp = usalp->bufptr;
+	Uchar	*subp;
+	Uchar	*sp;
+	int	secsize;
+	int	secspt;
+	int	bytespt;
+	long	amount;
+	int	startsec;
+	long	bytes = 0L;
+	int	textoff = 0;
+	msf_t	msf;
+
+	secsize = trackp[0].secsize;
+	secspt = trackp[0].secspt;
+	bytespt = secspt * secsize;
+
+	lba_to_msf(leadinstart, &msf);
+
+	fillbytes(bp, bytespt, '\0');
+
+	if (_nsubh) {
+		if (xdebug)
+			printf("Using CLONE LEADIN\n");
+	}
+	if (xdebug) {
+		printf("Leadinstart: %d %d:%d/%d",
+			leadinstart,
+			msf.msf_min, msf.msf_sec, msf.msf_frame);
+		printf(" FLAGS: 0x%X sect: %X RAW16:%d secs: %d spt: %d\n",
+			trackp[0].flags, trackp[0].sectype,
+			is_raw16(&trackp[0]), secsize, secspt);
+	}
+
+	startsec = leadinstart;
+	sp = bp;
+	subp = bp + 2352;
+	for (i = leadinstart, j = 0; i < -150; i++, j++) {
+		/*
+		 * TOC hat folgende unterschiedliche Sub Q Frames:
+		 * A0		First Track
+		 * A1		Last Track
+		 * A3		Lead out start
+		 * 1..99	Tracks
+		 * ==	3 + N* tracks
+		 * Jeder Frame wird 3x wiederholt.
+		 */
+		if (_nsubh) {
+			if (j >= (3*_nsubh))
+				j = 0;
+		} else {
+			if (j >= (3*3 + 3*trackp->tracks))
+				j = 0;
+		}
+		lba_to_msf((long)i, &m);
+		fillttime(_subq[j/3], &m);
+		fillcrc(_subq[j/3], 12);
+		if (xdebug > 2)
+			usal_prbytes("", _subq[j/3], 12);
+		if (is_raw16(&trackp[0])) {
+			qpto16(subp, _subq[j/3], 0);
+		} else {
+			extern Uchar *textsub;
+			extern int  textlen;
+
+			qpto96(subp, _subq[j/3], 0);
+			if (textsub) {
+				addrw(subp, &textsub[textoff]);
+				textoff += 96;
+				if (textoff >= textlen)
+					textoff = 0;
+			}
+/*			if (is_raw96p(&trackp[0]))*/
+/*				subinterleave(subp);*/
+		}
+		if ((startsec+secspt-1) == i || i == -151) {
+			if ((i-startsec+1) < secspt) {
+				secspt = i-startsec+1;
+				bytespt = secspt * secsize;
+			}
+			encsectors(trackp, bp, startsec, secspt);
+
+			amount = write_secs(usalp, dp,
+					(char *)bp, startsec, bytespt, secspt, FALSE);
+			if (amount < 0) {
+				printf("write leadin data: error after %ld bytes\n",
+							bytes);
+				return (-1);
+			}
+			bytes += amount;
+			startsec = i+1;
+			sp = bp;
+			subp = bp + 2352;
+			continue;
+		}
+		sp += secsize;
+		subp += secsize;
+	}
+	return (0);
+}
+
+/*
+ * Write Track 0xAA (lead-out)
+ */
+int
+write_leadout(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	tracks = trackp->tracks;
+	msf_t	m;
+	msf_t	mr;
+	int	ctrl;
+	int	i;
+	int	j;
+	Uchar	*bp = usalp->bufptr;
+	Uchar	*subp;
+	Uchar	*sp;
+	int	secsize;
+	int	secspt;
+	int	bytespt;
+	long	amount;
+	long	startsec;
+	long	endsec;
+	long	bytes = 0L;
+	int	leadoutstart;
+	Uchar	sub[12];
+	BOOL	p;
+	msf_t	msf;
+
+	fillbytes(sub, 12, '\0');
+
+	secsize = trackp[tracks+1].secsize;
+	secspt = trackp[tracks+1].secspt;
+	bytespt = secspt * secsize;
+
+	leadoutstart = trackp[tracks+1].trackstart;
+	lba_to_msf(leadoutstart, &msf);
+
+	fillbytes(bp, bytespt, '\0');
+
+	if (xdebug) {
+		printf("Leadoutstart: %d %d:%d/%d amt %ld",
+			leadoutstart,
+			msf.msf_min, msf.msf_sec, msf.msf_frame,
+			trackp[tracks+1].tracksecs);
+		printf(" FLAGS: 0x%X sect: %X RAW16:%d secs: %d spt: %d\n",
+			trackp[tracks+1].flags, trackp[tracks+1].sectype,
+			is_raw16(&trackp[tracks+1]), secsize, secspt);
+	}
+
+	startsec = leadoutstart;
+	endsec = startsec + trackp[tracks+1].tracksecs;
+	sp = bp;
+	subp = bp + 2352;
+	ctrl = (st2mode[trackp->sectype & ST_MASK]) << 4;
+	if (is_copy(trackp))
+		ctrl |= TM_ALLOW_COPY << 4;
+
+	for (i = leadoutstart, j = 0; i < endsec; i++, j++) {
+
+		lba_to_msf((long)i, &m);
+		sec_to_msf((long)j, &mr);
+		filldsubq(sub, ctrl|0x01, 0xAA, 1, &mr, &m);
+		sub[1] = 0xAA;
+		fillcrc(sub, 12);
+		p = (j % 150) < 75;
+		if (j < 150)
+			p = FALSE;
+		if (xdebug > 2)
+			usal_prbytes(p?"P":" ", sub, 12);
+
+		if (is_raw16(&trackp[0])) {
+			qpto16(subp, sub, p);
+		} else {
+			qpto96(subp, sub, p);
+/*			if (is_raw96p(&trackp[0]))*/
+/*				subinterleave(subp);*/
+		}
+		if ((startsec+secspt-1) == i || i == (endsec-1)) {
+			if ((i-startsec+1) < secspt) {
+				secspt = i-startsec+1;
+				bytespt = secspt * secsize;
+			}
+			encsectors(trackp, bp, startsec, secspt);
+
+			amount = write_secs(usalp, dp,
+					(char *)bp, startsec, bytespt, secspt, FALSE);
+			if (amount < 0) {
+				printf("write leadout data: error after %ld bytes\n",
+							bytes);
+				return (-1);
+			}
+			bytes += amount;
+			startsec = i+1;
+			sp = bp;
+			subp = bp + 2352;
+			continue;
+		}
+		sp += secsize;
+		subp += secsize;
+	}
+	return (0);
+}
+
+/*
+ * Fill in subchannel data.
+ *
+ * This function is used to prepare the sub channels when writing
+ * the data part of a CD (bewteen lead-in and lead-out).
+ */
+void
+fillsubch(track_t *trackp, 
+          Uchar *sp /* Sector data pointer  */, 
+          int secno /* Starting sector #    */, 
+          int nsecs /* # of sectors to fill */)
+{
+	msf_t	m;
+	msf_t	mr;
+	int	ctrl;
+	int	i;
+	int	rsecno;
+	int	end;
+	int	secsize = trackp->secsize;
+	int	trackno = trackp->trackno;
+	int	nindex = trackp->nindex;
+	int	curindex;
+	long	*tindex = NULL;
+	long	nextindex = 0L;
+	Uchar	sub[12];
+	Uchar	*sup;
+	char	*mcn;
+	/*
+	 * In theory this should make fillsubch() non-reenrtrant but it seems
+	 * that the probability check at the beginning of the function is
+	 * sufficient to make it work as expected.
+	 */
+static	long	nextmcn = -1000000L;
+static	long	nextisrc = -1000000L;
+static	Uchar	lastindex = 255;
+
+	fillbytes(sub, 12, '\0');
+
+	mcn = track_base(trackp)->isrc;
+	rsecno = secno - trackp->trackstart;
+	if ((secno + nsecs) > (trackp->trackstart + trackp->tracksecs)) {
+		comerrno(EX_BAD, "Implementation botch: track boundary in buffer.\n");
+	}
+	sup = sp + 2352;
+	if (mcn && (nextmcn < secno || nextmcn > (secno+100))) {
+		nextmcn = secno/100*100 + 99;
+	}
+	if (trackp->isrc && (nextisrc < secno || nextisrc > (secno+100))) {
+		nextisrc = secno/100*100 + 49;
+	}
+	ctrl = (st2mode[trackp->sectype & ST_MASK]) << 4;
+	if (is_copy(trackp))
+		ctrl |= TM_ALLOW_COPY << 4;
+
+#ifdef	SUB_DEBUG
+	fprintf(stderr, "Tracknl %d nindex %d trackstart %ld rsecno %d index0start %ld nsecs %d\n",
+	trackno, nindex, trackp->trackstart, rsecno, trackp->index0start, nsecs);
+#endif
+
+	if (rsecno < 0) {
+		/*
+		 * Called to manually write pregap null data into the pregap
+		 * while 'trackp' points to the curent track. For this reason,
+		 * the sectors are before the start of track 'n' index 0.
+		 */
+		curindex = 0;
+		end = trackp->trackstart;
+
+	} else if (rsecno > trackp->index0start) {
+		/*
+		 * This track contains pregap of next track.
+		 * We currently are inside this pregap.
+		 */
+		trackno++;
+		curindex = 0;
+		end = trackp->trackstart + trackp->tracksecs;
+	} else {
+		/*
+		 * We are inside the normal data part of this track.
+		 * This is index_1...index_m for track n.
+		 * Set 'end' to 0 in this case although it is only used
+		 * if 'index' is 0. But GCC gives a warning that 'end'
+		 * might be uninitialized.
+		 */
+		end = 0;
+		curindex = 1;
+		if (nindex > 1) {
+			tindex = trackp->tindex;
+			nextindex = trackp->tracksecs;
+			/*
+			 * find current index in list
+			 */
+			for (curindex = nindex; curindex >= 1; curindex--) {
+				if (rsecno >= tindex[curindex]) {
+					if (curindex < nindex)
+						nextindex = tindex[curindex+1];
+					break;
+				}
+			}
+		}
+	}
+
+	for (i = 0; i < nsecs; i++) {
+
+		if (tindex != NULL && rsecno >= nextindex) {
+			/*
+			 * Skip to next index in list.
+			 */
+			if (curindex < nindex) {
+				curindex++;
+				nextindex = tindex[curindex+1];
+			}
+		}
+		if (rsecno == trackp->index0start) {
+			/*
+			 * This track contains pregap of next track.
+			 */
+			trackno++;
+			curindex = 0;
+			end = trackp->trackstart + trackp->tracksecs;
+		}
+		lba_to_msf((long)secno, &m);
+		if (curindex == 0)
+			sec_to_msf((long)end-1 - secno, &mr);
+		else
+			sec_to_msf((long)rsecno, &mr);
+		if (is_scms(trackp)) {
+			if ((secno % 8) <= 3) {
+				ctrl &= ~(TM_ALLOW_COPY << 4);
+			} else {
+				ctrl |= TM_ALLOW_COPY << 4;
+			}
+		}
+		filldsubq(sub, ctrl|0x01, trackno, curindex, &mr, &m);
+		if (mcn && (secno == nextmcn)) {
+			if (curindex == lastindex) {
+				fillmcn(sub, (Uchar *)mcn);
+				nextmcn = (secno+1)/100*100 + 99;
+			} else {
+				nextmcn++;
+			}
+		}
+		if (trackp->isrc && (secno == nextisrc)) {
+			if (curindex == lastindex) {
+				fillisrc(sub, (Uchar *)trackp->isrc);
+				nextisrc = (secno+1)/100*100 + 49;
+			} else {
+				nextisrc++;
+			}
+		}
+		fillcrc(sub, 12);
+		if (xdebug > 2)
+			usal_prbytes(curindex == 0 ? "P":" ", sub, 12);
+		if (is_raw16(trackp)) {
+			qpto16(sup, sub, curindex == 0);
+		} else {
+			qpto96(sup, sub, curindex == 0);
+/*			if (is_raw96p(trackp))*/
+/*				subinterleave(sup);*/
+		}
+		lastindex = curindex;
+		secno++;
+		rsecno++;
+		sup += secsize;
+	}
+}
+
+
+/*
+ * Fill TOC Point
+ * Ax Werte einfüllen.
+ */
+void
+filltpoint(Uchar *sub, int ctrl_adr, int point, msf_t *mp)
+{
+	sub[0] = ctrl_adr;
+	sub[2] = point;
+	sub[7] = to_bcd(mp->msf_min);
+	sub[8] = to_bcd(mp->msf_sec);
+	sub[9] = to_bcd(mp->msf_frame);
+}
+
+/*
+ * Fill TOC time
+ * Aktuelle Zeit in TOC Sub-Q einfüllen.
+ */
+void
+fillttime(Uchar *sub, msf_t *mp)
+{
+	sub[3] = to_bcd(mp->msf_min);
+	sub[4] = to_bcd(mp->msf_sec);
+	sub[5] = to_bcd(mp->msf_frame);
+}
+
+/*
+ * Q-Sub in Datenbereich füllen.
+ */
+static void
+filldsubq(Uchar *sub, int ca, int t, int i, msf_t *mrp, msf_t *mp)
+{
+	sub[0] = ca;
+	sub[1] = to_bcd(t);
+	sub[2] = to_bcd(i);
+	sub[3] = to_bcd(mrp->msf_min);
+	sub[4] = to_bcd(mrp->msf_sec);
+	sub[5] = to_bcd(mrp->msf_frame);
+
+	sub[7] = to_bcd(mp->msf_min);
+	sub[8] = to_bcd(mp->msf_sec);
+	sub[9] = to_bcd(mp->msf_frame);
+}
+
+/*
+ * Fill MCN
+ * MCN konvertieren und in Sub-Q einfüllen.
+ */
+static void
+fillmcn(Uchar *sub, Uchar *mcn)
+{
+	register int	i;
+	register int	c;
+
+	sub[0] = ADR_MCN;
+	for (i = 1; i <= 8; i++) {
+		c = *mcn++;
+		if (c >= '0' && c <= '9')
+			sub[i] = (c - '0') << 4;
+		else
+			sub[i] = 0;
+
+		if (c != '\0')
+			c = *mcn++;
+		if (c >= '0' && c <= '9')
+			sub[i] |= (c - '0');
+
+		if (c == '\0') {
+			i++;
+			break;
+		}
+	}
+	for (; i <= 8; i++)
+		sub[i] = '\0';
+}
+
+/*
+ * Fill ISRC
+ * ISRC konvertieren und in Sub-Q einfüllen.
+ */
+static void
+fillisrc(Uchar *sub, Uchar *isrc)
+{
+	register int	i;
+	register int	j;
+	Uchar		tmp[13];
+	Uchar		*sp;
+
+	sub[0] = ADR_ISRC;
+	sp = &sub[1];
+
+	/*
+	 * Convert into Sub-Q character coding
+	 */
+	for (i = 0, j = 0; i < 12; i++) {
+		if (isrc[i+j] == '-')
+			j++;
+		if (isrc[i+j] == '\0')
+			break;
+		tmp[i] = ascii2q(isrc[i+j]);
+	}
+	for (; i < 13; i++)
+		tmp[i] = '\0';
+
+	/*
+	 * The first 5 chars from e.g. "FI-BAR-99-00312"
+	 */
+	sp[0]  = tmp[0] << 2;
+	sp[0] |= (tmp[1] >> 4) & 0x03;
+	sp[1]  = (tmp[1] << 4) & 0xF0;
+	sp[1] |= (tmp[2] >> 2) & 0x0F;
+	sp[2]  = (tmp[2] << 6) & 0xC0;
+	sp[2] |= tmp[3] & 0x3F;
+	sp[3]  = tmp[4] << 2;
+
+	/*
+	 * Now 7 digits from e.g. "FI-BAR-99-00312"
+	 */
+	for (i = 4, j = 5; i < 8; i++) {
+		sp[i]  = tmp[j++] << 4;
+		sp[i] |= tmp[j++];
+	}
+}
+
+/*
+ * ASCII -> Sub-Q ISRC code conversion
+ */
+static int
+ascii2q(int c)
+{
+	if (c >= '0' && c <= '9')
+		return (c - '0');
+	else if (c >= '@' && c <= 'o')
+		return (0x10 + c - '@');
+	return (0);
+}
+
+/*
+ * Q-Sub auf 16 Bytes blähen und P-Sub addieren
+ *
+ * OUT: sub, IN: subqptr
+ */
+static void
+qpto16(Uchar *sub, Uchar *subqptr, int dop)
+{
+	if (sub != subqptr)
+		movebytes(subqptr, sub, 12);
+	sub[12] = '\0';
+	sub[13] = '\0';
+	sub[14] = '\0';
+	sub[15] = '\0';
+	if (dop)
+		sub[15] |= 0x80;
+
+}
+
+/*
+ * Q-Sub auf 96 Bytes blähen und P-Sub addieren
+ *
+ * OUT: sub, IN: subqptr
+ */
+void
+qpto96(Uchar *sub, Uchar *subqptr, int dop)
+{
+	Uchar	tmp[16];
+	Uchar	*p;
+	int	c;
+	int	i;
+
+	if (subqptr == sub) {
+		/*
+		 * Remember 12 byte subchannel data if subchannel
+		 * is overlapping.
+		 */
+		movebytes(subqptr, tmp, 12);
+		subqptr = tmp;
+	}
+	/*
+	 * Clear all subchannel bits in the 96 byte target space.
+	 */
+	fillbytes(sub, 96, '\0');
+
+	/* BEGIN CSTYLED */
+	if (dop) for (i = 0, p = sub; i < 96; i++) {
+		*p++ |= 0x80;
+	}
+	for (i = 0, p = sub; i < 12; i++) {
+		c = subqptr[i] & 0xFF;
+/*printf("%02X\n", c);*/
+		if (c & 0x80)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x40)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x20)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x10)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x08)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x04)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x02)
+			*p++ |= 0x40;
+		else
+			p++;
+		if (c & 0x01)
+			*p++ |= 0x40;
+		else
+			p++;
+	}
+}
+
+/*
+ * Add R-W-Sub (96 Bytes) to P-Q-Sub (96 Bytes)
+ *
+ * OUT: sub, IN: subrwptr
+ */
+void
+addrw(register Uchar *sub, register Uchar *subrwptr)
+{
+	register int	i;
+
+#define	DO8(a)	a; a; a; a; a; a; a; a;
+
+	for (i = 0; i < 12; i++) {
+		DO8(*sub++ |= *subrwptr++ & 0x3F);
+	}
+}
+
+/*
+ * Q-W-Sub (96 Bytes) auf 16 Bytes schrumpfen
+ *
+ * OUT: subq, IN: subptr
+ */
+void
+qwto16(Uchar *subq, Uchar *subptr)
+{
+	register int	i;
+	register int	np = 0;
+	register Uchar	*p;
+		Uchar	tmp[96];
+
+	p = subptr;
+	for (i = 0; i < 96; i++)
+		if (*p++ & 0x80)
+			np++;
+	p = subptr;
+	if (subptr == subq) {
+		/*
+		 * Remember 96 byte subchannel data if subchannel
+		 * is overlapping.
+		 */
+		movebytes(subptr, tmp, 96);
+		p = tmp;
+	}
+
+	for (i = 0; i < 12; i++) {
+		subq[i] = 0;
+		if (*p++ & 0x40)
+			subq[i] |= 0x80;
+		if (*p++ & 0x40)
+			subq[i] |= 0x40;
+		if (*p++ & 0x40)
+			subq[i] |= 0x20;
+		if (*p++ & 0x40)
+			subq[i] |= 0x10;
+		if (*p++ & 0x40)
+			subq[i] |= 0x08;
+		if (*p++ & 0x40)
+			subq[i] |= 0x04;
+		if (*p++ & 0x40)
+			subq[i] |= 0x02;
+		if (*p++ & 0x40)
+			subq[i] |= 0x01;
+	}
+	subq[12] = 0;
+	subq[13] = 0;
+	subq[14] = 0;
+	if (np > (96/2))
+		subq[15] = 0x80;
+}
+
+/*
+ * Recode subchannels of sectors from 2352 + 96 bytes to 2352 + 16 bytes
+ */
+void
+subrecodesecs(track_t *trackp, Uchar *bp, int address, int nsecs)
+{
+	bp += 2352;
+	while (--nsecs >= 0) {
+		qwto16(bp, bp);
+		bp += trackp->isecsize;
+	}
+}
+
+#ifndef	HAVE_LIB_EDC_ECC
+void
+encsectors(track_t *trackp, Uchar *bp, int address, int nsecs)
+{
+	int	sectype = trackp->sectype;
+
+	if ((sectype & ST_MODE_MASK) == ST_MODE_AUDIO)
+		return;
+
+	comerrno(EX_BAD, "Can only write audio sectors in RAW mode.\n");
+}
+
+void
+scrsectors(track_t *trackp, Uchar *bp, int address, int nsecs)
+{
+	comerrno(EX_BAD, "Cannot write in clone RAW mode.\n");
+}
+#endif
+
+/*--------------------------------------------------------------------------*/
+#ifdef	TEST_CRC
+
+Uchar	tq[12] = { 0x01, 0x00, 0xA0, 0x98, 0x06, 0x12, 0x00, 0x01, 0x00, 0x00, 0xE3, 0x74 };
+
+/*
+01 00 A0 98 06 12 00 01 00 00 E3 74
+01 00 A0 98 06 13 00 01 00 00 49 25
+01 00 A1 98 06 14 00 13 00 00 44 21
+01 00 A1 98 06 15 00 13 00 00 EE 70
+01 00 A1 98 06 16 00 13 00 00 00 A2
+01 00 A2 98 06 17 00 70 40 73 E3 85
+01 00 A2 98 06 18 00 70 40 73 86 7C
+01 00 A2 98 06 19 00 70 40 73 2C 2D
+01 00 01 98 06 20 00 00 02 00 3B 71
+01 00 01 98 06 21 00 00 02 00 91 20
+01 00 01 98 06 22 00 00 02 00 7F F2
+01 00 02 98 06 23 00 03 48 45 BE E0
+01 00 02 98 06 24 00 03 48 45 D9 34
+
+*/
+
+static	int	b(int bcd);
+
+
+static int
+b(int bcd)
+{
+	return ((bcd & 0x0F) + 10 * (((bcd)>> 4) & 0x0F));
+}
+
+static void
+testcrc()
+{
+	struct q q;
+	int	ocrc;
+	int	crc1;
+	int	crc2;
+
+	movebytes(&tq, &q, 12);
+	crc1 = q.crc1 & 0xFF;
+	crc2 = q.crc2 & 0xFF;
+
+	/*
+	 * Per RED Book, CRC Bits on disk are inverted.
+	 * Invert them again to make calcCRC() work.
+	 */
+	q.crc1 ^= 0xFF;
+	q.crc2 ^= 0xFF;
+
+	ocrc = calcCRC((Uchar *)&q, 12);
+	printf("AC: %02X t: %3d (%02X) i: %3d (%02X) %d:%d:%d %d:%d:%d %02X%02X %X (%X)\n",
+		q.ctrl_adr,
+		b(q.track),
+		b(q.track) & 0xFF,
+		b(q.index),
+		q.index & 0xFF,
+		b(q.pmin),
+		b(q.psec),
+		b(q.pframe),
+		b(q.amin),
+		b(q.asec),
+		b(q.aframe),
+		crc1, crc2,
+		ocrc,
+		fillcrc((Uchar *)&q, 12) & 0xFFFF);
+}
+#endif	/* TEST_CRC */
+
+#ifdef	sss
+96 / 24 = 4
+
+index 1 < - > 18
+index 2 < - > 5
+index 3 < - > 23
+
+delay index mod 8
+#endif
+
+/*
+ * Sub 96 Bytes Interleave
+ */
+static void
+subinterleave(Uchar *sub)
+{
+	Uchar	*p;
+	int	i;
+
+	for (i = 0, p = sub; i < 4; i++) {
+		Uchar	save;
+
+		/*
+		 * index 1 < - > 18
+		 * index 2 < - > 5
+		 * index 3 < - > 23
+		 */
+		save  = p[1];
+		p[1]  = p[18];
+		p[18] = save;
+
+		save  = p[2];
+		p[2]  = p[5];
+		p[5]  = save;
+
+		save  = p[3];
+		p[3]  = p[23];
+		p[23] = save;
+
+		p += 24;
+	}
+}
diff --git a/wodim/wm_packet.c b/wodim/wm_packet.c
new file mode 100644
index 0000000..9566a52
--- /dev/null
+++ b/wodim/wm_packet.c
@@ -0,0 +1,306 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)wm_packet.c	1.25 04/03/01 Copyright 1995, 1997, 2001-2004 J. Schilling */
+/*
+ *	CDR write method abtraction layer
+ *	packet writing intercace routines
+ *
+ *	Copyright (c) 1995, 1997, 2001-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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <timedefs.h>
+#include <standard.h>
+#include <utypes.h>
+#include <schily.h>
+
+#include <usal/scsitransp.h>
+#include "wodim.h"
+#include "xio.h"
+
+extern	int	debug;
+extern	int	verbose;
+extern	int	lverbose;
+
+extern	char	*buf;			/* The transfer buffer */
+
+int	write_packet_data(SCSI *usalp, cdr_t *dp, track_t *trackp);
+
+int
+write_packet_data(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	track = trackp->trackno;
+	int	f = -1;
+	int	isaudio;
+	long	startsec;
+	Llong	bytes_read = 0;
+	Llong	bytes	= 0;
+	Llong	savbytes = 0;
+	int	count;
+	Llong	tracksize;
+	int	secsize;
+	int	secspt;
+	int	bytespt;
+	long	amount;
+	int	pad;
+	int	retried;
+	long	nextblock;
+	int	bytes_to_read;
+	BOOL	neednl	= FALSE;
+	BOOL	islast	= FALSE;
+	char	*bp	= buf;
+	struct timeval tlast;
+	struct timeval tcur;
+	float	secsps = 75.0;
+long bsize;
+long bfree;
+#define	BCAP
+#ifdef	BCAP
+int per;
+#ifdef	XBCAP
+int oper = -1;
+#endif
+#endif
+
+	if (dp->cdr_dstat->ds_flags & DSF_DVD)
+		secsps = 676.27;
+
+	usalp->silent++;
+	if ((*dp->cdr_buffer_cap)(usalp, &bsize, &bfree) < 0)
+		bsize = -1L;
+	if (bsize == 0)		/* If we have no (known) buffer, we cannot */
+		bsize = -1L;	/* retrieve the buffer fill ratio	   */
+	else
+		dp->cdr_dstat->ds_buflow = 0;
+	usalp->silent--;
+
+	if (trackp->xfp != NULL)
+		f = xfileno(trackp->xfp);
+
+	isaudio = is_audio(trackp);
+	tracksize = trackp->tracksize;
+	startsec = trackp->trackstart;
+
+	secsize = trackp->secsize;
+	secspt = trackp->secspt;
+	bytespt = secsize * secspt;
+
+	pad = !isaudio && is_pad(trackp);	/* Pad only data tracks */
+
+	if (debug) {
+		printf("secsize:%d secspt:%d bytespt:%d audio:%d pad:%d\n",
+			secsize, secspt, bytespt, isaudio, pad);
+	}
+
+	if (lverbose) {
+		if (tracksize > 0)
+			printf("\rTrack %02d:    0 of %4lld MB written.",
+				track, tracksize >> 20);
+		else
+			printf("\rTrack %02d:    0 MB written.", track);
+		flush();
+		neednl = TRUE;
+	}
+
+	gettimeofday(&tlast, (struct timezone *)0);
+	do {
+		bytes_to_read = bytespt;
+		if (tracksize > 0) {
+			if ((tracksize - bytes_read) > bytespt)
+				bytes_to_read = bytespt;
+			else
+				bytes_to_read = tracksize - bytes_read;
+		}
+					/* XXX next wr addr ??? */
+		count = get_buf(f, trackp, startsec, &bp, bytes_to_read);
+		if (count < 0)
+			comerr("read error on input file\n");
+		if (count == 0)
+			break;
+		bytes_read += count;
+		if (tracksize >= 0 && bytes_read >= tracksize) {
+			count -= bytes_read - tracksize;
+			if (trackp->padsecs == 0 || (bytes_read/secsize) >= 300)
+				islast = TRUE;
+		}
+
+		if (count < bytespt) {
+			if (debug) {
+				printf("\nNOTICE: reducing block size for last record.\n");
+				neednl = FALSE;
+			}
+
+			if ((amount = count % secsize) != 0) {
+				amount = secsize - amount;
+				fillbytes(&bp[count], amount, '\0');
+				count += amount;
+				printf("\nWARNING: padding up to secsize.\n");
+				neednl = FALSE;
+			}
+			if (is_packet(trackp) && trackp->pktsize > 0) {
+				if (count < bytespt) {
+					amount = bytespt - count;
+					count += amount;
+					printf("\nWARNING: padding remainder of packet.\n");
+					neednl = FALSE;
+				}
+			}
+			bytespt = count;
+			secspt = count / secsize;
+			if (trackp->padsecs == 0 || (bytes_read/secsize) >= 300)
+				islast = TRUE;
+		}
+
+		retried = 0;
+		retry:
+		/* XXX Fixed-packet writes can be very slow*/
+		if (is_packet(trackp) && trackp->pktsize > 0)
+			usal_settimeout(usalp, 100);
+		/* XXX */
+		if (is_packet(trackp) && trackp->pktsize == 0) {
+			if ((*dp->cdr_next_wr_address)(usalp, trackp, &nextblock) == 0) {
+				/*
+				 * Some drives (e.g. Ricoh MPS6201S) do not
+				 * increment the Next Writable Address value to
+				 * point to the beginning of a new packet if
+				 * their write buffer has underflowed.
+				 */
+				if (retried && nextblock == startsec) {
+					startsec += 7;
+				} else {
+					startsec = nextblock;
+				}
+			}
+		}
+
+		amount =  write_secs(usalp, dp, bp, startsec, bytespt, secspt, islast);
+		if (amount < 0) {
+			if (is_packet(trackp) && trackp->pktsize == 0 && !retried) {
+				printf("%swrite track data: error after %lld bytes, retry with new packet\n",
+					neednl?"\n":"", bytes);
+				retried = 1;
+				neednl = FALSE;
+				goto retry;
+			}
+			printf("%swrite track data: error after %lld bytes\n",
+							neednl?"\n":"", bytes);
+			return (-1);
+		}
+		bytes += amount;
+		startsec += amount / secsize;
+
+		if (lverbose && (bytes >= (savbytes + 0x100000))) {
+			int	fper;
+			int	nsecs = (bytes - savbytes) / secsize;
+			float	fspeed;
+
+			gettimeofday(&tcur, (struct timezone *)0);
+			printf("\rTrack %02d: %4lld", track, bytes >> 20);
+			if (tracksize > 0)
+				printf(" of %4lld MB", tracksize >> 20);
+			else
+				printf(" MB");
+			printf(" written");
+			fper = fifo_percent(TRUE);
+			if (fper >= 0)
+				printf(" (fifo %3d%%)", fper);
+#ifdef	BCAP
+			if (bsize > 0) {			/* buffer size known */
+				usalp->silent++;
+				per = (*dp->cdr_buffer_cap)(usalp, (long *)0, &bfree);
+				usalp->silent--;
+				if (per >= 0) {
+					per = 100*(bsize - bfree) / bsize;
+					if (per < 5)
+						dp->cdr_dstat->ds_buflow++;
+					if (per < (int)dp->cdr_dstat->ds_minbuf &&
+					    (startsec*secsize) > bsize) {
+						dp->cdr_dstat->ds_minbuf = per;
+					}
+					printf(" [buf %3d%%]", per);
+#ifdef	BCAPDBG
+					printf(" %3ld %3ld", bsize >> 10, bfree >> 10);
+#endif
+				}
+			}
+#endif
+
+			tlast.tv_sec = tcur.tv_sec - tlast.tv_sec;
+			tlast.tv_usec = tcur.tv_usec - tlast.tv_usec;
+			while (tlast.tv_usec < 0) {
+				tlast.tv_usec += 1000000;
+				tlast.tv_sec -= 1;
+			}
+			fspeed = (nsecs / secsps) /
+				(tlast.tv_sec * 1.0 + tlast.tv_usec * 0.000001);
+			if (fspeed > 999.0)
+				fspeed = 999.0;
+			printf(" %5.1fx", fspeed);
+			printf(".");
+			savbytes = (bytes >> 20) << 20;
+			flush();
+			neednl = TRUE;
+			tlast = tcur;
+		}
+	} while (tracksize < 0 || bytes_read < tracksize);
+
+	if ((bytes / secsize) < 300) {
+		if ((trackp->padsecs + (bytes / secsize)) < 300)
+			trackp->padsecs = 300 - (bytes / secsize);
+	}
+	if (trackp->padsecs > 0) {
+		Llong	padbytes;
+
+		/*
+		 * pad_track() is based on secsize. Compute the amount of bytes
+		 * assumed by pad_track().
+		 */
+		padbytes = (Llong)trackp->padsecs * secsize;
+
+		if (neednl) {
+			printf("\n");
+			neednl = FALSE;
+		}
+		if ((padbytes >> 20) > 0) {
+			neednl = TRUE;
+		} else if (lverbose) {
+			printf("Track %02d: writing %3lld KB of pad data.\n",
+						track, (Llong)(padbytes >> 10));
+			neednl = FALSE;
+		}
+		pad_track(usalp, dp, trackp, startsec, padbytes,
+					TRUE, &savbytes);
+		bytes += savbytes;
+		startsec += savbytes / secsize;
+	}
+	printf("%sTrack %02d: Total bytes read/written: %lld/%lld (%lld sectors).\n",
+		neednl?"\n":"", track, bytes_read, bytes, bytes/secsize);
+	return (0);
+}
diff --git a/wodim/wm_session.c b/wodim/wm_session.c
new file mode 100644
index 0000000..0505f9c
--- /dev/null
+++ b/wodim/wm_session.c
@@ -0,0 +1,51 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)wm_session.c	1.4 02/07/07 Copyright 1995, 1997 J. Schilling */
+/*
+ *	CDR write method abtraction layer
+ *	session at once / disk at once writing intercace routines
+ *
+ *	Copyright (c) 1995, 1997 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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <utypes.h>
+
+#include <usal/scsitransp.h>
+#include "wodim.h"
+
+extern	int	debug;
+extern	int	verbose;
+extern	int	lverbose;
+
+extern	char	*buf;			/* The transfer buffer */
+
+int	write_session_data(SCSI *usalp, cdr_t *dp, track_t *trackp);
diff --git a/wodim/wm_track.c b/wodim/wm_track.c
new file mode 100644
index 0000000..a3f9196
--- /dev/null
+++ b/wodim/wm_track.c
@@ -0,0 +1,50 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)wm_track.c	1.4 04/03/02 Copyright 1995, 1997, 2004 J. Schilling */
+/*
+ *	CDR write method abtraction layer
+ *	track at once writing intercace routines
+ *
+ *	Copyright (c) 1995, 1997, 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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <stdxlib.h>
+#include <unixstd.h>
+#include <standard.h>
+#include <utypes.h>
+
+#include "wodim.h"
+
+extern	int	debug;
+extern	int	verbose;
+extern	int	lverbose;
+
+extern	char	*buf;			/* The transfer buffer */
+
+int	write_track_data(cdr_t *dp, int track, track_t *trackp);
diff --git a/wodim/wodim.1 b/wodim/wodim.1
new file mode 100644
index 0000000..53e777c
--- /dev/null
+++ b/wodim/wodim.1
@@ -0,0 +1,2369 @@
+.\" @(#)wodim.1	 06/12/18 Copyright 2006 Cdrkit maintainers
+.\" derived from:
+.\" @(#)cdrecord.1	1.106 06/02/09 Copyright 1996 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.
+.\"
+.\" The GNU General Public License's references to "object code"
+.\" and "executables" are to be interpreted as the output of any
+.\" document formatting or typesetting system, including
+.\" intermediate and printed output.
+.\"
+.\" This manual 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.
+.\"
+.if t .ds a \v'-0.55m'\h'0.00n'\z.\h'0.40n'\z.\v'0.55m'\h'-0.40n'a
+.if t .ds o \v'-0.55m'\h'0.00n'\z.\h'0.45n'\z.\v'0.55m'\h'-0.45n'o
+.if t .ds u \v'-0.55m'\h'0.00n'\z.\h'0.40n'\z.\v'0.55m'\h'-0.40n'u
+.if t .ds A \v'-0.77m'\h'0.25n'\z.\h'0.45n'\z.\v'0.77m'\h'-0.70n'A
+.if t .ds O \v'-0.77m'\h'0.25n'\z.\h'0.45n'\z.\v'0.77m'\h'-0.70n'O
+.if t .ds U \v'-0.77m'\h'0.30n'\z.\h'0.45n'\z.\v'0.77m'\h'-0.75n'U
+.if t .ds s \\(*b
+.if t .ds S SS
+.if n .ds a ae
+.if n .ds o oe
+.if n .ds u ue
+.if n .ds s sz
+.if t .ds m \\(*m
+.if n .ds m micro
+.TH wodim 1 "Version 2.0" "" ""
+.SH NAME
+wodim \- write data to optical disk media
+.SH SYNOPSIS
+.B wodim
+.RI [ options "] " track1 .\|.\|. trackn
+.SH NOTE
+There may be similarities and differences between this program and other disk recording application(s). See the
+.B CREDITS
+and
+.B AUTHORS
+sections below to learn about the origin of
+.B wodim.
+
+.SH DESCRIPTION
+.B wodim
+is used to record data or audio Compact Discs on an Orange Book
+CD-Recorder or to write DVD media on a DVD-Recorder.
+.PP
+The
+.I device
+is the device file or label offered by the operating system to access the
+recorder with SCSI GENERIC (sg) interface. Note that some operating systems may
+provide separate device nodes for block\-oriented and sg access. For example, on
+older
+.I Linux
+systems, the sg access was available through
+.IR /dev/sg...
+files while the block oriented access was done through associated (but not identical)
+.IR /dev/hd...
+and 
+.IR /dev/sr...
+(or 
+.IR /dev/scd...
+) files.
+.PP
+In any case, the user running 
+.B wodim
+needs read and write access to the particular device file on a Linux system. It
+is recommended to be root or install the application as suid-root, because
+certain versions of Linux (kernel) limit the set of SCSI commands allowed for
+non-root users. Even if usage without root identity is possible in many cases,
+some device drivers still may fail, show unexplainable problems and generally
+the problems become harder to debug. The risk for buffer-underruns is also
+increased. See the
+.IR "PROCESS SCHEDULING PRIORITY"
+section below for more details.
+.PP
+There is an alternative way of specifying the device, using the traditional SCSI descriptions in form of
+.IR devicetype:bus/target/lun
+specification. However, the success of this method is not guaranteed since it
+requires an adaptation scheme for your architecture, and the numbers may vary
+depending on the hardware-internal numbering or on the order of hot-plug device
+detection. If your operating system does not provide a sufficient framework for
+keeping this numbers persistent, don't rely on them. See 
+.B \-scanbus
+and
+.B \-\-devices
+options below for details.
+.PP
+There are emulated SCSI compatible device systems, using the SCSI protocols
+transported over various hardware/media types. The most known examples is ATAPI
+("IDE burners") or USB storage ("external USB case"). If the pseudo-SCSI b/t/l
+device address specification is used instead of the native one, you need to
+prepend the "devicetype:" description to the emulated "bus/target/lun" device
+address.
+.PP
+If a file /etc/wodim.conf exists, the parameter to the
+.B dev=
+option may also be a drive name label in that file (see FILES section).
+.PP
+As a special exception, the device specification can be
+.IR -1
+or just omitted, which invokes automatic guessing of an appropriate device for
+the selected operation. However, this guessing is not available everywhere and
+is not reliable; it is only available for the user's convenience in simple
+environments.
+.PP
+In 
+.I Track At Once 
+mode, each
+.I track
+corresponds to a single file that contains the prepared data for that track.
+If the argument is 
+.RB ` \- ',
+standard input is used for that track. 
+Only one track may be taken from 
+.IR stdin .
+In the other write modes, the direct file to track relation may not be implemented.
+In 
+.B \-clone
+mode, a single file contains all data for the whole disk.
+To allow DVD writing on platforms that do not implement large file support,
+.B wodim
+concatenates all file arguments to a single track when writing to DVD media.
+
+.SH "PROCESS SCHEDULING PRIORITY"
+.PP
+Wodim tries to get higher process priority using different methods. This is
+important because the burn process is usually a realtime task, no long delays
+should occur while transmitting fresh data to the recorder. This is especially
+important on systems with insufficient RAM where swapping can create delays of
+many seconds.
+.PP
+A possible workaround on underpowered systems is the use of the burnfree or
+similar feature, allowing the recorder to resume.
+.PP
+Root permissions are usually required to get higher process scheduling priority.
+.PP
+On 
+.B SVr4 
+compliant systems, 
+.B wodim 
+uses the real time class to get the highest scheduling priority that is
+possible (higher than all kernel processes).
+On systems with 
+.B POSIX real time scheduling
+wodim uses real time scheduling too, 
+but may not be able to gain a priority that is higher than all kernel processes.
+.PP
+In order to be able to use the SCSI transport subsystem of the OS, run at highest
+priority and lock itself into core
+.B
+wodim
+either needs to be run as root, needs to be installed suid root or
+must be called via
+.B RBACs
+pfexec mechanism.
+
+.SH "GENERAL OPTIONS
+.PP
+General options must be before any track file name or track option.
+.TP
+.B \-version
+Print version information and exit.
+.TP
+.B \-v
+Increment the level of general verbosity by one.
+This is used e.g. to display the progress of the writing process.
+.TP
+.B \-V
+Increment the verbose level in respect of SCSI command transport by one.
+This helps to debug problems
+during the writing process, that occur in the CD/DVD-Recorder. 
+If you get incomprehensible error messages you should use this flag
+to get more detailed output.
+.B \-VV
+will show data buffer content in addition.
+Using
+.B \-V
+or
+.B \-VV
+slows down the process and may be the reason for a buffer underrun.
+.TP
+.BI debug= "#, " -d
+Set the misc debug value to # (with debug=#) or increment
+the misc debug level by one (with -d). If you specify
+.I -dd,
+this equals to 
+.BI debug= 2.
+This may help to find problems while opening a driver for libusal
+as well as with sector sizes and sector types.
+Using
+.B \-debug
+slows down the process and may be the reason for a buffer underrun.
+.TP
+.BR kdebug= "#, " kd= #
+Tell the 
+.BR usal -driver
+to modify the kernel debug value while SCSI commands are running.
+.TP
+.BR \-silent ", " \-s
+Do not print out a status report for failed SCSI commands.
+.TP
+.B \-force
+Force to continue on some errors. Be careful when using this option.
+.B wodim
+implements several checks that prevent you from doing unwanted things
+like damaging CD-RW media by improper drives. Many of the sanity checks are 
+disabled when the 
+.B \-force
+option is used.
+.sp
+This option also implements some tricks that will allow 
+you to blank bad CD-RW disks.
+.TP
+.B \-immed
+Tell wodim to set the
+.B "SCSI IMMED"
+flag in certain commands
+(load/eject/blank/close_track/close_session).
+This can be useful
+on broken systems with ATAPI harddisk and CD/DVD writer on the same bus or
+with SCSI systems that don't use disconnect/reconnect.
+These systems will freeze while blanking or fixating a CD/DVD or while a DVD
+writer is filling up a session to the minimum amount (approx. 800 MB).
+Setting the
+.B \-immed
+flag will request the command to return immediately
+while the operation proceeds in background, making
+the bus usable for the other devices and avoiding the system freeze.
+This is an experimental feature which may work or not, depending on the model
+of the CD/DVD writer.
+A correct solution would be to set up a correct cabling but there seem to be 
+notebooks around that have been set up the wrong way by the manufacturer.
+As it is impossible to fix this problem in notebooks, the
+.B \-immed
+option has been added.
+.sp
+A second experimental feature of the
+.B \-immed
+flag is to tell wodim to try to wait short times while writing to the
+media. This is expected to free the IDE bus if the CD/DVD writer and the
+data source are connected to the same IDE cable. In this case, the CD/DVD
+writer would otherwise usually block the IDE bus for nearly all the time
+making it impossible to fetch data from the source drive. See also
+.B minbuf=
+and
+.B \-v
+option.
+.sp
+Use both features at your own risk.
+If it turns out that it would make sense to have a separate option
+for the wait feature, write to the author and convince him.
+.TP
+.BI minbuf= value
+The #
+.B minbuf=
+option allows to define the minimum drive buffer fill ratio for the
+experimental ATAPI wait mode that is intended to free the IDE bus
+to allow hard disk and CD/DVD writer to be on the same IDE cable.
+As the wait mode currently only works when the verbose option
+.B \-v
+has been specified, 
+.B wodim
+implies the verbose option in case the 
+.B \-immed
+or
+.B minbuf=
+option have been specified.
+Valid values for 
+.B minbuf= 
+are between 25 and 95 for 25%.\|.\|.95% minimum drive buffer fill ratio.
+.TP
+.B \-dummy
+The CD/DVD-Recorder will go through all steps of the recording process,
+but the laser is turned off during this procedure.
+It is recommended to run several tests before actually writing to a 
+Compact Disk or Digital Versatile Disk,
+if the timing and load response of the system is not known.
+.TP
+.B \-clone
+Tells 
+.B wodim
+to handle images created by
+.IR "readom \-clone" .
+The
+.B \-clone
+may only be used in conjunction with with the
+.B \-raw96r
+or with the
+.B \-raw16
+option.
+Using
+.B \-clone
+together with
+.B \-raw96r
+is preferred as it allows to write all subchannel data.
+The option
+.B \-raw16
+should only be used with drives that do not support to write in
+.B \-raw96r
+mode.
+.TP
+.B \-dao
+.TP
+.B \-sao
+Set 
+.B "SAO (Session At Once)
+mode which is usually called
+.BR "Disk At Once " mode.
+This currently only works with MMC drives that support
+.B "Session At Once
+mode.
+Note that wodim needs to know the size of each track in advance for this mode
+(see the
+.B "genisoimage \-print-size"
+option and the 
+.I EXAMPLES
+section for more information).
+.TP
+.B \-tao
+Set
+.B "TAO (Track At Once) writing mode.
+This is the default write mode in previous
+.B wodim
+versions.
+With most drives, this write mode is required for multi session recording.
+.TP
+.B \-raw
+Set
+.B "RAW writing mode.
+Using this option defaults to 
+.BR \-raw96r .
+Note that wodim needs to know the size of each track in advance for this mode
+(see the
+.B "genisoimage \-print-size"
+option and the 
+.I EXAMPLES
+section for more information).
+.TP
+.B \-raw96r
+Select
+Set
+.B "RAW writing mode
+with 2352 byte sectors plus 96 bytes of raw P-W subchannel data resulting
+in a sector size of 2448 bytes.
+This is the preferred raw writing mode as it gives best control over the
+CD writing process.
+If you find any problems with the layout of a disk or with sub channel 
+content (e.g. wrong times on the display when playing the CD) and your drive
+supports to write in 
+.B \-raw96r
+or
+.B \-raw16
+mode, you should give it a try. There are several CD writers with bad firmware
+that result in broken disks when writing in TAO or SAO mode.
+Writing data disks in raw mode needs significantly more CPU time than other
+write modes. If your CPU is too slow, this may result in buffer underruns.
+Note that wodim needs to know the size of each track in advance for this mode
+(see the
+.B "genisoimage \-print-size"
+option and the 
+.I EXAMPLES
+section for more information).
+.TP
+.B \-raw96p
+Select
+Set
+.B "RAW writing mode
+with 2352 byte sectors plus 96 bytes of packed P-W subchannel data resulting
+in a sector size of 2448 bytes.
+This is the less preferred raw writing mode as only a few recorders support
+it and some of these recorders have bugs in the firmware implementation.
+Don't use this mode if your recorder supports
+.B \-raw96r
+or
+.BR \-raw16 .
+Writing data disks in raw mode needs significantly more CPU time than other
+write modes. If your CPU is too slow, this may result in buffer underruns.
+Note that wodim needs to know the size of each track in advance for this mode
+(see the
+.B "genisoimage \-print-size"
+option and the 
+.I EXAMPLES
+section for more information).
+.TP
+.B \-raw16
+Select
+Set
+.B "RAW writing mode
+with 2352 byte sectors plus 16 bytes of P-Q subchannel data resulting
+in a sector size of 2368 bytes.
+If a recorder does not support 
+.BR \-raw96r ,
+this is the preferred raw writing mode.
+It does not allow to write
+.I CD-Text
+or
+.I CD+Graphics
+but it is the only raw writing mode in cheap CD writers.
+As these cheap writers in most cases do not support
+.B \-dao
+mode.
+Don't use this mode if your recorder supports
+.BR \-raw96r .
+Writing data disks in raw mode needs significantly more CPU time than other
+write modes. If your CPU is too slow, this may result in buffer underruns.
+Note that wodim needs to know the size of each track in advance for this mode
+(see the
+.B "genisoimage \-print-size"
+option and the 
+.I EXAMPLES
+section for more information).
+.TP
+.B \-multi
+Allow multi session CDs to be made. This flag needs to be present
+on all sessions of a multi session disk,
+except you want to create a session that will be 
+the last session on the media.
+The fixation will be done in a way that allows the CD/DVD-Recorder to
+append additional sessions later. This is done by generation a TOC
+with a link to the next program area. The so generated media is not
+100% compatible to manufactured CDs (except for CDplus). 
+Use only for recording of multi session CDs.
+If this option is present, the default track type is
+.BR "CD-ROM XA mode 2 form 1"
+and the sector size is 2048 bytes. 
+The XA sector subheaders will be created by the drive. 
+The 
+.I Sony 
+drives have no hardware support for 
+.BR "CD-ROM XA mode 2 form 1" .
+You have to specify the 
+.B \-data 
+option in order to create multi session disks on these drives.
+As long as wodim does not have a coder for converting data sectors
+to audio sectors, you need to force 
+.B CD-ROM
+sectors by including the
+.B \-data
+option if you like to record a multisession disk in SAO mode.
+Not all drives allow multisession CDs in SAO mode.
+.TP
+.B \-msinfo
+Retrieve multi session info in a form suitable for 
+.B genisoimage
+and print it to standard output. See
+.B msifile=
+option for another version.
+.sp
+This option makes only sense with a CD that contains at least
+one closed session and is appendable (not finally closed yet). 
+Some drives create error messages if you try to get the multi 
+session info for a disk that is not suitable for this operation.
+.TP
+.BR msifile= filename
+Like 
+.B \-msinfo
+option but also stores the multi session info in a file.
+.TP
+.B \-toc
+Retrieve and print out the table of content or PMA of a CD.
+With this option, 
+.B wodim
+will work with CD-R drives and with CD-ROM drives.
+.TP
+.B \-atip
+Retrieve and print out the ATIP (absolute Time in Pre-groove) info of a CD/DVD
+recordable or CD/DVD re-writable media.
+With this option, 
+.B wodim
+will try to retrieve the ATIP info. If the actual drive does not support
+to read the ATIP info, it may be that only a reduced set of information
+records or even nothing is displayed. Only a limited number of MMC compliant
+drives support to read the ATIP info.
+.sp
+If 
+.B wodim
+is able to retrieve the lead-in start time for the first session, it will try to
+decode and print the manufacturer info from the media.
+DVD media does not have ATIP information but there is equivalent prerecorded
+information that is read out and printed.
+.TP
+.B \-fix
+The disk will only be fixated (i.e. a TOC for a CD-Reader will be written). 
+This may be used, if for some reason the disk has been written but not
+fixated. This option currently does not work with old TEAC drives (CD-R50S and
+CD-R55S).
+.TP
+.B \-nofix
+Do not fixate the disk after writing the tracks. This may be used
+to create an audio disk in steps. An un-fixated disk can usually not be used
+on a non CD-writer type drive but there are audio CD players that will
+be able to play such a disk.
+.TP
+.B \-waiti
+Wait for input to become available on standard input before trying to open
+the SCSI driver. This allows 
+.B wodim
+to read its input from a pipe even
+when writing additional sessions to a multi session disk.
+When writing another session to a multi session disk,
+.B genisoimage 
+needs to read the old session from the device before writing output.
+This cannot be done if
+.B wodim 
+opens the SCSI driver at the same time.
+.TP
+.B \-load
+Load the media and exit. This only works with a tray loading mechanism
+but seems to be useful when using the Kodak disk transporter.
+.TP
+.B \-lock
+Load the media, lock the door and exit. This only works with a tray loading mechanism
+but seems to be useful when using the Kodak disk transporter.
+.TP
+.B \-eject
+Eject disk after doing the work.
+Some devices (e.g. Philips) need to eject the medium before creating a new
+disk. Doing a \-dummy test and immediately creating a real disk would not
+work on these devices.
+.TP
+.BR speed= #
+Set the speed factor of the writing process to #.
+# is an integer, representing a multiple of the audio speed.
+This is about 150\ KB/s for CD-ROM, about 172\ KB/s for CD-Audio and about 1385\ kB/s
+for DVD media.
+If no 
+.I speed
+option is present,
+.B wodim
+will try to get a drive specific speed value from the file
+.B /etc/wodim.conf
+and if it cannot find one, it will try to get the speed value from the
+.B CDR_SPEED
+environment and later from the 
+.B CDR_SPEED=
+entry in
+.BR /etc/wodim.conf .
+If no speed value could be found, wodim uses a drive specific default speed.
+The default for all new (MMC compliant) drives is to use the maximum supported by the drive.
+If you use 
+.I "speed=0"
+with a MMC compliant drive,
+.B wodim
+will switch to the lowest possible speed for drive and medium.
+If you are using an old (non MMC) drive that has problems with
+.I "speed=2 
+or 
+.IR "speed=4" , 
+you should try 
+.IR "speed=0" .
+.TP
+.BI blank= type
+Blank a CD-RW and exit or blank a CD-RW before writing. The blanking type may be one of:
+.RS
+.TP 12
+help
+Display a list of possible blanking types.
+.TP
+all
+Blank the entire disk. This may take a long time.
+.TP
+fast
+Minimally blank the disk. This results in erasing the PMA, the TOC and the pregap.
+.TP
+track
+Blank a track.
+.TP
+unreserve
+Unreserve a reserved track.
+.TP
+trtail
+Blank the tail of a track.
+.TP
+unclose
+Unclose last session.
+.TP
+session
+Blank the last session.
+.RE
+Not all drives support all blanking types. It may be necessary to use
+.B "blank=all
+if a drive reports a specified command as being invalid.
+If used together with the 
+.B \-force
+flag, this option may be used to blank CD-RW disks that otherwise cannot be
+blanked. Note that you may need to specify
+.BI blank= all
+because some drives will not continue with certain types of bad CD-RW
+disks. Note also that
+.B wodim
+does its best if the 
+.B \-force 
+flag is used but it finally depends on the drive's firmware 
+whether the blanking operation will succeed or not.
+.TP
+.B \-format
+Format a CD-RW/DVD-RW/DVD+RW disc.
+Formatting is currently only implemented for DVD+RW media.
+A 'maiden' DVD+RW media needs to
+be formatted before you may write to it.
+However, as
+.B wodim
+autodetects the need for formatting in this case and auto formats the medium
+before it starts writing, the
+.B \-format
+option is only needed if you like to forcibly reformat a DVD+RW medium.
+.TP
+.BR fs= #
+Set the FIFO (ring buffer) size to #.
+You may use the same syntax as in 
+.BR dd (1),
+.BR sdd (1)
+or
+.BR star (1).
+The number representing the size is taken in bytes unless otherwise specified.
+If a number is followed directly by the letter `b', `k', `m', `s' or `f',
+the size is multiplied by 512, 1024, 1024*1024, 2048 or 2352.
+If the size consists of numbers separated by `x' or `*', multiplication of the 
+two numbers is performed.
+Thus 
+.I "fs=10x63k
+will specify a FIFO size of 630\ kBytes.
+.sp
+The size specified by the 
+.I fs=
+argument includes the shared memory that is needed for administration. This
+is at least one page of memory.
+If no
+.IR fs =
+option is present, 
+.B wodim
+will try to get the FIFO size value from the 
+.B CDR_FIFOSIZE
+environment.
+The default FIFO size is currently 4 MB.
+.sp
+The FIFO is used to increase buffering for the real time writing process.
+It allows to run a pipe from 
+.B genisoimage
+directly into 
+.BR wodim .
+If the FIFO is active and a pipe from 
+.B genisoimage
+into 
+.B wodim
+is used to create a CD, 
+.B wodim
+will abort prior to do any modifications on the disk if 
+.B genisoimage 
+dies before it starts writing.
+The recommended FIFO size is between 4 and 128\ MBytes.
+As a rule of thumb, the FIFO size should be at least equal to the size
+of the internal buffer of the CD/DVD-Recorder and no more than half of
+the physical amount of RAM available in the machine.
+If the FIFO size is big enough, the FIFO statistics will print a FIFO
+empty count of zero and the FIFO min fill is not below 20%.
+It is not wise to use too much space for the FIFO. If you need more
+than 8 MB to write a CD at a speed less than 20x from an image on a
+local file system on an idle machine, your machine is either underpowered,
+has hardware problems or is mis-configured.
+If you like to write DVDs or CDs at higher speed, it makes sense
+to use at least 16\ MB for the FIFO.
+.sp
+On old and small machines, you need to be more careful with the FIFO size.
+If your machine has less than 256\ MB of physical RAM, you should not
+set up a FIFO size that is more than 32\ MB.
+The sun4c architecture (e.g. a Sparcstation-2) has only MMU page table entries
+for 16\ MBytes per process. Using more than 14\ MBytes for the FIFO
+may cause the operating system in this case to spend much time to constantly
+reload the MMU tables. Newer machines from Sun do not have this MMU
+hardware problem. I have no information on PC-hardware reflecting
+this problem.
+.sp
+Old Linux systems for non x86 platforms have broken definitions for
+the shared memory size. You need to fix them and rebuild the kernel
+or manually tell
+.B wodim
+to use a smaller FIFO.
+.sp
+If you have buffer underruns or similar problems (like a constantly empty
+drive buffer) and observe a zero
+.IR "fifo empty count" ,
+you have hardware problems that prevents the data from flowing fast enough
+from the kernel memory to the drive. The FIFO size in this case is sufficient,
+but you should check for a working DMA setup.
+.TP
+.BR ts= #
+Set the maximum transfer size for a single SCSI command to #.
+The syntax for the 
+.B ts=
+option is the same as for wodim fs=# or sdd bs=#.
+.sp
+If no 
+.B ts=
+option has been specified,
+.B wodim
+defaults to a transfer size of 63\ kB. If libusal gets lower values from the
+operating system, the value is reduced to the maximum value that is possible
+with the current operating system.
+Sometimes, it may help to further reduce the transfer size or to enhance it,
+but note that it may take a long time to find a better value by experimenting
+with the
+.B ts=
+option.
+.TP
+.BI dev= target
+Sets the SCSI target for the CD/DVD-Recorder, see notes above.
+A typical device specification is
+.BI dev= 6,0
+\&.
+A filename or virtual device name can be passed instead of the symbolic SCSI
+numbers.  The correct device/filename in this case can be found in the system
+specific manuals of the target operating system.
+On a 
+.I FreeBSD
+system without 
+.I CAM
+support, you need to use the control device (e.g.
+.IR /dev/rcd0.ctl ).
+A correct device specification in this case may be
+.BI dev= /dev/rcd0.ctl:@
+\&.
+.sp
+On Linux and Windows 2000/XP, drives are accessible with their device (or
+drive) names or with the symbolic SCSI numbers (not recommended, mapping is not
+stable and could be completely removed in the future).
+.sp
+If no 
+.I dev
+option is present, 
+.B wodim
+will try to get the device from the 
+.B CDR_DEVICE
+environment.
+.sp
+If the argument to the
+.B dev=
+option does not contain the characters ',', '/', '@' or ':',
+it is interpreted as an label name that may be found in the file
+/etc/wodim.conf (see FILES section).
+.TP
+.BI gracetime= #
+Set the grace time before starting to write to
+.IR # " seconds.
+Values below 2 seconds are not recommended to give the kernel or volume
+management a chance to learn the new state.
+.TP
+.BI timeout= #
+Set the default SCSI command timeout value to 
+.IR # " seconds.
+The default SCSI command timeout is the minimum timeout used for sending
+SCSI commands.
+If a SCSI command fails due to a timeout, you may try to raise the
+default SCSI command timeout above the timeout value of the failed command.
+If the command runs correctly with a raised command timeout,
+please report the better timeout value and the corresponding command to 
+the author of the program.
+If no 
+.I timeout 
+option is present, a default timeout of 40 seconds is used.
+.TP
+.BI driver= name
+Allows the user to manually select a driver for the device.
+The reason for the existence of the
+.BI driver= name
+option is to allow users to use
+.B wodim
+with drives that are similar to supported drives but not known
+directly by
+.BR wodim .
+All drives made after 1997 should be MMC standard compliant and
+thus supported by one of the MMC drivers.
+It is most unlikely that
+.B wodim
+is unable to find the right driver automatically.
+Use this option with extreme care. If a wrong driver is used for a
+device, the possibility of creating corrupted disks is high.
+The minimum problem related to a wrong driver is that the 
+.B speed=
+or 
+.B \-dummy
+will not work.
+.br
+.RS
+.ne 8
+.PP
+The following driver names are supported:
+.TP
+.B help
+To get a list of possible drivers together with a short description.
+.TP
+.B mmc_cd
+The generic SCSI-3/mmc CD-ROM driver is auto-selected whenever
+.B wodim
+finds a MMC compliant drive that does not identify itself to support writing at
+all, or that only identifies to support media or write modes not implemented in
+.BR wodim .
+.TP
+.B mmc_cd_dvd
+The generic SCSI-3/mmc CD/DVD driver is auto-selected whenever
+.B wodim
+finds a MMC-2 or MMC-3 compliant drive that seems to support more than 
+one medium type and the tray is open or no medium could be found to select the
+right driver.
+This driver tries to close the tray, checks the medium found in the tray and then
+branches to the driver that matches the current medium.
+.TP
+.B mmc_cdr
+The generic SCSI-3/mmc CD-R/CD-RW driver is auto-selected whenever
+.B wodim
+find a MMC compliant drive that only supports to write CDs or a multi system
+drive that contains a CD as the current medium.
+.TP
+.B mmc_cdr_sony
+The generic SCSI-3/mmc CD-R/CD-RW driver is auto-selected whenever
+.B wodim
+would otherwise select the
+.B mmc_cdr
+driver but the device seems to be made by Sony.
+The
+.B mmc_cdr_sony
+is definitely needed for the Sony CDU 928 as this drive does not completely
+implement the MMC standard and some of the MMC SCSI commands have to be
+replaced by Sony proprietary commands. It seems that all Sony drives (even
+newer ones) still implement the Sony proprietary SCSI commands so it has
+not yet become a problem to use this driver for all Sony drives. If you find
+a newer Sony drive that does not work with this driver, please report.
+.TP
+.B mmc_dvd
+The generic SCSI-3/mmc-2 DVD-R/DVD-RW driver is auto-selected whenever
+.B wodim
+finds a MMC-2 or MMC-3 compliant drive that supports to write DVDs and
+an appropriate medium is loaded.
+There is no Track At Once mode for DVD writers.
+.TP
+.B mmc_dvdplus
+The generic SCSI-3/mmc-3 DVD+R/DVD+RW driver is auto-selected whenever
+one of the DVD+ media types that are incompatible to each other is found.
+It checks media and then 
+branches to the driver that matches the current medium.
+.TP
+.B mmc_dvdplusr
+The generic SCSI-3/mmc-3 DVD+R driver is auto-selected whenever
+a DVD+R medium is found in an appropriate writer.
+Note that for unknown reason, the DVD-Plus alliance does not
+like that there is a simulation mode for DVD+R media.
+The author of
+.B wodim
+tries to convince manufacturers to implement a simulation mode for DVD+R
+and implement support.
+DVD+R only supports one write mode that is somewhere between Track At Once
+and Packet writing; this mode is selected in 
+.B wodim
+via a the 
+.BR \-dao / \-sao
+option.
+.TP
+.B mmc_dvdplusrw
+The generic SCSI-3/mmc-3 DVD+RW driver is auto-selected whenever
+a DVD+RW medium is found in an appropriate writer.
+As DVD+RW media needs to be formatted before its first use, wodim
+auto-detects this media state and performs a format before it starts
+to write.
+Note that for unknown reason, the DVD-Plus alliance does not
+like that there is a simulation mode nor a way to erase DVD+RW media.
+DVD+RW only supports one write mode that is close to
+Packet writing; this mode is selected in 
+.B wodim
+via a the 
+.BR \-dao / \-sao
+option.
+.TP
+.B cw_7501
+The driver for Matsushita/Panasonic CW-7501 is auto-selected when
+.B wodim
+finds this old pre MMC drive.
+.B wodim
+supports all write modes for this drive type.
+.TP
+.B kodak_pcd_600
+The driver for Kodak PCD-600 is auto-selected when
+.B wodim
+finds this old pre MMC drive which has been the first high speed (6x)
+CD writer for a long time. This drive behaves similar to the
+Philips CDD-521 drive.
+.TP
+.B philips_cdd521
+The driver for Philips CDD-521 is auto-selected when
+.B wodim
+finds a Philips CDD-521 drive (which is the first CD writer ever made)
+or one of the other drives that are known to behave similar to this
+drive.
+All Philips CDD-521 or similar drives (see other drivers in this list)
+do not support Session At Once recording.
+.TP
+.B philips_cdd521_old
+The driver for Philips old CDD-521 is auto-selected when
+.B wodim
+finds a Philips CDD-521 with very old firmware which has some known limitations.
+.TP
+.B philips_cdd522
+The driver for Philips CDD-522 is auto-selected when
+.B wodim
+finds a Philips CDD-522 which is the successor of the 521 or one of its variants
+with Kodak label.
+.B wodim
+does not support Session At Once recording with these drives.
+.TP
+.B philips_dumb
+The driver for Philips CDD-521 with pessimistic assumptions is never auto-selected.
+It may be used by hand with drives that behave similar to the Philips CDD-521.
+.TP
+.B pioneer_dws114x
+The driver for Pioneer DW-S114X is auto-selected when
+.B wodim
+finds one of the old non MMC CD writers from Pioneer.
+.TP
+.B plasmon_rf4100
+The driver for Plasmon RF 4100 is auto-selected when
+.B wodim
+finds this specific variant of the Philips CDD-521.
+.TP
+.B ricoh_ro1060c
+The driver for Ricoh RO-1060C is auto-selected when
+.B wodim
+finds this drive. There is no real support for this drive yet.
+.TP
+.B ricoh_ro1420c
+The driver for Ricoh RO-1420C is auto-selected when
+.B wodim
+finds a drive with this specific variant of the Philips CDD-521 command set.
+.TP
+.B scsi2_cd
+The generic SCSI-2 CD-ROM driver is auto-selected whenever
+.B wodim
+finds a pre MMC drive that does not support writing or a pre MMC writer that is
+not supported by
+.BR wodim .
+.TP
+.B sony_cdu924
+The driver for Sony CDU-924 / CDU-948 is auto-selected whenever
+.B wodim
+finds one of the old pre MMC CD writers from Sony.
+.TP
+.B teac_cdr50
+The driver for Teac CD-R50S, Teac CD-R55S, JVC XR-W2010, Pinnacle RCD-5020
+is auto-selected whenever one of the drives is found that is known to the
+non MMC command set used by TEAC and JVC.
+Note that many drives from JVC will not work because they do not correctly implement
+the documented command set and JVC has been unwilling to fix or document the
+bugs.
+There is no support for the Session At Once write mode yet.
+.TP
+.B tyuden_ew50
+The driver for Taiyo Yuden EW-50 is auto-selected when
+.B wodim
+finds a drive with this specific variant of the Philips CDD-521 command set.
+.TP
+.B yamaha_cdr100
+The driver for Yamaha CDR-100 / CDR-102 is auto-selected when
+.B wodim
+finds one of the old pre MMC CD writers from Yamaha.
+There is no support for the Session At Once write mode yet.
+.TP
+.B cdr_simul
+The simulation CD-R driver allows to run timing and speed tests
+with parameters that match the behavior of CD writers.
+.TP
+.B dvd_simul
+The simulation DVD-R driver allows to run timing and speed tests
+with parameters that match the behavior of DVD writers.
+.PP
+
+.sp
+There are two special driver entries in the list:
+.B cdr_simul
+and
+.BR dvd_simul .
+These driver entries are designed to make timing tests at any speed
+or timing tests for drives that do not support the 
+.B \-dummy
+option.
+The simulation drivers implement a drive with a buffer size of 1\ MB
+that can be changed via the 
+.B CDR_SIMUL_BUFSIZE
+environment variable.
+The simulation driver correctly simulates even a buffer underrun condition.
+If the 
+.B \-dummy 
+option is present, the simulation is not aborted in case of a buffer underrun.
+.RE
+.TP
+.BI driveropts= "option list"
+Set driver specific options. The options are specified a comma separated list.
+To get a list of valid options use 
+.BI driveropts= help
+together with the 
+.I \-checkdrive
+option.
+If you like to set driver options without running a typical
+.B wodim
+task, you need to use the
+.B \-setdropts
+option in addition, otherwise the command line parser in
+.B wodim
+will complain.
+Currently implemented driver options are:
+.RS
+.TP
+.B burnfree 
+Turn the support for Buffer Underrun Free writing on.
+This only works for drives that support Buffer Underrun Free technology, which
+is available on most drives manufactured in this millennium. 
+This may be called:
+.BR "Sanyo BURN-Proof" ,
+.BR "Ricoh Just-Link" ,
+.B "Yamaha Lossless-Link"
+or similar.
+.sp
+This option is deprecated and is mentioned here for documentation purposes
+only. The BURN-Free feature is enabled by default if the drive supports it.
+However, use of BURN-Free may cause decreased burning quality. Therefore it can
+be useful to disable it for certain purposes, eg. when creating a master copy
+for mass CD production.
+.TP
+.B noburnfree 
+Turn the support for Buffer Underrun Free writing off.
+.TP
+.BI varirec= value
+Turn on the 
+.B "Plextor VariRec"
+writing mode. The mandatory parameter
+.I value
+is the laser power offset and currently may be selected from
+-2, -1, 0, 1, 2.
+In addition, you need to set the write speed to 4 in order to allow
+.B "VariRec"
+to work.
+.TP
+.BI gigarec= value
+Manage the
+.B "Plextor GigaRec"
+writing mode. The mandatory parameter
+.I value
+is the disk capacity ratio compared to normal recording and currently may be selected from
+0.6, 0.7, 0.8, 1.0, 1.2, 1.3, 1.4.
+If values < 1.0 are used, then the effect is similar to the
+.B "Yamaha Audio Master Q. R."
+feature. If values > 1.0 are used, then the disk capacity is 
+increased.
+.sp
+Not all drives support all 
+.B GigaRec
+values.
+When a drive uses the 
+.B GigaRec
+feature, the write speed is limited to 8x.
+.TP
+.B audiomaster
+Turn on the 
+.B "Yamaha Audio Master Q. R."
+feature which usually should result in high quality CDs that
+have less reading problems in Hi-Fi players.
+As this is implemented as a variant of the 
+Session at Once write mode, it will only work if you select 
+SAO write mode and there is no need to turn it off.
+The 
+.B "Audio Master"
+mode will work with a limited speed but
+may also be used with data CDs. In
+.B "Audio Master"
+mode, the pits on the CD will be written larger then usual so the capacity
+of the medium is reduced when turning this feature on.
+A 74 minute CD will only have a capacity of 63 minutes if
+.B "Audio Master"
+is active and the capacity of a 80 minute CD will be reduced to 68 minutes.
+.TP
+.B forcespeed
+Normally, modern drives know the highest possible speed for different
+media and may reduce the speed in order to grant best write quality.
+This technology may be called:
+.BR "Plextor PowerRec" ,
+.BR "Ricoh Just-Speed" ,
+.B "Yamaha Optimum Write Speed Control"
+or similar.
+Some drives (e.g. Plextor, Ricoh and Yamaha) allow to force the drive to
+use the selected speed even if the medium is so bad that the
+write quality would be poor. This option tells such a drive to
+force to use the selected speed regardless of the medium quality.
+.sp
+Use this option with extreme care and note that the drive should know better
+which medium will work at full speed.
+The default is to turn 
+.B forcespeed
+off, regardless of the defaults of the drive.
+.TP
+.B noforcespeed
+Turn off the 
+.B "force speed
+feature.
+.TP
+.B speedread
+Some ultra high speed drives such as 48x and faster drives from Plextor
+limit the read speed for unknown media to e.g. 40x in order to avoid
+damaged disks and drives.
+Using this option tells the drive to read any media as fast as possible.
+Be very careful as this may cause the media to break in the drive 
+while reading, resulting in a damaged media and drive! 
+.TP
+.B nospeedread
+Turn off unlimited read speed.
+.TP
+.B singlesession
+Turn the drive into a single session only drive.
+This allows to read defective or non-compliant (illegal) media with extremely
+non-standard additional (broken/illegal) TOC entries in the TOC from the second
+or higher session. Some of these disks become
+usable if only the information from the first session is used.
+You need to enable Single Session mode before you insert the defective disk!
+.TP
+.B nosinglesession
+Turn off single session mode. The drive will again behave as usual.
+.TP
+.B hidecdr
+Hide the fact that a medium might be a recordable medium.
+This allows to make CD-Rs look like CD-ROMs and applications believe 
+that the media in the drive is not a CD-R. 
+.TP
+.B nohidecdr
+Turn off hiding CD-R media.
+.TP
+.B tattooinfo
+Use this option together with
+.B \-checkdrive
+to retrieve the image size information for the
+.B "Yamaha DiskT@2
+feature. The images always have a line length of 3744 pixel.
+Line number 0 (radius 0) is mapped to the center of the disk.
+If you know the inner and outer radius you will be able to create a
+pre distorted image that later may appear undistorted on the disk.
+.TP
+.BI tattoofile= name
+Use this option together with
+.B \-checkdrive
+to write an image prepared for the
+.B "Yamaha DiskT@2
+feature to the medium.
+The file must be a file with raw image B&W data (one byte per pixel) 
+in a size as retrieved by a previous call to
+.BI tattoofile= name
+\&.
+If the size of the image equals the maximum possible size
+(3744 x 320 pixel), 
+.B wodim
+will use the first part of the file. This first part then will 
+be written to the leftover space on the CD.
+.sp
+Note that the image must be mirrored to be readable from the pick up
+side of the CD.
+.RE
+.TP
+.B \-setdropts
+Set the driveropts specified by
+.BI driveropts= "option list" ,
+the 
+.B speed
+of the drive and the 
+.B dummy
+flag and exit.
+This allows wodim to set drive specific parameters that are not directly 
+used by
+.B wodim
+like e.g.
+.BR "single session mode" ", " "hide cdr"
+and similar.
+It is needed in case that 
+.BI driveropts= "option list"
+should be called without planning to run a typical
+.B wodim
+task.
+.TP
+.B \-checkdrive
+Checks if a driver for the current drive is present and exit.
+If the drive is a known drive, 
+.B wodim
+uses exit code 0.
+.TP
+.B \-prcap
+Print the drive capabilities for SCSI-3/mmc compliant drives
+as obtained from mode page 0x2A. Values marked with 
+.I kB
+use 1000 bytes as kilo-byte, values marked with
+.I KB
+use 1024 bytes as Kilo-byte.
+.TP
+.B \-inq
+Do an inquiry for the drive, print the inquiry info and exit.
+.TP
+.B \-scanbus
+Scan all SCSI devices on all SCSI busses and print the inquiry
+strings. This option may be used to find SCSI address of the 
+CD/DVD-Recorder on a system. If some device types are invisible, try using
+.B dev=ATA:
+or similar option to give a hint about the device type you are looking for.
+The numbers printed out as labels are computed by: 
+.B "bus * 100 + target.
+On platforms and device systems without persistent SCSI number management the
+results are not reliable. Use the .B \-\-devices option instead.
+.TP
+.B \-\-devices
+Look for useable devices using the system specific functions, eg. probing with
+usual device nodes in /dev/*, and display the detections using symbolic device
+names in OS specific syntax.
+.TP
+.B \-reset
+Try to reset the SCSI bus where the CD recorder is located. This works not
+on all operating systems.
+.TP
+.B \-abort
+Try to send an 
+.B abort
+sequence to the drive.
+If you use 
+.B wodim
+only, this should never be needed; but other software may leave a drive 
+in an unusable condition.
+Calling
+.B "wodim \-reset
+may be needed if a previous write has been interrupted and the software did 
+not tell the drive that it will not continue to write.
+.TP
+.B \-overburn
+Allow 
+.B wodim 
+to write more than the official size of a medium. This feature is usually
+called 
+.I overburning
+and depends on the fact that most blank media may hold more space than the
+official size. As the official size of the lead-out area on the disk is
+90 seconds (6750 sectors) and a disk usually works if there are at least
+150 sectors of lead out, all media may be overburned by at least 88 seconds
+(6600 sectors).
+Most CD recorders only do overburning in 
+.B SAO
+or
+.B RAW
+mode. Known exceptions are TEAC CD-R50S, TEAC CD-R55S and the Panasonic
+CW-7502.
+Some drives do not allow to overburn as much as you might like and limit
+the size of a CD to e.g. 76 minutes. This problem may be circumvented by
+writing the CD in RAW mode because this way the drive has no chance to find
+the size before starting to burn.
+There is no guarantee that your drive supports overburning at all.
+Make a test to check if your drive implements the feature.
+.TP
+.B \-ignsize
+Ignore the known size of the medium. This option should be used with extreme
+care, it exists only for debugging purposes don't use it for other reasons.
+It is not needed to write disks with more than the nominal capacity.
+This option implies
+.BR \-overburn .
+.TP
+.B \-useinfo
+Use
+.B "*.inf
+files to overwrite audio options.
+If this option is used, the pregap size information is read from 
+the
+.B "*.inf
+file that is associated with the file that contains the audio
+data for a track.
+.sp
+If used together with the
+.B \-audio
+option,
+.B wodim
+may be used to write audio CDs from a pipe from
+.B icedax
+if you call
+.B wodim
+with the
+.B *.inf
+files as track parameter list instead of using audio files.
+The audio data is read from 
+.B stdin
+in this case.
+See
+.B EXAMPLES
+section below.
+.B wodim
+first verifies that 
+.B stdin
+is not connected to a terminal and runs some heuristic consistency checks
+on the
+.B *.inf
+files and then sets the track lengths from the information in
+the
+.B *.inf
+files.
+.sp
+If you like to write from 
+.BR stdin ,
+make sure that wodim is called with a large enough FIFO size, reduce the write
+speed to a value below the read speed of the source drive and switch the burn-free
+option for the recording drive on.
+.TP
+.BR defpregap= #
+Set the default pre-gap size for all tracks except track number 1.
+This option currently only makes sense with the TEAC drive when
+creating track-at-once disks without the 2 second silence before each track.
+.br
+This option may go away in future. 
+.TP
+.B \-packet
+Set 
+.B "Packet writing mode. 
+This is an experimental interface.
+.TP
+.BR pktsize= #
+Set the packet size to #, forces fixed packet mode.
+This is an experimental interface.
+.TP
+.B \-noclose
+Do not close the current track, useful only when in packet writing mode.
+This is an experimental interface.
+.TP
+.BI mcn= med_cat_nr
+Set the 
+.B "Media Catalog Number
+of the CD to 
+.IR med_cat_nr .
+.TP
+.B \-text
+Write CD-Text information
+based on information taken from a file that contains ascii information
+for the text strings. 
+.B wodim
+supports CD-Text information based on the content of the
+.B *.inf
+files created by 
+.B icedax 
+and CD-Text information based on the content from a
+.B "CUE sheet
+file.
+If a 
+.B "CUE sheet
+file contains both (binary CDTEXTFILE and text based SONGWRITER)
+entries, then the information based on the CDTEXTFILE entry will win.
+.sp
+You need to use the
+.B \-useinfo
+option in addition in order to tell 
+.B wodim
+to read the
+.B "*.inf
+files or
+.BI cuefile= filename
+in order to tell
+.B wodim
+to read a
+.B CUE sheet
+file in addition.
+If you like to write your own CD-Text information,
+edit the
+.B *.inf
+files or the
+.B "CUE sheet
+file with a text editor and change the fields
+that are relevant for CD-Text.
+.TP
+.BI textfile= filename
+Write CD-Text based on information found in the binary file
+.IR filename .
+This file must contain information in a data format defined in the
+SCSI-3 MMC-2 standard and in the Red Book. The four byte size header that is 
+defined in the SCSI standard is optional and allows to make the recognition of
+correct data less ambiguous.
+This is the best option to be used to copy CD-Text data from existing CDs
+that already carry CD-Text information. To get data in a format suitable
+for this option use 
+.B wodim \-vv \-toc
+to extract the information from disk.
+If both, 
+.BI textfile= filename
+and CD-Text information from
+.B *.inf
+or
+.B *.cue
+files are present,
+.BI textfile= filename
+will overwrite the other information.
+.TP
+.BI cuefile= filename
+Take all recording related information from a CDRWIN compliant
+.B "CUE sheet
+file.
+No track files are allowed when this option is present and the option
+.B \-dao
+is currently needed in addition.
+
+.SH "TRACK OPTIONS
+.PP
+Track options may be mixed with track file names.
+.TP
+.BI isrc= ISRC_number
+Set the 
+.B "International Standard Recording Number
+for the next track to
+.IR ISRC_number .
+.TP
+.BI index= list
+Sets an index list for the next track.
+In index list is a comma separated list of numbers that are counting
+from index 1. The first entry in this list must contain a 0, the following 
+numbers must be an ascending list of numbers (counting in 1/75 seconds) that 
+represent the start of the indices. An index list in the form:
+0,7500,15000 sets index 1 to the start of the track, index 2 100 seconds from
+the start of the track and index 3 200 seconds from the start of the track.
+.TP
+.B \-audio
+If this flag is present, all subsequent tracks are written in
+.B "CD-DA 
+(similar to Red Book) audio format.
+The file with data for this tracks should
+contain stereo, 16-bit digital audio with 44100 samples/s.
+The byte order should be the following: MSB left, LSB left, 
+MSB right, LSB right, MSB left and so on. The track should be a multiple of 
+2352 bytes. It is not possible to put the master image of an audio track 
+on a raw disk because 
+data will be read in multiple of 2352 bytes during the recording process.
+.sp
+If a filename ends in 
+.I .au
+or
+.I .wav
+the file is considered to be a structured audio data file.
+.B wodim
+assumes that the file in this case is a Sun audio file or a
+Microsoft .WAV file
+and extracts the audio data from the files by skipping over the
+non-audio header information.
+In all other cases, wodim will only work correctly if the
+audio data stream does not have any header.
+Because many structured audio files do not have an integral
+number of blocks (1/75th second) in length,
+it is often necessary to specify the
+.B \-pad
+option as well.
+.B wodim
+recognizes that audio data in a .WAV file is stored in Intel
+(little-endian) byte order, and will automatically byte-swap the data
+if the CD recorder requires big-endian data.  
+.B wodim
+will reject any audio file that does not match the Red Book requirements
+of 16-bit stereo samples in PCM coding at 44100 samples/second.
+.sp
+Using other structured audio data formats as input to 
+.B wodim
+will usually work if the structure of the data is the 
+structure described above (raw pcm data in big-endian byte order).
+However, if the data format includes a header,
+you will hear a click at the start of a track.
+.TP
+.I " "
+If neither 
+.I \-data 
+nor
+.I \-audio
+have been specified, 
+.B wodim
+defaults to 
+.I \-audio
+for all filenames that end in
+.I .au
+or 
+.I .wav
+and to
+.I \-data 
+for all other files.
+.TP
+.B \-swab
+If this flag is present, audio data is assumed to be in byte-swapped
+(little-endian) order.  Some types of CD-Writers e.g. Yamaha, Sony and the
+new SCSI-3/mmc drives require audio data to be presented in
+little-endian order,
+.\" (which is the order in which it's actually recorded on the CD) ????
+while other writers require audio data to be
+presented in the big-endian (network) byte order normally used by the
+SCSI protocol.
+.B wodim
+knows if a CD-Recorder needs audio data in big- or little-endian order,
+and corrects the byte order of the data stream to match the needs
+of the recorder.
+You only need the 
+.I \-swab 
+flag if your data stream is in Intel (little-endian) byte order.
+.sp
+Note that the verbose output of
+.B wodim
+will show you if swapping is necessary to make the byte order of 
+the input data fit the required byte order of the recorder.
+.B wodim
+will not show you if the 
+.I \-swab 
+flag was actually present for a track.
+.TP
+.B \-data
+If this flag is present, all subsequent tracks are written in
+.B "CD-ROM mode 1
+(Yellow Book) format. The data size is a multiple of 2048 bytes.
+The file with track data should contain an 
+.BR ISO-9660 " or " "Rock Ridge
+filesystem image (see 
+.B genisoimage
+for more details). If the track data is an
+.B ufs
+filesystem image, fragment size should be set to 2\ KB or more to allow
+CD-drives with 2\ KB sector size to be used for reading.
+.TP
+.I " "
+.I \-data
+is the default, if no other flag is present and the file does not
+appear to be of one of the well known audio file types.
+.TP
+.I " "
+If neither 
+.I \-data 
+nor
+.I \-audio
+have been specified, 
+.B wodim
+defaults to 
+.I \-audio
+for all filenames that end in
+.I .au
+or 
+.I .wav
+and to
+.I \-data 
+for all other files.
+.TP
+.B \-mode2
+If this flag is present, all subsequent tracks are written in
+.B "CD-ROM mode 2
+format. The data size is a multiple of 2336 bytes.
+.TP
+.B \-xa
+If this flag is present, all subsequent tracks are written in
+.B "CD-ROM XA mode 2 form 1
+format. The data size is a multiple of 2048 bytes.
+The XA sector sub headers will be created by the drive.
+With this option, the write mode is the same as with the
+.B \-multi
+option.
+.TP
+.B \-xa1
+If this flag is present, all subsequent tracks are written in
+.B "CD-ROM XA mode 2 form 1
+format. The data size is a multiple of 2056 bytes.
+The XA sector sub headers are part of the user data and have to be
+supplied by the application that prepares the data to be written.
+.TP
+.B \-xa2
+If this flag is present, all subsequent tracks are written in
+.B "CD-ROM XA mode 2 form 2
+format. The data is a multiple of 2324 bytes.
+The XA sector sub headers will be created by the drive.
+.TP
+.B \-xamix
+If this flag is present, all subsequent tracks are written in a way
+that allows a mix of 
+.B "CD-ROM XA mode 2 form 1/2
+format. The data size is a multiple of 2332 bytes.
+The XA sector sub headers are part of the user data and have to be
+supplied by the application that prepares the data to be written.
+The CRC and the P/Q parity ECC/EDC information (depending on the sector
+type) have to be supplied by the application that prepares the data to be written.
+.TP
+.B \-cdi
+If this flag is present, the TOC type for the disk is set to
+.BR CDI .
+This only makes sense with XA disks.
+.TP
+.B \-isosize
+Use the 
+.B "ISO-9660
+file system size as the size of the next track.
+This option is needed if you want 
+.B wodim
+to directly read the image of a track from
+a raw disk partition or from a 
+.I TAO 
+master CD. In the first case the option
+.B \-isosize
+is needed to limit the size of the CD to the size of the ISO filesystem.
+In the second case the option
+.B \-isosize
+is needed to prevent 
+.B wodim
+from reading the two run out blocks that are appended by each CD-recorder
+in track at once mode. These two run out blocks cannot be read and would
+cause a buffer underrun that would cause a defective copy.
+Do not use this option on files created by 
+.B genisoimage
+and in case
+.B wodim
+reads the track data from 
+.IR stdin .
+In the first case, you would prevent 
+.B wodim 
+from writing the amount of padding that has been appended by
+.B genisoimage
+and in the latter case, it will not work because 
+.I stdin
+is not seekable.
+.sp
+If 
+.B \-isosize
+is used for a track, 
+.B wodim
+will automatically add padding for this track as if the
+.B \-pad
+option has been used but the amount of padding may be less than the padding
+written by 
+.BR  genisoimage .
+Note that if you use
+.B \-isosize
+on a track that contains Sparc boot information, the boot information will
+be lost.
+.sp
+Note also that
+this option cannot be used to determine the size of a file system
+if the multi session option is present.
+.TP
+.B \-pad
+If the track is a data track, 15 sectors of zeroed data
+will be added to the end of this and each subsequent data track.
+In this case, the 
+.B \-pad 
+option is superseded by the 
+.B padsize=
+option. It will remain however as a shorthand for
+.BI padsize= 15s.
+If the 
+.I \-pad 
+option refers to an audio track,
+.B wodim 
+will pad the audio data to be a multiple of 2352 bytes. 
+The audio data padding is done with binary zeroes which is 
+equal to absolute silence.
+.sp
+.B \-pad 
+remains valid until disabled by 
+.BR \-nopad .
+.TP
+.BR padsize= #
+Set the amount of data to be appended as padding to the next track to #.
+Opposed to the behavior of the 
+.B \-pad
+option, the value for 
+.I padsize=
+is reset to zero for each new track.
+wodim assumes a sector size of 2048 bytes for the
+.I padsize=
+option, independent from the real 
+sector size and independent from the write mode.
+The megabytes mentioned in the verbose mode output however are counting
+the output sector size which is e.g. 2448 bytes when writing in RAW/RAW96
+mode.
+See
+.BR fs =
+option for possible arguments.
+To pad the equivalent of 20 minutes on a CD, you may write
+.BR padsize= 20x60x75s.
+Use this option if your CD-drive is not able to read the last sectors of
+a track or if you want to be able to read the CD
+on a 
+.B Linux 
+system with the ISO-9660 filesystem read ahead bug.
+If an empty file is used for track data, 
+this option may be used to create a disk that is entirely made of padding.
+This may e.g. be used to find out how much overburning is possible with a 
+specific media.
+.TP
+.B \-nopad
+Do not pad the following tracks \- the default.
+.TP
+.B \-shorttrack
+Allow all subsequent tracks to violate the Red Book track length standard
+which requires a minimum track length of 4 seconds.
+This option is only useful when used in SAO or RAW mode.
+Not all drives support this feature. The drive must accept the
+resulting CUE sheet or support RAW writing.
+.TP
+.B \-noshorttrack
+Re-enforce the Red Book track length standard. Tracks must be
+at least 4 seconds.
+.TP
+.BR pregap= #
+Set the  pre-gap size for the next track.
+This option currently only makes sense with the TEAC drive when
+creating track-at-once disks without the 2 second silence before each track.
+.br
+This option may go away in future. 
+.TP
+.B \-preemp
+If this flag is present, all TOC entries for subsequent audio tracks 
+will indicate that the audio data has been sampled with 50/15 \*msec
+pre-emphasis.
+The data, however is not modified during the process of transferring from file
+to disk. 
+This option has no effect on data tracks.
+.TP
+.B \-nopreemp
+If this flag is present, all TOC entries for subsequent audio tracks 
+will indicate that the audio data has been mastered with linear data \- 
+this is the default.
+.TP
+.B \-copy
+If this flag is present, all TOC entries for subsequent audio tracks
+of the resulting CD
+will indicate that the audio data has permission to be copied without limit.
+This option has no effect on data tracks.
+.TP
+.B \-nocopy
+If this flag is present, all TOC entries for subsequent audio tracks 
+of the resulting CD
+will indicate that the audio data has permission to be copied only once for
+personal use \-
+this is the default.
+.TP
+.B \-scms
+If this flag is present, all TOC entries for subsequent audio tracks 
+of the resulting CD
+will indicate that the audio data has no permission to be copied anymore.
+.TP
+.BR tsize= #
+If the master image for the next track has been stored on a raw disk, 
+use this option
+to specify the valid amount of data on this disk. If the image of the next 
+track is stored in a regular file, the size of that file is taken to determine
+the length of this track.
+If the track contains an ISO 9660 filesystem image use the 
+.I \-isosize
+option to determine the length of that filesystem image.
+.br
+In Disk at Once mode and with some drives that use
+the TEAC programming interface, even in Track at Once mode,
+.B wodim
+needs to know the size of each track before starting to write the disk.
+wodim now checks this and aborts before starting to write.
+If this happens you will need to run
+.B "genisoimage -print-size
+before and use the output (with `s' appended) as an argument to the 
+.BR tsize =
+option of 
+.B wodim
+(e.g. tsize=250000s).
+.br
+See
+.BR fs =
+option for possible arguments.
+
+.SH EXAMPLES
+.PP
+For all examples below, it will be assumed that the CD/DVD-Recorder is
+connected to the primary SCSI bus of the machine. The SCSI target id is
+set to 2.
+.PP
+To record a pure CD-ROM at double speed, using data from the file
+.IR cdimage.raw :
+.PP
+    wodim \-v speed=2 dev=2,0 cdimage.raw
+.PP
+To create an image for a ISO 9660 filesystem with Rock Ridge extensions:
+.PP
+    genisoimage \-R \-o cdimage.raw /home/joerg/master/tree
+.PP
+To check the resulting file before writing to CD on Solaris:
+.PP
+    mount \-r \-F fbk \-o type=hsfs /dev/fbk0:cdimage.raw /mnt
+.PP
+On Linux:
+.PP
+    mount cdimage.raw \-r \-t iso9660 \-o loop /mnt
+.PP
+Go on with:
+.br
+    ls \-lR /mnt
+.br
+    umount /mnt
+.PP
+If the overall speed of the system is sufficient and the structure of
+the filesystem is not too complex, wodim will run without creating an
+image of the ISO 9660 filesystem. Simply run the pipeline:
+.PP
+    genisoimage \-R /master/tree | wodim \-v fs=6m speed=2 dev=2,0 -
+.PP
+The recommended minimum FIFO size for running this pipeline is 4 MBytes.
+As the default FIFO size is 4 MB, the 
+.B fs=
+option needs only be present if you want to use a different FIFO size.
+If your system is loaded, you should run genisoimage in the real time class too.
+To raise the priority of 
+.B genisoimage
+replace the command
+.PP
+    genisoimage \-R /master/tree
+.br
+by
+.br
+    priocntl \-e \-c RT \-p 59 genisoimage \-R /master/tree
+.sp
+on Solaris and by
+.sp
+    nice --18 genisoimage \-R /master/tree
+.sp
+on systems that don't have
+.B "UNIX International
+compliant real-time scheduling.
+.PP
+wodim runs at priority 59 on Solaris, you should run genisoimage
+at no more than priority 58. On other systems, you should run genisoimage
+at no less than nice --18.
+.PP
+Creating a CD-ROM without file system image on disk has been tested
+on a Sparcstation-2 with a Yamaha CDR-400. It did work up to quad speed
+when the machine was not loaded.
+A faster machine may be able to handle quad speed also in the loaded case.
+.PP
+To record a pure CD-DA (audio) at single speed, with each track contained
+in a file named
+.IR track01.cdaudio ,
+.IR track02.cdaudio ,
+etc:
+.PP
+    wodim \-v speed=1 dev=/dev/cdrw -audio track*.cdaudio
+.PP
+To check if it will be ok to use double speed for the example above. 
+Use the dummy write option:
+.PP
+    wodim \-v \-dummy speed=2 dev=/dev/cdrw \-audio track*.cdaudio
+.PP
+To record a mixed-mode CD with an ISO 9660 filesystem from
+.I cdimage.raw
+on the first track, the other tracks being audio tracks from the files
+.IR track01.cdaudio ,
+.IR track02.cdaudio ,
+etc:
+.PP
+    wodim \-v dev=2,0 cdimage.raw \-audio track*.cdaudio
+.PP
+To handle drives that need to know the size of a track before starting to write,
+first run
+.PP
+    genisoimage -R -q -print-size /master/tree
+.PP
+and then run
+.PP
+    genisoimage -R /master/tree | wodim speed=2 dev=2,0 tsize=XXXs -
+.PP
+where 
+.I XXX
+is replaced by the output of the previous run of genisoimage.
+.PP
+To copy an audio CD in the most accurate way, first run
+.PP
+    icedax dev=/dev/cdrom \-vall cddb=0 -B \-Owav
+.PP
+and then run
+.PP
+    wodim dev=/dev/cdrw \-v \-dao \-useinfo \-text  *.wav
+.PP
+This will try to copy track indices and to read CD-Text information from disk.
+If there is no CD-Text information, 
+.B icedax
+will try to get the information from freedb.org instead.
+.PP
+To copy an audio CD from a pipe (without intermediate files), first run
+.PP
+    icedax dev=1,0 \-vall cddb=0 \-info-only
+.PP
+and then run
+.PP
+    icedax dev=1,0 \-no-infofile \-B \-Oraw \- | \\
+.br
+    wodim dev=2,0 \-v \-dao \-audio \-useinfo \-text *.inf
+.PP
+This will get all information (including track size info) from the
+.B *.inf
+files and then read the audio data from stdin.
+.sp
+If you like to write from 
+.BR stdin ,
+make sure that wodim is called with a large enough FIFO size (e.g.
+.BR fs=128m ),
+reduce the write speed to a value below the read speed of the source drive
+(e.g.
+.BR speed=12 ),
+and get a CD/DVD drive with BURN-Free feature if it is not available yet.
+.PP
+To set drive options without writing a CD (e.g. to switch a drive
+to single session mode), run
+.PP
+    wodim dev=1,0 \-setdropts driveropts=singlesession
+.PP
+If you like to do this when no CD is in the drive, call
+.PP
+    wodim dev=1,0 \-force \-setdropts driveropts=singlesession
+.PP
+To copy a CD in clone mode, first read the master CD using:
+.PP
+    readom dev=b,t,l \-clone f=somefile
+.PP
+or (in case the CD contains many sectors that are unreadable by intention)
+by calling:
+.PP
+    readom dev=1,0 -clone -nocorr f=somefile
+.PP
+will create the files
+.I somefile
+and
+.IR somefile.toc .
+Then write the CD using:
+.PP
+    wodim dev=1,0 -raw96r -clone -v somefile
+
+
+.SH ENVIRONMENT
+.TP
+.B CDR_DEVICE
+This may either hold a device identifier that is suitable to the open
+call of the SCSI transport library or a label in the file /etc/wodim.conf.
+.TP
+.B CDR_SPEED
+Sets the default speed value for writing (see also 
+.B speed=
+option).
+.TP
+.B CDR_FIFOSIZE
+Sets the default size of the FIFO (see also 
+.BR fs= #
+option).
+.TP
+.B CDR_FORCERAWSPEED
+If this environment variable is set, 
+.B wodim
+will allow you to write at the full RAW encoding speed a single CPU supports.
+This will create high potential of buffer underruns. Use with care.
+.TP
+.B CDR_FORCESPEED
+If this environment variable is set, 
+.B wodim
+will allow you to write at the full DMA speed the system supports.
+There is no DMA reserve for reading the data that is to be written from disk.
+This will create high potential of buffer underruns. Use with care.
+.TP
+.B RSH
+If the 
+.B RSH
+environment is present, the remote connection will not be created via
+.BR rcmd (3)
+but by calling the program pointed to by
+.BR RSH .
+Use e.g. 
+.BR RSH= /usr/bin/ssh
+to create a secure shell connection.
+.sp
+Note that this forces 
+.B wodim
+to create a pipe to the 
+.B rsh(1)
+program and disallows
+.B wodim
+to directly access the network socket to the remote server.
+This makes it impossible to set up performance parameters and slows down
+the connection compared to a 
+.B root
+initiated
+.B rcmd(3)
+connection.
+.TP
+.B RSCSI
+If the 
+.B RSCSI
+environment is present, the remote SCSI server will not be the program
+.B /opt/schily/sbin/rscsi
+but the program pointed to by
+.BR RSCSI .
+Note that the remote SCSI server program name will be ignored if you log in
+using an account that has been created with a remote SCSI server program as
+login shell.
+
+.SH FILES
+.TP
+/etc/wodim.conf
+Default values can be set for the following options in /etc/wodim.conf.
+For example:
+.SM CDR_FIFOSIZE=8m
+or
+.SM CDR_SPEED=2
+.RS
+.TP
+CDR_DEVICE
+This may either hold a device identifier that is suitable to the open
+call of the SCSI transport library or a label in the file /etc/wodim.conf 
+that allows to identify a specific drive on the system.
+.TP
+CDR_SPEED
+Sets the default speed value for writing (see also 
+.B speed=
+option).
+.TP
+CDR_FIFOSIZE
+Sets the default size of the FIFO (see also 
+.BR fs= #
+option).
+.TP
+CDR_MAXFIFOSIZE
+Sets the maximum size of the FIFO (see also 
+.BR fs= #
+option).
+.TP
+Any other keyword (label) is an identifier (symbolic name) for a specific drive
+on the system.  Such an identifier may not contain the characters ',', '/', '@'
+or ':'.
+.sp
+Each line that follows a label contains a whitespace separated list of items.
+Currently, four items are recognized: the drive's target specification, the
+default speed that should be used for this drive, the default FIFO size
+that should be used for this drive and drive specific options. The values for 
+.I speed
+and
+.I fifosize
+may be set to -1 to tell wodim to use the global defaults.
+.I target
+can be -1 to use the auto-guessing of the drive (see above).
+
+The value for driveropts may be omitted or set to "" if no driveropts are used.
+A typical line may look this way:
+.sp
+plex760= 0,5,0	12	50m	varirec=1
+.sp
+pioneer= /dev/hdd	-1	-1
+.sp
+This tells
+.B wodim
+that a drive named
+.I plex760
+is at scsibus 0, target 5, lun 0 and should be used with speed 12 and
+a FIFO size of 50 MB. It also uses some device specific parameter.
+A second drive may is accessible via the device file /dev/hdd and uses the
+default speed and the default FIFO size.
+.RE
+
+.SH SEE ALSO
+.BR icedax (1),
+.BR readom (1),
+.BR genisoimage (1),
+.BR ssh (1).
+
+.SH NOTES
+.PP
+On Solaris you need to stop the volume management if you like to use the USCSI
+fallback SCSI transport code. Even things like 
+.B "wodim -scanbus
+will not work if the volume management is running.
+.PP
+Disks made in 
+.B "Track At Once 
+mode are not suitable as a master for direct mass production by CD manufacturers.
+You will need the 
+.B "disk at once
+option to record such disks.
+Nevertheless the disks made in
+.B "Track At Once 
+will normally be read in all CD players. Some old
+audio CD players however may produce a two second click between two audio tracks.
+.PP
+The minimal size of a track is 4 seconds or 300 sectors. If you write 
+smaller tracks, the CD-Recorder will add dummy blocks. This is not an
+error, even though the SCSI-error message looks this way.
+.PP
+The Yamaha CDR-400 and all new SCSI-3/mmc conforming drives are supported
+in single and multi-session.
+.PP
+You should run several tests in all supported speeds of your drive with the
+.B \-dummy
+option turned on if you are using 
+.B wodim
+on an unknown system. Writing a CD is a real-time process. 
+.B NFS, CIFS
+and other network file systems
+won't always deliver constantly the needed data rates.
+If you want to use 
+.B wodim 
+with CD-images that are located on a
+.B NFS
+mounted filesystem, be sure that the FIFO size is big enough.
+If you want to make sure that buffer underruns are not
+caused by your source disk, you may use the command
+.PP
+.B "    wodim -dummy dev=2,0 padsize=600m /dev/null
+.PP
+to create a disk that is entirely made of dummy data.
+.PP
+There are also cases where you either need to be root or install
+.B wodim 
+executable with suid-root permissions. First, if you are using a device
+manufactured before 1999 which requires a non-MMC driver, you should run
+.B wodim
+in dummy mode before writing data. If you find a problem doing this, please
+report it to the
+.B cdrkit
+maintainers (see below).
+.PP
+Second, certain functionality may be unusable because of Linux's SCSI
+command filtering. When using
+.B wodim
+for anything except of pure data writing, you should also test the process in
+dummy mode and report trouble to the contact address below.
+.PP
+If you still want to run
+.B wodim
+with root permissions, you can set the permissions of the executable to
+suid-root. See the additional notes of your system/program distribution or
+README.suidroot which is part of the cdrkit source.
+.PP
+You should not connect old drives that do not support
+disconnect/reconnect to either the SCSI bus that is connected to the
+CD-Recorder or the source disk.
+.PP
+A Compact Disc can have no more than 99 tracks.
+.PP
+When creating a disc with both audio and data tracks, 
+the data should be on track 1 otherwise you should create
+a CDplus disk which is a multi session disk with the first session 
+containing the audio tracks and the following session containing the data track.
+.PP
+Many operating systems are not able to read more than a single data track, or
+need special software to do so.
+.PP
+If you have more information or SCSI command manuals for currently 
+unsupported CD/DVD/BR/HD-DVD-Recorders, please contact the
+.B cdrkit
+maintainers (see below).
+.PP
+Many CD recorders have bugs and often require a firmware update to work
+correctly. If you experience problems which cannot be solved or explained by the
+notes above, please look for instructions on the homepage of the particular
+manufacturer.
+.PP
+Some bugs will force you to power cycle the device or to reboot the machine.
+.PP
+The FIFO percent output is computed just after a block of data has been written
+to the CD/DVD-Recorder. For this reason, there will never be 100% FIFO fill ratio
+while the FIFO is in streaming mode.
+
+.SH DIAGNOSTICS
+.PP
+You have 4 seconds to abort
+.B wodim
+start after you see the message:
+.PP
+Starting to write CD at speed %d in %s mode for %s session.
+In most shells you can do that by pressing Ctrl-C.
+.PP
+A typical error message for a SCSI command looks like:
+.sp
+.RS
+.nf
+wodim: I/O error. test unit ready: scsi sendcmd: no error
+CDB:  00 20 00 00 00 00
+status: 0x2 (CHECK CONDITION)
+Sense Bytes: 70 00 05 00 00 00 00 0A 00 00 00 00 25 00 00 00 00 00
+Sense Key: 0x5 Illegal Request, Segment 0
+Sense Code: 0x25 Qual 0x00 (logical unit not supported) Fru 0x0
+Sense flags: Blk 0 (not valid)
+cmd finished after 0.002s timeout 40s
+.fi
+.RE
+.sp
+The first line gives information about the transport of the command.
+The text after the first colon gives the error text for the system call
+from the view of the kernel. It usually is:
+.B "I/O error
+unless other problems happen. The next words contain a short description for
+the SCSI command that fails. The rest of the line tells you if there were
+any problems for the transport of the command over the SCSI bus.
+.B "fatal error
+means that it was not possible to transport the command (i.e. no device present
+at the requested SCSI address).
+.PP
+The second line prints the SCSI command descriptor block for the failed command.
+.PP
+The third line gives information on the SCSI status code returned by the 
+command, if the transport of the command succeeds. 
+This is error information from the SCSI device.
+.PP
+The fourth line is a hex dump of the auto request sense information for the 
+command.
+.PP
+The fifth line is the error text for the sense key if available, followed
+by the segment number that is only valid if the command was a
+.I copy
+command. If the error message is not directly related to the current command,
+the text
+.I deferred error
+is appended.
+.PP
+The sixth line is the error text for the sense code and the sense qualifier if available.
+If the type of the device is known, the sense data is decoded from tables
+in
+.IR scsierrs.c " .
+The text is followed by the error value for a field replaceable unit.
+.PP
+The seventh line prints the block number that is related to the failed command
+and text for several error flags. The block number may not be valid.
+.PP
+The eight line reports the timeout set up for this command and the time
+that the command really needed to complete.
+.PP
+The following message is not an error:
+.sp
+.RS
+.nf
+Track 01: Total bytes read/written: 2048/2048 (1 sectors).
+wodim: I/O error. flush cache: scsi sendcmd: no error
+CDB:  35 00 00 00 00 00 00 00 00 00
+status: 0x2 (CHECK CONDITION)
+Sense Bytes: F0 00 05 80 00 00 27 0A 00 00 00 00 B5 00 00 00 00 00
+Sense Key: 0x5 Illegal Request, Segment 0
+Sense Code: 0xB5 Qual 0x00 (dummy data blocks added) Fru 0x0
+Sense flags: Blk -2147483609 (valid)
+cmd finished after 0.002s timeout 40s
+.fi
+.RE
+.sp
+It simply notifies, that a track that is smaller than the minimum size has been
+expanded to 300 sectors.
+.SH BUGS
+.PP
+.B netscsid
+does not work properly and is generally unmaintained. It is probably not
+compatible with rscsi from 
+.BR cdrtools
+either. Good bugfixes are welcome, talk to Cdrkit maintainers.
+.PP
+.B cuefile support is very limited, only one file is allowed. For volunteers,
+see TODO file in the source.
+.PP
+.B Specifying an audio file multiple times causes corruption of the second
+track (effectively no data plus minimum padding).
+.PP
+Some of the bugs may be fixed in Joerg Schilling's cdrtools. See there for
+details, URL attached below.
+
+.SH CREDITS
+.PP
+.TP 15
+Joerg Schilling (schilling@fokus.fhg.de)
+.br
+For writing cdrecord and libscg which represent the most parts of wodim's code.
+.PP
+.TP 15
+Bill Swartz	(Bill_Swartz@twolf.com)
+.br
+For helping me with the TEAC driver support
+.TP
+Aaron Newsome	(aaron.d.newsome@wdc.com)
+.br
+For letting me develop Sony support on his drive
+.TP
+Eric Youngdale	(eric@andante.jic.com)
+.br
+For supplying mkisofs
+.TP
+Gadi Oxman	(gadio@netvision.net.il)
+.br
+For tips on the ATAPI standard
+.TP
+Finn Arne Gangstad	(finnag@guardian.no)
+.br
+For the first FIFO implementation.
+.TP
+Dave Platt	(dplatt@feghoot.ml.org)
+.br
+For creating the experimental packet writing support,
+the first implementation of CD-RW blanking support,
+the first .wav file decoder 
+and many nice discussions on cdrecord.
+.TP
+Chris P. Ross (cross@eng.us.uu.net)
+.br
+For the first implementation of a BSDI SCSI transport.
+.TP
+Grant R. Guenther   (grant@torque.net)
+.br
+For creating the first parallel port transport implementation
+for Linux.
+.TP
+Kenneth D. Merry (ken@kdm.org)
+.br
+for providing the CAM port for FreeBSD together with Michael Smith (msmith@freebsd.org)
+.TP
+Heiko Ei\*sfeldt (heiko@hexco.de)
+for making libedc_ecc available (needed to write RAW data sectors).
+
+.SH "MAILING LISTS
+If you want to actively take part on the development of wodim,
+you may join the developer mailing list via this URL:
+.sp
+.B
+https://alioth.debian.org/mail/?group_id=31006
+.PP
+The mail address of the list is:
+.B
+debburn-devel@lists.alioth.debian.org
+
+.SH AUTHORS
+.B wodim
+is currently maintained as part of the cdrkit project by its developers. Most of the code and this manual page was originally written by:
+.PP
+.nf
+Joerg Schilling
+Seestr. 110
+D-13353 Berlin
+Germany
+.fi
+.PP
+This application is derived from "cdrecord" as included
+in the cdrtools package [1] created by Joerg
+Schilling, who deserves most of the credit for its success. However, he is not
+involved into the development of this spinoff and therefore he shall not be
+held responsible for any problems caused by it. Do not refer to this application
+as "cdrecord", do not try to get support for wodim by contacting the original
+authors.
+.PP
+Additional information can be found on:
+.br
+https://alioth.debian.org/projects/debburn/
+.PP
+If you have support questions, send them to
+.PP
+.B
+debburn-devel@lists.alioth.debian.org
+.br
+.PP
+If you have definitely found a bug, send a mail to this list or to
+.PP
+.B
+submit@bugs.debian.org
+.br
+.PP
+writing at least a short description into the Subject and "Package: cdrkit" in the first line of the mail body.
+.SH SOURCES
+.PP
+.br
+[1] Cdrtools 2.01.01a08 from May 2006, http://cdrecord.berlios.de
+
diff --git a/wodim/wodim.c b/wodim/wodim.c
new file mode 100644
index 0000000..7a54ccc
--- /dev/null
+++ b/wodim/wodim.c
@@ -0,0 +1,4701 @@
+/*
+ * 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.
+ *
+ */
+
+/*
+ *
+ * Modified by Eduard Bloch in 08/2006 and later
+ */
+
+/* @(#)cdrecord.c	1.310 06/02/09 Copyright 1995-2006 J. Schilling */
+/*
+ *	Record data on a CD/CVD-Recorder
+ *
+ *	Copyright (c) 1995-2006 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.
+ */
+
+#include <mconfig.h>
+#include <stdio.h>
+#include <standard.h>
+#include <stdxlib.h>
+#include <fctldefs.h>
+#include <errno.h>
+#include <timedefs.h>
+#ifdef	HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>	/* for rlimit */
+#endif
+#include <statdefs.h>
+#include <unixstd.h>
+#ifdef	HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+#endif
+#include <strdefs.h>
+#include <utypes.h>
+#include <intcvt.h>
+#include <signal.h>
+#include <schily.h>
+#include <string.h>
+#include <getargs.h>
+#ifdef	HAVE_PRIV_H
+#include <priv.h>
+#endif
+
+#include "xio.h"
+
+#include <usal/scsireg.h>	/* XXX wegen SC_NOT_READY */
+#include <usal/scsitransp.h>
+#include <usal/usalcmd.h>		/* XXX fuer read_buffer */
+#include "scsi_scan.h"
+
+#include "auheader.h"
+#include "wodim.h"
+#include "defaults.h"
+#include "movesect.h"
+
+#ifdef __linux__
+#include <sys/capability.h> 	/* for rawio capability */
+#endif
+
+#if defined(_POSIX_PRIORITY_SCHEDULING) && _POSIX_PRIORITY_SCHEDULING -0 >= 0
+#ifdef  HAVE_SYS_PRIOCNTL_H	/* The preferred SYSvR4 schduler */
+#else
+#define	USE_POSIX_PRIORITY_SCHEDULING
+#endif
+#endif
+
+/*
+ * Map toc/track types into names.
+ */
+char	*toc2name[] = {
+		"CD-DA",
+		"CD-ROM",
+		"CD-ROM XA mode 1",
+		"CD-ROM XA mode 2",
+		"CD-I",
+		"Illegal toc type 5",
+		"Illegal toc type 6",
+		"Illegal toc type 7",
+};
+
+/*
+ * Map sector types into names.
+ */
+char	*st2name[] = {
+		"Illegal sector type 0",
+		"CD-ROM mode 1",
+		"CD-ROM mode 2",
+		"Illegal sector type 3",
+		"CD-DA without preemphasis",
+		"CD-DA with preemphasis",
+		"Illegal sector type 6",
+		"Illegal sector type 7",
+};
+
+/*
+ * Map data block types into names.
+ */
+char	*db2name[] = {
+		"Raw (audio)",
+		"Raw (audio) with P/Q sub channel",
+		"Raw (audio) with P/W packed sub channel",
+		"Raw (audio) with P/W raw sub channel",
+		"Reserved mode 4",
+		"Reserved mode 5",
+		"Reserved mode 6",
+		"Vendor unique mode 7",
+		"CD-ROM mode 1",
+		"CD-ROM mode 2",
+		"CD-ROM XA mode 2 form 1",
+		"CD-ROM XA mode 2 form 1 (with subheader)",
+		"CD-ROM XA mode 2 form 2",
+		"CD-ROM XA mode 2 form 1/2/mix",
+		"Reserved mode 14",
+		"Vendor unique mode 15",
+};
+
+/*
+ * Map write modes into names.
+ */
+static	char	wm_none[] = "unknown";
+static	char	wm_ill[]  = "illegal";
+
+char	*wm2name[] = {
+		wm_none,
+		"BLANK",
+		"FORMAT",
+		wm_ill,
+		"PACKET",
+		wm_ill,
+		wm_ill,
+		wm_ill,
+		"TAO",
+		wm_ill,
+		wm_ill,
+		wm_ill,
+		"SAO",
+		"SAO/RAW16",	/* Most liklely not needed */
+		"SAO/RAW96P",
+		"SAO/RAW96R",
+		"RAW",
+		"RAW/RAW16",
+		"RAW/RAW96P",
+		"RAW/RAW96R",
+};
+
+int		debug;		/* print debug messages */
+static	int	kdebug;		/* print kernel debug messages */
+static	int	scsi_verbose;	/* SCSI verbose flag */
+static	int	silent;		/* SCSI silent flag */
+int		lverbose;	/* static verbose flag */
+int		xdebug;		/* extended debug flag */
+
+char	*buf;			/* The transfer buffer */
+long	bufsize = -1;		/* The size of the transfer buffer */
+
+static	int	gracetime = GRACE_TIME;
+static	int	raw_speed = -1;
+static	int	dma_speed = -1;
+static	int	dminbuf = -1;	/* XXX Hack for now drive min buf fill */
+BOOL	isgui;
+static	int	didintr;
+char	*driveropts;
+static	char	*cuefilename = NULL;
+static	uid_t	oeuid = (uid_t)-1;
+
+struct timeval	starttime;
+struct timeval	wstarttime;
+struct timeval	stoptime;
+struct timeval	fixtime;
+
+static	long	fs = -1;	/* fifo (ring buffer) size */
+static Llong warn_minisize = -1L;
+
+static	int	gracewait(cdr_t *dp, BOOL *didgracep);
+static	void	cdrstats(cdr_t *dp);
+static	void	susage(int);
+static	void	usage(int);
+static	void	blusage(int);
+static	void	formattypeusage(int);
+static	void	intr(int sig);
+static	void	catchsig(int sig);
+static	int	scsi_cb(void *arg);
+static	void	intfifo(int sig);
+static	void	exscsi(int excode, void *arg);
+static	void	excdr(int excode, void *arg);
+int	read_buf(int f, char *bp, int size);
+int	fill_buf(int f, track_t *trackp, long secno, char *bp, int size);
+int	get_buf(int f, track_t *trackp, long secno, char **bpp, int size);
+int	write_secs(SCSI *usalp, cdr_t *dp, char *bp, long startsec, int bytespt,
+					  int secspt, BOOL islast);
+static	int	write_track_data(SCSI *usalp, cdr_t *, track_t *);
+int	pad_track(SCSI *usalp, cdr_t *dp, track_t *trackp, long startsec, 
+					 Llong amt, BOOL dolast, Llong *bytesp);
+int	write_buf(SCSI *usalp, cdr_t *dp, track_t *trackp, char *bp, 
+					 long startsec, Llong amt, int secsize, BOOL dolast, 
+					 Llong *bytesp);
+static	void	printdata(int, track_t *);
+static	void	printaudio(int, track_t *);
+static	void	checkfile(int, track_t *);
+static	int	checkfiles(int, track_t *);
+static	void	setleadinout(int, track_t *);
+static	void	setpregaps(int, track_t *);
+static	long	checktsize(int, track_t *);
+static	void	opentracks(track_t *);
+static	void	checksize(track_t *);
+static	BOOL	checkdsize(SCSI *usalp, cdr_t *dp, long tsize, int flags);
+static	void	raise_fdlim(void);
+static	void	raise_memlock(void);
+static	int	gargs(int, char **, int *, track_t *, char **, int *, cdr_t **,
+							int *, long *, int *, int *);
+static	void	set_trsizes(cdr_t *, int, track_t *);
+void		load_media(SCSI *usalp, cdr_t *, BOOL);
+void		unload_media(SCSI *usalp, cdr_t *, int);
+void		reload_media(SCSI *usalp, cdr_t *);
+void		set_secsize(SCSI *usalp, int secsize);
+static	int	get_dmaspeed(SCSI *usalp, cdr_t *);
+static	BOOL	do_opc(SCSI *usalp, cdr_t *, int);
+static	void	check_recovery(SCSI *usalp, cdr_t *, int);
+void		audioread(SCSI *usalp, cdr_t *, int);
+static	void	print_msinfo(SCSI *usalp, cdr_t *);
+static	void	print_toc(SCSI *usalp, cdr_t *);
+static	void	print_track(int, long, struct msf *, int, int, int);
+#if !defined(HAVE_SYS_PRIOCNTL_H)
+static	int	rt_raisepri(int);
+#endif
+void		raisepri(int);
+static	void	wait_input(void);
+static	void	checkgui(void);
+static	int	getbltype(char *optstr, long *typep);
+static	int	getformattype(char *optstr, long *typep);
+static	void	print_drflags(cdr_t *dp);
+static	void	print_wrmodes(cdr_t *dp);
+static	BOOL	check_wrmode(cdr_t *dp, int wmode, int tflags);
+static	void	set_wrmode(cdr_t *dp, int wmode, int tflags);
+static	void	linuxcheck(void);
+
+#ifdef __linux__
+static int get_cap(cap_value_t cap_array);
+#endif
+
+struct exargs {
+	SCSI	*usalp;
+	cdr_t	*dp;
+	int	old_secsize;
+	int	flags;
+	int	exflags;
+} exargs;
+
+void fifo_cleanup(void) {
+   kill_faio();
+}
+
+/* shared variables */
+int	scandevs = 0;
+char	*msifile = NULL;
+
+int main(int argc, char *argv[])
+{
+	char	*dev = NULL;
+	int	timeout = 40;	/* Set default timeout to 40s CW-7502 is slow*/
+	int	speed = -1;
+	long	flags = 0L;
+	int	blanktype = 0;
+	int	formattype = 0;
+	int	i;
+	int	tracks = 0;
+	int	trackno;
+	long	tsize;
+	track_t	track[MAX_TRACK+2];	/* Max tracks + track 0 + track AA */
+	cdr_t	*dp = (cdr_t *)0;
+	long	startsec = 0L;
+	int	errs = 0;
+	SCSI	*usalp = NULL;
+	char	errstr[80];
+	BOOL	gracedone = FALSE;
+	int     ispacket;
+	BOOL	is_cdwr = FALSE;
+	BOOL	is_dvdwr = FALSE;
+
+	buf=strstr(argv[0], "cdrecord");
+	if(buf && '\0' == buf[8]) /* lame cheater detected */
+		argv[0]="wodim";
+
+#ifdef __EMX__
+	/* This gives wildcard expansion with Non-Posix shells with EMX */
+	_wildcard(&argc, &argv);
+#endif
+	save_args(argc, argv);
+	oeuid = geteuid();		/* Remember saved set uid	*/
+
+	fillbytes(track, sizeof (track), '\0');
+	for (i = 0; i < MAX_TRACK+2; i++)
+		track[i].track = track[i].trackno = i;
+	track[0].tracktype = TOC_MASK;
+	raise_fdlim();
+	ispacket = gargs(argc, argv, &tracks, track, &dev, &timeout, &dp, &speed, &flags,
+							&blanktype, &formattype);
+	if ((track[0].tracktype & TOC_MASK) == TOC_MASK)
+		comerrno(EX_BAD, "Internal error: Bad TOC type.\n");
+
+	if (flags & F_VERSION) {
+	   fprintf(stderr,
+			 "Cdrecord-yelling-line-to-tell-frontends-to-use-it-like-version 2.01.01a03-dvd \n"
+		 "Wodim " CDRKIT_VERSION "\n"
+		 "Copyright (C) 2006 Cdrkit suite contributors\n"
+		 "Based on works from Joerg Schilling, Copyright (C) 1995-2006, J. Schilling\n"
+		 );
+	   exit(0);
+	}
+
+	checkgui();
+
+	if (debug || lverbose) {
+		printf("TOC Type: %d = %s\n",
+			track[0].tracktype & TOC_MASK,
+			toc2name[track[0].tracktype & TOC_MASK]);
+	}
+
+	if ((flags & (F_MSINFO|F_TOC|F_PRATIP|F_FIX|F_VERSION|F_CHECKDRIVE|F_INQUIRY|F_SCANBUS|F_RESET)) == 0) {
+		/*
+		 * Try to lock us im memory (will only work for root)
+		 * but you need access to root anyway to send SCSI commands.
+		 * We need to be root to open /dev/usal? or similar devices
+		 * on other OS variants and we need to be root to be able
+		 * to send SCSI commands at least on AIX and
+		 * Solaris (USCSI only) regardless of the permissions for
+		 * opening files
+		 *
+		 * XXX The following test used to be
+		 * XXX #if defined(HAVE_MLOCKALL) || defined(_POSIX_MEMLOCK)
+		 * XXX but the definition for _POSIX_MEMLOCK did change during
+		 * XXX the last 8 years and the autoconf test is better for
+		 * XXX the static case. sysconf() only makes sense if we like
+		 * XXX to check dynamically.
+		 */
+		raise_memlock();
+#if defined(HAVE_MLOCKALL)
+		/*
+		 * XXX mlockall() needs root privilleges.
+		 */
+		if (mlockall(MCL_CURRENT|MCL_FUTURE) < 0) {
+			if(lverbose>2)
+				fprintf(stderr,
+						"W: Cannot do mlockall(2). Possibly increased risk for buffer underruns.\n");
+		}
+#endif
+
+		/*
+		 * XXX raisepri() needs root privilleges.
+		 */
+		raisepri(0); /* max priority */
+		/*
+		 * XXX shmctl(id, SHM_LOCK, 0) needs root privilleges.
+		 * XXX So if we use SysV shared memory, wee need to be root.
+		 *
+		 * Note that not being able to set up a FIFO bombs us
+		 * back to the DOS ages. Trying to run cdrecord without
+		 * root privillegs is extremely silly, it breaks most
+		 * of the advanced features. We need to be at least installed
+		 * suid root or called by RBACs pfexec.
+		 */
+		init_fifo(fs);	/* Attach shared memory (still one process) */
+	}
+
+	if ((flags & F_WAITI) != 0) {
+		if (lverbose)
+			printf("Waiting for data on stdin...\n");
+		wait_input();
+	}
+
+	/*
+	 * Call usal_remote() to force loading the remote SCSI transport library
+	 * code that is located in librusal instead of the dummy remote routines
+	 * that are located inside libusal.
+	 */
+	usal_remote();
+	if (dev != NULL &&
+	    ((strncmp(dev, "HELP", 4) == 0) ||
+	    (strncmp(dev, "help", 4) == 0))) {
+		usal_help(stderr);
+		exit(0);
+	}
+
+	if( (!dev || *dev=='\0'|| 0==strcmp(dev, "-1")) && (flags & F_SCANBUS)==0 ) {
+		int64_t need_size=0L;
+		struct stat statbuf;
+		int t;
+
+		fprintf(stderr, "Device was not specified. Trying to find an appropriate drive...\n");
+
+		/* estimate how much data user wants to write */
+		for(t=1;t<=tracks;t++) { 
+			if(track[t].tracksize>=0)
+				need_size+=track[t].tracksize;
+			else if(0==stat(track[t].filename, &statbuf))
+				need_size+=statbuf.st_size;
+		}
+		usalp=open_auto(need_size, debug, lverbose);
+	}
+
+	if(!usalp)
+		usalp = usal_open(dev, errstr, sizeof(errstr), debug, lverbose);
+
+	if(!usalp)
+	{
+		errmsg("\nCannot open SCSI driver!\n"
+				"For possible targets try 'wodim --devices' or 'wodim -scanbus'.\n"
+				"For possible transport specifiers try 'wodim dev=help'.\n"
+				"For IDE/ATAPI devices configuration, see the file README.ATAPI.setup from\n"
+				"the wodim documentation.\n");
+		exit(EX_BAD);
+	}
+
+#ifdef	HAVE_PRIV_SET
+#ifdef	PRIV_DEBUG
+	fprintf(stderr, "file_dac_read: %d\n", priv_ineffect(PRIV_FILE_DAC_READ));
+#endif
+	/*
+	 * Give up privs we do not need anymore.
+	 * We no longer need:
+	 *	file_dac_read,proc_lock_memory,proc_priocntl,net_privaddr
+	 * We still need:
+	 *	sys_devices
+	 */
+	priv_set(PRIV_OFF, PRIV_EFFECTIVE,
+		PRIV_FILE_DAC_READ, PRIV_PROC_LOCK_MEMORY,
+		PRIV_PROC_PRIOCNTL, PRIV_NET_PRIVADDR, NULL);
+	priv_set(PRIV_OFF, PRIV_PERMITTED,
+		PRIV_FILE_DAC_READ, PRIV_PROC_LOCK_MEMORY,
+		PRIV_PROC_PRIOCNTL, PRIV_NET_PRIVADDR, NULL);
+	priv_set(PRIV_OFF, PRIV_INHERITABLE,
+		PRIV_FILE_DAC_READ, PRIV_PROC_LOCK_MEMORY,
+		PRIV_PROC_PRIOCNTL, PRIV_NET_PRIVADDR, PRIV_SYS_DEVICES, NULL);
+#endif
+	/*
+	 * This is only for OS that do not support fine grained privs.
+	 *
+	 * XXX Below this point we do not need root privilleges anymore.
+	 */
+	if (geteuid() != getuid()) {	/* AIX does not like to do this */
+					/* If we are not root		*/
+#ifdef	HAVE_SETREUID
+		if (setreuid(-1, getuid()) < 0)
+#else
+#ifdef	HAVE_SETEUID
+		if (seteuid(getuid()) < 0)
+#else
+		if (setuid(getuid()) < 0)
+#endif
+#endif
+			comerr("Panic cannot set back effective uid.\n");
+	}
+
+#ifdef __linux__
+	/* get the rawio capability */
+	if (get_cap(CAP_SYS_RAWIO) && (debug || lverbose>2)) 
+	{
+		perror("Warning: Cannot gain SYS_RAWIO capability");
+		fprintf(stderr, "Possible reason: wodim not installed SUID root.\n");
+	}
+#endif
+
+	/*
+	 * WARNING: We now are no more able to do any privilleged operation
+	 * unless we have been called by root.
+	 *
+	 * XXX It may be that we later get problems in init_faio() because
+	 * XXX this function calls raisepri() to lower the priority slightly.
+	 */
+	usal_settimeout(usalp, timeout);
+	usalp->verbose = scsi_verbose;
+	usalp->silent = silent;
+	usalp->debug = debug;
+	usalp->kdebug = kdebug;
+	usalp->cap->c_bsize = DATA_SEC_SIZE;
+
+	if ((flags & F_MSINFO) == 0 || lverbose) {
+		char	*vers;
+		char	*auth;
+
+
+		if(lverbose)
+			fprintf(stderr, "Wodim version: " CDRKIT_VERSION "\n");
+
+		vers = usal_version(0, SCG_VERSION);
+		auth = usal_version(0, SCG_AUTHOR);
+		if(lverbose >1 && auth && vers)
+			fprintf(stderr, "Using libusal version '%s-%s'.\n", auth, vers);
+
+
+		vers = usal_version(usalp, SCG_RVERSION);
+		auth = usal_version(usalp, SCG_RAUTHOR);
+		if (lverbose > 1 && vers && auth)
+			fprintf(stderr, "Using remote transport code version '%s-%s'\n", auth, vers);
+	}
+
+	if (lverbose && driveropts)
+		printf("Driveropts: '%s'\n", driveropts);
+
+/*	bufsize = usal_bufsize(usalp, CDR_BUF_SIZE);*/
+	bufsize = usal_bufsize(usalp, bufsize);
+	if (lverbose || debug)
+		fprintf(stderr, "SCSI buffer size: %ld\n", bufsize);
+	if ((buf = usal_getbuf(usalp, bufsize)) == NULL)
+		comerr("Cannot get SCSI I/O buffer.\n");
+
+	if (scandevs)
+		return (list_devices(usalp, stdout, 0));
+
+	if ((flags & F_SCANBUS) != 0) {
+		select_target(usalp, stdout);
+		exit(0);
+	}
+	if ((flags & F_RESET) != 0) {
+		if (usal_reset(usalp, SCG_RESET_NOP) < 0)
+			comerr("Cannot reset (OS does not implement reset).\n");
+		if (usal_reset(usalp, SCG_RESET_TGT) >= 0)
+			exit(0);
+		if (usal_reset(usalp, SCG_RESET_BUS) < 0)
+			comerr("Cannot reset target.\n");
+		exit(0);
+	}
+
+	/*
+	 * First try to check which type of SCSI device we
+	 * have.
+	if (debug || lverbose)
+		printf("atapi: %d\n", usal_isatapi(usalp));
+	 */
+	usalp->silent++;
+	test_unit_ready(usalp);	/* eat up unit attention */
+	usalp->silent--;
+	if (!do_inquiry(usalp, (flags & F_MSINFO) == 0 || lverbose)) {
+		errmsgno(EX_BAD, "Cannot do inquiry for CD/DVD-Recorder.\n");
+		if (unit_ready(usalp))
+			errmsgno(EX_BAD, "The unit seems to be hung and needs power cycling.\n");
+		exit(EX_BAD);
+	}
+#ifdef	GCONF
+	/*
+	 * Debug only
+	 */
+	{
+		extern	void	gconf(SCSI *);
+
+		if (lverbose > 2)
+			gconf(usalp);
+	}
+#endif
+
+	if ((flags & F_PRCAP) != 0) {
+		print_capabilities(usalp);
+		print_capabilities_mmc4(usalp);
+		exit(0);
+	}
+	if ((flags & F_INQUIRY) != 0)
+		exit(0);
+
+	if (dp == (cdr_t *)NULL) {	/* No driver= option specified	*/
+		dp = get_cdrcmds(usalp);	/* Calls dp->cdr_identify()	*/
+	}
+	else if (!is_unknown_dev(usalp) && dp != get_cdrcmds(usalp)) {
+		errmsgno(EX_BAD, "WARNING: Trying to use other driver on known device.\n");
+	}
+        is_mmc(usalp, &is_cdwr, &is_dvdwr);
+	if (ispacket) {
+		if (is_dvdwr) {
+			track[0].flags |= TI_PACKET; 
+			/*XXX put here to only affect DVD writing, should be in gargs.
+			 * however if set in args for all mode, packet writing is then
+			 * broken for all disc as cdrecord assume that PACKET imply TAO which  
+			 * is not true at all???? */ 
+			track[0].flags &= ~TI_TAO;
+		}
+	}
+
+	if (dp == (cdr_t *)0)
+		comerrno(EX_BAD, "Sorry, no supported CD/DVD-Recorder found on this target.\n");
+
+	/* DVD does not support TAO */
+	if (dp->is_dvd) {
+	  if(lverbose>1)
+		fprintf(stderr, "Using Session At Once (SAO) for DVD mode.\n");
+	  dp->cdr_flags |= F_SAO;
+	  for (i = 0; i <= MAX_TRACK; i++) {
+		track[i].flags &= ~TI_TAO;
+		track[i].flags |= TI_SAO;
+	  }
+	}
+
+	if (!is_cddrive(usalp))
+		comerrno(EX_BAD, "Sorry, no CD/DVD-Drive found on this target.\n");
+	/*
+	 * The driver is known, set up data structures...
+	 */
+	{
+		cdr_t	*ndp;
+		dstat_t	*dsp;
+
+		ndp = malloc(sizeof (cdr_t));
+		dsp = malloc(sizeof (dstat_t));
+		if (ndp == NULL || dsp == NULL)
+			comerr("Cannot allocate memory for driver structure.\n");
+		movebytes(dp, ndp, sizeof (cdr_t));
+		dp = ndp;
+		dp->cdr_flags |= CDR_ALLOC;
+		dp->cdr_cmdflags = flags;
+
+		fillbytes(dsp, sizeof (*dsp), '\0');
+		dsp->ds_minbuf = 0xFFFF;
+		dp->cdr_dstat = dsp;
+	}
+
+	if ((flags & (F_MSINFO|F_TOC|F_LOAD|F_DLCK|F_EJECT)) == 0 ||
+			tracks > 0 ||
+			cuefilename != NULL)
+	{
+		if ((dp->cdr_flags & CDR_ISREADER) != 0) {
+			errmsgno(EX_BAD,
+					"Sorry, no CD/DVD-Recorder or unsupported CD/DVD-Recorder found on this target.\n");
+		}
+
+		if (!is_mmc(usalp, &is_cdwr, &is_dvdwr))
+			is_cdwr = TRUE;			/* If it is not MMC, it must be a CD writer */
+
+		if (is_dvdwr && !set_cdrcmds("mmc_mdvd", (cdr_t **)NULL)) {
+			errmsgno(EX_BAD,
+					"Internal error, DVD driver failure. Please report to debburn-devel@lists.alioth.debian.org.\n");
+		}
+		/*
+		 * Only exit if this is not the ProDVD test binary.
+		 */
+		if (!is_cdwr)
+			exit(EX_BAD);
+	}
+
+	/*
+	 * Set up data structures for current drive state.
+	 */
+	if ((*dp->cdr_attach)(usalp, dp) != 0)
+		comerrno(EX_BAD, "Cannot attach driver for CD/DVD-Recorder.\n");
+
+	if (lverbose > 1) {
+		printf("Drive current speed: %d\n", dp->cdr_dstat->ds_dr_cur_wspeed);
+		printf("Drive default speed: %d\n", dp->cdr_speeddef);
+		printf("Drive max speed    : %d\n", dp->cdr_speedmax);
+	}
+	if (speed > (int)dp->cdr_speedmax && (flags & F_FORCE) == 0)
+		speed = dp->cdr_speedmax;
+	if (speed < 0)
+		speed = dp->cdr_speeddef;
+
+	if (lverbose > 1) {
+		printf("Selected speed     : %d\n", speed);
+	}
+	dp->cdr_dstat->ds_wspeed = speed; /* XXX Remove 'speed' in future */
+
+	exargs.usalp	   = usalp;
+	exargs.dp	   = dp;
+	exargs.old_secsize = -1;
+	exargs.flags	   = flags;
+
+	if ((flags & F_MSINFO) == 0 || lverbose) {
+		printf("Using %s (%s).\n", dp->cdr_drtext, dp->cdr_drname);
+		print_drflags(dp);
+		print_wrmodes(dp);
+	}
+	usalp->silent++;
+	if ((debug || lverbose)) {
+		tsize = -1;
+		if ((*dp->cdr_buffer_cap)(usalp, &tsize, (long *)0) < 0 || tsize < 0) {
+			if (read_buffer(usalp, buf, 4, 0) >= 0)
+				tsize = a_to_u_4_byte(buf);
+		}
+		if (tsize > 0) {
+			printf("Drive buf size : %lu = %lu KB\n",
+						tsize, tsize >> 10);
+		}
+	}
+	usalp->silent--;
+
+	dma_speed = get_dmaspeed(usalp, dp);
+
+	if ((debug || lverbose) && dma_speed > 0) {
+		/*
+		 * We do not yet know what medium type is in...
+		 */
+		printf("Drive DMA Speed: %d kB/s %dx CD %dx DVD\n",
+			dma_speed, dma_speed/176, dma_speed/1385);
+	}
+	if ((tracks > 0 || cuefilename != NULL) && (debug || lverbose))
+		printf("FIFO size      : %lu = %lu KB\n", fs, fs >> 10);
+
+#ifdef	HAVE_LIB_EDC_ECC
+	if ((flags & F_RAW) != 0 && (dp->cdr_dstat->ds_flags & DSF_DVD) == 0)
+		raw_speed = encspeed(debug || lverbose);
+#endif
+
+	if ((flags & F_CHECKDRIVE) != 0)
+		exit(0);
+
+	if ((flags & F_ABORT) != 0) {
+		/*
+		 * flush cache is not supported by CD-ROMs avoid prob with -toc
+		 */
+		usalp->silent++;
+		scsi_flush_cache(usalp, FALSE);
+		(*dp->cdr_abort_session)(usalp, dp);
+		usalp->silent--;
+		exit(0);
+	}
+
+	if (tracks == 0 && cuefilename == NULL &&
+	    (flags & (F_FIX|F_BLANK)) == 0 && (flags & F_EJECT) != 0) {
+		/*
+		 * Do not check if the unit is ready here to allow to open
+		 * an empty unit too.
+		 */
+		unload_media(usalp, dp, flags);
+		exit(0);
+	}
+	flush();
+
+	if (cuefilename) {
+		parsecue(cuefilename, track);
+		tracks = track[0].tracks;
+	} else {
+		opentracks(track);
+	}
+
+	if (tracks > 1)
+		sleep(2);	/* Let the user watch the inquiry messages */
+
+	if (tracks > 0 && !check_wrmode(dp, flags, track[1].flags))
+		comerrno(EX_BAD, "Illegal write mode for this drive.\n");
+
+	if ((track[0].flags & TI_TEXT) == 0 &&	/* CD-Text not yet processed */
+	    (track[MAX_TRACK+1].flags & TI_TEXT) != 0) {
+		/*
+		 * CD-Text from textfile= or from CUE CDTEXTFILE will win
+		 * over CD-Text from *.inf files and over CD-Text from
+		 * CUE SONGWRITER, ...
+		 */
+		packtext(tracks, track);
+		track[0].flags |= TI_TEXT;
+	}
+#ifdef	CLONE_WRITE
+	if (flags & F_CLONE) {
+		clone_toc(track);
+		clone_tracktype(track);
+	}
+#endif
+	setleadinout(tracks, track);
+	set_trsizes(dp, tracks, track);
+	setpregaps(tracks, track);
+	checkfiles(tracks, track);
+	tsize = checktsize(tracks, track);
+
+	/*
+	 * Make wm2name[wrmode] work.
+	 * This must be done after the track flags have been set up
+	 * by the functions above.
+	 */
+	if (tracks == 0 && (flags & F_BLANK) != 0)
+		dp->cdr_dstat->ds_wrmode = WM_BLANK;
+	else if (tracks == 0 && (flags & F_FORMAT) != 0)
+		dp->cdr_dstat->ds_wrmode = WM_FORMAT;
+	else
+		set_wrmode(dp, flags, track[1].flags);
+
+	/*
+	 * Debug only
+	 */
+	{
+		void	*cp = NULL;
+
+		(*dp->cdr_gen_cue)(track, &cp, FALSE);
+		if (cp)
+			free(cp);
+	}
+
+	/*
+	 * Create Lead-in data. Only needed in RAW mode.
+	 */
+	do_leadin(track);
+
+
+	/*
+	 * Install exit handler before we change the drive status.
+	 */
+	on_comerr(exscsi, &exargs);
+
+	if ((flags & F_FORCE) == 0)
+		load_media(usalp, dp, TRUE);
+
+	if ((flags & (F_LOAD|F_DLCK)) != 0) {
+		if ((flags & F_DLCK) == 0) {
+			usalp->silent++;		/* silently		*/
+			scsi_prevent_removal(
+				usalp, 0);	/* allow manual open	*/
+			usalp->silent--;		/* if load failed...	*/
+		}
+		exit(0);			/* we did not change status */
+	}
+	exargs.old_secsize = sense_secsize(usalp, 1);
+	if (exargs.old_secsize < 0)
+		exargs.old_secsize = sense_secsize(usalp, 0);
+	if (debug)
+		printf("Current Secsize: %d\n", exargs.old_secsize);
+	usalp->silent++;
+	if (read_capacity(usalp) < 0) {
+		if (exargs.old_secsize > 0)
+			usalp->cap->c_bsize = exargs.old_secsize;
+	}
+	usalp->silent--;
+	if (exargs.old_secsize < 0)
+		exargs.old_secsize = usalp->cap->c_bsize;
+	if (exargs.old_secsize != usalp->cap->c_bsize)
+		errmsgno(EX_BAD, "Warning: blockdesc secsize %d differs from cap secsize %d\n",
+				exargs.old_secsize, usalp->cap->c_bsize);
+
+	if (lverbose)
+		printf("Current Secsize: %d\n", exargs.old_secsize);
+
+	if (exargs.old_secsize > 0 && exargs.old_secsize != DATA_SEC_SIZE) {
+		/*
+		 * Some drives (e.g. Plextor) don't like to write correctly
+		 * in SAO mode if the sector size is set to 512 bytes.
+		 * In addition, wodim -msinfo will not work properly
+		 * if the sector size is not 2048 bytes.
+		 */
+		set_secsize(usalp, DATA_SEC_SIZE);
+	}
+
+	/*
+	 * Is this the right place to do this ?
+	 */
+	check_recovery(usalp, dp, flags);
+
+/*audioread(dp, flags);*/
+/*unload_media(usalp, dp, flags);*/
+/*return 0;*/
+	if (flags & F_WRITE)
+		dp->cdr_dstat->ds_cdrflags |= RF_WRITE;
+	if (flags & F_BLANK)
+		dp->cdr_dstat->ds_cdrflags |= RF_BLANK;
+	if (flags & F_PRATIP || lverbose > 0) {
+		dp->cdr_dstat->ds_cdrflags |= RF_PRATIP;
+	}
+	if (flags & F_IMMED || dminbuf > 0) {
+		if (dminbuf <= 0)
+			dminbuf = 50;
+		if (lverbose <= 0)	/* XXX Hack needed for now */
+			lverbose++;
+		dp->cdr_dstat->ds_cdrflags |= RF_WR_WAIT;
+	}
+	if ((*dp->cdr_getdisktype)(usalp, dp) < 0) {
+		errmsgno(EX_BAD, "Cannot get disk type.\n");
+		if ((flags & F_FORCE) == 0)
+			comexit(EX_BAD);
+	}
+	if (flags & F_PRATIP) {
+		comexit(0);
+	}
+	/*
+	 * The next actions should depend on the disk type.
+	 */
+	if (dma_speed > 0) {
+		if ((dp->cdr_dstat->ds_flags & DSF_DVD) == 0)
+			dma_speed /= 176;
+		else
+			dma_speed /= 1385;
+	}
+
+	/*
+	 * Init drive to default modes:
+	 *
+	 * We set TAO unconditionally to make checkdsize() work
+	 * currectly in SAO mode too.
+	 *
+	 * At least MMC drives will not return the next writable
+	 * address we expect when the drive's write mode is set
+	 * to SAO. We need this address for mkisofs and thus
+	 * it must be the first user accessible sector and not the
+	 * first sector of the pregap.
+	 *
+	 * XXX The ACER drive:
+	 * XXX Vendor_info    : 'ATAPI   '
+	 * XXX Identifikation : 'CD-R/RW 8X4X32  '
+	 * XXX Revision       : '5.EW'
+	 * XXX Will not return from -dummy to non-dummy without
+	 * XXX opening the tray.
+	 */
+	usalp->silent++;
+	if ((*dp->cdr_init)(usalp, dp) < 0)
+		comerrno(EX_BAD, "Cannot init drive.\n");
+	usalp->silent--;
+
+	if (flags & F_SETDROPTS) {
+		/*
+		 * Note that the set speed function also contains
+		 * drive option processing for speed related drive options.
+		 */
+		if ((*dp->cdr_opt1)(usalp, dp) < 0) {
+			errmsgno(EX_BAD, "Cannot set up 1st set of driver options.\n");
+		}
+		if ((*dp->cdr_set_speed_dummy)(usalp, dp, &speed) < 0) {
+			errmsgno(EX_BAD, "Cannot set speed/dummy.\n");
+		}
+		dp->cdr_dstat->ds_wspeed = speed; /* XXX Remove 'speed' in future */
+		if ((*dp->cdr_opt2)(usalp, dp) < 0) {
+			errmsgno(EX_BAD, "Cannot set up 2nd set of driver options.\n");
+		}
+		comexit(0);
+	}
+	/*
+	 * XXX If dp->cdr_opt1() ever affects the result for
+	 * XXX the multi session info we would need to move it here.
+	 */
+	if (flags & F_MSINFO) {
+		print_msinfo(usalp, dp);
+		comexit(0);
+	}
+	if (flags & F_TOC) {
+		print_toc(usalp, dp);
+		comexit(0);
+	}
+#ifdef	XXX
+	if ((*dp->cdr_check_session)() < 0) {
+		comexit(EX_BAD);
+	}
+#endif
+	{
+		Int32_t omb = dp->cdr_dstat->ds_maxblocks;
+
+		if ((*dp->cdr_opt1)(usalp, dp) < 0) {
+			errmsgno(EX_BAD, "Cannot set up 1st set of driver options.\n");
+		}
+		if (tsize > 0 && omb != dp->cdr_dstat->ds_maxblocks) {
+			printf("Disk size changed by user options.\n");
+			printf("Checking disk capacity according to new values.\n");
+		}
+	}
+	if (tsize == 0) {
+		if (tracks > 0) {
+			errmsgno(EX_BAD,
+			"WARNING: Total disk size unknown. Data may not fit on disk.\n");
+		}
+	} else if (tracks > 0) {
+		/*
+		 * XXX How do we let the user check the remaining
+		 * XXX disk size witout starting the write process?
+		 */
+		if (!checkdsize(usalp, dp, tsize, flags))
+			comexit(EX_BAD);
+	}
+	if (tracks > 0 && fs > 0l) {
+#if defined(USE_POSIX_PRIORITY_SCHEDULING) && defined(HAVE_SETREUID)
+		/*
+		 * Hack to work around the POSIX design bug in real time
+		 * priority handling: we need to be root even to lower
+		 * our priority.
+		 * Note that we need to find a more general way that works
+		 * even on OS that do not support getreuid() which is *BSD
+		 * and SUSv3 only.
+		 */
+		if (oeuid != getuid()) {
+			if (setreuid(-1, oeuid) < 0)
+				errmsg("Could set back effective uid.\n");
+		}
+
+#endif
+		/*
+		 * fork() here to start the extra process needed for
+		 * improved buffering.
+		 */
+		if (!init_faio(track, bufsize))
+			fs = 0L;
+		else
+			on_comerr(excdr, &exargs);
+
+    atexit(fifo_cleanup);
+
+#if defined(USE_POSIX_PRIORITY_SCHEDULING) && defined(HAVE_SETREUID)
+		/*
+		 * XXX Below this point we never need root privilleges anymore.
+		 */
+		if (geteuid() != getuid()) {	/* AIX does not like to do this */
+						/* If we are not root		*/
+			if (setreuid(-1, getuid()) < 0)
+				comerr("Panic cannot set back effective uid.\n");
+		}
+#ifdef __linux__
+		if (get_cap(CAP_SYS_RAWIO) && (debug || lverbose>2))
+			perror("Error: Cannot gain SYS_RAWIO capability, is wodim installed SUID root? Reason");
+#endif
+
+#endif
+	}
+
+	if ((*dp->cdr_set_speed_dummy)(usalp, dp, &speed) < 0) {
+		errmsgno(EX_BAD, "Cannot set speed/dummy.\n");
+		if ((flags & F_FORCE) == 0)
+			comexit(EX_BAD);
+	}
+	dp->cdr_dstat->ds_wspeed = speed; /* XXX Remove 'speed' in future */
+	if ((flags & F_WRITE) != 0 && raw_speed >= 0) {
+		int	max_raw = (flags & F_FORCE) != 0 ? raw_speed:raw_speed/2;
+
+		if (getenv("CDR_FORCERAWSPEED"))
+			max_raw = raw_speed;
+
+		for (i = 1; i <= MAX_TRACK; i++) {
+			/*
+			 * Check for Clone tracks
+			 */
+			if ((track[i].sectype & ST_MODE_RAW) != 0)
+				continue;
+			/*
+			 * Check for non-data tracks
+			 */
+			if ((track[i].sectype & ST_MODE_MASK) == ST_MODE_AUDIO)
+				continue;
+
+			if (speed > max_raw) {
+				errmsgno(EX_BAD,
+				"Processor too slow. Cannot write RAW data at speed %d.\n",
+				speed);
+				comerrno(EX_BAD, "Max RAW data speed on this processor is %d.\n",
+				max_raw);
+			}
+			break;
+		}
+	}
+	if (tracks > 0 && (flags & F_WRITE) != 0 && dma_speed > 0) {
+		int max_dma = (dma_speed+1)*4/5; /* use an empirical formula to estimate available bandwith */
+
+        if((flags & F_FORCE) != 0 || getenv("CDR_FORCESPEED"))
+			max_dma = dma_speed;
+
+		if (speed > max_dma) {
+			errmsgno(EX_BAD,
+			"DMA speed too slow (OK for %dx). Cannot write at speed %dx.\n",
+					max_dma, speed);
+			if ((dp->cdr_dstat->ds_cdrflags & RF_BURNFREE) == 0) {
+				errmsgno(EX_BAD, "Max DMA data speed is %d.\n", max_dma);
+				comerrno(EX_BAD, "Try to use 'driveropts=burnfree'.\n");
+			}
+		}
+	}
+	if ((flags & (F_WRITE|F_BLANK)) != 0 &&
+				(dp->cdr_dstat->ds_flags & DSF_ERA) != 0) {
+		if (xdebug) {
+			printf("Current speed %d, medium low speed: %d medium high speed: %d\n",
+				speed,
+				dp->cdr_dstat->ds_at_min_speed,
+				dp->cdr_dstat->ds_at_max_speed);
+		}
+		if (dp->cdr_dstat->ds_at_max_speed > 0 &&
+				speed <= 8 &&
+				speed > (int)dp->cdr_dstat->ds_at_max_speed) {
+			/*
+			 * Be careful here: 10x media may be written faster.
+			 * The current code will work as long as there is no
+			 * writer that can only write faster than 8x
+			 */
+			if ((flags & F_FORCE) == 0) {
+				errmsgno(EX_BAD,
+				"Write speed %d of medium not sufficient for this writer.\n",
+					dp->cdr_dstat->ds_at_max_speed);
+				comerrno(EX_BAD,
+				"You may have used an ultra low speed medium on a high speed writer.\n");
+			}
+		}
+
+		if ((dp->cdr_dstat->ds_flags & DSF_ULTRASPP_ERA) != 0 &&
+		    (speed < 16 || (dp->cdr_cdrw_support & CDR_CDRW_ULTRAP) == 0)) {
+			if ((dp->cdr_cdrw_support & CDR_CDRW_ULTRAP) == 0) {
+				comerrno(EX_BAD,
+				"Trying to use ultra high speed+ medium on a writer which is not\ncompatible with ultra high speed+ media.\n");
+			} else if ((flags & F_FORCE) == 0) {
+				comerrno(EX_BAD,
+				"Probably trying to use ultra high speed+ medium on improper writer.\n");
+			}
+		} else if ((dp->cdr_dstat->ds_flags & DSF_ULTRASP_ERA) != 0 &&
+		    (speed < 16 || (dp->cdr_cdrw_support & CDR_CDRW_ULTRA) == 0)) {
+			if ((dp->cdr_cdrw_support & CDR_CDRW_ULTRA) == 0) {
+				comerrno(EX_BAD,
+				"Trying to use ultra high speed medium on a writer which is not\ncompatible with ultra high speed media.\n");
+			} else if ((flags & F_FORCE) == 0) {
+				comerrno(EX_BAD,
+				"Probably trying to use ultra high speed medium on improper writer.\n");
+			}
+		}
+		if (dp->cdr_dstat->ds_at_min_speed >= 4 &&
+				dp->cdr_dstat->ds_at_max_speed > 4 &&
+				dp->cdr_dstat->ds_dr_max_wspeed <= 4) {
+			if ((flags & F_FORCE) == 0) {
+				comerrno(EX_BAD,
+				"Trying to use high speed medium on low speed writer.\n");
+			}
+		}
+		if ((int)dp->cdr_dstat->ds_at_min_speed > speed) {
+			if ((flags & F_FORCE) == 0) {
+				errmsgno(EX_BAD,
+				"Write speed %d of writer not sufficient for this medium.\n",
+					speed);
+				errmsgno(EX_BAD,
+				"You did use a %s speed medium on an improper writer or\n",
+				dp->cdr_dstat->ds_flags & DSF_ULTRASP_ERA ?
+				"ultra high": "high");
+				comerrno(EX_BAD,
+				"you used a speed=# option with a speed too low for this medium.\n");
+			}
+		}
+	}
+	if ((flags & (F_BLANK|F_FORCE)) == (F_BLANK|F_FORCE)) {
+		printf("Waiting for drive to calm down.\n");
+		wait_unit_ready(usalp, 120);
+		if (gracewait(dp, &gracedone) < 0) {
+			/*
+			 * In case kill() did not work ;-)
+			 */
+			errs++;
+			goto restore_it;
+		}
+		scsi_blank(usalp, 0L, blanktype, FALSE);
+	}
+
+	/*
+	 * Last chance to quit!
+	 */
+	if (gracewait(dp, &gracedone) < 0) {
+		/*
+		 * In case kill() did not work ;-)
+		 */
+		errs++;
+		goto restore_it;
+	}
+ 	
+ 	if (dp->profile == 0x2B && flags & F_SAO && tsize > 0) {
+ 	    printf("Preparing middle zone location for this DVD+R dual layer disc\n");
+ 	    if (!dp->cdr_layer_split(usalp, dp, tsize)) {
+ 		errmsgno(EX_BAD, "Cannot send structure for middle zone location.\n");
+ 		comexit(EX_BAD);
+ 	    }
+ 	}
+
+	if (tracks > 0 && fs > 0l) {
+		/*
+		 * Wait for the read-buffer to become full.
+		 * This should be take no extra time if the input is a file.
+		 * If the input is a pipe (e.g. mkisofs) this can take a
+		 * while. If mkisofs dumps core before it starts writing,
+		 * we abort before the writing process started.
+		 */
+		if (!await_faio()) {
+			comerrno(EX_BAD, "Input buffer error, aborting.\n");
+		}
+	}
+	wait_unit_ready(usalp, 120);
+
+	starttime.tv_sec = 0;
+	wstarttime.tv_sec = 0;
+	stoptime.tv_sec = 0;
+	fixtime.tv_sec = 0;
+	if (gettimeofday(&starttime, (struct timezone *)0) < 0)
+		errmsg("Cannot get start time\n");
+
+	/*
+	 * Blank the media if we were requested to do so
+	 */
+	if (flags & F_BLANK) {
+		/*
+		 * Do not abort if OPC failes. Just give it a chance
+		 * for better laser power calibration than without OPC.
+		 *
+		 * Ricoh drives return with a vendor unique sense code.
+		 * This is most likely because they refuse to do OPC
+		 * on a non blank media.
+		 */
+		usalp->silent++;
+		do_opc(usalp, dp, flags);
+		usalp->silent--;
+		wait_unit_ready(usalp, 120);
+		if (gettimeofday(&starttime, (struct timezone *)0) < 0)
+			errmsg("Cannot get start time\n");
+
+		if ((*dp->cdr_blank)(usalp, dp, 0L, blanktype) < 0) {
+			errmsgno(EX_BAD, "Cannot blank disk, aborting.\n");
+			if (blanktype != BLANK_DISC) {
+				errmsgno(EX_BAD, "Some drives do not support all blank types.\n");
+				errmsgno(EX_BAD, "Try again with wodim blank=all.\n");
+			}
+			comexit(EX_BAD);
+		}
+		if (gettimeofday(&fixtime, (struct timezone *)0) < 0)
+			errmsg("Cannot get blank time\n");
+		if (lverbose)
+			prtimediff("Blanking time: ", &starttime, &fixtime);
+
+		/*
+		 * XXX Erst blank und dann format?
+		 * XXX Wenn ja, dann hier (flags & F_FORMAT) testen
+		 *
+		 * EB: nee, besser nicht
+		 */
+		if (!wait_unit_ready(usalp, 240) || tracks == 0) {
+			comexit(0);
+		}
+	}
+	if (flags & F_FORMAT) {
+		printf("wodim: media format asked\n");
+		/*
+		* Do not abort if OPC failes. Just give it a chance
+		* for better laser power calibration than without OPC.
+		*
+		* Ricoh drives return with a vendor unique sense code.
+		* This is most likely because they refuse to do OPC
+		* on a non blank media.
+		*/
+		usalp->silent++;
+		do_opc(usalp, dp, flags);
+		usalp->silent--;
+		wait_unit_ready(usalp, 120);
+		if (gettimeofday(&starttime, (struct timezone *)0) < 0)
+			errmsg("Cannot get start time\n");
+
+		if ((*dp->cdr_format)(usalp, dp, formattype) < 0) {
+			errmsgno(EX_BAD, "Cannot format disk, aborting.\n");
+			comexit(EX_BAD);
+		}
+		if (gettimeofday(&fixtime, (struct timezone *)0) < 0)
+			errmsg("Cannot get format time\n");
+		if (lverbose)
+			prtimediff("Formatting time: ", &starttime, &fixtime);
+
+		if (!wait_unit_ready(usalp, 240) || tracks == 0) {
+			comexit(0);
+		}
+		if (gettimeofday(&starttime, (struct timezone *)0) < 0)
+			errmsg("Cannot get start time\n");
+	}
+	/*
+	* Reset start time so we will not see blanking time and
+	* writing time counted together.
+	*/
+	if (gettimeofday(&starttime, (struct timezone *)0) < 0)
+		errmsg("Cannot get start time\n");
+	if (tracks == 0 && (flags & F_FIX) == 0)
+	comerrno(EX_BAD, "No tracks found.\n");
+	/*
+	 * Get the number of the next recordable track by reading the TOC and
+	 * use the number the last current track number.
+	 */
+	usalp->silent++;
+	if (read_tochdr(usalp, dp, NULL, &trackno) < 0) {
+		trackno = 0;
+	}
+	usalp->silent--;
+      
+	/* If it is DVD, the information in TOC is fabricated :)
+	   The real information is from read disk info command*/
+	if((dp->cdr_dstat->ds_disktype&DT_DVD) && (dp->cdr_dstat->ds_trlast>0)){
+		trackno=dp->cdr_dstat->ds_trlast-1;
+		if (lverbose > 2)
+			printf("trackno=%d\n",trackno);
+	}
+
+	if ((tracks + trackno) > MAX_TRACK) {
+		/*
+		 * XXX How many tracks are allowed on a DVD?
+		 */
+		comerrno(EX_BAD, "Too many tracks for this disk, last track number is %d.\n",
+				tracks + trackno);
+	}
+
+	for (i = 0; i <= tracks+1; i++) {	/* Lead-in ... Lead-out */
+		track[i].trackno = i + trackno;	/* Set up real track #	*/
+	}
+
+	if ((*dp->cdr_opt2)(usalp, dp) < 0) {
+		errmsgno(EX_BAD, "Cannot set up 2nd set of driver options.\n");
+	}
+
+	/*
+	 * Now we actually start writing to the CD/DVD.
+	 * XXX Check total size of the tracks and remaining size of disk.
+	 */
+	if ((*dp->cdr_open_session)(usalp, dp, track) < 0) {
+		comerrno(EX_BAD, "Cannot open new session.\n");
+	}
+	if (!do_opc(usalp, dp, flags))
+		comexit(EX_BAD);
+
+	/*
+	 * As long as open_session() will do nothing but
+	 * set up parameters, we may leave fix_it here.
+	 * I case we have to add an open_session() for a drive
+	 * that wants to do something that modifies the disk
+	 * We have to think about a new solution.
+	 */
+	if (flags & F_FIX)
+		goto fix_it;
+
+	/*
+	 * This call may modify trackp[i].trackstart for all tracks.
+	 */
+	if ((*dp->cdr_write_leadin)(usalp, dp, track) < 0)
+		comerrno(EX_BAD, "Could not write Lead-in.\n");
+
+	if (lverbose && (dp->cdr_dstat->ds_cdrflags & RF_LEADIN) != 0) {
+
+		if (gettimeofday(&fixtime, (struct timezone *)0) < 0)
+			errmsg("Cannot get lead-in write time\n");
+		prtimediff("Lead-in write time: ", &starttime, &fixtime);
+	}
+
+	if (gettimeofday(&wstarttime, (struct timezone *)0) < 0)
+		errmsg("Cannot get start time\n");
+	for (i = 1; i <= tracks; i++) {
+		startsec = 0L;
+
+		if ((*dp->cdr_open_track)(usalp, dp, &track[i]) < 0) {
+			errmsgno(EX_BAD, "Cannot open next track.\n");
+			errs++;
+			break;
+		}
+
+		if ((flags & (F_SAO|F_RAW)) == 0) {
+			if ((*dp->cdr_next_wr_address)(usalp, &track[i], &startsec) < 0) {
+				errmsgno(EX_BAD, "Cannot get next writable address.\n");
+				errs++;
+				break;
+			}
+			track[i].trackstart = startsec;
+		}
+		if (debug || lverbose) {
+			printf("Starting new track at sector: %ld\n",
+						track[i].trackstart);
+			flush();
+		}
+		if (write_track_data(usalp, dp, &track[i]) < 0) {
+			if (cdr_underrun(usalp)) {
+				errmsgno(EX_BAD,
+				"The current problem looks like a buffer underrun.\n");
+				if ((dp->cdr_dstat->ds_cdrflags & RF_BURNFREE) == 0)
+					errmsgno(EX_BAD, "Try to use 'driveropts=burnfree'.\n");
+				else {
+					errmsgno(EX_BAD, "It looks like 'driveropts=burnfree' does not work for this drive.\n");
+					errmsgno(EX_BAD, "Please report.\n");
+				}
+
+				errmsgno(EX_BAD,
+				"Make sure that you are root, enable DMA and check your HW/OS set up.\n");
+			} else {
+				errmsgno(EX_BAD, "A write error occured.\n");
+				errmsgno(EX_BAD, "Please properly read the error message above.\n");
+			}
+			errs++;
+			sleep(5);
+			unit_ready(usalp);
+			(*dp->cdr_close_track)(usalp, dp, &track[i]);
+			break;
+		}
+		if ((*dp->cdr_close_track)(usalp, dp, &track[i]) < 0) {
+			/*
+			 * Check for "Dummy blocks added" message first.
+			 */
+			if (usal_sense_key(usalp) != SC_ILLEGAL_REQUEST ||
+					usal_sense_code(usalp) != 0xB5) {
+				errmsgno(EX_BAD, "Cannot close track.\n");
+				errs++;
+				break;
+			}
+		}
+	}
+fix_it:
+	if (gettimeofday(&stoptime, (struct timezone *)0) < 0)
+		errmsg("Cannot get stop time\n");
+	cdrstats(dp);
+
+	if (flags & F_RAW) {
+		if (lverbose) {
+			printf("Writing Leadout...\n");
+			flush();
+		}
+		write_leadout(usalp, dp, track);
+	}
+	if ((flags & F_NOFIX) == 0) {
+		if (lverbose) {
+			printf("Fixating...\n");
+			flush();
+		}
+		if ((*dp->cdr_fixate)(usalp, dp, track) < 0) {
+			/*
+			 * Ignore fixating errors in dummy mode.
+			 */
+			if ((flags & F_DUMMY) == 0) {
+				errmsgno(EX_BAD, "Cannot fixate disk.\n");
+				errs++;
+			}
+		}
+		if (gettimeofday(&fixtime, (struct timezone *)0) < 0)
+			errmsg("Cannot get fix time\n");
+		if (lverbose)
+			prtimediff("Fixating time: ", &stoptime, &fixtime);
+	}
+	if ((dp->cdr_dstat->ds_cdrflags & RF_DID_CDRSTAT) == 0) {
+		dp->cdr_dstat->ds_cdrflags |= RF_DID_CDRSTAT;
+		(*dp->cdr_stats)(usalp, dp);
+	}
+	if ((flags & (F_RAW|F_EJECT)) == F_RAW) {
+		/*
+		 * Most drives seem to forget to reread the TOC from disk
+		 * if they are in RAW mode.
+		 */
+		usalp->silent++;
+		if (read_tochdr(usalp, dp, NULL, NULL) < 0) {
+			usalp->silent--;
+			if ((flags & F_DUMMY) == 0)
+				reload_media(usalp, dp);
+		} else {
+			usalp->silent--;
+		}
+	}
+
+restore_it:
+	/*
+	 * Try to restore the old sector size and stop FIFO.
+	 */
+	kill_faio();
+	comexit(errs?-2:0);
+	return (0);
+}
+
+static int 
+gracewait(cdr_t *dp, BOOL *didgracep)
+{
+	int	i;
+	BOOL	didgrace = FALSE;
+
+	if (didgracep)
+		didgrace = *didgracep;
+
+	if(warn_minisize>=0) {
+		fprintf(stderr,  "\nWARNING: found a microscopic small track size (%lld bytes).\n"
+				"         Do you really want to write this image? Press Ctrl-C to abort...\n\n",
+				warn_minisize);
+		gracetime+=20;
+	}
+	if (gracetime < MIN_GRACE_TIME)
+		gracetime = MIN_GRACE_TIME;
+	if (gracetime > 999)
+		gracetime = 999;
+
+	printf("Starting to write CD/DVD at speed %5.1f in %s%s %s mode for %s session.\n",
+         (float)dp->cdr_dstat->ds_wspeed,
+		(dp->cdr_cmdflags & F_DUMMY) ? "dummy" : "real",
+		(dp->cdr_cmdflags & F_FORCE) ? " force" : "",
+		wm2name[dp->cdr_dstat->ds_wrmode],
+		(dp->cdr_cmdflags & F_MULTI) ? "multi" : "single");
+	if (didgrace) {
+		printf("No chance to quit anymore.");
+		goto grace_done;
+	}
+	printf("Last chance to quit, starting %s write in %4d seconds.",
+		(dp->cdr_cmdflags & F_DUMMY)?"dummy":"real", gracetime);
+	flush();
+	signal(SIGINT, intr);
+	signal(SIGHUP, intr);
+	signal(SIGTERM, intr);
+
+	for (i = gracetime; --i >= 0; ) {
+		sleep(1);
+		if (didintr) {
+			printf("\n");
+			excdr(SIGINT, &exargs);
+			signal(SIGINT, SIG_DFL);
+			kill(getpid(), SIGINT);
+			/*
+			 * In case kill() did not work ;-)
+			 */
+			if (didgracep)
+				*didgracep = FALSE;
+			return (-1);
+		}
+		printf("\b\b\b\b\b\b\b\b\b\b\b\b\b%4d seconds.", i);
+		flush();
+	}
+grace_done:
+	printf(" Operation starts.");
+	flush();
+	signal(SIGINT, SIG_DFL);
+	signal(SIGHUP, SIG_DFL);
+	signal(SIGTERM, SIG_DFL);
+	signal(SIGINT, intfifo);
+	signal(SIGHUP, intfifo);
+	signal(SIGTERM, intfifo);
+	printf("\n");
+
+	if (didgracep)
+		*didgracep = TRUE;
+	return (0);
+}
+
+static void 
+cdrstats(cdr_t *dp)
+{
+	float	secsps = 75.0;
+	int	nsecs;
+	float	fspeed;
+	struct timeval	tcur;
+	struct timeval	tlast;
+	BOOL	nostop = FALSE;
+
+	if (starttime.tv_sec == 0)
+		return;
+
+	if (stoptime.tv_sec == 0) {
+		gettimeofday(&stoptime, (struct timezone *)0);
+		nostop = TRUE;
+	}
+
+	if ((dp->cdr_dstat->ds_cdrflags & RF_DID_STAT) != 0)
+		return;
+	dp->cdr_dstat->ds_cdrflags |= RF_DID_STAT;
+
+	if (lverbose == 0)
+		return;
+
+	if (dp->cdr_cmdflags & F_FIX)
+		return;
+
+	if ((dp->cdr_cmdflags & (F_WRITE|F_BLANK)) == F_BLANK)
+		return;
+
+	tlast = wstarttime;
+	tcur = stoptime;
+
+	prtimediff("Writing  time: ", &starttime, &stoptime);
+
+	nsecs = dp->cdr_dstat->ds_endsec - dp->cdr_dstat->ds_startsec;
+
+	if (dp->cdr_dstat->ds_flags & DSF_DVD)
+		secsps = 676.27;
+
+	tlast.tv_sec = tcur.tv_sec - tlast.tv_sec;
+	tlast.tv_usec = tcur.tv_usec - tlast.tv_usec;
+	while (tlast.tv_usec < 0) {
+		tlast.tv_usec += 1000000;
+		tlast.tv_sec -= 1;
+	}
+	if (!nostop && nsecs != 0 && dp->cdr_dstat->ds_endsec > 0) {
+		/*
+		 * May not be known (e.g. cdrecord -)
+		 *
+		 * XXX if we later allow this code to know how much has
+		 * XXX actually been written, then we may remove the
+		 * XXX dependance from nostop & nsecs != 0
+		 */
+		fspeed = (nsecs / secsps) /
+			(tlast.tv_sec * 1.0 + tlast.tv_usec * 0.000001);
+		if (fspeed > 999.0)
+			fspeed = 999.0;
+      if (dp->is_dvd) fspeed /= 9;
+		printf("Average write speed %5.1fx.\n", fspeed);
+	}
+
+	if (dp->cdr_dstat->ds_minbuf <= 100) {
+		printf("Min drive buffer fill was %u%%\n",
+			(unsigned int)dp->cdr_dstat->ds_minbuf);
+	}
+	if (dp->cdr_dstat->ds_buflow > 0) {
+		printf("Total of %ld possible drive buffer underruns predicted.\n",
+			(long)dp->cdr_dstat->ds_buflow);
+	}
+}
+
+/*
+ * Short usage
+ */
+static void
+susage(int ret)
+{
+	fprintf(stderr, "Usage: %s [options] track1...trackn\n", get_progname());
+	fprintf(stderr, "\nUse\t%s -help\n", get_progname());
+	fprintf(stderr, "to get a list of valid options.\n");
+	fprintf(stderr, "\nUse\t%s blank=help\n", get_progname());
+	fprintf(stderr, "to get a list of valid blanking options.\n");
+	fprintf(stderr, "\nUse\t%s dev=b,t,l driveropts=help -checkdrive\n", get_progname());
+	fprintf(stderr, "to get a list of drive specific options.\n");
+	fprintf(stderr, "\nUse\t%s dev=help\n", get_progname());
+	fprintf(stderr, "to get a list of possible SCSI transport specifiers.\n");
+	exit(ret);
+	/* NOTREACHED */
+}
+
+static void 
+usage(int excode)
+{
+	fprintf(stderr, "Usage: %s [options] track1...trackn\n", get_progname());
+	fprintf(stderr, "Options:\n");
+	fprintf(stderr, "\t-version	print version information and exit\n");
+	fprintf(stderr, "\tdev=target	SCSI target to use as CD/DVD-Recorder\n");
+	fprintf(stderr, "\tgracetime=#	set the grace time before starting to write to #.\n");
+	fprintf(stderr, "\ttimeout=#	set the default SCSI command timeout to #.\n");
+	fprintf(stderr, "\tdebug=#,-d	Set to # or increment misc debug level\n");
+	fprintf(stderr, "\tkdebug=#,kd=#	do Kernel debugging\n");
+	fprintf(stderr, "\t-verbose,-v	increment general verbose level by one\n");
+	fprintf(stderr, "\t-Verbose,-V	increment SCSI command transport verbose level by one\n");
+	fprintf(stderr, "\t-silent,-s	do not print status of failed SCSI commands\n");
+	fprintf(stderr, "\tdriver=name	user supplied driver name, use with extreme care\n");
+	fprintf(stderr, "\tdriveropts=opt	a comma separated list of driver specific options\n");
+	fprintf(stderr, "\t-setdropts	set driver specific options and exit\n");
+	fprintf(stderr, "\t-checkdrive	check if a driver for the drive is present\n");
+	fprintf(stderr, "\t-prcap		print drive capabilities for MMC compliant drives\n");
+	fprintf(stderr, "\t-inq		do an inquiry for the drive and exit\n");
+ 	fprintf(stderr, "\t-scanbus	scan the SCSI and IDE buses and exit\n");
+	fprintf(stderr, "\t-reset		reset the SCSI bus with the cdrecorder (if possible)\n");
+	fprintf(stderr, "\t-abort		send an abort sequence to the drive (may help if hung)\n");
+	fprintf(stderr, "\t-overburn	allow to write more than the official size of a medium\n");
+	fprintf(stderr, "\t-ignsize	ignore the known size of a medium (may cause problems)\n");
+	fprintf(stderr, "\t-useinfo	use *.inf files to overwrite audio options.\n");
+	fprintf(stderr, "\tspeed=#		set speed of drive\n");
+	fprintf(stderr, "\tblank=type	blank a CD-RW disc (see blank=help)\n");
+	fprintf(stderr, "\t-format		format a CD-RW/DVD-RW/DVD+RW disc\n");
+   fprintf(stderr, "\tformattype=#	select the format method for DVD+RW disc\n");
+#ifdef	FIFO
+	fprintf(stderr, "\tfs=#		Set fifo size to # (0 to disable, default is %ld MB)\n",
+							DEFAULT_FIFOSIZE/(1024L*1024L));
+#endif
+	fprintf(stderr, "\tts=#		set maximum transfer size for a single SCSI command\n");
+	fprintf(stderr, "\t-load		load the disk and exit (works only with tray loader)\n");
+	fprintf(stderr, "\t-lock		load and lock the disk and exit (works only with tray loader)\n");
+	fprintf(stderr, "\t-eject		eject the disk after doing the work\n");
+	fprintf(stderr, "\t-dummy		do everything with laser turned off\n");
+	fprintf(stderr, "\t-msinfo		retrieve multi-session info for genisoimage\n");
+	fprintf(stderr, "\t-msifile=path	run -msinfo and copy output to file\n");
+	fprintf(stderr, "\t-toc		retrieve and print TOC/PMA data\n");
+	fprintf(stderr, "\t-atip		retrieve and print ATIP data\n");
+	fprintf(stderr, "\t-multi		generate a TOC that allows multi session\n");
+	fprintf(stderr, "\t		In this case default track type is CD-ROM XA mode 2 form 1 - 2048 bytes\n");
+	fprintf(stderr, "\t-fix		fixate a corrupt or unfixated disk (generate a TOC)\n");
+	fprintf(stderr, "\t-nofix		do not fixate disk after writing tracks\n");
+	fprintf(stderr, "\t-waiti		wait until input is available before opening SCSI\n");
+	fprintf(stderr, "\t-immed		Try to use the SCSI IMMED flag with certain long lasting commands\n");
+	fprintf(stderr, "\t-force		force to continue on some errors to allow blanking bad disks\n");
+	fprintf(stderr, "\t-tao		Write disk in TAO mode.\n");
+	fprintf(stderr, "\t-dao		Write disk in SAO mode.\n");
+	fprintf(stderr, "\t-sao		Write disk in SAO mode.\n");
+	fprintf(stderr, "\t-raw		Write disk in RAW mode.\n");
+	fprintf(stderr, "\t-raw96r		Write disk in RAW/RAW96R mode.\n");
+	fprintf(stderr, "\t-raw96p		Write disk in RAW/RAW96P mode.\n");
+	fprintf(stderr, "\t-raw16		Write disk in RAW/RAW16 mode.\n");
+#ifdef	CLONE_WRITE
+	fprintf(stderr, "\t-clone		Write disk in clone write mode.\n");
+#endif
+	fprintf(stderr, "\ttsize=#		Length of valid data in next track\n");
+	fprintf(stderr, "\tpadsize=#	Amount of padding for next track\n");
+	fprintf(stderr, "\tpregap=#	Amount of pre-gap sectors before next track\n");
+	fprintf(stderr, "\tdefpregap=#	Amount of pre-gap sectors for all but track #1\n");
+	fprintf(stderr, "\tmcn=text	Set the media catalog number for this CD to 'text'\n");
+	fprintf(stderr, "\tisrc=text	Set the ISRC number for the next track to 'text'\n");
+	fprintf(stderr, "\tindex=list	Set the index list for the next track to 'list'\n");
+	fprintf(stderr, "\t-text		Write CD-Text from information from *.inf or *.cue files\n");
+	fprintf(stderr, "\ttextfile=name	Set the file with CD-Text data to 'name'\n");
+	fprintf(stderr, "\tcuefile=name	Set the file with CDRWIN CUE data to 'name'\n");
+
+	fprintf(stderr, "\t-audio		Subsequent tracks are CD-DA audio tracks\n");
+	fprintf(stderr, "\t-data		Subsequent tracks are CD-ROM data mode 1 - 2048 bytes (default)\n");
+	fprintf(stderr, "\t-mode2		Subsequent tracks are CD-ROM data mode 2 - 2336 bytes\n");
+	fprintf(stderr, "\t-xa		Subsequent tracks are CD-ROM XA mode 2 form 1 - 2048 bytes\n");
+	fprintf(stderr, "\t-xa1		Subsequent tracks are CD-ROM XA mode 2 form 1 - 2056 bytes\n");
+	fprintf(stderr, "\t-xa2		Subsequent tracks are CD-ROM XA mode 2 form 2 - 2324 bytes\n");
+	fprintf(stderr, "\t-xamix		Subsequent tracks are CD-ROM XA mode 2 form 1/2 - 2332 bytes\n");
+	fprintf(stderr, "\t-cdi		Subsequent tracks are CDI tracks\n");
+	fprintf(stderr, "\t-isosize	Use iso9660 file system size for next data track\n");
+	fprintf(stderr, "\t-preemp		Audio tracks are mastered with 50/15 microseconds preemphasis\n");
+	fprintf(stderr, "\t-nopreemp	Audio tracks are mastered with no preemphasis (default)\n");
+	fprintf(stderr, "\t-copy		Audio tracks have unlimited copy permission\n");
+	fprintf(stderr, "\t-nocopy		Audio tracks may only be copied once for personal use (default)\n");
+	fprintf(stderr, "\t-scms		Audio tracks will not have any copy permission at all\n");
+	fprintf(stderr, "\t-pad		Pad data tracks with %d zeroed sectors\n", PAD_SECS);
+	fprintf(stderr, "\t		Pad audio tracks to a multiple of %d bytes\n", AUDIO_SEC_SIZE);
+	fprintf(stderr, "\t-nopad		Do not pad data tracks (default)\n");
+	fprintf(stderr, "\t-shorttrack	Subsequent tracks may be non Red Book < 4 seconds if in SAO or RAW mode\n");
+	fprintf(stderr, "\t-noshorttrack	Subsequent tracks must be >= 4 seconds\n");
+	fprintf(stderr, "\t-swab		Audio data source is byte-swapped (little-endian/Intel)\n");
+	fprintf(stderr, "The type of the first track is used for the toc type.\n");
+	fprintf(stderr, "Currently only form 1 tracks are supported.\n");
+	exit(excode);
+}
+
+static void 
+blusage(int ret)
+{
+	fprintf(stderr, "Blanking options:\n");
+	fprintf(stderr, "\tall\t\tblank the entire disk\n");
+	fprintf(stderr, "\tdisc\t\tblank the entire disk\n");
+	fprintf(stderr, "\tdisk\t\tblank the entire disk\n");
+	fprintf(stderr, "\tfast\t\tminimally blank the entire disk (PMA, TOC, pregap)\n");
+	fprintf(stderr, "\tminimal\t\tminimally blank the entire disk (PMA, TOC, pregap)\n");
+	fprintf(stderr, "\ttrack\t\tblank a track\n");
+	fprintf(stderr, "\tunreserve\tunreserve a track\n");
+	fprintf(stderr, "\ttrtail\t\tblank a track tail\n");
+	fprintf(stderr, "\tunclose\t\tunclose last session\n");
+	fprintf(stderr, "\tsession\t\tblank last session\n");
+
+	exit(ret);
+	/* NOTREACHED */
+}
+
+static void 
+formattypeusage(int ret)
+{
+	fprintf(stderr, "Formating options:\n");
+	fprintf(stderr, "\tfull\t\tstandard formating\n");
+	fprintf(stderr, "\tbackground\t\tbackground formating\n");
+	fprintf(stderr, "\tforce\t\tforce reformat\n");
+
+	exit(ret);
+	/* NOTREACHED */
+}
+
+/* ARGSUSED */
+static void
+intr(int sig)
+{
+	sig = 0;	/* Fake usage for gcc */
+
+	signal(SIGINT, intr);
+
+	didintr++;
+}
+
+static void 
+catchsig(int sig)
+{
+	signal(sig, catchsig);
+}
+
+static int 
+scsi_cb(void *arg)
+{
+	comexit(EX_BAD);
+	/* NOTREACHED */
+	return (0);	/* Keep lint happy */
+}
+
+static void 
+intfifo(int sig)
+{
+	errmsgno(EX_BAD, "Caught interrupt.\n");
+	if (exargs.usalp) {
+		SCSI	*usalp = exargs.usalp;
+
+		if (usalp->running) {
+			if (usalp->cb_fun != NULL) {
+				comerrno(EX_BAD, "Second interrupt. Doing hard abort.\n");
+				/* NOTREACHED */
+			}
+			usalp->cb_fun = scsi_cb;
+			usalp->cb_arg = &exargs;
+			return;
+		}
+	}
+	comexit(sig);
+}
+
+/* ARGSUSED */
+static void 
+exscsi(int excode, void *arg)
+{
+	struct exargs	*exp = (struct exargs *)arg;
+
+	/*
+	 * Try to restore the old sector size.
+	 */
+	if (exp != NULL && exp->exflags == 0) {
+		if (exp->usalp->running) {
+			return;
+		}
+		/*
+		 * flush cache is not supported by CD-ROMs avoid prob with -toc
+		 */
+		exp->usalp->silent++;
+		scsi_flush_cache(exp->usalp, FALSE);
+		(*exp->dp->cdr_abort_session)(exp->usalp, exp->dp);
+		exp->usalp->silent--;
+		set_secsize(exp->usalp, exp->old_secsize);
+		unload_media(exp->usalp, exp->dp, exp->flags);
+
+		exp->exflags++;	/* Make sure that it only get called once */
+	}
+}
+
+static void 
+excdr(int excode, void *arg)
+{
+	struct exargs	*exp = (struct exargs *)arg;
+
+	exscsi(excode, arg);
+
+	cdrstats(exp->dp);
+	if ((exp->dp->cdr_dstat->ds_cdrflags & RF_DID_CDRSTAT) == 0) {
+		exp->dp->cdr_dstat->ds_cdrflags |= RF_DID_CDRSTAT;
+		(*exp->dp->cdr_stats)(exp->usalp, exp->dp);
+	}
+
+#ifdef	FIFO
+	kill_faio();
+	wait_faio();
+	if (debug || lverbose)
+		fifo_stats();
+#endif
+}
+
+int 
+read_buf(int f, char *bp, int size)
+{
+	char	*p = bp;
+	int	amount = 0;
+	int	n;
+
+	do {
+		do {
+			n = read(f, p, size-amount);
+		} while (n < 0 && (geterrno() == EAGAIN || geterrno() == EINTR));
+		if (n < 0)
+			return (n);
+		amount += n;
+		p += n;
+
+	} while (amount < size && n > 0);
+	return (amount);
+}
+
+int 
+fill_buf(int f, track_t *trackp, long secno, char *bp, int size)
+{
+	int	amount = 0;
+	int	nsecs;
+	int	rsize;
+	int	rmod;
+	int	readoffset = 0;
+
+	nsecs = size / trackp->secsize;
+	if (nsecs < trackp->secspt) {
+		/*
+		 * Clear buffer to prepare for last transfer.
+		 * Make sure that a partial sector ends with NULs
+		 */
+		fillbytes(bp, trackp->secspt * trackp->secsize, '\0');
+	}
+
+	if (!is_raw(trackp)) {
+		amount = read_buf(f, bp, size);
+		if (amount != size) {
+			if (amount < 0)
+				return (amount);
+			/*
+			 * We got less than expected, clear rest of buf.
+			 */
+			fillbytes(&bp[amount], size-amount, '\0');
+		}
+		if (is_swab(trackp))
+			swabbytes(bp, amount);
+		return (amount);
+	}
+
+	rsize = nsecs * trackp->isecsize;
+	rmod  = size % trackp->secsize;
+	if (rmod > 0) {
+		rsize += rmod;
+		nsecs++;
+	}
+
+	readoffset = trackp->dataoff;
+	amount = read_buf(f, bp + readoffset, rsize);
+	if (is_swab(trackp))
+		swabbytes(bp + readoffset, amount);
+
+	if (trackp->isecsize == 2448 && trackp->secsize == 2368)
+		subrecodesecs(trackp, (Uchar *)bp, secno, nsecs);
+
+	scatter_secs(trackp, bp + readoffset, nsecs);
+
+	if (amount != rsize) {
+		if (amount < 0)
+			return (amount);
+		/*
+		 * We got less than expected, clear rest of buf.
+		 */
+		fillbytes(&bp[amount], rsize-amount, '\0');
+		nsecs = amount / trackp->isecsize;
+		rmod  = amount % trackp->isecsize;
+		amount = nsecs * trackp->secsize;
+		if (rmod > 0) {
+			nsecs++;
+			amount += rmod;
+		}
+	} else {
+		amount = size;
+	}
+	if ((trackp->sectype & ST_MODE_RAW) == 0) {
+		encsectors(trackp, (Uchar *)bp, secno, nsecs);
+		fillsubch(trackp, (Uchar *)bp, secno, nsecs);
+	} else {
+		scrsectors(trackp, (Uchar *)bp, secno, nsecs);
+	}
+	return (amount);
+}
+
+int 
+get_buf(int f, track_t *trackp, long secno, char **bpp, int size)
+{
+	if (fs > 0) {
+/*		return (faio_read_buf(f, *bpp, size));*/
+		return (faio_get_buf(f, bpp, size));
+	} else {
+		return (fill_buf(f, trackp, secno, *bpp, size));
+	}
+}
+
+int 
+write_secs(SCSI *usalp, cdr_t *dp, char *bp, long startsec, int bytespt, 
+        		int secspt, BOOL islast)
+{
+	int	amount;
+
+again:
+	usalp->silent++;
+	amount = (*dp->cdr_write_trackdata)(usalp, bp, startsec, bytespt, secspt, islast);
+	usalp->silent--;
+	if (amount < 0) {
+		if (scsi_in_progress(usalp)) {
+			/*
+			 * If we sleep too long, the drive buffer is empty
+			 * before we start filling it again. The max. CD speed
+			 * is ~ 10 MB/s (52x RAW writing). The max. DVD speed
+			 * is ~ 25 MB/s (18x DVD 1385 kB/s).
+			 * With 10 MB/s, a 1 MB buffer empties within 100ms.
+			 * With 25 MB/s, a 1 MB buffer empties within 40ms.
+			 */
+			if ((dp->cdr_dstat->ds_flags & DSF_DVD) == 0) {
+				usleep(60000);
+			} else {
+#ifndef	_SC_CLK_TCK
+				usleep(20000);
+#else
+				if (sysconf(_SC_CLK_TCK) < 100)
+					usleep(20000);
+				else
+					usleep(10000);
+
+#endif
+			}
+			goto again;
+		}
+		return (-1);
+	}
+	return (amount);
+}
+
+static int 
+write_track_data(SCSI *usalp, cdr_t *dp, track_t *trackp)
+{
+	int	track = trackp->trackno;
+	int	f = -1;
+	int	isaudio;
+	long	startsec;
+	Llong	bytes_read = 0;
+	Llong	bytes	= 0;
+	Llong	savbytes = 0;
+	int	count;
+	Llong	tracksize;
+	int	secsize;
+	int	secspt;
+	int	bytespt;
+	int	bytes_to_read;
+	long	amount;
+	int	pad;
+	BOOL	neednl	= FALSE;
+	BOOL	islast	= FALSE;
+	char	*bp	= buf;
+	struct timeval tlast;
+	struct timeval tcur;
+	float	secsps = 75.0;
+long bsize;
+long bfree;
+#define	BCAP
+#ifdef	BCAP
+int per = 0;
+#ifdef	XBCAP
+int oper = -1;
+#endif
+#endif
+
+	if (dp->cdr_dstat->ds_flags & DSF_DVD)
+		secsps = 676.27;
+
+	usalp->silent++;
+	if ((*dp->cdr_buffer_cap)(usalp, &bsize, &bfree) < 0)
+		bsize = -1L;
+	if (bsize == 0)		/* If we have no (known) buffer, we cannot */
+		bsize = -1L;	/* retrieve the buffer fill ratio	   */
+	usalp->silent--;
+
+
+	if (is_packet(trackp))	/* XXX Ugly hack for now */
+		return (write_packet_data(usalp, dp, trackp));
+
+	if (trackp->xfp != NULL)
+		f = xfileno(trackp->xfp);
+
+	isaudio = is_audio(trackp);
+	tracksize = trackp->tracksize;
+	startsec = trackp->trackstart;
+
+	secsize = trackp->secsize;
+	secspt = trackp->secspt;
+	bytespt = secsize * secspt;
+
+	pad = !isaudio && is_pad(trackp);	/* Pad only data tracks */
+
+	if (debug) {
+		printf("secsize:%d secspt:%d bytespt:%d audio:%d pad:%d\n",
+			secsize, secspt, bytespt, isaudio, pad);
+	}
+
+	if (lverbose) {
+		if (tracksize > 0)
+			printf("\rTrack %02d:    0 of %4lld MB written.",
+				track, tracksize >> 20);
+		else
+			printf("\rTrack %02d:    0 MB written.", track);
+		flush();
+		neednl = TRUE;
+	}
+
+	gettimeofday(&tlast, (struct timezone *)0);
+	do {
+		bytes_to_read = bytespt;
+		if (tracksize > 0) {
+			if ((tracksize - bytes_read) > bytespt)
+				bytes_to_read = bytespt;
+			else
+				bytes_to_read = tracksize - bytes_read;
+		}
+		count = get_buf(f, trackp, startsec, &bp, bytes_to_read);
+
+		if (count < 0)
+			comerr("read error on input file\n");
+		if (count == 0)
+			break;
+		bytes_read += count;
+		if (tracksize >= 0 && bytes_read >= tracksize) {
+			count -= bytes_read - tracksize;
+			/*
+			 * Paranoia: tracksize is known (trackp->tracksize >= 0)
+			 * At this point, trackp->padsize should alway be set
+			 * if the tracksize is less than 300 sectors.
+			 */
+			if (trackp->padsecs == 0 &&
+			    (is_shorttrk(trackp) || (bytes_read/secsize) >= 300))
+				islast = TRUE;
+		}
+
+		if (count < bytespt) {
+			if (debug) {
+				printf("\nNOTICE: reducing block size for last record.\n");
+				neednl = FALSE;
+			}
+
+			if ((amount = count % secsize) != 0) {
+				amount = secsize - amount;
+				count += amount;
+				printf("\nWARNING: padding up to secsize.\n");
+				neednl = FALSE;
+			}
+			bytespt = count;
+			secspt = count / secsize;
+			/*
+			 * If tracksize is not known (trackp->tracksize < 0)
+			 * we may need to set trackp->padsize
+			 * if the tracksize is less than 300 sectors.
+			 */
+			if (trackp->padsecs == 0 &&
+			    (is_shorttrk(trackp) || (bytes_read/secsize) >= 300))
+				islast = TRUE;
+		}
+
+		amount = write_secs(usalp, dp, bp, startsec, bytespt, secspt, islast);
+		if (amount < 0) {
+			printf("%swrite track data: error after %lld bytes\n",
+							neednl?"\n":"", bytes);
+			return (-1);
+		}
+		bytes += amount;
+		startsec += amount / secsize;
+
+		if (lverbose && (bytes >= (savbytes + 0x100000))) {
+			int	fper;
+			int	nsecs = (bytes - savbytes) / secsize;
+			float	fspeed;
+
+			gettimeofday(&tcur, (struct timezone *)0);
+			printf("\rTrack %02d: %4lld", track, bytes >> 20);
+			if (tracksize > 0)
+				printf(" of %4lld MB", tracksize >> 20);
+			else
+				printf(" MB");
+			printf(" written");
+			fper = fifo_percent(TRUE);
+			if (fper >= 0)
+				printf(" (fifo %3d%%)", fper);
+#ifdef	BCAP
+			if (bsize > 0) {			/* buffer size known */
+				usalp->silent++;
+				per = (*dp->cdr_buffer_cap)(usalp, (long *)0, &bfree);
+				usalp->silent--;
+				if (per >= 0) {
+					per = 100*(bsize - bfree) / bsize;
+					if ((bsize - bfree) <= amount || per <= 5)
+						dp->cdr_dstat->ds_buflow++;
+					if (per < (int)dp->cdr_dstat->ds_minbuf &&
+					    (startsec*secsize) > bsize) {
+						dp->cdr_dstat->ds_minbuf = per;
+					}
+					printf(" [buf %3d%%]", per);
+#ifdef	BCAPDBG
+					printf(" %3ld %3ld", bsize >> 10, bfree >> 10);
+#endif
+				}
+			}
+#endif
+
+			tlast.tv_sec = tcur.tv_sec - tlast.tv_sec;
+			tlast.tv_usec = tcur.tv_usec - tlast.tv_usec;
+			while (tlast.tv_usec < 0) {
+				tlast.tv_usec += 1000000;
+				tlast.tv_sec -= 1;
+			}
+			fspeed = (nsecs / secsps) /
+				(tlast.tv_sec * 1.0 + tlast.tv_usec * 0.000001);
+			if (fspeed > 999.0)
+				fspeed = 999.0;
+#ifdef	BCAP
+			if (bsize > 0 && per > dminbuf &&
+			    dp->cdr_dstat->ds_cdrflags & RF_WR_WAIT) {
+				int	wsecs = (per-dminbuf)*(bsize/secsize)/100;
+				int	msecs = 0x100000/secsize;
+				int	wt;
+				int	mt;
+				int	s = dp->cdr_dstat->ds_dr_cur_wspeed;
+
+
+				if (s <= 0) {
+					if (dp->cdr_dstat->ds_flags & DSF_DVD)
+						s = 4;
+					else
+						s = 50;
+				}
+				if (wsecs > msecs)	/* Less that 1 MB */
+					wsecs = msecs;
+				wt = wsecs * 1000 / secsps / fspeed;
+				mt = (per-dminbuf)*(bsize/secsize)/100 * 1000 / secsps/s;
+
+				if (wt > mt)
+					wt = mt;
+				if (wt > 1000)		/* Max 1 second */
+					wt = 1000;
+				if (wt < 20)		/* Min 20 ms */
+					wt = 0;
+
+				if (xdebug)
+					printf(" |%3d %4dms %5dms|", wsecs, wt, mt);
+				else
+					printf(" |%3d %4dms|", wsecs, wt);
+				if (wt > 0)
+					usleep(wt*1000);
+			}
+#endif
+         if (dp->is_dvd) fspeed /= 9;
+			printf(" %5.1fx", fspeed);
+			printf(".");
+			savbytes = (bytes >> 20) << 20;
+			flush();
+			neednl = TRUE;
+			tlast = tcur;
+		}
+#ifdef	XBCAP
+		if (bsize > 0) {			/* buffer size known */
+			(*dp->cdr_buffer_cap)(usalp, (long *)0, &bfree);
+			per = 100*(bsize - bfree) / bsize;
+			if (per != oper)
+				printf("[buf %3d%%] %3ld %3ld\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b",
+					per, bsize >> 10, bfree >> 10);
+			oper = per;
+			flush();
+		}
+
+
+#endif
+	} while (tracksize < 0 || bytes_read < tracksize);
+
+	if (!is_shorttrk(trackp) && (bytes / secsize) < 300) {
+		/*
+		 * If tracksize is not known (trackp->tracksize < 0) or
+		 * for some strange reason we did not set padsecs properly
+		 * we may need to modify trackp->padsecs if
+		 * tracksize+padsecs is less than 300 sectors.
+		 */
+		if ((trackp->padsecs + (bytes / secsize)) < 300)
+			trackp->padsecs = 300 - (bytes / secsize);
+	}
+	if (trackp->padsecs > 0) {
+		Llong	padbytes;
+
+		/*
+		 * pad_track() is based on secsize. Compute the amount of bytes
+		 * assumed by pad_track().
+		 */
+		padbytes = (Llong)trackp->padsecs * secsize;
+
+		if (neednl) {
+			printf("\n");
+			neednl = FALSE;
+		}
+		if ((padbytes >> 20) > 0) {
+			neednl = TRUE;
+		} else if (lverbose) {
+			printf("Track %02d: writing %3lld KB of pad data.\n",
+					track, (Llong)(padbytes >> 10));
+			neednl = FALSE;
+		}
+		pad_track(usalp, dp, trackp, startsec, padbytes,
+					TRUE, &savbytes);
+		bytes += savbytes;
+		startsec += savbytes / secsize;
+	}
+	printf("%sTrack %02d: Total bytes read/written: %lld/%lld (%lld sectors).\n",
+		neednl?"\n":"", track, bytes_read, bytes, bytes/secsize);
+	flush();
+	return (0);
+}
+
+int 
+pad_track(SCSI *usalp, cdr_t	*dp, track_t *trackp, long startsec, Llong amt,
+				BOOL dolast, Llong *bytesp)
+{
+	int	track = trackp->trackno;
+	Llong	bytes	= 0;
+	Llong	savbytes = 0;
+	Llong	padsize = amt;
+	int	secsize;
+	int	secspt;
+	int	bytespt;
+	int	amount;
+	BOOL	neednl	= FALSE;
+	BOOL	islast	= FALSE;
+	struct timeval tlast;
+	struct timeval tcur;
+	float	secsps = 75.0;
+long bsize;
+long bfree;
+#define	BCAP
+#ifdef	BCAP
+int per;
+#ifdef	XBCAP
+int oper = -1;
+#endif
+#endif
+
+	if (dp->cdr_dstat->ds_flags & DSF_DVD)
+		secsps = 676.27;
+
+	usalp->silent++;
+	if ((*dp->cdr_buffer_cap)(usalp, &bsize, &bfree) < 0)
+		bsize = -1L;
+	if (bsize == 0)		/* If we have no (known) buffer, we cannot */
+		bsize = -1L;	/* retrieve the buffer fill ratio	   */
+	usalp->silent--;
+
+	secsize = trackp->secsize;
+	secspt = trackp->secspt;
+	bytespt = secsize * secspt;
+
+	fillbytes(buf, bytespt, '\0');
+
+	if ((amt >> 20) > 0) {
+		printf("\rTrack %02d:    0 of %4lld MB pad written.",
+						track, amt >> 20);
+		flush();
+	}
+	gettimeofday(&tlast, (struct timezone *)0);
+	do {
+		if (amt < bytespt) {
+			bytespt = roundup(amt, secsize);
+			secspt = bytespt / secsize;
+		}
+		if (dolast && (amt - bytespt) <= 0)
+			islast = TRUE;
+
+		if (is_raw(trackp)) {
+			encsectors(trackp, (Uchar *)buf, startsec, secspt);
+			fillsubch(trackp, (Uchar *)buf, startsec, secspt);
+		}
+
+		amount = write_secs(usalp, dp, buf, startsec, bytespt, secspt, islast);
+		if (amount < 0) {
+			printf("%swrite track pad data: error after %lld bytes\n",
+							neednl?"\n":"", bytes);
+			if (bytesp)
+				*bytesp = bytes;
+(*dp->cdr_buffer_cap)(usalp, (long *)0, (long *)0);
+			return (-1);
+		}
+		amt -= amount;
+		bytes += amount;
+		startsec += amount / secsize;
+
+		if (lverbose && (bytes >= (savbytes + 0x100000))) {
+			int	nsecs = (bytes - savbytes) / secsize;
+			float	fspeed;
+
+			gettimeofday(&tcur, (struct timezone *)0);
+			printf("\rTrack %02d: %4lld", track, bytes >> 20);
+			if (padsize > 0)
+				printf(" of %4lld MB", padsize >> 20);
+			else
+				printf(" MB");
+			printf(" pad written");
+			savbytes = (bytes >> 20) << 20;
+
+#ifdef	BCAP
+			if (bsize > 0) {			/* buffer size known */
+				usalp->silent++;
+				per = (*dp->cdr_buffer_cap)(usalp, (long *)0, &bfree);
+				usalp->silent--;
+				if (per >= 0) {
+					per = 100*(bsize - bfree) / bsize;
+					if ((bsize - bfree) <= amount || per <= 5)
+						dp->cdr_dstat->ds_buflow++;
+					if (per < (int)dp->cdr_dstat->ds_minbuf &&
+					    (startsec*secsize) > bsize) {
+						dp->cdr_dstat->ds_minbuf = per;
+					}
+					printf(" [buf %3d%%]", per);
+#ifdef	BCAPDBG
+					printf(" %3ld %3ld", bsize >> 10, bfree >> 10);
+#endif
+				}
+			}
+#endif
+			tlast.tv_sec = tcur.tv_sec - tlast.tv_sec;
+			tlast.tv_usec = tcur.tv_usec - tlast.tv_usec;
+			while (tlast.tv_usec < 0) {
+				tlast.tv_usec += 1000000;
+				tlast.tv_sec -= 1;
+			}
+			fspeed = (nsecs / secsps) /
+				(tlast.tv_sec * 1.0 + tlast.tv_usec * 0.000001);
+			if (fspeed > 999.0)
+				fspeed = 999.0;
+			printf(" %5.1fx", fspeed);
+			printf(".");
+			flush();
+			neednl = TRUE;
+			tlast = tcur;
+		}
+	} while (amt > 0);
+
+	if (bytesp)
+		*bytesp = bytes;
+	if (bytes == 0)
+		return (0);
+	return (bytes > 0 ? 1:-1);
+}
+
+#ifdef	USE_WRITE_BUF
+int 
+write_buf(SCSI *usalp, cdr_t *dp, track_t *trackp, char *bp, long startsec, 
+        	  Llong amt, int secsize, BOOL dolast, Llong *bytesp)
+{
+	int	track = trackp->trackno;
+	Llong	bytes	= 0;
+	Llong	savbytes = 0;
+/*	int	secsize;*/
+	int	secspt;
+	int	bytespt;
+	int	amount;
+	BOOL	neednl	= FALSE;
+	BOOL	islast	= FALSE;
+
+/*	secsize = trackp->secsize;*/
+/*	secspt = trackp->secspt;*/
+
+	secspt = bufsize/secsize;
+	secspt = min(255, secspt);
+	bytespt = secsize * secspt;
+
+/*	fillbytes(buf, bytespt, '\0');*/
+
+	if ((amt >> 20) > 0) {
+		printf("\rTrack %02d:   0 of %4ld MB pad written.",
+						track, amt >> 20);
+		flush();
+	}
+	do {
+		if (amt < bytespt) {
+			bytespt = roundup(amt, secsize);
+			secspt = bytespt / secsize;
+		}
+		if (dolast && (amt - bytespt) <= 0)
+			islast = TRUE;
+
+		amount = write_secs(usalp, dp, bp, startsec, bytespt, secspt, islast);
+		if (amount < 0) {
+			printf("%swrite track data: error after %ld bytes\n",
+							neednl?"\n":"", bytes);
+			if (bytesp)
+				*bytesp = bytes;
+(*dp->cdr_buffer_cap)(usalp, (long *)0, (long *)0);
+			return (-1);
+		}
+		amt -= amount;
+		bytes += amount;
+		startsec += amount / secsize;
+
+		if (lverbose && (bytes >= (savbytes + 0x100000))) {
+			printf("\rTrack %02d: %3ld", track, bytes >> 20);
+			savbytes = (bytes >> 20) << 20;
+			flush();
+			neednl = TRUE;
+		}
+	} while (amt > 0);
+
+	if (bytesp)
+		*bytesp = bytes;
+	return (bytes);
+}
+#endif	/* USE_WRITE_BUF */
+
+static void 
+printdata(int track, track_t *trackp)
+{
+	if (trackp->itracksize >= 0) {
+		printf("Track %02d: data  %4lld MB        ",
+					track, (Llong)(trackp->itracksize >> 20));
+	} else {
+		printf("Track %02d: data  unknown length",
+					track);
+	}
+	if (trackp->padsecs > 0) {
+		Llong	padbytes = (Llong)trackp->padsecs * trackp->isecsize;
+
+		if ((padbytes >> 20) > 0)
+			printf(" padsize: %4lld MB", (Llong)(padbytes >> 20));
+		else
+			printf(" padsize: %4lld KB", (Llong)(padbytes >> 10));
+	}
+	if (trackp->pregapsize != (trackp->flags & TI_DVD)? 0 : 150) {
+		printf(" pregapsize: %3ld", trackp->pregapsize);
+	}
+	if (xdebug)
+		printf(" START: %ld SECTORS: %ld INDEX0 %ld",
+			trackp->trackstart, trackp->tracksecs, trackp->index0start);
+	printf("\n");
+}
+
+static void 
+printaudio(int track, track_t *trackp)
+{
+	if (trackp->itracksize >= 0) {
+		printf("Track %02d: audio %4lld MB (%02d:%02d.%02d) %spreemp%s%s",
+			track, (Llong)(trackp->itracksize >> 20),
+			minutes(trackp->itracksize),
+			seconds(trackp->itracksize),
+			hseconds(trackp->itracksize),
+			is_preemp(trackp) ? "" : "no ",
+			is_swab(trackp) ? " swab":"",
+			((trackp->itracksize < 300L*trackp->isecsize) ||
+			(trackp->itracksize % trackp->isecsize)) &&
+			is_pad(trackp) ? " pad" : "");
+	} else {
+		printf("Track %02d: audio unknown length    %spreemp%s%s",
+			track, is_preemp(trackp) ? "" : "no ",
+			is_swab(trackp) ? " swab":"",
+			(trackp->itracksize % trackp->isecsize) && is_pad(trackp) ? " pad" : "");
+	}
+	if (is_scms(trackp))
+		printf(" scms");
+	else if (is_copy(trackp))
+		printf(" copy");
+	else
+		printf("     ");
+
+	if (trackp->padsecs > 0) {
+		Llong	padbytes = (Llong)trackp->padsecs * trackp->isecsize;
+
+		if ((padbytes >> 20) > 0)
+			printf(" padsize: %4lld MB", (Llong)(padbytes >> 20));
+		else
+			printf(" padsize: %4lld KB", (Llong)(padbytes >> 10));
+		printf(" (%02d:%02d.%02d)",
+			Sminutes(trackp->padsecs),
+			Sseconds(trackp->padsecs),
+			Shseconds(trackp->padsecs));
+	}
+	if (trackp->pregapsize != ((trackp->flags & TI_DVD)? 0 : 150) || xdebug > 0) {
+		printf(" pregapsize: %3ld", trackp->pregapsize);
+	}
+	if (xdebug)
+		printf(" START: %ld SECTORS: %ld INDEX0 %ld",
+			trackp->trackstart, trackp->tracksecs, trackp->index0start);
+	printf("\n");
+}
+
+static void 
+checkfile(int track, track_t *trackp)
+{
+	if (trackp->itracksize > 0 &&
+			is_audio(trackp) &&
+			((!is_shorttrk(trackp) &&
+			(trackp->itracksize < 300L*trackp->isecsize)) ||
+			(trackp->itracksize % trackp->isecsize)) &&
+						!is_pad(trackp)) {
+		errmsgno(EX_BAD, "Bad audio track size %lld for track %02d.\n",
+				(Llong)trackp->itracksize, track);
+		errmsgno(EX_BAD, "Audio tracks must be at least %ld bytes and a multiple of %d.\n",
+				300L*trackp->isecsize, trackp->isecsize);
+
+		if (!is_shorttrk(trackp) && (trackp->itracksize < 300L*trackp->isecsize))
+			comerrno(EX_BAD, "See -shorttrack option.\n");
+		if (!is_pad(trackp) && (trackp->itracksize % trackp->isecsize))
+			comerrno(EX_BAD, "See -pad option.\n");
+	}
+
+	if (lverbose == 0 && xdebug == 0)
+		return;
+
+	if (is_audio(trackp))
+		printaudio(track, trackp);
+	else
+		printdata(track, trackp);
+}
+
+static int 
+checkfiles(int tracks, track_t *trackp)
+{
+	int	i;
+	int	isaudio = 1;
+	int	starttrack = 1;
+	int	endtrack = tracks;
+
+	if (xdebug) {
+		/*
+		 * Include Lead-in & Lead-out.
+		 */
+		starttrack--;
+		endtrack++;
+	}
+	for (i = starttrack; i <= endtrack; i++) {
+		if (!is_audio(&trackp[i]))
+			isaudio = 0;
+		if (xdebug)
+			printf("SECTYPE %X ", trackp[i].sectype);
+		checkfile(i, &trackp[i]);
+	}
+	return (isaudio);
+}
+
+static void 
+setleadinout(int tracks, track_t *trackp)
+{
+	/*
+	 * Set some values for track 0 (the lead-in)
+	 */
+	if (!is_clone(&trackp[0])) {
+		trackp[0].sectype = trackp[1].sectype;
+		trackp[0].dbtype  = trackp[1].dbtype;
+		trackp[0].dataoff = trackp[1].dataoff;
+
+		/*
+		 * XXX Which other flags should be copied to Track 0 ?
+		 */
+		if (is_audio(&trackp[1]))
+			trackp[0].flags |= TI_AUDIO;
+	}
+
+	/*
+	 * Set some values for track 0xAA (the lead-out)
+	 */
+	trackp[tracks+1].pregapsize = 0;
+	trackp[tracks+1].isecsize   = trackp[tracks].isecsize;
+	trackp[tracks+1].secsize    = trackp[tracks].secsize;
+
+	if (!is_clone(&trackp[0])) {
+		trackp[tracks+1].tracktype = trackp[tracks].tracktype;
+		trackp[tracks+1].sectype   = trackp[tracks].sectype;
+		trackp[tracks+1].dbtype    = trackp[tracks].dbtype;
+		trackp[tracks+1].dataoff   = trackp[tracks].dataoff;
+	}
+
+	trackp[tracks+1].flags = trackp[tracks].flags;
+}
+
+static void 
+setpregaps(int tracks, track_t *trackp)
+{
+	int	i;
+	int	sectype;
+	long	pregapsize;
+	track_t	*tp;
+
+	sectype = trackp[1].sectype;
+	sectype &= ST_MASK;
+
+	for (i = 1; i <= tracks; i++) {
+		tp = &trackp[i];
+		if (tp->pregapsize == -1L) {
+			tp->pregapsize = 150;		/* Default CD Pre GAP*/
+			if (trackp->flags & TI_DVD) {
+				tp->pregapsize = 0;
+			} else if (sectype != (tp->sectype & ST_MASK)) {
+				tp->pregapsize = 255;	/* Pre GAP is 255 */
+				tp->flags &= ~TI_PREGAP;
+			}
+		}
+		sectype = tp->sectype & ST_MASK;	/* Save old sectype */
+	}
+	trackp[tracks+1].pregapsize = 0;
+	trackp[tracks+1].index0start = 0;
+
+	for (i = 1; i <= tracks; i++) {
+		/*
+		 * index0start is set below tracksecks if this track contains
+		 * the pregap (index 0) of the next track.
+		 */
+		trackp[i].index0start = trackp[i].tracksecs;
+
+		pregapsize = trackp[i+1].pregapsize;
+		if (is_pregap(&trackp[i+1]) && pregapsize > 0)
+			trackp[i].index0start -= pregapsize;
+	}
+}
+
+/*
+ * Check total size of the medium
+ */
+static long 
+checktsize(int tracks, track_t *trackp)
+{
+	int	i;
+	Llong	curr;
+	Llong	total = -150;	/* CD track #1 pregap compensation */
+	Ullong	btotal;
+	track_t	*tp;
+
+	if (trackp->flags & TI_DVD)
+		total = 0;
+	for (i = 1; i <= tracks; i++) {
+		tp = &trackp[i];
+		if (!is_pregap(tp))
+			total += tp->pregapsize;
+
+		if (lverbose > 1) {
+			printf("track: %d start: %lld pregap: %ld\n",
+					i, total, tp->pregapsize);
+		}
+		tp->trackstart = total;
+		if (tp->itracksize >= 0) {
+			curr = (tp->itracksize + (tp->isecsize-1)) / tp->isecsize;
+			curr += tp->padsecs;
+			/*
+			 * Minimum track size is 4s
+			 */
+			if (!is_shorttrk(tp) && curr < 300)
+				curr = 300;
+			if ((trackp->flags & TI_DVD) == 0) {
+				/*
+				 * XXX Was passiert hier bei is_packet() ???
+				 */
+				if (is_tao(tp) && !is_audio(tp)) {
+					curr += 2;
+				}
+			}
+			total += curr;
+		} else if (is_sao(tp) || is_raw(tp)) {
+			errmsgno(EX_BAD, "Track %d has unknown length.\n", i);
+			comerrno(EX_BAD,
+			"Use tsize= option in %s mode to specify track size.\n",
+			is_sao(tp) ? "SAO" : "RAW");
+		}
+	}
+	tp = &trackp[i];
+	tp->trackstart = total;
+	tp->tracksecs = 6750;		/* Size of first session Lead-Out */
+	if (!lverbose)
+		return (total);
+
+	if (trackp->flags & TI_DVD)
+		btotal = (Ullong)total * 2048;
+	else
+		btotal = (Ullong)total * 2352;
+/* XXX CD Sector Size ??? */
+	if (tracks > 0) {
+		if (trackp->flags & TI_DVD) {
+			printf("Total size:     %4llu MB = %lld sectors\n",
+				btotal >> 20, total);
+		} else {
+			printf("Total size:     %4llu MB (%02d:%02d.%02d) = %lld sectors\n",
+				btotal >> 20,
+				minutes(btotal),
+				seconds(btotal),
+				hseconds(btotal), total);
+			btotal += 150 * 2352;
+			printf("Lout start:     %4llu MB (%02d:%02d/%02d) = %lld sectors\n",
+				btotal >> 20,
+				minutes(btotal),
+				seconds(btotal),
+				frames(btotal), total);
+		}
+	}
+	return (total);
+}
+
+static void 
+opentracks(track_t *trackp)
+{
+	track_t	*tp;
+	int	i;
+	int	tracks = trackp[0].tracks;
+
+	Llong	tracksize;
+	int	secsize;
+
+	for (i = 1; i <= tracks; i++) {
+		tp = &trackp[i];
+
+		if (auinfosize(tp->filename, tp)) {
+			/*
+			 * open stdin
+			 */
+			tp->xfp = xopen(NULL, O_RDONLY|O_BINARY, 0);
+		} else if (strcmp("-", tp->filename) == 0) {
+			/*
+			 * open stdin
+			 */
+			tp->xfp = xopen(NULL, O_RDONLY|O_BINARY, 0);
+		} else {
+			if ((tp->xfp = xopen(tp->filename,
+					O_RDONLY|O_BINARY, 0)) == NULL) {
+				comerr("Cannot open '%s'.\n", tp->filename);
+			}
+		}
+
+		checksize(tp);
+		tracksize = tp->itracksize;
+		secsize = tp->isecsize;
+		if (!is_shorttrk(tp) &&
+		    tracksize > 0 && (tracksize / secsize) < 300) {
+
+			tracksize = roundup(tracksize, secsize);
+			if ((tp->padsecs +
+			    (tracksize / secsize)) < 300) {
+				tp->padsecs =
+					300 - tracksize / secsize;
+			}
+			if (xdebug) {
+				printf("TRACK %d SECTORS: %ld",
+					i, tp->tracksecs);
+				printf(" pasdize %lld (%ld sectors)\n",
+					(Llong)tp->padsecs * secsize,
+					tp->padsecs);
+			}
+		}
+#ifdef	AUINFO
+		if (tp->flags & TI_USEINFO) {
+			auinfo(tp->filename, i, trackp);
+			if (lverbose > 0 && i == 1)
+				printf("pregap1: %ld\n", trackp[1].pregapsize);
+		}
+#endif
+		/*
+		 * tracksecks is total numbers of sectors in track (starting from
+		 * index 0).
+		 */
+		if (tp->padsecs > 0)
+			tp->tracksecs += tp->padsecs;
+
+		if (debug) {
+			printf("File: '%s' itracksize: %lld isecsize: %d tracktype: %d = %s sectype: %X = %s dbtype: %s flags %X\n",
+				tp->filename, (Llong)tp->itracksize,
+				tp->isecsize,
+				tp->tracktype & TOC_MASK, toc2name[tp->tracktype & TOC_MASK],
+				tp->sectype, st2name[tp->sectype & ST_MASK], db2name[tp->dbtype], tp->flags);
+		}
+	}
+}
+
+static void 
+checksize(track_t *trackp)
+{
+	struct stat	st;
+	Llong		lsize;
+	int		f = -1;
+
+	if (trackp->xfp != NULL)
+		f = xfileno(trackp->xfp);
+
+	/*
+	 * If the current input file is a regular file and
+	 * 'padsize=' has not been specified,
+	 * use fstat() or file parser to get the size of the file.
+	 */
+	if (trackp->itracksize < 0 && (trackp->flags & TI_ISOSIZE) != 0) {
+		lsize = isosize(f);
+		trackp->itracksize = lsize;
+		if (trackp->itracksize != lsize)
+			comerrno(EX_BAD, "This OS cannot handle large ISO-9660 images.\n");
+	}
+	if (trackp->itracksize < 0 && (trackp->flags & TI_NOAUHDR) == 0) {
+		lsize = ausize(f);
+		trackp->itracksize = lsize;
+		if (trackp->itracksize != lsize)
+			comerrno(EX_BAD, "This OS cannot handle large audio images.\n");
+	}
+	if (trackp->itracksize < 0 && (trackp->flags & TI_NOAUHDR) == 0) {
+		lsize = wavsize(f);
+		trackp->itracksize = lsize;
+		if (trackp->itracksize != lsize)
+			comerrno(EX_BAD, "This OS cannot handle large WAV images.\n");
+		if (trackp->itracksize > 0)	/* Force little endian input */
+			trackp->flags |= TI_SWAB;
+	}
+	if (trackp->itracksize == AU_BAD_CODING) {
+		comerrno(EX_BAD, "Inappropriate audio coding in '%s'.\n",
+							trackp->filename);
+	}
+	if (trackp->itracksize < 0 &&
+			fstat(f, &st) >= 0 && S_ISREG(st.st_mode)) {
+		trackp->itracksize = st.st_size;
+	}
+	if (trackp->itracksize >= 0) {
+		/*
+		 * We do not allow cdrecord to start if itracksize is not
+		 * a multiple of isecsize or we are allowed to pad to secsize via -pad.
+		 * For this reason, we may safely always assume padding.
+		 */
+		trackp->tracksecs = (trackp->itracksize + trackp->isecsize -1) / trackp->isecsize;
+		trackp->tracksize = (trackp->itracksize / trackp->isecsize) * trackp->secsize
+					+ trackp->itracksize % trackp->isecsize;
+	} else {
+		trackp->tracksecs = -1L;
+	}
+}
+
+static BOOL 
+checkdsize(SCSI *usalp, cdr_t *dp, long tsize, int flags)
+{
+	long	startsec = 0L;
+	long	endsec = 0L;
+	dstat_t	*dsp = dp->cdr_dstat;
+	int	profile;
+
+	usalp->silent++;
+	(*dp->cdr_next_wr_address)(usalp, (track_t *)0, &startsec);
+	usalp->silent--;
+
+	/*
+	 * This only should happen when the drive is currently in SAO mode.
+	 * We rely on the drive being in TAO mode, a negative value for
+	 * startsec is not correct here it may be caused by bad firmware or
+	 * by a drive in SAO mode. In SAO mode the drive will report the
+	 * pre-gap as part of the writable area.
+	 */
+	if (startsec < 0)
+		startsec = 0;
+
+	/*
+	 * Size limitations (sectors) for CD's:
+	 *
+	 *		404850 == 90 min	Red book calls this the
+	 *					first negative time
+	 *					allows lead out start up to
+	 *					block 404700
+	 *
+	 *		449850 == 100 min	This is the first time that
+	 *					is no more representable
+	 *					in a two digit BCD number.
+	 *					allows lead out start up to
+	 *					block 449700
+	 *
+	 *		~540000 == 120 min	The largest CD ever made.
+	 *
+	 *		~650000 == 1.3 GB	a Double Density (DD) CD.
+	 */
+
+	endsec = startsec + tsize;
+	dsp->ds_startsec = startsec;
+	dsp->ds_endsec = endsec;
+
+
+	if (dsp->ds_maxblocks > 0) {
+		/*
+		 * dsp->ds_maxblocks > 0 (disk capacity is known).
+		 */
+		if (lverbose)
+			printf("Blocks total: %ld Blocks current: %ld Blocks remaining: %ld\n",
+					(long)dsp->ds_maxblocks,
+					(long)dsp->ds_maxblocks - startsec,
+					(long)dsp->ds_maxblocks - endsec);
+
+		if (endsec > dsp->ds_maxblocks) {
+			if (dsp->ds_flags & DSF_DVD) {	/* A DVD and not a CD */
+				/*
+				 * There is no overburning on DVD...
+				 */
+				errmsgno(EX_BAD,
+				"Data does not fit on current disk.\n");
+				goto toolarge;
+			}
+			errmsgno(EX_BAD,
+			"WARNING: Data may not fit on current disk.\n");
+
+			/* XXX Check for flags & CDR_NO_LOLIMIT */
+/*			goto toolarge;*/
+		}
+		if (lverbose && dsp->ds_maxrblocks > 0)
+			printf("RBlocks total: %ld RBlocks current: %ld RBlocks remaining: %ld\n",
+					(long)dsp->ds_maxrblocks,
+					(long)dsp->ds_maxrblocks - startsec,
+					(long)dsp->ds_maxrblocks - endsec);
+		if (dsp->ds_maxrblocks > 0 && endsec > dsp->ds_maxrblocks) {
+			errmsgno(EX_BAD,
+			"Data does not fit on current disk.\n");
+			goto toolarge;
+		}
+		if ((endsec > dsp->ds_maxblocks && endsec > 404700) ||
+		    (dsp->ds_maxrblocks > 404700 && 449850 > dsp->ds_maxrblocks)) {
+			/*
+			 * Assume that this must be a CD and not a DVD.
+			 * So this is a non Red Book compliant CD with a
+			 * capacity between 90 and 99 minutes.
+			 */
+			if (dsp->ds_maxrblocks > 404700)
+				printf("RedBook total: %ld RedBook current: %ld RedBook remaining: %ld\n",
+					404700L,
+					404700L - startsec,
+					404700L - endsec);
+			if (endsec > dsp->ds_maxblocks && endsec > 404700) {
+				if ((flags & (F_IGNSIZE|F_FORCE)) == 0) {
+					errmsgno(EX_BAD,
+					"Notice: Most recorders cannot write CD's >= 90 minutes.\n");
+					errmsgno(EX_BAD,
+					"Notice: Use -ignsize option to allow >= 90 minutes.\n");
+				}
+				goto toolarge;
+			}
+		}
+	} else {
+		/*
+		 * dsp->ds_maxblocks == 0 (disk capacity is unknown).
+		 */
+	        profile = dp->profile;
+	        if (endsec >= (4200000)) {
+		        errmsgno(EX_BAD,
+			"ERROR: Could not manage to find medium size, and more than 8.0 GB of data.\n");
+  		        goto toolarge;  
+		} else if (profile != 0x2B) { 
+		    if (endsec >= (2300000)) {
+			errmsgno(EX_BAD,
+				"ERROR: Could not manage to find medium size, and more than 4.3 GB of data for a non dual layer disc.\n");
+			goto toolarge;
+		    } else if (endsec >= (405000-300)) {            /*<90 min disk or DVD*/
+			errmsgno(EX_BAD,
+				"WARNING: Could not manage to find medium size, and more than 90 mins of data.\n");
+		    } else if (endsec >= (333000-150)) {		/* 74 min disk*/
+			errmsgno(EX_BAD,
+				"WARNING: Data may not fit on standard 74min disk.\n");
+		    }
+		}
+	}
+	if (dsp->ds_maxblocks <= 0 || endsec <= dsp->ds_maxblocks)
+		return (TRUE);
+	/* FALLTHROUGH */
+toolarge:
+	if (dsp->ds_maxblocks > 0 && endsec > dsp->ds_maxblocks) {
+		if ((flags & (F_OVERBURN|F_IGNSIZE|F_FORCE)) != 0) {
+			if (dsp->ds_flags & DSF_DVD) {	/* A DVD and not a CD */
+				errmsgno(EX_BAD,
+				"Notice: -overburn is not expected to work with DVD media.\n");
+			}
+			errmsgno(EX_BAD,
+				"Notice: Overburning active. Trying to write more than the official disk capacity.\n");
+			return (TRUE);
+		} else {
+			if ((dsp->ds_flags & DSF_DVD) == 0) {	/* A CD and not a DVD */
+				errmsgno(EX_BAD,
+				"Notice: Use -overburn option to write more than the official disk capacity.\n");
+				errmsgno(EX_BAD,
+				"Notice: Most CD-writers do overburning only on SAO or RAW mode.\n");
+			}
+			return (FALSE);
+		}
+	}
+	if (dsp->ds_maxblocks < 449850) {
+		if ((dsp->ds_flags & DSF_DVD) == 0) {	/* A CD and not a DVD */
+			if (endsec <= dsp->ds_maxblocks)
+				return (TRUE);
+			errmsgno(EX_BAD, "Cannot write more than remaining DVD capacity.\n");
+			return (FALSE);
+		}
+		/*
+		 * Assume that this must be a CD and not a DVD.
+		 */
+		if (endsec > 449700) {
+			errmsgno(EX_BAD, "Cannot write CD's >= 100 minutes.\n");
+			return (FALSE);
+		}
+	}
+	if ((flags & (F_IGNSIZE|F_FORCE)) != 0)
+		return (TRUE);
+	return (FALSE);
+}
+
+static void 
+raise_fdlim()
+{
+#ifdef	RLIMIT_NOFILE
+
+	struct rlimit	rlim;
+
+	/*
+	 * Set max # of file descriptors to be able to hold all files open
+	 */
+	getrlimit(RLIMIT_NOFILE, &rlim);
+	if (rlim.rlim_cur >= (MAX_TRACK + 10))
+		return;
+
+	rlim.rlim_cur = MAX_TRACK + 10;
+	if (rlim.rlim_cur > rlim.rlim_max)
+		errmsgno(EX_BAD,
+			"Warning: low file descriptor limit (%lld)\n",
+						(Llong)rlim.rlim_max);
+	setrlimit(RLIMIT_NOFILE, &rlim);
+
+#endif	/* RLIMIT_NOFILE */
+}
+
+static void 
+raise_memlock()
+{
+#ifdef	RLIMIT_MEMLOCK
+	struct rlimit rlim;
+
+	rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY;
+
+	if (setrlimit(RLIMIT_MEMLOCK, &rlim) < 0)
+		errmsg("Warning: Cannot raise RLIMIT_MEMLOCK limits.\n");
+#endif	/* RLIMIT_MEMLOCK */
+}
+
+char	*opts =
+"help,version,checkdrive,prcap,inq,devices,scanbus,reset,abort,overburn,ignsize,useinfo,dev*,timeout#,driver*,driveropts*,setdropts,tsize&,padsize&,pregap&,defpregap&,speed#,load,lock,eject,dummy,msinfo,toc,atip,multi,fix,nofix,waiti,immed,debug#,d+,kdebug#,kd#,verbose+,v+,Verbose+,V+,x+,xd#,silent,s,audio,data,mode2,xa,xa1,xa2,xamix,cdi,isosize,nopreemp,preemp,nocopy,copy,nopad,pad,swab,fs&,ts&,blank&,format,formattype&,pktsize#,packet,noclose,force,tao,dao,sao,raw,raw96r,raw96p,raw16,clone,scms,isrc*,mcn*,index*,cuefile*,textfile*,text,shorttrack,noshorttrack,gracetime#,minbuf#,msifile*";
+
+/*
+ * Defines used to find whether a write mode has been specified.
+ */
+#define	M_TAO		1	/* Track at Once mode */
+#define	M_SAO		2	/* Session at Once mode (also known as DAO) */
+#define	M_RAW		4	/* Raw mode */
+#define	M_PACKET	8	/* Packed mode */
+static int 
+gargs(int ac, char **av, int *tracksp, track_t *trackp, char **devp, 
+		int *timeoutp, cdr_t **dpp, int *speedp, long *flagsp, int *blankp, 
+		int *formatp)
+{
+	int	cac;
+	char	* const*cav;
+	char	*driver = NULL;
+	char	*dev = NULL;
+	char	*isrc = NULL;
+	char	*mcn = NULL;
+	char	*tindex = NULL;
+	char	*cuefile = NULL;
+	char	*textfile = NULL;
+	long	bltype = -1;
+	int	doformat = 0;
+	int	formattype = -1;
+	Llong	tracksize;
+	Llong	padsize;
+	long	pregapsize;
+	long	defpregap = -1L;
+	int	pktsize;
+	int	speed = -1;
+	int	help = 0;
+	int	version = 0;
+	int	checkdrive = 0;
+	int	setdropts = 0;
+	int	prcap = 0;
+	int	inq = 0;
+	int	scanbus = 0;
+	int	reset = 0;
+	int	doabort = 0;
+	int	overburn = 0;
+	int	ignsize = 0;
+	int	useinfo = 0;
+	int	load = 0;
+	int	lock = 0;
+	int	eject = 0;
+	int	dummy = 0;
+	int	msinfo = 0;
+	int	toc = 0;
+	int	atip = 0;
+	int	multi = 0;
+	int	fix = 0;
+	int	nofix = 0;
+	int	waiti = 0;
+	int	immed = 0;
+	int	audio;
+	int	autoaudio = 0;
+	int	data;
+	int	mode2;
+	int	xa;
+	int	xa1;
+	int	xa2;
+	int	xamix;
+	int	cdi;
+	int	isize;
+	int	ispacket = 0;
+	int	noclose = 0;
+	int	force = 0;
+	int	tao = 0;
+	int	dao = 0;
+	int	raw = 0;
+	int	raw96r = 0;
+	int	raw96p = 0;
+	int	raw16 = 0;
+	int	clone = 0;
+	int	scms = 0;
+	int	preemp = 0;
+	int	nopreemp;
+	int	copy = 0;
+	int	nocopy;
+	int	pad = 0;
+	int	bswab = 0;
+	int	nopad;
+	int	usetext = 0;
+	int	shorttrack = 0;
+	int	noshorttrack;
+	int	flags;
+	int	tracks = *tracksp;
+	int	tracktype = TOC_ROM;
+/*	int	sectype = ST_ROM_MODE1 | ST_MODE_1;*/
+	int	sectype = SECT_ROM;
+	int	dbtype = DB_ROM_MODE1;
+	int	secsize = DATA_SEC_SIZE;
+	int	dataoff = 16;
+	int	ga_ret;
+	int	wm = 0;
+
+	trackp[0].flags |= TI_TAO;
+	trackp[1].pregapsize = -1;
+	*flagsp |= F_WRITE;
+
+	cac = --ac;
+	cav = ++av;
+	for (; ; cac--, cav++) {
+		tracksize = (Llong)-1L;
+		padsize = (Llong)0L;
+		pregapsize = defpregap;
+		audio = data = mode2 = xa = xa1 = xa2 = xamix = cdi = 0;
+		isize = nopreemp = nocopy = nopad = noshorttrack = 0;
+		pktsize = 0;
+		isrc = NULL;
+		tindex = NULL;
+		/*
+		 * Get options up to next file type arg.
+		 */
+		if ((ga_ret = getargs(&cac, &cav, opts,
+				&help, &version, &checkdrive, &prcap,
+				&inq, &scandevs, &scanbus, &reset, &doabort, &overburn, &ignsize,
+				&useinfo,
+				devp, timeoutp, &driver, &driveropts, &setdropts,
+				getllnum, &tracksize,
+				getllnum, &padsize,
+				getnum, &pregapsize,
+				getnum, &defpregap,
+				&speed,
+				&load, &lock,
+				&eject, &dummy, &msinfo, &toc, &atip,
+				&multi, &fix, &nofix, &waiti, &immed,
+				&debug, &debug,
+				&kdebug, &kdebug,
+				&lverbose, &lverbose,
+				&scsi_verbose, &scsi_verbose,
+				&xdebug, &xdebug,
+				&silent, &silent,
+				&audio, &data, &mode2,
+				&xa, &xa1, &xa2, &xamix, &cdi,
+				&isize,
+				&nopreemp, &preemp,
+				&nocopy, &copy,
+				&nopad, &pad, &bswab, getnum, &fs, getnum, &bufsize,
+				getbltype, &bltype, &doformat, getformattype, &formattype, &pktsize,
+				&ispacket, &noclose, &force,
+				&tao, &dao, &dao, &raw, &raw96r, &raw96p, &raw16,
+				&clone,
+				&scms, &isrc, &mcn, &tindex,
+				&cuefile, &textfile, &usetext,
+				&shorttrack, &noshorttrack,
+				&gracetime, &dminbuf, &msifile)) < 0) {
+			errmsgno(EX_BAD, "Bad Option: %s.\n", cav[0]);
+			susage(EX_BAD);
+		}
+		if (help)
+			usage(0);
+		if (tracks == 0) {
+			if (driver)
+				set_cdrcmds(driver, dpp);
+			if (version)
+				*flagsp |= F_VERSION;
+			if (checkdrive)
+				*flagsp |= F_CHECKDRIVE;
+			if (prcap)
+				*flagsp |= F_PRCAP;
+			if (inq)
+				*flagsp |= F_INQUIRY;
+			if (scanbus || scandevs) /* scandevs behaves similarly WRT in the legacy code, just the scan operation is different */
+				*flagsp |= F_SCANBUS;
+			if (reset)
+				*flagsp |= F_RESET;
+			if (doabort)
+				*flagsp |= F_ABORT;
+			if (overburn)
+				*flagsp |= F_OVERBURN;
+			if (ignsize)
+				*flagsp |= F_IGNSIZE;
+			if (load)
+				*flagsp |= F_LOAD;
+			if (lock)
+				*flagsp |= F_DLCK;
+			if (eject)
+				*flagsp |= F_EJECT;
+			if (dummy)
+				*flagsp |= F_DUMMY;
+			if (setdropts)
+				*flagsp |= F_SETDROPTS;
+			if(msifile)
+				msinfo++;
+			if (msinfo)
+				*flagsp |= F_MSINFO;
+			if (toc) {
+				*flagsp |= F_TOC;
+				*flagsp &= ~F_WRITE;
+			}
+			if (atip) {
+				*flagsp |= F_PRATIP;
+				*flagsp &= ~F_WRITE;
+			}
+			if (multi) {
+				/*
+				 * 2048 Bytes user data
+				 */
+				*flagsp |= F_MULTI;
+				tracktype = TOC_XA2;
+				sectype = ST_ROM_MODE2 | ST_MODE_2_FORM_1;
+				sectype = SECT_MODE_2_F1;
+				dbtype = DB_XA_MODE2;	/* XXX -multi nimmt DB_XA_MODE2_F1 !!! */
+				secsize = DATA_SEC_SIZE;	/* 2048 */
+				dataoff = 24;
+			}
+			if (fix)
+				*flagsp |= F_FIX;
+			if (nofix)
+				*flagsp |= F_NOFIX;
+			if (waiti)
+				*flagsp |= F_WAITI;
+			if (immed)
+				*flagsp |= F_IMMED;
+			if (force)
+				*flagsp |= F_FORCE;
+
+			if (bltype >= 0) {
+				*flagsp |= F_BLANK;
+				*blankp = bltype;
+			}
+ 			if (doformat > 0) {
+ 				*flagsp |= F_FORMAT;
+ 				*formatp |= FULL_FORMAT;
+ 			}
+ 			if (formattype >= 0) {
+ 				*flagsp |= F_FORMAT;
+ 				*formatp |= formattype;
+ 			}
+			if (ispacket)
+				wm |= M_PACKET;
+			if (tao)
+				wm |= M_TAO;
+			if (dao) {
+				*flagsp |= F_SAO;
+				trackp[0].flags &= ~TI_TAO;
+				trackp[0].flags |= TI_SAO;
+				wm |= M_SAO;
+
+			} else if ((raw == 0) && (raw96r + raw96p + raw16) > 0)
+				raw = 1;
+			if ((raw != 0) && (raw96r + raw96p + raw16) == 0)
+				raw96r = 1;
+			if (raw96r) {
+				if (!dao)
+					*flagsp |= F_RAW;
+				trackp[0].flags &= ~TI_TAO;
+				trackp[0].flags |= TI_RAW;
+				trackp[0].flags |= TI_RAW96R;
+				wm |= M_RAW;
+			}
+			if (raw96p) {
+				if (!dao)
+					*flagsp |= F_RAW;
+				trackp[0].flags &= ~TI_TAO;
+				trackp[0].flags |= TI_RAW;
+				wm |= M_RAW;
+			}
+			if (raw16) {
+				if (!dao)
+					*flagsp |= F_RAW;
+				trackp[0].flags &= ~TI_TAO;
+				trackp[0].flags |= TI_RAW;
+				trackp[0].flags |= TI_RAW16;
+				wm |= M_RAW;
+			}
+			if (mcn) {
+#ifdef	AUINFO
+				setmcn(mcn, &trackp[0]);
+#else
+				trackp[0].isrc = malloc(16);
+				fillbytes(trackp[0].isrc, 16, '\0');
+				strncpy(trackp[0].isrc, mcn, 13);
+#endif
+				mcn = NULL;
+			}
+			if ((raw96r + raw96p + raw16) > 1) {
+				errmsgno(EX_BAD, "Too many raw modes.\n");
+				comerrno(EX_BAD, "Only one of -raw16, -raw96p, -raw96r allowed.\n");
+			}
+			if ((tao + ispacket + dao + raw) > 1) {
+				errmsgno(EX_BAD, "Too many write modes.\n");
+				comerrno(EX_BAD, "Only one of -packet, -dao, -raw allowed.\n");
+			}
+			if (dao && (raw96r + raw96p + raw16) > 0) {
+				if (raw16)
+					comerrno(EX_BAD, "SAO RAW writing does not allow -raw16.\n");
+				if (!clone)
+					comerrno(EX_BAD, "SAO RAW writing only makes sense in clone mode.\n");
+#ifndef	CLONE_WRITE
+				comerrno(EX_BAD, "SAO RAW writing not yet implemented.\n");
+#endif
+				comerrno(EX_BAD, "SAO RAW writing not yet implemented.\n");
+			}
+			if (clone) {
+				*flagsp |= F_CLONE;
+				trackp[0].flags |= TI_CLONE;
+#ifndef	CLONE_WRITE
+				comerrno(EX_BAD, "Clone writing not compiled in.\n");
+#endif
+			}
+			if (textfile) {
+				if (!checktextfile(textfile)) {
+					if ((*flagsp & F_WRITE) != 0) {
+						comerrno(EX_BAD,
+							"Cannot use '%s' as CD-Text file.\n",
+							textfile);
+					}
+				}
+				if ((*flagsp & F_WRITE) != 0) {
+					if ((dao + raw96r + raw96p) == 0)
+						comerrno(EX_BAD,
+							"CD-Text needs -dao, -raw96r or -raw96p.\n");
+				}
+				trackp[0].flags |= TI_TEXT;
+			}
+			version = checkdrive = prcap = inq = scanbus = reset = doabort =
+			overburn = ignsize =
+			load = lock = eject = dummy = msinfo = toc = atip = multi = fix = nofix =
+			waiti = immed = force = dao = setdropts = 0;
+			raw96r = raw96p = raw16 = clone = 0;
+		} else if ((version + checkdrive + prcap + inq + scanbus +
+			    reset + doabort + overburn + ignsize +
+			    load + lock + eject + dummy + msinfo + toc + atip + multi + fix + nofix +
+			    waiti + immed + force + dao + setdropts +
+			    raw96r + raw96p + raw16 + clone) > 0 ||
+				mcn != NULL)
+			comerrno(EX_BAD, "Badly placed option. Global options must be before any track.\n");
+
+		if (nopreemp)
+			preemp = 0;
+		if (nocopy)
+			copy = 0;
+		if (nopad)
+			pad = 0;
+		if (noshorttrack)
+			shorttrack = 0;
+
+		if ((audio + data + mode2 + xa + xa1 + xa2 + xamix) > 1) {
+			errmsgno(EX_BAD, "Too many types for track %d.\n", tracks+1);
+			comerrno(EX_BAD, "Only one of -audio, -data, -mode2, -xa, -xa1, -xa2, -xamix allowed.\n");
+		}
+		if (ispacket && audio) {
+			comerrno(EX_BAD, "Audio data cannot be written in packet mode.\n");
+		}
+		/*
+		 * Check whether the next argument is a file type arg.
+		 * If this is true, then we got a track file name.
+		 * If getargs() did previously return NOTAFLAG, we may have hit
+		 * an argument that has been escaped via "--", so we may not
+		 * call getfiles() again in this case. If we would call
+		 * getfiles() and the current arg has been escaped and looks
+		 * like an option, a call to getfiles() would skip it.
+		 */
+		if (ga_ret != NOTAFLAG)
+			ga_ret = getfiles(&cac, &cav, opts);
+		if (autoaudio) {
+			autoaudio = 0;
+			tracktype = TOC_ROM;
+			sectype = ST_ROM_MODE1 | ST_MODE_1;
+			sectype = SECT_ROM;
+			dbtype = DB_ROM_MODE1;
+			secsize = DATA_SEC_SIZE;	/* 2048 */
+			dataoff = 16;
+		}
+		if (ga_ret == NOTAFLAG && (is_auname(cav[0]) || is_wavname(cav[0]))) {
+			/*
+			 * We got a track and autodetection decided that it
+			 * is an audio track.
+			 */
+			autoaudio++;
+			audio++;
+		}
+		if (data) {
+			/*
+			 * 2048 Bytes user data
+			 */
+			tracktype = TOC_ROM;
+			sectype = ST_ROM_MODE1 | ST_MODE_1;
+			sectype = SECT_ROM;
+			dbtype = DB_ROM_MODE1;
+			secsize = DATA_SEC_SIZE;	/* 2048 */
+			dataoff = 16;
+		}
+		if (mode2) {
+			/*
+			 * 2336 Bytes user data
+			 */
+			tracktype = TOC_ROM;
+			sectype = ST_ROM_MODE2 | ST_MODE_2;
+			sectype = SECT_MODE_2;
+			dbtype = DB_ROM_MODE2;
+			secsize = MODE2_SEC_SIZE;	/* 2336 */
+			dataoff = 16;
+		}
+		if (audio) {
+			/*
+			 * 2352 Bytes user data
+			 */
+			tracktype = TOC_DA;
+			sectype = preemp ? ST_AUDIO_PRE : ST_AUDIO_NOPRE;
+			sectype |= ST_MODE_AUDIO;
+			sectype = SECT_AUDIO;
+			if (preemp)
+				sectype |= ST_PREEMPMASK;
+			dbtype = DB_RAW;
+			secsize = AUDIO_SEC_SIZE;	/* 2352 */
+			dataoff = 0;
+		}
+		if (xa) {
+			/*
+			 * 2048 Bytes user data
+			 */
+			if (tracktype != TOC_CDI)
+				tracktype = TOC_XA2;
+			sectype = ST_ROM_MODE2 | ST_MODE_2_FORM_1;
+			sectype = SECT_MODE_2_F1;
+			dbtype = DB_XA_MODE2;
+			secsize = DATA_SEC_SIZE;	/* 2048 */
+			dataoff = 24;
+		}
+		if (xa1) {
+			/*
+			 * 8 Bytes subheader + 2048 Bytes user data
+			 */
+			if (tracktype != TOC_CDI)
+				tracktype = TOC_XA2;
+			sectype = ST_ROM_MODE2 | ST_MODE_2_FORM_1;
+			sectype = SECT_MODE_2_F1;
+			dbtype = DB_XA_MODE2_F1;
+			secsize = 2056;
+			dataoff = 16;
+		}
+		if (xa2) {
+			/*
+			 * 2324 Bytes user data
+			 */
+			if (tracktype != TOC_CDI)
+				tracktype = TOC_XA2;
+			sectype = ST_ROM_MODE2 | ST_MODE_2_FORM_2;
+			sectype = SECT_MODE_2_F2;
+			dbtype = DB_XA_MODE2_F2;
+			secsize = 2324;
+			dataoff = 24;
+		}
+		if (xamix) {
+			/*
+			 * 8 Bytes subheader + 2324 Bytes user data
+			 */
+			if (tracktype != TOC_CDI)
+				tracktype = TOC_XA2;
+			sectype = ST_ROM_MODE2 | ST_MODE_2_MIXED;
+			sectype = SECT_MODE_2_MIX;
+			dbtype = DB_XA_MODE2_MIX;
+			secsize = 2332;
+			dataoff = 16;
+		}
+		if (cdi) {
+			tracktype = TOC_CDI;
+		}
+		if (tracks == 0) {
+			trackp[0].tracktype = tracktype;
+			trackp[0].dbtype = dbtype;
+			trackp[0].isecsize = secsize;
+			trackp[0].secsize = secsize;
+			if ((*flagsp & F_RAW) != 0) {
+				trackp[0].secsize = is_raw16(&trackp[0]) ?
+						RAW16_SEC_SIZE:RAW96_SEC_SIZE;
+			}
+			if ((*flagsp & F_DUMMY) != 0)
+				trackp[0].tracktype |= TOCF_DUMMY;
+			if ((*flagsp & F_MULTI) != 0)
+				trackp[0].tracktype |= TOCF_MULTI;
+		}
+
+		flags = trackp[0].flags;
+
+		if ((sectype & ST_AUDIOMASK) != 0)
+			flags |= TI_AUDIO;
+		if (isize) {
+			flags |= TI_ISOSIZE;
+			if ((*flagsp & F_MULTI) != 0)
+				comerrno(EX_BAD, "Cannot get isosize for multi session disks.\n");
+			/*
+			 * As we do not get the padding from the ISO-9660
+			 * formatting utility, we need to force padding here.
+			 */
+			flags |= TI_PAD;
+			if (padsize == (Llong)0L)
+				padsize = (Llong)PAD_SIZE;
+		}
+
+		if ((flags & TI_AUDIO) != 0) {
+			if (preemp)
+				flags |= TI_PREEMP;
+			if (copy)
+				flags |= TI_COPY;
+			if (scms)
+				flags |= TI_SCMS;
+		}
+		if (pad || ((flags & TI_AUDIO) == 0 && padsize > (Llong)0L)) {
+			flags |= TI_PAD;
+			if ((flags & TI_AUDIO) == 0 && padsize == (Llong)0L)
+				padsize = (Llong)PAD_SIZE;
+		}
+		if (shorttrack && (*flagsp & (F_SAO|F_RAW)) != 0)
+			flags |= TI_SHORT_TRACK;
+		if (noshorttrack)
+			flags &= ~TI_SHORT_TRACK;
+		if (bswab)
+			flags |= TI_SWAB;
+		if (ispacket) {
+			flags |= TI_PACKET;
+			trackp[0].flags &= ~TI_TAO;
+		}
+		if (noclose)
+			flags |= TI_NOCLOSE;
+		if (useinfo)
+			flags |= TI_USEINFO;
+
+		if (ga_ret == NOARGS) {
+			/*
+			 * All options have already been parsed and no more
+			 * file type arguments are present.
+			 */
+			break;
+		}
+		if (tracks == 0 && (wm == 0)) {
+			errmsgno(EX_BAD, "No write mode specified.\n");
+			errmsgno(EX_BAD, "Assuming -tao mode.\n");
+			errmsgno(EX_BAD, "Future versions of wodim may have different drive dependent defaults.\n");
+			tao = 1;
+		}
+		tracks++;
+
+		if (tracks > MAX_TRACK)
+			comerrno(EX_BAD, "Track limit (%d) exceeded\n",
+								MAX_TRACK);
+		/*
+		 * Make 'tracks' immediately usable in track structure.
+		 */
+		{	register int i;
+			for (i = 0; i < MAX_TRACK+2; i++)
+				trackp[i].tracks = tracks;
+		}
+
+		if (strcmp("-", cav[0]) == 0)
+			*flagsp |= F_STDIN;
+
+		if (!is_auname(cav[0]) && !is_wavname(cav[0]))
+			flags |= TI_NOAUHDR;
+
+		if ((*flagsp & (F_SAO|F_RAW)) != 0 && (flags & TI_AUDIO) != 0)
+			flags |= TI_PREGAP;	/* Hack for now */
+		if (tracks == 1)
+			flags &= ~TI_PREGAP;
+
+		if (tracks == 1 && (pregapsize != -1L && pregapsize != 150))
+			pregapsize = -1L;
+		trackp[tracks].filename = cav[0];
+		trackp[tracks].trackstart = 0L;
+		trackp[tracks].itracksize = tracksize;
+		trackp[tracks].tracksize = tracksize;
+		trackp[tracks].tracksecs = -1L;
+		if (tracksize >= 0) {
+			trackp[tracks].tracksecs = (tracksize+secsize-1)/secsize;
+			if(tracksize<616448)
+				warn_minisize=tracksize;
+		}
+		if (trackp[tracks].pregapsize < 0)
+			trackp[tracks].pregapsize = pregapsize;
+		trackp[tracks+1].pregapsize = -1;
+		trackp[tracks].padsecs = (padsize+2047)/2048;
+		trackp[tracks].isecsize = secsize;
+		trackp[tracks].secsize = secsize;
+		trackp[tracks].flags = flags;
+		/*
+		 * XXX Dies ist falsch: auch bei SAO/RAW kann
+		 * XXX secsize != isecsize sein.
+		 */
+		if ((*flagsp & F_RAW) != 0) {
+			if (is_raw16(&trackp[tracks]))
+				trackp[tracks].secsize = RAW16_SEC_SIZE;
+			else
+				trackp[tracks].secsize = RAW96_SEC_SIZE;
+#ifndef	HAVE_LIB_EDC_ECC
+			if ((sectype & ST_MODE_MASK) != ST_MODE_AUDIO) {
+				errmsgno(EX_BAD,
+					"EDC/ECC library not compiled in.\n");
+				comerrno(EX_BAD,
+					"Data sectors are not supported in RAW mode.\n");
+			}
+#endif
+		}
+		trackp[tracks].secspt = 0;	/* transfer size is set up in set_trsizes() */
+		trackp[tracks].pktsize = pktsize;
+		trackp[tracks].trackno = tracks;
+		trackp[tracks].sectype = sectype;
+#ifdef	CLONE_WRITE
+		if ((*flagsp & F_CLONE) != 0) {
+			trackp[tracks].isecsize = 2448;
+			trackp[tracks].sectype |= ST_MODE_RAW;
+			dataoff = 0;
+		}
+#endif
+		trackp[tracks].dataoff = dataoff;
+		trackp[tracks].tracktype = tracktype;
+		trackp[tracks].dbtype = dbtype;
+		trackp[tracks].flags = flags;
+		trackp[tracks].nindex = 1;
+		trackp[tracks].tindex = 0;
+		if (isrc) {
+#ifdef	AUINFO
+			setisrc(isrc, &trackp[tracks]);
+#else
+			trackp[tracks].isrc = malloc(16);
+			fillbytes(trackp[tracks].isrc, 16, '\0');
+			strncpy(trackp[tracks].isrc, isrc, 12);
+#endif
+		}
+		if (tindex) {
+#ifdef	AUINFO
+			setindex(tindex, &trackp[tracks]);
+#endif
+		}
+	}
+
+	if (dminbuf >= 0) {
+		if (dminbuf < 25 || dminbuf > 95)
+			comerrno(EX_BAD,
+			"Bad minbuf=%d option (must be between 25 and 95)\n",
+				dminbuf);
+	}
+
+	if (speed < 0 && speed != -1)
+		comerrno(EX_BAD, "Bad speed option.\n");
+
+	if (fs < 0L && fs != -1L)
+		comerrno(EX_BAD, "Bad fifo size option.\n");
+
+	if (bufsize < 0L && bufsize != -1L)
+		comerrno(EX_BAD, "Bad transfer size option.\n");
+	if (bufsize < 0L)
+		bufsize = CDR_BUF_SIZE;
+	if (bufsize > CDR_MAX_BUF_SIZE)
+		bufsize = CDR_MAX_BUF_SIZE;
+
+	dev = *devp;
+	cdr_defaults(&dev, &speed, &fs, &driveropts);
+	if (debug) {
+		printf("dev: '%s' speed: %d fs: %ld driveropts '%s'\n",
+					dev, speed, fs, driveropts);
+	}
+	if (speed >= 0)
+		*speedp = speed;
+
+	if (fs < 0L)
+		fs = DEFAULT_FIFOSIZE;
+	if (fs < 2*bufsize) {
+		errmsgno(EX_BAD, "Fifo size %ld too small, turning fifo off.\n", fs);
+		fs = 0L;
+	}
+
+	if (dev != *devp && (*flagsp & F_SCANBUS) == 0)
+		*devp = dev;
+
+	if (*devp &&
+	    ((strncmp(*devp, "HELP", 4) == 0) ||
+	    (strncmp(*devp, "help", 4) == 0))) {
+		*flagsp |= F_CHECKDRIVE; /* Set this for not calling mlockall() */
+		return ispacket;
+	}
+	if (*flagsp & (F_LOAD|F_DLCK|F_SETDROPTS|F_MSINFO|F_TOC|F_PRATIP|F_FIX|F_VERSION|F_CHECKDRIVE|F_PRCAP|F_INQUIRY|F_SCANBUS|F_RESET|F_ABORT)) {
+		if (tracks != 0) {
+       fprintf(stderr,
+             "No tracks allowed with -load, -lock, -setdropts, -msinfo, -toc, -atip, -fix,\n"
+             "-version, -checkdrive, -prcap, -inq, -scanbus, --devices, -reset and -abort options.\n" );
+       exit(EXIT_FAILURE);
+		}
+		return ispacket;
+	}
+	*tracksp = tracks;
+	if (*flagsp & F_SAO) {
+		/*
+		 * Make sure that you change WRITER_MAXWAIT & READER_MAXWAIT
+		 * too if you change this timeout.
+		 */
+		if (*timeoutp < 200)		/* Lead in size is 2:30 */
+			*timeoutp = 200;	/* 200s is 150s *1.33	*/
+	}
+	if (usetext) {
+		trackp[MAX_TRACK+1].flags |= TI_TEXT;
+	}
+	if (cuefile) {
+#ifdef	FUTURE
+		if ((*flagsp & F_SAO) == 0 &&
+		    (*flagsp & F_RAW) == 0) {
+#else
+		if ((*flagsp & F_SAO) == 0) {
+#endif
+			errmsgno(EX_BAD, "The cuefile= option only works with -dao.\n");
+			susage(EX_BAD);
+		}
+		if (tracks > 0) {
+			errmsgno(EX_BAD, "No tracks allowed with the cuefile= option\n");
+			susage(EX_BAD);
+		}
+		cuefilename = cuefile;
+		return ispacket;
+	}
+	if (tracks == 0 && (*flagsp & (F_LOAD|F_DLCK|F_EJECT|F_BLANK|F_FORMAT)) == 0) {
+		errmsgno(EX_BAD, "No tracks specified. Need at least one.\n");
+		susage(EX_BAD);
+	}
+	return ispacket;
+}
+
+static void 
+set_trsizes(cdr_t *dp, int tracks, track_t *trackp)
+{
+	int	i;
+	int	secsize;
+	int	secspt;
+
+	trackp[1].flags		|= TI_FIRST;
+	trackp[tracks].flags	|= TI_LAST;
+
+	if (xdebug)
+		printf("Set Transfersizes start\n");
+	for (i = 0; i <= tracks+1; i++) {
+		if ((dp->cdr_flags & CDR_SWABAUDIO) != 0 &&
+					is_audio(&trackp[i])) {
+			trackp[i].flags ^= TI_SWAB;
+		}
+		if (!is_audio(&trackp[i]))
+			trackp[i].flags &= ~TI_SWAB;	/* Only swab audio  */
+
+		/*
+		 * Use the biggest sector size to compute how many
+		 * sectors may fit into one single DMA buffer.
+		 */
+		secsize = trackp[i].secsize;
+		if (trackp[i].isecsize > secsize)
+			secsize = trackp[i].isecsize;
+
+		/*
+		 * We are using SCSI Group 0 write
+		 * and cannot write more than 255 secs at once.
+		 */
+		secspt = bufsize/secsize;
+		secspt = min(255, secspt);
+		trackp[i].secspt = secspt;
+
+		if (is_packet(&trackp[i]) && trackp[i].pktsize > 0) {
+			if (trackp[i].secspt >= trackp[i].pktsize) {
+				trackp[i].secspt = trackp[i].pktsize;
+			} else {
+				comerrno(EX_BAD,
+					"Track %d packet size %d exceeds buffer limit of %d sectors",
+					i, trackp[i].pktsize, trackp[i].secspt);
+			}
+		}
+		if (xdebug) {
+			printf("Track %d flags %X secspt %d secsize: %d isecsize: %d\n",
+				i, trackp[i].flags, trackp[i].secspt,
+				trackp[i].secsize, trackp[i].isecsize);
+		}
+	}
+	if (xdebug)
+		printf("Set Transfersizes end\n");
+}
+
+void 
+load_media(SCSI *usalp, cdr_t *dp, BOOL doexit)
+{
+	int	code;
+	int	key;
+	BOOL	immed = (dp->cdr_cmdflags&F_IMMED) != 0;
+
+	/*
+	 * Do some preparation before...
+	 */
+	usalp->silent++;			/* Be quiet if this fails		*/
+	test_unit_ready(usalp);		/* First eat up unit attention		*/
+	if ((*dp->cdr_load)(usalp, dp) < 0) {	/* now try to load media and	*/
+		if (!doexit)
+			return;
+		comerrno(EX_BAD, "Cannot load media.\n");
+	}
+	scsi_start_stop_unit(usalp, 1, 0, immed); /* start unit in silent mode	*/
+	usalp->silent--;
+
+	if (!wait_unit_ready(usalp, 60)) {
+		code = usal_sense_code(usalp);
+		key = usal_sense_key(usalp);
+		usalp->silent++;
+		scsi_prevent_removal(usalp, 0); /* In case someone locked it */
+		usalp->silent--;
+
+		if (!doexit)
+			return;
+		if (key == SC_NOT_READY && (code == 0x3A || code == 0x30))
+			comerrno(EX_BAD, "No disk / Wrong disk!\n");
+		comerrno(EX_BAD, "CD/DVD-Recorder not ready.\n");
+	}
+
+	scsi_prevent_removal(usalp, 1);
+	scsi_start_stop_unit(usalp, 1, 0, immed);
+	wait_unit_ready(usalp, 120);
+	usalp->silent++;
+	if(geteuid() == 0) /* EB: needed? Not allowed for non-root, that is sure. */
+      rezero_unit(usalp);	/* Is this needed? Not supported by some drvives */
+	usalp->silent--;
+	test_unit_ready(usalp);
+	scsi_start_stop_unit(usalp, 1, 0, immed);
+	wait_unit_ready(usalp, 120);
+}
+
+void 
+unload_media(SCSI *usalp, cdr_t *dp, int flags)
+{
+	scsi_prevent_removal(usalp, 0);
+	if ((flags & F_EJECT) != 0) {
+		if ((*dp->cdr_unload)(usalp, dp) < 0)
+			errmsgno(EX_BAD, "Cannot eject media.\n");
+	}
+}
+
+void 
+reload_media(SCSI *usalp, cdr_t *dp)
+{
+	char	ans[2];
+#ifdef	F_GETFL
+	int	f = -1;
+#endif
+
+	errmsgno(EX_BAD, "Drive needs to reload the media to return to proper status.\n");
+	unload_media(usalp, dp, F_EJECT);
+
+	/*
+	 * Note that even Notebook drives identify as CDR_TRAYLOAD
+	 */
+	if ((dp->cdr_flags & CDR_TRAYLOAD) != 0) {
+		usalp->silent++;
+		load_media(usalp, dp, FALSE);
+		usalp->silent--;
+	}
+
+	usalp->silent++;
+	if (((dp->cdr_flags & CDR_TRAYLOAD) == 0) ||
+				!wait_unit_ready(usalp, 5)) {
+		static FILE	*tty = NULL;
+
+		printf("Re-load disk and hit <CR>");
+		if (isgui)
+			printf("\n");
+		flush();
+
+		if (tty == NULL) {
+			tty = stdin;
+			if ((dp->cdr_cmdflags & F_STDIN) != 0)
+				tty = fileluopen(STDERR_FILENO, "rw");
+		}
+#ifdef	F_GETFL
+		if (tty != NULL)
+			f = fcntl(fileno(tty), F_GETFL, 0);
+		if (f < 0 || (f & O_ACCMODE) == O_WRONLY) {
+#ifdef	SIGUSR1
+			signal(SIGUSR1, catchsig);
+			printf("Controlling file not open for reading, send SIGUSR1 to continue.\n");
+			flush();
+			pause();
+#endif
+		} else
+#endif
+		if (rols_fgetline(tty, ans, 1) < 0)
+			comerrno(EX_BAD, "Aborted by EOF on input.\n");
+	}
+	usalp->silent--;
+
+	load_media(usalp, dp, TRUE);
+}
+
+void 
+set_secsize(SCSI *usalp, int secsize)
+{
+	if (secsize > 0) {
+		/*
+		 * Try to restore the old sector size.
+		 */
+		usalp->silent++;
+		select_secsize(usalp, secsize);
+		usalp->silent--;
+	}
+}
+
+static int 
+get_dmaspeed(SCSI *usalp, cdr_t *dp)
+{
+	int	i;
+	long	t;
+	int	bs;
+	int	tsize;
+
+  if(getenv("CDR_NODMATEST"))
+     return -1;
+
+  if (debug || lverbose)
+     fprintf( stderr, 
+           "Beginning DMA speed test. Set CDR_NODMATEST environment variable if device\n"
+           "communication breaks or freezes immediately after that.\n" );
+
+	fillbytes((caddr_t)buf, 4, '\0');
+	tsize = 0;
+	usalp->silent++;
+	i = read_buffer(usalp, buf, 4, 0);
+	usalp->silent--;
+	if (i < 0)
+		return (-1);
+	tsize = a_to_u_4_byte(buf);
+	if (tsize <= 0)
+		return (-1);
+
+	if (gettimeofday(&starttime, (struct timezone *)0) < 0)
+		return (-1);
+
+	bs = bufsize;
+	if (tsize < bs)
+		bs = tsize;
+	for (i = 0; i < 100; i++) {
+		if (read_buffer(usalp, buf, bs, 0) < 0)
+			return (-1);
+	}
+	if (gettimeofday(&fixtime, (struct timezone *)0) < 0) {
+		errmsg("Cannot get DMA stop time\n");
+		return (-1);
+	}
+	timevaldiff(&starttime, &fixtime);
+	tsize = bs * 100;
+	t = fixtime.tv_sec * 1000 + fixtime.tv_usec / 1000;
+	if (t <= 0)
+		return (-1);
+#ifdef	DEBUG
+	fprintf(stderr, "Read Speed: %lu %ld %ld kB/s %ldx CD %ldx DVD\n",
+		tsize, t, tsize/t, tsize/t/176, tsize/t/1385);
+#endif
+
+	return (tsize/t);
+}
+
+
+static BOOL 
+do_opc(SCSI *usalp, cdr_t *dp, int flags)
+{
+	if ((flags & F_DUMMY) == 0 && dp->cdr_opc) {
+		if (debug || lverbose) {
+			printf("Performing OPC...\n");
+			flush();
+		}
+		if (dp->cdr_opc(usalp, NULL, 0, TRUE) < 0) {
+			errmsgno(EX_BAD, "OPC failed.\n");
+			if ((flags & F_FORCE) == 0)
+				return (FALSE);
+		}
+	}
+	return (TRUE);
+}
+
+static void 
+check_recovery(SCSI *usalp, cdr_t *dp, int flags)
+{
+	if ((*dp->cdr_check_recovery)(usalp, dp)) {
+		errmsgno(EX_BAD, "Recovery needed.\n");
+		unload_media(usalp, dp, flags);
+		comexit(EX_BAD);
+	}
+}
+
+#ifndef	DEBUG
+#define	DEBUG
+#endif
+void 
+audioread(SCSI *usalp, cdr_t *dp, int flags)
+{
+#ifdef	DEBUG
+	int speed = 1;
+	int	oflags = dp->cdr_cmdflags;
+
+	dp->cdr_cmdflags &= ~F_DUMMY;
+	if ((*dp->cdr_set_speed_dummy)(usalp, dp, &speed) < 0)
+		comexit(-1);
+	dp->cdr_dstat->ds_wspeed = speed; /* XXX Remove 'speed' in future */
+	dp->cdr_cmdflags = oflags;
+
+	if ((*dp->cdr_set_secsize)(usalp, 2352) < 0)
+		comexit(-1);
+	usalp->cap->c_bsize = 2352;
+
+	read_scsi(usalp, buf, 1000, 1);
+	printf("XXX:\n");
+	write(1, buf, 512); /* FIXME: handle return value */
+	unload_media(usalp, dp, flags);
+	comexit(0);
+#endif
+}
+
+static void 
+print_msinfo(SCSI *usalp, cdr_t *dp)
+{
+	long	off;
+	long	fa;
+
+	if ((*dp->cdr_session_offset)(usalp, &off) < 0) {
+		errmsgno(EX_BAD, "Cannot read session offset\n");
+		return;
+	}
+	if (lverbose)
+		printf("session offset: %ld\n", off);
+
+	if (dp->cdr_next_wr_address(usalp, (track_t *)0, &fa) < 0) {
+		errmsgno(EX_BAD, "Cannot read first writable address\n");
+		return;
+	}
+	printf("%ld,%ld\n", off, fa);
+	if(msifile) {
+		FILE *f = fopen(msifile, "w");
+		if(f) {
+			fprintf(f, "%ld,%ld", off, fa);
+			fclose(f);
+		}
+		else {
+			perror("Unable to write multi session info file");
+			exit(EXIT_FAILURE);
+		}
+	}
+}
+
+static void 
+print_toc(SCSI *usalp, cdr_t *dp)
+{
+	int	first;
+	int	last;
+	long	lba;
+	long	xlba;
+	struct msf msf;
+	int	adr;
+	int	control;
+	int	mode;
+	int	i;
+
+	usalp->silent++;
+	if (read_capacity(usalp) < 0) {
+		usalp->silent--;
+		errmsgno(EX_BAD, "Cannot read capacity\n");
+		return;
+	}
+	usalp->silent--;
+	if (read_tochdr(usalp, dp, &first, &last) < 0) {
+		errmsgno(EX_BAD, "Cannot read TOC/PMA\n");
+		return;
+	}
+	printf("first: %d last %d\n", first, last);
+	for (i = first; i <= last; i++) {
+		read_trackinfo(usalp, i, &lba, &msf, &adr, &control, &mode);
+		xlba = -150 +
+			msf.msf_frame + (75*msf.msf_sec) + (75*60*msf.msf_min);
+		if (xlba == lba/4)
+			lba = xlba;
+		print_track(i, lba, &msf, adr, control, mode);
+	}
+	i = 0xAA;
+	read_trackinfo(usalp, i, &lba, &msf, &adr, &control, &mode);
+	xlba = -150 +
+		msf.msf_frame + (75*msf.msf_sec) + (75*60*msf.msf_min);
+	if (xlba == lba/4)
+		lba = xlba;
+	print_track(i, lba, &msf, adr, control, mode);
+	if (lverbose > 1) {
+		usalp->silent++;
+		if (read_cdtext(usalp) < 0)
+			errmsgno(EX_BAD, "No CD-Text or CD-Text unaware drive.\n");
+		usalp->silent++;
+	}
+}
+
+static void 
+print_track(int track, long lba, struct msf *msp, int adr, 
+				int control, int mode)
+{
+	long	lba_512 = lba*4;
+
+	if (track == 0xAA)
+		printf("track:lout ");
+	else
+		printf("track: %3d ", track);
+
+	printf("lba: %9ld (%9ld) %02d:%02d:%02d adr: %X control: %X mode: %d\n",
+			lba, lba_512,
+			msp->msf_min,
+			msp->msf_sec,
+			msp->msf_frame,
+			adr, control, mode);
+}
+
+#ifdef	HAVE_SYS_PRIOCNTL_H	/* The preferred SYSvR4 schduler */
+
+#include <sys/procset.h>	/* Needed for SCO Openserver */
+#include <sys/priocntl.h>
+#include <sys/rtpriocntl.h>
+
+void 
+raisepri(int pri)
+{
+	int		pid;
+	int		classes;
+	int		ret;
+	pcinfo_t	info;
+	pcparms_t	param;
+	rtinfo_t	rtinfo;
+	rtparms_t	rtparam;
+
+	pid = getpid();
+
+	/* get info */
+	strcpy(info.pc_clname, "RT");
+	classes = priocntl(P_PID, pid, PC_GETCID, (void *)&info);
+	if (classes == -1)
+		comerr("Cannot get priority class id priocntl(PC_GETCID)\n");
+
+	movebytes(info.pc_clinfo, &rtinfo, sizeof (rtinfo_t));
+
+	/* set priority to max */
+	rtparam.rt_pri = rtinfo.rt_maxpri - pri;
+	rtparam.rt_tqsecs = 0;
+	rtparam.rt_tqnsecs = RT_TQDEF;
+	param.pc_cid = info.pc_cid;
+	movebytes(&rtparam, param.pc_clparms, sizeof (rtparms_t));
+	ret = priocntl(P_PID, pid, PC_SETPARMS, (void *)&param);
+	if (ret == -1) {
+		errmsg("WARNING: Cannot set priority class parameters priocntl(PC_SETPARMS)\n");
+		errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.\n");
+	}
+}
+
+#else	/* HAVE_SYS_PRIOCNTL_H */
+
+#if defined(_POSIX_PRIORITY_SCHEDULING) && _POSIX_PRIORITY_SCHEDULING -0 >= 0
+/*
+ * The second best choice: POSIX real time scheduling.
+ */
+/*
+ * XXX Ugly but needed because of a typo in /usr/iclude/sched.h on Linux.
+ * XXX This should be removed as soon as we are sure that Linux-2.0.29 is gone.
+ */
+#ifdef	__linux
+#define	_P	__P
+#endif
+
+#include <sched.h>
+
+#ifdef	__linux
+#undef	_P
+#endif
+
+static int 
+rt_raisepri(int pri)
+{
+	struct sched_param scp;
+
+	/*
+	 * Verify that scheduling is available
+	 */
+#ifdef	_SC_PRIORITY_SCHEDULING
+	if (sysconf(_SC_PRIORITY_SCHEDULING) == -1) {
+		errmsg("WARNING: RR-scheduler not available, disabling.\n");
+		return (-1);
+	}
+#endif
+	fillbytes(&scp, sizeof (scp), '\0');
+	scp.sched_priority = sched_get_priority_max(SCHED_RR) - pri;
+	if (sched_setscheduler(0, SCHED_RR, &scp) < 0) {
+		if(lverbose>2)
+       errmsg("WARNING: Cannot set RR-scheduler\n");
+		return (-1);
+	}
+	return (0);
+}
+
+#else	/* _POSIX_PRIORITY_SCHEDULING */
+
+#ifdef	__CYGWIN32__
+/*
+ * Win32 specific priority settings.
+ */
+/*
+ * NOTE: Base.h from Cygwin-B20 has a second typedef for BOOL.
+ *	 We define BOOL to make all static code use BOOL
+ *	 from Windows.h and use the hidden __SBOOL for
+ *	 our global interfaces.
+ *
+ * NOTE: windows.h from Cygwin-1.x includes a structure field named sample,
+ *	 so me may not define our own 'sample' or need to #undef it now.
+ *	 With a few nasty exceptions, Microsoft assumes that any global
+ *	 defines or identifiers will begin with an Uppercase letter, so
+ *	 there may be more of these problems in the future.
+ *
+ * NOTE: windows.h defines interface as an alias for struct, this
+ *	 is used by COM/OLE2, I guess it is class on C++
+ *	 We man need to #undef 'interface'
+ */
+#define	BOOL	WBOOL		/* This is the Win BOOL		*/
+#define	format	__format	/* Avoid format parameter hides global ... */
+#include <windows.h>
+#undef format
+#undef interface
+
+static int 
+rt_raisepri(int pri)
+{
+	int prios[] = {THREAD_PRIORITY_TIME_CRITICAL, THREAD_PRIORITY_HIGHEST};
+
+	/* set priority class */
+	if (SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS) == FALSE) {
+		if(debug || lverbose>2)
+       errmsgno(EX_BAD, "No realtime priority class possible.\n");
+		return (-1);
+	}
+
+	/* set thread priority */
+	if (pri >= 0 && pri <= 1 && SetThreadPriority(GetCurrentThread(), prios[pri]) == FALSE) {
+		errmsgno(EX_BAD, "Could not set realtime priority.\n");
+		return (-1);
+	}
+	return (0);
+}
+
+#else
+/*
+ * This OS does not support real time scheduling.
+ */
+static int 
+rt_raisepri(int pri)
+{
+	return (-1);
+}
+
+#endif	/* __CYGWIN32__ */
+
+#endif	/* _POSIX_PRIORITY_SCHEDULING */
+
+void 
+raisepri(int pri)
+{
+	if (rt_raisepri(pri) >= 0)
+		return;
+#if	defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS)
+
+	if (setpriority(PRIO_PROCESS, getpid(), -20 + pri) < 0) {
+		if(debug || lverbose>2)
+       fprintf(stderr,
+             "WARNING: Cannot set priority using setpriority(),"
+             "increased risk for buffer underruns.\n");
+	}
+#else
+#ifdef	HAVE_DOSSETPRIORITY	/* RT priority on OS/2 */
+	/*
+	 * Set priority to timecritical 31 - pri (arg)
+	 */
+	DosSetPriority(0, 3, 31, 0);
+	DosSetPriority(0, 3, -pri, 0);
+#else
+#if	defined(HAVE_NICE) && !defined(__DJGPP__) /* DOS has nice but no multitasking */
+	if (nice(-20 + pri) == -1) {
+		errmsg("WARNING: Cannot set priority using nice().\n");
+		errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.\n");
+	}
+#else
+	errmsgno(EX_BAD, "WARNING: Cannot set priority on this OS.\n");
+	errmsgno(EX_BAD, "WARNING: This causes a high risk for buffer underruns.\n");
+#endif
+#endif
+#endif
+}
+
+#endif	/* HAVE_SYS_PRIOCNTL_H */
+
+#ifdef	HAVE_SELECT
+/*
+ * sys/types.h and sys/time.h are already included.
+ */
+#else
+#	include	<stropts.h>
+#	include	<poll.h>
+
+#ifndef	INFTIM
+#define	INFTIM	(-1)
+#endif
+#endif
+
+#if	defined(HAVE_SELECT) && defined(NEED_SYS_SELECT_H)
+#include <sys/select.h>
+#endif
+#if	defined(HAVE_SELECT) && defined(NEED_SYS_SOCKET_H)
+#include <sys/socket.h>
+#endif
+
+static void 
+wait_input()
+{
+#ifdef	HAVE_SELECT
+	fd_set	in;
+
+	FD_ZERO(&in);
+	FD_SET(STDIN_FILENO, &in);
+	select(1, &in, NULL, NULL, 0);
+#else
+	struct pollfd pfd;
+
+	pfd.fd = STDIN_FILENO;
+	pfd.events = POLLIN;
+	pfd.revents = 0;
+	poll(&pfd, (unsigned long)1, INFTIM);
+#endif
+}
+
+static void 
+checkgui()
+{
+	struct stat st;
+
+	if (fstat(STDERR_FILENO, &st) >= 0 && !S_ISCHR(st.st_mode)) {
+		isgui = TRUE;
+		if (lverbose > 1)
+			printf("Using remote (pipe) mode for interactive i/o.\n");
+	}
+}
+
+static int 
+getbltype(char *optstr, long *typep)
+{
+	if (streql(optstr, "all")) {
+		*typep = BLANK_DISC;
+	} else if (streql(optstr, "disc")) {
+		*typep = BLANK_DISC;
+	} else if (streql(optstr, "disk")) {
+		*typep = BLANK_DISC;
+	} else if (streql(optstr, "fast")) {
+		*typep = BLANK_MINIMAL;
+	} else if (streql(optstr, "minimal")) {
+		*typep = BLANK_MINIMAL;
+	} else if (streql(optstr, "track")) {
+		*typep = BLANK_TRACK;
+	} else if (streql(optstr, "unreserve")) {
+		*typep = BLANK_UNRESERVE;
+	} else if (streql(optstr, "trtail")) {
+		*typep = BLANK_TAIL;
+	} else if (streql(optstr, "unclose")) {
+		*typep = BLANK_UNCLOSE;
+	} else if (streql(optstr, "session")) {
+		*typep = BLANK_SESSION;
+	} else if (streql(optstr, "help")) {
+		blusage(0);
+	} else {
+		fprintf(stderr, "Illegal blanking type '%s'.\n", optstr);
+		blusage(EX_BAD);
+		return (-1);
+	}
+	return (TRUE);
+}
+
+static int 
+getformattype(char *optstr, long *typep)
+{
+	if (streql(optstr, "full")) {
+		*typep = FULL_FORMAT;
+	} else if (streql(optstr, "background")) {
+		*typep = BACKGROUND_FORMAT;
+	} else if (streql(optstr, "force")) {
+		*typep = FORCE_FORMAT;
+	} else if (streql(optstr, "help")) {
+		formattypeusage(0);
+	} else {
+		fprintf(stderr, "Illegal blanking type '%s'.\n", optstr);
+		formattypeusage(EX_BAD);
+		return (-1);
+	}
+	return (TRUE);
+}
+static void 
+print_drflags(cdr_t *dp)
+{
+	printf("Driver flags   : ");
+
+	if ((dp->cdr_flags & CDR_DVD) != 0)
+		printf("DVD ");
+
+	if ((dp->cdr_flags & CDR_MMC3) != 0)
+		printf("MMC-3 ");
+	else if ((dp->cdr_flags & CDR_MMC2) != 0)
+		printf("MMC-2 ");
+	else if ((dp->cdr_flags & CDR_MMC) != 0)
+		printf("MMC ");
+
+	if ((dp->cdr_flags & CDR_SWABAUDIO) != 0)
+		printf("SWABAUDIO ");
+	if ((dp->cdr_flags & CDR_BURNFREE) != 0)
+		printf("BURNFREE ");
+	if ((dp->cdr_flags & CDR_VARIREC) != 0)
+		printf("VARIREC ");
+	if ((dp->cdr_flags & CDR_GIGAREC) != 0)
+		printf("GIGAREC ");
+	if ((dp->cdr_flags & CDR_AUDIOMASTER) != 0)
+		printf("AUDIOMASTER ");
+	if ((dp->cdr_flags & CDR_FORCESPEED) != 0)
+		printf("FORCESPEED ");
+	if ((dp->cdr_flags & CDR_SPEEDREAD) != 0)
+		printf("SPEEDREAD ");
+	if ((dp->cdr_flags & CDR_DISKTATTOO) != 0)
+		printf("DISKTATTOO ");
+	if ((dp->cdr_flags & CDR_SINGLESESS) != 0)
+		printf("SINGLESESSION ");
+	if ((dp->cdr_flags & CDR_HIDE_CDR) != 0)
+		printf("HIDECDR ");
+	printf("\n");
+}
+
+static void 
+print_wrmodes(cdr_t *dp)
+{
+	BOOL	needblank = FALSE;
+
+	printf("Supported modes: ");
+	if ((dp->cdr_flags & CDR_TAO) != 0) {
+		printf("TAO");
+		needblank = TRUE;
+	}
+	if ((dp->cdr_flags & CDR_PACKET) != 0) {
+		printf("%sPACKET", needblank?" ":"");
+		needblank = TRUE;
+	}
+	if ((dp->cdr_flags & CDR_SAO) != 0) {
+		printf("%sSAO", needblank?" ":"");
+		needblank = TRUE;
+	}
+#ifdef	__needed__
+	if ((dp->cdr_flags & (CDR_SAO|CDR_SRAW16)) == (CDR_SAO|CDR_SRAW16)) {
+		printf("%sSAO/R16", needblank?" ":"");
+		needblank = TRUE;
+	}
+#endif
+	if ((dp->cdr_flags & (CDR_SAO|CDR_SRAW96P)) == (CDR_SAO|CDR_SRAW96P)) {
+		printf("%sSAO/R96P", needblank?" ":"");
+		needblank = TRUE;
+	}
+	if ((dp->cdr_flags & (CDR_SAO|CDR_SRAW96R)) == (CDR_SAO|CDR_SRAW96R)) {
+		printf("%sSAO/R96R", needblank?" ":"");
+		needblank = TRUE;
+	}
+	if ((dp->cdr_flags & (CDR_RAW|CDR_RAW16)) == (CDR_RAW|CDR_RAW16)) {
+		printf("%sRAW/R16", needblank?" ":"");
+		needblank = TRUE;
+	}
+	if ((dp->cdr_flags & (CDR_RAW|CDR_RAW96P)) == (CDR_RAW|CDR_RAW96P)) {
+		printf("%sRAW/R96P", needblank?" ":"");
+		needblank = TRUE;
+	}
+	if ((dp->cdr_flags & (CDR_RAW|CDR_RAW96R)) == (CDR_RAW|CDR_RAW96R)) {
+		printf("%sRAW/R96R", needblank?" ":"");
+		needblank = TRUE;
+	}
+	printf("\n");
+}
+
+static BOOL 
+check_wrmode(cdr_t *dp, int wmode, int tflags)
+{
+	int	cdflags = dp->cdr_flags;
+
+	if ((tflags & TI_PACKET) != 0 && (cdflags & CDR_PACKET) == 0) {
+		errmsgno(EX_BAD, "Drive does not support PACKET recording.\n");
+		return (FALSE);
+	}
+	if ((tflags & TI_TAO) != 0 && (cdflags & CDR_TAO) == 0) {
+		errmsgno(EX_BAD, "Drive does not support TAO recording.\n");
+		return (FALSE);
+	}
+	if ((wmode & F_SAO) != 0) {
+		if ((cdflags & CDR_SAO) == 0) {
+			errmsgno(EX_BAD, "Drive does not support SAO recording.\n");
+			if ((cdflags & CDR_RAW) != 0)
+				errmsgno(EX_BAD, "Try -raw option.\n");
+			return (FALSE);
+		}
+#ifdef	__needed__
+		if ((tflags & TI_RAW16) != 0 && (cdflags & CDR_SRAW16) == 0) {
+			errmsgno(EX_BAD, "Drive does not support SAO/RAW16.\n");
+			goto badsecs;
+		}
+#endif
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == TI_RAW && (cdflags & CDR_SRAW96P) == 0) {
+			errmsgno(EX_BAD, "Drive does not support SAO/RAW96P.\n");
+			goto badsecs;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == (TI_RAW|TI_RAW96R) && (cdflags & CDR_SRAW96R) == 0) {
+			errmsgno(EX_BAD, "Drive does not support SAO/RAW96R.\n");
+			goto badsecs;
+		}
+	}
+	if ((wmode & F_RAW) != 0) {
+		if ((cdflags & CDR_RAW) == 0) {
+			errmsgno(EX_BAD, "Drive does not support RAW recording.\n");
+			return (FALSE);
+		}
+		if ((tflags & TI_RAW16) != 0 && (cdflags & CDR_RAW16) == 0) {
+			errmsgno(EX_BAD, "Drive does not support RAW/RAW16.\n");
+			goto badsecs;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == TI_RAW && (cdflags & CDR_RAW96P) == 0) {
+			errmsgno(EX_BAD, "Drive does not support RAW/RAW96P.\n");
+			goto badsecs;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == (TI_RAW|TI_RAW96R) && (cdflags & CDR_RAW96R) == 0) {
+			errmsgno(EX_BAD, "Drive does not support RAW/RAW96R.\n");
+			goto badsecs;
+		}
+	}
+	return (TRUE);
+
+badsecs:
+	if ((wmode & F_SAO) != 0)
+		cdflags &= ~(CDR_RAW16|CDR_RAW96P|CDR_RAW96R);
+	if ((wmode & F_RAW) != 0)
+		cdflags &= ~(CDR_SRAW96P|CDR_SRAW96R);
+
+	if ((cdflags & (CDR_SRAW96R|CDR_RAW96R)) != 0)
+		errmsgno(EX_BAD, "Try -raw96r option.\n");
+	else if ((cdflags & (CDR_SRAW96P|CDR_RAW96P)) != 0)
+		errmsgno(EX_BAD, "Try -raw96p option.\n");
+	else if ((cdflags & CDR_RAW16) != 0)
+		errmsgno(EX_BAD, "Try -raw16 option.\n");
+	return (FALSE);
+}
+
+static void 
+set_wrmode(cdr_t *dp, int wmode, int tflags)
+{
+	dstat_t	*dsp = dp->cdr_dstat;
+
+	if ((tflags & TI_PACKET) != 0) {
+		dsp->ds_wrmode = WM_PACKET;
+		return;
+	}
+	if ((tflags & TI_TAO) != 0) {
+		dsp->ds_wrmode = WM_TAO;
+		return;
+	}
+	if ((wmode & F_SAO) != 0) {
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == 0) {
+			dsp->ds_wrmode = WM_SAO;
+			return;
+		}
+		if ((tflags & TI_RAW16) != 0) {		/* Is this needed? */
+			dsp->ds_wrmode = WM_SAO_RAW16;
+			return;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == TI_RAW) {
+			dsp->ds_wrmode = WM_SAO_RAW96P;
+			return;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == (TI_RAW|TI_RAW96R)) {
+			dsp->ds_wrmode = WM_SAO_RAW96R;
+			return;
+		}
+	}
+	if ((wmode & F_RAW) != 0) {
+		if ((tflags & TI_RAW16) != 0) {
+			dsp->ds_wrmode = WM_RAW_RAW16;
+			return;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == TI_RAW) {
+			dsp->ds_wrmode = WM_RAW_RAW96P;
+			return;
+		}
+		if ((tflags & (TI_RAW|TI_RAW16|TI_RAW96R)) == (TI_RAW|TI_RAW96R)) {
+			dsp->ds_wrmode = WM_RAW_RAW96R;
+			return;
+		}
+	}
+	dsp->ds_wrmode = WM_NONE;
+}
+
+#if	defined(linux) || defined(__linux) || defined(__linux__)
+#ifdef	HAVE_UNAME
+#include <sys/utsname.h>
+#endif
+#endif
+
+#ifdef __linux__
+static int 
+get_cap(cap_value_t cap_array)
+{ 
+    	  int ret;
+	  cap_t capa;
+	  capa = cap_get_proc();
+	  cap_set_flag(capa, CAP_EFFECTIVE,  1, &cap_array, CAP_SET);
+	  ret = cap_set_proc(capa);
+	  cap_free(capa);
+	  return ret; 
+}
+#endif
diff --git a/wodim/wodim.dfl b/wodim/wodim.dfl
new file mode 100644
index 0000000..41c4201
--- /dev/null
+++ b/wodim/wodim.dfl
@@ -0,0 +1,48 @@
+# wodim.dfl Copyright 2006 E. Bloch
+# Based on cdrecord.dfl (Copyright 1998 J. Schilling)
+#
+# This file is /etc/wodim.conf
+# It contains defaults that are used if no command line option
+# or environment is present.
+# 
+# The default device, if not specified elsewhere.
+#
+#CDR_DEVICE=yamaha
+CDR_DEVICE=cdrom
+
+# 
+# The default speed, if not specified elswhere.
+#
+# For MMC compliant drives, the default is to write at maximum speed, so it in
+# general does not make sense to set up a default speed in /etc/wodim.conf.
+#
+#CDR_SPEED=40
+
+# 
+# The default FIFO size if, not specified elswhere.
+#
+CDR_FIFOSIZE=12m
+
+#
+# CDR_MAXFIFOSIZE can limit the maximum allowed FIFO size. This is useful to
+# not let mallicious users allocate too much system memory if no ulimit is set
+# or wodim runs with suid-root permissions.
+#
+# CDR_MAXFIFOSIZE=256m
+
+#
+# The following definitions allow abstract device names.  They are used if the
+# device name does not contain the the characters ',', ':', '/' and '@'
+#
+# Unless you have a good reason, use speed == -1 and let wodim use its internal
+# drive specific defaults.
+#
+# drive name	device	speed	fifosize driveropts
+#
+#default=	USCSI:1,0,0	-1	-1	burnfree
+#sanyo=		1,4,0	-1	-1	burnfree
+#cdrom=		0,6,0	2	1m	""
+#remote=		REMOTE:rscsi@somehost:1,0,0	16	32m	burnfree
+#
+cdrom=          -1      -1      -1      burnfree
+
diff --git a/wodim/wodim.h b/wodim/wodim.h
new file mode 100644
index 0000000..0dfdfdc
--- /dev/null
+++ b/wodim/wodim.h
@@ -0,0 +1,1212 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)cdrecord.h	1.165 05/06/11 Copyright 1995-2005 J. Schilling */
+/*
+ *	Definitions for cdrecord
+ *
+ *	Copyright (c) 1995-2005 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.
+ */
+
+/*
+ * Make sure it is there. We need it for off_t.
+ */
+#ifndef	_INCL_SYS_TYPES_H
+#include <sys/types.h>
+#define	_INCL_SYS_TYPES_H
+#endif
+
+#ifndef	_UTYPES_H
+#include <utypes.h>
+#endif
+
+/*
+ * Defines for command line option flags
+ */
+#define	F_DUMMY		0x00000001L	/* Do dummy (simulation) writes */
+#define	F_TOC		0x00000002L	/* Get TOC */
+#define	F_EJECT		0x00000004L	/* Eject disk after doing the work */
+#define	F_LOAD		0x00000008L	/* Load disk only */
+#define	F_MULTI		0x00000010L	/* Create linkable TOC/multi-session */
+#define	F_MSINFO	0x00000020L	/* Get multi-session info */
+#define	F_FIX		0x00000040L	/* Fixate disk only */
+#define	F_NOFIX		0x00000080L	/* Do not fixate disk */
+#define	F_VERSION	0x00000100L	/* Print version info */
+#define	F_CHECKDRIVE	0x00000200L	/* Check for driver */
+#define	F_INQUIRY	0x00000400L	/* Do inquiry */
+#define	F_PRCAP		0x00000800L	/* Print capabilities */
+#define	F_SCANBUS	0x00001000L	/* Scan SCSI Bus */
+#define	F_RESET		0x00002000L	/* Reset SCSI Bus */
+#define	F_BLANK		0x00004000L	/* Blank CD-RW */
+#define	F_PRATIP	0x00008000L	/* Print ATIP info */
+#define	F_PRDINFO	0x00010000L	/* Print disk info (XXX not yet used)  */
+#define	F_IGNSIZE	0x00020000L	/* Ignore disk size */
+#define	F_SAO		0x00040000L	/* Session at once */
+#define	F_RAW		0x00080000L	/* Raw mode */
+#define	F_WRITE		0x00100000L	/* Disk is going to be written */
+#define	F_FORCE		0x00200000L	/* Force things (e.g. blank on dead disk)  */
+#define	F_WAITI		0x00400000L	/* Wait until data is available on stdin */
+#define	F_OVERBURN	0x00800000L	/* Allow oveburning */
+#define	F_CLONE		0x01000000L	/* Do clone writing */
+#define	F_STDIN		0x02000000L	/* We are using stdin as CD data */
+#define	F_IMMED		0x04000000L	/* Try tu use IMMED SCSI flag if possible */
+#define	F_DLCK		0x08000000L	/* Load disk and lock door */
+#define	F_SETDROPTS	0x10000000L	/* Set driver opts and exit */
+#define	F_FORMAT	0x20000000L	/* Format media */
+#define	F_ABORT		0x40000000L	/* Send abort sequence to drive */
+
+#ifdef	min
+#undef	min
+#endif
+#define	min(a, b)	((a) < (b) ? (a):(b))
+
+#ifdef	max
+#undef	max
+#endif
+#define	max(a, b)	((a) < (b) ? (b):(a))
+
+#undef	roundup
+#define	roundup(x, y)	((((x)+((y)-1))/(y))*(y))
+
+/*
+ * NOTICE:	You should not make CDR_BUF_SIZE more than
+ *		the buffer size of the CD-Recorder.
+ *
+ * The Philips CDD 521 is the recorder with the smallest buffer.
+ * It only has 256kB of buffer RAM.
+ *
+ * WARNING:	Philips CDD 521 dies if CDR_BUF_SIZE is to big.
+ *		If you like to support the CDD 521 keep the buffer
+ *		at 63kB.
+ */
+/*#define	CDR_BUF_SIZE	(126*1024)*/
+#define	CDR_BUF_SIZE		(63*1024)
+#define	CDR_MAX_BUF_SIZE	(256*1024)
+
+/*
+ * Never set MIN_GRACE_TIME < 3 seconds. We need to give
+ * the volume management a chance to settle before we
+ * start writing.
+ */
+#ifndef	MIN_GRACE_TIME
+#define	MIN_GRACE_TIME	0		/* changed to 0, there is no point in forcing it in this application. Fix your volume management if it breaks because it could not read the medium. */
+#endif
+#ifndef	GRACE_TIME
+#define	GRACE_TIME	4
+#endif
+
+/*
+ * Some sector sizes used for reading/writing ...
+ */
+#define	DATA_SEC_SIZE	2048		/* 2048 bytes */
+#define	MODE2_SEC_SIZE	2336		/* 2336 bytes */
+#define	AUDIO_SEC_SIZE	2352		/* 2352 bytes */
+#define	RAW16_SEC_SIZE	(2352+16)	/* 2368 bytes */
+#define	RAW96_SEC_SIZE	(2352+96)	/* 2448 bytes */
+
+#define	MAX_TRACK	99	/* Red Book track limit */
+
+#define	PAD_SECS	15	/* NOTE: pad must be less than BUF_SIZE */
+#define	PAD_SIZE	(PAD_SECS * DATA_SEC_SIZE)
+
+/*
+ * FIFO size must be at least 2x CDR_MAX_BUF_SIZE
+ */
+#define	DEFAULT_FIFOSIZE (4L*1024L*1024L)
+
+#if	!defined(HAVE_LARGEFILES) && SIZEOF_LLONG > SIZEOF_LONG
+typedef	Llong	tsize_t;
+#else
+typedef	off_t	tsize_t;
+#endif
+
+#ifdef	nono
+typedef struct tindex {
+	int	dummy;		/* Not yet implemented */
+} tindex_t;
+#endif
+
+typedef struct ofile {
+	struct ofile *next;	/* Next open file			*/
+	int	f;		/* Open file				*/
+	char	*filename;	/* File name				*/
+	int	refcnt;		/* open reference count			*/
+} ofile_t;
+
+typedef struct track {
+	void	*xfp;		/* Open file for this track from xopen()*/
+	char	*filename;	/* File name for this track		*/
+
+	tsize_t	itracksize;	/* Size of track bytes (-1 == until EOF)*/
+				/* This is in units of isecsize		*/
+	tsize_t	tracksize;	/* Size of track bytes (-1 == until EOF)*/
+				/* This is in units of secsize		*/
+
+	long	trackstart;	/* Start sector # of this track		*/
+	long	tracksecs;	/* Size of this track (sectors)		*/
+	long	padsecs;	/* Pad size for this track (sectors)	*/
+	long	pregapsize;	/* Pre-gap size for this track (sectors)*/
+	long	index0start;	/* Index 0 start within this tr(sectors)*/
+	int	isecsize;	/* Read input sector size for this track*/
+	int	secsize;	/* Sector size for this track (bytes)	*/
+	int	secspt;		/* # of sectors to copy for one transfer*/
+	int	pktsize;	/* # of blocks per write packet		*/
+	Uchar	dataoff;	/* offset of user data in raw sector	*/
+	Uchar	tracks;		/* Number of tracks on this disk	*/
+	Uchar	track;		/* Track # as offset in track[] array	*/
+	Uchar	trackno;	/* Track # on disk for this track	*/
+	Uchar	tracktype;	/* Track type (toc type)		*/
+	Uchar	dbtype;		/* Data block type for this track	*/
+	int	sectype;	/* Sector type				*/
+	int	flags;		/* Flags (see below)			*/
+	int	nindex;		/* Number of indices for track		*/
+	long	*tindex;	/* Track index descriptor		*/
+	char	*isrc;		/* ISRC code for this track / disk MCN	*/
+	void	*text;		/* Opaque CD-Text data (txtptr_t *)	*/
+} track_t;
+
+#define	track_base(tp)	((tp) - (tp)->track)
+
+/*
+ * Defines for tp->flags
+ */
+#define	TI_AUDIO	0x00001	/* File is an audio track		*/
+#define	TI_PREEMP	0x00002	/* Audio track recorded w/preemphasis	*/
+#define	TI_MIX		0x00004	/* This is a mixed mode track		*/
+#define	TI_RAW		0x00008	/* Write this track in raw mode		*/
+#define	TI_PAD		0x00010	/* Pad data track			*/
+#define	TI_SWAB		0x00020	/* Swab audio data			*/
+#define	TI_ISOSIZE	0x00040	/* Use iso size for track		*/
+#define	TI_NOAUHDR	0x00080	/* Don't look for audio header		*/
+#define	TI_FIRST	0x00100	/* This is the first track		*/
+#define	TI_LAST		0x00200	/* This is the last track		*/
+#define	TI_PACKET	0x00400	/* Fixed- or variable-packet track	*/
+#define	TI_NOCLOSE	0x00800	/* Don't close the track after writing	*/
+#define	TI_TAO		0x01000	/* This track is written in TAO mode	*/
+#define	TI_PREGAP	0x02000	/* Prev. track incl. pregap of this tr. */
+#define	TI_SCMS		0x04000	/* Force to follow the SCMS rules	*/
+#define	TI_COPY		0x08000	/* Allow digital copy			*/
+#define	TI_SHORT_TRACK	0x10000	/* Ignore min 4 second Red Book	std.	*/
+#define	TI_RAW16	0x20000	/* This track uses 16 bytes subch.	*/
+#define	TI_RAW96R	0x40000	/* This track uses 96 bytes RAW subch.	*/
+#define	TI_CLONE	0x80000	/* Special clone treatment needed	*/
+#define	TI_TEXT		0x100000 /* This track holds CD-Text information */
+#define	TI_DVD		0x200000 /* We are writing a DVD track		*/
+#define	TI_SAO		0x400000 /* This track is written in SAO mode	*/
+#define	TI_USEINFO	0x800000 /* Use information from *.inf files	*/
+#define	TI_QUADRO	0x1000000 /* Four Channel Audio Data		*/
+
+
+#define	is_audio(tp)	(((tp)->flags & TI_AUDIO) != 0)
+#define	is_preemp(tp)	(((tp)->flags & TI_PREEMP) != 0)
+#define	is_pad(tp)	(((tp)->flags & TI_PAD) != 0)
+#define	is_swab(tp)	(((tp)->flags & TI_SWAB) != 0)
+#define	is_first(tp)	(((tp)->flags & TI_FIRST) != 0)
+#define	is_last(tp)	(((tp)->flags & TI_LAST) != 0)
+#define	is_packet(tp)	(((tp)->flags & TI_PACKET) != 0)
+#define	is_noclose(tp)	(((tp)->flags & TI_NOCLOSE) != 0)
+#define	is_tao(tp)	(((tp)->flags & TI_TAO) != 0)
+#define	is_sao(tp)	(((tp)->flags & TI_SAO) != 0)
+#define	is_raw(tp)	(((tp)->flags & TI_RAW) != 0)
+#define	is_raw16(tp)	(((tp)->flags & TI_RAW16) != 0)
+#define	is_raw96(tp)	(((tp)->flags & (TI_RAW|TI_RAW16)) == TI_RAW)
+#define	is_raw96p(tp)	(((tp)->flags & (TI_RAW|TI_RAW16|TI_RAW96R)) == TI_RAW)
+#define	is_raw96r(tp)	(((tp)->flags & (TI_RAW|TI_RAW16|TI_RAW96R)) == (TI_RAW|TI_RAW96R))
+#define	is_pregap(tp)	(((tp)->flags & TI_PREGAP) != 0)
+#define	is_scms(tp)	(((tp)->flags & TI_SCMS) != 0)
+#define	is_copy(tp)	(((tp)->flags & TI_COPY) != 0)
+#define	is_shorttrk(tp)	(((tp)->flags & TI_SHORT_TRACK) != 0)
+#define	is_clone(tp)	(((tp)->flags & TI_CLONE) != 0)
+#define	is_text(tp)	(((tp)->flags & TI_TEXT) != 0)
+#define	is_quadro(tp)	(((tp)->flags & TI_QUADRO) != 0)
+
+/*
+ * Defines for toc type / track type
+ */
+#define	TOC_DA		0	/* CD-DA				*/
+#define	TOC_ROM		1	/* CD-ROM				*/
+#define	TOC_XA1		2	/* CD_ROM XA with first track in mode 1 */
+#define	TOC_XA2		3	/* CD_ROM XA with first track in mode 2 */
+#define	TOC_CDI		4	/* CDI					*/
+
+#define	TOC_MASK	7	/* Mask needed for toctname[]		*/
+
+/*
+ * Additional flags in toc type / trackp->tracktype
+ * XXX TOCF_DUMMY istr schon in dp->cdr_cmdflags & F_DUMMY
+ * XXX TOCF_MULTI istr schon in dp->cdr_cmdflags & F_MULTI
+ */
+#define	TOCF_DUMMY	0x10	/* Write in dummy (simulation) mode	*/
+#define	TOCF_MULTI	0x20	/* Multisession (Open Next Programarea) */
+
+#define	TOCF_MASK	0xF0	/* All possible flags in tracktype	*/
+
+extern	char	*toc2name[];	/* Convert toc type to name		*/
+extern	int	toc2sess[];	/* Convert toc type to session format	*/
+
+/*
+ * Defines for sector type
+ *
+ * Mode is 2 bits
+ * Aud  is 1 bit
+ *
+ * Sector is: aud << 2 | mode
+ */
+#define	ST_ROM_MODE1	1	/* CD-ROM in mode 1 (vanilla cdrom)	*/
+#define	ST_ROM_MODE2	2	/* CD-ROM in mode 2			*/
+#define	ST_AUDIO_NOPRE	4	/* CD-DA stereo without preemphasis	*/
+#define	ST_AUDIO_PRE	5	/* CD-DA stereo with preemphasis	*/
+
+#define	ST_PREEMPMASK	0x01	/* Mask for preemphasis bit		*/
+#define	ST_AUDIOMASK	0x04	/* Mask for audio bit			*/
+#define	ST_MODEMASK	0x03	/* Mask for mode bits in sector type	*/
+#define	ST_MASK		0x07	/* Mask needed for sectname[]		*/
+
+/*
+ * There are 6 different generic basic sector types.
+ */
+#define	ST_MODE_AUDIO	 0x00	/* Generic Audio mode			*/
+#define	ST_MODE_0	 0x10	/* Generic Zero mode			*/
+#define	ST_MODE_1	 0x20	/* Generic CD-ROM mode	(ISO/IEC 10149)	*/
+#define	ST_MODE_2	 0x30	/* Generic Mode 2	(ISO/IEC 10149)	*/
+#define	ST_MODE_2_FORM_1 0x40	/* Generic Mode 2 form 1		*/
+#define	ST_MODE_2_FORM_2 0x50	/* Generic Mode 2 form 2		*/
+#define	ST_MODE_2_MIXED	 0x60	/* Generic Mode 2 mixed form (1/2)	*/
+
+#define	ST_MODE_MASK	 0x70	/* Mask needed to get generic sectype	*/
+
+#define	ST_MODE_RAW	 0x08	/* Do not touch EDC & subchannels	*/
+#define	ST_NOSCRAMBLE	 0x80	/* Do not srcamble sectors 		*/
+
+#define	SECT_AUDIO	(ST_AUDIO_NOPRE  | ST_MODE_AUDIO)
+#define	SECT_AUDIO_NOPRE (ST_AUDIO_NOPRE | ST_MODE_AUDIO)
+#define	SECT_AUDIO_PRE	(ST_AUDIO_PRE    | ST_MODE_AUDIO)
+#define	SECT_MODE_0	(ST_ROM_MODE1    | ST_MODE_0)
+#define	SECT_ROM	(ST_ROM_MODE1    | ST_MODE_1)
+#define	SECT_MODE_2	(ST_ROM_MODE2    | ST_MODE_2)
+#define	SECT_MODE_2_F1	(ST_ROM_MODE2    | ST_MODE_2_FORM_1)
+#define	SECT_MODE_2_F2	(ST_ROM_MODE2    | ST_MODE_2_FORM_2)
+#define	SECT_MODE_2_MIX	(ST_ROM_MODE2    | ST_MODE_2_MIXED)
+
+extern	char	*st2name[];	/* Convert sector type to name		*/
+extern	int	st2mode[];	/* Convert sector type to control nibble*/
+
+/*
+ * Control nibble bits:
+ *
+ * 0	with preemphasis (audio) / incremental (data)
+ * 1	digital copy permitted
+ * 2	data (not audio) track
+ * 3	4 channels (not 2)
+ */
+#define	TM_PREEM	0x1	/* Audio track with preemphasis	*/
+#define	TM_INCREMENTAL	0x1	/* Incremental data track	*/
+#define	TM_ALLOW_COPY	0x2	/* Digital copy permitted	*/
+#define	TM_DATA		0x4	/* This is a data track		*/
+#define	TM_QUADRO	0x8	/* Four channel audio		*/
+
+/*
+ * Adr nibble:
+ */
+#define	ADR_NONE	0	/* Sub-Q mode info not supplied		*/
+#define	ADR_POS		1	/* Sub-Q encodes position data		*/
+#define	ADR_MCN		2	/* Sub-Q encodes Media Catalog Number	*/
+#define	ADR_ISRC	3	/* Sub-Q encodes ISRC			*/
+
+/*
+ * Defines for write type (from SCSI-3/mmc)
+ */
+#define	WT_PACKET	0x0	/* Packet writing	*/
+#define	WT_TAO		0x1	/* Track at once	*/
+#define	WT_SAO		0x2	/* Session at once	*/
+#define	WT_RAW		0x3	/* Raw			*/
+#define	WT_RES_4	0x4	/* Reserved		*/
+#define	WT_RES_5	0x5	/* Reserved		*/
+#define	WT_RES_6	0x6	/* Reserved		*/
+#define	WT_RES_7	0x7	/* Reserved		*/
+#define	WT_RES_8	0x8	/* Reserved		*/
+#define	WT_RES_9	0x9	/* Reserved		*/
+#define	WT_RES_A	0xA	/* Reserved		*/
+#define	WT_RES_B	0xB	/* Reserved		*/
+#define	WT_RES_C	0xC	/* Reserved		*/
+#define	WT_RES_D	0xD	/* Reserved		*/
+#define	WT_RES_E	0xE	/* Reserved		*/
+#define	WT_RES_F	0xF	/* Reserved		*/
+
+/*
+ * Data block layout:
+ *
+ *	-	Sync pattern 12 Bytes:	0x00 0xFF 0xFF ... 0xFF 0xFF 0x00
+ *	-	Block header 4  Bytes:	| minute | second | frame | mode |
+ *		Mode byte:
+ *			Bits 7, 6, 5	Run-in/Run-out/Link
+ *			Bits 4, 3, 2	Reserved
+ *			Bits 1, 0	Mode
+ *	-	Rest of sector see below.
+ *
+ * Mode 0 Format:
+ *	0	12   Bytes Sync header
+ *	12	4    Bytes Block header with Data mode == 0
+ *	16	2336 Bytes of zero data
+ *
+ * Mode 1 Format:
+ *	0	12   Bytes Sync header
+ *	12	4    Bytes Block header with Data mode == 1
+ *	16	2048 Bytes of user data
+ *	2064	4    Bytes CRC for Bytes 0-2063
+ *	2068	8    Bytes Zero fill
+ *	2076	172  Bytes P parity symbols
+ *	2248	104  Bytes Q parity symbols
+ *
+ * Mode 2 Format (formless):
+ *	0	12   Bytes Sync header
+ *	12	4    Bytes Block header with Data mode == 2
+ *	16	2336 Bytes of user data
+ *
+ * Mode 2 form 1 Format:
+ *	0	12   Bytes Sync header
+ *	12	4    Bytes Block header with Data mode == 2
+ *	16	4    Bytes subheader first copy
+ *	20	4    Bytes subheader second copy
+ *	24	2048 Bytes of user data
+ *	2072	4    Bytes CRC for Bytes 16-2071
+ *	2076	172  Bytes P parity symbols
+ *	2248	104  Bytes Q parity symbols
+ *
+ * Mode 2 form 2 Format:
+ *	0	12   Bytes Sync header
+ *	12	4    Bytes Block header with Data mode == 2
+ *	16	4    Bytes subheader first copy
+ *	20	4    Bytes subheader second copy
+ *	24	2324 Bytes of user data
+ *	2348	4    Bytes Optional CRC for Bytes 16-2347
+ */
+
+/*
+ * Mode Byte definitions (the 4th Byte in the Block header)
+ */
+#define	SH_MODE_DATA	0x00	/* User Data Block	*/
+#define	SH_MODE_RI4	0x20	/* Fourth run in Block	*/
+#define	SH_MODE_RI3	0x40	/* Third run in Block	*/
+#define	SH_MODE_RI2	0x60	/* Second run in Block	*/
+#define	SH_MODE_RI1	0x80	/* First run in Block	*/
+#define	SH_MODE_LINK	0xA0	/* Link Block		*/
+#define	SH_MODE_RO2	0xC0	/* Second run out Block	*/
+#define	SH_MODE_RO1	0xE0	/* First run out Block	*/
+#define	SH_MODE_M0	0x00	/* Mode 0 Data		*/
+#define	SH_MODE_M1	0x01	/* Mode 1 Data		*/
+#define	SH_MODE_M2	0x02	/* Mode 2 Data		*/
+#define	SH_MODE_MR	0x03	/* Reserved		*/
+
+/*
+ * Defines for data block type (from SCSI-3/mmc)
+ *
+ * Mandatory are only:
+ *	DB_ROM_MODE1	(8)	Mode 1     (ISO/IEC 10149)
+ *	DB_XA_MODE2	(10)	Mode 2-F1  (CD-ROM XA form 1)
+ *	DB_XA_MODE2_MIX	(13)	Mode 2-MIX (CD-ROM XA 1/2+subhdr)
+ */
+#define	DB_RAW		0	/* 2352 bytes of raw data		  */
+#define	DB_RAW_PQ	1	/* 2368 bytes (raw data + P/Q Subchannel) */
+#define	DB_RAW_PW	2	/* 2448 bytes (raw data + P-W Subchannel) */
+#define	DB_RAW_PW_R	3	/* 2448 bytes (raw data + P-W raw Subchannel)*/
+#define	DB_RES_4	4	/* -	Reserved			  */
+#define	DB_RES_5	5	/* -	Reserved			  */
+#define	DB_RES_6	6	/* -	Reserved			  */
+#define	DB_VU_7		7	/* -	Vendor specific			  */
+#define	DB_ROM_MODE1	8	/* 2048 bytes Mode 1 (ISO/IEC 10149)	  */
+#define	DB_ROM_MODE2	9	/* 2336 bytes Mode 2 (ISO/IEC 10149)	  */
+#define	DB_XA_MODE2	10	/* 2048 bytes Mode 2 (CD-ROM XA form 1)   */
+#define	DB_XA_MODE2_F1	11	/* 2056 bytes Mode 2 (CD-ROM XA form 1)	  */
+#define	DB_XA_MODE2_F2	12	/* 2324 bytes Mode 2 (CD-ROM XA form 2)	  */
+#define	DB_XA_MODE2_MIX	13	/* 2332 bytes Mode 2 (CD-ROM XA 1/2+subhdr) */
+#define	DB_RES_14	14	/* -	Reserved			  */
+#define	DB_VU_15	15	/* -	Vendor specific			  */
+
+extern	char	*db2name[];	/* Convert data block type to name	  */
+
+/*
+ * Defines for multi session type (from SCSI-3/mmc)
+ */
+#define	MS_NONE		0	/* No B0 pointer. Next session not allowed*/
+#define	MS_FINAL	1	/* B0 = FF:FF:FF. Next session not allowed*/
+#define	MS_RES		2	/* Reserved				  */
+#define	MS_MULTI	3	/* B0 = Next PA.  Next session allowed	  */
+
+/*
+ * Defines for session format (from SCSI-3/mmc)
+ */
+#define	SES_DA_ROM	0x00	/* CD-DA or CD-ROM disk			  */
+#define	SES_CDI		0x10	/* CD-I disk				  */
+#define	SES_XA		0x20	/* CD-ROM XA disk			  */
+#define	SES_UNDEF	0xFF	/* Undefined disk type (read disk info)	  */
+
+/*
+ * Defines for blanking of CD-RW discs (from SCSI-3/mmc)
+ */
+#define	BLANK_DISC	0x00	/* Erase the entire disc		  */
+#define	BLANK_MINIMAL	0x01	/* Erase the PMA, 1st session TOC, pregap */
+#define	BLANK_TRACK	0x02	/* Erase an incomplete track		  */
+#define	BLANK_UNRESERVE	0x03	/* Unreserve a track			  */
+#define	BLANK_TAIL	0x04	/* Erase the tail of a track		  */
+#define	BLANK_UNCLOSE	0x05	/* Unclose the last session		  */
+#define	BLANK_SESSION	0x06	/* Erase the last session		  */
+
+/*
+ * Defines for formating DVD (custom values)
+ */
+#define	FULL_FORMAT       0x00    /* Interactive format  */
+#define	BACKGROUND_FORMAT 0x01    /* Background format   */
+#define	FORCE_FORMAT      0x02    /* Force reformat      */
+
+/*
+ * Defines for formating DVD (custom values)
+ */
+#define	FULL_FORMAT       0x00    /* Interactive format  */
+#define	BACKGROUND_FORMAT 0x01    /* Background format   */
+#define	FORCE_FORMAT      0x02    /* Force reformat      */
+
+/*
+ * Useful definitions for audio tracks
+ */
+#define	msample		(44100 * 2)		/* one 16bit audio sample */
+#define	ssample		(msample * 2)		/* one stereo sample	*/
+#define	samples(v)	((v) / ssample)		/* # of stereo samples	*/
+#define	hsamples(v)	((v) / (ssample/100))	/* 100* # of stereo samples/s*/
+#define	fsamples(v)	((v) / (ssample/75))	/* 75* # of stereo samples/s */
+
+#define	minutes(v)	((int)(samples(v) / 60))
+#define	seconds(v)	((int)(samples(v) % 60))
+#define	hseconds(v)	((int)(hsamples(v) % 100))
+#define	frames(v)	((int)(fsamples(v) % 75))
+
+/*
+ * sector based macros
+ */
+#define	Sminutes(s)	((int)((s) / (60*75)))
+#define	Sseconds(s)	((int)((s) / 75))
+#define	Shseconds(s)	((int)(((s) % 75)*100)/75)
+#define	Sframes(s)	((int)((s) % 75))
+
+typedef struct msf {
+	char	msf_min;
+	char	msf_sec;
+	char	msf_frame;
+} msf_t;
+
+/*
+ * Definitions for read TOC/PMA/ATIP command
+ */
+#define	FMT_TOC		0
+#define	FMT_SINFO	1
+#define	FMT_FULLTOC	2
+#define	FMT_PMA		3
+#define	FMT_ATIP	4
+#define	FMT_CDTEXT	5
+
+/*
+ * Definitions for read disk information "recording flags"
+ * used in UInt16_t "ds_cdrflags".
+ */
+#define	RF_WRITE	0x0001	/* Disk is going to be written		*/
+#define	RF_BLANK	0x0002	/* Disk is going to be erased		*/
+#define	RF_PRATIP	0x0004	/* Print ATIP info			*/
+#define	RF_LEADIN	0x0008	/* Lead-in has been "manually" written	*/
+#define	RF_BURNFREE	0x0010	/* BUFFER underrun free recording	*/
+#define	RF_VARIREC	0x0020	/* Plextor VariRec			*/
+#define	RF_AUDIOMASTER	0x0040	/* Yamaha AudioMaster			*/
+#define	RF_FORCESPEED	0x0080	/* WriteSpeed forced high		*/
+#define	RF_DID_STAT	0x0100	/* Already did call cdrstats()		*/
+#define	RF_DID_CDRSTAT	0x0200	/* Already did call (*dp->cdr_stats)()	*/
+#define	RF_WR_WAIT	0x0400	/* Wait during writing to free bus	*/
+#define	RF_SINGLESESS	0x0800	/* Plextor single sess. mode		*/
+#define	RF_HIDE_CDR	0x1000	/* Plextor hide CDR features		*/
+#define	RF_SPEEDREAD	0x2000	/* Plextor SpeedReed			*/
+#define	RF_GIGAREC	0x4000	/* Plextor GigaRec			*/
+
+/*
+ * Definitions for read disk information "disk status"
+ * used in "ds_diskstat".
+ */
+#define	DS_EMPTY	0	/* Empty disk				*/
+#define	DS_APPENDABLE	1	/* Incomplete disk (appendable)		*/
+#define	DS_COMPLETE	2	/* Complete disk (closed/no B0 pointer)	*/
+#define	DS_RESERVED	3	/* Reserved				*/
+
+/*
+ * Definitions for read disk information "session status"
+ * used in "ds_sessstat".
+ */
+#define	SS_EMPTY	0	/* Empty session			*/
+#define	SS_APPENDABLE	1	/* Incomplete session			*/
+#define	SS_RESERVED	2	/* Reserved				*/
+#define	SS_COMPLETE	3	/* Complete session (needs DS_COMPLETE)	*/
+
+/*
+ * Definitions for disk_status write mode
+ * used in "ds_wrmode".
+ */
+#define	WM_NONE		0	/* No write mode selected		*/
+#define	WM_BLANK	1	/* Blanking mode			*/
+#define	WM_FORMAT	2	/* Formatting				*/
+#define	WM_PACKET	4	/* Packet writing			*/
+#define	WM_TAO		8	/* Track at Once			*/
+#define	WM_SAO		12	/* Session at Once w/ cooked sectors	*/
+#define	WM_SAO_RAW16	13	/* Session at Once RAW+16 byte sectors	*/
+#define	WM_SAO_RAW96P	14	/* Session at Once RAW+96P byte sectors	*/
+#define	WM_SAO_RAW96R	15	/* Session at Once RAW+96R byte sectors	*/
+#define	WM_RAW		16	/* RAW with cooked sectors is impossible*/
+#define	WM_RAW_RAW16	17	/* RAW with RAW+16 byte sectors		*/
+#define	WM_RAW_RAW96P	18	/* RAW with RAW+96P byte sectors	*/
+#define	WM_RAW_RAW96R	19	/* RAW with RAW+96R byte sectors	*/
+
+#define	wm_base(wm)	((wm)/4*4) /* The basic write mode for this mode */
+
+/*
+ * Definitions for disk_status flags
+ * used in UInt16_t "ds_flags".
+ */
+#define	DSF_DID_V	0x0001	/* Disk id valid			*/
+#define	DSF_DBC_V	0x0002	/* Disk bar code valid			*/
+#define	DSF_URU		0x0004	/* Disk is for unrestricted use		*/
+#define	DSF_ERA		0x0008	/* Disk is erasable			*/
+#define	DSF_HIGHSP_ERA	0x0010	/* Disk is high speed erasable		*/
+#define	DSF_ULTRASP_ERA	0x0020	/* Disk is ultra speed erasable		*/
+#define	DSF_ULTRASPP_ERA 0x0040	/* Disk is ultra speed+ erasable	*/
+
+
+#define	DSF_DVD		0x0100	/* Disk is a DVD			*/
+#define	DSF_DVD_PLUS_R	0x0200	/* Disk is a DVD+R			*/
+#define	DSF_DVD_PLUS_RW	0x0400	/* Disk is a DVD+RW			*/
+#define	DSF_NEED_FORMAT	0x0800	/* Disk needs to be formatted		*/
+
+/*
+ * Definitions for disktype flags
+ */
+#define DT_CD           0x001  /*is a CD                                */
+#define DT_DVD          0x002  /*is a DVD                               */
+
+/*
+ * Definitions for disktype flags
+ */
+#define DT_CD           0x001  /*is a CD                                */
+#define DT_DVD          0x002  /*is a DVD                               */
+
+/*
+ * Definitions for disk_status disk type
+ * used in "ds_type".
+ */
+/* None defined yet */
+
+typedef	struct disk_status	dstat_t;
+
+struct disk_status {
+	UInt32_t ds_diskid;		/* Disk identification		*/
+	UInt16_t ds_cdrflags;		/* Recording flags from cdrecord*/
+	UInt16_t ds_flags;		/* Disk_status flags		*/
+	Uchar	 ds_wrmode;		/* Selected write mode		*/
+	Uchar	 ds_type;		/* Abstract disk type		*/
+
+	Uchar	 ds_disktype;		/* Disk type (from TOC/PMA)	*/
+	Uchar	 ds_diskstat;		/* Disk status (MMC)		*/
+	Uchar	 ds_sessstat;		/* Status of last sesion (MMC)	*/
+	Uchar	 ds_trfirst;		/* first track #		*/
+	Uchar	 ds_trlast;		/* last track #			*/
+	Uchar	 ds_trfirst_ls;		/* first track # in last session*/
+	Uchar	 ds_barcode[8];		/* Disk bar code		*/
+
+	Int32_t	 ds_first_leadin;	/* Start of first lead in (ATIP)*/
+	Int32_t	 ds_last_leadout;	/* Start of last lead out (ATIP)*/
+	Int32_t	 ds_curr_leadin;	/* Start of next lead in	*/
+	Int32_t	 ds_curr_leadout;	/* Start of next lead out	*/
+
+	Int32_t	 ds_maxblocks;		/* # of official blocks on disk	*/
+	Int32_t	 ds_maxrblocks;		/* # real blocks on disk	*/
+	Int32_t	 ds_fwa;		/* first writable addr		*/
+
+	Int32_t	 ds_startsec;		/* Actual start sector		*/
+	Int32_t	 ds_endsec;		/* Actual end sector		*/
+	Int32_t	 ds_buflow;		/* # of times drive buffer empty*/
+
+	UInt16_t ds_minbuf;		/* Minimum drive bufer fill rt.	*/
+
+	UInt16_t ds_at_min_speed;	/* The minimal ATIP write speed	*/
+	UInt16_t ds_at_max_speed;	/* The maximal ATIP write speed	*/
+	UInt16_t ds_dr_cur_rspeed;	/* The drive's cur read speed	*/
+	UInt16_t ds_dr_max_rspeed;	/* The drive's max read speed	*/
+	UInt16_t ds_dr_cur_wspeed;	/* The drive's cur write speed	*/
+	UInt16_t ds_dr_max_wspeed;	/* The drive's max write speed	*/
+	UInt16_t ds_wspeed;		/* The selected/drive wr. speed */
+};
+
+/*
+ * First approach of a CDR device abstraction layer.
+ * This interface will change as long as I did not find the
+ * optimum that fits for all devices.
+ *
+ * Called with pointer to whole track array:
+ *	cdr_send_cue()
+ *	cdr_write_leadin()
+ *	cdr_open_session()
+ *	cdr_fixate()
+ *
+ * Called with (track_t *) 0 or pointer to current track:
+ *	cdr_next_wr_address()
+ *
+ * Called with pointer to current track:
+ *	cdr_open_track()
+ *	cdr_close_track()
+ *
+ * Calling sequence:
+ *	cdr_identify()					May modify driver
+ *	Here, the cdr_t will be allocated and
+ *	copied to a new writable area.
+ *	cdr_attach()					Get drive properties
+ *	cdr_buffer_cap()
+ *	cdr_getdisktype()				GET ATIP
+ *	cdr_init()					set TAO for -msinfo
+ *	cdr_check_session				XXX ????
+ *	cdr_opt1()					set early options
+ *	cdr_set_speed_dummy(usalp, dp, &speed)
+ *	<---	Grace time processing goes here
+ *	{ do_opc(); cdr_blank() }
+ *	cdr_opt2()					set late options
+ *	cdr_open_session()				set up params (no wrt.)
+ *	do_opc()
+ *	cdr_write_leadin()				start writing
+ *	LOOP {
+ *		cdr_open_track()
+ *		cdr_next_wr_address()			only TAO / Packet
+ *		write_track_data()
+ *		cdr_close_track()
+ *	}
+ *	write_leadout()				XXX should go -> driver!
+ *	cdr_fixate()
+ *	cdr_stats()
+ */
+/*--------------------------------------------------------------------------*/
+typedef	struct cdr_cmd	cdr_t;
+
+#ifdef	_SCG_SCSITRANSP_H
+struct cdr_cmd {
+	int	cdr_dev;						/* Numerical device type */
+	UInt32_t cdr_cmdflags;			/* Command line options */
+	UInt32_t cdr_flags;				/* Drive related flags	*/
+	UInt8_t	 cdr_cdrw_support;	/* CD-RW write media types */
+	UInt16_t cdr_speeddef;			/* Default write speed	*/
+	UInt16_t cdr_speedmax;			/* Max. write speed	*/
+
+	char	*cdr_drname;				/* Driver ID string	*/
+	char	*cdr_drtext;				/* Driver ID text	*/
+	struct cd_mode_page_2A *cdr_cdcap;
+	dstat_t	*cdr_dstat;
+#ifdef	_SCG_SCSIREG_H
+	/* identify drive */
+	cdr_t	*(*cdr_identify)(SCSI *usalp, cdr_t *, struct scsi_inquiry *);	
+#else
+	/* identify drive */
+	cdr_t	*(*cdr_identify)(SCSI *usalp, cdr_t *, void *);		
+#endif
+	/* init error decoding etc*/
+	int	(*cdr_attach)(SCSI *usalp, cdr_t *);
+	/* init drive to useful deflts */
+	int	(*cdr_init)(SCSI *usalp, cdr_t *);
+	/* get disk type */
+	int	(*cdr_getdisktype)(SCSI *usalp, cdr_t *);
+	/* load disk */
+	int	(*cdr_load)(SCSI *usalp, cdr_t *);
+	/* unload disk */
+	int	(*cdr_unload)(SCSI *usalp, cdr_t *);	
+	/* read buffer capacity */
+	int	(*cdr_buffer_cap)(SCSI *usalp, long *sizep, long *freep);
+	/* check if recover is needed */
+	int	(*cdr_check_recovery)(SCSI *usalp, cdr_t *);
+	/* do recover */
+	int	(*cdr_recover)(SCSI *usalp, cdr_t *, int track);
+	/* set recording speed & dummy write */
+	int	(*cdr_set_speed_dummy)(SCSI *usalp, cdr_t *, int *speedp);
+	/* set sector size */
+	int	(*cdr_set_secsize)(SCSI *usalp, int secsize);
+	/* get next writable addr. */
+	int	(*cdr_next_wr_address)(SCSI *usalp, track_t *trackp, long *ap);
+	/* reserve track for future use */
+	int	(*cdr_reserve_track)(SCSI *usalp, Ulong len);
+	int	(*cdr_write_trackdata)(SCSI *usalp, caddr_t buf, long daddr, long bytecnt, 
+										  int seccnt, BOOL islast);
+	/* generate cue sheet */
+	int	(*cdr_gen_cue)(track_t *trackp, void *cuep, BOOL needgap);
+	/* send cue sheet */
+	int	(*cdr_send_cue)(SCSI *usalp, cdr_t *, track_t *trackp);
+	/* write leadin */
+	int	(*cdr_write_leadin)(SCSI *usalp, cdr_t *, track_t *trackp);
+	/* open new track */
+	int	(*cdr_open_track)(SCSI *usalp, cdr_t *, track_t *trackp);
+	/* close written track */
+	int	(*cdr_close_track)(SCSI *usalp, cdr_t *, track_t *trackp);
+	/* open new session */
+	int	(*cdr_open_session)(SCSI *usalp, cdr_t *, track_t *trackp);
+	/* really needed ??? */
+	int	(*cdr_close_session)(SCSI *usalp, cdr_t *);
+	/* abort current write */
+	int	(*cdr_abort_session)(SCSI *usalp, cdr_t *);
+	/* read session offset*/
+	int	(*cdr_session_offset)(SCSI *usalp, long *soff);
+	/* write toc on disk */
+	int	(*cdr_fixate)(SCSI *usalp, cdr_t *, track_t *trackp);
+	/* final statistics printing*/
+	int	(*cdr_stats)(SCSI *usalp, cdr_t *);
+	/* blank something */
+	int	(*cdr_blank)(SCSI *usalp, cdr_t *, long addr, int blanktype);
+	/* format media */
+	int	(*cdr_format)(SCSI *usalp, cdr_t *, int fmtflags);
+	/* Do OPC */
+	int	(*cdr_opc)(SCSI *usalp, caddr_t bp, int cnt, int doopc);
+	/* do early option processing*/
+	int	(*cdr_opt1)(SCSI *usalp, cdr_t *);
+	/* do late option processing */
+	int	(*cdr_opt2)(SCSI *usalp, cdr_t *);
+	/* calculate optimale split */
+	int	(*cdr_layer_split)(SCSI *usalp, cdr_t *, long tsize);
+	int	profile;
+	BOOL	is_dvd;
+};
+#endif
+
+/*
+ * Definitions for cdr_flags
+ */
+#define	CDR_TAO		0x01		/* Drive supports Track at once	*/
+#define	CDR_SAO		0x02		/* Drive supports Sess at once	*/
+#define	CDR_PACKET	0x04		/* Drive supports packet writing*/
+#define	CDR_RAW		0x08		/* Drive supports raw writing	*/
+#define	CDR_RAW16	0x10		/* Drive supports RAW raw16	*/
+#define	CDR_RAW96P	0x20		/* Drive supports RAW raw96 pak	*/
+#define	CDR_RAW96R	0x40		/* Drive supports RAW raw96 raw	*/
+#ifdef	__needed__
+#define	CDR_SRAW16	0x100		/* Drive supports SAO raw16	*/
+#endif
+#define	CDR_SRAW96P	0x200		/* Drive supports SAO raw96 pak	*/
+#define	CDR_SRAW96R	0x400		/* Drive supports SAO raw96 raw */
+#define	CDR_SWABAUDIO	0x1000		/* Drive swabs audio data	*/
+#define	CDR_ISREADER	0x2000		/* Drive is s CD-ROM reader	*/
+#define	CDR_TRAYLOAD	0x4000		/* Drive loads CD with tray	*/
+#define	CDR_CADDYLOAD	0x8000		/* Drive loads CD with caddy	*/
+#define	CDR_NO_LOLIMIT	0x10000		/* Drive ignores lead-out limit	*/
+#define	CDR_DVD		0x20000		/* Drive is a DVD drive		*/
+#define	CDR_SIMUL	0x40000		/* Drive is simulated		*/
+#define	CDR_BURNFREE	0x80000		/* Drive sup. BUFund. free rec.	*/
+#define	CDR_VARIREC	0x100000	/* Drive sup. VariRec	 Plex.	*/
+#define	CDR_AUDIOMASTER	0x200000	/* Drive sup. AudioMaster Yamah.*/
+#define	CDR_FORCESPEED	0x400000	/* Drive sup. WriteSpeed ctl.	*/
+#define	CDR_DISKTATTOO	0x800000	/* Drive sup. Yamaha DiskT@2	*/
+#define	CDR_SINGLESESS	0x1000000	/* Drive sup. single sess. mode */
+#define	CDR_HIDE_CDR	0x2000000	/* Drive sup. hide CDR features	*/
+#define	CDR_SPEEDREAD	0x4000000	/* Drive sup. SpeedReed		*/
+#define	CDR_GIGAREC	0x8000000	/* Drive sup. GigaRec	 Plex.	*/
+#define	CDR_MMC		0x10000000	/* Drive is MMC compliant	*/
+#define	CDR_MMC2	0x20000000	/* Drive is MMC-2 compliant	*/
+#define	CDR_MMC3	0x40000000	/* Drive is MMC-3 compliant	*/
+#ifdef	PROTOTYPES
+#define	CDR_ALLOC	0x80000000UL	/* structure is allocated	*/
+#else
+#define	CDR_ALLOC	0x80000000	/* structure is allocated	*/
+#endif
+
+/*
+ * Definitions for cdr_cdrw_support
+ */
+#define	CDR_CDRW_NONE	0x00		/* CD-RW writing not supported */
+#define	CDR_CDRW_MULTI	0x01		/* CD-RW multi speed supported */
+#define	CDR_CDRW_HIGH	0x02		/* CD-RW high speed supported */
+#define	CDR_CDRW_ULTRA	0x04		/* CD-RW ultra high speed supported */
+#define	CDR_CDRW_ULTRAP	0x08		/* CD-RW ultra high speed+ supported */
+#define	CDR_CDRW_ALL	0xFF		/* All bits set: unknown - support all */
+
+/*
+ * cdrecord.c
+ */
+extern	int	read_buf(int f, char *bp, int size);
+extern	int	fill_buf(int f, track_t *trackp, long secno, char *bp, int size);
+extern	int	get_buf(int f, track_t *trackp, long secno, char **bpp, int size);
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	write_secs(SCSI *usalp, cdr_t *dp, char *bp, long startsec, 
+								  int bytespt, int secspt, BOOL islast);
+extern	int	pad_track(SCSI *usalp, cdr_t *dp, track_t *trackp,
+								 long startsec, Llong amt,
+								 BOOL dolast, Llong *bytesp);
+extern	void	load_media(SCSI *usalp, cdr_t *, BOOL);
+extern	void	unload_media(SCSI *usalp, cdr_t *, int);
+extern	void	reload_media(SCSI *usalp, cdr_t *);
+#endif
+extern	void	raisepri(int);
+extern	int	getnum(char *arg, long *valp);
+
+/*
+ * cd_misc.c
+ */
+extern	int	from_bcd(int b);
+extern	int	to_bcd(int i);
+extern	long	msf_to_lba(int m, int s, int f, BOOL force_positive);
+extern	BOOL	lba_to_msf(long lba, msf_t *mp);
+extern	void	sec_to_msf(long sec, msf_t *mp);
+extern	void	print_min_atip(long li, long lo);
+
+/*
+ * fifo.c
+ */
+extern	void	init_fifo(long);
+extern	BOOL	init_faio(track_t *track, int);
+extern	BOOL	await_faio(void);
+extern	void	kill_faio(void);
+extern	int	wait_faio(void);
+extern	int	faio_read_buf(int f, char *bp, int size);
+extern	int	faio_get_buf(int f, char **bpp, int size);
+extern	void	fifo_stats(void);
+extern	int	fifo_percent(BOOL addone);
+
+/*
+ * wm_session.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	write_session_data(SCSI *usalp, cdr_t *dp, track_t *trackp);
+#endif
+
+/*
+ * wm_track.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+/*extern	int	write_track_data __PR((SCSI *usalp, cdr_t *dp, track_t *trackp));*/
+#endif
+
+/*
+ * wm_packet.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	write_packet_data(SCSI *usalp, cdr_t *dp, track_t *trackp);
+#endif
+
+/*
+ * modes.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	BOOL	get_mode_params(SCSI *usalp, int page, char *pagename,
+										 Uchar *modep, Uchar *cmodep,
+										 Uchar *dmodep, Uchar *smodep,
+										 int *lenp);
+extern	BOOL	set_mode_params(SCSI *usalp, char *pagename, Uchar *modep,
+										 int len, int save, int secsize);
+#endif
+
+/*
+ * misc.c
+ */
+#ifdef	timerclear
+extern	void	timevaldiff(struct timeval *start, struct timeval *stop);
+extern	void	prtimediff(const char *fmt, struct timeval *start,
+								  struct timeval *stop);
+#endif
+
+/*
+ * getnum.c
+ */
+extern	int	getnum(char *arg, long *valp);
+extern	int	getllnum(char *arg, Llong *lvalp);
+
+/*
+ * scsi_cdr.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	BOOL	unit_ready(SCSI *usalp);
+extern	BOOL	wait_unit_ready(SCSI *usalp, int secs);
+extern	BOOL	scsi_in_progress(SCSI *usalp);
+extern	BOOL	cdr_underrun(SCSI *usalp);
+extern	int	test_unit_ready(SCSI *usalp);
+extern	int	rezero_unit(SCSI *usalp);
+extern	int	request_sense(SCSI *usalp);
+extern	int	request_sense_b(SCSI *usalp, caddr_t bp, int cnt);
+extern	int	inquiry(SCSI *usalp, caddr_t, int);
+extern	int	read_capacity(SCSI *usalp);
+#ifdef	EOF	/* stdio.h has been included */
+extern	void	print_capacity(SCSI *usalp, FILE *f);
+#endif
+extern	int	scsi_load_unload(SCSI *usalp, int);
+extern	int	scsi_prevent_removal(SCSI *usalp, int);
+extern	int	scsi_start_stop_unit(SCSI *usalp, int, int, BOOL immed);
+
+#define	ROTCTL_CLV	0	/* CLV or PCAV	*/
+#define	ROTCTL_CAV	1	/* True CAV	*/
+
+extern	int	scsi_set_speed(SCSI *usalp, int readspeed, int writespeed, 
+										int rotctl);
+extern	int	scsi_get_speed(SCSI *usalp, int *readspeedp, int *writespeedp);
+extern	int	qic02(SCSI *usalp, int);
+extern	int	write_xscsi(SCSI *usalp, caddr_t, long, long, int);
+extern	int	write_xg0(SCSI *usalp, caddr_t, long, long, int);
+extern	int	write_xg1(SCSI *usalp, caddr_t, long, long, int);
+extern	int	write_xg5(SCSI *usalp, caddr_t, long, long, int);
+extern	int	seek_scsi(SCSI *usalp, long addr);
+extern	int	seek_g0(SCSI *usalp, long addr);
+extern	int	seek_g1(SCSI *usalp, long addr);
+extern	int	scsi_flush_cache(SCSI *usalp, BOOL immed);
+extern	int	read_buffer(SCSI *usalp, caddr_t bp, int cnt, int mode);
+extern	int	write_buffer(SCSI *usalp, char *buffer, long length, int mode, 
+									 int bufferid, long offset);
+extern	int	read_subchannel(SCSI *usalp, caddr_t bp, int track, int cnt, 
+										 int msf, int subq, int fmt);
+extern	int	read_toc(SCSI *usalp, caddr_t, int, int, int, int);
+extern	int	read_toc_philips(SCSI *usalp, caddr_t, int, int, int, int);
+extern	int	read_header(SCSI *usalp, caddr_t, long, int, int);
+extern	int	read_disk_info(SCSI *usalp, caddr_t, int);
+
+#define	TI_TYPE_LBA	0	/* Address is LBA */
+#define	TI_TYPE_TRACK	1	/* Address: 0 -> TOC, xx -> Track xx, 0xFF -> Inv Track */
+#define	TI_TYPE_SESS	2	/* Address is session # */
+extern	int	read_track_info(SCSI *usalp, caddr_t, int type, int addr, int cnt);
+extern	int	read_rzone_info(SCSI *usalp, caddr_t bp, int cnt);
+extern	int	reserve_tr_rzone(SCSI *usalp, long size);
+extern	int	read_dvd_structure(SCSI *usalp, caddr_t bp, int cnt, int addr, 
+											 int layer, int fmt);
+extern	int	send_dvd_structure(SCSI *usalp, caddr_t bp, int cnt, int layer, 
+											 int fmt);
+extern	int	send_opc(SCSI *usalp, caddr_t, int cnt, int doopc);
+
+#define	CL_TYPE_STOP_DEICE	0	/* Stop De-icing a DVD+RW Media */
+#define	CL_TYPE_TRACK		1	/* Close Track # */
+#define	CL_TYPE_SESSION		2	/* Close Session/Border / Stop backgrnd. format */
+#define	CL_TYPE_INTER_BORDER	3	/* Close intermediate Border */
+#define	CL_TYPE_OPEN_SESSION	4	/* Close the Open Session and Record an Extended lead-out */
+#define	CL_TYPE_FINALISE_MINRAD	5	/* Finalize the Disc with a Minimum Recorded Radius */
+#define	CL_TYPE_FINALISE	6	/* Finalize the disc */
+extern	int	scsi_close_tr_session(SCSI *usalp, int type, int track, 
+												 BOOL immed);
+extern	int	read_master_cue(SCSI *usalp, caddr_t bp, int sheet, int cnt);
+extern	int	send_cue_sheet(SCSI *usalp, caddr_t bp, long size);
+extern	int	read_buff_cap(SCSI *usalp, long *, long *);
+extern	int	scsi_blank(SCSI *usalp, long addr, int blanktype, BOOL immed);
+extern	BOOL	allow_atapi(SCSI *usalp, BOOL new);
+extern	int	mode_select(SCSI *usalp, Uchar *, int, int, int);
+extern	int	mode_sense(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+extern	int	mode_select_sg0(SCSI *usalp, Uchar *, int, int, int);
+extern	int	mode_sense_sg0(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+extern	int	mode_select_g0(SCSI *usalp, Uchar *, int, int, int);
+extern	int	mode_select_g1(SCSI *usalp, Uchar *, int, int, int);
+extern	int	mode_sense_g0(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+extern	int	mode_sense_g1(SCSI *usalp, Uchar *dp, int cnt, int page, int pcf);
+extern	int	read_tochdr(SCSI *usalp, cdr_t *, int *, int *);
+extern	int	read_cdtext(SCSI *usalp);
+extern	int	read_trackinfo(SCSI *usalp, int, long *, struct msf *, int *, 
+										int *, int *);
+extern	int	read_B0(SCSI *usalp, BOOL isbcd, long *b0p, long *lop);
+extern	int	read_session_offset(SCSI *usalp, long *);
+extern	int	read_session_offset_philips(SCSI *usalp, long *);
+extern	int	sense_secsize(SCSI *usalp, int current);
+extern	int	select_secsize(SCSI *usalp, int);
+extern	BOOL	is_cddrive(SCSI *usalp);
+extern	BOOL	is_unknown_dev(SCSI *usalp);
+extern	int	read_scsi(SCSI *usalp, caddr_t, long, int);
+extern	int	read_g0(SCSI *usalp, caddr_t, long, int);
+extern	int	read_g1(SCSI *usalp, caddr_t, long, int);
+extern	BOOL	getdev(SCSI *usalp, BOOL);
+#ifdef	EOF	/* stdio.h has been included */
+extern	void	printinq(SCSI *usalp, FILE *f);
+#endif
+extern	void	printdev(SCSI *usalp);
+extern	BOOL	do_inquiry(SCSI *usalp, BOOL);
+extern	BOOL	recovery_needed(SCSI *usalp, cdr_t *);
+extern	int	scsi_load(SCSI *usalp, cdr_t *);
+extern	int	scsi_unload(SCSI *usalp, cdr_t *);
+extern	int	scsi_cdr_write(SCSI *usalp, caddr_t bp, long sectaddr, 
+										long size, int blocks, BOOL islast);
+extern	struct cd_mode_page_2A *mmc_cap(SCSI *usalp, Uchar *modep);
+extern	void	mmc_getval(struct cd_mode_page_2A *mp, BOOL *cdrrp, BOOL *cdwrp,
+								  BOOL *cdrrwp, BOOL *cdwrwp, BOOL *dvdp, BOOL *dvdwp);
+extern	BOOL	is_mmc(SCSI *usalp, BOOL *cdwp, BOOL *dvdwp);
+extern	BOOL	mmc_check(SCSI *usalp, BOOL *cdrrp, BOOL *cdwrp, BOOL *cdrrwp, 
+								 BOOL *cdwrwp, BOOL *dvdp, BOOL *dvdwp);
+extern	void	print_capabilities(SCSI *usalp);
+#endif
+
+/*
+ * scsi_cdr.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	void	print_capabilities_mmc4(SCSI *usalp);
+#endif
+
+/*
+ * scsi_mmc.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	get_configuration(SCSI *usalp, caddr_t bp, int cnt, 
+											int st_feature, int rt);
+extern	int	get_curprofile(SCSI *usalp);
+extern	int	print_profiles(SCSI *usalp);
+extern	int	get_proflist(SCSI *usalp, BOOL *wp, BOOL *cdp, BOOL *dvdp,
+									 BOOL *dvdplusp, BOOL *ddcdp);
+extern	int	get_wproflist(SCSI *usalp, BOOL *cdp, BOOL *dvdp,
+									  BOOL *dvdplusp, BOOL *ddcdp);
+extern char *mmc_obtain_profile_name(int profile_number);
+#endif
+
+/*
+ * scsi_mmc.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	get_supported_cdrw_media_types(SCSI *usalp);
+#endif
+
+/*
+ * mmc_misc.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	check_writemodes_mmc(SCSI *usalp, cdr_t *dp);
+#endif	/* _SCG_SCSITRANSP_H */
+
+/*
+ * cdr_drv.c
+ */
+#ifdef	_SCG_SCSITRANSP_H
+#ifdef	_SCG_SCSIREG_H
+extern	cdr_t	*drive_identify(SCSI *usalp, cdr_t *, struct scsi_inquiry *ip);
+#else
+extern	cdr_t	*drive_identify(SCSI *usalp, cdr_t *, void *ip);
+#endif
+extern	int	drive_attach(SCSI *usalp, cdr_t *);
+#endif
+extern	int	attach_unknown(void);
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	blank_dummy(SCSI *usalp, cdr_t *, long addr, int blanktype);
+int	format_dummy(SCSI *usalp, cdr_t *, int fmtflags);
+extern	int	drive_getdisktype(SCSI *usalp, cdr_t *dp);
+extern	int	cmd_ill(SCSI *usalp);
+extern	int	cmd_dummy(SCSI *usalp, cdr_t *);
+extern	int	no_sendcue(SCSI *usalp, cdr_t *, track_t *trackp);
+extern	int	buf_dummy(SCSI *usalp, long *sp, long *fp);
+#endif
+extern	BOOL	set_cdrcmds(char *name, cdr_t **dpp);
+#ifdef	_SCG_SCSITRANSP_H
+extern	cdr_t	*get_cdrcmds(SCSI *usalp);
+#endif
+
+
+/*
+ * drv_mmc.c
+ */
+extern	void	mmc_opthelp(cdr_t *dp, int excode);
+extern	char	*hasdrvopt(char *optstr, char *optname);
+#ifdef	_SCG_SCSITRANSP_H
+extern struct ricoh_mode_page_30 *get_justlink_ricoh(SCSI *usalp, Uchar *mode);
+#endif
+
+/*
+ * isosize.c
+ */
+extern	Llong	isosize(int f);
+
+/*
+ * audiosize.c
+ */
+extern	BOOL	is_auname(const char *name);
+extern	off_t	ausize(int f);
+extern	BOOL	is_wavname(const char *name);
+extern	off_t	wavsize(int f);
+
+/*
+ * auinfo.c
+ */
+extern	BOOL	auinfosize(char *name, track_t *trackp);
+extern	void	auinfo(char *name, int track, track_t *trackp);
+#ifdef CDTEXT_H
+extern	textptr_t *gettextptr(int track, track_t *trackp);
+#endif
+extern	void	setmcn(char *mcn, track_t *trackp);
+extern	void	setisrc(char *isrc, track_t *trackp);
+extern	void	setindex(char *tindex, track_t *trackp);
+
+/*
+ * diskid.c
+ */
+extern	void	pr_manufacturer(msf_t *mp, BOOL rw, BOOL audio);
+extern	int	manufacturer_id(msf_t *mp);
+extern	long	disk_rcap(msf_t *mp, long maxblock, BOOL rw, BOOL audio);
+
+/*--------------------------------------------------------------------------*/
+/* Test only								    */
+/*--------------------------------------------------------------------------*/
+#ifdef _SCSIMMC_H
+/*extern	int	do_cue		__PR((track_t *trackp, struct mmc_cue **cuep));*/
+#else
+/*extern	int	do_cue		__PR((track_t *trackp, void *cuep));*/
+#endif
+
+/*
+ * subchan.c
+ */
+extern	int	do_leadin(track_t *trackp);
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	write_leadin(SCSI *usalp, cdr_t *dp, track_t *trackp, 
+									 int leadinstart);
+extern	int	write_leadout(SCSI *usalp, cdr_t *dp, track_t *trackp);
+#endif
+extern	void	fillsubch(track_t *trackp, Uchar *sp, int secno, int nsecs);
+extern	void	filltpoint(Uchar *sub, int ctrl_adr, int point, msf_t *mp);
+extern	void	fillttime(Uchar *sub, msf_t *mp);
+extern	void	qpto96(Uchar *sub, Uchar *subq, int dop);
+extern	void	addrw(Uchar *sub, Uchar	*subrwptr);
+extern	void	qwto16(Uchar *subq, Uchar *subptr);
+extern	void	subrecodesecs(track_t *trackp, Uchar *bp, int address, int nsecs);
+
+/*
+ * sector.c
+ */
+extern	int	encspeed(BOOL be_verbose);
+extern	void	encsectors(track_t *trackp, Uchar *bp, int address, int nsecs);
+extern	void	scrsectors(track_t *trackp, Uchar *bp, int address, int nsecs);
+extern	void	encodesector(Uchar *sp, int sectype, int address);
+extern	void	fillsector(Uchar *sp, int sectype, int address);
+
+/*
+ * clone.c
+ */
+extern	void	clone_toc(track_t *trackp);
+extern	void	clone_tracktype(track_t *trackp);
+
+/*
+ * cdtext.c
+ */
+extern	BOOL	checktextfile(char *fname);
+extern	void	packtext(int tracks, track_t *trackp);
+#ifdef	_SCG_SCSITRANSP_H
+extern	int	write_cdtext(SCSI *usalp, cdr_t *dp, long startsec);
+#endif
+
+/*
+ * cue.c
+ */
+extern	int	parsecue(char *cuefname, track_t trackp[]);
+#ifdef	EOF	/* stdio.h has been included */
+extern	void	fparsecue(FILE *f, track_t trackp[]);
+#endif
diff --git a/wodim/xio.c b/wodim/xio.c
new file mode 100644
index 0000000..04118cd
--- /dev/null
+++ b/wodim/xio.c
@@ -0,0 +1,164 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)xio.c	1.11 04/07/11 Copyright 2003-2004 J. Schilling */
+/*
+ *	EXtended I/O functions for cdrecord
+ *
+ *	Copyright (c) 2003-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.
+ */
+
+#include <mconfig.h>
+#include <unixstd.h>
+#include <stdxlib.h>
+#include <strdefs.h>
+#include <standard.h>
+#include <fctldefs.h>
+
+#ifdef	NEED_O_BINARY
+#include <io.h>					/* for setmode() prototype */
+#endif
+
+#include "xio.h"
+
+static xio_t	x_stdin = {
+	NULL,		/* x_next	*/
+	NULL,		/* x_name	*/
+	0,		/* x_off	*/
+	STDIN_FILENO,	/* x_file	*/
+	999,		/* x_refcnt	*/
+	O_RDONLY,	/* x_oflag	*/
+	0		/* x_omode	*/
+};
+
+static xio_t	*x_root = &x_stdin;
+static xio_t	**x_tail = NULL;
+
+
+static	xio_t	*xnewnode(char *name);
+void	*xopen(char *name, int oflag, int mode);
+int	xclose(void *vp);
+
+static xio_t *
+xnewnode(char *name)
+{
+	xio_t	*xp;
+
+	if ((xp = malloc(sizeof (xio_t))) == NULL)
+		return ((xio_t *) NULL);
+
+	xp->x_next = (xio_t *) NULL;
+	xp->x_name = strdup(name);
+	if (xp->x_name == NULL) {
+		free(xp);
+		return ((xio_t *) NULL);
+	}
+	xp->x_off = 0;
+	xp->x_file = -1;
+	xp->x_refcnt = 1;
+	xp->x_oflag = 0;
+	xp->x_omode = 0;
+	return (xp);
+}
+
+void *
+xopen(char *name, int oflag, int mode)
+{
+	int	f;
+	xio_t	*xp;
+	xio_t	*pp = x_root;
+
+	if (x_tail == NULL)
+		x_tail = &x_stdin.x_next;
+	if (name == NULL) {
+		xp = &x_stdin;
+		xp->x_refcnt++;
+#ifdef	NEED_O_BINARY
+		if ((oflag & O_BINARY) != 0) {
+			setmode(STDIN_FILENO, O_BINARY);
+		}
+#endif
+		return (xp);
+	}
+	for (; pp; pp = pp->x_next) {
+		if (pp->x_name == NULL)	/* stdin avoid core dump in strcmp() */
+			continue;
+		if ((strcmp(pp->x_name, name) == 0) &&
+		    (pp->x_oflag == oflag) && (pp->x_omode == mode)) {
+			break;
+		}
+	}
+	if (pp) {
+		pp->x_refcnt++;
+		return ((void *)pp);
+	}
+	if ((f = open(name, oflag, mode)) < 0)
+		return (NULL);
+
+	if ((xp = xnewnode(name)) == NULL) {
+		close(f);
+		return (NULL);
+	}
+	xp->x_file = f;
+	xp->x_oflag = oflag;
+	xp->x_omode = mode;
+	*x_tail = xp;
+	x_tail = &xp->x_next;
+	return ((void *)xp);
+}
+
+int
+xclose(void *vp)
+{
+	xio_t	*xp = vp;
+	xio_t	*pp = x_root;
+	int	ret = 0;
+
+	if (xp == &x_stdin)
+		return (ret);
+	if (x_tail == NULL)
+		x_tail = &x_stdin.x_next;
+
+	if (--xp->x_refcnt <= 0) {
+		ret = close(xp->x_file);
+		while (pp) {
+			if (pp->x_next == xp)
+				break;
+			if (pp->x_next == NULL)
+				break;
+			pp = pp->x_next;
+		}
+		if (pp->x_next == xp) {
+			if (x_tail == &xp->x_next)
+				x_tail = &pp->x_next;
+			pp->x_next = xp->x_next;
+		}
+
+		free(xp->x_name);
+		free(xp);
+	}
+	return (ret);
+}
diff --git a/wodim/xio.h b/wodim/xio.h
new file mode 100644
index 0000000..a7836b2
--- /dev/null
+++ b/wodim/xio.h
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ *
+ */
+
+/* @(#)xio.h	1.2 04/03/02 Copyright 2003-2004 J. Schilling */
+/*
+ *	EXtended I/O functions for cdrecord
+ *
+ *	Copyright (c) 2003-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.
+ */
+
+#ifndef	_XIO_H
+#define	_XIO_H
+
+#include <utypes.h>
+
+typedef struct xio {
+	struct xio	*x_next;
+	char		*x_name;
+	Ullong		x_off;
+	int		x_file;
+	int		x_refcnt;
+	int		x_oflag;
+	int		x_omode;
+} xio_t;
+
+#define	xfileno(p)	(((xio_t *)(p))->x_file)
+
+extern	void	*xopen(char *name, int oflag, int mode);
+extern	int	xclose(void *vp);
+
+#endif