path: root/scsi/rz_audio.c

/* 
 * 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 */