13 files changed, 2276 insertions, 18 deletions

diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC
index 3de583d25294..e25e158ff026 100644
--- a/sys/amd64/conf/GENERIC
+++ b/sys/amd64/conf/GENERIC
@@ -1,7 +1,7 @@
 #
 # GENERIC -- Generic machine with WD/AHx/NCR/BTx family disks
 #
-#	$Id: GENERIC,v 1.45.2.3 1995/06/05 21:50:41 jkh Exp $
+#	$Id: GENERIC,v 1.46 1995/06/11 19:31:11 rgrimes Exp $
 #
 
 machine		"i386"
@@ -41,6 +41,9 @@ controller	wdc1	at isa? port "IO_WD2" bio irq 15 vector wdintr
 disk		wd2	at wdc1 drive 0
 disk		wd3	at wdc1 drive 1
 
+options         ATAPI   #Enable ATAPI support for IDE bus
+device          wcd0    #IDE CD-ROM
+
 controller	ncr0
 controller	ahc0
 
diff --git a/sys/conf/NOTES b/sys/conf/NOTES
index b30e0616e9c1..3c5765f1e1a6 100644
--- a/sys/conf/NOTES
+++ b/sys/conf/NOTES
@@ -2,7 +2,7 @@
 # LINT -- config file for checking all the sources, tries to pull in
 #	as much of the source tree as it can.
 #
-#	$Id: LINT,v 1.192 1995/08/11 17:18:42 joerg Exp $
+#	$Id: LINT,v 1.193 1995/08/12 13:40:42 ats Exp $
 #
 # NB: You probably don't want to try running a kernel built from this
 # file.  Instead, you should start from GENERIC, and add options from
@@ -493,6 +493,16 @@ disk		wd2	at wdc1 drive 0
 disk		wd3	at wdc1 drive 1
 
 #
+# Options for `wdc':
+#
+# ATAPI enables the support for ATAPI-compatible IDE devices
+#
+options         ATAPI   #Enable ATAPI support for IDE bus
+
+# IDE CD-ROM driver - requires wdc controller and ATAPI option
+device          wcd0
+
+#
 # Standard floppy disk controllers and floppy tapes: `fdc', `fd', and `ft'
 #
 controller	fdc0	at isa? port "IO_FD1" bio irq 6 drq 2 vector fdintr
diff --git a/sys/conf/files.i386 b/sys/conf/files.i386
index cd71c62937f7..45e331551d7e 100644
--- a/sys/conf/files.i386
+++ b/sys/conf/files.i386
@@ -1,7 +1,7 @@
 # This file tells config what files go into building a kernel,
 # files marked standard are always included.
 #
-#	$Id: files.i386,v 1.102 1995/07/28 22:25:52 jkh Exp $
+#	$Id: files.i386,v 1.103 1995/08/05 21:32:52 peter Exp $
 #
 aic7xxx_asm			optional	ahc	device-driver	   \
 	dependency 	"$S/dev/aic7xxx/aic7xxx_asm.c"			   \
@@ -167,6 +167,8 @@ i386/isa/syscons.c		optional	sc	device-driver
 i386/isa/tw.c			optional	tw	device-driver
 i386/isa/ultra14f.c		optional	uha	device-driver
 i386/isa/wd.c			optional	wd	device-driver
+i386/isa/atapi.c		optional	wd	device-driver
+i386/isa/wcd.c			optional	wcd	device-driver
 i386/isa/wd7000.c		optional	wds	device-driver
 i386/isa/wt.c			optional	wt	device-driver
 i386/scsi/aic7xxx.c		optional	ahc	device-driver	   \
diff --git a/sys/i386/conf/GENERIC b/sys/i386/conf/GENERIC
index 3de583d25294..e25e158ff026 100644
--- a/sys/i386/conf/GENERIC
+++ b/sys/i386/conf/GENERIC
@@ -1,7 +1,7 @@
 #
 # GENERIC -- Generic machine with WD/AHx/NCR/BTx family disks
 #
-#	$Id: GENERIC,v 1.45.2.3 1995/06/05 21:50:41 jkh Exp $
+#	$Id: GENERIC,v 1.46 1995/06/11 19:31:11 rgrimes Exp $
 #
 
 machine		"i386"
@@ -41,6 +41,9 @@ controller	wdc1	at isa? port "IO_WD2" bio irq 15 vector wdintr
 disk		wd2	at wdc1 drive 0
 disk		wd3	at wdc1 drive 1
 
+options         ATAPI   #Enable ATAPI support for IDE bus
+device          wcd0    #IDE CD-ROM
+
 controller	ncr0
 controller	ahc0
 
diff --git a/sys/i386/conf/LINT b/sys/i386/conf/LINT
index b30e0616e9c1..3c5765f1e1a6 100644
--- a/sys/i386/conf/LINT
+++ b/sys/i386/conf/LINT
@@ -2,7 +2,7 @@
 # LINT -- config file for checking all the sources, tries to pull in
 #	as much of the source tree as it can.
 #
-#	$Id: LINT,v 1.192 1995/08/11 17:18:42 joerg Exp $
+#	$Id: LINT,v 1.193 1995/08/12 13:40:42 ats Exp $
 #
 # NB: You probably don't want to try running a kernel built from this
 # file.  Instead, you should start from GENERIC, and add options from
@@ -493,6 +493,16 @@ disk		wd2	at wdc1 drive 0
 disk		wd3	at wdc1 drive 1
 
 #
+# Options for `wdc':
+#
+# ATAPI enables the support for ATAPI-compatible IDE devices
+#
+options         ATAPI   #Enable ATAPI support for IDE bus
+
+# IDE CD-ROM driver - requires wdc controller and ATAPI option
+device          wcd0
+
+#
 # Standard floppy disk controllers and floppy tapes: `fdc', `fd', and `ft'
 #
 controller	fdc0	at isa? port "IO_FD1" bio irq 6 drq 2 vector fdintr
diff --git a/sys/i386/conf/NOTES b/sys/i386/conf/NOTES
index b30e0616e9c1..3c5765f1e1a6 100644
--- a/sys/i386/conf/NOTES
+++ b/sys/i386/conf/NOTES
@@ -2,7 +2,7 @@
 # LINT -- config file for checking all the sources, tries to pull in
 #	as much of the source tree as it can.
 #
-#	$Id: LINT,v 1.192 1995/08/11 17:18:42 joerg Exp $
+#	$Id: LINT,v 1.193 1995/08/12 13:40:42 ats Exp $
 #
 # NB: You probably don't want to try running a kernel built from this
 # file.  Instead, you should start from GENERIC, and add options from
@@ -493,6 +493,16 @@ disk		wd2	at wdc1 drive 0
 disk		wd3	at wdc1 drive 1
 
 #
+# Options for `wdc':
+#
+# ATAPI enables the support for ATAPI-compatible IDE devices
+#
+options         ATAPI   #Enable ATAPI support for IDE bus
+
+# IDE CD-ROM driver - requires wdc controller and ATAPI option
+device          wcd0
+
+#
 # Standard floppy disk controllers and floppy tapes: `fdc', `fd', and `ft'
 #
 controller	fdc0	at isa? port "IO_FD1" bio irq 6 drq 2 vector fdintr
diff --git a/sys/i386/conf/files.i386 b/sys/i386/conf/files.i386
index cd71c62937f7..45e331551d7e 100644
--- a/sys/i386/conf/files.i386
+++ b/sys/i386/conf/files.i386
@@ -1,7 +1,7 @@
 # This file tells config what files go into building a kernel,
 # files marked standard are always included.
 #
-#	$Id: files.i386,v 1.102 1995/07/28 22:25:52 jkh Exp $
+#	$Id: files.i386,v 1.103 1995/08/05 21:32:52 peter Exp $
 #
 aic7xxx_asm			optional	ahc	device-driver	   \
 	dependency 	"$S/dev/aic7xxx/aic7xxx_asm.c"			   \
@@ -167,6 +167,8 @@ i386/isa/syscons.c		optional	sc	device-driver
 i386/isa/tw.c			optional	tw	device-driver
 i386/isa/ultra14f.c		optional	uha	device-driver
 i386/isa/wd.c			optional	wd	device-driver
+i386/isa/atapi.c		optional	wd	device-driver
+i386/isa/wcd.c			optional	wcd	device-driver
 i386/isa/wd7000.c		optional	wds	device-driver
 i386/isa/wt.c			optional	wt	device-driver
 i386/scsi/aic7xxx.c		optional	ahc	device-driver	   \
diff --git a/sys/i386/i386/conf.c b/sys/i386/i386/conf.c
index 1c5fa6916065..8dc88a10cbce 100644
--- a/sys/i386/i386/conf.c
+++ b/sys/i386/i386/conf.c
@@ -42,7 +42,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)conf.c	5.8 (Berkeley) 5/12/91
- *	$Id: conf.c,v 1.90 1995/07/31 22:06:55 jkh Exp $
+ *	$Id: conf.c,v 1.91 1995/08/05 21:33:04 peter Exp $
  */
 
 #include <sys/param.h>
@@ -294,6 +294,19 @@ d_psize_t	atasize;
 #define	atadump		nxdump
 #endif
 
+#include "wcd.h"
+#if NWCD > 0
+d_open_t	wcdopen;
+d_close_t	wcdclose;
+d_strategy_t	wcdstrategy;
+d_ioctl_t	wcdioctl;
+#else
+#define wcdopen		nxopen
+#define wcdclose	nxclose
+#define wcdstrategy	nxstrategy
+#define wcdioctl	nxioctl
+#endif
+
 #include "ch.h"
 #if NCH > 0
 d_open_t	chopen;
@@ -422,7 +435,10 @@ struct bdevsw	bdevsw[] =
 	{ matcdopen,	matcdclose,	matcdstrategy,	matcdioctl,	/*17*/
 	  matcddump,	matcdsize,	0 },
 	{ ataopen,	ataclose,	atastrategy,	ataioctl,	/*18*/
-	  atadump,	atasize,	0 }
+	  atadump,	atasize,	0 },
+	{ wcdopen,      wcdclose,       wcdstrategy,    wcdioctl,       /*19*/
+	  nxdump,       zerosize,       0 },
+
 /*
  * If you need a bdev major number for a driver that you intend to donate
  * back to the group or release publically, please contact the FreeBSD team
@@ -1275,6 +1291,9 @@ struct cdevsw	cdevsw[] =
 	{ siopen,	siclose,	siread,		siwrite,	/*68*/
 	  siioctl,	sistop,		sireset,	sidevtotty,/* slxos */
 	  ttselect,	nxmmap,		NULL },
+	{ wcdopen,      wcdclose,       rawread,        nowrite,        /*69*/
+	  wcdioctl,     nostop,         nullreset,      nodevtotty,/* atapi */
+	  seltrue,      nommap,         wcdstrategy },
 };
 int	nchrdev = sizeof (cdevsw) / sizeof (cdevsw[0]);
 
diff --git a/sys/i386/isa/atapi.c b/sys/i386/isa/atapi.c
new file mode 100644
index 000000000000..ccbd85ba88d4
--- /dev/null
+++ b/sys/i386/isa/atapi.c
@@ -0,0 +1,822 @@
+/*
+ * Device-independent level for ATAPI drivers.
+ *
+ * Copyright (C) 1995 Cronyx Ltd.
+ * Author Serge Vakulenko, <vak@cronyx.ru>
+ *
+ * This software is distributed with NO WARRANTIES, not even the implied
+ * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Authors grant any other persons or organisations permission to use
+ * or modify this software as long as this message is kept with the software,
+ * all derivative works or modified versions.
+ *
+ * Version 1.1, Mon Jul 10 21:55:11 MSD 1995
+ */
+
+/*
+ * The ATAPI level is implemented as a machine-dependent layer
+ * between the device driver and the IDE controller.
+ * All the machine- and controller dependency is isolated inside
+ * the ATAPI level, while all the device dependency is located
+ * in the device subdriver.
+ *
+ * It seems that an ATAPI bus will became popular for medium-speed
+ * storage devices such as CD-ROMs, magneto-optical disks, tape streamers etc.
+ *
+ * To ease the development of new ATAPI drivers, the subdriver
+ * interface was designed to be as simple as possible.
+ *
+ * Three routines are available for the subdriver to access the device:
+ *
+ *      struct atapires atapi_request_wait (ata, unit, cmd, a1, a2, a3, a4, a5,
+ *              a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, addr, count);
+ *      struct atapi *ata;  -- atapi controller descriptor
+ *      int unit;           -- device unit number on the IDE bus
+ *      u_char cmd;         -- ATAPI command code
+ *      u_char a1..a15;     -- ATAPI command arguments
+ *      char *addr;         -- address of the data buffer for i/o
+ *      int count;          -- data length, >0 for read ops, <0 for write ops
+ *
+ * The atapi_request_wait() function puts the op in the queue of ATAPI
+ * commands for the IDE controller, starts the controller, the waits for
+ * operation to be completed (using tsleep).
+ * The function should be called from the user phase only (open(), close(),
+ * ioctl() etc).
+ * Ata and unit args are the values which the subdriver gets from the ATAPI
+ * level via attach() call.
+ * Buffer pointed to by *addr should be placed in core memory, static
+ * or dynamic, but not in stack.
+ * The function returns the error code structure, which consists of:
+ * - atapi driver code value
+ * - controller status port value
+ * - controller error port value
+ *
+ *      struct atapires atapi_request_immediate (ata, unit, cmd, a1, a2, a3,
+ *              a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
+ *              addr, count);
+ *
+ * The atapi_request_immediate() function is similar to atapi_request_wait(),
+ * but it does not use interrupts for performing the request.
+ * It should be used during an attach phase to get parameters from the device.
+ *
+ *      void atapi_request_callback (ata, unit, cmd, a1, a2, a3, a4, a5,
+ *              a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
+ *              addr, count, done, x, y);
+ *      struct atapi *ata;  -- atapi controller descriptor
+ *      int unit;           -- device unit number on the IDE bus
+ *      u_char cmd;         -- ATAPI command code
+ *      u_char a1..a15;     -- ATAPI command arguments
+ *      char *addr;         -- address of the data buffer for i/o
+ *      int count;          -- data length, >0 for read ops, <0 for write ops
+ *      void (*done)();     -- function to call when op finished
+ *      void *x, *y;        -- arguments for done() function
+ *
+ * The atapi_request_callback() function puts the op in the queue of ATAPI
+ * commands for the IDE controller, starts the controller, then returns.
+ * When the operation finishes, then the callback function done()
+ * will be called on the interrupt level.
+ * The function is designed to be callable from the interrupt phase.
+ * The done() functions is called with the following arguments:
+ *      (void) (*done) (x, y, count, errcode)
+ *      void *x, *y;             -- arguments from the atapi_request_callback()
+ *      int count;               -- the data residual count
+ *      struct atapires errcode; -- error code structure, see above
+ *
+ * The new driver could be added in three steps:
+ * 1. Add entries for the new driver to bdevsw and cdevsw tables in conf.c.
+ *    You will need to make at least three routines: open(), close(),
+ *    strategy() and possibly ioctl().
+ * 2. Make attach() routine, which should allocate all the needed data
+ *    structures and print the device description string (see wcdattach()).
+ * 3. Add an appropriate case to the switch in atapi_attach() routine,
+ *    call attach() routine of the new driver here.  Add the appropriate
+ *    #include line at the top of attach.c.
+ * That's all!
+ *
+ * Use #define DEBUG in atapi.c to enable tracing of all i/o operations
+ * on the IDE bus.
+ */
+#undef DEBUG
+
+#include "wd.h"
+#include "wcd.h"
+/* #include "whd.h" -- add your driver here */
+/* #include "wmt.h" -- add your driver here */
+/* #include "wmd.h" -- add your driver here */
+
+#if NWDC > 0 && defined (ATAPI)
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/malloc.h>
+#include <i386/include/cpufunc.h>
+#include <i386/include/clock.h>
+#include <i386/isa/atapi.h>
+
+#ifdef DEBUG
+#   define print(s)     printf s
+#else
+#   define print(s)     {/*void*/}
+#endif
+
+#define MAXCMD  (8*NWDC)
+
+/*
+ * ATAPI packet command phase.
+ */
+#define PHASE_CMDOUT    (ARS_DRQ | ARI_CMD)
+#define PHASE_DATAIN    (ARS_DRQ | ARI_IN)
+#define PHASE_DATAOUT   ARS_DRQ
+#define PHASE_COMPLETED (ARI_IN | ARI_CMD)
+
+struct atapicmd {                       /* ATAPI command block */
+	struct atapicmd *next;          /* next command in queue */
+	int              busy;          /* busy flag */
+	u_char           cmd[16];       /* command and args */
+	int              unit;          /* drive unit number */
+	int              count;         /* byte count, >0 - read, <0 - write */
+	char            *addr;          /* data to transfer */
+	void           (*callback) ();  /* call when done */
+	void            *cbarg1;        /* callback arg 1 */
+	void            *cbarg2;        /* callback arg 1 */
+	struct atapires  result;        /* resulting error code */
+};
+
+struct atapi {                          /* ATAPI controller data */
+	u_short          port;          /* i/o port base */
+	u_char           ctrlr;         /* physical controller number */
+	u_char           debug : 1;     /* trace enable flag */
+	u_char           cmd16 : 1;     /* 16-byte command flag */
+	u_char           intrcmd : 1;   /* interrupt before cmd flag */
+	u_char           slow : 1;      /* slow reaction device */
+	struct atapicmd *queue;         /* queue of commands to perform */
+	struct atapicmd *tail;          /* tail of queue */
+	struct atapicmd *free;          /* queue of free command blocks */
+	struct atapicmd  cmdrq[MAXCMD]; /* pool of command requests */
+};
+
+struct atapi atapitab[NWDC];
+
+static struct atapi_params *atapi_probe (int port, int unit);
+static int atapi_wait (int port, u_char bits_wanted);
+static void atapi_send_cmd (struct atapi *ata, struct atapicmd *ac);
+static int atapi_io (struct atapi *ata, struct atapicmd *ac);
+static int atapi_start_cmd (struct atapi *ata, struct atapicmd *ac);
+static int atapi_wait_cmd (struct atapi *ata, struct atapicmd *ac);
+
+extern int wdstart (int ctrlr);
+
+void atapi_attach (int ctlr, int unit, int port, struct kern_devconf *parent)
+{
+	struct atapi *ata = atapitab + ctlr;
+	struct atapi_params *ap;
+	char buf [sizeof(ap->model) + 1];
+	struct atapicmd *ac;
+
+	print (("atapi%d.%d at 0x%x: attach called\n", ctlr, unit, port));
+	ap = atapi_probe (port, unit);
+	if (! ap)
+		return;
+
+	bcopy (ap->model, buf, sizeof(buf)-1);
+	buf[sizeof(buf)-1] = 0;
+	printf ("wdc%d: unit %d (atapi): <%s>", ctlr, unit, buf);
+
+	/* device is removable */
+	if (ap->removable)
+		printf (", removable");
+
+	/* packet command size */
+	switch (ap->cmdsz) {
+	case AT_PSIZE_12: break;
+	case AT_PSIZE_16: printf (", cmd16"); ata->cmd16 = 1; break;
+	default:          printf (", cmd%d", ap->cmdsz);
+	}
+
+	/* DRQ type */
+	switch (ap->drqtype) {
+	case AT_DRQT_MPROC: ata->slow = 1; break;
+	case AT_DRQT_INTR:  printf (", intr"); ata->intrcmd = 1; break;
+	case AT_DRQT_ACCEL: printf (", accel"); break;
+	default:            printf (", drq%d", ap->cmdsz);
+	}
+
+	/* overlap operation supported */
+	if (ap->ovlapflag)
+		printf (", ovlap");
+
+	/* interleaved DMA supported */
+	if (ap->idmaflag)
+		printf (", idma");
+	/* DMA supported */
+	else if (ap->dmaflag)
+		printf (", dma");
+
+	/* IORDY can be disabled */
+	if (ap->iordydis)
+		printf (", iordis");
+	/* IORDY supported */
+	else if (ap->iordyflag)
+		printf (", iordy");
+
+	printf ("\n");
+
+	ata->port = port;
+	ata->ctrlr = ctlr;
+#ifdef DEBUG
+	ata->debug = 1;
+#else
+	ata->debug = 0;
+#endif
+	/* Initialize free queue. */
+	ata->cmdrq[MAXCMD-1].next = 0;
+	for (ac = ata->cmdrq+MAXCMD-2; ac >= ata->cmdrq; --ac)
+		ac->next = ac+1;
+	ata->free = ata->cmdrq;
+
+	if (ap->proto != AT_PROTO_ATAPI) {
+		printf ("wdc%d: unit %d: unknown ATAPI protocol=%d\n",
+			ctlr, unit, ap->proto);
+		free (ap, M_TEMP);
+		return;
+	}
+	switch (ap->devtype) {
+	default:
+		/* unknown ATAPI device */
+		printf ("wdc%d: unit %d: unknown ATAPI type=%d\n",
+			ctlr, unit, ap->devtype);
+		break;
+	case AT_TYPE_CDROM:             /* CD-ROM device */
+#if NWCD > 0
+		/* ATAPI CD-ROM */
+		{
+			int wcdattach (struct atapi*, int, struct atapi_params*,
+				int, struct kern_devconf*);
+			if (wcdattach (ata, unit, ap, ata->debug, parent) < 0)
+				break;
+		}
+		/* Device attached successfully. */
+		return;
+#else
+		printf ("wdc%d: ATAPI CD-ROMs not configured\n", ctlr);
+		break;
+#endif
+	case AT_TYPE_DIRECT:            /* direct-access (magnetic disk) */
+#if NWHD > 0
+		/* Add your driver here */
+#else
+		printf ("wdc%d: ATAPI hard disks not supported\n", ctlr);
+		break;
+#endif
+	case AT_TYPE_TAPE:              /* streaming tape (QIC-121 model) */
+#if NWMT > 0
+		/* Add your driver here */
+#else
+		printf ("wdc%d: ATAPI streaming tapes not supported yet\n", ctlr);
+		break;
+#endif
+	case AT_TYPE_OPTICAL:           /* optical disk */
+#if NWMD > 0
+		/* Add your driver here */
+#else
+		printf ("wdc%d: ATAPI optical disks not supported yet\n", ctlr);
+		break;
+#endif
+	}
+	/* Attach failed. */
+	free (ap, M_TEMP);
+}
+
+/*
+ * Issue IDENTIFY command to ATAPI drive to ask it what it is.
+ */
+static struct atapi_params *atapi_probe (int port, int unit)
+{
+	struct atapi_params *ap;
+	char tb [DEV_BSIZE];
+	int i;
+
+	/* Wait for controller not busy. */
+	if (atapi_wait (port, 0) < 0) {
+		print (("atapi.%d at 0x%x: controller busy, status=%b\n",
+			unit, port, inb (port + AR_STATUS), ARS_BITS));
+		return (0);
+	}
+
+	/* Issue ATAPI IDENTIFY command. */
+	outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0);
+	outb (port + AR_COMMAND, ATAPIC_IDENTIFY);
+
+	/* Check that device is present. */
+	if (inb (port + AR_STATUS) == 0xff) {
+		print (("atapi.%d at 0x%x: no device\n", unit, port));
+		if (unit == 1)
+			/* Select unit 0. */
+			outb (port + AR_DRIVE, ARD_DRIVE0);
+		return (0);
+	}
+
+	/* Wait for data ready. */
+	if (atapi_wait (port, ARS_DRQ) != 0) {
+		print (("atapi.%d at 0x%x: identify not ready, status=%b\n",
+			unit, port, inb (port + AR_STATUS), ARS_BITS));
+		if (unit == 1)
+			/* Select unit 0. */
+			outb (port + AR_DRIVE, ARD_DRIVE0);
+		return (0);
+	}
+
+	/* Obtain parameters. */
+	insw (port + AR_DATA, tb, sizeof(tb) / sizeof(short));
+
+	ap = malloc (sizeof *ap, M_TEMP, M_NOWAIT);
+	if (! ap)
+		return (0);
+	bcopy (tb, ap, sizeof *ap);
+
+	/* Shuffle string byte order. */
+	for (i=0; i<sizeof(ap->model); i+=2) {
+		u_short *p = (u_short*) (ap->model + i);
+		*p = ntohs (*p);
+	}
+
+	/* Clean up the model by converting nulls to spaces, and
+	 * then removing the trailing spaces. */
+	for (i=0; i < sizeof(ap->model); i++)
+		if (! ap->model[i])
+			ap->model[i] = ' ';
+	for (i=sizeof(ap->model)-1; i>=0 && ap->model[i]==' '; i--)
+		ap->model[i] = 0;
+	return (ap);
+}
+
+/*
+ * Wait uninterruptibly until controller is not busy and certain
+ * status bits are set.
+ * The wait is usually short unless it is for the controller to process
+ * an entire critical command.
+ * Return 1 for (possibly stale) controller errors, -1 for timeout errors,
+ * or 0 for no errors.
+ */
+static int atapi_wait (int port, u_char bits_wanted)
+{
+	int cnt;
+	u_char s;
+
+	/* Wait 5 sec for BUSY deassert. */
+	for (cnt=500000; cnt>0; --cnt) {
+		s = inb (port + AR_STATUS);
+		if (! (s & ARS_BSY))
+			break;
+		DELAY (10);
+	}
+	if (cnt <= 0)
+		return (-1);
+	if (! bits_wanted)
+		return (s & ARS_CHECK);
+
+	/* Wait 50 msec for bits wanted. */
+	for (cnt=5000; cnt>0; --cnt) {
+		s = inb (port + AR_STATUS);
+		if ((s & bits_wanted) == bits_wanted)
+			return (s & ARS_CHECK);
+		DELAY (10);
+	}
+	return (-1);
+}
+
+void atapi_debug (struct atapi *ata, int on)
+{
+	ata->debug = on;
+}
+
+static struct atapicmd *atapi_alloc (struct atapi *ata)
+{
+	struct atapicmd *ac;
+
+	while (! ata->free)
+		tsleep ((caddr_t)ata, PRIBIO, "atacmd", 0);
+	ac = ata->free;
+	ata->free = ac->next;
+	ac->busy = 1;
+	return (ac);
+}
+
+static void atapi_free (struct atapi *ata, struct atapicmd *ac)
+{
+	if (! ata->free)
+		wakeup ((caddr_t)&ata);
+	ac->busy = 0;
+	ac->next = ata->free;
+	ata->free = ac;
+}
+
+/*
+ * Add new command request to the end of the queue.
+ */
+static void atapi_enqueue (struct atapi *ata, struct atapicmd *ac)
+{
+	ac->next = 0;
+	if (ata->tail)
+		ata->tail->next = ac;
+	else
+		ata->queue = ac;
+	ata->tail = ac;
+}
+
+static void atapi_done (struct atapi *ata)
+{
+	struct atapicmd *ac = ata->queue;
+
+	if (! ac)
+		return; /* cannot happen */
+
+	ata->queue = ac->next;
+	if (! ata->queue)
+		ata->tail = 0;
+
+	if (ac->callback) {
+		(*ac->callback) (ac->cbarg1, ac->cbarg2, ac->count, ac->result);
+		atapi_free (ata, ac);
+	} else
+		wakeup ((caddr_t)ac);
+}
+
+/*
+ * Start new packet op.  Called from wdstart().
+ * Return 1 if op started, and we are waiting for interrupt.
+ * Return 0 when idle.
+ */
+int atapi_start (int ctrlr)
+{
+	struct atapi *ata = atapitab + ctrlr;
+	struct atapicmd *ac;
+again:
+	ac = ata->queue;
+	if (! ac)
+		return (0);
+
+	/* Start packet command. */
+	if (atapi_start_cmd (ata, ac) < 0) {
+		atapi_done (ata);
+		goto again;
+	}
+
+	if (ata->intrcmd)
+		/* Wait for interrupt before sending packet command */
+		return (1);
+
+	/* Wait for DRQ. */
+	if (atapi_wait_cmd (ata, ac) < 0) {
+		atapi_done (ata);
+		goto again;
+	}
+
+	/* Send packet command. */
+	atapi_send_cmd (ata, ac);
+	return (1);
+}
+
+/*
+ * Start new packet op. Returns -1 on errors.
+ */
+int atapi_start_cmd (struct atapi *ata, struct atapicmd *ac)
+{
+	ac->result.error = 0;
+	ac->result.status = 0;
+
+	outb (ata->port + AR_DRIVE, ac->unit ? ARD_DRIVE1 : ARD_DRIVE0);
+	if (atapi_wait (ata->port, 0) < 0) {
+		printf ("atapi%d.%d: controller not ready for cmd\n",
+			ata->ctrlr, ac->unit);
+		ac->result.code = RES_NOTRDY;
+		return (-1);
+	}
+
+	/* Set up the controller registers. */
+	outb (ata->port + AR_FEATURES, 0);
+	outb (ata->port + AR_IREASON, 0);
+	outb (ata->port + AR_TAG, 0);
+	outb (ata->port + AR_CNTLO, ac->count & 0xff);
+	outb (ata->port + AR_CNTHI, ac->count >> 8);
+	outb (ata->port + AR_COMMAND, ATAPIC_PACKET);
+
+	if (ata->debug)
+		printf ("atapi%d.%d: start\n", ata->ctrlr, ac->unit);
+	return (0);
+}
+
+/*
+ * Wait for DRQ before sending packet cmd. Returns -1 on errors.
+ */
+int atapi_wait_cmd (struct atapi *ata, struct atapicmd *ac)
+{
+	/* Wait for DRQ from 50 usec to 3 msec for slow devices */
+	int cnt = ata->intrcmd ? 10000 : ata->slow ? 3000 : 50;
+
+	for (; cnt>0; cnt-=10) {
+		ac->result.status = inb (ata->port + AR_STATUS);
+		if (ac->result.status & ARS_DRQ)
+			break;
+		DELAY (10);
+	}
+	if (! (ac->result.status & ARS_DRQ)) {
+		printf ("atapi%d.%d: no cmd drq\n", ata->ctrlr, ac->unit);
+		ac->result.code = RES_NODRQ;
+		ac->result.error = inb (ata->port + AR_ERROR);
+		return (-1);
+	}
+	return (0);
+}
+
+/*
+ * Send packet cmd.
+ */
+void atapi_send_cmd (struct atapi *ata, struct atapicmd *ac)
+{
+	outsw (ata->port + AR_DATA, ac->cmd, ata->cmd16 ? 8 : 6);
+	if (ata->debug)
+		printf ("atapi%d.%d: send cmd %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x\n",
+			ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
+			ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
+			ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
+			ac->cmd[10], ac->cmd[11], ac->cmd[12],
+			ac->cmd[13], ac->cmd[14], ac->cmd[15]);
+}
+
+/*
+ * Interrupt routine for the controller.  Called from wdintr().
+ * Finish the started op, wakeup wait-type commands,
+ * run callbacks for callback-type commands, then return.
+ * Do not start new op here, it will be done by wdstart,
+ * which is called just after us.
+ * Return 1 if op continues, and we are waiting for new interrupt.
+ * Return 0 when idle.
+ */
+int atapi_intr (int ctrlr)
+{
+	struct atapi *ata = atapitab + ctrlr;
+	struct atapicmd *ac = ata->queue;
+
+	if (! ac) {
+		printf ("atapi%d: stray interrupt\n", ata->ctrlr);
+		return (0);
+	}
+	if (atapi_io (ata, ac) > 0)
+		return (1);
+	atapi_done (ata);
+	return (0);
+}
+
+/*
+ * Process the i/o phase, transferring the command/data to/from the device.
+ * Return 1 if op continues, and we are waiting for new interrupt.
+ * Return 0 when idle.
+ */
+int atapi_io (struct atapi *ata, struct atapicmd *ac)
+{
+	u_char ireason;
+	u_short len;
+
+	if (atapi_wait (ata->port, ac->count ? ARS_DRQ : 0) < 0) {
+		printf ("atapi%d.%d: controller not ready\n",
+			ata->ctrlr, ac->unit);
+		ac->result.code = RES_NOTRDY;
+		ac->result.status = 0;
+		ac->result.error = 0;
+		return (0);
+	}
+
+	ac->result.status = inb (ata->port + AR_STATUS);
+	ac->result.error = inb (ata->port + AR_ERROR);
+	len = inb (ata->port + AR_CNTLO);
+	len |= inb (ata->port + AR_CNTHI) << 8;
+	ireason = inb (ata->port + AR_IREASON);
+
+	if (ata->debug) {
+		printf ("atapi%d.%d: intr ireason=0x%x, len=%d, status=%b, error=%b\n",
+			ata->ctrlr, ac->unit, ireason, len,
+			ac->result.status, ARS_BITS,
+			ac->result.error, AER_BITS);
+	}
+	switch ((ireason & (ARI_CMD | ARI_IN)) | (ac->result.status & ARS_DRQ)) {
+	default:
+		printf ("atapi%d.%d: unknown phase\n", ata->ctrlr, ac->unit);
+		ac->result.code = RES_ERR;
+		break;
+
+	case PHASE_CMDOUT:
+		/* Send packet command. */
+		if (! (ac->result.status & ARS_DRQ)) {
+			printf ("atapi%d.%d: no cmd drq\n",
+				ata->ctrlr, ac->unit);
+			ac->result.code = RES_NODRQ;
+			break;
+		}
+		atapi_send_cmd (ata, ac);
+		return (1);
+
+	case PHASE_DATAOUT:
+		/* Write data */
+		if (ac->count > 0) {
+			printf ("atapi%d.%d: invalid data direction\n",
+				ata->ctrlr, ac->unit);
+			ac->result.code = RES_INVDIR;
+			break;
+		}
+		if (-ac->count < len) {
+			printf ("atapi%d.%d: send data underrun, %d bytes left\n",
+				ata->ctrlr, ac->unit, -ac->count);
+			ac->result.code = RES_UNDERRUN;
+			break;
+		}
+		outsw (ata->port + AR_DATA, ac->addr, len / sizeof(short));
+		ac->addr += len;
+		ac->count += len;
+		return (1);
+
+	case PHASE_DATAIN:
+		/* Read data */
+		if (ac->count < 0) {
+			printf ("atapi%d.%d: invalid data direction\n",
+				ata->ctrlr, ac->unit);
+			ac->result.code = RES_INVDIR;
+			break;
+		}
+		if (ac->count < len) {
+			printf ("atapi%d.%d: recv data overrun, %d bytes left\n",
+				ata->ctrlr, ac->unit, ac->count);
+			ac->result.code = RES_OVERRUN;
+			break;
+		}
+		insw (ata->port + AR_DATA, ac->addr, len / sizeof(short));
+		ac->addr += len;
+		ac->count -= len;
+		return (1);
+
+	case PHASE_COMPLETED:
+		if (ac->result.status & (ARS_CHECK | ARS_DF)) {
+			ac->result.code = RES_ERR;
+			break;
+		}
+		if (ac->count < 0) {
+			printf ("atapi%d.%d: send data overrun, %d bytes left\n",
+				ata->ctrlr, ac->unit, -ac->count);
+			ac->result.code = RES_OVERRUN;
+			break;
+		}
+		if (ac->count > 0) {
+			printf ("atapi%d.%d: recv data underrun, %d bytes left\n",
+				ata->ctrlr, ac->unit, ac->count);
+			ac->result.code = RES_UNDERRUN;
+			break;
+		}
+		ac->result.code = RES_OK;
+		break;
+	}
+	return (0);
+}
+
+/*
+ * Queue new packet request, then call wdstart().
+ * Called on splbio().
+ */
+void atapi_request_callback (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count, void (*done)(), void *x, void *y)
+{
+	struct atapicmd *ac;
+
+	ac = atapi_alloc (ata);
+	ac->cmd[0] = cmd;       ac->cmd[1] = a1;
+	ac->cmd[2] = a2;        ac->cmd[3] = a3;
+	ac->cmd[4] = a4;        ac->cmd[5] = a5;
+	ac->cmd[6] = a6;        ac->cmd[7] = a7;
+	ac->cmd[8] = a8;        ac->cmd[9] = a9;
+	ac->cmd[10] = a10;      ac->cmd[11] = a11;
+	ac->cmd[12] = a12;      ac->cmd[13] = a13;
+	ac->cmd[14] = a14;      ac->cmd[15] = a15;
+	ac->unit = unit;
+	ac->addr = addr;
+	ac->count = count;
+	ac->callback = done;
+	ac->cbarg1 = x;
+	ac->cbarg2 = y;
+
+	if (ata->debug)
+		printf ("atapi%d.%d: req cb %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x len=%d\n",
+			ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
+			ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
+			ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
+			ac->cmd[10], ac->cmd[11], ac->cmd[12],
+			ac->cmd[13], ac->cmd[14], ac->cmd[15], count);
+	atapi_enqueue (ata, ac);
+	wdstart (ata->ctrlr);
+}
+
+/*
+ * Queue new packet request, then call wdstart().
+ * Wait until the request is finished.
+ * Called on spl0().
+ * Return atapi error.
+ * Buffer pointed to by *addr should be placed in core memory, not in stack!
+ */
+struct atapires atapi_request_wait (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count)
+{
+	struct atapicmd *ac;
+	int x = splbio ();
+	struct atapires result;
+
+	ac = atapi_alloc (ata);
+	ac->cmd[0] = cmd;       ac->cmd[1] = a1;
+	ac->cmd[2] = a2;        ac->cmd[3] = a3;
+	ac->cmd[4] = a4;        ac->cmd[5] = a5;
+	ac->cmd[6] = a6;        ac->cmd[7] = a7;
+	ac->cmd[8] = a8;        ac->cmd[9] = a9;
+	ac->cmd[10] = a10;      ac->cmd[11] = a11;
+	ac->cmd[12] = a12;      ac->cmd[13] = a13;
+	ac->cmd[14] = a14;      ac->cmd[15] = a15;
+	ac->unit = unit;
+	ac->addr = addr;
+	ac->count = count;
+	ac->callback = 0;
+	ac->cbarg1 = 0;
+	ac->cbarg2 = 0;
+
+	if (ata->debug)
+		printf ("atapi%d.%d: req w %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x len=%d\n",
+			ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
+			ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
+			ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
+			ac->cmd[10], ac->cmd[11], ac->cmd[12],
+			ac->cmd[13], ac->cmd[14], ac->cmd[15], count);
+	atapi_enqueue (ata, ac);
+	wdstart (ata->ctrlr);
+	tsleep ((caddr_t)ac, PRIBIO, "atareq", 0);
+
+	result = ac->result;
+	atapi_free (ata, ac);
+	splx (x);
+	return (result);
+}
+
+/*
+ * Perform a packet command on the device.
+ * Should be called on splbio().
+ * Return atapi error.
+ */
+struct atapires atapi_request_immediate (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count)
+{
+	struct atapicmd cmdbuf, *ac = &cmdbuf;
+	int cnt;
+
+	ac->cmd[0] = cmd;       ac->cmd[1] = a1;
+	ac->cmd[2] = a2;        ac->cmd[3] = a3;
+	ac->cmd[4] = a4;        ac->cmd[5] = a5;
+	ac->cmd[6] = a6;        ac->cmd[7] = a7;
+	ac->cmd[8] = a8;        ac->cmd[9] = a9;
+	ac->cmd[10] = a10;      ac->cmd[11] = a11;
+	ac->cmd[12] = a12;      ac->cmd[13] = a13;
+	ac->cmd[14] = a14;      ac->cmd[15] = a15;
+	ac->unit = unit;
+	ac->addr = addr;
+	ac->count = count;
+	ac->callback = 0;
+	ac->cbarg1 = 0;
+	ac->cbarg2 = 0;
+
+	if (ata->debug)
+		printf ("atapi%d.%d: req im %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x len=%d\n",
+			ata->ctrlr, ac->unit, ac->cmd[0], ac->cmd[1],
+			ac->cmd[2], ac->cmd[3], ac->cmd[4], ac->cmd[5],
+			ac->cmd[6], ac->cmd[7], ac->cmd[8], ac->cmd[9],
+			ac->cmd[10], ac->cmd[11], ac->cmd[12],
+			ac->cmd[13], ac->cmd[14], ac->cmd[15], count);
+
+	/* Start packet command, wait for DRQ. */
+	if (atapi_start_cmd (ata, ac) >= 0 && atapi_wait_cmd (ata, ac) >= 0) {
+		/* Send packet command. */
+		atapi_send_cmd (ata, ac);
+
+		/* Do all needed i/o. */
+		while (atapi_io (ata, ac))
+			/* Wait for DRQ deassert. */
+			for (cnt=2000; cnt>0; --cnt)
+				if (! (inb (ata->port + AR_STATUS) & ARS_DRQ))
+					break;
+	}
+	return (ac->result);
+}
+#endif /* NWDC && ATAPI */
diff --git a/sys/i386/isa/atapi.h b/sys/i386/isa/atapi.h
new file mode 100644
index 000000000000..7374acdcf010
--- /dev/null
+++ b/sys/i386/isa/atapi.h
@@ -0,0 +1,206 @@
+/*
+ * Device-independent level for ATAPI drivers.
+ *
+ * Copyright (C) 1995 Cronyx Ltd.
+ * Author Serge Vakulenko, <vak@cronyx.ru>
+ *
+ * This software is distributed with NO WARRANTIES, not even the implied
+ * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Authors grant any other persons or organisations permission to use
+ * or modify this software as long as this message is kept with the software,
+ * all derivative works or modified versions.
+ *
+ * Version 1.1, Mon Jul 10 21:55:11 MSD 1995
+ */
+
+/*
+ * Disk Controller ATAPI register definitions.
+ */
+#define AR_DATA         0x0             /* RW - data register (16 bits) */
+#define AR_ERROR        0x1             /*  R - error register */
+#define AR_FEATURES     0x1             /*  W - features */
+#define AR_IREASON      0x2             /* RW - interrupt reason */
+#define AR_TAG          0x3             /*    - reserved for SAM TAG byte */
+#define AR_CNTLO        0x4             /* RW - byte count, low byte */
+#define AR_CNTHI        0x5             /* RW - byte count, high byte */
+#define AR_DRIVE        0x6             /* RW - drive select */
+#define AR_COMMAND      0x7             /*  W - command register */
+#define AR_STATUS       0x7             /*  R - immediate status */
+
+/*
+ * Status register bits
+ */
+#define ARS_CHECK       0x01            /* error occured, see sense key/code */
+					/* bit 0x02 reserved */
+#define ARS_CORR        0x04            /* correctable error occured */
+#define ARS_DRQ         0x08            /* data request / ireason valid */
+#define ARS_DSC         0x10            /* immediate operation completed */
+#define ARS_DF          0x20            /* drive fault */
+#define ARS_DRDY        0x40            /* ready to get command */
+#define ARS_BSY         0x80            /* registers busy */
+					/* for overlap mode only: */
+#define ARS_SERVICE     0x10            /* service is requested */
+#define ARS_DMARDY      0x20            /* ready to start a DMA transfer */
+#define ARS_BITS        "\20\010busy\7ready\6fault\5opdone\4drq\3corr\1check"
+
+/*
+ * Error register bits
+ */
+#define AER_ILI         0x01            /* illegal length indication */
+#define AER_EOM         0x02            /* end of media detected */
+#define AER_ABRT        0x04            /* command aborted */
+#define AER_MCR         0x08            /* media change requested */
+#define AER_SKEY        0xf0            /* sense key mask */
+#define AER_SK_NO_SENSE         0x00    /* no spesific sense key info */
+#define AER_SK_RECOVERED_ERROR  0x10    /* command succeeded, data recovered */
+#define AER_SK_NOT_READY        0x20    /* no access to drive */
+#define AER_SK_MEDIUM_ERROR     0x30    /* non-recovered data error */
+#define AER_SK_HARDWARE_ERROR   0x40    /* non-recoverable hardware failure */
+#define AER_SK_ILLEGAL_REQUEST  0x50    /* invalid command parameter(s) */
+#define AER_SK_UNIT_ATTENTION   0x60    /* media changed */
+#define AER_SK_DATA_PROTECT     0x70    /* reading read-protected sector */
+#define AER_SK_ABORTED_COMMAND  0xb0    /* command aborted, try again */
+#define AER_SK_MISCOMPARE       0xe0    /* data did not match the medium */
+#define AER_BITS        "\20\4mchg\3abort\2eom\1ili"
+
+/*
+ * Feature register bits
+ */
+#define ARF_DMA         0x01            /* transfer data via DMA */
+#define ARF_OVERLAP     0x02            /* release the bus until completion */
+
+/*
+ * Interrupt reason register bits
+ */
+#define ARI_CMD         0x01            /* command(1) or data(0) */
+#define ARI_IN          0x02            /* transfer to(1) or from(0) the host */
+#define ARI_RELEASE     0x04            /* bus released until completion */
+
+/*
+ * Drive register values
+ */
+#define ARD_DRIVE0      0xa0            /* drive 0 selected */
+#define ARD_DRIVE1      0xb0            /* drive 1 selected */
+
+/*
+ * ATA commands
+ */
+#define ATAPIC_IDENTIFY         0xa1    /* get drive parameters */
+#define ATAPIC_PACKET           0xa0    /* execute packet command */
+
+/*
+ * Packet commands
+ */
+#define ATAPI_TEST_UNIT_READY   0x00    /* check if the device is ready */
+#define ATAPI_REQUEST_SENSE     0x03    /* get sense data */
+#define ATAPI_START_STOP        0x1b    /* start/stop the media */
+#define ATAPI_PREVENT_ALLOW     0x1e    /* prevent/allow media removal */
+#define ATAPI_READ_CAPACITY     0x25    /* get volume capacity */
+#define ATAPI_READ_BIG          0x28    /* read data */
+#define ATAPI_READ_TOC          0x43    /* get table of contents */
+#define ATAPI_READ_SUBCHANNEL   0x42    /* get subchannel info */
+#define ATAPI_PLAY_MSF          0x47    /* play by MSF address */
+#define ATAPI_PLAY_TRACK        0x48    /* play by track number */
+#define ATAPI_PAUSE             0x4b    /* stop/start audio operation */
+#define ATAPI_MODE_SELECT_BIG   0x55    /* set device parameters */
+#define ATAPI_MODE_SENSE        0x5a    /* get device parameters */
+#define ATAPI_PLAY_BIG          0xa5    /* play by logical block address */
+
+/*
+ * Drive parameter information
+ */
+struct atapi_params {
+	unsigned        cmdsz : 2;      /* packet command size */
+#define AT_PSIZE_12     0
+#define AT_PSIZE_16     1
+	unsigned : 3;
+	unsigned        drqtype : 2;    /* DRQ type */
+#define AT_DRQT_MPROC   0               /* microprocessor DRQ - 3 msec delay */
+#define AT_DRQT_INTR    1               /* interrupt DRQ - 10 msec delay */
+#define AT_DRQT_ACCEL   2               /* accelerated DRQ - 50 usec delay */
+	unsigned        removable : 1;  /* device is removable */
+	unsigned        devtype : 5;    /* packet command size */
+#define AT_TYPE_DIRECT  0               /* direct-access (magnetic disk) */
+#define AT_TYPE_TAPE    1               /* streaming tape (QIC-121 model) */
+#define AT_TYPE_CDROM   5               /* CD-ROM device */
+#define AT_TYPE_OPTICAL 7               /* optical disk */
+	unsigned : 1;
+	unsigned        proto : 2;      /* packet command size */
+#define AT_PROTO_ATAPI  2
+	short reserved1[9];
+	char            serial[20];     /* serial number - optional */
+	short reserved2[3];
+	char            revision[8];    /* firmware revision */
+	char            model[40];      /* model name */
+	short reserved3[2];
+	u_char          vendor_cap;     /* vendor unique capabilities */
+	unsigned        dmaflag : 1;    /* DMA supported */
+	unsigned        lbaflag : 1;    /* LBA supported - always 1 */
+	unsigned        iordydis : 1;   /* IORDY can be disabled */
+	unsigned        iordyflag : 1;  /* IORDY supported */
+	unsigned : 1;
+	unsigned        ovlapflag : 1;  /* overlap operation supported */
+	unsigned : 1;
+	unsigned        idmaflag : 1;   /* interleaved DMA supported */
+	short reserved4;
+	u_short         pio_timing;     /* PIO cycle timing */
+	u_short         dma_timing;     /* DMA cycle timing */
+	u_short         flags;          /* flags */
+#define AT_FLAG_54_58   1               /* words 54-58 valid */
+#define AT_FLAG_64_70   2               /* words 64-70 valid */
+	short reserved5[8];
+	u_char          swdma_flag;     /* singleword DMA mode supported */
+	u_char          swdma_active;   /* singleword DMA mode active */
+	u_char          mwdma_flag;     /* multiword DMA mode supported */
+	u_char          mwdma_active;   /* multiword DMA mode active */
+	u_char          apio_flag;      /* advanced PIO mode supported */
+	u_char reserved6;
+	u_short         mwdma_min;      /* min. M/W DMA time per word (ns) */
+	u_short         mwdma_dflt;     /* recommended M/W DMA time (ns) - optional */
+	u_short         pio_nfctl_min;  /* min. PIO cycle time w/o flow ctl - optional */
+	u_short         pio_iordy_min;  /* min. PIO c/t with IORDY flow ctl - optional */
+	short reserved7[2];
+	u_short         rls_ovlap;      /* release time (us) for overlap cmd - optional */
+	u_short         rls_service;    /* release time (us) for service cmd - optional */
+};
+
+/*
+ * ATAPI operation result structure
+ */
+struct atapires {
+	u_char code;                    /* result code */
+#define RES_OK          0               /* i/o done */
+#define RES_ERR         1               /* i/o finished with error */
+#define RES_NOTRDY      2               /* controller not ready */
+#define RES_NODRQ       3               /* no data request */
+#define RES_INVDIR      4               /* invalid bus phase direction */
+#define RES_OVERRUN     5               /* data overrun */
+#define RES_UNDERRUN    6               /* data underrun */
+	u_char status;                  /* status register contents */
+	u_char error;                   /* error register contents */
+};
+
+#ifdef KERNEL
+struct atapi;
+struct kern_devconf;
+void atapi_attach (int ctlr, int unit, int port, struct kern_devconf*);
+int atapi_start (int ctrlr);
+int atapi_intr (int ctrlr);
+void atapi_debug (struct atapi *ata, int on);
+struct atapires atapi_request_wait (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count);
+void atapi_request_callback (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count, void (*done)(), void *x, void *y);
+struct atapires atapi_request_immediate (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count);
+#endif
diff --git a/sys/i386/isa/wcd.c b/sys/i386/isa/wcd.c
new file mode 100644
index 000000000000..cc750e613309
--- /dev/null
+++ b/sys/i386/isa/wcd.c
@@ -0,0 +1,921 @@
+/*
+ * IDE CD-ROM driver for FreeBSD.
+ * Supports ATAPI-compatible drives.
+ *
+ * Copyright (C) 1995 Cronyx Ltd.
+ * Author Serge Vakulenko, <vak@cronyx.ru>
+ *
+ * This software is distributed with NO WARRANTIES, not even the implied
+ * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Authors grant any other persons or organisations permission to use
+ * or modify this software as long as this message is kept with the software,
+ * all derivative works or modified versions.
+ *
+ * Version 1.1, Mon Jul 10 21:55:11 MSD 1995
+ */
+
+/*
+ * The driver was tested on Toshiba XM-5302TA drive. (vak)
+ */
+#include "wd.h"
+#include "wcd.h"
+#if NWCD > 0 && NWDC > 0 && defined (ATAPI)
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+#include <sys/malloc.h>
+#include <sys/buf.h>
+#include <sys/ioctl.h>
+#include <sys/devconf.h>
+#include <sys/disklabel.h>
+#include <sys/cdio.h>
+#include <i386/include/cpufunc.h>
+#include <i386/isa/atapi.h>
+
+#define NUNIT   (NWDC*2)        /* Max. number of devices */
+#define UNIT(d) (minor(d) & 3)  /* Unit part of minor device number */
+#define SECSIZE 2048            /* CD-ROM sector size in bytes */
+
+#define F_OPEN          0x0001  /* The drive os opened */
+#define F_MEDIA_CHANGED 0x0002  /* The media have changed since open */
+#define F_DEBUG         0x0004  /* The media have changed since open */
+
+/*
+ * Disc table of contents.
+ */
+#define MAXTRK 99
+struct toc {
+	struct ioc_toc_header hdr;
+	struct cd_toc_entry tab[MAXTRK+1];      /* One extra for the leadout */
+};
+
+/*
+ * Volume size info.
+ */
+struct volinfo {
+	u_long volsize;         /* Volume size in blocks */
+	u_long blksize;         /* Block size in bytes */
+} info;
+
+/*
+ * Current subchannel status.
+ */
+struct subchan {
+	u_char void0;
+	u_char audio_status;
+	u_short data_length;
+	u_char data_format;
+	u_char control;
+	u_char track;
+	u_char indx;
+	u_long abslba;
+	u_long rellba;
+};
+
+/*
+ * Audio Control Parameters Page
+ */
+struct audiopage {
+	/* Mode data header */
+	u_short data_length;
+	u_char  medium_type;
+	u_char  reserved1[5];
+
+	/* Audio control page */
+	u_char  page_code;
+#define AUDIO_PAGE      0x0e
+#define AUDIO_PAGE_MASK 0x4e            /* changeable values */
+	u_char  param_len;
+	u_char  flags;
+#define CD_PA_SOTC      0x02            /* mandatory */
+#define CD_PA_IMMED     0x04            /* always 1 */
+	u_char  reserved3[3];
+	u_short lb_per_sec;
+	struct port_control {
+		u_char  channels : 4;
+#define CHANNEL_0       1               /* mandatory */
+#define CHANNEL_1       2               /* mandatory */
+#define CHANNEL_2       4               /* optional */
+#define CHANNEL_3       8               /* optional */
+		u_char  volume;
+	} port[4];
+};
+
+/*
+ * CD-ROM Capabilities and Mechanical Status Page
+ */
+struct cappage {
+	/* Mode data header */
+	u_short data_length;
+	u_char  medium_type;
+#define MDT_UNKNOWN     0x00
+#define MDT_DATA_120    0x01
+#define MDT_AUDIO_120   0x02
+#define MDT_COMB_120    0x03
+#define MDT_PHOTO_120   0x04
+#define MDT_DATA_80     0x05
+#define MDT_AUDIO_80    0x06
+#define MDT_COMB_80     0x07
+#define MDT_PHOTO_80    0x08
+#define MDT_NO_DISC     0x70
+#define MDT_DOOR_OPEN   0x71
+#define MDT_FMT_ERROR   0x72
+	u_char  reserved1[5];
+
+	/* Capabilities page */
+	u_char  page_code;
+#define CAP_PAGE        0x2a
+	u_char  param_len;
+	u_char  reserved2[2];
+
+	u_char  audio_play : 1;         /* audio play supported */
+	u_char  composite : 1;          /* composite audio/video supported */
+	u_char  dport1 : 1;             /* digital audio on port 1 */
+	u_char  dport2 : 1;             /* digital audio on port 2 */
+	u_char  mode2_form1 : 1;        /* mode 2 form 1 (XA) read */
+	u_char  mode2_form2 : 1;        /* mode 2 form 2 format */
+	u_char  multisession : 1;       /* multi-session photo-CD */
+	u_char  : 1;
+	u_char  cd_da : 1;              /* audio-CD read supported */
+	u_char  cd_da_stream : 1;       /* CD-DA streaming */
+	u_char  rw : 1;                 /* combined R-W subchannels */
+	u_char  rw_corr : 1;            /* R-W subchannel data corrected */
+	u_char  c2 : 1;                 /* C2 error pointers supported */
+	u_char  isrc : 1;               /* can return the ISRC info */
+	u_char  upc : 1;                /* can return the catalog number UPC */
+	u_char  : 1;
+	u_char  lock : 1;               /* could be locked */
+	u_char  locked : 1;             /* current lock state */
+	u_char  prevent : 1;            /* prevent jumper installed */
+	u_char  eject : 1;              /* can eject */
+	u_char  : 1;
+	u_char  mech : 3;               /* loading mechanism type */
+#define MECH_CADDY      0
+#define MECH_TRAY       1
+#define MECH_POPUP      2
+#define MECH_CHANGER    4
+#define MECH_CARTRIDGE  5
+	u_char  sep_vol : 1;            /* independent volume of channels */
+	u_char  sep_mute : 1;           /* independent mute of channels */
+	u_char  : 6;
+
+	u_short max_speed;              /* max raw data rate in bytes/1000 */
+	u_short max_vol_levels;         /* number of discrete volume levels */
+	u_short buf_size;               /* internal buffer size in bytes/1024 */
+	u_short cur_speed;              /* current data rate in bytes/1000  */
+};
+
+struct wcd {
+	struct atapi *ata;              /* Controller structure */
+	int unit;                       /* IDE bus drive unit */
+	int lun;                        /* Logical device unit */
+	int flags;                      /* Device state flags */
+	struct buf queue;               /* Queue of i/o requests */
+	struct atapi_params *param;     /* Drive parameters table */
+	struct toc toc;                 /* Table of disc contents */
+	struct volinfo info;            /* Volume size info */
+	struct audiopage au;            /* Audio page info */
+	struct cappage cap;             /* Capabilities page info */
+	struct audiopage aumask;        /* Audio page mask */
+	struct subchan subchan;         /* Subchannel info */
+	struct kern_devconf cf;         /* Driver configuration info */
+	char description[80];           /* Device description */
+};
+
+struct wcd *wcdtab[NUNIT];      /* Drive info by unit number */
+static int wcdnlun = 0;         /* Number of configured drives */
+
+static void wcd_start (struct wcd *t);
+static void wcd_done (struct wcd *t, struct buf *bp, int resid,
+	struct atapires result);
+static void wcd_error (struct wcd *t, struct atapires result);
+static int wcd_read_toc (struct wcd *t);
+static int wcd_request_wait (struct wcd *t, u_char cmd, u_char a1, u_char a2,
+	u_char a3, u_char a4, u_char a5, u_char a6, u_char a7, u_char a8,
+	u_char a9, char *addr, int count);
+static int wcd_externalize (struct proc*, struct kern_devconf*, void*, size_t);
+static int wcd_goaway (struct kern_devconf *kdc, int force);
+static void wcd_describe (struct wcd *t);
+static int wcd_setchan (struct wcd *t,
+	u_char c0, u_char c1, u_char c2, u_char c3);
+
+static struct kern_devconf cftemplate = {
+	0, 0, 0, "wcd", 0, { MDDT_DISK, 0 },
+	wcd_externalize, 0, wcd_goaway, DISK_EXTERNALLEN,
+	0, 0, DC_IDLE, "ATAPI compact disc",
+};
+
+/*
+ * Dump the array in hexadecimal format for debugging purposes.
+ */
+static void wcd_dump (int lun, char *label, void *data, int len)
+{
+	u_char *p = data;
+
+	printf ("wcd%d: %s %x", lun, label, *p++);
+	while (--len > 0)
+		printf ("-%x", *p++);
+	printf ("\n");
+}
+
+static int wcd_externalize (struct proc *p, struct kern_devconf *kdc,
+	void *userp, size_t len)
+{
+	return disk_externalize (wcdtab[kdc->kdc_unit]->unit, userp, &len);
+}
+
+static int wcd_goaway (struct kern_devconf *kdc, int force)
+{
+	dev_detach (kdc);
+	return 0;
+}
+
+void wcdattach (struct atapi *ata, int unit, struct atapi_params *ap, int debug,
+	struct kern_devconf *parent)
+{
+	struct wcd *t;
+	struct atapires result;
+
+	if (wcdnlun >= NUNIT) {
+		printf ("wcd: too many units\n");
+		return;
+	}
+	t = malloc (sizeof (struct wcd), M_TEMP, M_NOWAIT);
+	if (! t) {
+		printf ("wcd: out of memory\n");
+		return;
+	}
+	wcdtab[wcdnlun] = t;
+	bzero (t, sizeof (struct wcd));
+	t->ata = ata;
+	t->unit = unit;
+	t->lun = wcdnlun++;
+	t->param = ap;
+	t->flags = F_MEDIA_CHANGED;
+	if (debug) {
+		t->flags |= F_DEBUG;
+		/* Print params. */
+		wcd_dump (t->lun, "info", ap, sizeof *ap);
+	}
+
+	/* Get drive capabilities. */
+	result = atapi_request_immediate (ata, unit, ATAPI_MODE_SENSE,
+		0, CAP_PAGE, 0, 0, 0, 0, sizeof (t->cap) >> 8, sizeof (t->cap),
+		0, 0, 0, 0, 0, 0, 0, (char*) &t->cap, sizeof (t->cap));
+
+	if (result.code == 0) {
+		wcd_describe (t);
+		if (t->flags & F_DEBUG)
+			wcd_dump (t->lun, "cap", &t->cap, sizeof t->cap);
+	}
+
+	/* Register driver */
+	t->cf = cftemplate;
+	t->cf.kdc_unit = t->lun;
+	t->cf.kdc_parent = parent;
+	t->cf.kdc_description = t->description;
+	strcpy (t->description, cftemplate.kdc_description);
+	strcat (t->description, ": ");
+	strncpy (t->description + strlen(t->description),
+		ap->model, sizeof(ap->model));
+	dev_attach (&t->cf);
+}
+
+void wcd_describe (struct wcd *t)
+{
+	char *m;
+
+	t->cap.max_speed      = ntohs (t->cap.max_speed);
+	t->cap.max_vol_levels = ntohs (t->cap.max_vol_levels);
+	t->cap.buf_size       = ntohs (t->cap.buf_size);
+	t->cap.cur_speed      = ntohs (t->cap.cur_speed);
+
+	printf ("wcd%d: ", t->lun);
+	if (t->cap.cur_speed != t->cap.max_speed)
+		printf ("%d/", t->cap.cur_speed * 1000 / 1024);
+	printf ("%dKb/sec", t->cap.max_speed * 1000 / 1024, t->cap.buf_size);
+	if (t->cap.buf_size)
+		printf (", %dKb cache", t->cap.buf_size);
+
+	if (t->cap.audio_play)
+		printf (", audio play");
+	if (t->cap.max_vol_levels)
+		printf (", %d volume levels", t->cap.max_vol_levels);
+
+	switch (t->cap.mech) {
+	default:             m = 0;           break;
+	case MECH_CADDY:     m = "caddy";     break;
+	case MECH_TRAY:      m = "tray";      break;
+	case MECH_POPUP:     m = "popup";     break;
+	case MECH_CHANGER:   m = "changer";   break;
+	case MECH_CARTRIDGE: m = "cartridge"; break;
+	}
+	if (m)
+		printf (", %s%s", t->cap.eject ? "ejectable " : "", m);
+	else if (t->cap.eject)
+		printf (", eject");
+	printf ("\n");
+
+	printf ("wcd%d: ", t->lun);
+	switch (t->cap.medium_type) {
+	case MDT_UNKNOWN:   printf ("medium type unknown");          break;
+	case MDT_DATA_120:  printf ("120mm data disc loaded");       break;
+	case MDT_AUDIO_120: printf ("120mm audio disc loaded");      break;
+	case MDT_COMB_120:  printf ("120mm data/audio disc loaded"); break;
+	case MDT_PHOTO_120: printf ("120mm photo disc loaded");      break;
+	case MDT_DATA_80:   printf ("80mm data disc loaded");        break;
+	case MDT_AUDIO_80:  printf ("80mm audio disc loaded");       break;
+	case MDT_COMB_80:   printf ("80mm data/audio disc loaded");  break;
+	case MDT_PHOTO_80:  printf ("80mm photo disc loaded");       break;
+	case MDT_NO_DISC:   printf ("no disc inside");               break;
+	case MDT_DOOR_OPEN: printf ("door open");                    break;
+	case MDT_FMT_ERROR: printf ("medium format error");          break;
+	default:    printf ("medium type=0x%x", t->cap.medium_type); break;
+	}
+	if (t->cap.lock)
+		printf (t->cap.locked ? ", locked" : ", unlocked");
+	if (t->cap.prevent)
+		printf (", lock protected");
+	printf ("\n");
+}
+
+int wcdopen (dev_t dev)
+{
+	int lun = UNIT(dev);
+	struct wcd *t;
+	struct atapires result;
+
+	/* Check the unit is legal. */
+	if (lun >= wcdnlun)
+		return (ENXIO);
+	t = wcdtab[lun];
+
+	/* If already opened, that's all. */
+	if (t->flags & F_OPEN) {
+		/* If it's been invalidated, forbid re-entry.
+		 * (may have changed media) */
+		if (t->flags & F_MEDIA_CHANGED)
+			return (ENXIO);
+		return (0);
+	}
+
+	/* On the first open: check for the media.
+	 * Do it twice to avoid the stale media changed state. */
+	result = atapi_request_wait (t->ata, t->unit, ATAPI_TEST_UNIT_READY,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	if (result.code == RES_ERR && result.error == AER_SK_UNIT_ATTENTION)
+		t->flags |= F_MEDIA_CHANGED;
+
+	if (result.code)
+		result = atapi_request_wait (t->ata, t->unit,
+			ATAPI_TEST_UNIT_READY, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	if (result.code) {
+		wcd_error (t, result);
+		return (ENXIO);
+	}
+
+	/* Read table of contents. */
+	if (wcd_read_toc (t) != 0)
+		return (EIO);
+
+	/* Read disc capacity. */
+	if (wcd_request_wait (t, ATAPI_READ_CAPACITY, 0, 0, 0, 0, 0, 0,
+	    0, sizeof(t->info), 0, (char*)&t->info, sizeof(t->info)) != 0)
+		return (EIO);
+	t->info.volsize = ntohl (t->info.volsize);
+	t->info.blksize = ntohl (t->info.blksize);
+	if (t->flags & (F_MEDIA_CHANGED | F_DEBUG)) {
+		printf ("wcd%d: ", t->lun);
+		if (t->toc.tab[0].control & 4)
+			printf ("%ldMB ", t->info.volsize / 512);
+		else
+			printf ("%ld:%ld audio ", t->info.volsize/75/60,
+				t->info.volsize/75%60);
+		printf ("(%ld sectors), %d tracks\n", t->info.volsize,
+			t->toc.hdr.ending_track - t->toc.hdr.starting_track + 1);
+	}
+	/* Lock the media. */
+	wcd_request_wait (t, ATAPI_PREVENT_ALLOW,
+		0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
+
+	t->flags &= ~F_MEDIA_CHANGED;
+	t->flags |= F_OPEN;
+	return (0);
+}
+
+/*
+ * Close the device.  Only called if we are the LAST
+ * occurence of an open device.
+ */
+int wcdclose (dev_t dev)
+{
+	int lun = UNIT(dev);
+	struct wcd *t = wcdtab[lun];
+
+	/* If we were the last open of the entire device, release it. */
+	wcd_request_wait (t, ATAPI_PREVENT_ALLOW,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	t->flags &= ~F_OPEN;
+	return (0);
+}
+
+/*
+ * Actually translate the requested transfer into one the physical driver can
+ * understand. The transfer is described by a buf and will include only one
+ * physical transfer.
+ */
+int wcdstrategy (struct buf *bp)
+{
+	int lun = UNIT(bp->b_dev);
+	struct wcd *t = wcdtab[lun];
+	int x;
+
+	/* If the device has been made invalid, error out
+	 * maybe the media changed. */
+	if (t->flags & F_MEDIA_CHANGED) {
+		bp->b_error = EIO;
+		bp->b_flags |= B_ERROR;
+		biodone (bp);
+		return (0);
+	}
+
+	/* Can't ever write to a CD. */
+	if (! (bp->b_flags & B_READ)) {
+		bp->b_error = EROFS;
+		bp->b_flags |= B_ERROR;
+		biodone (bp);
+		return (0);
+	}
+
+	/* If it's a null transfer, return immediatly. */
+	if (bp->b_bcount == 0) {
+		bp->b_resid = 0;
+		biodone (bp);
+		return (0);
+	}
+
+	/* Process transfer request. */
+	bp->b_pblkno = bp->b_blkno;
+	bp->b_resid = bp->b_bcount;
+	x = splbio();
+
+	/* Place it in the queue of disk activities for this disk. */
+	disksort (&t->queue, bp);
+
+	/* Tell the device to get going on the transfer if it's
+	 * not doing anything, otherwise just wait for completion. */
+	wcd_start (t);
+	splx(x);
+	return (0);
+}
+
+/*
+ * Look 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 an ATAPI command to perform the
+ * transfer in the buf.
+ * The bufs are queued by the strategy routine (wcdstrategy).
+ * Must be called at the correct (splbio) level.
+ */
+static void wcd_start (struct wcd *t)
+{
+	struct buf *bp = t->queue.b_actf;
+	u_long blkno, nblk;
+
+	/* See if there is a buf to do and we are not already doing one. */
+	if (! bp)
+		return;
+
+	/* Unqueue the request. */
+	t->queue.b_actf = bp->b_actf;
+
+	/* Should reject all queued entries if media have changed. */
+	if (t->flags & F_MEDIA_CHANGED) {
+		bp->b_error = EIO;
+		bp->b_flags |= B_ERROR;
+		biodone (bp);
+		return;
+	}
+
+	/* We have a buf, now we should make a command
+	 * First, translate the block to absolute and put it in terms of the
+	 * logical blocksize of the device.
+	 * What if something asks for 512 bytes not on a 2k boundary? */
+	blkno = bp->b_blkno / (SECSIZE / 512);
+	nblk = (bp->b_bcount + (SECSIZE - 1)) / SECSIZE;
+
+	atapi_request_callback (t->ata, t->unit, ATAPI_READ_BIG, 0,
+		blkno>>24, blkno>>16, blkno>>8, blkno, 0, nblk>>8, nblk, 0, 0,
+		0, 0, 0, 0, 0, (u_char*) bp->b_un.b_addr, bp->b_bcount,
+		wcd_done, t, bp);
+	t->cf.kdc_state = DC_BUSY;
+}
+
+static void wcd_done (struct wcd *t, struct buf *bp, int resid,
+	struct atapires result)
+{
+	if (result.code) {
+		wcd_error (t, result);
+		bp->b_error = EIO;
+		bp->b_flags |= B_ERROR;
+	} else
+		bp->b_resid = resid;
+	biodone (bp);
+	t->cf.kdc_state = DC_IDLE;
+	wcd_start (t);
+}
+
+static void wcd_error (struct wcd *t, struct atapires result)
+{
+	if (result.code != RES_ERR)
+		return;
+	switch (result.error) {
+	case AER_SK_NOT_READY:
+		/* Tray open. */
+		if (! (t->flags & F_MEDIA_CHANGED))
+			printf ("wcd%d: tray open\n", t->lun);
+		t->flags |= F_MEDIA_CHANGED;
+		break;
+
+	case AER_SK_UNIT_ATTENTION:
+		/* Media changed. */
+		if (! (t->flags & F_MEDIA_CHANGED))
+			printf ("wcd%d: media changed\n", t->lun);
+		t->flags |= F_MEDIA_CHANGED;
+		break;
+
+	case AER_SK_NOT_READY | AER_ILI | AER_EOM:
+		/* Audio disc. */
+		printf ("wcd%d: cannot read audio disc\n", t->lun);
+		break;
+
+	case AER_SK_ILLEGAL_REQUEST:
+		/* Unknown command or invalid command arguments. */
+		if (t->flags & F_DEBUG)
+			printf ("wcd%d: invalid command\n", t->lun);
+		break;
+
+	default:
+		printf ("wcd%d: i/o error, status=%b, error=%b\n", t->lun,
+			result.status, ARS_BITS, result.error, AER_BITS);
+		break;
+	}
+}
+
+static int wcd_request_wait (struct wcd *t, u_char cmd, u_char a1, u_char a2,
+	u_char a3, u_char a4, u_char a5, u_char a6, u_char a7, u_char a8,
+	u_char a9, char *addr, int count)
+{
+	struct atapires result;
+
+	t->cf.kdc_state = DC_BUSY;
+	result = atapi_request_wait (t->ata, t->unit, cmd,
+		a1, a2, a3, a4, a5, a6, a7, a8, a9, 0, 0, 0, 0, 0, 0,
+		addr, count);
+	t->cf.kdc_state = DC_IDLE;
+	if (result.code) {
+		wcd_error (t, result);
+		return (EIO);
+	}
+	return (0);
+}
+
+static inline void lba2msf (int lba, u_char *m, u_char *s, u_char *f)
+{
+	lba += 150;             /* offset of first logical frame */
+	lba &= 0xffffff;        /* negative lbas use only 24 bits */
+	*m = lba / (60 * 75);
+	lba %= (60 * 75);
+	*s = lba / 75;
+	*f = lba % 75;
+}
+
+/*
+ * Perform special action on behalf of the user.
+ * Knows about the internals of this device
+ */
+int wcdioctl (dev_t dev, int cmd, caddr_t addr, int flag)
+{
+	int lun = UNIT(dev);
+	struct wcd *t = wcdtab[lun];
+	int error = 0;
+
+	/* If the device is not valid.. abandon ship.  */
+	if (t->flags & F_MEDIA_CHANGED)
+		return (EIO);
+	switch (cmd) {
+	default:
+		return (ENOTTY);
+
+	case CDIOCSETDEBUG:
+		t->flags |= F_DEBUG;
+		atapi_debug (t->ata, 1);
+		return 0;
+
+	case CDIOCCLRDEBUG:
+		t->flags &= ~F_DEBUG;
+		atapi_debug (t->ata, 0);
+		return 0;
+
+	case CDIOCRESUME:
+		return wcd_request_wait (t, ATAPI_PAUSE,
+			0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0);
+
+	case CDIOCPAUSE:
+		return wcd_request_wait (t, ATAPI_PAUSE,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOCSTART:
+		return wcd_request_wait (t, ATAPI_START_STOP,
+			1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOCSTOP:
+		return wcd_request_wait (t, ATAPI_START_STOP,
+			1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOCALLOW:
+		return wcd_request_wait (t, ATAPI_PREVENT_ALLOW,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOCPREVENT:
+		return wcd_request_wait (t, ATAPI_PREVENT_ALLOW,
+			0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOCRESET:
+		return wcd_request_wait (t, ATAPI_TEST_UNIT_READY,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOCEJECT:
+		/* Stop the disc. */
+		error = wcd_request_wait (t, ATAPI_START_STOP,
+			1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+		if (error)
+			return (error);
+		/* Give it some time to stop spinning. */
+		tsleep ((caddr_t)&lbolt, PRIBIO, "wcdejct", 0);
+		tsleep ((caddr_t)&lbolt, PRIBIO, "wcdejct", 0);
+		/* Eject. */
+		return wcd_request_wait (t, ATAPI_START_STOP,
+			0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0);
+
+	case CDIOREADTOCHEADER:
+		bcopy (&t->toc.hdr, addr, sizeof t->toc.hdr);
+		break;
+
+	case CDIOREADTOCENTRYS: {
+		struct ioc_read_toc_entry *te =
+			(struct ioc_read_toc_entry*) addr;
+		struct toc *toc = &t->toc;
+		struct toc buf;
+		u_long len;
+
+		if (te->starting_track < toc->hdr.starting_track ||
+		    te->starting_track > toc->hdr.ending_track)
+			return (EINVAL);
+
+		len = (toc->hdr.ending_track - te->starting_track + 2) *
+			sizeof(toc->tab[0]);
+		if (te->data_len < len)
+			len = te->data_len;
+		if (len <= 0)
+			return (EINVAL);
+
+		/* Convert to MSF format, if needed. */
+		if (te->address_format == CD_MSF_FORMAT) {
+			struct cd_toc_entry *e;
+
+			buf = t->toc;
+			toc = &buf;
+			e = toc->tab + toc->hdr.ending_track -
+				te->starting_track + 2;
+			while (--e >= toc->tab)
+				lba2msf (e->addr.lba, &e->addr.msf.minute,
+				    &e->addr.msf.second, &e->addr.msf.frame);
+		}
+		if (copyout (toc->tab + te->starting_track -
+		    toc->hdr.starting_track, te->data, len) != 0)
+			error = EFAULT;
+		break;
+	}
+	case CDIOCREADSUBCHANNEL: {
+		struct ioc_read_subchannel *args =
+			(struct ioc_read_subchannel*) addr;
+		struct cd_sub_channel_info data;
+		u_long len = args->data_len;
+		int abslba, rellba;
+
+		if (len > sizeof(data) ||
+		    len < sizeof(struct cd_sub_channel_header))
+			return (EINVAL);
+
+		if (wcd_request_wait (t, ATAPI_READ_SUBCHANNEL, 0, 0x40, 1, 0,
+		    0, 0, sizeof (t->subchan) >> 8, sizeof (t->subchan),
+		    0, (char*)&t->subchan, sizeof (t->subchan)) != 0)
+			return (EIO);
+		if (t->flags & F_DEBUG)
+			wcd_dump (t->lun, "subchan", &t->subchan, sizeof t->subchan);
+
+		abslba = ntohl (t->subchan.abslba);
+		rellba = ntohl (t->subchan.rellba);
+		if (args->address_format == CD_MSF_FORMAT) {
+			lba2msf (abslba,
+				&data.what.position.absaddr.msf.minute,
+				&data.what.position.absaddr.msf.second,
+				&data.what.position.absaddr.msf.frame);
+			lba2msf (rellba,
+				&data.what.position.reladdr.msf.minute,
+				&data.what.position.reladdr.msf.second,
+				&data.what.position.reladdr.msf.frame);
+		} else {
+			data.what.position.absaddr.lba = abslba;
+			data.what.position.reladdr.lba = rellba;
+		}
+		data.header.audio_status = t->subchan.audio_status;
+		data.what.position.control = t->subchan.control & 0xf;
+		data.what.position.track_number = t->subchan.track;
+		data.what.position.index_number = t->subchan.indx;
+
+		if (copyout (&data, args->data, len) != 0)
+			error = EFAULT;
+		break;
+	}
+	case CDIOCPLAYMSF: {
+		struct ioc_play_msf *args = (struct ioc_play_msf*) addr;
+
+		return wcd_request_wait (t, ATAPI_PLAY_MSF, 0, 0,
+			args->start_m, args->start_s, args->start_f,
+			args->end_m, args->end_s, args->end_f, 0, 0, 0);
+	}
+	case CDIOCPLAYBLOCKS: {
+		struct ioc_play_blocks *args = (struct ioc_play_blocks*) addr;
+
+		return wcd_request_wait (t, ATAPI_PLAY_BIG, 0,
+			args->blk >> 24 & 0xff, args->blk >> 16 & 0xff,
+			args->blk >> 8 & 0xff, args->blk & 0xff,
+			args->len >> 24 & 0xff, args->len >> 16 & 0xff,
+			args->len >> 8 & 0xff, args->len & 0xff, 0, 0);
+	}
+	case CDIOCPLAYTRACKS: {
+		struct ioc_play_track *args = (struct ioc_play_track*) addr;
+		u_long start, len;
+		int t1, t2;
+
+		/* Ignore index fields,
+		 * play from start_track to end_track inclusive. */
+		if (args->end_track < t->toc.hdr.ending_track+1)
+			++args->end_track;
+		if (args->end_track > t->toc.hdr.ending_track+1)
+			args->end_track = t->toc.hdr.ending_track+1;
+		t1 = args->start_track - t->toc.hdr.starting_track;
+		t2 = args->end_track - t->toc.hdr.starting_track;
+		if (t1 < 0 || t2 < 0)
+			return (EINVAL);
+		start = t->toc.tab[t1].addr.lba;
+		len = t->toc.tab[t2].addr.lba - start;
+
+		return wcd_request_wait (t, ATAPI_PLAY_BIG, 0,
+			start >> 24 & 0xff, start >> 16 & 0xff,
+			start >> 8 & 0xff, start & 0xff,
+			len >> 24 & 0xff, len >> 16 & 0xff,
+			len >> 8 & 0xff, len & 0xff, 0, 0);
+	}
+	case CDIOCGETVOL: {
+		struct ioc_vol *arg = (struct ioc_vol*) addr;
+
+		error = wcd_request_wait (t, ATAPI_MODE_SENSE, 0, AUDIO_PAGE,
+			0, 0, 0, 0, sizeof (t->au) >> 8, sizeof (t->au), 0,
+			(char*) &t->au, sizeof (t->au));
+		if (error)
+			return (error);
+		if (t->flags & F_DEBUG)
+			wcd_dump (t->lun, "au", &t->au, sizeof t->au);
+		if (t->au.page_code != AUDIO_PAGE)
+			return (EIO);
+		arg->vol[0] = t->au.port[0].volume;
+		arg->vol[1] = t->au.port[1].volume;
+		arg->vol[2] = t->au.port[2].volume;
+		arg->vol[3] = t->au.port[3].volume;
+		break;
+	}
+	case CDIOCSETVOL: {
+		struct ioc_vol *arg = (struct ioc_vol*) addr;
+
+		error = wcd_request_wait (t, ATAPI_MODE_SENSE, 0, AUDIO_PAGE,
+			0, 0, 0, 0, sizeof (t->au) >> 8, sizeof (t->au), 0,
+			(char*) &t->au, sizeof (t->au));
+		if (error)
+			return (error);
+		if (t->flags & F_DEBUG)
+			wcd_dump (t->lun, "au", &t->au, sizeof t->au);
+		if (t->au.page_code != AUDIO_PAGE)
+			return (EIO);
+
+		error = wcd_request_wait (t, ATAPI_MODE_SENSE, 0,
+			AUDIO_PAGE_MASK, 0, 0, 0, 0, sizeof (t->aumask) >> 8,
+			sizeof (t->aumask), 0, (char*) &t->aumask,
+			sizeof (t->aumask));
+		if (error)
+			return (error);
+		if (t->flags & F_DEBUG)
+			wcd_dump (t->lun, "mask", &t->aumask, sizeof t->aumask);
+
+		t->au.port[0].channels = CHANNEL_0;
+		t->au.port[1].channels = CHANNEL_1;
+		t->au.port[0].volume = arg->vol[0] & t->aumask.port[0].volume;
+		t->au.port[1].volume = arg->vol[1] & t->aumask.port[1].volume;
+		t->au.port[2].volume = arg->vol[2] & t->aumask.port[2].volume;
+		t->au.port[3].volume = arg->vol[3] & t->aumask.port[3].volume;
+		return wcd_request_wait (t, ATAPI_MODE_SELECT_BIG, 0x10,
+			0, 0, 0, 0, 0, sizeof (t->au) >> 8, sizeof (t->au),
+			0, (char*) &t->au, - sizeof (t->au));
+	}
+	case CDIOCSETPATCH: {
+		struct ioc_patch *arg = (struct ioc_patch*) addr;
+
+		return wcd_setchan (t, arg->patch[0], arg->patch[1],
+			arg->patch[2], arg->patch[3]);
+	}
+	case CDIOCSETMONO:
+		return wcd_setchan (t, CHANNEL_0 | CHANNEL_1,
+			CHANNEL_0 | CHANNEL_1, 0, 0);
+
+	case CDIOCSETSTERIO:
+		return wcd_setchan (t, CHANNEL_0, CHANNEL_1, 0, 0);
+
+	case CDIOCSETMUTE:
+		return wcd_setchan (t, 0, 0, 0, 0);
+
+	case CDIOCSETLEFT:
+		return wcd_setchan (t, CHANNEL_0, CHANNEL_0, 0, 0);
+
+	case CDIOCSETRIGHT:
+		return wcd_setchan (t, CHANNEL_1, CHANNEL_1, 0, 0);
+	}
+	return (error);
+}
+
+/*
+ * Read the entire TOC for the disc into our internal buffer.
+ */
+static int wcd_read_toc (struct wcd *t)
+{
+	int ntracks, len, i;
+
+	/* First read just the header, so we know how long the TOC is. */
+	len = sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry);
+	if (wcd_request_wait (t, ATAPI_READ_TOC, 0, 0, 0, 0, 0, 0,
+	    len >> 8, len & 0xff, 0, (char*)&t->toc, len) != 0)
+		return (EIO);
+
+	ntracks = t->toc.hdr.ending_track - t->toc.hdr.starting_track + 1;
+	if (ntracks <= 0)
+		return (EIO);
+	if (ntracks > MAXTRK)
+		ntracks = MAXTRK;
+
+	/* Now read the whole schmeer. */
+	len = sizeof(struct ioc_toc_header) +
+		(ntracks+1) * sizeof(struct cd_toc_entry);
+	if (wcd_request_wait (t, ATAPI_READ_TOC, 0, 0, 0, 0, 0, 0,
+	    len >> 8, len & 0xff, 0, (char*)&t->toc, len) & 0xff)
+		return (EIO);
+
+	t->toc.hdr.len = ntohs (t->toc.hdr.len);
+	for (i=0; i<=ntracks; i++)
+		t->toc.tab[i].addr.lba = ntohl (t->toc.tab[i].addr.lba);
+	return (0);
+}
+
+/*
+ * Set up the audio channel masks.
+ */
+static int wcd_setchan (struct wcd *t,
+	u_char c0, u_char c1, u_char c2, u_char c3)
+{
+	int error;
+
+	error = wcd_request_wait (t, ATAPI_MODE_SENSE, 0, AUDIO_PAGE,
+		0, 0, 0, 0, sizeof (t->au) >> 8, sizeof (t->au), 0,
+		(char*) &t->au, sizeof (t->au));
+	if (error)
+		return (error);
+	if (t->flags & F_DEBUG)
+		wcd_dump (t->lun, "au", &t->au, sizeof t->au);
+	if (t->au.page_code != AUDIO_PAGE)
+		return (EIO);
+
+	t->au.port[0].channels = c0;
+	t->au.port[1].channels = c1;
+	t->au.port[2].channels = c2;
+	t->au.port[3].channels = c3;
+	return wcd_request_wait (t, ATAPI_MODE_SELECT_BIG, 0x10,
+		0, 0, 0, 0, 0, sizeof (t->au) >> 8, sizeof (t->au),
+		0, (char*) &t->au, - sizeof (t->au));
+}
+#endif /* NWCD && NWDC && ATAPI */
diff --git a/sys/i386/isa/wd.c b/sys/i386/isa/wd.c
index 412ba4dec7a5..01a00660a70c 100644
--- a/sys/i386/isa/wd.c
+++ b/sys/i386/isa/wd.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)wd.c	7.2 (Berkeley) 5/9/91
- *	$Id: wd.c,v 1.80 1995/05/09 12:26:00 rgrimes Exp $
+ *	$Id: wd.c,v 1.81 1995/05/16 07:52:04 davidg Exp $
  */
 
 /* TODO:
@@ -84,6 +84,10 @@
 #include <sys/dkstat.h>
 #include <vm/vm.h>
 
+#ifdef ATAPI
+#include <i386/isa/atapi.h>
+#endif
+
 #define TIMEOUT		10000
 #define	RETRIES		5	/* number of retries before giving up */
 #define RECOVERYTIME	500000	/* usec for controller to recover after err */
@@ -113,7 +117,7 @@ static struct kern_devconf kdc_wd[NWD] = { {
 	DC_CLS_DISK		/* class */
 } };
 
-static struct kern_devconf kdc_wdc[NWDC] = { {
+struct kern_devconf kdc_wdc[NWDC] = { {
 	0, 0, 0,		/* filled in by kern_devconf.c */
 	"wdc", 0, { MDDT_ISA, 0 },
 	isa_generic_externalize, 0, wdc_goaway, ISA_EXTERNALLEN,
@@ -239,7 +243,7 @@ static struct buf rwdbuf[NWD];	/* buffers for raw IO */
 static int wdprobe(struct isa_device *dvp);
 static int wdattach(struct isa_device *dvp);
 static void wdustart(struct disk *du);
-static void wdstart(int ctrlr);
+void wdstart(int ctrlr);
 static int wdcontrol(struct buf *bp);
 static int wdcommand(struct disk *du, u_int cylinder, u_int head,
 		     u_int sector, u_int count, u_int command);
@@ -449,7 +453,19 @@ wdattach(struct isa_device *dvp)
 			wddrives[lunit] = NULL;
 		}
 	}
-
+#ifdef ATAPI
+	/*
+	 * Probe all free IDE units, searching for ATAPI drives.
+	 */
+	for (unit=0; unit<2; ++unit) {
+		for (lunit=0; lunit<NWD && wddrives[lunit]; ++lunit)
+			if (wddrives[lunit]->dk_ctrlr == dvp->id_unit &&
+			    wddrives[lunit]->dk_unit == unit)
+				goto next;
+		atapi_attach (dvp->id_unit, unit, dvp->id_iobase,
+			&kdc_wdc[dvp->id_unit]);
+next:   }
+#endif
 	/*
 	 * Discard any interrupts generated by wdgetctlr().  wdflushirq()
 	 * doesn't work now because the ambient ipl is too high.
@@ -612,7 +628,7 @@ wdustart(register struct disk *du)
  * 1. The transfer length must be an exact multiple of the sector size.
  */
 
-static void
+void
 wdstart(int ctrlr)
 {
 	register struct disk *du;
@@ -624,11 +640,21 @@ wdstart(int ctrlr)
 	int	lunit;
 	int	count;
 
+	if (wdtab[ctrlr].b_active == 2)
+		wdtab[ctrlr].b_active = 0;
+	if (wdtab[ctrlr].b_active)
+		return;
 loop:
 	/* is there a drive for the controller to do a transfer with? */
 	bp = wdtab[ctrlr].b_actf;
-	if (bp == NULL)
+	if (bp == NULL) {
+#ifdef ATAPI
+		if (atapi_start (ctrlr))
+			/* mark controller active in ATAPI mode */
+			wdtab[ctrlr].b_active = 3;
 		return;
+#endif
+	}
 
 	/* obtain controller and drive information */
 	lunit = dkunit(bp->b_dev);
@@ -854,7 +880,18 @@ wdintr(int unit)
 #endif
 		return;
 	}
-
+#ifdef ATAPI
+	if (wdtab[unit].b_active == 3) {
+		/* process an ATAPI interrupt */
+		if (atapi_intr (unit))
+			/* ATAPI op continues */
+			return;
+		/* controller is free, start new op */
+		wdtab[unit].b_active = 0;
+		wdstart (unit);
+		return;
+	}
+#endif
 	bp = wdtab[unit].b_actf;
 	du = wddrives[dkunit(bp->b_dev)];
 	dp = &wdutab[du->dk_lunit];
@@ -1016,7 +1053,10 @@ done: ;
 	/* anything more on drive queue? */
 	wdustart(du);
 	/* anything more for controller to do? */
+#ifndef ATAPI
+	/* This is not valid in ATAPI mode. */
 	if (wdtab[unit].b_actf)
+#endif
 		wdstart(unit);
 }
 
@@ -1862,8 +1902,12 @@ wdreset(struct disk *du)
 	outb(wdc + wd_ctlr, WDCTL_IDS | WDCTL_RST);
 	DELAY(10 * 1000);
 	outb(wdc + wd_ctlr, WDCTL_IDS);
-	if (wdwait(du, WDCS_READY | WDCS_SEEKCMPLT, TIMEOUT) != 0
-	    || (du->dk_error = inb(wdc + wd_error)) != 0x01)
+	if (wdwait(du, 0, TIMEOUT) != 0)
+		return (1);
+	du->dk_status = inb(wdc + wd_status);
+	du->dk_error = inb(wdc + wd_error);
+	if ((du->dk_status & ~(WDCS_READY | WDCS_SEEKCMPLT)) != 0 ||
+	    du->dk_error != 0x01)
 		return (1);
 	outb(wdc + wd_ctlr, WDCTL_4BIT);
 	return (0);
diff --git a/sys/pc98/pc98/atapi.h b/sys/pc98/pc98/atapi.h
new file mode 100644
index 000000000000..7374acdcf010
--- /dev/null
+++ b/sys/pc98/pc98/atapi.h
@@ -0,0 +1,206 @@
+/*
+ * Device-independent level for ATAPI drivers.
+ *
+ * Copyright (C) 1995 Cronyx Ltd.
+ * Author Serge Vakulenko, <vak@cronyx.ru>
+ *
+ * This software is distributed with NO WARRANTIES, not even the implied
+ * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Authors grant any other persons or organisations permission to use
+ * or modify this software as long as this message is kept with the software,
+ * all derivative works or modified versions.
+ *
+ * Version 1.1, Mon Jul 10 21:55:11 MSD 1995
+ */
+
+/*
+ * Disk Controller ATAPI register definitions.
+ */
+#define AR_DATA         0x0             /* RW - data register (16 bits) */
+#define AR_ERROR        0x1             /*  R - error register */
+#define AR_FEATURES     0x1             /*  W - features */
+#define AR_IREASON      0x2             /* RW - interrupt reason */
+#define AR_TAG          0x3             /*    - reserved for SAM TAG byte */
+#define AR_CNTLO        0x4             /* RW - byte count, low byte */
+#define AR_CNTHI        0x5             /* RW - byte count, high byte */
+#define AR_DRIVE        0x6             /* RW - drive select */
+#define AR_COMMAND      0x7             /*  W - command register */
+#define AR_STATUS       0x7             /*  R - immediate status */
+
+/*
+ * Status register bits
+ */
+#define ARS_CHECK       0x01            /* error occured, see sense key/code */
+					/* bit 0x02 reserved */
+#define ARS_CORR        0x04            /* correctable error occured */
+#define ARS_DRQ         0x08            /* data request / ireason valid */
+#define ARS_DSC         0x10            /* immediate operation completed */
+#define ARS_DF          0x20            /* drive fault */
+#define ARS_DRDY        0x40            /* ready to get command */
+#define ARS_BSY         0x80            /* registers busy */
+					/* for overlap mode only: */
+#define ARS_SERVICE     0x10            /* service is requested */
+#define ARS_DMARDY      0x20            /* ready to start a DMA transfer */
+#define ARS_BITS        "\20\010busy\7ready\6fault\5opdone\4drq\3corr\1check"
+
+/*
+ * Error register bits
+ */
+#define AER_ILI         0x01            /* illegal length indication */
+#define AER_EOM         0x02            /* end of media detected */
+#define AER_ABRT        0x04            /* command aborted */
+#define AER_MCR         0x08            /* media change requested */
+#define AER_SKEY        0xf0            /* sense key mask */
+#define AER_SK_NO_SENSE         0x00    /* no spesific sense key info */
+#define AER_SK_RECOVERED_ERROR  0x10    /* command succeeded, data recovered */
+#define AER_SK_NOT_READY        0x20    /* no access to drive */
+#define AER_SK_MEDIUM_ERROR     0x30    /* non-recovered data error */
+#define AER_SK_HARDWARE_ERROR   0x40    /* non-recoverable hardware failure */
+#define AER_SK_ILLEGAL_REQUEST  0x50    /* invalid command parameter(s) */
+#define AER_SK_UNIT_ATTENTION   0x60    /* media changed */
+#define AER_SK_DATA_PROTECT     0x70    /* reading read-protected sector */
+#define AER_SK_ABORTED_COMMAND  0xb0    /* command aborted, try again */
+#define AER_SK_MISCOMPARE       0xe0    /* data did not match the medium */
+#define AER_BITS        "\20\4mchg\3abort\2eom\1ili"
+
+/*
+ * Feature register bits
+ */
+#define ARF_DMA         0x01            /* transfer data via DMA */
+#define ARF_OVERLAP     0x02            /* release the bus until completion */
+
+/*
+ * Interrupt reason register bits
+ */
+#define ARI_CMD         0x01            /* command(1) or data(0) */
+#define ARI_IN          0x02            /* transfer to(1) or from(0) the host */
+#define ARI_RELEASE     0x04            /* bus released until completion */
+
+/*
+ * Drive register values
+ */
+#define ARD_DRIVE0      0xa0            /* drive 0 selected */
+#define ARD_DRIVE1      0xb0            /* drive 1 selected */
+
+/*
+ * ATA commands
+ */
+#define ATAPIC_IDENTIFY         0xa1    /* get drive parameters */
+#define ATAPIC_PACKET           0xa0    /* execute packet command */
+
+/*
+ * Packet commands
+ */
+#define ATAPI_TEST_UNIT_READY   0x00    /* check if the device is ready */
+#define ATAPI_REQUEST_SENSE     0x03    /* get sense data */
+#define ATAPI_START_STOP        0x1b    /* start/stop the media */
+#define ATAPI_PREVENT_ALLOW     0x1e    /* prevent/allow media removal */
+#define ATAPI_READ_CAPACITY     0x25    /* get volume capacity */
+#define ATAPI_READ_BIG          0x28    /* read data */
+#define ATAPI_READ_TOC          0x43    /* get table of contents */
+#define ATAPI_READ_SUBCHANNEL   0x42    /* get subchannel info */
+#define ATAPI_PLAY_MSF          0x47    /* play by MSF address */
+#define ATAPI_PLAY_TRACK        0x48    /* play by track number */
+#define ATAPI_PAUSE             0x4b    /* stop/start audio operation */
+#define ATAPI_MODE_SELECT_BIG   0x55    /* set device parameters */
+#define ATAPI_MODE_SENSE        0x5a    /* get device parameters */
+#define ATAPI_PLAY_BIG          0xa5    /* play by logical block address */
+
+/*
+ * Drive parameter information
+ */
+struct atapi_params {
+	unsigned        cmdsz : 2;      /* packet command size */
+#define AT_PSIZE_12     0
+#define AT_PSIZE_16     1
+	unsigned : 3;
+	unsigned        drqtype : 2;    /* DRQ type */
+#define AT_DRQT_MPROC   0               /* microprocessor DRQ - 3 msec delay */
+#define AT_DRQT_INTR    1               /* interrupt DRQ - 10 msec delay */
+#define AT_DRQT_ACCEL   2               /* accelerated DRQ - 50 usec delay */
+	unsigned        removable : 1;  /* device is removable */
+	unsigned        devtype : 5;    /* packet command size */
+#define AT_TYPE_DIRECT  0               /* direct-access (magnetic disk) */
+#define AT_TYPE_TAPE    1               /* streaming tape (QIC-121 model) */
+#define AT_TYPE_CDROM   5               /* CD-ROM device */
+#define AT_TYPE_OPTICAL 7               /* optical disk */
+	unsigned : 1;
+	unsigned        proto : 2;      /* packet command size */
+#define AT_PROTO_ATAPI  2
+	short reserved1[9];
+	char            serial[20];     /* serial number - optional */
+	short reserved2[3];
+	char            revision[8];    /* firmware revision */
+	char            model[40];      /* model name */
+	short reserved3[2];
+	u_char          vendor_cap;     /* vendor unique capabilities */
+	unsigned        dmaflag : 1;    /* DMA supported */
+	unsigned        lbaflag : 1;    /* LBA supported - always 1 */
+	unsigned        iordydis : 1;   /* IORDY can be disabled */
+	unsigned        iordyflag : 1;  /* IORDY supported */
+	unsigned : 1;
+	unsigned        ovlapflag : 1;  /* overlap operation supported */
+	unsigned : 1;
+	unsigned        idmaflag : 1;   /* interleaved DMA supported */
+	short reserved4;
+	u_short         pio_timing;     /* PIO cycle timing */
+	u_short         dma_timing;     /* DMA cycle timing */
+	u_short         flags;          /* flags */
+#define AT_FLAG_54_58   1               /* words 54-58 valid */
+#define AT_FLAG_64_70   2               /* words 64-70 valid */
+	short reserved5[8];
+	u_char          swdma_flag;     /* singleword DMA mode supported */
+	u_char          swdma_active;   /* singleword DMA mode active */
+	u_char          mwdma_flag;     /* multiword DMA mode supported */
+	u_char          mwdma_active;   /* multiword DMA mode active */
+	u_char          apio_flag;      /* advanced PIO mode supported */
+	u_char reserved6;
+	u_short         mwdma_min;      /* min. M/W DMA time per word (ns) */
+	u_short         mwdma_dflt;     /* recommended M/W DMA time (ns) - optional */
+	u_short         pio_nfctl_min;  /* min. PIO cycle time w/o flow ctl - optional */
+	u_short         pio_iordy_min;  /* min. PIO c/t with IORDY flow ctl - optional */
+	short reserved7[2];
+	u_short         rls_ovlap;      /* release time (us) for overlap cmd - optional */
+	u_short         rls_service;    /* release time (us) for service cmd - optional */
+};
+
+/*
+ * ATAPI operation result structure
+ */
+struct atapires {
+	u_char code;                    /* result code */
+#define RES_OK          0               /* i/o done */
+#define RES_ERR         1               /* i/o finished with error */
+#define RES_NOTRDY      2               /* controller not ready */
+#define RES_NODRQ       3               /* no data request */
+#define RES_INVDIR      4               /* invalid bus phase direction */
+#define RES_OVERRUN     5               /* data overrun */
+#define RES_UNDERRUN    6               /* data underrun */
+	u_char status;                  /* status register contents */
+	u_char error;                   /* error register contents */
+};
+
+#ifdef KERNEL
+struct atapi;
+struct kern_devconf;
+void atapi_attach (int ctlr, int unit, int port, struct kern_devconf*);
+int atapi_start (int ctrlr);
+int atapi_intr (int ctrlr);
+void atapi_debug (struct atapi *ata, int on);
+struct atapires atapi_request_wait (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count);
+void atapi_request_callback (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count, void (*done)(), void *x, void *y);
+struct atapires atapi_request_immediate (struct atapi *ata, int unit,
+	u_char cmd, u_char a1, u_char a2, u_char a3, u_char a4,
+	u_char a5, u_char a6, u_char a7, u_char a8, u_char a9,
+	u_char a10, u_char a11, u_char a12, u_char a13, u_char a14, u_char a15,
+	char *addr, int count);
+#endif