Bring in Serge Vakulenko's IDE CDROM (ATAPI) driver. A number of
people have now indicated to me that it's working more than well enough to bring into -current. Submitted by: Serge Vakulenko <vak@cronyx.ru>
This commit is contained in:
parent
649ed5d50c
commit
f4568c6696
@ -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
|
||||
|
||||
|
@ -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
|
||||
@ -492,6 +492,16 @@ 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 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'
|
||||
#
|
||||
|
@ -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 \
|
||||
|
@ -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
|
||||
|
||||
|
@ -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
|
||||
@ -492,6 +492,16 @@ 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 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'
|
||||
#
|
||||
|
@ -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
|
||||
@ -492,6 +492,16 @@ 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 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'
|
||||
#
|
||||
|
@ -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 \
|
||||
|
@ -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]);
|
||||
|
||||
|
822
sys/i386/isa/atapi.c
Normal file
822
sys/i386/isa/atapi.c
Normal file
@ -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 */
|
206
sys/i386/isa/atapi.h
Normal file
206
sys/i386/isa/atapi.h
Normal file
@ -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
|
921
sys/i386/isa/wcd.c
Normal file
921
sys/i386/isa/wcd.c
Normal file
@ -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 */
|
@ -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);
|
||||
|
206
sys/pc98/pc98/atapi.h
Normal file
206
sys/pc98/pc98/atapi.h
Normal file
@ -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
|
Loading…
Reference in New Issue
Block a user