Initial source

1 files changed, 1901 insertions, 0 deletions

diff --git a/scsi/rz_audio.c b/scsi/rz_audio.c
new file mode 100644
index 0000000..4d60fa1
--- /dev/null
+++ b/scsi/rz_audio.c
@@ -0,0 +1,1901 @@
+/* 
+ * Mach Operating System
+ * Copyright (c) 1993 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ *	File: rz_audio.c
+ * 	Author: Alessandro Forin, Carnegie Mellon University
+ *	Date:	3/93
+ *
+ *	Top layer of the SCSI driver: interface with the MI.
+ *	This file contains operations specific to audio CD-ROM devices.
+ *	Unlike many others, it sits on top of the rz.c module.
+ */
+
+#include <mach/std_types.h>
+#include <kern/strings.h>
+#include <machine/machspl.h>		/* spl definitions */
+#include <vm/vm_kern.h>
+#include <device/ds_routines.h>
+
+#include <scsi/compat_30.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi2.h>
+#include <scsi/scsi_defs.h>
+#include <scsi/rz.h>
+
+#if (NSCSI > 0)
+
+#define private static
+
+/* some data is two BCD digits in one byte */
+#define	bcd_to_decimal(b)	(((b)&0xf) + 10 * (((b) >> 4) & 0xf))
+#define decimal_to_bcd(b)	((((b) / 10) << 4)  |  ((b) % 10))
+
+/*
+ * Regular use of a CD-ROM is for data, and is handled
+ * by the default set of operations. Ours is for funtime..
+ */
+
+extern char	*sccdrom_name();
+int		cd_strategy();
+void		cd_start();
+
+private scsi_devsw_t	scsi_audio = {
+	sccdrom_name, 0, 0, 0, cd_strategy, cd_start, 0, 0
+};
+
+private char unsupported[] = "Device does not support it.";
+
+/*
+ * Unfortunately, none of the vendors appear to
+ * abide by the SCSI-2 standard and many of them
+ * violate or stretch even the SCSI-1 one.
+ * Therefore, we keep a red-list here of the worse
+ * offendors and how to deal with them.
+ * The user is notified of the problem and invited
+ * to solicit his vendor to upgrade the firmware.
+ * [They had plenty of time to do so]
+ */
+typedef struct red_list {
+	char	*vendor;
+	char	*product;
+	char	*rev;
+	/*
+	 * The standard MANDATES [par 13.1.6] the play_audio command
+	 * at least as a way to discover if the device
+	 * supports audio operations at all. This is the only way
+	 * we need to use it.
+	 */
+	scsi_ret_t	(*can_play_audio)( target_info_t *, char *, io_req_t);
+	/*
+	 * The standard defines the use of start_stop_unit to
+	 * cause the drive to eject the disk.
+	 */
+	scsi_ret_t	(*eject)( target_info_t *, char *, io_req_t );
+	/*
+	 * The standard defines read_subchannel as a way to
+	 * get the current playing position.
+	 */
+	scsi_ret_t	(*current_position)( target_info_t *, char *, io_req_t );
+	/*
+	 * The standard defines read_table_of_content to get
+	 * the listing of audio tracks available.
+	 */
+	scsi_ret_t	(*read_toc)( target_info_t *, char *, io_req_t );
+	/*
+	 * The standard defines read_subchannel as the way to
+	 * report the current audio status (playing/stopped/...).
+	 */
+	scsi_ret_t	(*get_status)( target_info_t *, char *, io_req_t );
+	/*
+	 * The standard defines two ways to issue a play command,
+	 * depending on the type of addressing used.
+	 */
+	scsi_ret_t	(*play_msf)( target_info_t *, char *, io_req_t );
+	scsi_ret_t	(*play_ti)( target_info_t *, char *, io_req_t );
+	/*
+	 * The standard defines the pause_resume command to
+	 * suspend or resume playback of audio data.
+	 */
+	scsi_ret_t	(*pause_resume)( target_info_t *, char *, io_req_t );
+	/*
+	 * The standard defines the audio page among the
+	 * mode selection options as a way to control
+	 * both volume and connectivity of the channels
+	 */
+	scsi_ret_t	(*volume_control)( target_info_t *, char *, io_req_t );
+} red_list_t;
+
+#define	if_it_can_do(some_cmd)						\
+	if (tgt->dev_info.cdrom.violates_standards &&			\
+	    tgt->dev_info.cdrom.violates_standards->some_cmd)		\
+	    rc = (*tgt->dev_info.cdrom.violates_standards->some_cmd)	\
+			(tgt,cmd,ior);	\
+	else
+
+/*
+ * So now that you know what they should have implemented :-),
+ * check at the end of the file what the naughty boys did instead.
+ */
+/* private red_list_t	audio_replacements[];	/ * at end */
+
+/*
+ * Forward decls
+ */
+private void decode_status( char *buf, unsigned char audio_status );
+void zero_ior( io_req_t );
+
+/*
+ * Open routine.  Does some checking, sets up
+ * the replacement pointer.
+ */
+io_return_t
+cd_open(
+	int		dev,
+	dev_mode_t	mode,
+	io_req_t	req)
+{
+	scsi_softc_t	*sc = 0;
+	target_info_t	*tgt;
+	int		ret;
+	scsi_ret_t	rc;
+	io_req_t	ior = 0;
+	vm_offset_t	mem = 0;
+	extern boolean_t rz_check();
+
+	if (!rz_check(dev, &sc, &tgt)) {
+		/*
+		 * Probe it again: might have installed a new device
+		 */
+		if (!sc || !scsi_probe(sc, &tgt, rzslave(dev), ior))
+			return D_NO_SUCH_DEVICE;
+		bzero(&tgt->dev_info, sizeof(tgt->dev_info));
+	}
+
+	/*
+	 * Check this is indeded a CD-ROM
+	 */
+	if (tgt->dev_ops != &scsi_devsw[SCSI_CDROM]) {
+		rz_close(dev);
+		return D_NO_SUCH_DEVICE;
+	}
+
+	/*
+	 * Switch to audio ops, unless some wrong
+	 */
+	tgt->dev_ops = &scsi_audio;
+
+	/*
+	 * Bring unit online
+	 */
+	ret = rz_open(dev, mode, req);
+	if (ret) goto bad;
+
+	/* Pessimistic */
+	ret = D_INVALID_OPERATION;
+
+	/*
+	 * Check if this device is on the red list
+	 */
+	{
+	    scsi2_inquiry_data_t	*inq;
+	    private void 		check_red_list();
+
+	    scsi_inquiry(tgt, SCSI_INQ_STD_DATA);
+	    inq = (scsi2_inquiry_data_t*)tgt->cmd_ptr;
+
+	    check_red_list( tgt, inq );
+
+	}
+
+	/*
+	 * Allocate dynamic data
+	 */
+	if (kmem_alloc(kernel_map, &mem, PAGE_SIZE) != KERN_SUCCESS)
+	  return D_NO_MEMORY;
+	tgt->dev_info.cdrom.result = (void *)mem;
+	tgt->dev_info.cdrom.result_available = FALSE;
+
+	/*
+	 * See if this CDROM can play audio data
+	 */
+	io_req_alloc(ior,0);		
+	zero_ior( ior );
+
+	{
+		char *cmd = 0;
+		if_it_can_do(can_play_audio)
+			rc = scsi_play_audio( tgt, 0, 0, FALSE, ior);
+	}
+
+	if (rc != SCSI_RET_SUCCESS) goto bad;
+
+	io_req_free(ior);
+	return D_SUCCESS;
+
+bad:
+	if (ior) io_req_free(ior);
+	if (mem) kmem_free(kernel_map, mem, PAGE_SIZE);
+	tgt->dev_ops = &scsi_devsw[SCSI_CDROM];
+	return ret;
+}
+
+/*
+ * Close routine.
+ */
+io_return_t
+cd_close(
+	int	dev)
+{
+	scsi_softc_t	*sc;
+	target_info_t	*tgt;
+	vm_offset_t	mem;
+
+	if (!rz_check(dev, &sc, &tgt))
+		return D_NO_SUCH_DEVICE;
+	if (!tgt || (tgt->dev_ops != &scsi_audio))
+		return D_NO_SUCH_DEVICE;
+
+	/*
+	 * Cleanup state
+	 */
+	mem = (vm_offset_t) tgt->dev_info.cdrom.result;
+	tgt->dev_info.cdrom.result = (void *)0;
+	tgt->dev_info.cdrom.result_available = FALSE;
+
+	(void) kmem_free(kernel_map, mem, PAGE_SIZE);
+
+	(void) rz_close(dev);
+
+	tgt->dev_ops = &scsi_devsw[SCSI_CDROM];
+	return D_SUCCESS;
+}
+
+/*
+ * Write routine.  It is passed an ASCII string
+ * with the command to be executed.
+ */
+io_return_t
+cd_write(
+	int		dev,
+	io_req_t	ior)
+{
+	register kern_return_t	rc;
+	boolean_t		wait = FALSE;
+	io_return_t		ret;
+	int			count;
+	register char		*data;
+	vm_offset_t		addr;
+
+	data  = ior->io_data;
+	count = ior->io_count;
+	if (count == 0)
+	    return D_SUCCESS;
+
+	if (!(ior->io_op & IO_INBAND)) {
+	    /*
+	     * Copy out-of-line data into kernel address space.
+	     * Since data is copied as page list, it will be
+	     * accessible.
+	     */
+	    vm_map_copy_t copy = (vm_map_copy_t) data;
+	    kern_return_t kr;
+
+	    kr = vm_map_copyout(device_io_map, &addr, copy);
+	    if (kr != KERN_SUCCESS)
+		return kr;
+	    data = (char *) addr;
+	}
+
+	if (scsi_debug)	printf("Got command '%s'\n", data);
+
+	ret = cd_command( dev, data, count, ior);
+
+	if (!(ior->io_op & IO_INBAND))
+	    (void) vm_deallocate(device_io_map, addr, ior->io_count);
+	return D_SUCCESS;
+}
+
+/*
+ * Read routine. Returns an ASCII string with the results
+ * of the last command executed.
+ */
+io_return_t
+cd_read(
+	int		dev,
+	io_req_t	ior)
+{
+	target_info_t	*tgt;
+	kern_return_t	rc;
+	natural_t	count;
+
+	/*
+	 * Allocate memory for read buffer.
+	 */
+	count = (natural_t)ior->io_count;
+	if (count > PAGE_SIZE)
+		return D_INVALID_SIZE;	/* sanity */
+
+	rc = device_read_alloc(ior, count);
+	if (rc != KERN_SUCCESS)
+		return rc;
+
+	if (scsi_debug) printf("Got read req for %d bytes\n", count);
+
+	/*
+	 * See if last cmd left some to say
+	 */
+	tgt = scsi_softc[rzcontroller(dev)]->target[rzslave(dev)];
+	if (tgt->dev_info.cdrom.result_available) {
+		int len;
+
+		tgt->dev_info.cdrom.result_available = FALSE;
+		len = strlen(tgt->dev_info.cdrom.result)+1;
+
+		if (count > len)
+			count = len;
+		bcopy(tgt->dev_info.cdrom.result, ior->io_data, count);
+
+	} else {
+#		define noway "No results pending"
+		count = (count > sizeof(noway)) ? sizeof(noway) : count;
+		bcopy(noway, ior->io_data, count);
+	}
+
+	ior->io_residual = ior->io_count - count;
+	return D_SUCCESS;
+}
+
+/*
+ * This does all the work
+ */
+io_return_t
+cd_command(
+	int		dev,
+	char		*cmd,
+	int		count,
+	io_req_t	req)
+{
+	target_info_t	*tgt;
+	io_req_t	ior;
+	io_return_t	ret = D_INVALID_OPERATION;
+	scsi_ret_t	rc;
+	char		*buf;
+
+	tgt = scsi_softc[rzcontroller(dev)]->target[rzslave(dev)];
+
+	buf = tgt->dev_info.cdrom.result;
+	tgt->dev_info.cdrom.result_available = FALSE;
+
+	io_req_alloc(ior,0);		
+	zero_ior( ior );
+
+	switch (cmd[0]) {
+
+	    case 'E':
+	    		/* "Eject" */
+		/* too many dont support it. Sigh */
+		tgt->flags |= TGT_OPTIONAL_CMD;
+		(void) scsi_medium_removal( tgt, TRUE, ior);
+		tgt->flags &= ~TGT_OPTIONAL_CMD;
+
+		zero_ior( ior );
+
+		if_it_can_do(eject)
+			rc = scsi_start_unit(tgt, SCSI_CMD_SS_EJECT, ior);
+		break;
+
+	    case 'G':
+		switch (cmd[4]) {
+
+		    case 'P':
+	    		/* "Get Position MSF|ABS" */
+		      if_it_can_do(current_position) {
+			rc = scsi_read_subchannel(tgt,
+						  cmd[13] == 'M',
+						  SCSI_CMD_RS_FMT_CURPOS,
+						  0,
+						  ior);
+			if (rc == SCSI_RET_SUCCESS) {
+			    cdrom_chan_curpos_t	*st;
+			    st = (cdrom_chan_curpos_t *)tgt->cmd_ptr;
+			    if (cmd[13] == 'M')
+				sprintf(buf, "MSF Position %d %d %d %d %d %d",
+			    	      (integer_t)st->subQ.absolute_address.msf.minute,
+				      (integer_t)st->subQ.absolute_address.msf.second,
+				      (integer_t)st->subQ.absolute_address.msf.frame,
+				      (integer_t)st->subQ.relative_address.msf.minute,
+				      (integer_t)st->subQ.relative_address.msf.second,
+				      (integer_t)st->subQ.relative_address.msf.frame);
+			    else
+				sprintf(buf, "ABS Position %d %d", (integer_t)
+			    	      (st->subQ.absolute_address.lba.lba1<<24)+
+			    		(st->subQ.absolute_address.lba.lba2<<16)+
+			    		(st->subQ.absolute_address.lba.lba3<< 8)+
+			    		 st->subQ.absolute_address.lba.lba4,
+				       (integer_t)
+			    		(st->subQ.relative_address.lba.lba1<<24)+
+			    		(st->subQ.relative_address.lba.lba2<<16)+
+			    		(st->subQ.relative_address.lba.lba3<< 8)+
+			    		 st->subQ.relative_address.lba.lba4);
+			    tgt->dev_info.cdrom.result_available = TRUE;
+			}
+		      }
+			break;
+
+		    case 'T':
+	    		/* "Get TH" */
+			if_it_can_do(read_toc) {
+			    rc = scsi_read_toc(tgt, TRUE, 1, PAGE_SIZE, ior);
+			    if (rc == SCSI_RET_SUCCESS) {
+			      cdrom_toc_t *toc = (cdrom_toc_t *)tgt->cmd_ptr;
+			      sprintf(buf, "toc header: %d %d %d",
+					(toc->len1 << 8) + toc->len2,
+					toc->first_track,
+					toc->last_track);
+			      tgt->dev_info.cdrom.result_available = TRUE;
+			    }
+			}
+			break;
+
+		    case 'S':
+	    		/* "Get Status" */
+			if_it_can_do(get_status) {
+			    rc = scsi_read_subchannel(tgt,
+						      TRUE,
+						      SCSI_CMD_RS_FMT_CURPOS,
+						      0,
+						      ior);
+			    if (rc == SCSI_RET_SUCCESS) {
+				cdrom_chan_curpos_t *st;
+				st = (cdrom_chan_curpos_t *)tgt->cmd_ptr;
+				decode_status(buf, st->audio_status);
+			        tgt->dev_info.cdrom.result_available = TRUE;
+			    }
+			}
+			break;
+		}
+		break;
+
+	    case 'P':
+		switch (cmd[5]) {
+		    case 'A':
+	    		/* "Play A startM startS startF endM endS endF" */
+			if_it_can_do(play_msf) {
+
+				int sm, ss, sf, em, es, ef;
+
+				sscanf(&cmd[7], "%d %d %d %d %d %d",
+				       &sm, &ss, &sf, &em, &es, &ef);
+
+				rc = scsi_play_audio_msf(tgt,
+							 sm, ss, sf,
+							 em, es, ef,
+							 ior);
+			}
+			break;
+
+		    case 'T':
+	    		/* "Play TI startT startI endT endI" */
+			if_it_can_do(play_ti) {
+
+				int st, si, et, ei;
+
+				sscanf(&cmd[8], "%d %d %d %d",
+				       &st, &si, &et, &ei);
+
+				rc = scsi_play_audio_track_index(tgt,
+					st, si, et, ei, ior);
+			}
+			break;
+		}
+		break;
+
+	    case 'R':
+	    		/* "Resume" */
+		if_it_can_do(pause_resume)
+			rc = scsi_pause_resume(tgt, FALSE, ior);
+		break;
+
+	    case 'S':
+		switch (cmd[2]) {
+
+		    case 'a':
+	    		/* "Start" */
+			rc = scsi_start_unit(tgt, SCSI_CMD_SS_START, ior);
+			break;
+
+		    case 'o':
+	    		/* "Stop" */
+			if_it_can_do(pause_resume)
+				rc = scsi_pause_resume(tgt, TRUE, ior);
+			break;
+
+		    case 't':
+	    		/* "Set V chan0vol chan1vol chan2vol chan3vol" */
+			if_it_can_do(volume_control) {
+
+			    int v0, v1, v2, v3;
+			    cdrom_audio_page_t	au, *aup;
+
+			    rc = scsi_mode_sense(tgt,
+					SCSI_CD_AUDIO_PAGE,
+					sizeof(au),
+					ior);
+			    if (rc == SCSI_RET_SUCCESS) {
+
+				sscanf(&cmd[6], "%d %d %d %d",
+					&v0, &v1, &v2, &v3);
+
+				aup = (cdrom_audio_page_t *) tgt->cmd_ptr;
+				au = *aup;
+				/* au.h.bdesc ... */
+				au.vol0 = v0;
+				au.vol1 = v1;
+				au.vol2 = v2;
+				au.vol3 = v3;
+				au.imm = 1;
+				au.aprv = 0;
+
+				zero_ior( ior );
+
+				rc = scsi2_mode_select(tgt, FALSE,
+						&au, sizeof(au), ior);
+			    }
+			}
+			break;
+		}
+		break;
+
+	    case 'T':
+	    		/* "Toc MSF|ABS trackno" */
+		if_it_can_do(read_toc) {
+
+		    int t, m;
+
+		    sscanf(&cmd[8], "%d", &t);
+		    rc = scsi_read_toc( tgt, cmd[4]=='M', t, PAGE_SIZE, ior);
+
+		    if (rc == SCSI_RET_SUCCESS) {
+
+			cdrom_toc_t	*toc = (cdrom_toc_t *)tgt->cmd_ptr;
+
+			sprintf(buf, "TOC from track %d:\n", t);
+			m = (toc->len1 << 8) + toc->len2;
+			m -= 4; /* header */
+			for (t = 0; m > 0; t++, m -= sizeof(struct cdrom_toc_desc)) {
+			    buf += strlen(buf);
+			    if (cmd[4] == 'M')
+			      sprintf(buf, "%d %d %d %d %d %d\n",
+			    	toc->descs[t].control,
+			    	toc->descs[t].adr,
+			    	toc->descs[t].trackno,
+			    	(integer_t)toc->descs[t].absolute_address.msf.minute,
+			    	(integer_t)toc->descs[t].absolute_address.msf.second,
+			    	(integer_t)toc->descs[t].absolute_address.msf.frame);
+			    else
+			      sprintf(buf, "%d %d %d %d\n",
+			    	toc->descs[t].control,
+			    	toc->descs[t].adr,
+			    	toc->descs[t].trackno,
+			    	(toc->descs[t].absolute_address.lba.lba1<<24)+
+			    	(toc->descs[t].absolute_address.lba.lba2<<16)+
+			    	(toc->descs[t].absolute_address.lba.lba3<<8)+
+			    	 toc->descs[t].absolute_address.lba.lba4);
+			}
+			tgt->dev_info.cdrom.result_available = TRUE;
+		    }
+		}
+		break;
+	}
+
+	if (rc == SCSI_RET_SUCCESS)
+		ret = D_SUCCESS;
+
+	/* We are stateless, but.. */
+	if (rc == SCSI_RET_NEED_SENSE) {
+		zero_ior( ior );
+		tgt->ior = ior;
+		scsi_request_sense(tgt, ior, 0);
+		iowait(ior);
+		if (scsi_check_sense_data(tgt, tgt->cmd_ptr))
+			scsi_print_sense_data(tgt->cmd_ptr);
+	}
+
+	io_req_free(ior);
+	return ret;
+}
+
+private	char st_invalid [] = "Drive would not say";
+private	char st_playing [] = "Playing";
+private	char st_paused  [] = "Suspended";
+private	char st_complete[] = "Done playing";
+private	char st_error   [] = "Stopped in error";
+private	char st_nothing [] = "Idle";
+
+private void
+decode_status(
+	char		*buf,
+	unsigned char	audio_status)
+{
+    switch (audio_status) {
+	case SCSI_CDST_INVALID:
+		sprintf(buf, st_invalid); break;
+	case SCSI_CDST_PLAYING:
+		sprintf(buf, st_playing); break;
+	case SCSI_CDST_PAUSED:
+		sprintf(buf, st_paused); break;
+	case SCSI_CDST_COMPLETED:
+		sprintf(buf, st_complete); break;
+	case SCSI_CDST_ERROR:
+		sprintf(buf, st_error); break;
+	case SCSI_CDST_NO_STATUS:
+		sprintf(buf, st_nothing); break;
+    }
+}
+
+/* some vendor specific use this instead */
+private void
+decode_status_1(
+	char		*buf,
+	unsigned char	audio_status)
+{
+	switch (audio_status) {
+	    case 0:	sprintf(buf, st_playing ); break;
+	    case 1:
+	    case 2:	sprintf(buf, st_paused ); break;
+	    case 3:	sprintf(buf, st_complete ); break;
+	    default:
+		sprintf(buf, "Unknown status" ); break;
+	}
+}
+
+
+private void
+curse_the_vendor(
+	red_list_t	*list,
+	boolean_t	not_really)
+{
+	if (not_really) return;
+
+	printf("%s\n%s\n%s\n%s\n",
+		"The CDROM you use is not fully SCSI-2 compliant.",
+		"We invite You to contact Your vendor and ask",
+		"that they provide You with a firmware upgrade.",
+		"Here is a list of some known deficiencies");
+
+	printf("Vendor: %s Product: %s.. Revision: %s..\n",
+		list->vendor, list->product, list->rev);
+
+#define check(x,y,z) \
+	if (list->x) printf("Command code x%x %s not supported\n", y, z);
+
+	check(can_play_audio, SCSI_CMD_PLAY_AUDIO, "PLAY_AUDIO");
+	check(eject, SCSI_CMD_START_STOP_UNIT,
+		"START_STOP_UNIT, flag EJECT(0x2) in byte 5");
+	check(current_position, SCSI_CMD_READ_SUBCH, "READ_SUBCHANNEL");
+	check(read_toc, SCSI_CMD_READ_TOC, "READ_TOC");
+/*	check(get_status, ...); duplicate of current_position */
+	check(play_msf, SCSI_CMD_PLAY_AUDIO_MSF, "PLAY_AUDIO_MSF");
+	check(play_ti, SCSI_CMD_PLAY_AUDIO_TI, "PLAY_AUDIO_TRACK_INDEX");
+	check(pause_resume, SCSI_CMD_PAUSE_RESUME, "PAUSE_RESUME");
+	check(volume_control, SCSI_CMD_MODE_SELECT,
+		"MODE_SELECT, AUDIO page(0xe)");
+
+#undef	check
+	printf("Will work around these problems...\n");
+}
+
+/*
+ * Ancillaries
+ */
+cd_strategy(ior)
+	register io_req_t	ior;
+{
+	return rz_simpleq_strategy( ior, cd_start);
+}
+
+void cd_start( tgt, done)
+	target_info_t	*tgt;
+	boolean_t	done;
+{
+	io_req_t	ior;
+
+	ior = tgt->ior;
+	if (done && ior) {
+		tgt->ior = 0;
+		iodone(ior);
+		return;
+	}
+	panic("cd start"); /* uhu? */
+}
+
+/*
+ * When the hardware cannot
+ */
+private scsi_ret_t
+op_not_supported(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	/*
+	 * The command is not implemented, no way around it
+	 */
+	sprintf(tgt->dev_info.cdrom.result, unsupported);
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+/****************************************/
+/*	Vendor Specific Operations	*/
+/****************************************/
+
+	/*   DEC RRD42   */
+
+#define SCSI_CMD_DEC_SET_ADDRESS_FORMAT		0xc0
+#	define scsi_cmd_saf_fmt	scsi_cmd_xfer_len_2
+
+#define SCSI_CMD_DEC_PLAYBACK_STATUS		0xc4
+typedef struct {
+    unsigned char	xxx;
+    BITFIELD_2(unsigned char,
+    	is_msf: 1,
+	xxx1:   7);
+    unsigned char	data_len1;
+    unsigned char	data_len0;
+    unsigned char	audio_status;
+    BITFIELD_2(unsigned char,
+        control	: 4,
+	xxx2 : 4);
+    cdrom_addr_t address;
+    BITFIELD_2(unsigned char,
+        chan0_select : 4,
+	xxx3 : 4);
+    unsigned char	chan0_volume;
+    BITFIELD_2(unsigned char,
+        chan1_select : 4,
+	xxx4 : 4);
+    unsigned char	chan1_volume;
+    BITFIELD_2(unsigned char,
+        chan2_select : 4,
+	xxx5 : 4);
+    unsigned char	chan2_volume;
+    BITFIELD_2(unsigned char,
+        chan3_select : 4,
+	xxx6 : 4);
+    unsigned char	chan3_volume;
+} dec_playback_status_t;
+
+#define SCSI_CMD_DEC_PLAYBACK_CONTROL		0xc9
+typedef struct {
+    unsigned char	xxx0;
+    BITFIELD_2(unsigned char,
+        fmt  : 1,
+	xxx1 : 7);
+    unsigned char	xxx[8];
+    BITFIELD_2(unsigned char,
+        chan0_select : 4,
+	xxx3 : 4);
+    unsigned char	chan0_volume;
+    BITFIELD_2(unsigned char,
+        chan1_select : 4,
+	xxx4 : 4);
+    unsigned char	chan1_volume;
+    BITFIELD_2(unsigned char,
+        chan2_select : 4,
+	xxx5 : 4);
+    unsigned char	chan2_volume;
+    BITFIELD_2(unsigned char,
+        chan3_select : 4,
+	xxx6 : 4);
+    unsigned char	chan3_volume;
+} dec_playback_control_t;
+
+
+#if	0
+
+private scsi_ret_t
+rrd42_status(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_ret_t		rc;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_command_group_2	c;
+	dec_playback_status_t	*st;
+
+	/* We might have to specify addressing fmt */
+	if (cmd[4] == 'P') {
+		scsi_command_group_2 saf;
+
+		bzero(&saf, sizeof(saf));
+		saf.scsi_cmd_code = SCSI_CMD_DEC_SET_ADDRESS_FORMAT;
+		saf.scsi_cmd_saf_fmt = (cmd[13] == 'A') ? 0 : 1;
+
+		rc = cdrom_vendor_specific(tgt, &saf, 0, 0, 0, ior);
+
+		if (rc != SCSI_RET_SUCCESS) return rc;
+
+		zero_ior( ior );
+	}
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_DEC_PLAYBACK_STATUS;
+	c.scsi_cmd_xfer_len_2 = sizeof(*st);
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(*st), ior);
+
+	if (rc != SCSI_RET_SUCCESS) return rc;
+
+	st = (dec_playback_status_t *) tgt->cmd_ptr;
+
+	if (cmd[4] == 'S')
+		decode_status( buf, st->audio_status+0x11 );
+	else {
+		if (st->is_msf)
+		    sprintf(buf, "MSF Position %d %d %d",
+		    	(integer_t)st->address.msf.minute,
+		    	(integer_t)st->address.msf.second,
+		    	(integer_t)st->address.msf.frame);
+		else
+		    sprintf(buf, "ABS Position %d", (integer_t)
+		    	(st->address.lba.lba1<<24)+
+		    	(st->address.lba.lba2<<16)+
+		    	(st->address.lba.lba3<< 8)+
+		    	 st->address.lba.lba4);
+	}
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return rc;
+}
+#endif
+
+private scsi_ret_t
+rrd42_set_volume(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	dec_playback_control_t		req;
+	int				v0, v1, v2, v3;
+
+	sscanf(&cmd[6], "%d %d %d %d",	&v0, &v1, &v2, &v3);
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_DEC_PLAYBACK_CONTROL;
+	c.scsi_cmd_xfer_len_2 = sizeof(req);
+	bzero(&req, sizeof(req));
+	if (v0) {
+		req.chan0_select = 1;
+		req.chan0_volume = v0;
+	}
+	if (v1) {
+		req.chan1_select = 2;
+		req.chan1_volume = v1;
+	}
+	if (v2) {
+		req.chan2_select = 4;
+		req.chan2_volume = v2;
+	}
+	if (v3) {
+		req.chan3_select = 8;
+		req.chan3_volume = v3;
+	}
+	return cdrom_vendor_specific(tgt, &c, &req, sizeof(req), 0, ior);
+}
+
+	/* NEC CD-ROM */
+
+#define SCSI_CMD_NEC_READ_TOC           	0xde
+typedef struct {
+    unsigned char	xxx[9];
+    unsigned char	first_track;
+    unsigned char	xxx1[9];
+    unsigned char	last_track;
+    unsigned char	xxx2[9];
+    unsigned char	lead_out_addr[3];
+    struct {
+	BITFIELD_2(unsigned char,
+	    adr  : 4,
+	    ctrl : 4);
+	unsigned char	xxx3[6];
+	unsigned char	address[3];
+    } track_info[1]; /* VARSIZE */
+} nec_toc_data_t;
+
+#define SCSI_CMD_NEC_SEEK_TRK			0xd8
+#define SCSI_CMD_NEC_PLAY_AUDIO			0xd9
+#define SCSI_CMD_NEC_PAUSE			0xda
+#define	SCSI_CMD_NEC_EJECT			0xdc
+
+#define SCSI_CMD_NEC_READ_SUBCH_Q		0xdd
+typedef struct {
+    unsigned char	audio_status;	/* see decode_status_1 */
+    BITFIELD_2(unsigned char,
+        ctrl : 4,
+	xxx1 : 4);
+    unsigned char	trackno;
+    unsigned char	indexno;
+    unsigned char	relative_address[3];
+    unsigned char	absolute_address[3];
+} nec_subch_data_t;
+
+/*
+ * Reserved bits in byte1
+ */
+#define NEC_LR_PLAY_MODE	0x01	/* RelAdr bit overload */
+#define	NEC_LR_STEREO		0x02	/* mono/stereo */
+
+/*
+ * Vendor specific bits in the control byte.
+ * NEC uses them to specify the addressing mode
+ */
+#define NEC_CTRL_A_ABS		0x00	/* XXX not sure about this */
+#define NEC_CTRL_A_MSF		0x40	/* min/sec/frame */
+#define NEC_CTRL_A_TI		0x80	/* track/index */
+#define NEC_CTRL_A_CURRENT	0xc0	/* same as last specified */
+
+private scsi_ret_t
+nec_eject(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_NEC_EJECT;
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+private scsi_ret_t
+nec_subchannel(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	nec_subch_data_t	*st;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_ret_t		rc;
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_NEC_READ_SUBCH_Q;
+	c.scsi_cmd_lun_and_relbit = sizeof(*st);	/* Sic! */
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(*st), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+	
+	st = (nec_subch_data_t *) tgt->cmd_ptr;
+
+	/* Status or Position ? */
+
+	if (cmd[4] == 'S') {
+	    decode_status_1( buf, st->audio_status);
+	} else {
+
+	    /* XXX can it do ABS addressing e.g. 'logical' ? */
+
+	    sprintf(buf, "MSF Position %d %d %d %d %d %d",
+		    (integer_t)bcd_to_decimal(st->absolute_address[0]), /* min */
+		    (integer_t)bcd_to_decimal(st->absolute_address[1]), /* sec */
+		    (integer_t)bcd_to_decimal(st->absolute_address[2]), /* frm */
+		    (integer_t)bcd_to_decimal(st->relative_address[0]), /* min */
+		    (integer_t)bcd_to_decimal(st->relative_address[1]), /* sec */
+		    (integer_t)bcd_to_decimal(st->relative_address[2])); /* frm */
+	}
+
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+private scsi_ret_t
+nec_read_toc(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	nec_toc_data_t		*t;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_ret_t		rc;
+	int			first, last, i;
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_NEC_READ_TOC;
+	c.scsi_cmd_lun_and_relbit = NEC_LR_PLAY_MODE|NEC_LR_STEREO;
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, 512/*XXX*/, ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+	
+	t = (nec_toc_data_t *) tgt->cmd_ptr;
+
+	first = bcd_to_decimal(t->first_track);
+	last  = bcd_to_decimal(t->last_track);
+
+	/*
+	 * "Get TH" wants summary, "TOC MSF|ABS from_track" wants all
+	 */
+	if (cmd[0] == 'G') {
+	    sprintf(buf, "toc header: %d %d %d",
+		sizeof(*t) + sizeof(t->track_info) * (last - first - 1),
+		first, last);
+	    goto out;
+	}
+
+	/*
+	 * The whole shebang
+	 */
+	sscanf(&cmd[8], "%d", &i);
+	sprintf(buf, "TOC from track %d:\n", i);
+
+	last -= first;
+	i -= first;
+	while ((i >= 0) && (i <= last)) {
+	    buf += strlen(buf);
+	    if (cmd[4] == 'M')
+	      sprintf(buf, "%d %d %d %d %d %d\n",
+			t->track_info[i].ctrl,
+			t->track_info[i].adr,
+			first + i,
+			bcd_to_decimal(t->track_info[i].address[0]),
+			bcd_to_decimal(t->track_info[i].address[1]),
+			bcd_to_decimal(t->track_info[i].address[2]));
+	    else
+/* THIS IS WRONG */
+	      sprintf(buf, "%d %d %d %d\n",
+			t->track_info[i].ctrl,
+			t->track_info[i].adr,
+			first + i,
+			bcd_to_decimal(t->track_info[i].address[0]) * 10000 +
+			bcd_to_decimal(t->track_info[i].address[1]) * 100 +
+			bcd_to_decimal(t->track_info[i].address[2]));
+	    i++;
+	}
+	/* To know how long the last track is */
+	buf += strlen(buf);
+	if (cmd[4] == 'M')
+	  sprintf(buf, "%d %d %d %d %d %d\n",
+		  0, 1, 0xaa /* User expects this */,
+		  bcd_to_decimal(t->lead_out_addr[0]),
+		  bcd_to_decimal(t->lead_out_addr[1]),
+		  bcd_to_decimal(t->lead_out_addr[2]));
+	    else
+/* THIS IS WRONG */
+	  sprintf(buf, "%d %d %d %d\n",
+		  0, 1, 0xaa /* User expects this */,
+		  bcd_to_decimal(t->lead_out_addr[0]) * 10000 +
+		  bcd_to_decimal(t->lead_out_addr[1]) * 100 +
+		  bcd_to_decimal(t->lead_out_addr[2]));
+out:
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+
+private scsi_ret_t
+nec_play(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	int			sm, ss, sf, em, es, ef;
+	int			st, si, et, ei;
+	scsi_ret_t		rc;
+
+	/*
+	 * Seek to desired position
+	 */
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_NEC_SEEK_TRK;
+	c.scsi_cmd_lun_and_relbit = NEC_LR_PLAY_MODE;
+
+	/*
+	 * Play_msf or Play_ti
+	 */
+	if (cmd[5] == 'A') {
+		/* "Play A startM startS startF endM endS endF" */
+
+		sscanf(&cmd[7], "%d %d %d %d %d %d",
+		       &sm, &ss, &sf, &em, &es, &ef);
+
+		c.scsi_cmd_lba1 = decimal_to_bcd(sm);
+		c.scsi_cmd_lba2 = decimal_to_bcd(ss);
+		c.scsi_cmd_lba3 = decimal_to_bcd(sf);
+	        c.scsi_cmd_ctrl_byte = NEC_CTRL_A_MSF;
+
+	} else {
+		/* "Play TI startT startI endT endI" */
+
+		sscanf(&cmd[8], "%d %d %d %d", &st, &si, &et, &ei);
+
+		c.scsi_cmd_lba1 = decimal_to_bcd(st);
+		c.scsi_cmd_lba2 = decimal_to_bcd(si);
+		c.scsi_cmd_lba3 = 0;
+		c.scsi_cmd_ctrl_byte = NEC_CTRL_A_TI;
+
+	}
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+	
+	/*
+	 * Now ask it to play until..
+	 */
+	zero_ior( ior );
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_NEC_PLAY_AUDIO;
+	c.scsi_cmd_lun_and_relbit = NEC_LR_PLAY_MODE|NEC_LR_STEREO;
+
+	if (cmd[5] == 'A') {
+		c.scsi_cmd_lba1 = decimal_to_bcd(em);
+		c.scsi_cmd_lba2 = decimal_to_bcd(es);
+		c.scsi_cmd_lba3 = decimal_to_bcd(ef);
+		c.scsi_cmd_ctrl_byte = NEC_CTRL_A_MSF;
+	} else {
+		c.scsi_cmd_lba1 = decimal_to_bcd(et);
+		c.scsi_cmd_lba2 = decimal_to_bcd(ei);
+		c.scsi_cmd_lba3 = 0;
+		c.scsi_cmd_ctrl_byte = NEC_CTRL_A_TI;
+	}
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+private scsi_ret_t
+nec_pause_resume(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+
+	bzero(&c, sizeof(c));
+	/*
+	 * "Resume" or "Stop"
+	 */
+	if (cmd[0] == 'R') {
+	        c.scsi_cmd_code = SCSI_CMD_NEC_PLAY_AUDIO;
+	        c.scsi_cmd_lun_and_relbit = NEC_LR_PLAY_MODE|NEC_LR_STEREO;
+	        c.scsi_cmd_ctrl_byte = NEC_CTRL_A_CURRENT;
+	} else {
+	        c.scsi_cmd_code = SCSI_CMD_NEC_PAUSE;
+	}
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+	/* TOSHIBA CD-ROM DRIVE:XM 3232 */
+
+#define	SCSI_CMD_TOSHIBA_SEEK_TRK		0xc0
+#define	SCSI_CMD_TOSHIBA_PLAY_AUDIO		0xc1
+#define	SCSI_CMD_TOSHIBA_PAUSE_AUDIO		0xc2
+#define	SCSI_CMD_TOSHIBA_EJECT			0xc4
+
+#define	SCSI_CMD_TOSHIBA_READ_SUBCH_Q		0xc6
+typedef nec_subch_data_t toshiba_subch_data_t;
+/* audio status -> decode_status_1 */
+
+#define	SCSI_CMD_TOSHIBA_READ_TOC_ENTRY		0xc7
+typedef struct {
+    unsigned char       first_track;
+    unsigned char       last_track;
+    unsigned char       xxx[2];
+} toshiba_toc_header_t;
+typedef struct {
+    unsigned char       address[4];
+} toshiba_toc_data_t;
+
+
+private scsi_ret_t
+toshiba_eject(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_TOSHIBA_EJECT;
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+private scsi_ret_t
+toshiba_subchannel(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	toshiba_subch_data_t	*st;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_ret_t		rc;
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_TOSHIBA_READ_SUBCH_Q;
+	c.scsi_cmd_lun_and_relbit = sizeof(*st);	/* Sic! */
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(*st), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+	
+	st = (toshiba_subch_data_t *) tgt->cmd_ptr;
+
+	/* Status or Position ? */
+
+	if (cmd[4] == 'S') {
+	    decode_status_1( buf, st->audio_status);
+	} else {
+
+	    /* XXX can it do ABS addressing e.g. 'logical' ? */
+
+	    sprintf(buf, "MSF Position %d %d %d %d %d %d",
+		    (integer_t)bcd_to_decimal(st->absolute_address[0]), /* min */
+		    (integer_t)bcd_to_decimal(st->absolute_address[1]), /* sec */
+		    (integer_t)bcd_to_decimal(st->absolute_address[2]), /* frm */
+		    (integer_t)bcd_to_decimal(st->relative_address[0]), /* min */
+		    (integer_t)bcd_to_decimal(st->relative_address[1]), /* sec */
+		    (integer_t)bcd_to_decimal(st->relative_address[2])); /* frm */
+	}
+
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+private scsi_ret_t
+toshiba_read_toc(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	toshiba_toc_data_t	*t;
+	toshiba_toc_header_t	*th;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_ret_t		rc;
+	int			first, last, i;
+
+	/* TOC header first */
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_TOSHIBA_READ_TOC_ENTRY;
+	c.scsi_cmd_lun_and_relbit = 0;
+	c.scsi_cmd_lba1 = 0;
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(*th), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+	
+	th = (toshiba_toc_header_t *) tgt->cmd_ptr;
+
+	first = bcd_to_decimal(th->first_track);
+	last  = bcd_to_decimal(th->last_track);
+
+	/*
+	 * "Get TH" wants summary, "TOC MSF|ABS from_track" wants all
+	 */
+	if (cmd[0] == 'G') {
+	    sprintf(buf, "toc header: %d %d %d",
+		sizeof(*th) + sizeof(*t) * (last - first + 1),
+		first, last);
+	    goto out;
+	}
+
+	/*
+	 * The whole shebang
+	 */
+	sscanf(&cmd[8], "%d", &i);
+	sprintf(buf, "TOC from track %d:\n", i);
+
+	while (i <= last) {
+	    bzero(&c, sizeof(c));
+
+	    c.scsi_cmd_code = SCSI_CMD_TOSHIBA_READ_TOC_ENTRY;
+	    c.scsi_cmd_lun_and_relbit = 2;
+	    c.scsi_cmd_lba1 = decimal_to_bcd(i);
+
+	    zero_ior( ior );
+	    rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(*t), ior);
+	    if (rc != SCSI_RET_SUCCESS) break;
+	
+	    t = (toshiba_toc_data_t *) tgt->cmd_ptr;
+
+	    buf += strlen(buf);
+	    if (cmd[4] == 'M')
+	      sprintf(buf, "0 0 %d %d %d %d\n",
+			i,
+			bcd_to_decimal(t->address[0]),
+			bcd_to_decimal(t->address[1]),
+			bcd_to_decimal(t->address[2]));
+	    else
+/* THIS IS WRONG */
+	      sprintf(buf, "0 0 %d %d\n",
+			i,
+			bcd_to_decimal(t->address[0]) * 10000 +
+			bcd_to_decimal(t->address[1]) * 100 +
+			bcd_to_decimal(t->address[2]));
+	    i++;
+	}
+
+	/* Must simulate the lead-out track */
+	bzero(&c, sizeof(c));
+
+	c.scsi_cmd_code = SCSI_CMD_TOSHIBA_READ_TOC_ENTRY;
+	c.scsi_cmd_lun_and_relbit = 1;
+	c.scsi_cmd_lba1 = 0;
+
+	zero_ior( ior );
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(*t), ior);
+	if (rc != SCSI_RET_SUCCESS) goto out;
+	
+	t = (toshiba_toc_data_t *) tgt->cmd_ptr;
+
+	buf += strlen(buf);
+	if (cmd[4] == 'M')
+	  sprintf(buf, "0 0 %d %d %d %d\n",
+			i,
+			bcd_to_decimal(t->address[0]),
+			bcd_to_decimal(t->address[1]),
+			bcd_to_decimal(t->address[2]));
+	else
+/* THIS IS WRONG */
+	  sprintf(buf, "0 0 %d %d\n",
+			i,
+			bcd_to_decimal(t->address[0]) * 10000 +
+			bcd_to_decimal(t->address[1]) * 100 +
+			bcd_to_decimal(t->address[2]));
+	i++;
+
+out:
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+
+private scsi_ret_t
+toshiba_play(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	int			sm, ss, sf, em, es, ef;
+	int			st, si, et, ei;
+	scsi_ret_t		rc;
+
+	/*
+	 * Seek to desired position
+	 */
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_TOSHIBA_SEEK_TRK;
+
+	/*
+	 * Play_msf or Play_ti
+	 */
+	if (cmd[5] == 'A') {
+		/* "Play A startM startS startF endM endS endF" */
+
+		sscanf(&cmd[7], "%d %d %d %d %d %d",
+		       &sm, &ss, &sf, &em, &es, &ef);
+
+		c.scsi_cmd_lba1 = decimal_to_bcd(sm);
+		c.scsi_cmd_lba2 = decimal_to_bcd(ss);
+		c.scsi_cmd_lba3 = decimal_to_bcd(sf);
+	        c.scsi_cmd_ctrl_byte = NEC_CTRL_A_MSF;
+
+	} else {
+		/* "Play TI startT startI endT endI" */
+
+		sscanf(&cmd[8], "%d %d %d %d", &st, &si, &et, &ei);
+
+		c.scsi_cmd_lba1 = decimal_to_bcd(st);
+		c.scsi_cmd_lba2 = decimal_to_bcd(si);
+		c.scsi_cmd_lba3 = 0;
+		c.scsi_cmd_ctrl_byte = NEC_CTRL_A_TI;
+
+	}
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+	
+	/*
+	 * Now ask it to play until..
+	 */
+	zero_ior( ior );
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_TOSHIBA_PLAY_AUDIO;
+	c.scsi_cmd_lun_and_relbit = NEC_LR_PLAY_MODE|NEC_LR_STEREO;
+
+	if (cmd[5] == 'A') {
+		c.scsi_cmd_lba1 = decimal_to_bcd(em);
+		c.scsi_cmd_lba2 = decimal_to_bcd(es);
+		c.scsi_cmd_lba3 = decimal_to_bcd(ef);
+		c.scsi_cmd_ctrl_byte = NEC_CTRL_A_MSF;
+	} else {
+		c.scsi_cmd_lba1 = decimal_to_bcd(et);
+		c.scsi_cmd_lba2 = decimal_to_bcd(ei);
+		c.scsi_cmd_lba3 = 0;
+		c.scsi_cmd_ctrl_byte = NEC_CTRL_A_TI;
+	}
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+private scsi_ret_t
+toshiba_pause_resume(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+
+	bzero(&c, sizeof(c));
+	/*
+	 * "Resume" or "Stop"
+	 */
+	if (cmd[0] == 'R') {
+		/* ???? would have to remember last cmd ???? */
+/* broken ! */
+	        c.scsi_cmd_code = SCSI_CMD_TOSHIBA_PLAY_AUDIO;
+	        c.scsi_cmd_lun_and_relbit = NEC_LR_PLAY_MODE|NEC_LR_STEREO;
+	        c.scsi_cmd_ctrl_byte = NEC_CTRL_A_CURRENT;
+	} else {
+	        c.scsi_cmd_code = SCSI_CMD_TOSHIBA_PAUSE_AUDIO;
+	}
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+
+#if	0
+	/* I have info on these drives, but no drive to test */
+
+	/* PIONEER DRM-600 */
+
+#define SCSI_CMD_PIONEER_EJECT			0xc0
+
+#define SCSI_CMD_PIONEER_READ_TOC		0xc1
+typedef struct {
+	unsigned char	first_track;
+	unsigned char	last_track;
+	unsigned char	xxx[2];
+} pioneer_toc_hdr_t;
+typedef struct {
+	unsigned char	ctrl;
+	unsigned char	address[3];
+} pioneer_toc_info_t;
+
+#define SCSI_CMD_PIONEER_READ_SUBCH		0xc2
+typedef struct {
+    BITFIELD_2(unsigned char,
+        ctrl : 4,
+	xxx1 : 4);
+    unsigned char	trackno;
+    unsigned char	indexno;
+    unsigned char	relative_address[3];
+    unsigned char	absolute_address[3];
+} pioneer_subch_data_t;
+
+#define SCSI_CMD_PIONEER_SEEK_TRK		0xc8
+#define SCSI_CMD_PIONEER_PLAY_AUDIO		0xc9
+#define SCSI_CMD_PIONEER_PAUSE			0xca
+
+#define SCSI_CMD_PIONEER_AUDIO_STATUS		0xcc
+typedef struct {
+	unsigned char	audio_status;
+	unsigned char	xxx[5];
+} pioneer_status_t;
+
+/*
+ * Reserved bits in byte1
+ */
+#define PIONEER_LR_END_ADDR	0x10
+#define PIONEER_LR_PAUSE	0x10
+#define PIONEER_LR_RESUME	0x00
+
+/*
+ * Vendor specific bits in the control byte.
+ */
+#define PIONEER_CTRL_TH		0x00	/* TOC header */
+#define PIONEER_CTRL_TE		0x80	/* one TOC entry */
+#define PIONEER_CTRL_LO		0x40	/* lead-out track info */
+
+#define PIONEER_CTRL_A_MSF	0x40	/* min/sec/frame addr */
+
+private scsi_ret_t
+pioneer_eject(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+
+	bzero(&c, sizeof(c));
+        c.scsi_cmd_code = SCSI_CMD_PIONEER_EJECT;
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+private scsi_ret_t
+pioneer_position(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	scsi_ret_t		rc;
+	char			*buf = tgt->dev_info.cdrom.result;
+	pioneer_subch_data_t	*st;
+
+	bzero(&c, sizeof(c));
+        c.scsi_cmd_code = SCSI_CMD_PIONEER_READ_SUBCH;
+        c.scsi_cmd_xfer_len_2 = sizeof(pioneer_subch_data_t); /* 9 bytes */
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(pioneer_subch_data_t), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+
+	st = (pioneer_subch_data_t *) tgt->cmd_ptr;
+
+	/* XXX can it do ABS addressing e.g. 'logical' ? */
+
+	sprintf(buf, "MSF Position %d %d %d %d %d %d",
+		    (integer_t)bcd_to_decimal(st->absolute_address[0]), /* min */
+		    (integer_t)bcd_to_decimal(st->absolute_address[1]), /* sec */
+		    (integer_t)bcd_to_decimal(st->absolute_address[2]), /* frm */
+		    (integer_t)bcd_to_decimal(st->relative_address[0]), /* min */
+		    (integer_t)bcd_to_decimal(st->relative_address[1]), /* sec */
+		    (integer_t)bcd_to_decimal(st->relative_address[2])); /* frm */
+
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+private scsi_ret_t
+pioneer_toc(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	pioneer_toc_hdr_t	*th;
+	pioneer_toc_info_t	*t;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_ret_t		rc;
+	int			first, last, i;
+
+	/* Read header first */
+	bzero(&c, sizeof(c));
+        c.scsi_cmd_code = SCSI_CMD_PIONEER_READ_TOC;
+        c.scsi_cmd_xfer_len_2 = sizeof(pioneer_toc_hdr_t);
+        c.scsi_cmd_ctrl_byte = PIONEER_CTRL_TH;
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(pioneer_toc_hdr_t), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+
+	th = (pioneer_toc_hdr_t *)tgt->cmd_ptr;
+	first = bcd_to_decimal(th->first_track);
+	last = bcd_to_decimal(th->last_track);
+
+	/*
+	 * "Get TH" wants summary, "TOC MSF|ABS from_track" wants all
+	 */
+	if (cmd[0] == 'G') {
+	    sprintf(buf, "toc header: %d %d %d", 0, first, last);
+	    goto out;
+	}
+
+	/*
+	 * Must do it one track at a time
+	 */
+	sscanf(&cmd[8], "%d", &i);
+	sprintf(buf, "TOC from track %d:\n", i);
+
+	for ( ; i <= last; i++) {
+	    zero_ior(ior);
+	    bzero(&c, sizeof(c));
+	    c.scsi_cmd_code = SCSI_CMD_PIONEER_READ_TOC;
+	    c.scsi_cmd_lba4 = decimal_to_bcd(i);
+	    c.scsi_cmd_xfer_len_2 = sizeof(pioneer_toc_info_t);
+	    c.scsi_cmd_ctrl_byte = PIONEER_CTRL_TE;
+
+	    rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(pioneer_toc_info_t), ior);
+	    if (rc != SCSI_RET_SUCCESS) break;
+
+	    t = (pioneer_toc_info_t *)tgt->cmd_ptr;
+
+	    buf += strlen(buf);
+	    if (cmd[4] == 'M')
+	      sprintf(buf, "%d %d %d %d %d %d\n",
+			t->ctrl, 0, i,
+			bcd_to_decimal(t->address[0]),
+			bcd_to_decimal(t->address[1]),
+			bcd_to_decimal(t->address[2]));
+	    else
+/* THIS IS WRONG */
+	      sprintf(buf, "%d %d %d %d\n",
+			t->ctrl, 0, i,
+			bcd_to_decimal(t->address[0]) * 10000 +
+			bcd_to_decimal(t->address[1]) * 100 +
+			bcd_to_decimal(t->address[2]));
+	}
+	/* To know how long the last track is */
+	zero_ior(ior);
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_PIONEER_READ_TOC;
+	c.scsi_cmd_xfer_len_2 = sizeof(pioneer_toc_info_t);
+	c.scsi_cmd_ctrl_byte = PIONEER_CTRL_LO;
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(pioneer_toc_info_t), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+
+	buf += strlen(buf);
+	t = (pioneer_toc_info_t *)tgt->cmd_ptr;
+	if (cmd[4] == 'M')
+	      sprintf(buf, "%d %d %d %d %d %d\n",
+			t->ctrl, 0, 0xaa /* User expects this */,
+			bcd_to_decimal(t->address[0]),
+			bcd_to_decimal(t->address[1]),
+			bcd_to_decimal(t->address[2]));
+	else
+/* THIS IS WRONG */
+	      sprintf(buf, "%d %d %d %d\n",
+			t->ctrl, 0, 0xaa /* User expects this */,
+			bcd_to_decimal(t->address[0]) * 10000 +
+			bcd_to_decimal(t->address[1]) * 100 +
+			bcd_to_decimal(t->address[2]));
+
+out:
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+private scsi_ret_t
+pioneer_status(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	pioneer_status_t	*st;
+	char			*buf = tgt->dev_info.cdrom.result;
+	scsi_ret_t		rc;
+
+	bzero(&c, sizeof(c));
+        c.scsi_cmd_code = SCSI_CMD_PIONEER_AUDIO_STATUS;
+        c.scsi_cmd_xfer_len_2 = sizeof(pioneer_status_t); /* 6 bytes */
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, sizeof(pioneer_status_t), ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+
+	st = (pioneer_status_t*) tgt->cmd_ptr;
+	decode_status_1( buf, st->audio_status);
+
+	tgt->dev_info.cdrom.result_available = TRUE;
+	return SCSI_RET_SUCCESS;
+}
+
+private scsi_ret_t
+pioneer_play(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+	int			sm, ss, sf, em, es, ef;
+	int			st, si, et, ei;
+	scsi_ret_t		rc;
+
+	/*
+	 * Seek to desired position
+	 */
+	bzero(&c, sizeof(c));
+        c.scsi_cmd_code = SCSI_CMD_PIONEER_SEEK_TRK;
+	/*
+	 * Play_msf or Play_ti
+	 */
+	if (cmd[5] == 'A') {
+		/* "Play A startM startS startF endM endS endF" */
+
+		sscanf(&cmd[7], "%d %d %d %d %d %d",
+		       &sm, &ss, &sf, &em, &es, &ef);
+
+		c.scsi_cmd_lba2 = decimal_to_bcd(sm);
+		c.scsi_cmd_lba3 = decimal_to_bcd(ss);
+		c.scsi_cmd_lba4 = decimal_to_bcd(sf);
+	        c.scsi_cmd_ctrl_byte = PIONEER_CTRL_A_MSF;
+
+	} else {
+		/* "Play TI startT startI endT endI" */
+
+		sscanf(&cmd[8], "%d %d %d %d", &st, &si, &et, &ei);
+
+		c.scsi_cmd_lba3 = decimal_to_bcd(st);
+		c.scsi_cmd_lba4 = decimal_to_bcd(si);
+		c.scsi_cmd_ctrl_byte = 0x80;	/* Pure speculation!! */
+
+	}
+
+	rc = cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+	if (rc != SCSI_RET_SUCCESS) return rc;
+
+	/*
+	 * Now ask it to play until..
+	 */
+	zero_ior( ior );
+
+	bzero(&c, sizeof(c));
+	c.scsi_cmd_code = SCSI_CMD_PIONEER_PLAY_AUDIO;
+	c.scsi_cmd_lun_and_relbit = PIONEER_LR_END_ADDR;
+
+	if (cmd[5] == 'A') {
+		c.scsi_cmd_lba2 = decimal_to_bcd(em);
+		c.scsi_cmd_lba3 = decimal_to_bcd(es);
+		c.scsi_cmd_lba4 = decimal_to_bcd(ef);
+		c.scsi_cmd_ctrl_byte = PIONEER_CTRL_A_MSF;
+	} else {
+		c.scsi_cmd_lba3 = decimal_to_bcd(et);
+		c.scsi_cmd_lba4 = decimal_to_bcd(ei);
+		c.scsi_cmd_ctrl_byte = 0x80;	/* Pure speculation! */
+	}
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+private scsi_ret_t
+pioneer_pause_resume(
+	target_info_t	*tgt,
+	char		*cmd,
+	io_req_t	ior)
+{
+	scsi_command_group_2	c;
+
+	bzero(&c, sizeof(c));
+        c.scsi_cmd_code = SCSI_CMD_PIONEER_PAUSE;
+	/*
+	 * "Resume" or "Stop"
+	 */
+	if (cmd[0] == 'S')
+		c.scsi_cmd_lun_and_relbit = PIONEER_LR_PAUSE;
+	else
+		c.scsi_cmd_lun_and_relbit = PIONEER_LR_RESUME;
+
+	return cdrom_vendor_specific(tgt, &c, 0, 0, 0, ior);
+}
+
+	/* DENON DRD-253 */
+
+#define SCSI_CMD_DENON_PLAY_AUDIO		0x22
+#define SCSI_CMD_DENON_EJECT			0xe6
+#define SCSI_CMD_DENON_PAUSE_AUDIO		0xe7
+#define SCSI_CMD_DENON_READ_TOC			0xe9
+#define SCSI_CMD_DENON_READ_SUBCH		0xeb
+
+
+	/* HITACHI 1750 */
+
+#define SCSI_CMD_HITACHI_PLAY_AUDIO_MSF		0xe0
+#define SCSI_CMD_HITACHI_PAUSE_AUDIO		0xe1
+#define SCSI_CMD_HITACHI_EJECT			0xe4
+#define SCSI_CMD_HITACHI_READ_SUBCH		0xe5
+#define SCSI_CMD_HITACHI_READ_TOC		0xe8
+
+#endif
+
+/*
+ * Tabulate all of the above
+ */
+private red_list_t	cdrom_exceptions[] = {
+
+#if 0
+	For documentation purposes, here are some SCSI-2 compliant drives:
+
+	Vendor		Product			Rev	 Comments
+
+	"SONY    "	"CD-ROMCDU-541   "	"2.6a"	 The NeXT drive
+#endif
+
+	/* vendor, product, rev */
+	/* can_play_audio */
+	/* eject */
+	/* current_position */
+	/* read_toc */
+	/* get_status */
+	/* play_msf */
+	/* play_ti */
+	/* pause_resume */
+	/* volume_control */
+
+	  /* We have seen a "RRD42(C)DEC     " "4.5d" */
+	{ "DEC     ", "RRD42", "",
+	  0, 0, 0, 0, 0, 0, 0, 0, rrd42_set_volume },
+
+	  /* We have seen a "CD-ROM DRIVE:84 " "1.0 " */
+	{ "NEC     ", "CD-ROM DRIVE:84", "",
+	  op_not_supported, nec_eject, nec_subchannel, nec_read_toc,
+	  nec_subchannel, nec_play, nec_play, nec_pause_resume,
+	  op_not_supported },
+
+	  /* We have seen a "CD-ROM DRIVE:XM " "3232" */
+	{ "TOSHIBA ", "CD-ROM DRIVE:XM", "32",
+	  op_not_supported, toshiba_eject, toshiba_subchannel, toshiba_read_toc,
+	  toshiba_subchannel, toshiba_play, toshiba_play, toshiba_pause_resume,
+	  op_not_supported },
+
+	{ "TOSHIBA ", "CD-ROM DRIVE:XM", "33",
+	  op_not_supported, toshiba_eject, toshiba_subchannel, toshiba_read_toc,
+	  toshiba_subchannel, toshiba_play, toshiba_play, toshiba_pause_resume,
+	  op_not_supported },
+
+#if 0
+	{ "PIONEER ", "???????DRM-6", "",
+	  op_not_supported, pioneer_eject, pioneer_position, pioneer_toc,
+	  pioneer_status, pioneer_play, pioneer_play, pioneer_pause_resume,
+	  op_not_supported },
+
+	{ "DENON   ", "DRD 25X", "", ...},
+	{ "HITACHI ", "CDR 1750S", "", ...},
+	{ "HITACHI ", "CDR 1650S", "", ...},
+	{ "HITACHI ", "CDR 3650", "", ...},
+
+#endif
+
+	/* Zero terminate this list */
+	{ 0, }
+};
+
+private void
+check_red_list(
+	target_info_t		*tgt,
+	scsi2_inquiry_data_t	*inq)
+
+{
+	red_list_t		*list;
+
+	for (list = &cdrom_exceptions[0]; list->vendor; list++) {
+
+		/*
+		 * Prefix-Match all strings 
+		 */
+		if ((strncmp(list->vendor, (const char *)inq->vendor_id,
+				strlen(list->vendor)) == 0) &&
+		    (strncmp(list->product, (const char *)inq->product_id,
+				strlen(list->product)) == 0) &&
+		    (strncmp(list->rev, (const char *)inq->product_rev,
+				 strlen(list->rev)) == 0)) {
+			/*
+			 * One of them..
+			 */
+			if (tgt->dev_info.cdrom.violates_standards != list) {
+			    tgt->dev_info.cdrom.violates_standards = list;
+			    curse_the_vendor( list, TRUE );
+			}
+			return;
+		}
+	}
+}
+#endif  /* NSCSI > 0 */