boot monitor. Added SCSI_SENSE command that asks the drive, with request sense, about diagnostics for the previous error. This command is called and the results printed when atapi_debug is enabled and atapi errors occur. Debug output also prints actual commands sent to the drive. Suddenly, Andy's problem has vanished. Don't know why, minor changes (e.g. moving the atapi packet data from stack to static) shouldn't have fixed this.. But with the debug info, we stand a better chance of finding out what it was if it occurs again.
1704 lines
54 KiB
C
1704 lines
54 KiB
C
/* This file contains the device dependent part of a driver for the IBM-AT
|
|
* winchester controller. Written by Adri Koppes.
|
|
*
|
|
* The file contains one entry point:
|
|
*
|
|
* at_winchester_task: main entry when system is brought up
|
|
*
|
|
* Changes:
|
|
* Aug 19, 2005 ata pci support, supports SATA (Ben Gras)
|
|
* Nov 18, 2004 moved AT disk driver to user-space (Jorrit N. Herder)
|
|
* Aug 20, 2004 watchdogs replaced by sync alarms (Jorrit N. Herder)
|
|
* Mar 23, 2000 added ATAPI CDROM support (Michael Temari)
|
|
* May 14, 2000 d-d/i rewrite (Kees J. Bot)
|
|
* Apr 13, 1992 device dependent/independent split (Kees J. Bot)
|
|
*/
|
|
|
|
#include "at_wini.h"
|
|
#include "../libpci/pci.h"
|
|
|
|
#include <minix/sysutil.h>
|
|
#include <minix/keymap.h>
|
|
#include <sys/ioc_disk.h>
|
|
|
|
#define ATAPI_DEBUG 0 /* To debug ATAPI code. */
|
|
|
|
/* I/O Ports used by winchester disk controllers. */
|
|
|
|
/* Read and write registers */
|
|
#define REG_CMD_BASE0 0x1F0 /* command base register of controller 0 */
|
|
#define REG_CMD_BASE1 0x170 /* command base register of controller 1 */
|
|
#define REG_CTL_BASE0 0x3F6 /* control base register of controller 0 */
|
|
#define REG_CTL_BASE1 0x376 /* control base register of controller 1 */
|
|
|
|
#define REG_DATA 0 /* data register (offset from the base reg.) */
|
|
#define REG_PRECOMP 1 /* start of write precompensation */
|
|
#define REG_COUNT 2 /* sectors to transfer */
|
|
#define REG_SECTOR 3 /* sector number */
|
|
#define REG_CYL_LO 4 /* low byte of cylinder number */
|
|
#define REG_CYL_HI 5 /* high byte of cylinder number */
|
|
#define REG_LDH 6 /* lba, drive and head */
|
|
#define LDH_DEFAULT 0xA0 /* ECC enable, 512 bytes per sector */
|
|
#define LDH_LBA 0x40 /* Use LBA addressing */
|
|
#define ldh_init(drive) (LDH_DEFAULT | ((drive) << 4))
|
|
|
|
/* Read only registers */
|
|
#define REG_STATUS 7 /* status */
|
|
#define STATUS_BSY 0x80 /* controller busy */
|
|
#define STATUS_RDY 0x40 /* drive ready */
|
|
#define STATUS_WF 0x20 /* write fault */
|
|
#define STATUS_SC 0x10 /* seek complete (obsolete) */
|
|
#define STATUS_DRQ 0x08 /* data transfer request */
|
|
#define STATUS_CRD 0x04 /* corrected data */
|
|
#define STATUS_IDX 0x02 /* index pulse */
|
|
#define STATUS_ERR 0x01 /* error */
|
|
#define STATUS_ADMBSY 0x100 /* administratively busy (software) */
|
|
#define REG_ERROR 1 /* error code */
|
|
#define ERROR_BB 0x80 /* bad block */
|
|
#define ERROR_ECC 0x40 /* bad ecc bytes */
|
|
#define ERROR_ID 0x10 /* id not found */
|
|
#define ERROR_AC 0x04 /* aborted command */
|
|
#define ERROR_TK 0x02 /* track zero error */
|
|
#define ERROR_DM 0x01 /* no data address mark */
|
|
|
|
/* Write only registers */
|
|
#define REG_COMMAND 7 /* command */
|
|
#define CMD_IDLE 0x00 /* for w_command: drive idle */
|
|
#define CMD_RECALIBRATE 0x10 /* recalibrate drive */
|
|
#define CMD_READ 0x20 /* read data */
|
|
#define CMD_READ_EXT 0x24 /* read data (LBA48 addressed) */
|
|
#define CMD_WRITE 0x30 /* write data */
|
|
#define CMD_WRITE_EXT 0x34 /* write data (LBA48 addressed) */
|
|
#define CMD_READVERIFY 0x40 /* read verify */
|
|
#define CMD_FORMAT 0x50 /* format track */
|
|
#define CMD_SEEK 0x70 /* seek cylinder */
|
|
#define CMD_DIAG 0x90 /* execute device diagnostics */
|
|
#define CMD_SPECIFY 0x91 /* specify parameters */
|
|
#define ATA_IDENTIFY 0xEC /* identify drive */
|
|
/* #define REG_CTL 0x206 */ /* control register */
|
|
#define REG_CTL 0 /* control register */
|
|
#define CTL_NORETRY 0x80 /* disable access retry */
|
|
#define CTL_NOECC 0x40 /* disable ecc retry */
|
|
#define CTL_EIGHTHEADS 0x08 /* more than eight heads */
|
|
#define CTL_RESET 0x04 /* reset controller */
|
|
#define CTL_INTDISABLE 0x02 /* disable interrupts */
|
|
|
|
#if ENABLE_ATAPI
|
|
#define ERROR_SENSE 0xF0 /* sense key mask */
|
|
#define SENSE_NONE 0x00 /* no sense key */
|
|
#define SENSE_RECERR 0x10 /* recovered error */
|
|
#define SENSE_NOTRDY 0x20 /* not ready */
|
|
#define SENSE_MEDERR 0x30 /* medium error */
|
|
#define SENSE_HRDERR 0x40 /* hardware error */
|
|
#define SENSE_ILRQST 0x50 /* illegal request */
|
|
#define SENSE_UATTN 0x60 /* unit attention */
|
|
#define SENSE_DPROT 0x70 /* data protect */
|
|
#define SENSE_ABRT 0xb0 /* aborted command */
|
|
#define SENSE_MISCOM 0xe0 /* miscompare */
|
|
#define ERROR_MCR 0x08 /* media change requested */
|
|
#define ERROR_ABRT 0x04 /* aborted command */
|
|
#define ERROR_EOM 0x02 /* end of media detected */
|
|
#define ERROR_ILI 0x01 /* illegal length indication */
|
|
#define REG_FEAT 1 /* features */
|
|
#define FEAT_OVERLAP 0x02 /* overlap */
|
|
#define FEAT_DMA 0x01 /* dma */
|
|
#define REG_IRR 2 /* interrupt reason register */
|
|
#define IRR_REL 0x04 /* release */
|
|
#define IRR_IO 0x02 /* direction for xfer */
|
|
#define IRR_COD 0x01 /* command or data */
|
|
#define REG_SAMTAG 3
|
|
#define REG_CNT_LO 4 /* low byte of cylinder number */
|
|
#define REG_CNT_HI 5 /* high byte of cylinder number */
|
|
#define REG_DRIVE 6 /* drive select */
|
|
#define REG_STATUS 7 /* status */
|
|
#define STATUS_BSY 0x80 /* controller busy */
|
|
#define STATUS_DRDY 0x40 /* drive ready */
|
|
#define STATUS_DMADF 0x20 /* dma ready/drive fault */
|
|
#define STATUS_SRVCDSC 0x10 /* service or dsc */
|
|
#define STATUS_DRQ 0x08 /* data transfer request */
|
|
#define STATUS_CORR 0x04 /* correctable error occurred */
|
|
#define STATUS_CHECK 0x01 /* check error */
|
|
|
|
#define ATAPI_PACKETCMD 0xA0 /* packet command */
|
|
#define ATAPI_IDENTIFY 0xA1 /* identify drive */
|
|
#define SCSI_READ10 0x28 /* read from disk */
|
|
#define SCSI_SENSE 0x03 /* sense request */
|
|
|
|
#define CD_SECTOR_SIZE 2048 /* sector size of a CD-ROM */
|
|
#endif /* ATAPI */
|
|
|
|
/* Interrupt request lines. */
|
|
#define NO_IRQ 0 /* no IRQ set yet */
|
|
|
|
#define ATAPI_PACKETSIZE 12
|
|
#define SENSE_PACKETSIZE 18
|
|
|
|
/* Common command block */
|
|
struct command {
|
|
u8_t precomp; /* REG_PRECOMP, etc. */
|
|
u8_t count;
|
|
u8_t sector;
|
|
u8_t cyl_lo;
|
|
u8_t cyl_hi;
|
|
u8_t ldh;
|
|
u8_t command;
|
|
};
|
|
|
|
/* Error codes */
|
|
#define ERR (-1) /* general error */
|
|
#define ERR_BAD_SECTOR (-2) /* block marked bad detected */
|
|
|
|
/* Some controllers don't interrupt, the clock will wake us up. */
|
|
#define WAKEUP (32*HZ) /* drive may be out for 31 seconds max */
|
|
|
|
/* Miscellaneous. */
|
|
#define MAX_DRIVES 8
|
|
#define COMPAT_DRIVES 4
|
|
#if _WORD_SIZE > 2
|
|
#define MAX_SECS 256 /* controller can transfer this many sectors */
|
|
#else
|
|
#define MAX_SECS 127 /* but not to a 16 bit process */
|
|
#endif
|
|
#define MAX_ERRORS 4 /* how often to try rd/wt before quitting */
|
|
#define NR_MINORS (MAX_DRIVES * DEV_PER_DRIVE)
|
|
#define SUB_PER_DRIVE (NR_PARTITIONS * NR_PARTITIONS)
|
|
#define NR_SUBDEVS (MAX_DRIVES * SUB_PER_DRIVE)
|
|
#define DELAY_USECS 1000 /* controller timeout in microseconds */
|
|
#define DELAY_TICKS 1 /* controller timeout in ticks */
|
|
#define DEF_TIMEOUT_TICKS 300 /* controller timeout in ticks */
|
|
#define RECOVERY_USECS 500000 /* controller recovery time in microseconds */
|
|
#define RECOVERY_TICKS 30 /* controller recovery time in ticks */
|
|
#define INITIALIZED 0x01 /* drive is initialized */
|
|
#define DEAF 0x02 /* controller must be reset */
|
|
#define SMART 0x04 /* drive supports ATA commands */
|
|
#if ENABLE_ATAPI
|
|
#define ATAPI 0x08 /* it is an ATAPI device */
|
|
#else
|
|
#define ATAPI 0 /* don't bother with ATAPI; optimise out */
|
|
#endif
|
|
#define IDENTIFIED 0x10 /* w_identify done successfully */
|
|
#define IGNORING 0x20 /* w_identify failed once */
|
|
|
|
/* Timeouts and max retries. */
|
|
int timeout_ticks = DEF_TIMEOUT_TICKS, max_errors = MAX_ERRORS;
|
|
int wakeup_ticks = WAKEUP;
|
|
long w_standard_timeouts = 0, w_pci_debug = 0, w_instance = 0,
|
|
w_lba48 = 0, atapi_debug = 0;
|
|
|
|
int w_testing = 0, w_silent = 0;
|
|
|
|
int w_next_drive = 0;
|
|
|
|
/* Variables. */
|
|
|
|
/* wini is indexed by controller first, then drive (0-3).
|
|
* controller 0 is always the 'compatability' ide controller, at
|
|
* the fixed locations, whether present or not.
|
|
*/
|
|
PRIVATE struct wini { /* main drive struct, one entry per drive */
|
|
unsigned state; /* drive state: deaf, initialized, dead */
|
|
unsigned w_status; /* device status register */
|
|
unsigned base_cmd; /* command base register */
|
|
unsigned base_ctl; /* control base register */
|
|
unsigned irq; /* interrupt request line */
|
|
unsigned irq_mask; /* 1 << irq */
|
|
unsigned irq_need_ack; /* irq needs to be acknowledged */
|
|
int irq_hook_id; /* id of irq hook at the kernel */
|
|
int lba48; /* supports lba48 */
|
|
unsigned lcylinders; /* logical number of cylinders (BIOS) */
|
|
unsigned lheads; /* logical number of heads */
|
|
unsigned lsectors; /* logical number of sectors per track */
|
|
unsigned pcylinders; /* physical number of cylinders (translated) */
|
|
unsigned pheads; /* physical number of heads */
|
|
unsigned psectors; /* physical number of sectors per track */
|
|
unsigned ldhpref; /* top four bytes of the LDH (head) register */
|
|
unsigned precomp; /* write precompensation cylinder / 4 */
|
|
unsigned max_count; /* max request for this drive */
|
|
unsigned open_ct; /* in-use count */
|
|
struct device part[DEV_PER_DRIVE]; /* disks and partitions */
|
|
struct device subpart[SUB_PER_DRIVE]; /* subpartitions */
|
|
} wini[MAX_DRIVES], *w_wn;
|
|
|
|
PRIVATE int w_device = -1;
|
|
PRIVATE int w_controller = -1;
|
|
PRIVATE int w_major = -1;
|
|
PRIVATE char w_id_string[40];
|
|
|
|
PRIVATE int win_tasknr; /* my task number */
|
|
PRIVATE int w_command; /* current command in execution */
|
|
PRIVATE u8_t w_byteval; /* used for SYS_IRQCTL */
|
|
PRIVATE int w_drive; /* selected drive */
|
|
PRIVATE int w_controller; /* selected controller */
|
|
PRIVATE struct device *w_dv; /* device's base and size */
|
|
|
|
FORWARD _PROTOTYPE( void init_params, (void) );
|
|
FORWARD _PROTOTYPE( void init_drive, (struct wini *, int, int, int, int, int, int));
|
|
FORWARD _PROTOTYPE( void init_params_pci, (int) );
|
|
FORWARD _PROTOTYPE( int w_do_open, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( struct device *w_prepare, (int dev) );
|
|
FORWARD _PROTOTYPE( int w_identify, (void) );
|
|
FORWARD _PROTOTYPE( char *w_name, (void) );
|
|
FORWARD _PROTOTYPE( int w_specify, (void) );
|
|
FORWARD _PROTOTYPE( int w_io_test, (void) );
|
|
FORWARD _PROTOTYPE( int w_transfer, (int proc_nr, int opcode, off_t position,
|
|
iovec_t *iov, unsigned nr_req) );
|
|
FORWARD _PROTOTYPE( int com_out, (struct command *cmd) );
|
|
FORWARD _PROTOTYPE( void w_need_reset, (void) );
|
|
FORWARD _PROTOTYPE( void ack_irqs, (unsigned int) );
|
|
FORWARD _PROTOTYPE( int w_do_close, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( int w_other, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( int w_hw_int, (struct driver *dp, message *m_ptr) );
|
|
FORWARD _PROTOTYPE( int com_simple, (struct command *cmd) );
|
|
FORWARD _PROTOTYPE( void w_timeout, (void) );
|
|
FORWARD _PROTOTYPE( int w_reset, (void) );
|
|
FORWARD _PROTOTYPE( void w_intr_wait, (void) );
|
|
FORWARD _PROTOTYPE( int at_intr_wait, (void) );
|
|
FORWARD _PROTOTYPE( int w_waitfor, (int mask, int value) );
|
|
FORWARD _PROTOTYPE( void w_geometry, (struct partition *entry) );
|
|
#if ENABLE_ATAPI
|
|
FORWARD _PROTOTYPE( int atapi_sendpacket, (u8_t *packet, unsigned cnt) );
|
|
FORWARD _PROTOTYPE( int atapi_intr_wait, (void) );
|
|
FORWARD _PROTOTYPE( int atapi_open, (void) );
|
|
FORWARD _PROTOTYPE( void atapi_close, (void) );
|
|
FORWARD _PROTOTYPE( int atapi_transfer, (int proc_nr, int opcode,
|
|
off_t position, iovec_t *iov, unsigned nr_req) );
|
|
#endif
|
|
|
|
/* Entry points to this driver. */
|
|
PRIVATE struct driver w_dtab = {
|
|
w_name, /* current device's name */
|
|
w_do_open, /* open or mount request, initialize device */
|
|
w_do_close, /* release device */
|
|
do_diocntl, /* get or set a partition's geometry */
|
|
w_prepare, /* prepare for I/O on a given minor device */
|
|
w_transfer, /* do the I/O */
|
|
nop_cleanup, /* nothing to clean up */
|
|
w_geometry, /* tell the geometry of the disk */
|
|
nop_signal, /* no cleanup needed on shutdown */
|
|
nop_alarm, /* ignore leftover alarms */
|
|
nop_cancel, /* ignore CANCELs */
|
|
nop_select, /* ignore selects */
|
|
w_other, /* catch-all for unrecognized commands and ioctls */
|
|
w_hw_int /* leftover hardware interrupts */
|
|
};
|
|
|
|
/*===========================================================================*
|
|
* at_winchester_task *
|
|
*===========================================================================*/
|
|
PUBLIC int main()
|
|
{
|
|
/* Set special disk parameters then call the generic main loop. */
|
|
init_params();
|
|
driver_task(&w_dtab);
|
|
return(OK);
|
|
}
|
|
|
|
/*============================================================================*
|
|
* init_params *
|
|
*============================================================================*/
|
|
PRIVATE void init_params()
|
|
{
|
|
/* This routine is called at startup to initialize the drive parameters. */
|
|
|
|
u16_t parv[2];
|
|
unsigned int vector, size;
|
|
int drive, nr_drives;
|
|
struct wini *wn;
|
|
u8_t params[16];
|
|
int s;
|
|
|
|
/* Boot variables. */
|
|
env_parse("ata_std_timeout", "d", 0, &w_standard_timeouts, 0, 1);
|
|
env_parse("ata_pci_debug", "d", 0, &w_pci_debug, 0, 1);
|
|
env_parse("ata_instance", "d", 0, &w_instance, 0, 8);
|
|
env_parse("ata_lba48", "d", 0, &w_lba48, 0, 1);
|
|
env_parse("atapi_debug", "d", 0, &atapi_debug, 0, 1);
|
|
|
|
if(w_instance == 0) {
|
|
/* Get the number of drives from the BIOS data area */
|
|
if ((s=sys_vircopy(SELF, BIOS_SEG, NR_HD_DRIVES_ADDR,
|
|
SELF, D, (vir_bytes) params, NR_HD_DRIVES_SIZE)) != OK)
|
|
panic(w_name(), "Couldn't read BIOS", s);
|
|
if ((nr_drives = params[0]) > 2) nr_drives = 2;
|
|
|
|
for (drive = 0, wn = wini; drive < COMPAT_DRIVES; drive++, wn++) {
|
|
if (drive < nr_drives) {
|
|
/* Copy the BIOS parameter vector */
|
|
vector = (drive == 0) ? BIOS_HD0_PARAMS_ADDR:BIOS_HD1_PARAMS_ADDR;
|
|
size = (drive == 0) ? BIOS_HD0_PARAMS_SIZE:BIOS_HD1_PARAMS_SIZE;
|
|
if ((s=sys_vircopy(SELF, BIOS_SEG, vector,
|
|
SELF, D, (vir_bytes) parv, size)) != OK)
|
|
panic(w_name(), "Couldn't read BIOS", s);
|
|
|
|
/* Calculate the address of the parameters and copy them */
|
|
if ((s=sys_vircopy(
|
|
SELF, BIOS_SEG, hclick_to_physb(parv[1]) + parv[0],
|
|
SELF, D, (phys_bytes) params, 16L))!=OK)
|
|
panic(w_name(),"Couldn't copy parameters", s);
|
|
|
|
/* Copy the parameters to the structures of the drive */
|
|
wn->lcylinders = bp_cylinders(params);
|
|
wn->lheads = bp_heads(params);
|
|
wn->lsectors = bp_sectors(params);
|
|
wn->precomp = bp_precomp(params) >> 2;
|
|
}
|
|
|
|
/* Fill in non-BIOS parameters. */
|
|
init_drive(wn,
|
|
drive < 2 ? REG_CMD_BASE0 : REG_CMD_BASE1,
|
|
drive < 2 ? REG_CTL_BASE0 : REG_CTL_BASE1,
|
|
NO_IRQ, 0, 0, drive);
|
|
w_next_drive++;
|
|
}
|
|
}
|
|
|
|
/* Look for controllers on the pci bus. Skip none the first instance,
|
|
* skip one and then 2 for every instance, for every next instance.
|
|
*/
|
|
if(w_instance == 0)
|
|
init_params_pci(0);
|
|
else
|
|
init_params_pci(w_instance*2-1);
|
|
|
|
}
|
|
|
|
#define ATA_IF_NOTCOMPAT1 (1L << 0)
|
|
#define ATA_IF_NOTCOMPAT2 (1L << 2)
|
|
|
|
/*============================================================================*
|
|
* init_drive *
|
|
*============================================================================*/
|
|
PRIVATE void init_drive(struct wini *w, int base_cmd, int base_ctl, int irq, int ack, int hook, int drive)
|
|
{
|
|
w->state = 0;
|
|
w->w_status = 0;
|
|
w->base_cmd = base_cmd;
|
|
w->base_ctl = base_ctl;
|
|
w->irq = irq;
|
|
w->irq_mask = 1 << irq;
|
|
w->irq_need_ack = ack;
|
|
w->irq_hook_id = hook;
|
|
w->ldhpref = ldh_init(drive);
|
|
w->max_count = MAX_SECS << SECTOR_SHIFT;
|
|
w->lba48 = 0;
|
|
}
|
|
|
|
/*============================================================================*
|
|
* init_params_pci *
|
|
*============================================================================*/
|
|
PRIVATE void init_params_pci(int skip)
|
|
{
|
|
int r, devind, drive;
|
|
u16_t vid, did;
|
|
pci_init();
|
|
for(drive = w_next_drive; drive < MAX_DRIVES; drive++)
|
|
wini[drive].state = IGNORING;
|
|
for(r = pci_first_dev(&devind, &vid, &did);
|
|
r != 0 && w_next_drive < MAX_DRIVES; r = pci_next_dev(&devind, &vid, &did)) {
|
|
int interface, irq, irq_hook;
|
|
/* Base class must be 01h (mass storage), subclass must
|
|
* be 01h (ATA).
|
|
*/
|
|
if(pci_attr_r8(devind, PCI_BCR) != 0x01 ||
|
|
pci_attr_r8(devind, PCI_SCR) != 0x01) {
|
|
continue;
|
|
}
|
|
/* Found a controller.
|
|
* Programming interface register tells us more.
|
|
*/
|
|
interface = pci_attr_r8(devind, PCI_PIFR);
|
|
irq = pci_attr_r8(devind, PCI_ILR);
|
|
|
|
/* Any non-compat drives? */
|
|
if(interface & (ATA_IF_NOTCOMPAT1 | ATA_IF_NOTCOMPAT2)) {
|
|
int s;
|
|
irq_hook = irq;
|
|
if(skip > 0) {
|
|
if(w_pci_debug) printf("atapci skipping controller (remain %d)\n", skip);
|
|
skip--;
|
|
continue;
|
|
}
|
|
if ((s=sys_irqsetpolicy(irq, 0, &irq_hook)) != OK) {
|
|
printf("atapci: couldn't set IRQ policy %d\n", irq);
|
|
continue;
|
|
}
|
|
if ((s=sys_irqenable(&irq_hook)) != OK) {
|
|
printf("atapci: couldn't enable IRQ line %d\n", irq);
|
|
continue;
|
|
}
|
|
} else {
|
|
/* If not.. this is not the ata-pci controller we're
|
|
* looking for.
|
|
*/
|
|
if(w_pci_debug) printf("atapci skipping compatability controller\n");
|
|
continue;
|
|
}
|
|
|
|
/* Primary channel not in compatability mode? */
|
|
if(interface & ATA_IF_NOTCOMPAT1) {
|
|
u32_t base_cmd, base_ctl;
|
|
base_cmd = pci_attr_r32(devind, PCI_BAR) & 0xffffffe0;
|
|
base_ctl = pci_attr_r32(devind, PCI_BAR_2) & 0xffffffe0;
|
|
if(base_cmd != REG_CMD_BASE0 && base_cmd != REG_CMD_BASE1) {
|
|
init_drive(&wini[w_next_drive],
|
|
base_cmd, base_ctl, irq, 1, irq_hook, 0);
|
|
init_drive(&wini[w_next_drive+1],
|
|
base_cmd, base_ctl, irq, 1, irq_hook, 1);
|
|
if(w_pci_debug)
|
|
printf("atapci %d: 0x%x 0x%x irq %d\n", devind, base_cmd, base_ctl, irq);
|
|
} else printf("atapci: ignored drives on primary channel, base %x\n", base_cmd);
|
|
}
|
|
|
|
/* Secondary channel not in compatability mode? */
|
|
if(interface & ATA_IF_NOTCOMPAT2) {
|
|
u32_t base_cmd, base_ctl;
|
|
base_cmd = pci_attr_r32(devind, PCI_BAR_3) & 0xffffffe0;
|
|
base_ctl = pci_attr_r32(devind, PCI_BAR_4) & 0xffffffe0;
|
|
if(base_cmd != REG_CMD_BASE0 && base_cmd != REG_CMD_BASE1) {
|
|
init_drive(&wini[w_next_drive+2],
|
|
base_cmd, base_ctl, irq, 1, irq_hook, 2);
|
|
init_drive(&wini[w_next_drive+3],
|
|
base_cmd, base_ctl, irq, 1, irq_hook, 3);
|
|
if(w_pci_debug)
|
|
printf("atapci %d: 0x%x 0x%x irq %d\n", devind, base_cmd, base_ctl, irq);
|
|
} else printf("atapci: ignored drives on secondary channel, base %x\n", base_cmd);
|
|
}
|
|
w_next_drive += 4;
|
|
}
|
|
}
|
|
|
|
/*============================================================================*
|
|
* w_do_open *
|
|
*============================================================================*/
|
|
PRIVATE int w_do_open(dp, m_ptr)
|
|
struct driver *dp;
|
|
message *m_ptr;
|
|
{
|
|
/* Device open: Initialize the controller and read the partition table. */
|
|
|
|
struct wini *wn;
|
|
|
|
if (w_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
|
|
|
|
wn = w_wn;
|
|
|
|
/* If we've probed it before and it failed, don't probe it again. */
|
|
if (wn->state & IGNORING) return ENXIO;
|
|
|
|
/* If we haven't identified it yet, or it's gone deaf,
|
|
* (re-)identify it.
|
|
*/
|
|
if (!(wn->state & IDENTIFIED) || (wn->state & DEAF)) {
|
|
/* Try to identify the device. */
|
|
if (w_identify() != OK) {
|
|
#if VERBOSE
|
|
printf("%s: probe failed\n", w_name());
|
|
#endif
|
|
if (wn->state & DEAF) w_reset();
|
|
wn->state = IGNORING;
|
|
return(ENXIO);
|
|
}
|
|
/* Do a test transaction unless it's a CD drive (then
|
|
* we can believe the controller, and a test may fail
|
|
* due to no CD being in the drive). If it fails, ignore
|
|
* the device forever.
|
|
*/
|
|
if(!(wn->state & ATAPI) && w_io_test() != OK) {
|
|
wn->state |= IGNORING;
|
|
return(ENXIO);
|
|
}
|
|
|
|
#if VERBOSE
|
|
printf("%s: AT driver detected ", w_name());
|
|
if (wn->state & (SMART|ATAPI)) {
|
|
printf("%.40s\n", w_id_string);
|
|
} else {
|
|
printf("%ux%ux%u\n", wn->pcylinders, wn->pheads, wn->psectors);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if ENABLE_ATAPI
|
|
if ((wn->state & ATAPI) && (m_ptr->COUNT & W_BIT))
|
|
return(EACCES);
|
|
#endif
|
|
|
|
/* If it's not an ATAPI device, then don't open with RO_BIT. */
|
|
if (!(wn->state & ATAPI) && (m_ptr->COUNT & RO_BIT)) return EACCES;
|
|
|
|
/* Partition the drive if it's being opened for the first time,
|
|
* or being opened after being closed.
|
|
*/
|
|
if (wn->open_ct == 0) {
|
|
#if ENABLE_ATAPI
|
|
if (wn->state & ATAPI) {
|
|
int r;
|
|
if ((r = atapi_open()) != OK) return(r);
|
|
}
|
|
#endif
|
|
|
|
/* Partition the disk. */
|
|
partition(&w_dtab, w_drive * DEV_PER_DRIVE, P_PRIMARY, wn->state & ATAPI);
|
|
}
|
|
wn->open_ct++;
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_prepare *
|
|
*===========================================================================*/
|
|
PRIVATE struct device *w_prepare(int device)
|
|
{
|
|
/* Prepare for I/O on a device. */
|
|
struct wini *prev_wn;
|
|
prev_wn = w_wn;
|
|
w_device = device;
|
|
|
|
if (device < NR_MINORS) { /* d0, d0p[0-3], d1, ... */
|
|
w_drive = device / DEV_PER_DRIVE; /* save drive number */
|
|
w_wn = &wini[w_drive];
|
|
w_dv = &w_wn->part[device % DEV_PER_DRIVE];
|
|
} else
|
|
if ((unsigned) (device -= MINOR_d0p0s0) < NR_SUBDEVS) {/*d[0-7]p[0-3]s[0-3]*/
|
|
w_drive = device / SUB_PER_DRIVE;
|
|
w_wn = &wini[w_drive];
|
|
w_dv = &w_wn->subpart[device % SUB_PER_DRIVE];
|
|
} else {
|
|
w_device = -1;
|
|
return(NIL_DEV);
|
|
}
|
|
return(w_dv);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_identify *
|
|
*===========================================================================*/
|
|
PRIVATE int w_identify()
|
|
{
|
|
/* Find out if a device exists, if it is an old AT disk, or a newer ATA
|
|
* drive, a removable media device, etc.
|
|
*/
|
|
|
|
struct wini *wn = w_wn;
|
|
struct command cmd;
|
|
int i, s;
|
|
unsigned long size;
|
|
#define id_byte(n) (&tmp_buf[2 * (n)])
|
|
#define id_word(n) (((u16_t) id_byte(n)[0] << 0) \
|
|
|((u16_t) id_byte(n)[1] << 8))
|
|
#define id_longword(n) (((u32_t) id_byte(n)[0] << 0) \
|
|
|((u32_t) id_byte(n)[1] << 8) \
|
|
|((u32_t) id_byte(n)[2] << 16) \
|
|
|((u32_t) id_byte(n)[3] << 24))
|
|
|
|
/* Try to identify the device. */
|
|
cmd.ldh = wn->ldhpref;
|
|
cmd.command = ATA_IDENTIFY;
|
|
if (com_simple(&cmd) == OK) {
|
|
/* This is an ATA device. */
|
|
wn->state |= SMART;
|
|
|
|
/* Device information. */
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, SELF, tmp_buf, SECTOR_SIZE)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
|
|
/* Why are the strings byte swapped??? */
|
|
for (i = 0; i < 40; i++) w_id_string[i] = id_byte(27)[i^1];
|
|
|
|
/* Preferred CHS translation mode. */
|
|
wn->pcylinders = id_word(1);
|
|
wn->pheads = id_word(3);
|
|
wn->psectors = id_word(6);
|
|
size = (u32_t) wn->pcylinders * wn->pheads * wn->psectors;
|
|
|
|
if ((id_byte(49)[1] & 0x02) && size > 512L*1024*2) {
|
|
/* Drive is LBA capable and is big enough to trust it to
|
|
* not make a mess of it.
|
|
*/
|
|
wn->ldhpref |= LDH_LBA;
|
|
size = id_longword(60);
|
|
|
|
if(w_lba48 && ((id_word(83)) & (1L << 10))) {
|
|
/* Drive is LBA48 capable (and LBA48 is turned on). */
|
|
if(id_word(102) || id_word(103)) {
|
|
/* If no. of sectors doesn't fit in 32 bits,
|
|
* trunacte to this. So it's LBA32 for now.
|
|
* This can still address devices up to 2TB
|
|
* though.
|
|
*/
|
|
size = ULONG_MAX;
|
|
} else {
|
|
/* Actual number of sectors fits in 32 bits. */
|
|
size = id_longword(100);
|
|
}
|
|
|
|
wn->lba48 = 1;
|
|
}
|
|
}
|
|
|
|
if (wn->lcylinders == 0) {
|
|
/* No BIOS parameters? Then make some up. */
|
|
wn->lcylinders = wn->pcylinders;
|
|
wn->lheads = wn->pheads;
|
|
wn->lsectors = wn->psectors;
|
|
while (wn->lcylinders > 1024) {
|
|
wn->lheads *= 2;
|
|
wn->lcylinders /= 2;
|
|
}
|
|
}
|
|
#if ENABLE_ATAPI
|
|
} else
|
|
if (cmd.command = ATAPI_IDENTIFY, com_simple(&cmd) == OK) {
|
|
/* An ATAPI device. */
|
|
wn->state |= ATAPI;
|
|
|
|
/* Device information. */
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, SELF, tmp_buf, 512)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
|
|
/* Why are the strings byte swapped??? */
|
|
for (i = 0; i < 40; i++) w_id_string[i] = id_byte(27)[i^1];
|
|
|
|
size = 0; /* Size set later. */
|
|
#endif
|
|
} else {
|
|
/* Not an ATA device; no translations, no special features. Don't
|
|
* touch it unless the BIOS knows about it.
|
|
*/
|
|
if (wn->lcylinders == 0) { return(ERR); } /* no BIOS parameters */
|
|
wn->pcylinders = wn->lcylinders;
|
|
wn->pheads = wn->lheads;
|
|
wn->psectors = wn->lsectors;
|
|
size = (u32_t) wn->pcylinders * wn->pheads * wn->psectors;
|
|
}
|
|
|
|
/* Size of the whole drive */
|
|
wn->part[0].dv_size = mul64u(size, SECTOR_SIZE);
|
|
|
|
/* Reset/calibrate (where necessary) */
|
|
if (w_specify() != OK && w_specify() != OK) {
|
|
return(ERR);
|
|
}
|
|
|
|
if(wn->irq == NO_IRQ) {
|
|
/* Everything looks OK; register IRQ so we can stop polling. */
|
|
wn->irq = w_drive < 2 ? AT_WINI_0_IRQ : AT_WINI_1_IRQ;
|
|
wn->irq_hook_id = wn->irq; /* id to be returned if interrupt occurs */
|
|
if ((s=sys_irqsetpolicy(wn->irq, IRQ_REENABLE, &wn->irq_hook_id)) != OK)
|
|
panic(w_name(), "couldn't set IRQ policy", s);
|
|
if ((s=sys_irqenable(&wn->irq_hook_id)) != OK)
|
|
panic(w_name(), "couldn't enable IRQ line", s);
|
|
}
|
|
wn->state |= IDENTIFIED;
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_name *
|
|
*===========================================================================*/
|
|
PRIVATE char *w_name()
|
|
{
|
|
/* Return a name for the current device. */
|
|
static char name[] = "AT-D0";
|
|
|
|
name[4] = '0' + w_drive;
|
|
return name;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_io_test *
|
|
*===========================================================================*/
|
|
PRIVATE int w_io_test(void)
|
|
{
|
|
int r, save_dev;
|
|
int save_timeout, save_errors, save_wakeup;
|
|
iovec_t iov;
|
|
#ifdef CD_SECTOR_SIZE
|
|
static char buf[CD_SECTOR_SIZE];
|
|
#else
|
|
static char buf[SECTOR_SIZE];
|
|
#endif
|
|
|
|
iov.iov_addr = (vir_bytes) buf;
|
|
iov.iov_size = sizeof(buf);
|
|
save_dev = w_device;
|
|
|
|
/* Reduce timeout values for this test transaction. */
|
|
save_timeout = timeout_ticks;
|
|
save_errors = max_errors;
|
|
save_wakeup = wakeup_ticks;
|
|
|
|
if(!w_standard_timeouts) {
|
|
timeout_ticks = HZ * 4;
|
|
wakeup_ticks = HZ * 6;
|
|
max_errors = 3;
|
|
}
|
|
|
|
w_testing = 1;
|
|
|
|
/* Try I/O on the actual drive (not any (sub)partition). */
|
|
if(w_prepare(w_drive * DEV_PER_DRIVE) == NIL_DEV)
|
|
panic(w_name(), "Couldn't switch devices", NO_NUM);
|
|
|
|
r = w_transfer(SELF, DEV_GATHER, 0, &iov, 1);
|
|
|
|
/* Switch back. */
|
|
if(w_prepare(save_dev) == NIL_DEV)
|
|
panic(w_name(), "Couldn't switch back devices", NO_NUM);
|
|
|
|
/* Restore parameters. */
|
|
timeout_ticks = save_timeout;
|
|
max_errors = save_errors;
|
|
wakeup_ticks = save_wakeup;
|
|
w_testing = 0;
|
|
|
|
/* Test if everything worked. */
|
|
if(r != OK || iov.iov_size != 0) {
|
|
return ERR;
|
|
}
|
|
|
|
/* Everything worked. */
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_specify *
|
|
*===========================================================================*/
|
|
PRIVATE int w_specify()
|
|
{
|
|
/* Routine to initialize the drive after boot or when a reset is needed. */
|
|
|
|
struct wini *wn = w_wn;
|
|
struct command cmd;
|
|
|
|
if ((wn->state & DEAF) && w_reset() != OK) {
|
|
return(ERR);
|
|
}
|
|
|
|
if (!(wn->state & ATAPI)) {
|
|
/* Specify parameters: precompensation, number of heads and sectors. */
|
|
cmd.precomp = wn->precomp;
|
|
cmd.count = wn->psectors;
|
|
cmd.ldh = w_wn->ldhpref | (wn->pheads - 1);
|
|
cmd.command = CMD_SPECIFY; /* Specify some parameters */
|
|
|
|
/* Output command block and see if controller accepts the parameters. */
|
|
if (com_simple(&cmd) != OK) return(ERR);
|
|
|
|
if (!(wn->state & SMART)) {
|
|
/* Calibrate an old disk. */
|
|
cmd.sector = 0;
|
|
cmd.cyl_lo = 0;
|
|
cmd.cyl_hi = 0;
|
|
cmd.ldh = w_wn->ldhpref;
|
|
cmd.command = CMD_RECALIBRATE;
|
|
|
|
if (com_simple(&cmd) != OK) return(ERR);
|
|
}
|
|
}
|
|
wn->state |= INITIALIZED;
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* do_transfer *
|
|
*===========================================================================*/
|
|
PRIVATE int do_transfer(struct wini *wn, unsigned int precomp, unsigned int count,
|
|
unsigned int sector, unsigned int opcode)
|
|
{
|
|
struct command cmd;
|
|
unsigned secspcyl = wn->pheads * wn->psectors;
|
|
|
|
cmd.precomp = precomp;
|
|
cmd.count = count;
|
|
cmd.command = opcode == DEV_SCATTER ? CMD_WRITE : CMD_READ;
|
|
/*
|
|
if (w_lba48 && wn->lba48) {
|
|
} else */
|
|
if (wn->ldhpref & LDH_LBA) {
|
|
cmd.sector = (sector >> 0) & 0xFF;
|
|
cmd.cyl_lo = (sector >> 8) & 0xFF;
|
|
cmd.cyl_hi = (sector >> 16) & 0xFF;
|
|
cmd.ldh = wn->ldhpref | ((sector >> 24) & 0xF);
|
|
} else {
|
|
int cylinder, head, sec;
|
|
cylinder = sector / secspcyl;
|
|
head = (sector % secspcyl) / wn->psectors;
|
|
sec = sector % wn->psectors;
|
|
cmd.sector = sec + 1;
|
|
cmd.cyl_lo = cylinder & BYTE;
|
|
cmd.cyl_hi = (cylinder >> 8) & BYTE;
|
|
cmd.ldh = wn->ldhpref | head;
|
|
}
|
|
|
|
return com_out(&cmd);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_transfer *
|
|
*===========================================================================*/
|
|
PRIVATE int w_transfer(proc_nr, opcode, position, iov, nr_req)
|
|
int proc_nr; /* process doing the request */
|
|
int opcode; /* DEV_GATHER or DEV_SCATTER */
|
|
off_t position; /* offset on device to read or write */
|
|
iovec_t *iov; /* pointer to read or write request vector */
|
|
unsigned nr_req; /* length of request vector */
|
|
{
|
|
struct wini *wn = w_wn;
|
|
iovec_t *iop, *iov_end = iov + nr_req;
|
|
int r, s, errors;
|
|
unsigned long block;
|
|
unsigned long dv_size = cv64ul(w_dv->dv_size);
|
|
unsigned cylinder, head, sector, nbytes;
|
|
|
|
#if ENABLE_ATAPI
|
|
if (w_wn->state & ATAPI) {
|
|
return atapi_transfer(proc_nr, opcode, position, iov, nr_req);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
/* Check disk address. */
|
|
if ((position & SECTOR_MASK) != 0) return(EINVAL);
|
|
|
|
errors = 0;
|
|
|
|
while (nr_req > 0) {
|
|
/* How many bytes to transfer? */
|
|
nbytes = 0;
|
|
for (iop = iov; iop < iov_end; iop++) nbytes += iop->iov_size;
|
|
if ((nbytes & SECTOR_MASK) != 0) return(EINVAL);
|
|
|
|
/* Which block on disk and how close to EOF? */
|
|
if (position >= dv_size) return(OK); /* At EOF */
|
|
if (position + nbytes > dv_size) nbytes = dv_size - position;
|
|
block = div64u(add64ul(w_dv->dv_base, position), SECTOR_SIZE);
|
|
|
|
if (nbytes >= wn->max_count) {
|
|
/* The drive can't do more then max_count at once. */
|
|
nbytes = wn->max_count;
|
|
}
|
|
|
|
/* First check to see if a reinitialization is needed. */
|
|
if (!(wn->state & INITIALIZED) && w_specify() != OK) return(EIO);
|
|
|
|
/* Tell the controller to transfer nbytes bytes. */
|
|
#if 1
|
|
r = do_transfer(wn, wn->precomp, ((nbytes >> SECTOR_SHIFT) & BYTE),
|
|
block, opcode);
|
|
#else
|
|
cmd.precomp = wn->precomp;
|
|
cmd.count = (nbytes >> SECTOR_SHIFT) & BYTE;
|
|
if (wn->ldhpref & LDH_LBA) {
|
|
cmd.sector = (block >> 0) & 0xFF;
|
|
cmd.cyl_lo = (block >> 8) & 0xFF;
|
|
cmd.cyl_hi = (block >> 16) & 0xFF;
|
|
cmd.ldh = wn->ldhpref | ((block >> 24) & 0xF);
|
|
} else {
|
|
cylinder = block / secspcyl;
|
|
head = (block % secspcyl) / wn->psectors;
|
|
sector = block % wn->psectors;
|
|
cmd.sector = sector + 1;
|
|
cmd.cyl_lo = cylinder & BYTE;
|
|
cmd.cyl_hi = (cylinder >> 8) & BYTE;
|
|
cmd.ldh = wn->ldhpref | head;
|
|
}
|
|
cmd.command = opcode == DEV_SCATTER ? CMD_WRITE : CMD_READ;
|
|
|
|
r = com_out(&cmd);
|
|
#endif
|
|
|
|
while (r == OK && nbytes > 0) {
|
|
/* For each sector, wait for an interrupt and fetch the data
|
|
* (read), or supply data to the controller and wait for an
|
|
* interrupt (write).
|
|
*/
|
|
|
|
if (opcode == DEV_GATHER) {
|
|
/* First an interrupt, then data. */
|
|
if ((r = at_intr_wait()) != OK) {
|
|
/* An error, send data to the bit bucket. */
|
|
if (w_wn->w_status & STATUS_DRQ) {
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, SELF, tmp_buf, SECTOR_SIZE)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Wait for data transfer requested. */
|
|
if (!w_waitfor(STATUS_DRQ, STATUS_DRQ)) { r = ERR; break; }
|
|
|
|
/* Copy bytes to or from the device's buffer. */
|
|
if (opcode == DEV_GATHER) {
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, proc_nr, (void *) iov->iov_addr, SECTOR_SIZE)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
} else {
|
|
if ((s=sys_outsw(wn->base_cmd + REG_DATA, proc_nr, (void *) iov->iov_addr, SECTOR_SIZE)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
|
|
/* Data sent, wait for an interrupt. */
|
|
if ((r = at_intr_wait()) != OK) break;
|
|
}
|
|
|
|
/* Book the bytes successfully transferred. */
|
|
nbytes -= SECTOR_SIZE;
|
|
position += SECTOR_SIZE;
|
|
iov->iov_addr += SECTOR_SIZE;
|
|
if ((iov->iov_size -= SECTOR_SIZE) == 0) { iov++; nr_req--; }
|
|
}
|
|
|
|
/* Any errors? */
|
|
if (r != OK) {
|
|
/* Don't retry if sector marked bad or too many errors. */
|
|
if (r == ERR_BAD_SECTOR || ++errors == max_errors) {
|
|
w_command = CMD_IDLE;
|
|
return(EIO);
|
|
}
|
|
}
|
|
}
|
|
|
|
w_command = CMD_IDLE;
|
|
return(OK);
|
|
}
|
|
|
|
/*============================================================================*
|
|
* com_out *
|
|
*============================================================================*/
|
|
PRIVATE int com_out(cmd)
|
|
struct command *cmd; /* Command block */
|
|
{
|
|
/* Output the command block to the winchester controller and return status */
|
|
|
|
struct wini *wn = w_wn;
|
|
unsigned base_cmd = wn->base_cmd;
|
|
unsigned base_ctl = wn->base_ctl;
|
|
pvb_pair_t outbyte[7]; /* vector for sys_voutb() */
|
|
int s; /* status for sys_(v)outb() */
|
|
|
|
if(w_wn->state & IGNORING) return ERR;
|
|
|
|
if (!w_waitfor(STATUS_BSY, 0)) {
|
|
printf("%s: controller not ready\n", w_name());
|
|
return(ERR);
|
|
}
|
|
|
|
/* Select drive. */
|
|
if ((s=sys_outb(base_cmd + REG_LDH, cmd->ldh)) != OK)
|
|
panic(w_name(),"Couldn't write register to select drive",s);
|
|
|
|
if (!w_waitfor(STATUS_BSY, 0)) {
|
|
printf("%s: com_out: drive not ready\n", w_name());
|
|
return(ERR);
|
|
}
|
|
|
|
/* Schedule a wakeup call, some controllers are flaky. This is done with
|
|
* a synchronous alarm. If a timeout occurs a SYN_ALARM message is sent
|
|
* from HARDWARE, so that w_intr_wait() can call w_timeout() in case the
|
|
* controller was not able to execute the command. Leftover timeouts are
|
|
* simply ignored by the main loop.
|
|
*/
|
|
sys_setalarm(wakeup_ticks, 0);
|
|
|
|
wn->w_status = STATUS_ADMBSY;
|
|
w_command = cmd->command;
|
|
pv_set(outbyte[0], base_ctl + REG_CTL, wn->pheads >= 8 ? CTL_EIGHTHEADS : 0);
|
|
pv_set(outbyte[1], base_cmd + REG_PRECOMP, cmd->precomp);
|
|
pv_set(outbyte[2], base_cmd + REG_COUNT, cmd->count);
|
|
pv_set(outbyte[3], base_cmd + REG_SECTOR, cmd->sector);
|
|
pv_set(outbyte[4], base_cmd + REG_CYL_LO, cmd->cyl_lo);
|
|
pv_set(outbyte[5], base_cmd + REG_CYL_HI, cmd->cyl_hi);
|
|
pv_set(outbyte[6], base_cmd + REG_COMMAND, cmd->command);
|
|
if ((s=sys_voutb(outbyte,7)) != OK)
|
|
panic(w_name(),"Couldn't write registers with sys_voutb()",s);
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_need_reset *
|
|
*===========================================================================*/
|
|
PRIVATE void w_need_reset()
|
|
{
|
|
/* The controller needs to be reset. */
|
|
struct wini *wn;
|
|
int dr = 0;
|
|
|
|
for (wn = wini; wn < &wini[MAX_DRIVES]; wn++, dr++) {
|
|
if (wn->base_cmd == w_wn->base_cmd) {
|
|
wn->state |= DEAF;
|
|
wn->state &= ~INITIALIZED;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*============================================================================*
|
|
* w_do_close *
|
|
*============================================================================*/
|
|
PRIVATE int w_do_close(dp, m_ptr)
|
|
struct driver *dp;
|
|
message *m_ptr;
|
|
{
|
|
/* Device close: Release a device. */
|
|
if (w_prepare(m_ptr->DEVICE) == NIL_DEV)
|
|
return(ENXIO);
|
|
w_wn->open_ct--;
|
|
#if ENABLE_ATAPI
|
|
if (w_wn->open_ct == 0 && (w_wn->state & ATAPI)) atapi_close();
|
|
#endif
|
|
return(OK);
|
|
}
|
|
|
|
/*============================================================================*
|
|
* com_simple *
|
|
*============================================================================*/
|
|
PRIVATE int com_simple(cmd)
|
|
struct command *cmd; /* Command block */
|
|
{
|
|
/* A simple controller command, only one interrupt and no data-out phase. */
|
|
int r;
|
|
|
|
if(w_wn->state & IGNORING) return ERR;
|
|
|
|
if ((r = com_out(cmd)) == OK) r = at_intr_wait();
|
|
w_command = CMD_IDLE;
|
|
return(r);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_timeout *
|
|
*===========================================================================*/
|
|
PRIVATE void w_timeout(void)
|
|
{
|
|
struct wini *wn = w_wn;
|
|
|
|
switch (w_command) {
|
|
case CMD_IDLE:
|
|
break; /* fine */
|
|
case CMD_READ:
|
|
case CMD_WRITE:
|
|
/* Impossible, but not on PC's: The controller does not respond. */
|
|
|
|
/* Limiting multisector I/O seems to help. */
|
|
if (wn->max_count > 8 * SECTOR_SIZE) {
|
|
wn->max_count = 8 * SECTOR_SIZE;
|
|
} else {
|
|
wn->max_count = SECTOR_SIZE;
|
|
}
|
|
/*FALL THROUGH*/
|
|
default:
|
|
/* Some other command. */
|
|
if(w_testing) wn->state |= IGNORING; /* Kick out this drive. */
|
|
else if(!w_silent) printf("%s: timeout on command %02x\n", w_name(), w_command);
|
|
w_need_reset();
|
|
wn->w_status = 0;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* w_reset *
|
|
*===========================================================================*/
|
|
PRIVATE int w_reset()
|
|
{
|
|
/* Issue a reset to the controller. This is done after any catastrophe,
|
|
* like the controller refusing to respond.
|
|
*/
|
|
int s;
|
|
struct wini *wn = w_wn;
|
|
|
|
/* Don't bother if this drive is forgotten. */
|
|
if(w_wn->state & IGNORING) return ERR;
|
|
|
|
/* Wait for any internal drive recovery. */
|
|
tickdelay(RECOVERY_TICKS);
|
|
|
|
/* Strobe reset bit */
|
|
if ((s=sys_outb(wn->base_ctl + REG_CTL, CTL_RESET)) != OK)
|
|
panic(w_name(),"Couldn't strobe reset bit",s);
|
|
tickdelay(DELAY_TICKS);
|
|
if ((s=sys_outb(wn->base_ctl + REG_CTL, 0)) != OK)
|
|
panic(w_name(),"Couldn't strobe reset bit",s);
|
|
tickdelay(DELAY_TICKS);
|
|
|
|
/* Wait for controller ready */
|
|
if (!w_waitfor(STATUS_BSY, 0)) {
|
|
printf("%s: reset failed, drive busy\n", w_name());
|
|
return(ERR);
|
|
}
|
|
|
|
/* The error register should be checked now, but some drives mess it up. */
|
|
|
|
for (wn = wini; wn < &wini[MAX_DRIVES]; wn++) {
|
|
if (wn->base_cmd == w_wn->base_cmd) {
|
|
wn->state &= ~DEAF;
|
|
if (w_wn->irq_need_ack) {
|
|
/* Make sure irq is actually enabled.. */
|
|
sys_irqenable(&w_wn->irq_hook_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*============================================================================*
|
|
* w_intr_wait *
|
|
*============================================================================*/
|
|
PRIVATE void w_intr_wait()
|
|
{
|
|
/* Wait for a task completion interrupt. */
|
|
|
|
message m;
|
|
|
|
if (w_wn->irq != NO_IRQ) {
|
|
/* Wait for an interrupt that sets w_status to "not busy". */
|
|
while (w_wn->w_status & (STATUS_ADMBSY|STATUS_BSY)) {
|
|
receive(ANY, &m); /* expect HARD_INT message */
|
|
if (m.m_type == SYN_ALARM) { /* but check for timeout */
|
|
w_timeout(); /* a.o. set w_status */
|
|
} else if (m.m_type == HARD_INT) {
|
|
sys_inb(w_wn->base_cmd + REG_STATUS, &w_wn->w_status);
|
|
ack_irqs(m.NOTIFY_ARG);
|
|
} else {
|
|
printf("AT_WINI got unexpected message %d from %d\n",
|
|
m.m_type, m.m_source);
|
|
}
|
|
}
|
|
} else {
|
|
/* Interrupt not yet allocated; use polling. */
|
|
(void) w_waitfor(STATUS_BSY, 0);
|
|
}
|
|
}
|
|
|
|
/*============================================================================*
|
|
* at_intr_wait *
|
|
*============================================================================*/
|
|
PRIVATE int at_intr_wait()
|
|
{
|
|
/* Wait for an interrupt, study the status bits and return error/success. */
|
|
int r;
|
|
int s,inbval; /* read value with sys_inb */
|
|
|
|
w_intr_wait();
|
|
if ((w_wn->w_status & (STATUS_BSY | STATUS_WF | STATUS_ERR)) == 0) {
|
|
r = OK;
|
|
} else {
|
|
if ((s=sys_inb(w_wn->base_cmd + REG_ERROR, &inbval)) != OK)
|
|
panic(w_name(),"Couldn't read register",s);
|
|
if ((w_wn->w_status & STATUS_ERR) && (inbval & ERROR_BB)) {
|
|
r = ERR_BAD_SECTOR; /* sector marked bad, retries won't help */
|
|
} else {
|
|
r = ERR; /* any other error */
|
|
}
|
|
}
|
|
w_wn->w_status |= STATUS_ADMBSY; /* assume still busy with I/O */
|
|
return(r);
|
|
}
|
|
|
|
/*==========================================================================*
|
|
* w_waitfor *
|
|
*==========================================================================*/
|
|
PRIVATE int w_waitfor(mask, value)
|
|
int mask; /* status mask */
|
|
int value; /* required status */
|
|
{
|
|
/* Wait until controller is in the required state. Return zero on timeout.
|
|
* An alarm that set a timeout flag is used. TIMEOUT is in micros, we need
|
|
* ticks. Disabling the alarm is not needed, because a static flag is used
|
|
* and a leftover timeout cannot do any harm.
|
|
*/
|
|
clock_t t0, t1;
|
|
int s;
|
|
getuptime(&t0);
|
|
do {
|
|
if ((s=sys_inb(w_wn->base_cmd + REG_STATUS, &w_wn->w_status)) != OK)
|
|
panic(w_name(),"Couldn't read register",s);
|
|
if ((w_wn->w_status & mask) == value) {
|
|
return 1;
|
|
}
|
|
} while ((s=getuptime(&t1)) == OK && (t1-t0) < timeout_ticks );
|
|
if (OK != s) printf("AT_WINI: warning, get_uptime failed: %d\n",s);
|
|
|
|
w_need_reset(); /* controller gone deaf */
|
|
return(0);
|
|
}
|
|
|
|
/*============================================================================*
|
|
* w_geometry *
|
|
*============================================================================*/
|
|
PRIVATE void w_geometry(entry)
|
|
struct partition *entry;
|
|
{
|
|
struct wini *wn = w_wn;
|
|
|
|
if (wn->state & ATAPI) { /* Make up some numbers. */
|
|
entry->cylinders = div64u(wn->part[0].dv_size, SECTOR_SIZE) / (64*32);
|
|
entry->heads = 64;
|
|
entry->sectors = 32;
|
|
} else { /* Return logical geometry. */
|
|
entry->cylinders = wn->lcylinders;
|
|
entry->heads = wn->lheads;
|
|
entry->sectors = wn->lsectors;
|
|
}
|
|
}
|
|
|
|
#if ENABLE_ATAPI
|
|
/*===========================================================================*
|
|
* atapi_open *
|
|
*===========================================================================*/
|
|
PRIVATE int atapi_open()
|
|
{
|
|
/* Should load and lock the device and obtain its size. For now just set the
|
|
* size of the device to something big. What is really needed is a generic
|
|
* SCSI layer that does all this stuff for ATAPI and SCSI devices (kjb). (XXX)
|
|
*/
|
|
w_wn->part[0].dv_size = mul64u(800L*1024, 1024);
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* atapi_close *
|
|
*===========================================================================*/
|
|
PRIVATE void atapi_close()
|
|
{
|
|
/* Should unlock the device. For now do nothing. (XXX) */
|
|
}
|
|
|
|
void sense_request(void)
|
|
{
|
|
int r, i;
|
|
static u8_t sense[100], packet[ATAPI_PACKETSIZE];
|
|
|
|
packet[0] = SCSI_SENSE;
|
|
packet[1] = 0;
|
|
packet[2] = 0;
|
|
packet[3] = 0;
|
|
packet[4] = SENSE_PACKETSIZE;
|
|
packet[5] = 0;
|
|
packet[7] = 0;
|
|
packet[8] = 0;
|
|
packet[9] = 0;
|
|
packet[10] = 0;
|
|
packet[11] = 0;
|
|
|
|
for(i = 0; i < SENSE_PACKETSIZE; i++) sense[i] = 0xff;
|
|
r = atapi_sendpacket(packet, SENSE_PACKETSIZE);
|
|
if (r != OK) { printf("request sense command failed\n"); return; }
|
|
if(atapi_intr_wait() <= 0) { printf("WARNING: request response failed\n"); }
|
|
|
|
if (sys_insw(w_wn->base_cmd + REG_DATA, SELF, (void *) sense, SENSE_PACKETSIZE) != OK)
|
|
printf("WARNING: sense reading failed\n");
|
|
|
|
printf("sense data:");
|
|
for(i = 0; i < SENSE_PACKETSIZE; i++) printf(" %02x", sense[i]);
|
|
printf("\n");
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* atapi_transfer *
|
|
*===========================================================================*/
|
|
PRIVATE int atapi_transfer(proc_nr, opcode, position, iov, nr_req)
|
|
int proc_nr; /* process doing the request */
|
|
int opcode; /* DEV_GATHER or DEV_SCATTER */
|
|
off_t position; /* offset on device to read or write */
|
|
iovec_t *iov; /* pointer to read or write request vector */
|
|
unsigned nr_req; /* length of request vector */
|
|
{
|
|
struct wini *wn = w_wn;
|
|
iovec_t *iop, *iov_end = iov + nr_req;
|
|
int r, s, errors, fresh;
|
|
u64_t pos;
|
|
unsigned long block;
|
|
unsigned long dv_size = cv64ul(w_dv->dv_size);
|
|
unsigned nbytes, nblocks, count, before, chunk;
|
|
static u8_t packet[ATAPI_PACKETSIZE];
|
|
|
|
errors = fresh = 0;
|
|
|
|
while (nr_req > 0 && !fresh) {
|
|
/* The Minix block size is smaller than the CD block size, so we
|
|
* may have to read extra before or after the good data.
|
|
*/
|
|
pos = add64ul(w_dv->dv_base, position);
|
|
block = div64u(pos, CD_SECTOR_SIZE);
|
|
before = rem64u(pos, CD_SECTOR_SIZE);
|
|
|
|
/* How many bytes to transfer? */
|
|
nbytes = count = 0;
|
|
for (iop = iov; iop < iov_end; iop++) {
|
|
nbytes += iop->iov_size;
|
|
if ((before + nbytes) % CD_SECTOR_SIZE == 0) count = nbytes;
|
|
}
|
|
|
|
/* Does one of the memory chunks end nicely on a CD sector multiple? */
|
|
if (count != 0) nbytes = count;
|
|
|
|
/* Data comes in as words, so we have to enforce even byte counts. */
|
|
if ((before | nbytes) & 1) return(EINVAL);
|
|
|
|
/* Which block on disk and how close to EOF? */
|
|
if (position >= dv_size) return(OK); /* At EOF */
|
|
if (position + nbytes > dv_size) nbytes = dv_size - position;
|
|
|
|
nblocks = (before + nbytes + CD_SECTOR_SIZE - 1) / CD_SECTOR_SIZE;
|
|
if (ATAPI_DEBUG) {
|
|
printf("block=%lu, before=%u, nbytes=%u, nblocks=%u\n",
|
|
block, before, nbytes, nblocks);
|
|
}
|
|
|
|
/* First check to see if a reinitialization is needed. */
|
|
if (!(wn->state & INITIALIZED) && w_specify() != OK) return(EIO);
|
|
|
|
/* Build an ATAPI command packet. */
|
|
packet[0] = SCSI_READ10;
|
|
packet[1] = 0;
|
|
packet[2] = (block >> 24) & 0xFF;
|
|
packet[3] = (block >> 16) & 0xFF;
|
|
packet[4] = (block >> 8) & 0xFF;
|
|
packet[5] = (block >> 0) & 0xFF;
|
|
packet[7] = (nblocks >> 8) & 0xFF;
|
|
packet[8] = (nblocks >> 0) & 0xFF;
|
|
packet[9] = 0;
|
|
packet[10] = 0;
|
|
packet[11] = 0;
|
|
|
|
/* Tell the controller to execute the packet command. */
|
|
r = atapi_sendpacket(packet, nblocks * CD_SECTOR_SIZE);
|
|
if (r != OK) goto err;
|
|
|
|
/* Read chunks of data. */
|
|
while ((r = atapi_intr_wait()) > 0) {
|
|
count = r;
|
|
|
|
if (ATAPI_DEBUG) {
|
|
printf("before=%u, nbytes=%u, count=%u\n",
|
|
before, nbytes, count);
|
|
}
|
|
|
|
while (before > 0 && count > 0) { /* Discard before. */
|
|
chunk = before;
|
|
if (chunk > count) chunk = count;
|
|
if (chunk > DMA_BUF_SIZE) chunk = DMA_BUF_SIZE;
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, SELF, tmp_buf, chunk)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
before -= chunk;
|
|
count -= chunk;
|
|
}
|
|
|
|
while (nbytes > 0 && count > 0) { /* Requested data. */
|
|
chunk = nbytes;
|
|
if (chunk > count) chunk = count;
|
|
if (chunk > iov->iov_size) chunk = iov->iov_size;
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, proc_nr, (void *) iov->iov_addr, chunk)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
position += chunk;
|
|
nbytes -= chunk;
|
|
count -= chunk;
|
|
iov->iov_addr += chunk;
|
|
fresh = 0;
|
|
if ((iov->iov_size -= chunk) == 0) {
|
|
iov++;
|
|
nr_req--;
|
|
fresh = 1; /* new element is optional */
|
|
}
|
|
}
|
|
|
|
while (count > 0) { /* Excess data. */
|
|
chunk = count;
|
|
if (chunk > DMA_BUF_SIZE) chunk = DMA_BUF_SIZE;
|
|
if ((s=sys_insw(wn->base_cmd + REG_DATA, SELF, tmp_buf, chunk)) != OK)
|
|
panic(w_name(),"Call to sys_insw() failed", s);
|
|
count -= chunk;
|
|
}
|
|
}
|
|
|
|
if (r < 0) {
|
|
err: /* Don't retry if too many errors. */
|
|
if(atapi_debug) sense_request();
|
|
if (++errors == max_errors) {
|
|
w_command = CMD_IDLE;
|
|
if(atapi_debug) printf("giving up (%d)\n", errors);
|
|
return(EIO);
|
|
}
|
|
if(atapi_debug) printf("retry (%d)\n", errors);
|
|
}
|
|
}
|
|
|
|
w_command = CMD_IDLE;
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* atapi_sendpacket *
|
|
*===========================================================================*/
|
|
PRIVATE int atapi_sendpacket(packet, cnt)
|
|
u8_t *packet;
|
|
unsigned cnt;
|
|
{
|
|
/* Send an Atapi Packet Command */
|
|
struct wini *wn = w_wn;
|
|
pvb_pair_t outbyte[6]; /* vector for sys_voutb() */
|
|
int s;
|
|
|
|
if(wn->state & IGNORING) return ERR;
|
|
|
|
/* Select Master/Slave drive */
|
|
if ((s=sys_outb(wn->base_cmd + REG_DRIVE, wn->ldhpref)) != OK)
|
|
panic(w_name(),"Couldn't select master/ slave drive",s);
|
|
|
|
if (!w_waitfor(STATUS_BSY | STATUS_DRQ, 0)) {
|
|
printf("%s: atapi_sendpacket: drive not ready\n", w_name());
|
|
return(ERR);
|
|
}
|
|
|
|
/* Schedule a wakeup call, some controllers are flaky. This is done with
|
|
* a synchronous alarm. If a timeout occurs a SYN_ALARM message is sent
|
|
* from HARDWARE, so that w_intr_wait() can call w_timeout() in case the
|
|
* controller was not able to execute the command. Leftover timeouts are
|
|
* simply ignored by the main loop.
|
|
*/
|
|
sys_setalarm(wakeup_ticks, 0);
|
|
|
|
#if _WORD_SIZE > 2
|
|
if (cnt > 0xFFFE) cnt = 0xFFFE; /* Max data per interrupt. */
|
|
#endif
|
|
|
|
w_command = ATAPI_PACKETCMD;
|
|
pv_set(outbyte[0], wn->base_cmd + REG_FEAT, 0);
|
|
pv_set(outbyte[1], wn->base_cmd + REG_IRR, 0);
|
|
pv_set(outbyte[2], wn->base_cmd + REG_SAMTAG, 0);
|
|
pv_set(outbyte[3], wn->base_cmd + REG_CNT_LO, (cnt >> 0) & 0xFF);
|
|
pv_set(outbyte[4], wn->base_cmd + REG_CNT_HI, (cnt >> 8) & 0xFF);
|
|
pv_set(outbyte[5], wn->base_cmd + REG_COMMAND, w_command);
|
|
if(atapi_debug) printf("cmd: %x ", w_command);
|
|
if ((s=sys_voutb(outbyte,6)) != OK)
|
|
panic(w_name(),"Couldn't write registers with sys_voutb()",s);
|
|
|
|
if (!w_waitfor(STATUS_BSY | STATUS_DRQ, STATUS_DRQ)) {
|
|
printf("%s: timeout (BSY|DRQ -> DRQ)\n", w_name());
|
|
return(ERR);
|
|
}
|
|
wn->w_status |= STATUS_ADMBSY; /* Command not at all done yet. */
|
|
|
|
/* Send the command packet to the device. */
|
|
if ((s=sys_outsw(wn->base_cmd + REG_DATA, SELF, packet, ATAPI_PACKETSIZE)) != OK)
|
|
panic(w_name(),"sys_outsw() failed", s);
|
|
|
|
{
|
|
int p;
|
|
if(atapi_debug) {
|
|
printf("sent command:");
|
|
for(p = 0; p < ATAPI_PACKETSIZE; p++) { printf(" %02x", packet[p]); }
|
|
printf("\n");
|
|
}
|
|
}
|
|
return(OK);
|
|
}
|
|
|
|
/*============================================================================*
|
|
* w_other *
|
|
*============================================================================*/
|
|
PRIVATE int w_other(dr, m)
|
|
struct driver *dr;
|
|
message *m;
|
|
{
|
|
int r, timeout, prev;
|
|
|
|
if(m->m_type != DEV_IOCTL ) {
|
|
return EINVAL;
|
|
}
|
|
|
|
if(m->REQUEST == DIOCTIMEOUT) {
|
|
if((r=sys_datacopy(m->PROC_NR, (vir_bytes)m->ADDRESS,
|
|
SELF, (vir_bytes)&timeout, sizeof(timeout))) != OK)
|
|
return r;
|
|
|
|
if(timeout == 0) {
|
|
/* Restore defaults. */
|
|
timeout_ticks = DEF_TIMEOUT_TICKS;
|
|
max_errors = MAX_ERRORS;
|
|
wakeup_ticks = WAKEUP;
|
|
w_silent = 0;
|
|
} else if(timeout < 0) {
|
|
return EINVAL;
|
|
} else {
|
|
prev = wakeup_ticks;
|
|
|
|
if(!w_standard_timeouts) {
|
|
/* Set (lower) timeout, lower error
|
|
* tolerance and set silent mode.
|
|
*/
|
|
wakeup_ticks = timeout;
|
|
max_errors = 3;
|
|
w_silent = 1;
|
|
|
|
if(timeout_ticks > timeout)
|
|
timeout_ticks = timeout;
|
|
}
|
|
|
|
if((r=sys_datacopy(SELF, (vir_bytes)&prev,
|
|
m->PROC_NR, (vir_bytes)m->ADDRESS, sizeof(prev))) != OK)
|
|
return r;
|
|
}
|
|
|
|
return OK;
|
|
} else if(m->REQUEST == DIOCOPENCT) {
|
|
int count;
|
|
if(w_prepare(m->DEVICE) == NIL_DEV) return ENXIO;
|
|
count = w_wn->open_ct;
|
|
if((r=sys_datacopy(SELF, (vir_bytes)&count,
|
|
m->PROC_NR, (vir_bytes)m->ADDRESS, sizeof(count))) != OK)
|
|
return r;
|
|
return OK;
|
|
}
|
|
return EINVAL;
|
|
}
|
|
|
|
|
|
/*============================================================================*
|
|
* w_hw_int *
|
|
*============================================================================*/
|
|
PRIVATE int w_hw_int(dr, m)
|
|
struct driver *dr;
|
|
message *m;
|
|
{
|
|
/* Leftover interrupt(s) received; ack it/them. */
|
|
ack_irqs(m->NOTIFY_ARG);
|
|
|
|
return OK;
|
|
}
|
|
|
|
|
|
/*============================================================================*
|
|
* ack_irqs *
|
|
*============================================================================*/
|
|
PRIVATE void ack_irqs(unsigned int irqs)
|
|
{
|
|
unsigned int drive;
|
|
for (drive = 0; drive < MAX_DRIVES && irqs; drive++) {
|
|
if(!(wini[drive].state & IGNORING) && wini[drive].irq_need_ack &&
|
|
(wini[drive].irq_mask & irqs)) {
|
|
if(sys_inb((wini[drive].base_cmd + REG_STATUS), &wini[drive].w_status) != OK)
|
|
printf("couldn't ack irq on drive %d\n", drive);
|
|
if (sys_irqenable(&wini[drive].irq_hook_id) != OK)
|
|
printf("couldn't re-enable drive %d\n", drive);
|
|
irqs &= ~wini[drive].irq_mask;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#define STSTR(a) if(status & STATUS_ ## a) { strcat(str, #a); strcat(str, " "); }
|
|
#define ERRSTR(a) if(e & ERROR_ ## a) { strcat(str, #a); strcat(str, " "); }
|
|
char *strstatus(int status)
|
|
{
|
|
static char str[200];
|
|
str[0] = '\0';
|
|
|
|
STSTR(BSY);
|
|
STSTR(DRDY);
|
|
STSTR(DMADF);
|
|
STSTR(SRVCDSC);
|
|
STSTR(DRQ);
|
|
STSTR(CORR);
|
|
STSTR(CHECK);
|
|
return str;
|
|
}
|
|
|
|
char *strerr(int e)
|
|
{
|
|
static char str[200];
|
|
str[0] = '\0';
|
|
|
|
ERRSTR(BB);
|
|
ERRSTR(ECC);
|
|
ERRSTR(ID);
|
|
ERRSTR(AC);
|
|
ERRSTR(TK);
|
|
ERRSTR(DM);
|
|
|
|
return str;
|
|
}
|
|
|
|
/*============================================================================*
|
|
* atapi_intr_wait *
|
|
*============================================================================*/
|
|
PRIVATE int atapi_intr_wait()
|
|
{
|
|
/* Wait for an interrupt and study the results. Returns a number of bytes
|
|
* that need to be transferred, or an error code.
|
|
*/
|
|
struct wini *wn = w_wn;
|
|
pvb_pair_t inbyte[4]; /* vector for sys_vinb() */
|
|
int s; /* status for sys_vinb() */
|
|
int e;
|
|
int len;
|
|
int irr;
|
|
int r;
|
|
int phase;
|
|
|
|
w_intr_wait();
|
|
|
|
/* Request series of device I/O. */
|
|
inbyte[0].port = wn->base_cmd + REG_ERROR;
|
|
inbyte[1].port = wn->base_cmd + REG_CNT_LO;
|
|
inbyte[2].port = wn->base_cmd + REG_CNT_HI;
|
|
inbyte[3].port = wn->base_cmd + REG_IRR;
|
|
if ((s=sys_vinb(inbyte, 4)) != OK)
|
|
panic(w_name(),"ATAPI failed sys_vinb()", s);
|
|
e = inbyte[0].value;
|
|
len = inbyte[1].value;
|
|
len |= inbyte[2].value << 8;
|
|
irr = inbyte[3].value;
|
|
|
|
#if ATAPI_DEBUG
|
|
printf("wn %p S=%x=%s E=%02x=%s L=%04x I=%02x\n", wn, wn->w_status, strstatus(wn->w_status), e, strerr(e), len, irr);
|
|
#endif
|
|
if (wn->w_status & (STATUS_BSY | STATUS_CHECK)) {
|
|
if(atapi_debug) {
|
|
printf("atapi fail: S=%x=%s E=%02x=%s L=%04x I=%02x\n", wn->w_status, strstatus(wn->w_status), e, strerr(e), len, irr);
|
|
}
|
|
return ERR;
|
|
}
|
|
|
|
phase = (wn->w_status & STATUS_DRQ) | (irr & (IRR_COD | IRR_IO));
|
|
|
|
switch (phase) {
|
|
case IRR_COD | IRR_IO:
|
|
if (ATAPI_DEBUG) printf("ACD: Phase Command Complete\n");
|
|
r = OK;
|
|
break;
|
|
case 0:
|
|
if (ATAPI_DEBUG) printf("ACD: Phase Command Aborted\n");
|
|
r = ERR;
|
|
break;
|
|
case STATUS_DRQ | IRR_COD:
|
|
if (ATAPI_DEBUG) printf("ACD: Phase Command Out\n");
|
|
r = ERR;
|
|
break;
|
|
case STATUS_DRQ:
|
|
if (ATAPI_DEBUG) printf("ACD: Phase Data Out %d\n", len);
|
|
r = len;
|
|
break;
|
|
case STATUS_DRQ | IRR_IO:
|
|
if (ATAPI_DEBUG) printf("ACD: Phase Data In %d\n", len);
|
|
r = len;
|
|
break;
|
|
default:
|
|
if (ATAPI_DEBUG) printf("ACD: Phase Unknown\n");
|
|
r = ERR;
|
|
break;
|
|
}
|
|
|
|
#if 0
|
|
/* retry if the media changed */
|
|
XXX while (phase == (IRR_IO | IRR_COD) && (wn->w_status & STATUS_CHECK)
|
|
&& (e & ERROR_SENSE) == SENSE_UATTN && --try > 0);
|
|
#endif
|
|
|
|
wn->w_status |= STATUS_ADMBSY; /* Assume not done yet. */
|
|
return(r);
|
|
}
|
|
#endif /* ENABLE_ATAPI */
|