path: root/sys/scsi/worm.c

/*
 * worm: Write Once device driver
 *
 * Copyright (C) 1995, HD Associates, Inc.
 * PO Box 276
 * Pepperell, MA 01463
 * 508 433 5266
 * dufault@hda.com
 *
 * Copyright (C) 1996-97 interface business GmbH
 *   Naumannstr. 1
 *   D-01309 Dresden
 *   F.R. Germany
 * <joerg_wunsch@interface-business.de>
 *
 * This code is contributed to the University of California at Berkeley:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      $Id: worm.c,v 1.54 1998/04/15 17:47:24 bde Exp $
 */

#include "opt_bounce.h"
#include "opt_devfs.h"
#include "opt_scsi.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/cdio.h>
#include <sys/wormio.h>
#include <sys/fcntl.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#ifdef DEVFS
#include <sys/devfsext.h>
#endif /*DEVFS*/
#include <scsi/scsiconf.h>
#include <scsi/scsi_debug.h>
#include <scsi/scsi_disk.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_worm.h>
#include <scsi/scsi_cd.h>
#include <sys/dkstat.h>
#include <sys/malloc.h>

struct worm_quirks
{
	/*
	 * The device-specific functions that need to be called during
	 * the several steps.
	 */
	errval	(*prepare_disk)(struct scsi_link *, int dummy, int speed);
	errval	(*prepare_track)(struct scsi_link *, struct wormio_prepare_track *t);
	errval	(*finalize_track)(struct scsi_link *);
	errval	(*finalize_disk)(struct scsi_link *, int toc_type, int onp);
	errval	(*write_session)(struct scsi_link *, struct wormio_write_session *);
	errval	(*read_first_writable_address)(struct scsi_link *sc_link, 
			   int track, int mode, int raw, int audio, int *addr);
};


struct scsi_data
{
	struct buf_queue_head buf_queue;
	int dkunit;		/* disk stats unit number */
	u_int32_t blk_size;	/* Size of each blocks */
#ifdef	DEVFS
	void	*b_devfs_token;
	void	*c_devfs_token;
	void	*ctl_devfs_token;
#endif

	struct worm_quirks *quirks; /* model-specific functions */
	struct wormio_prepare_track preptrack; /* scratch region */
	struct wormio_write_session *write_session; /* scratch region */

	u_int8_t dummy;		/* use dummy writes */
	u_int8_t speed;		/* select drive speed */

	u_int32_t worm_flags;	/* driver-internal flags */
#define WORMFL_DISK_PREPED	0x01 /* disk parameters have been spec'ed */
#define WORMFL_TRACK_PREPED	0x02 /* track parameters have been sent */
#define WORMFL_WRITTEN		0x04 /* track has been written */
#define WORMFL_IOCTL_ONLY	0x08 /* O_NDELAY, only ioctls allowed */
#define WORMFL_TRACK_PREP  	0x10 /* track parameters have been spec'ed */

        int error;              /* last error */
};

static struct {
    int asc;
    int devmode;
    int error;
    int ret;
} worm_error[] = {
    {0x24, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_ABSORPTION_CONTROL_ERROR, 0},
    {0xb0, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_CALIBRATION_AREA_ALMOST_FULL, 0},
    {0xb4, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_CALIBRATION_AREA_FULL, SCSIRET_CONTINUE},
    {0xb5, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_DUMMY_BLOCKS_ADDED, 0},
    {0xaa, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_END_OF_MEDIUM, SCSIRET_CONTINUE},
    {0xad, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_BUFFER_UNDERRUN, SCSIRET_CONTINUE},
    {0xaf, WORM_Q_PLASMON|WORM_Q_PHILIPS, WORM_OPTIMUM_POWER_CALIBRATION_ERROR, SCSIRET_CONTINUE},
    {0, 0, 0, 0}
};

static void wormstart(u_int32_t unit, u_int32_t flags);

static errval worm_open(dev_t dev, int flags, int fmt, struct proc *p,
			struct scsi_link *sc_link);
static errval worm_ioctl(dev_t dev, int cmd, caddr_t addr, int flag,
			 struct proc *p, struct scsi_link *sc_link);
static errval worm_close(dev_t dev, int flag, int fmt, struct proc *p,
			 struct scsi_link *sc_link);
static void worm_strategy(struct buf *bp, struct scsi_link *sc_link);
static errval worm_read_toc(struct scsi_link *sc_link,
			    u_int32_t mode, u_int32_t start,
			    struct cd_toc_entry *data, u_int32_t len);
static errval worm_rezero_unit(struct scsi_link *sc_link);
static errval worm_read_session_info(struct scsi_link *, struct wormio_session_info *);
static int worm_sense_handler(struct scsi_xfer *);
static errval worm_set_blksize(struct scsi_link *sc_link, int size);

/* XXX should be moved out to an LKM */
static errval rf4100_prepare_disk(struct scsi_link *, int dummy, int speed);
static errval rf4100_prepare_track(struct scsi_link *, struct wormio_prepare_track *);
static errval rf4100_finalize_track(struct scsi_link *);
static errval rf4100_finalize_disk(struct scsi_link *, int toc_type, int onp);

static errval hp4020i_prepare_disk(struct scsi_link *, int dummy, int speed);
static errval hp4020i_prepare_track(struct scsi_link *, struct  wormio_prepare_track *);
static errval hp4020i_finalize_track(struct scsi_link *);
static errval hp4020i_finalize_disk(struct scsi_link *, int toc_type, int onp);
static errval hp4020i_write_session(struct scsi_link *, struct wormio_write_session *);
static errval hp4020i_read_first_writable_address (struct scsi_link *sc_link, 
			   int track, int mode, int raw, int audio, int *addr);

static worm_devsw_installed = 0;

static	d_open_t	wormopen;
static	d_close_t	wormclose;
static	d_ioctl_t	wormioctl;
static	d_strategy_t	wormstrategy;

#define CDEV_MAJOR 62
#define BDEV_MAJOR 23
static struct cdevsw worm_cdevsw;
static struct bdevsw worm_bdevsw = 
	{ wormopen,	wormclose,	wormstrategy,	wormioctl,	/*23*/
	  nodump,	nopsize,	D_DISK,	"worm",	&worm_cdevsw,	-1 };


static int
wormunit(dev_t dev)
{
	return (minor(dev) & ~(SCSI_FIXED_MASK|SCSI_CONTROL_MASK));
}

SCSI_DEVICE_ENTRIES(worm)

static struct scsi_device worm_switch =
{
	worm_sense_handler,
	wormstart,   /* we have a queue, and this is how we service it */
	NULL,
	NULL,
	"worm",
	0,
	{0, 0},
	SDEV_ONCE_ONLY,	/* Only one open allowed */
	wormattach,
	"Write-Once",
	wormopen,
	sizeof(struct scsi_data),
	T_WORM,
	wormunit,
	0,
	worm_open,
	worm_ioctl,
	worm_close,
	worm_strategy,
};

static struct worm_quirks worm_quirks_plasmon = {
    rf4100_prepare_disk, rf4100_prepare_track,
    rf4100_finalize_track, rf4100_finalize_disk,
    0, hp4020i_read_first_writable_address
};
static struct worm_quirks worm_quirks_philips = {
    hp4020i_prepare_disk, hp4020i_prepare_track,
    hp4020i_finalize_track, hp4020i_finalize_disk,
    hp4020i_write_session, hp4020i_read_first_writable_address
};

static __inline void
worm_registerdev(int unit)
{
	if (dk_ndrive < DK_NDRIVE) {
		sprintf(dk_names[dk_ndrive], "worm%d", unit);
		dk_wpms[dk_ndrive] = (1*1024*1024/2);	/* 1MB/sec XXX - fake! */
		SCSI_DATA(&worm_switch, unit)->dkunit = dk_ndrive++;
	} else {
		SCSI_DATA(&worm_switch, unit)->dkunit = -1;
	}
}

static errval
worm_size(struct scsi_link *sc_link, int flags)
{
	errval ret;
	struct scsi_data *worm = sc_link->sd;
	int blk_size;
	u_int32_t n_blks;

	SC_DEBUG(sc_link, SDEV_DB2, ("worm_size"));

	n_blks = scsi_read_capacity(sc_link, &blk_size, flags);

	/*
	 * CD-R devices can assume various sizes, depending on the
	 * intended purpose of the track.  Hence, READ CAPACITY
	 * doesn't give us any good results.  We make a more educated
	 * guess when it comes to prepare a track.
	 */

	if (n_blks > 0) {
		sc_link->flags |= SDEV_MEDIA_LOADED;
		ret = 0;
	} else {
		sc_link->flags &= ~SDEV_MEDIA_LOADED;
		ret = ENXIO;
	}

	return ret;
}

static errval
wormattach(struct scsi_link *sc_link)
{
	u_int32_t unit = sc_link->dev_unit;
#ifdef DEVFS
	int mynor;
#endif
	struct scsi_data *worm = sc_link->sd;

	if (sc_link->devmodes == 0)
		printf(", warning: unknown drive type", unit);

	bufq_init(&worm->buf_queue);

#ifdef DEVFS
	mynor = wormunit(sc_link->dev);
	worm->b_devfs_token =
		devfs_add_devswf(&worm_bdevsw, mynor,
				 DV_BLK, 0, 0, 0444, "worm%d", mynor);
	worm->c_devfs_token =
		devfs_add_devswf(&worm_cdevsw, mynor,
				 DV_CHR, 0, 0, 0644, "rworm%d", mynor);
	worm->ctl_devfs_token =
		devfs_add_devswf(&worm_cdevsw, mynor | SCSI_CONTROL_MASK,
				 DV_CHR, 0, 0, 0600, "rworm%d.ctl", mynor);
#endif
	worm_registerdev(unit);
	return 0;
}

/*
 * wormstart looks to see if there is a buf waiting for the device
 * and that the device is not already busy. If both are true,
 * It dequeues the buf and creates a scsi command to perform the
 * transfer required. The transfer request will call scsi_done
 * on completion, which will in turn call this routine again
 * so that the next queued transfer is performed.
 * The bufs are queued by the strategy routine (wormstrategy)
 *
 * This routine is also called after other non-queued requests
 * have been made of the scsi driver, to ensure that the queue
 * continues to be drained.
 * wormstart() is called at splbio
 *
 * XXX It looks like we need a "scsistart" to hoist common code up
 * into.  In particular, the removable media checking should be
 * handled in one place.
 *
 * Writes will fail if the disk and track not been prepared via the control
 * device.
 */
static void
wormstart(unit, flags)
	u_int32_t	unit;
	u_int32_t flags;
{
	struct scsi_link *sc_link = SCSI_LINK(&worm_switch, unit);
	struct scsi_data *worm = sc_link->sd;
	register struct buf *bp = 0;
	struct scsi_rw_big cmd;

	u_int32_t lba;  /* Logical block address */
	u_int32_t tl;		/* Transfer length */

	SC_DEBUG(sc_link, SDEV_DB2, ("wormstart "));

	/*
	 * We should reject all queued entries if SDEV_MEDIA_LOADED is not true.
	 */
	if (!(sc_link->flags & SDEV_MEDIA_LOADED)) {
		goto badnews;	/* no I/O.. media changed or something */
	}

	/*
	 * See if there is a buf to do and we are not already
	 * doing one
	 */
	while (sc_link->opennings != 0) {

		/* if a special awaits, let it proceed first */
		if (sc_link->flags & SDEV_WAITING) {
			sc_link->flags &= ~SDEV_WAITING;
			wakeup(sc_link);
			return;
		}

		bp = bufq_first(&worm->buf_queue);
		if (bp == NULL)
			return;

		bufq_remove(&worm->buf_queue, bp);

		if ((bp->b_flags & B_READ) == B_WRITE) {
		    if ((worm->worm_flags & WORMFL_TRACK_PREPED) == 0) {
			if ((worm->worm_flags & WORMFL_TRACK_PREP) == 0 &&
			    !worm->write_session) {
			    SC_DEBUG(sc_link, SDEV_DB3, ("sequence error\n"));
			    bp->b_error = EIO;
			    bp->b_flags |= B_ERROR;
			    worm->error = WORM_SEQUENCE_ERROR;
			    biodone(bp);
			    goto badnews;
			} else {
			    if (worm->write_session) {
				if ((worm->quirks->write_session)
				    (sc_link, worm->write_session)) {
				    biodone(bp);
				    goto badnews;
				}
			    } else
				if (worm->quirks->prepare_track(sc_link, &worm->preptrack)
				    != 0) {
				    biodone(bp);
				    goto badnews;
				}
			    worm->worm_flags |= WORMFL_TRACK_PREPED;
			}
		    }
		}
		/*
		 *  Fill out the scsi command
		 */
		bzero(&cmd, sizeof(cmd));
		if ((bp->b_flags & B_READ) == B_WRITE) {
			cmd.op_code = WRITE_BIG;
			flags |= SCSI_DATA_OUT;
		} else {
			cmd.op_code = READ_BIG;
			flags |= SCSI_DATA_IN;
		}

		worm->error = 0;

                lba = bp->b_blkno / (worm->blk_size / DEV_BSIZE);
		tl = bp->b_bcount / worm->blk_size;

		if (bp->b_flags & B_READ)
		    /*
		     * Leave the LBA as 0 for write operations, it
		     * is reserved in this case (and wouldn't make
		     * any sense to set it at all, since CD-R write
		     * operations are in `streaming' mode anyway.
		     */
		    scsi_uto4b(lba, &cmd.addr_3);
		scsi_uto2b(tl, &cmd.length2);

		/*
		 * go ask the adapter to do all this for us
		 */
		if (scsi_scsi_cmd(sc_link,
			(struct scsi_generic *) &cmd,
			sizeof(cmd),
			(u_char *) bp->b_data,
			bp->b_bcount,
			0,
			100000,
			bp,
			flags | SCSI_NOSLEEP) == SUCCESSFULLY_QUEUED) {
			if (worm->dkunit >= 0) {	/* Cloned from od.c, possibly with same mistakes. :) */
				dk_xfer[worm->dkunit]++;
				dk_seek[worm->dkunit] = 1; /* single track */
				dk_wds[worm->dkunit] += bp->b_bcount >> 6;
			}
			if ((bp->b_flags & B_READ) == B_WRITE)
				worm->worm_flags |= WORMFL_WRITTEN;
		} else {
			printf("worm%ld: oops not queued\n", unit);
			if (bp) {
				bp->b_flags |= B_ERROR;
				bp->b_error = EIO;
				biodone(bp);
			}
		}
	} /* go back and see if we can cram more work in.. */
badnews: ;
}

static void
worm_strategy(struct buf *bp, struct scsi_link *sc_link)
{
	unsigned char unit;
	u_int32_t opri;
	struct scsi_data *worm;

	unit = wormunit(bp->b_dev);
	worm = sc_link->sd;

	if ((worm->worm_flags & WORMFL_IOCTL_ONLY) != 0) {
		SC_DEBUG(sc_link, SDEV_DB3,
			 ("attempted IO on ioctl-only descriptor\n"));
		bp->b_error = EBADF;
		bp->b_flags |= B_ERROR;
		biodone(bp);
		return;
	}

	/*
	 * check it's not too big a transfer for our adapter
	 */
        wormminphys(bp);

	opri = splbio();

	/*
	 * Use a bounce buffer if necessary
	 * XXX: How can we move this up?
	 */
#ifdef BOUNCE_BUFFERS
	if (sc_link->flags & SDEV_BOUNCE)
		vm_bounce_alloc(bp);
#endif

	/*
	 * Place it in the queue of activities for this device
	 * at the end.
	 */
	bufq_insert_tail(&worm->buf_queue, bp);

	wormstart(unit, 0);

	splx(opri);
	return;
}

/*
 * Open the device.
 * Only called for the "real" device, not for the control device.
 */
static int
worm_open(dev_t dev, int flags, int fmt, struct proc *p,
	  struct scsi_link *sc_link)
{
	struct scsi_data *worm;
	errval error;

	error = 0;
	worm = sc_link->sd;

	if (sc_link->flags & SDEV_OPEN)
		return EBUSY;

	/*
	 * Unknown drive type: only the control device can be opened
	 * in this case, so scsi(8) and things like cdrecord will
	 * work.
	 */
	if (sc_link->devmodes == 0)
		return ENXIO;

	/*
	 * Check that it is still responding and ok.
	 * if the media has been changed this will result in a
	 * "unit attention" error which the error code will
	 * disregard because the SDEV_OPEN flag is not yet set
	 *
	 * XXX This should REALLY be hoisted up.  As soon as Bruce
	 * finishes that slice stuff. (Add a different flag,
	 * and then do a "scsi_test_unit_ready" with the "ignore
	 * unit attention" thing set.  Then all this replicated
	 * test unit ready code can be pulled up.
	 */
	scsi_test_unit_ready(sc_link, SCSI_SILENT);

	/*
	 * The semantics of the "flags" is as follows:
	 *
	 * If the device has been opened with O_NONBLOCK set, no
	 * actual IO will be allowed, and the command sequence is only
	 * subject to the restrictions as in worm_ioctl() below.
	 */
	/*
	 * Next time actually take notice of error returns,
	 * unit attn errors are now errors.
	 */
	sc_link->flags |= SDEV_OPEN;

	if (scsi_test_unit_ready(sc_link, SCSI_SILENT) != 0) {
		SC_DEBUG(sc_link, SDEV_DB3, ("not ready\n"));
		error = ENXIO;
		goto out;
	}

	if ((flags & O_NONBLOCK) == 0) {
		scsi_start_unit(sc_link, SCSI_SILENT);
		scsi_prevent(sc_link, PR_PREVENT, SCSI_SILENT);

		if((flags & FWRITE) != 0) {
			if ((error = worm_rezero_unit(sc_link)) != 0 ||
			    (error = worm_size(sc_link, 0)) != 0) {
				SC_DEBUG(sc_link, SDEV_DB3,
					 ("rezero, or get size failed\n"));
				error = EIO;
				goto out;
			}
		} else {
			/* read/only */
			if ((error = worm_size(sc_link, 0)) != 0) {
				SC_DEBUG(sc_link, SDEV_DB3,
					 ("get size failed\n"));
				error = EIO;
				goto out;
			}
			worm->blk_size = 2048;
		}
	} else
		worm->worm_flags |= WORMFL_IOCTL_ONLY;

	switch (*(int *) sc_link->devmodes) {
	case WORM_Q_PLASMON:
	    worm->quirks = &worm_quirks_plasmon;
	    break;
	case WORM_Q_PHILIPS:
	    worm->quirks = &worm_quirks_philips;
	    break;
	default:
	    error = ENXIO; 
	}
	worm->error = 0;

  out:
	if (error) {
	    scsi_prevent(sc_link, PR_ALLOW, SCSI_SILENT);
	    worm->worm_flags &= ~(WORMFL_TRACK_PREPED| WORMFL_TRACK_PREP);
	    sc_link->flags &= ~SDEV_OPEN;
	}

	return error;
}

static int
worm_close(dev_t dev, int flags, int fmt, struct proc *p,
	   struct scsi_link *sc_link)
{
	struct scsi_data *worm = sc_link->sd;
	errval error;

	error = 0;

	if ((worm->worm_flags & WORMFL_IOCTL_ONLY) == 0) {
		if ((flags & FWRITE) != 0) {
		    worm->error = 0;
		    if ((worm->worm_flags & WORMFL_TRACK_PREPED) != 0) {
			error = (worm->quirks->finalize_track)(sc_link);
		    	worm->worm_flags &=
			    ~(WORMFL_TRACK_PREPED | WORMFL_TRACK_PREP);
		    }
		}
		scsi_prevent(sc_link, PR_ALLOW, SCSI_SILENT);
	} else {
	    worm->worm_flags &= ~WORMFL_IOCTL_ONLY;
	    if (worm->write_session) {
#ifdef BOUNCE_BUFFERS
		vm_bounce_kva_alloc_free((vm_offset_t)worm->write_session,
		    btoc(sizeof(struct wormio_write_session) +
		    worm->write_session->length));
#else
		free(worm->write_session, M_DEVBUF);
#endif
		worm->write_session = 0;
	    }
	}
	sc_link->flags &= ~SDEV_OPEN;

	return error;
}

/*
 * Perform special action on behalf of the user.
 * Knows about the internals of this device
 */
errval
worm_ioctl(dev_t dev, int cmd, caddr_t addr, int flag, struct proc *p,
	   struct scsi_link *sc_link)
{
	errval  error = 0;
	u_int8_t  unit;
	register struct scsi_data *worm;

	/*
	 * Find the device that the user is talking about
	 */
	unit = wormunit(dev);
	worm = sc_link->sd;
	SC_DEBUG(sc_link, SDEV_DB2, ("wormioctl 0x%x ", cmd));

	switch (cmd) {
	case WORMIOCPREPDISK:
	{
	    struct wormio_prepare_disk *w =
		(struct wormio_prepare_disk *)addr;
	    if (w->dummy != 0 && w->dummy != 1)
		error = EINVAL;
	    else {
		error = (worm->quirks->prepare_disk)
		    (sc_link, w->dummy, w->speed);
		if (error == 0) {
		    worm->worm_flags |= WORMFL_DISK_PREPED;
		    worm->dummy = w->dummy;
		    worm->speed = w->speed;
		}
	    }
	}
	break;

	case WORMIOCPREPTRACK:
	{
	    struct wormio_prepare_track *w =
		(struct wormio_prepare_track *)addr;
	    if (w->audio != 0 && w->audio != 1)
		error = EINVAL;
	    else if (w->audio == 0 && w->preemp)
		error = EINVAL;
	    else if ((worm->worm_flags & WORMFL_DISK_PREPED)==0) {
		error = EINVAL;
		worm->error = WORM_SEQUENCE_ERROR;
	    } else {
		/*
		 * This sets a flag only.  Actual preparation of a
		 * track will be deferred up to the first write.
		 */
		worm->worm_flags |= WORMFL_TRACK_PREP;
		worm->preptrack = *w;
		if (worm->write_session) {
#ifdef BOUNCE_BUFFERS
		    vm_bounce_kva_alloc_free((vm_offset_t)worm->write_session,
			btoc(sizeof(struct wormio_write_session) +
			worm->write_session->length));
#else
		    free(worm->write_session, M_DEVBUF);
#endif
		    worm->write_session = 0;
		}
	    }
	}
	break;

	case WORMIOCFINISHTRACK:
	    if ((worm->worm_flags & WORMFL_TRACK_PREPED) != 0)
		error = (worm->quirks->finalize_track)(sc_link);
	    worm->worm_flags &= ~(WORMFL_TRACK_PREPED | WORMFL_TRACK_PREP);
	    break;

	case WORMIOCFIXATION:
	{
	    struct wormio_fixation *w =
		(struct wormio_fixation *)addr;
	    
	    if ((worm->worm_flags & WORMFL_WRITTEN) == 0)
		error = EINVAL;
	    else if (w->toc_type < WORM_TOC_TYPE_AUDIO ||
		     w->toc_type > WORM_TOC_TYPE_CDI)
		error = EINVAL;
	    else if (w->onp != 0 && w->onp != 1)
		error = EINVAL;
	    else {
		worm->worm_flags = 0;
		/* no fixation needed if dummy write */
		if (worm->dummy == 0) {
		    worm->error = 0;
		    error = (worm->quirks->finalize_disk)
			(sc_link, w->toc_type, w->onp);
		}
	    }
	}
	break;

	case WORMIOCREADSESSIONINFO:
	{
	    struct wormio_session_info si;
	    error = worm_read_session_info(sc_link, &si);
	    if (error)
		break;
	    NTOHS(si.lead_in);
	    NTOHS(si.lead_out);
	    bcopy(&si, addr, sizeof si);
	}
	break;

	case WORMIOCWRITESESSION:
	    if (worm->quirks->write_session) {
		if ((worm->worm_flags & WORMFL_DISK_PREPED)==0) {
		    error = EINVAL;
		    worm->error = WORM_SEQUENCE_ERROR;
		} else {
#ifdef BOUNCE_BUFFERS
		    worm->write_session = (struct wormio_write_session *)
		        vm_bounce_kva_alloc(
			btoc(sizeof(struct wormio_write_session) +
		    	((struct wormio_write_session *) addr)->length));
		    if (!worm->write_session) {
			error = ENOMEM;
			break;
		    }
#else
		    worm->write_session = malloc(sizeof(struct wormio_write_session) +
			       ((struct wormio_write_session *) addr)->length,
			       M_DEVBUF, M_WAITOK);
#endif
		    bcopy(addr, worm->write_session, sizeof(struct wormio_write_session));
		    worm->write_session->track_desc = sizeof(struct wormio_write_session) + 
			(u_char *) worm->write_session;
		    bcopy(((struct wormio_write_session *) addr)->track_desc, 
			  worm->write_session->track_desc, ((struct wormio_write_session *) addr)->length);
		}
	    } else
		error = ENXIO;
	    break;

	case WORMIOCFIRSTWRITABLEADDR:
	    if (worm->quirks->read_first_writable_address) {
		int address;
		struct wormio_first_writable_addr *a = 
		    (struct wormio_first_writable_addr *) addr;
		if ((a->audio & ~1) || (a->raw & ~1) || (a->mode & ~3)
		    || (a->track & ~0x7f)) {
		    error = EINVAL;
		    break;
		}
		error = worm->quirks->read_first_writable_address(sc_link, a->track,
							 a->mode, a->raw, 
							 a->audio, &address);
		if (error)
		    break;
		error = copyout(&address, a->addr, sizeof(int));
	    } else
		error = ENXIO;
	    break;

	case WORMIOERROR:
            bcopy(&(worm->error), addr, sizeof (int));
	    break;

	case CDIOREADTOCHEADER:
		{
			struct ioc_toc_header th;
			error = worm_read_toc(sc_link, 0, 0,
					      (struct cd_toc_entry *)&th,
					      sizeof th);
			if (error)
				break;
			NTOHS(th.len);
			bcopy(&th, addr, sizeof th);
		}
		break;

	case CDIOREADTOCENTRYS:
		{
			struct {
				struct ioc_toc_header header;
				struct cd_toc_entry entries[100];
			} data;
			struct {
				struct ioc_toc_header header;
				struct cd_toc_entry entry;
			} lead;
			struct ioc_read_toc_entry *te =
				(struct ioc_read_toc_entry *) addr;
			struct ioc_toc_header *th;
			u_int32_t len, readlen, idx, num;
			u_int32_t starting_track = te->starting_track;

			if (te->data_len < sizeof(struct cd_toc_entry)
			    || (te->data_len % sizeof(struct cd_toc_entry)) != 0
			    || te->address_format != CD_MSF_FORMAT
			    && te->address_format != CD_LBA_FORMAT) {
				error = EINVAL;
				break;
			}

			th = &data.header;
			error = worm_read_toc(sc_link, 0, 0,
					      (struct cd_toc_entry *)th,
					      sizeof (*th));
			if (error)
				break;

			if (starting_track == 0)
				starting_track = th->starting_track;
			else if (starting_track == 0xaa)
				starting_track = th->ending_track + 1;
			else if (starting_track < th->starting_track ||
				 starting_track > th->ending_track + 1) {
				error = EINVAL;
				break;
			}

			/* calculate reading length without leadout entry */
			readlen = (th->ending_track - starting_track + 1) *
				  sizeof(struct cd_toc_entry);

			/* and with leadout entry */
			len = readlen + sizeof(struct cd_toc_entry);
			if (te->data_len < len) {
				len = te->data_len;
				if (readlen > len)
					readlen = len;
			}
			if (len > sizeof(data.entries)) {
				error = EINVAL;
				break;
			}
			num = len / sizeof(struct cd_toc_entry);

			if (readlen > 0) {
				error = worm_read_toc(sc_link,
						      te->address_format,
						      starting_track,
						      (struct cd_toc_entry *)&data,
						      readlen + sizeof (*th));
				if (error)
					break;
			}

			/* make leadout entry if needed */
			idx = starting_track + num - 1;
			if (idx == th->ending_track + 1) {
				error = worm_read_toc(sc_link,
						      te->address_format, 0xaa,
						      (struct cd_toc_entry *)&lead,
						      sizeof(lead));
				if (error)
					break;
				data.entries[idx - starting_track] = lead.entry;
			}

			error = copyout(data.entries, te->data, len);
		}
		break;

	case CDIOREADTOCENTRY:
		{
			struct {
				struct ioc_toc_header header;
				struct cd_toc_entry entry;
			} data;
			struct ioc_read_toc_single_entry *te =
				(struct ioc_read_toc_single_entry *) addr;
			struct ioc_toc_header *th;
			u_int32_t track;

			if (te->address_format != CD_MSF_FORMAT
			    && te->address_format != CD_LBA_FORMAT) {
				error = EINVAL;
				break;
			}

			th = &data.header;
			error = worm_read_toc(sc_link, 0, 0,
					      (struct cd_toc_entry *)th,
					      sizeof (*th));
			if (error)
				break;

			track = te->track;
			if (track == 0)
				track = th->starting_track;
			else if (track == 0xaa)
				/* OK */;
			else if (track < th->starting_track ||
				 track > th->ending_track + 1) {
				error = EINVAL;
				break;
			}

			error = worm_read_toc(sc_link, te->address_format,
					      track,
					      (struct cd_toc_entry *)&data,
					      sizeof data);
			if (error)
				break;

			bcopy(&data.entry, &te->entry,
			      sizeof(struct cd_toc_entry));
		}
		break;
		
	default:
		error = ENOTTY;
		break;
	}
	return (error);
}


static errval
worm_rezero_unit(struct scsi_link *sc_link)
{
	struct scsi_rezero_unit cmd;
	
	SC_DEBUG(sc_link, SDEV_DB2, ("worm_rezero_unit"));

	/*
	 * Re-initialize the unit, just to be sure.
	 */
	bzero(&cmd, sizeof(cmd));
	cmd.op_code = REZERO_UNIT;
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     0,	/* no data transfer */
			     0,
			     /*WORMRETRY*/ 4,
			     5000,
			     NULL,
			     0);
}

static errval
worm_read_session_info(struct scsi_link *sc_link, struct wormio_session_info *data)
{
	struct scsi_read_session_info cmd;
	
	SC_DEBUG(sc_link, SDEV_DB2, ("worm_read_session_info"));

	bzero(&cmd, sizeof(cmd));
	cmd.op_code = READ_SESSION_INFO;
	cmd.transfer_length = sizeof(struct wormio_session_info);
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     (u_char *) data,
			     sizeof(struct wormio_session_info),
			     /*WORMRETRY*/ 4,
			     5000,
			     NULL,
			     SCSI_DATA_IN);
}

/*
 * Read table of contents
 *
 * Stolen from cd.c
 */
static errval
worm_read_toc(struct scsi_link *sc_link, u_int32_t mode, u_int32_t start,
	      struct cd_toc_entry *data, u_int32_t len)
{
	struct scsi_read_toc scsi_cmd;
	u_int32_t ntoc;

	bzero(&scsi_cmd, sizeof(scsi_cmd));
	ntoc = len;

	scsi_cmd.op_code = READ_TOC;
	if (mode == CD_MSF_FORMAT)
		scsi_cmd.byte2 |= CD_MSF;
	scsi_cmd.from_track = start;
	scsi_cmd.data_len[0] = (ntoc) >> 8;
	scsi_cmd.data_len[1] = (ntoc) & 0xff;
	return (scsi_scsi_cmd(sc_link,
			      (struct scsi_generic *) &scsi_cmd,
			      sizeof(struct scsi_read_toc),
			      (u_char *) data,
			      len,
			      /*WORMRETRY*/ 4,
			      5000,
			      NULL,
			      SCSI_DATA_IN));
}

static int
worm_sense_handler(struct scsi_xfer *xs)
{
    struct scsi_data *worm;
    struct scsi_sense_data *sense;
    struct scsi_sense_extended *ext;
    int asc, devmode, i;
   
    worm = xs->sc_link->sd;
    sense = &(xs->sense);
    ext = (struct scsi_sense_extended *) &(sense->ext.extended);
    asc = ext->add_sense_code;
    devmode = *(int *) xs->sc_link->devmodes;

    for (i = 0; worm_error[i].asc; i++)
	if ((asc == worm_error[i].asc) && (devmode & worm_error[i].devmode)) {
	    worm->error = worm_error[i].error;
	    return worm_error[i].ret;
	}
    worm->error = -1;
    return SCSIRET_CONTINUE;
}

static errval 
worm_set_blksize(struct scsi_link *sc_link, int size)
{
    struct scsi_mode_select scsi_cmd;
    struct {
	struct scsi_mode_header header;
	struct blk_desc desc;
    } dat;
    bzero(&scsi_cmd, sizeof(scsi_cmd));
    bzero(&dat, sizeof(dat));
    scsi_cmd.op_code = MODE_SELECT;
    scsi_cmd.length = sizeof(dat);
    dat.header.blk_desc_len = sizeof(struct blk_desc);
    scsi_uto3b(size, dat.desc.blklen);
    return scsi_scsi_cmd(sc_link,
			  (struct scsi_generic *) &scsi_cmd,
			  sizeof(scsi_cmd),
			  (u_char *) &dat,
			  sizeof(dat),
			  /*WORM_RETRIES*/ 4,
			  5000,
			  NULL,
			  SCSI_DATA_OUT);
}

static void
worm_drvinit(void *unused)
{

	if (!worm_devsw_installed) {
		bdevsw_add_generic(BDEV_MAJOR, CDEV_MAJOR, &worm_bdevsw);
		worm_devsw_installed = 1;
    	}
}

SYSINIT(wormdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,worm_drvinit,NULL)

/*
 * Begin device-specific stuff.  Subject to being moved out to LKMs.
 */

static u_char
ascii_to_6bit (char c)
{
    if (c < '0' || c > 'Z' || (c > '9' && c < 'A'))
	return 0;
    if (c <= '9')
	return c - '0';
    else
	return c - 'A' + 11;
}
/*
 * PLASMON RF4100/4102
 * Perhaps other Plasmon's, too.
 *
 * NB: By now, you'll certainly have to compare the SCSI reference
 * manual in order to understand the following.
 */

/* The following mode pages might apply to other drives as well. */

struct plasmon_rf4100_pages
{
	u_char	page_code;
#define RF4100_PAGE_CODE_20 0x20
#define RF4100_PAGE_CODE_21 0x21
#define RF4100_PAGE_CODE_22 0x22
#define RF4100_PAGE_CODE_23 0x23
#define RF4100_PAGE_CODE_24 0x24
#define RF4100_PAGE_CODE_25 0x25
	u_char	param_len;
	union
	{
		/* page 0x20 omitted by now */
		struct
		{
			u_char	reserved1;
			u_char	mode;
#define RF4100_RAW_MODE		0x10	/* raw mode enabled */
#define RF4100_MIXED_MODE	0x08	/* mixed mode data enabled */
#define RF4100_AUDIO_MODE	0x04	/* audio mode data enabled */
#define RF4100_MODE_1		0x01	/* mode 1 blocks are enabled */
#define RF4100_MODE_2		0x02	/* mode 2 blocks are enabled */
			u_char	track_number;
			u_char	isrc_i1; /* country code, ASCII */
			u_char	isrc_i2;
			u_char	isrc_i3; /* owner code, ASCII */
			u_char	isrc_i4;
			u_char	isrc_i5;
			u_char	isrc_i6_7; /* country code, BCD */
			u_char	isrc_i8_9; /* serial number, BCD */
			u_char	isrc_i10_11;
			u_char	isrc_i12_0;
			u_char	reserved2[2];
		}
		page_0x21;
		/* mode page 0x22 omitted by now */
		struct
		{
			u_char	speed_select;
#define RF4100_SPEED_AUDIO	0x01
#define RF4100_SPEED_DOUBLE	0x02
			u_char	dummy_write;
#define RF4100_DUMMY_WRITE	0x01
			u_char	reserved[4];
		}
		page_0x23;
		/* pages 0x24 and 0x25 omitted by now */
	}
	pages;
};


static errval
rf4100_prepare_disk(struct scsi_link *sc_link, int dummy, int speed)
{
	struct scsi_mode_select scsi_cmd;
	struct {
		struct scsi_mode_header header;
		struct plasmon_rf4100_pages page;
	} dat;
	u_int32_t pagelen, dat_len;

	pagelen = sizeof(dat.page.pages.page_0x23) + PAGE_HEADERLEN;
	dat_len = sizeof(struct scsi_mode_header) + pagelen;

	SC_DEBUG(sc_link, SDEV_DB2, ("rf4100_prepare_disk"));

	if (speed != RF4100_SPEED_AUDIO && speed != RF4100_SPEED_DOUBLE)
		return EINVAL;

	/*
	 * Set up a mode page 0x23
	 */
	bzero(&dat, sizeof(dat));
	bzero(&scsi_cmd, sizeof(scsi_cmd));
	scsi_cmd.op_code = MODE_SELECT;
	scsi_cmd.length = dat_len;
	/* dat.header.dev_spec = host application code; (see spec) */
	dat.page.page_code = RF4100_PAGE_CODE_23;
	dat.page.param_len = sizeof(dat.page.pages.page_0x23);
	dat.page.pages.page_0x23.speed_select = speed;
	dat.page.pages.page_0x23.dummy_write = dummy? RF4100_DUMMY_WRITE: 0;
	/*
	 * Fire it off.
	 */
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &scsi_cmd,
			     sizeof(scsi_cmd),
			     (u_char *) &dat,
			     dat_len,
			     /*WORM_RETRIES*/ 4,
			     5000,
			     NULL,
			     SCSI_DATA_OUT);
}


static errval
rf4100_prepare_track(struct scsi_link *sc_link, struct wormio_prepare_track *t)
{
	struct scsi_mode_select scsi_cmd;
	struct scsi_data *worm;
	struct {
		struct scsi_mode_header header;
		struct blk_desc blk_desc;
		struct plasmon_rf4100_pages page;
	} dat;
	u_int32_t pagelen, dat_len, blk_len;
	int year;

	worm = sc_link->sd;

	pagelen = sizeof(dat.page.pages.page_0x21) + PAGE_HEADERLEN;
	dat_len = sizeof(struct scsi_mode_header)
		+ sizeof(struct blk_desc)
		+ pagelen;

	SC_DEBUG(sc_link, SDEV_DB2, ("rf4100_prepare_track"));

	/*
	 * Set up a mode page 0x21.  Note that the block descriptor is
	 * mandatory in at least one of the MODE SELECT commands, in
	 * order to select the block length in question.  We do this
	 * here, just prior to opening the write channel.  (Spec:
	 * ``All information for the write is included in the MODE
	 * SELECT, MODE PAGE 21h, and the write channel can be
	 * considered open on receipt of the first WRITE command.''  I
	 * didn't have luck with an explicit WRITE TRACK command
	 * anyway, this might be different for other CD-R drives. -
	 * Jörg)
	 */
	bzero(&dat, sizeof(dat));
	bzero(&scsi_cmd, sizeof(scsi_cmd));
	scsi_cmd.op_code = MODE_SELECT;
	scsi_cmd.length = dat_len;
	dat.header.blk_desc_len = sizeof(struct blk_desc);
	dat.page.page_code = RF4100_PAGE_CODE_21;
	dat.page.param_len = sizeof(dat.page.pages.page_0x21);
	/* dat.header.dev_spec = host application code; (see spec) */
	if (t->audio) {
	    blk_len = 2352;
	    dat.page.pages.page_0x21.mode = RF4100_AUDIO_MODE + 
		(t->preemp? RF4100_MODE_1 : 0);
	} else
	    switch (t->track_type) {
	    case BLOCK_RAW: 
		blk_len = 2352;
		dat.page.pages.page_0x21.mode = RF4100_RAW_MODE;
		break;
	    case BLOCK_MODE_1: 
		blk_len = 2048;
		dat.page.pages.page_0x21.mode = RF4100_MODE_1;
		break;
	    case BLOCK_MODE_2: 
		blk_len = 2336; 
		dat.page.pages.page_0x21.mode = RF4100_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_1:
		blk_len = 2048;
		dat.page.pages.page_0x21.mode = RF4100_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_1b:
		blk_len = 2056;
		dat.page.pages.page_0x21.mode = RF4100_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_2:
		blk_len = 2324;
		dat.page.pages.page_0x21.mode = RF4100_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_2b:
		blk_len = 2332;
		dat.page.pages.page_0x21.mode = RF4100_MODE_2;
		break;
	    default:
		return EINVAL;
	    }
	dat.page.pages.page_0x21.mode |= t->copy_bits << 5;
	
	worm->blk_size = blk_len;

	dat.page.pages.page_0x21.track_number = t->track_number;

	dat.page.pages.page_0x21.isrc_i1 = ascii_to_6bit(t->ISRC_country[0]);
	dat.page.pages.page_0x21.isrc_i2 = ascii_to_6bit(t->ISRC_country[1]);
	dat.page.pages.page_0x21.isrc_i3 = ascii_to_6bit(t->ISRC_owner[0]);
	dat.page.pages.page_0x21.isrc_i4 = ascii_to_6bit(t->ISRC_owner[1]);
	dat.page.pages.page_0x21.isrc_i5 = ascii_to_6bit(t->ISRC_owner[2]);
	year = t->ISRC_year % 100;
	if (year < 0)
	    return EINVAL;
	dat.page.pages.page_0x21.isrc_i6_7 = bin2bcd(year);
	if (t->ISRC_serial[0]) {
	    dat.page.pages.page_0x21.isrc_i8_9 = ((t->ISRC_serial[0]-'0') << 4) |
		(t->ISRC_serial[1] - '0');
	    dat.page.pages.page_0x21.isrc_i10_11 = ((t->ISRC_serial[2]-'0') << 4) |
		(t->ISRC_serial[3] - '0');
	    dat.page.pages.page_0x21.isrc_i12_0 =  (t->ISRC_serial[4] - '0' << 4);
	}
	scsi_uto3b(blk_len, dat.blk_desc.blklen);

	/*
	 * Fire it off.
	 */
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &scsi_cmd,
			     sizeof(scsi_cmd),
			     (u_char *) &dat,
			     dat_len,
			     /*WORM_RETRIES*/ 4,
			     5000,
			     NULL,
			     SCSI_DATA_OUT);
}


static errval
rf4100_finalize_track(struct scsi_link *sc_link)
{
	struct scsi_synchronize_cache cmd;
	int error;

	SC_DEBUG(sc_link, SDEV_DB2, ("rf4100_finalize_track"));

	/*
	 * Only a "synchronize cache" is needed.
	 */
	bzero(&cmd, sizeof(cmd));
	cmd.op_code = SYNCHRONIZE_CACHE;
	error = scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     0,	/* no data transfer */
			     0,
			     1,
			     60000, /* this may take a while */
			     NULL,
			     0);
	if (!error) 
	    error = worm_set_blksize(sc_link, 2048);

	return error;
}


static errval
rf4100_finalize_disk(struct scsi_link *sc_link, int toc_type, int onp)
{
	struct scsi_fixation cmd;

	SC_DEBUG(sc_link, SDEV_DB2, ("rf4100_finalize_disk"));

	if (toc_type < 0 || toc_type > WORM_TOC_TYPE_CDI)
		return EINVAL;

	/*
	 * Fixate this session.  Mark the next one as opened if onp
	 * is true.  Otherwise, the disk will be finalized once and
	 * for all.  ONP stands for "open next program area".
	 */
	
	bzero(&cmd, sizeof(cmd));
	cmd.op_code = FIXATION;
	cmd.action = (onp? WORM_FIXATION_ONP: 0) + toc_type;
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     0,	/* no data transfer */
			     0,
			     1,
			     20*60*1000, /* takes a huge amount of time */
			     NULL,
			     0);
}

/*
 * End Plasmon RF4100/4102 section.
 */

/*
 * HP C4324/C4325 (This is what the scsi spec. and firmware says) 
 * Drive model 4020i
 *  This is very similar to the Plasmon above.
 */

/* The following mode pages might apply to other drives as well. */

struct hp_4020i_pages
{
	u_char	page_code;
#define HP4020I_PAGE_CODE_20 0x20
#define HP4020I_PAGE_CODE_21 0x21
#define HP4020I_PAGE_CODE_22 0x22
#define HP4020I_PAGE_CODE_23 0x23
#define HP4020I_PAGE_CODE_24 0x24
#define HP4020I_PAGE_CODE_25 0x25
	u_char	param_len;
	union
	{
		/* page 0x20 omitted by now */
		struct
		{
			u_char	reserved1;
			u_char	mode;
#define HP4020I_RAW_MODE		0x10	/* raw mode enabled */
#define HP4020I_MIXED_MODE	0x08	/* mixed mode data enabled */
#define HP4020I_AUDIO_MODE	0x04	/* audio mode data enabled */
#define HP4020I_MODE_1		0x01	/* mode 1 blocks are enabled */
#define HP4020I_MODE_2		0x02	/* mode 2 blocks are enabled */
			u_char	track_number;
			u_char	isrc_i1; /* country code, ASCII */
			u_char	isrc_i2;
			u_char	isrc_i3; /* owner code, ASCII */
			u_char	isrc_i4;
			u_char	isrc_i5;
			u_char	isrc_i6_7; /* year code, BCD */
			u_char	isrc_i8_9; /* serial number, BCD */
			u_char	isrc_i10_11;
			u_char	isrc_i12_0;
			u_char	reserved2[2];
		}
		page_0x21;
		struct
		{
			u_char	catalog_valid;
			u_char	catalog_c1_c2; /* catalog number, BCD */
			u_char	catalog_c3_c4;
			u_char	catalog_c5_c6;
			u_char	catalog_c7_c8;
			u_char	catalog_c9_c10;
			u_char	catalog_c11_c12;
			u_char	catalog_c13_0;
		} page_0x22;
		struct
		{
			u_char	speed_select;
#define HP4020I_SPEED_AUDIO	0x01
#define HP4020I_SPEED_DOUBLE	0x02
			u_char	dummy_write;
#define HP4020I_DUMMY_WRITE	0x01
			u_char	reserved[4];
		}
		page_0x23;
		/* pages 0x24 and 0x25 omitted by now */
	}
	pages;
};

static errval
hp4020i_prepare_disk(struct scsi_link *sc_link, int dummy, int speed)
{
	struct scsi_mode_select scsi_cmd;
	struct {
		struct scsi_mode_header header;
		struct hp_4020i_pages page;
	} dat;
	u_int32_t pagelen, dat_len;

	pagelen = sizeof(dat.page.pages.page_0x23) + PAGE_HEADERLEN;
	dat_len = sizeof(struct scsi_mode_header) + pagelen;

	SC_DEBUG(sc_link, SDEV_DB2, ("hp4020i_prepare_disk"));

	if (speed != HP4020I_SPEED_AUDIO && speed != HP4020I_SPEED_DOUBLE)
		return EINVAL;

	/*
	 * Set up a mode page 0x23
	 */
	bzero(&dat, sizeof(dat));
	bzero(&scsi_cmd, sizeof(scsi_cmd));
	scsi_cmd.op_code = MODE_SELECT;
	scsi_cmd.byte2 |= SMS_PF;
	scsi_cmd.length = dat_len;
	/* dat.header.dev_spec = host application code; (see spec) */
	dat.page.page_code = HP4020I_PAGE_CODE_23;
	dat.page.param_len = sizeof(dat.page.pages.page_0x23);
	dat.page.pages.page_0x23.speed_select = speed;
	dat.page.pages.page_0x23.dummy_write = dummy? HP4020I_DUMMY_WRITE: 0;
	/*
	 * Fire it off.
	 */
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &scsi_cmd,
			     sizeof(scsi_cmd),
			     (u_char *) &dat,
			     dat_len,
			     /*WORM_RETRIES*/ 4,
			     5000,
			     NULL,
			     SCSI_DATA_OUT);
}


static errval
hp4020i_prepare_track(struct scsi_link *sc_link, struct wormio_prepare_track *t)
{
	struct scsi_mode_select scsi_cmd;
	struct scsi_data *worm;
	struct {
		struct scsi_mode_header header;
		struct blk_desc blk_desc;
		struct hp_4020i_pages page;
	} dat;
	u_int32_t pagelen, dat_len, blk_len;
	int year;

	worm = sc_link->sd;

	pagelen = sizeof(dat.page.pages.page_0x21) + PAGE_HEADERLEN;
	dat_len = sizeof(struct scsi_mode_header)
		+ sizeof(struct blk_desc)
		+ pagelen;

	SC_DEBUG(sc_link, SDEV_DB2, ("hp4020i_prepare_track"));


	/*
	 * Set up a mode page 0x21.  Note that the block descriptor is
	 * mandatory in at least one of the MODE SELECT commands, in
	 * order to select the block length in question.  We do this
	 * here, just prior to opening the write channel.  (Spec:
	 * ``All information for the write is included in the MODE
	 * SELECT, MODE PAGE 21h, and the write channel can be
	 * considered open on receipt of the first WRITE command.''  I
	 * didn't have luck with an explicit WRITE TRACK command
	 * anyway, this might be different for other CD-R drives. -
	 * Jörg)
	 */
	bzero(&dat, sizeof(dat));
	bzero(&scsi_cmd, sizeof(scsi_cmd));
	scsi_cmd.op_code = MODE_SELECT;
	scsi_cmd.byte2 |= SMS_PF;
	scsi_cmd.length = dat_len;
	dat.header.blk_desc_len = sizeof(struct blk_desc);
	dat.page.page_code = HP4020I_PAGE_CODE_21;
	dat.page.param_len = sizeof(dat.page.pages.page_0x21);
	/* dat.header.dev_spec = host application code; (see spec) */
	if (t->audio) {
	    blk_len = 2352;
	    dat.page.pages.page_0x21.mode = HP4020I_AUDIO_MODE + 
		(t->preemp? HP4020I_MODE_1 : 0);
	} else
	    switch (t->track_type) {
	    case BLOCK_RAW: 
		blk_len = 2352;
		dat.page.pages.page_0x21.mode = HP4020I_RAW_MODE;
		break;
	    case BLOCK_MODE_1: 
		blk_len = 2048;
		dat.page.pages.page_0x21.mode = HP4020I_MODE_1;
		break;
	    case BLOCK_MODE_2: 
		blk_len = 2336; 
		dat.page.pages.page_0x21.mode = HP4020I_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_1:
		blk_len = 2048;
		dat.page.pages.page_0x21.mode = HP4020I_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_1b:
		blk_len = 2056;
		dat.page.pages.page_0x21.mode = HP4020I_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_2:
		blk_len = 2324;
		dat.page.pages.page_0x21.mode = HP4020I_MODE_2;
		break;
	    case BLOCK_MODE_2_FORM_2b:
		blk_len = 2332;
		dat.page.pages.page_0x21.mode = HP4020I_MODE_2;
		break;
	    default:
		return EINVAL;
	    }
	dat.page.pages.page_0x21.mode |= t->copy_bits << 5;
	
	worm->blk_size = blk_len;

	dat.page.pages.page_0x21.track_number = t->track_number;

	dat.page.pages.page_0x21.isrc_i1 = ascii_to_6bit(t->ISRC_country[0]);
	dat.page.pages.page_0x21.isrc_i2 = ascii_to_6bit(t->ISRC_country[1]);
	dat.page.pages.page_0x21.isrc_i3 = ascii_to_6bit(t->ISRC_owner[0]);
	dat.page.pages.page_0x21.isrc_i4 = ascii_to_6bit(t->ISRC_owner[1]);
	dat.page.pages.page_0x21.isrc_i5 = ascii_to_6bit(t->ISRC_owner[2]);
	year = t->ISRC_year % 100;
	if (year < 0)
	    return EINVAL;
	dat.page.pages.page_0x21.isrc_i6_7 = bin2bcd(year);
	if (t->ISRC_serial[0]) {
	    dat.page.pages.page_0x21.isrc_i8_9 = ((t->ISRC_serial[0]-'0') << 4) |
		(t->ISRC_serial[1] - '0');
	    dat.page.pages.page_0x21.isrc_i10_11 = ((t->ISRC_serial[2]-'0') << 4) |
		(t->ISRC_serial[3] - '0');
	    dat.page.pages.page_0x21.isrc_i12_0 =  (t->ISRC_serial[4] - '0' << 4);
	}

	scsi_uto3b(blk_len, dat.blk_desc.blklen);
	
	/*
	 * Fire it off.
	 */
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &scsi_cmd,
			     sizeof(scsi_cmd),
			     (u_char *) &dat,
			     dat_len,
			     /*WORM_RETRIES*/ 4,
			     5000,
			     NULL,
			     SCSI_DATA_OUT);
}


static errval
hp4020i_finalize_track(struct scsi_link *sc_link)
{
	struct scsi_synchronize_cache cmd;
	int error;

	SC_DEBUG(sc_link, SDEV_DB2, ("hp4020i_finalize_track"));

	/*
	 * Only a "synchronize cache" is needed.
	 */
	bzero(&cmd, sizeof(cmd));
	cmd.op_code = SYNCHRONIZE_CACHE;
	error = scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     0,	/* no data transfer */
			     0,
			     1,
			     60000, /* this may take a while */
			     NULL,
			     0);
	if (!error) 
	    error = worm_set_blksize(sc_link, 2048);

	return error;
}


static errval
hp4020i_finalize_disk(struct scsi_link *sc_link, int toc_type, int onp)
{
	struct scsi_fixation cmd;

	SC_DEBUG(sc_link, SDEV_DB2, ("hp4020i_finalize_disk"));

	if (toc_type < 0 || toc_type > WORM_TOC_TYPE_CDI)
		return EINVAL;

	/*
	 * Fixate this session.  Mark the next one as opened if onp
	 * is true.  Otherwise, the disk will be finalized once and
	 * for all.  ONP stands for "open next program area".
	 */
	
	bzero(&cmd, sizeof(cmd));
	cmd.op_code = FIXATION;
	cmd.action = (onp? WORM_FIXATION_ONP: 0) + toc_type;
	return scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     0,	/* no data transfer */
			     0,
			     1,
			     20*60*1000, /* takes a huge amount of time */
			     NULL,
			     0);
}
static errval
hp4020i_write_session(struct scsi_link *sc_link, struct wormio_write_session *ws)
{
    struct {
	struct scsi_mode_header header;
	struct blk_desc blk_desc;
	struct hp_4020i_pages page;
	} dat;
    struct scsi_mode_select cmd1;
    struct scsi_write_session cmd2;
    struct scsi_data *worm;
    u_int32_t pagelen, dat_len, blk_len;
    errval error;

    SC_DEBUG(sc_link, SDEV_DB2, ("hp4020i_write_session"));

    if (ws->toc_type < 0 || ws->toc_type > WORM_TOC_TYPE_CDI || ws->lofp & ~3)
	return EINVAL;

    pagelen = sizeof(dat.page.pages.page_0x22) + PAGE_HEADERLEN;
    dat_len = sizeof(struct scsi_mode_header)
	+ sizeof(struct blk_desc)
	+ pagelen;

    worm = sc_link->sd;

    /* set the block size to 2352 and the catalog */
    bzero(&dat, sizeof(dat));
    bzero(&cmd1, sizeof(cmd1));
    cmd1.op_code = MODE_SELECT;
    cmd1.byte2 |= SMS_PF;
    cmd1.length = dat_len;
    dat.header.blk_desc_len = sizeof(struct blk_desc);
    dat.page.page_code = HP4020I_PAGE_CODE_22;
    dat.page.param_len = sizeof(dat.page.pages.page_0x22);
    blk_len = 2352;
    if (ws->catalog[0] >= '0' && ws->catalog[0] <= '9') {
	dat.page.pages.page_0x22.catalog_valid = 1;
	dat.page.pages.page_0x22.catalog_c1_c2 = ((ws->catalog[0]-'0') << 4)
	    | ((ws->catalog[1]-'0') << 4);
	dat.page.pages.page_0x22.catalog_c3_c4 = ((ws->catalog[2]-'0') << 4)
	    | ((ws->catalog[3]-'0') << 4);
	dat.page.pages.page_0x22.catalog_c5_c6 = ((ws->catalog[4]-'0') << 4)
	    | ((ws->catalog[5]-'0') << 4);
	dat.page.pages.page_0x22.catalog_c7_c8 = ((ws->catalog[6]-'0') << 4)
	    | ((ws->catalog[7]-'0') << 4);
	dat.page.pages.page_0x22.catalog_c9_c10 = ((ws->catalog[8]-'0') << 4)
	    | ((ws->catalog[9]-'0') << 4);
	dat.page.pages.page_0x22.catalog_c11_c12 = ((ws->catalog[10]-'0') << 4)
	    | ((ws->catalog[11]-'0') << 4);
	dat.page.pages.page_0x22.catalog_c13_0 = ((ws->catalog[12]-'0') << 4);
    }
    scsi_uto3b(blk_len, dat.blk_desc.blklen);
	
    error = scsi_scsi_cmd(sc_link,
			  (struct scsi_generic *) &cmd1,
			  sizeof(cmd1),
			  (u_char *) &dat,
			  dat_len,
			  /*WORM_RETRIES*/ 4,
			  5000,
			  NULL,
			  SCSI_DATA_OUT);

    if (!error) {
	worm->blk_size = blk_len;
	bzero(&cmd2, sizeof(cmd2));
	cmd2.op_code = WRITE_SESSION;
	cmd2.action = (ws->lofp << 4) | (ws->onp? WORM_FIXATION_ONP: 0) + ws->toc_type;
	scsi_uto2b(ws->length, &cmd2.transfer_length_2);

	error = scsi_scsi_cmd(sc_link,
			      (struct scsi_generic *) &cmd2,
			      sizeof(cmd2),
			      ws->track_desc,
			      ws->length,
			      1,
			      5000,
			      NULL,
			      SCSI_DATA_OUT);
    }
    return error;
}

static errval 
hp4020i_read_first_writable_address (struct scsi_link *sc_link,
			  int track, int mode, int raw, int audio, int *addr)
{
	struct scsi_first_writable_address cmd;
	char data[6];
	errval error;

	SC_DEBUG(sc_link, SDEV_DB2, ("worm_read_first_writable_address"));

	bzero(&cmd, sizeof(cmd));
	cmd.op_code = FIRST_WRITEABLE_ADDR;
	cmd.track_number = track;
	cmd.mode = (raw << 3) | (audio << 2) | mode;
	cmd.transfer_length = sizeof(data);
	error = scsi_scsi_cmd(sc_link,
			     (struct scsi_generic *) &cmd,
			     sizeof(cmd),
			     (u_char *) data,
			     sizeof(data),
			     /*WORMRETRY*/ 4,
			     5000,
			     NULL,
			     SCSI_DATA_IN);
	*addr = scsi_4btou (data+1);
	return error;
}
    
/*
 * End HP C4324/C4325 (4020i) section.
 */