/*      $NetBSD: hdc9224.c,v 1.62 2021/08/07 16:19:07 thorpej Exp $ */
/*
* Copyright (c) 1996 Ludd, University of Lule}, Sweden.
* All rights reserved.
*
* This code is derived from software contributed to Ludd by Bertram Barth.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
* with much help from (in alphabetical order):
*      Jeremy
*      Roger Ivie
*      Rick Macklem
*      Mike Young
*
* Rewritten by Ragge 25 Jun 2000. New features:
*      - Uses interrupts instead of polling to signal ready.
*      - Can cooperate with the SCSI routines WRT. the DMA area.
*
* TODO:
*      - Floppy support missing.
*      - Bad block forwarding missing.
*      - Statistics collection.
*/
#undef  RDDEBUG

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hdc9224.c,v 1.62 2021/08/07 16:19:07 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/cpu.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/proc.h>
#include <sys/stat.h>
#include <sys/syslog.h>

#include <uvm/uvm_extern.h>

#include <ufs/ufs/dinode.h> /* For BBSIZE */
#include <ufs/ffs/fs.h>

#include <machine/sid.h>
#include <machine/ka410.h>
#include <machine/vsbus.h>
#include <machine/rpb.h>
#include <machine/scb.h>

#include <dev/mscp/mscp.h> /* For DEC disk encoding */

#include <vax/vsa/hdc9224.h>

#include "ioconf.h"
#include "locators.h"


/*
* on-disk geometry block
*/
#define _aP     __attribute__ ((packed))        /* force byte-alignment */
struct rdgeom {
       char mbz[10];           /* 10 bytes of zero */
       long xbn_count _aP;     /* number of XBNs */
       long dbn_count _aP;     /* number of DBNs */
       long lbn_count _aP;     /* number of LBNs (Logical-Block-Numbers) */
       long rbn_count _aP;     /* number of RBNs (Replacement-Block-Numbers) */
       short nspt;             /* number of sectors per track */
       short ntracks;          /* number of tracks */
       short ncylinders;       /* number of cylinders */
       short precomp;          /* first cylinder for write precompensation */
       short reduced;          /* first cylinder for reduced write current */
       short seek_rate;        /* seek rate or zero for buffered seeks */
       short crc_eec;          /* 0 if CRC, 1 if ECC is being used */
       short rct;              /* "replacement control table" (RCT) */
       short rct_ncopies;      /* number of copies of the RCT */
       long    media_id _aP;   /* media identifier */
       short interleave;       /* sector-to-sector interleave */
       short headskew;         /* head-to-head skew */
       short cylskew;          /* cylinder-to-cylinder skew */
       short gap0_size;        /* size of GAP 0 in the MFM format */
       short gap1_size;        /* size of GAP 1 in the MFM format */
       short gap2_size;        /* size of GAP 2 in the MFM format */
       short gap3_size;        /* size of GAP 3 in the MFM format */
       short sync_value;       /* sync value used when formatting */
       char    reserved[32];   /* reserved for use by the RQDX formatter */
       short serial_number;    /* serial number */
#if 0   /* we don't need these 412 useless bytes ... */
       char    fill[412-2];    /* Filler bytes to the end of the block */
       short checksum; /* checksum over the XBN */
#endif
};

/*
* Software status
*/
struct  rdsoftc {
       device_t sc_dev;                /* must be here! (pseudo-OOP:) */
       struct hdcsoftc *sc_hdc;
       struct disk sc_disk;            /* disklabel etc. */
       struct rdgeom sc_xbn;           /* on-disk geometry information */
       int sc_drive;           /* physical unit number */
};

struct  hdcsoftc {
       device_t sc_dev;                /* must be here (pseudo-OOP:) */
       struct evcnt sc_intrcnt;
       struct vsbus_dma sc_vd;
       vaddr_t sc_regs;                /* register addresses */
       struct bufq_state *sc_q;
       struct buf *sc_active;
       struct hdc9224_UDCreg sc_creg;  /* (command) registers to be written */
       struct hdc9224_UDCreg sc_sreg;  /* (status) registers being read */
       void *  sc_dmabase;             /* */
       int     sc_dmasize;
       void *sc_bufaddr;               /* Current in-core address */
       int sc_diskblk;                 /* Current block on disk */
       int sc_bytecnt;                 /* How much left to transfer */
       int sc_xfer;                    /* Current transfer size */
       int sc_retries;
       volatile u_char sc_status;      /* last status from interrupt */
       char sc_intbit;
};

struct hdc_attach_args {
       int ha_drive;
};

/*
* prototypes for (almost) all the internal routines
*/
static  int hdcmatch(device_t, cfdata_t, void *);
static  void hdcattach(device_t, device_t, void *);
static  int hdcprint(void *, const char *);
static  int rdmatch(device_t, cfdata_t, void *);
static  void rdattach(device_t, device_t, void *);
static  void hdcintr(void *);
static  int hdc_command(struct hdcsoftc *, int);
static  void rd_readgeom(struct hdcsoftc *, struct rdsoftc *);
#ifdef RDDEBUG
static  void hdc_printgeom( struct rdgeom *);
#endif
static  void hdc_writeregs(struct hdcsoftc *);
static  void hdcstart(struct hdcsoftc *, struct buf *);
static  int hdc_rdselect(struct hdcsoftc *, int);
static  void rdmakelabel(struct disklabel *, struct rdgeom *);
static  void hdc_writeregs(struct hdcsoftc *);
static  void hdc_readregs(struct hdcsoftc *);
static  void hdc_qstart(void *);

CFATTACH_DECL_NEW(hdc, sizeof(struct hdcsoftc),
   hdcmatch, hdcattach, NULL, NULL);

CFATTACH_DECL_NEW(rd, sizeof(struct rdsoftc),
   rdmatch, rdattach, NULL, NULL);

static dev_type_open(rdopen);
static dev_type_close(rdclose);
static dev_type_read(rdread);
static dev_type_write(rdwrite);
static dev_type_ioctl(rdioctl);
static dev_type_strategy(rdstrategy);
static dev_type_size(rdpsize);

const struct bdevsw rd_bdevsw = {
       .d_open = rdopen,
       .d_close = rdclose,
       .d_strategy = rdstrategy,
       .d_ioctl = rdioctl,
       .d_dump = nulldump,
       .d_psize = rdpsize,
       .d_discard = nodiscard,
       .d_flag = D_DISK
};

const struct cdevsw rd_cdevsw = {
       .d_open = rdopen,
       .d_close = rdclose,
       .d_read = rdread,
       .d_write = rdwrite,
       .d_ioctl = rdioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = D_DISK
};

/* At least 0.7 uS between register accesses */
static int rd_dmasize, inq = 0;
static volatile int u;
#define WAIT    __asm("movl %0,%0;movl %0,%0;movl %0,%0; movl %0,%0" :: "m"(u))

#define HDC_WREG(x)     *(volatile char *)(sc->sc_regs) = (x)
#define HDC_RREG        *(volatile char *)(sc->sc_regs)
#define HDC_WCMD(x)     *(volatile char *)(sc->sc_regs + 4) = (x)
#define HDC_RSTAT       *(volatile char *)(sc->sc_regs + 4)

/*
* new-config's hdcmatch() is similar to old-config's hdcprobe(),
* thus we probe for the existence of the controller and reset it.
* NB: we can't initialize the controller yet, since space for hdcsoftc
*     is not yet allocated. Thus we do this in hdcattach()...
*/
int
hdcmatch(device_t parent, cfdata_t cf, void *aux)
{
       struct vsbus_attach_args * const va = aux;
       volatile char * const hdc_csr = (volatile char *)va->va_addr;
       int i;

       u = 8; /* !!! - GCC */

       if (vax_boardtype == VAX_BTYP_49 || vax_boardtype == VAX_BTYP_46
           || vax_boardtype == VAX_BTYP_48 || vax_boardtype == VAX_BTYP_53)
               return 0;

       hdc_csr[4] = DKC_CMD_RESET; /* reset chip */
       for (i = 0; i < 1000; i++) {
               DELAY(1000);
               if (hdc_csr[4] & DKC_ST_DONE)
                       break;
       }
       if (i == 100)
               return 0; /* No response to reset */

       hdc_csr[4] = DKC_CMD_SETREGPTR|UDC_TERM;
       WAIT;
       hdc_csr[0] = UDC_TC_CRCPRE|UDC_TC_INTDONE;
       WAIT;
       hdc_csr[4] = DKC_CMD_DRDESELECT; /* Should be harmless */
       DELAY(1000);
       return (1);
}

int
hdcprint(void *aux, const char *name)
{
       struct hdc_attach_args * const ha = aux;

       if (name)
               aprint_normal ("RD?? at %s drive %d", name, ha->ha_drive);
       return UNCONF;
}

/*
* hdc_attach() probes for all possible devices
*/
void
hdcattach(device_t parent, device_t self, void *aux)
{
       struct vsbus_attach_args * const va = aux;
       struct hdcsoftc * const sc = device_private(self);
       struct hdc_attach_args ha;
       int status, i;

       aprint_normal("\n");

       sc->sc_dev = self;

       /*
        * Get interrupt vector, enable instrumentation.
        */
       scb_vecalloc(va->va_cvec, hdcintr, sc, SCB_ISTACK, &sc->sc_intrcnt);
       evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
           device_xname(self), "intr");

       sc->sc_regs = vax_map_physmem(va->va_paddr, 1);
       sc->sc_dmabase = (void *)va->va_dmaaddr;
       sc->sc_dmasize = va->va_dmasize;
       sc->sc_intbit = va->va_maskno;
       rd_dmasize = uimin(MAXPHYS, sc->sc_dmasize); /* Used in rd_minphys */

       sc->sc_vd.vd_go = hdc_qstart;
       sc->sc_vd.vd_arg = sc;
       /*
        * Reset controller.
        */
       HDC_WCMD(DKC_CMD_RESET);
       DELAY(1000);
       status = HDC_RSTAT;
       if (status != (DKC_ST_DONE|DKC_TC_SUCCESS)) {
               aprint_error_dev(self, "RESET failed,  status 0x%x\n", status);
               return;
       }
       bufq_alloc(&sc->sc_q, "disksort", BUFQ_SORT_CYLINDER);

       /*
        * now probe for all possible hard drives
        */
       for (i = 0; i < 4; i++) {
               if (i == 2) /* Floppy, needs special handling */
                       continue;
               HDC_WCMD(DKC_CMD_DRSELECT | i);
               DELAY(1000);
               status = HDC_RSTAT;
               ha.ha_drive = i;
               if ((status & DKC_ST_TERMCOD) == DKC_TC_SUCCESS)
                       config_found(self, (void *)&ha, hdcprint, CFARGS_NONE);
       }
}

/*
* rdmatch() probes for the existence of a RD-type disk/floppy
*/
int
rdmatch(device_t parent, cfdata_t cf, void *aux)
{
       struct hdc_attach_args * const ha = aux;

       if (cf->cf_loc[HDCCF_DRIVE] != HDCCF_DRIVE_DEFAULT &&
           cf->cf_loc[HDCCF_DRIVE] != ha->ha_drive)
               return 0;

       if (ha->ha_drive == 2) /* Always floppy, not supported */
               return 0;

       return 1;
}

void
rdattach(device_t parent, device_t self, void *aux)
{
       struct hdcsoftc * const sc = device_private(parent);
       struct rdsoftc * const rd = device_private(self);
       struct hdc_attach_args * const ha = aux;
       struct disklabel *dl;
       const char *msg;

       rd->sc_dev = self;
       rd->sc_drive = ha->ha_drive;
       rd->sc_hdc = sc;
       /*
        * Initialize and attach the disk structure.
        */
       disk_init(&rd->sc_disk, device_xname(rd->sc_dev), NULL);
       disk_attach(&rd->sc_disk);

       /*
        * if it's not a floppy then evaluate the on-disk geometry.
        * if necessary correct the label...
        */
       rd_readgeom(sc, rd);
       disk_printtype(rd->sc_drive, rd->sc_xbn.media_id);
       dl = rd->sc_disk.dk_label;
       rdmakelabel(dl, &rd->sc_xbn);
       msg = readdisklabel(MAKEDISKDEV(cdevsw_lookup_major(&rd_cdevsw),
                                       device_unit(rd->sc_dev), RAW_PART),
                           rdstrategy, dl, NULL);
       if (msg)
               aprint_normal_dev(self, "%s: size %u sectors",
                   msg, dl->d_secperunit);
       else
               aprint_normal_dev(self, "size %u sectors\n", dl->d_secperunit);
#ifdef RDDEBUG
       hdc_printgeom(&rd->sc_xbn);
#endif
}

void
hdcintr(void *arg)
{
       struct hdcsoftc * const sc = arg;
       struct buf *bp;

       sc->sc_status = HDC_RSTAT;
       if (sc->sc_active == 0)
               return; /* Complain? */

       if ((sc->sc_status & (DKC_ST_INTPEND|DKC_ST_DONE)) !=
           (DKC_ST_INTPEND|DKC_ST_DONE))
               return; /* Why spurious ints sometimes??? */

       bp = sc->sc_active;
       sc->sc_active = 0;
       if ((sc->sc_status & DKC_ST_TERMCOD) != DKC_TC_SUCCESS) {
               int i;
               u_char *g = (u_char *)&sc->sc_sreg;

               if (sc->sc_retries++ < 3) { /* Allow 3 retries */
                       hdcstart(sc, bp);
                       return;
               }
               aprint_error_dev(sc->sc_dev, "failed, status 0x%x\n",
                   sc->sc_status);
               hdc_readregs(sc);
               for (i = 0; i < 10; i++)
                       aprint_error("%i: %x\n", i, g[i]);
               bp->b_error = ENXIO;
               bp->b_resid = bp->b_bcount;
               biodone(bp);
               vsbus_dma_intr();
               return;
       }

       if (bp->b_flags & B_READ) {
               vsbus_copytoproc(bp->b_proc, sc->sc_dmabase, sc->sc_bufaddr,
                   sc->sc_xfer);
       }
       sc->sc_diskblk += (sc->sc_xfer/DEV_BSIZE);
       sc->sc_bytecnt -= sc->sc_xfer;
       sc->sc_bufaddr = (char *)sc->sc_bufaddr + sc->sc_xfer;

       if (sc->sc_bytecnt == 0) { /* Finished transfer */
               biodone(bp);
               vsbus_dma_intr();
       } else
               hdcstart(sc, bp);
}

/*
*
*/
void
rdstrategy(struct buf *bp)
{
       struct rdsoftc *rd;
       struct hdcsoftc *sc;
       struct disklabel *lp;
       int s;

       if ((rd = device_lookup_private(&rd_cd, DISKUNIT(bp->b_dev))) == NULL) {
               bp->b_error = ENXIO;
               goto done;
       }
       sc = rd->sc_hdc;

       lp = rd->sc_disk.dk_label;
       if ((bounds_check_with_label(&rd->sc_disk, bp, 1)) <= 0)
               goto done;

       if (bp->b_bcount == 0)
               goto done;

       bp->b_rawblkno =
           bp->b_blkno + lp->d_partitions[DISKPART(bp->b_dev)].p_offset;
       bp->b_cylinder = bp->b_rawblkno / lp->d_secpercyl;

       s = splbio();
       bufq_put(sc->sc_q, bp);
       if (inq == 0) {
               inq = 1;
               vsbus_dma_start(&sc->sc_vd);
       }
       splx(s);
       return;

done:   biodone(bp);
}

void
hdc_qstart(void *arg)
{
       struct hdcsoftc * const sc = arg;

       inq = 0;

       hdcstart(sc, 0);
       if (bufq_peek(sc->sc_q)) {
               vsbus_dma_start(&sc->sc_vd); /* More to go */
               inq = 1;
       }
}

void
hdcstart(struct hdcsoftc *sc, struct buf *ob)
{
       struct hdc9224_UDCreg * const p = &sc->sc_creg;
       struct disklabel *lp;
       struct rdsoftc *rd;
       struct buf *bp;
       int cn, sn, tn, bn, blks;

       if (sc->sc_active)
               return; /* Already doing something */

       if (ob == 0) {
               bp = bufq_get(sc->sc_q);
               if (bp == NULL)
                       return; /* Nothing to do */
               sc->sc_bufaddr = bp->b_data;
               sc->sc_diskblk = bp->b_rawblkno;
               sc->sc_bytecnt = bp->b_bcount;
               sc->sc_retries = 0;
               bp->b_resid = 0;
       } else
               bp = ob;

       rd = device_lookup_private(&rd_cd, DISKUNIT(bp->b_dev));
       hdc_rdselect(sc, rd->sc_drive);
       sc->sc_active = bp;

       bn = sc->sc_diskblk;
       lp = rd->sc_disk.dk_label;
       if (bn) {
               cn = bn / lp->d_secpercyl;
               sn = bn % lp->d_secpercyl;
               tn = sn / lp->d_nsectors;
               sn = sn % lp->d_nsectors;
       } else
               cn = sn = tn = 0;

       cn++; /* first cylinder is reserved */

       memset(p, 0, sizeof(struct hdc9224_UDCreg));

       /*
        * Tricky thing: the controller do itself only increase the sector
        * number, not the track or cylinder number. Therefore the driver
        * is not allowed to have transfers that crosses track boundaries.
        */
       blks = sc->sc_bytecnt/DEV_BSIZE;
       if ((sn + blks) > lp->d_nsectors)
               blks = lp->d_nsectors - sn;

       p->udc_dsect = sn;
       p->udc_dcyl = cn & 0xff;
       p->udc_dhead = ((cn >> 4) & 0x70) | tn;
       p->udc_scnt = blks;

       p->udc_rtcnt = UDC_RC_RTRYCNT;
       p->udc_mode = UDC_MD_HDD;
       p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWRFLT;
       hdc_writeregs(sc);

       /* Count up vars */
       sc->sc_xfer = blks * DEV_BSIZE;

       (void)HDC_RSTAT; /* Avoid pending interrupts */
       WAIT;
       vsbus_clrintr(sc->sc_intbit); /* Clear pending int's */

       if (bp->b_flags & B_READ) {
               HDC_WCMD(DKC_CMD_READ_HDD);
       } else {
               vsbus_copyfromproc(bp->b_proc, sc->sc_bufaddr, sc->sc_dmabase,
                   sc->sc_xfer);
               HDC_WCMD(DKC_CMD_WRITE_HDD);
       }
}

void
rd_readgeom(struct hdcsoftc *sc, struct rdsoftc *rd)
{
       struct hdc9224_UDCreg * const p = &sc->sc_creg;

       hdc_rdselect(sc, rd->sc_drive);         /* select drive right now */

       memset(p, 0, sizeof(*p));

       p->udc_scnt  = 1;
       p->udc_rtcnt = UDC_RC_RTRYCNT;
       p->udc_mode  = UDC_MD_HDD;
       p->udc_term  = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWPROT;
       hdc_writeregs(sc);
       sc->sc_status = 0;
       HDC_WCMD(DKC_CMD_READ_HDD|2);
       while ((sc->sc_status & DKC_ST_INTPEND) == 0)
               ;
       memcpy(&rd->sc_xbn, sc->sc_dmabase, sizeof(struct rdgeom));
}

#ifdef RDDEBUG
/*
* display the contents of the on-disk geometry structure
*/
void
hdc_printgeom(struct rdgeom *p)
{
       printf ("**DiskData**    XBNs: %ld, DBNs: %ld, LBNs: %ld, RBNs: %ld\n",
               p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count);
       printf ("sec/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n",
               p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced);
       printf ("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n",
               p->seek_rate, p->crc_eec?"EEC":"CRC", p->rct, p->rct_ncopies);
       printf ("media-ID: %lx, interleave: %d, headskew: %d, cylskew: %d\n",
               p->media_id, p->interleave, p->headskew, p->cylskew);
       printf ("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n",
               p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size,
               p->sync_value);
}
#endif

/*
* Return the size of a partition, if known, or -1 if not.
*/
int
rdpsize(dev_t dev)
{
       struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
       const int part = DISKPART(dev);

       if (rd == NULL || part >= rd->sc_disk.dk_label->d_npartitions)
               return -1;

       return rd->sc_disk.dk_label->d_partitions[part].p_size *
           (rd->sc_disk.dk_label->d_secsize / DEV_BSIZE);
}

/*
*
*/
int
rdopen(dev_t dev, int flag, int fmt, struct lwp *l)
{
       struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
       const int part = DISKPART(dev);

       if (rd == NULL || part >= rd->sc_disk.dk_label->d_npartitions)
               return ENXIO;

       switch (fmt) {
       case S_IFCHR:
               rd->sc_disk.dk_copenmask |= (1 << part);
               break;
       case S_IFBLK:
               rd->sc_disk.dk_bopenmask |= (1 << part);
               break;
       }
       rd->sc_disk.dk_openmask =
           rd->sc_disk.dk_copenmask | rd->sc_disk.dk_bopenmask;

       return 0;
}

/*
*
*/
int
rdclose(dev_t dev, int flag, int fmt, struct lwp *l)
{
       struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
       const int part = DISKPART(dev);

       switch (fmt) {
       case S_IFCHR:
               rd->sc_disk.dk_copenmask &= ~(1 << part);
               break;
       case S_IFBLK:
               rd->sc_disk.dk_bopenmask &= ~(1 << part);
               break;
       }
       rd->sc_disk.dk_openmask =
           rd->sc_disk.dk_copenmask | rd->sc_disk.dk_bopenmask;

       return (0);
}

/*
*
*/
int
rdioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
{
       struct rdsoftc * const rd = device_lookup_private(&rd_cd, DISKUNIT(dev));
       struct disklabel * const lp = rd->sc_disk.dk_label;
       int error;

       error = disk_ioctl(&rd->sc_disk, dev, cmd, addr, flag, l);
       if (error != EPASSTHROUGH)
               return error;
       else
               error = 0;

       switch (cmd) {
       case DIOCWDINFO:
       case DIOCSDINFO:
               if ((flag & FWRITE) == 0)
                       return EBADF;
               error = (cmd == DIOCSDINFO ?
                   setdisklabel(lp, (struct disklabel *)addr, 0, 0) :
                   writedisklabel(dev, rdstrategy, lp, 0));
               break;

       case DIOCGDEFLABEL:
               memset(lp, 0, sizeof(*lp));
               rdmakelabel(lp, &rd->sc_xbn);
               break;

       case DIOCWLABEL:
               if ((flag & FWRITE) == 0)
                       error = EBADF;
               break;

       default:
               error = ENOTTY;
       }
       return error;
}

/*
*
*/
int
rdread(dev_t dev, struct uio *uio, int flag)
{
       return (physio (rdstrategy, NULL, dev, B_READ, minphys, uio));
}

/*
*
*/
int
rdwrite(dev_t dev, struct uio *uio, int flag)
{
       return (physio (rdstrategy, NULL, dev, B_WRITE, minphys, uio));
}

/*
* we have to wait 0.7 usec between two accesses to any of the
* dkc-registers, on a VS2000 with 1 MIPS, this is roughly one
* instruction. Thus the loop-overhead will be enough...
*/
static void
hdc_readregs(struct hdcsoftc *sc)
{
       int i;
       char *p;

       HDC_WCMD(DKC_CMD_SETREGPTR);
       WAIT;
       p = (void*)&sc->sc_sreg;
       for (i=0; i<10; i++) {
               *p++ = HDC_RREG;        /* dkc_reg auto-increments */
               WAIT;
       }
}

static void
hdc_writeregs(struct hdcsoftc *sc)
{
       int i;
       char *p;

       HDC_WCMD(DKC_CMD_SETREGPTR);
       p = (void*)&sc->sc_creg;
       for (i=0; i<10; i++) {
               HDC_WREG(*p++); /* dkc_reg auto-increments */
               WAIT;
       }
}

/*
* hdc_command() issues a command and polls the intreq-register
* to find when command has completed
*/
int
hdc_command(struct hdcsoftc *sc, int cmd)
{
       hdc_writeregs(sc);              /* write the prepared registers */
       HDC_WCMD(cmd);
       WAIT;
       return (0);
}

int
hdc_rdselect(struct hdcsoftc *sc, int unit)
{
       struct hdc9224_UDCreg * const p = &sc->sc_creg;
       int error;

       /*
        * bring "creg" in some known-to-work state and
        * select the drive with the DRIVE SELECT command.
        */
       memset(p, 0, sizeof(*p));

       p->udc_rtcnt = UDC_RC_HDD_READ;
       p->udc_mode  = UDC_MD_HDD;
       p->udc_term  = UDC_TC_HDD;

       error = hdc_command(sc, DKC_CMD_DRSEL_HDD | unit);

       return error;
}

void
rdmakelabel(struct disklabel *dl, struct rdgeom *g)
{
       int n, p = 0;

       dl->d_bbsize = BBSIZE;
       dl->d_sbsize = SBLOCKSIZE;
       dl->d_typename[p++] = MSCP_MID_CHAR(2, g->media_id);
       dl->d_typename[p++] = MSCP_MID_CHAR(1, g->media_id);
       if (MSCP_MID_ECH(0, g->media_id))
               dl->d_typename[p++] = MSCP_MID_CHAR(0, g->media_id);
       n = MSCP_MID_NUM(g->media_id);
       if (n > 99) {
               dl->d_typename[p++] = '1';
               n -= 100;
       }
       if (n > 9) {
               dl->d_typename[p++] = (n / 10) + '0';
               n %= 10;
       }
       dl->d_typename[p++] = n + '0';
       dl->d_typename[p] = 0;
       dl->d_type = DKTYPE_MSCP; /* XXX - what to use here??? */
       dl->d_rpm = 3600;
       dl->d_secsize = DEV_BSIZE;

       dl->d_secperunit = g->lbn_count;
       dl->d_nsectors = g->nspt;
       dl->d_ntracks = g->ntracks;
       dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks;
       dl->d_ncylinders = dl->d_secperunit / dl->d_secpercyl;

       dl->d_npartitions = MAXPARTITIONS;
       dl->d_partitions[0].p_size = dl->d_partitions[2].p_size =
           dl->d_secperunit;
       dl->d_partitions[0].p_offset = dl->d_partitions[2].p_offset = 0;
       dl->d_interleave = dl->d_headswitch = 1;
       dl->d_magic = dl->d_magic2 = DISKMAGIC;
       dl->d_checksum = dkcksum(dl);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.