FreeBSD/Linux Kernel Cross Reference
sys/drivers/at_wini/at_wini.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 */
   #endif
   
   #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 */
   
   #ifdef ENABLE_ATAPI
   #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. */
   
   /* The struct 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()
   {
   /* Install signal handlers. Ask PM to transform signal into message. */
     struct sigaction sa;
   
     sa.sa_handler = SIG_MESS;
     sigemptyset(&sa.sa_mask);
     sa.sa_flags = 0;
     if (sigaction(SIGTERM,&sa,NULL)<0) panic("RS","sigaction failed", errno);
   
     /* Set special disk parameters then call the generic main loop. */
     init_params();
     signal(SIGTERM, SIG_IGN);
     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] = '' + 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. */
           r = do_transfer(wn, wn->precomp, ((nbytes >> SECTOR_SHIFT) & BYTE),
                   block, opcode);
   
           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 if (m.m_type == DEV_PING) {
                      notify(m.m_source);
                  } 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);
  }
  
  
  #endif /* ENABLE_ATAPI */
  
  /*===========================================================================*
   *                              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;
  }
  
  #if ENABLE_ATAPI
  
  /*===========================================================================*
   *                              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 */

Cache object: 466ee477b32a3756fec170c3911a1667