From 2fc1b2c314d8695720cde9bd268065f4ab4c1541 Mon Sep 17 00:00:00 2001 From: Yoshihiro Takahashi Date: Fri, 3 Dec 1999 12:56:21 +0000 Subject: [PATCH] pc98/pc98/atapi.c Copied from i386/isa/atapi.c. Fixed to support slave devices. Ignore the device that has strange model strings. i386/isa/atapi.c Removed pc98 codes. Submitted by: chi@bd.mbn.or.jp (Chiharu Shibata) --- sys/conf/files.pc98 | 2 +- sys/i386/isa/atapi.c | 34 +- sys/pc98/conf/files.pc98 | 2 +- sys/pc98/pc98/atapi.c | 988 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 992 insertions(+), 34 deletions(-) create mode 100644 sys/pc98/pc98/atapi.c diff --git a/sys/conf/files.pc98 b/sys/conf/files.pc98 index 33a588b53493..34d07d6bbf2e 100644 --- a/sys/conf/files.pc98 +++ b/sys/conf/files.pc98 @@ -178,7 +178,7 @@ i386/isa/bs/bsif.c optional bs #i386/isa/adv_isa.c optional adv i386/isa/asc.c optional asc i386/isa/atapi-cd.c optional wcd -i386/isa/atapi.c optional wdc +pc98/pc98/atapi.c optional wdc pc98/pc98/clock.c standard i386/isa/cronyx.c optional cx i386/isa/ctx.c optional ctx diff --git a/sys/i386/isa/atapi.c b/sys/i386/isa/atapi.c index 857637371456..8ee0164bcaf0 100644 --- a/sys/i386/isa/atapi.c +++ b/sys/i386/isa/atapi.c @@ -12,6 +12,8 @@ * all derivative works or modified versions. * * Version 1.9, Mon Oct 9 22:34:47 MSK 1995 + * + * $FreeBSD$ */ /* @@ -366,18 +368,9 @@ static struct atapi_params *atapi_probe (int port, int unit) { struct atapi_params *ap; char tb [DEV_BSIZE]; -#ifdef PC98 - int cnt; - outb(0x432,unit%2); - print(("unit = %d,select %d\n",unit,unit%2)); -#endif /* Wait for controller not busy. */ -#ifdef PC98 - outb (port + AR_DRIVE, unit / 2 ? ARD_DRIVE1 : ARD_DRIVE0); -#else outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0); -#endif if (atapi_wait (port, 0) < 0) { print (("atapiX.%d at 0x%x: controller busy, status=%b\n", unit, port, inb (port + AR_STATUS), ARS_BITS)); @@ -385,20 +378,8 @@ static struct atapi_params *atapi_probe (int port, int unit) } /* Issue ATAPI IDENTIFY command. */ -#ifdef PC98 - outb (port + AR_DRIVE, unit/2 ? ARD_DRIVE1 : ARD_DRIVE0); - - /* Wait for DRQ deassert. */ - for (cnt=2000; cnt>0; --cnt) - if (! (inb (port + AR_STATUS) & ARS_DRQ)) - break; - - outb (port + AR_COMMAND, ATAPIC_IDENTIFY); - DELAY(500); -#else outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0); outb (port + AR_COMMAND, ATAPIC_IDENTIFY); -#endif /* Check that device is present. */ if (inb (port + AR_STATUS) == 0xff) { @@ -588,13 +569,7 @@ int atapi_start_cmd (struct atapi *ata, struct atapicmd *ac) ac->result.error = 0; ac->result.status = 0; -#ifdef PC98 - outb(0x432,(ac->unit)%2); - print(("(ac->unit) = %d,select %d (2) \n",(ac->unit),(ac->unit)%2)); - outb (ata->port + AR_DRIVE, (ac->unit)/2 ? ARD_DRIVE1 : ARD_DRIVE0); -#else outb (ata->port + AR_DRIVE, ac->unit ? ARD_DRIVE1 : ARD_DRIVE0); -#endif if (atapi_wait (ata->port, 0) < 0) { printf ("atapi%d.%d: controller not ready for cmd\n", ata->ctrlr, ac->unit); @@ -676,11 +651,6 @@ int atapi_intr (int ctrlr) struct atapi *ata = atapitab + ctrlr; struct atapicmd *ac = ata->queue; -#ifdef PC98 - outb(0x432,(ac->unit)%2); - print(("atapi_intr:(ac->unit)= %d,select %d\n",ac->unit,(ac->unit)%2)); -#endif - if (! ac) { printf ("atapi%d: stray interrupt\n", ata->ctrlr); return (0); diff --git a/sys/pc98/conf/files.pc98 b/sys/pc98/conf/files.pc98 index 33a588b53493..34d07d6bbf2e 100644 --- a/sys/pc98/conf/files.pc98 +++ b/sys/pc98/conf/files.pc98 @@ -178,7 +178,7 @@ i386/isa/bs/bsif.c optional bs #i386/isa/adv_isa.c optional adv i386/isa/asc.c optional asc i386/isa/atapi-cd.c optional wcd -i386/isa/atapi.c optional wdc +pc98/pc98/atapi.c optional wdc pc98/pc98/clock.c standard i386/isa/cronyx.c optional cx i386/isa/ctx.c optional ctx diff --git a/sys/pc98/pc98/atapi.c b/sys/pc98/pc98/atapi.c new file mode 100644 index 000000000000..eda6ee011c94 --- /dev/null +++ b/sys/pc98/pc98/atapi.c @@ -0,0 +1,988 @@ +/* + * Device-independent level for ATAPI drivers. + * + * Copyright (C) 1995 Cronyx Ltd. + * Author Serge Vakulenko, + * + * 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.9, Mon Oct 9 22:34:47 MSK 1995 + * + * $FreeBSD$ + */ + +/* + * 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 xxxattach()). + * 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 "wdc.h" + +#include "wcd.h" +#include "wfd.h" +#include "wst.h" +/* #include "wmd.h" -- add your driver here */ + +#if NWDC > 0 + +#include +#include +#include + +#include + +#include + +/* this code is compiled part of the module */ + +#ifdef DEBUG +# define print(s) printf s +#else +# define print(s) {/*void*/} +#endif + +/* + * 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) +#define PHASE_ABORTED 0 /* nonstandard - for NEC 260 */ + +static 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 void wdstart (int ctrlr); +extern int acdattach(struct atapi*, int, struct atapi_params*, int); +extern int wfdattach(struct atapi*, int, struct atapi_params*, int); +extern int wstattach(struct atapi*, int, struct atapi_params*, int); + +/* + * Probe the ATAPI device at IDE controller `ctlr', drive `unit'. + * Called at splbio(). + */ +int atapi_attach (int ctlr, int unit, int port) +{ + struct atapi *ata = atapitab + ctlr; + struct atapi_params *ap; + char buf [sizeof(ap->model) + 1]; + char revbuf [sizeof(ap->revision) + 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 (0); + + bcopy (ap->model, buf, sizeof(buf)-1); + buf[sizeof(buf)-1] = 0; + + bcopy (ap->revision, revbuf, sizeof(revbuf)-1); + revbuf[sizeof(revbuf)-1] = 0; + + printf ("wdc%d: unit %d (atapi): <%s/%s>", ctlr, unit, buf, revbuf); + + /* 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"); ata->accel = 1; break; + default: printf (", drq%d", ap->drqtype); + } + if (ata->slow) + ata->intrcmd = 0; + + /* + * If we have two devices, one supporting INTR and one ACCEL, we + * have to pessimise - clear INTR and set slow. + */ + if (ata->accel && ata->intrcmd) { + ata->intrcmd = 0; + ata->slow = 1; + } + + /* 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; + ata->attached[unit] = 0; +#ifdef DEBUG + ata->debug = 1; +#else + ata->debug = 0; +#endif + /* Initialize free queue. */ + ata->cmdrq[15].next = 0; + for (ac = ata->cmdrq+14; 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 (0); + } + 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_DIRECT: /* direct-access */ +#if NWFD > 0 + /* ATAPI Floppy(LS-120) */ + if (wfdattach (ata, unit, ap, ata->debug) < 0) + break; + /* Device attached successfully. */ + ata->attached[unit] = 1; + return (1); +#else + printf ("wdc%d: ATAPI Floppies not configured\n", ctlr); + break; +#endif + case AT_TYPE_CDROM: /* CD-ROM device */ +#if NWCD > 0 + /* ATAPI CD-ROM & CD-R/RW drives */ + if (acdattach (ata, unit, ap, ata->debug) < 0) + break; + ata->attached[unit] = 1; + return (1); +#else + printf ("wdc%d: ATAPI CD-ROMs not configured\n", ctlr); + break; +#endif + + case AT_TYPE_TAPE: /* streaming tape */ +#if NWST > 0 + /* ATAPI Streaming Tape */ + if (wstattach (ata, unit, ap, ata->debug) < 0) + break; + /* Device attached successfully. */ + ata->attached[unit] = 1; + return (1); +#else + printf ("wdc%d: ATAPI streaming tapes not configured\n", ctlr); +#endif + break; + + 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); +#endif + break; + } + /* Attach failed. */ + free (ap, M_TEMP); + return (0); +} + +static char *cmdname (u_char cmd) +{ + static char buf[8]; + + switch (cmd) { + case 0x00: return ("TEST_UNIT_READY"); + case 0x01: return ("REZERO_UNIT"); + case 0x03: return ("REQUEST_SENSE"); + case 0x04: return ("FORMAT_UNIT"); + case 0x1b: return ("START_STOP"); + case 0x1e: return ("PREVENT_ALLOW"); + case 0x25: return ("READ_CAPACITY"); + case 0x28: return ("READ_BIG"); + case 0x2a: return ("WRITE_BIG"); + case 0x35: return ("SYNCHRONIZE_CACHE"); + case 0x42: return ("READ_SUBCHANNEL"); + case 0x43: return ("READ_TOC"); + case 0x51: return ("READ_DISC_INFO"); + case 0x52: return ("READ_TRACK_INFO"); + case 0x53: return ("RESERVE_TRACK"); + case 0x54: return ("SEND_OPC_INFO"); + case 0x55: return ("MODE_SELECT"); + case 0x58: return ("REPAIR_TRACK"); + case 0x59: return ("READ_MASTER_CUE"); + case 0x5a: return ("MODE_SENSE"); + case 0x5b: return ("CLOSE_TRACK/SESSION"); + case 0x5c: return ("READ_BUFFER_CAPACITY"); + case 0x5d: return ("SEND_CUE_SHEET"); + case 0x47: return ("PLAY_MSF"); + case 0x4b: return ("PAUSE"); + case 0x48: return ("PLAY_TRACK"); + case 0xa1: return ("BLANK_CMD"); + case 0xa5: return ("PLAY_BIG"); + case 0xb4: return ("PLAY_CD"); + case 0xbd: return ("ATAPI_MECH_STATUS"); + case 0xbe: return ("READ_CD"); + } + snprintf (buf, sizeof(buf), "[0x%x]", cmd); + return (buf); +} + +static void bswap (char *buf, int len) +{ + u_short *p = (u_short*) (buf + len); + while (--p >= (u_short*) buf) + *p = ntohs (*p); +} + +static void btrim (char *buf, int len) +{ + char *p; + + /* Remove the trailing spaces. */ + for (p=buf; p=buf && *p==' '; --p) + *p = 0; +} + +/* + * 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]; +#ifdef PC98 + int cnt; + + outb(0x432,unit%2); + print(("unit = %d,select %d\n",unit,unit%2)); +#endif + /* Wait for controller not busy. */ +#ifdef PC98 + outb (port + AR_DRIVE, unit / 2 ? ARD_DRIVE1 : ARD_DRIVE0); +#else + outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0); +#endif + if (atapi_wait (port, 0) < 0) { + print (("atapiX.%d at 0x%x: controller busy, status=%b\n", + unit, port, inb (port + AR_STATUS), ARS_BITS)); + return (0); + } + + /* Issue ATAPI IDENTIFY command. */ +#ifdef PC98 + outb (port + AR_DRIVE, unit/2 ? ARD_DRIVE1 : ARD_DRIVE0); + + /* Wait for DRQ deassert. */ + for (cnt=2000; cnt>0; --cnt) + if (! (inb (port + AR_STATUS) & ARS_DRQ)) + break; + + outb (port + AR_COMMAND, ATAPIC_IDENTIFY); + DELAY(500); +#else + outb (port + AR_DRIVE, unit ? ARD_DRIVE1 : ARD_DRIVE0); + outb (port + AR_COMMAND, ATAPIC_IDENTIFY); +#endif + + /* Check that device is present. */ + if (inb (port + AR_STATUS) == 0xff) { + print (("atapiX.%d at 0x%x: no device\n", unit, port)); +#ifdef PC98 + if (unit / 2) +#else + if (unit == 1) +#endif + /* Select unit 0. */ + outb (port + AR_DRIVE, ARD_DRIVE0); + return (0); + } + + /* Wait for data ready. */ + if (atapi_wait (port, ARS_DRQ) != 0) { + print (("atapiX.%d at 0x%x: identify not ready, status=%b\n", + unit, port, inb (port + AR_STATUS), ARS_BITS)); +#ifdef PC98 + if (unit / 2) +#else + if (unit == 1) +#endif + /* Select unit 0. */ + outb (port + AR_DRIVE, ARD_DRIVE0); + return (0); + } + + /* check that DRQ isn't a fake */ + if (inb (port + AR_STATUS) == 0xff) { + print (("atapiX.%d at 0x%x: no device\n", unit, port)); +#ifdef PC98 + if (unit / 2) +#else + if (unit == 1) +#endif + /* 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); + +#ifdef PC98 + /* + * Check model string. + * If all of it makes unprintable characters, ignore this device. + */ + for (cnt = 0; cnt < sizeof(ap->model)-1; cnt++) { + if (ap->model[cnt] >= ' ') + break; + } + if (cnt >= sizeof(ap->model)-1) { + free (ap, M_TEMP); + return (0); + } +#endif + + /* + * Shuffle string byte order. + * Mitsumi and NEC drives don't need this. + */ + if (! ((ap->model[0] == 'N' && ap->model[1] == 'E') || + (ap->model[0] == 'F' && ap->model[1] == 'X'))) + bswap (ap->model, sizeof(ap->model)); + bswap (ap->serial, sizeof(ap->serial)); + bswap (ap->revision, sizeof(ap->revision)); + + /* Clean up the model name, serial and revision numbers. */ + btrim (ap->model, sizeof(ap->model)); + btrim (ap->serial, sizeof(ap->serial)); + btrim (ap->revision, sizeof(ap->revision)); + 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", 100); + 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; + +#ifdef PC98 + outb(0x432,(ac->unit)%2); + print(("(ac->unit) = %d,select %d (2) \n",(ac->unit),(ac->unit)%2)); + outb (ata->port + AR_DRIVE, (ac->unit)/2 ? ARD_DRIVE1 : ARD_DRIVE0); +#else + outb (ata->port + AR_DRIVE, ac->unit ? ARD_DRIVE1 : ARD_DRIVE0); +#endif + 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 100 usec to 3 msec for slow devices */ + int cnt = ata->intrcmd ? 10000 : ata->slow ? 3000 : 100; + int ireason = 0, phase = 0; + + /* Wait for command phase. */ + for (; cnt>0; cnt-=10) { + ireason = inb (ata->port + AR_IREASON); + ac->result.status = inb (ata->port + AR_STATUS); + phase = (ireason & (ARI_CMD | ARI_IN)) | + (ac->result.status & (ARS_DRQ | ARS_BSY)); + if (phase == PHASE_CMDOUT) + break; + DELAY (10); + } + + if (phase != PHASE_CMDOUT) { + ac->result.code = RES_NODRQ; + ac->result.error = inb (ata->port + AR_ERROR); + printf ("atapi%d.%d: invalid command phase, ireason=0x%x, status=%b, error=%b\n", + ata->ctrlr, ac->unit, ireason, + ac->result.status, ARS_BITS, + ac->result.error, AER_BITS); + 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 %s %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x\n", + ata->ctrlr, ac->unit, cmdname (ac->cmd[0]), 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; + +#ifdef PC98 + outb(0x432,(ac->unit)%2); + print(("atapi_intr:(ac->unit)= %d,select %d\n",ac->unit,(ac->unit)%2)); +#endif + + 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, i; + + if (atapi_wait (ata->port, 0) < 0) { + ac->result.status = inb (ata->port + AR_STATUS); + ac->result.error = inb (ata->port + AR_ERROR); + ac->result.code = RES_NOTRDY; + printf ("atapi%d.%d: controller not ready, status=%b, error=%b\n", + ata->ctrlr, ac->unit, ac->result.status, ARS_BITS, + ac->result.error, AER_BITS); + 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) { + print (("atapi%d.%d: send data underrun, %d bytes left\n", + ata->ctrlr, ac->unit, -ac->count)); + ac->result.code = RES_UNDERRUN; + outsw (ata->port + AR_DATA, ac->addr, + -ac->count / sizeof(short)); + for (i= -ac->count; iport + AR_DATA, 0); + } else + 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) { + print (("atapi%d.%d: recv data overrun, %d bytes left\n", + ata->ctrlr, ac->unit, ac->count)); + ac->result.code = RES_OVERRUN; + insw (ata->port + AR_DATA, ac->addr, + ac->count / sizeof(short)); + for (i=ac->count; iport + AR_DATA); + } else + insw (ata->port + AR_DATA, ac->addr, + len / sizeof(short)); + ac->addr += len; + ac->count -= len; + return (1); + + case PHASE_ABORTED: + case PHASE_COMPLETED: + if (ac->result.status & (ARS_CHECK | ARS_DF)) + ac->result.code = RES_ERR; + else if (ac->count < 0) { + print (("atapi%d.%d: send data overrun, %d bytes left\n", + ata->ctrlr, ac->unit, -ac->count)); + ac->result.code = RES_OVERRUN; + } else if (ac->count > 0) { + print (("atapi%d.%d: recv data underrun, %d bytes left\n", + ata->ctrlr, ac->unit, ac->count)); + ac->result.code = RES_UNDERRUN; + bzero (ac->addr, ac->count); + } else + 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, atapi_callback_t *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); + if (ata->tail == ac) + 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); + + /* Wait for data i/o phase. */ + for (cnt=20000; cnt>0; --cnt) + if (((inb (ata->port + AR_IREASON) & (ARI_CMD | ARI_IN)) | + (inb (ata->port + AR_STATUS) & ARS_DRQ)) != PHASE_CMDOUT) + break; + + /* 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; + DELAY(10); + } + } + return (ac->result); +} + +#endif /* NWDC */