/* $NetBSD: fd.c,v 1.99 2024/07/20 20:36:33 andvar Exp $ */
/*
* Copyright (c) 1995 Leo Weppelman.
* All rights reserved.
*
* 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.
*/
/*
* This file contains a driver for the Floppy Disk Controller (FDC)
* on the Atari TT. It uses the WD 1772 chip, modified for steprates.
*
* The ST floppy disk controller shares the access to the DMA circuitry
* with other devices. For this reason the floppy disk controller makes
* use of some special DMA accessing code.
*
* Interrupts from the FDC are in fact DMA interrupts which get their
* first level handling in 'dma.c' . If the floppy driver is currently
* using DMA the interrupt is signalled to 'fdcint'.
*
* TODO:
* - Test it with 2 drives (I don't have them)
* - Test it with an HD-drive (Don't have that either)
* - Finish ioctl's
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.99 2024/07/20 20:36:33 andvar Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/kernel.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/proc.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/conf.h>
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <sys/dkbad.h>
#include <atari/atari/device.h>
#include <atari/atari/stalloc.h>
#include <machine/disklabel.h>
#include <machine/iomap.h>
#include <machine/mfp.h>
#include <machine/dma.h>
#include <machine/video.h>
#include <machine/cpu.h>
#include <atari/dev/ym2149reg.h>
#include <atari/dev/fdreg.h>
#include "ioconf.h"
/*
* Be verbose for debugging
*/
/*#define FLP_DEBUG 1 */
#define FDC_MAX_DMA_AD 0x1000000 /* No DMA possible beyond */
/* Parameters for the disk drive. */
#define SECTOR_SIZE 512 /* physical sector size in bytes */
#define NR_DRIVES 2 /* maximum number of drives */
#define NR_TYPES 3 /* number of diskette/drive combinations*/
#define MAX_ERRORS 10 /* how often to try rd/wt before quitting*/
#define STEP_DELAY 6000 /* 6ms (6000us) delay after stepping */
#define INV_TRK 32000 /* Should fit in unsigned short */
#define INV_PART NR_TYPES
/*
* Driver states
*/
#define FLP_IDLE 0x00 /* floppy is idle */
#define FLP_MON 0x01 /* idle with motor on */
#define FLP_STAT 0x02 /* determine floppy status */
#define FLP_XFER 0x04 /* read/write data from floppy */
/*
* Timer delay's
*/
#define FLP_MONDELAY (3 * hz) /* motor-on delay */
#define FLP_XFERDELAY (2 * hz) /* timeout on transfer */
/*
* The density codes
*/
#define FLP_DD 0 /* Double density */
#define FLP_HD 1 /* High density */
#define b_block b_resid /* FIXME: this is not the place */
/*
* Global data for all physical floppy devices
*/
static short selected = 0; /* drive/head currently selected*/
static short motoron = 0; /* motor is spinning */
static short nopens = 0; /* Number of opens executed */
static short fd_state = FLP_IDLE; /* Current driver state */
static int lock_stat = 0; /* DMA locking status */
static short fd_cmd = 0; /* command being executed */
static const char *fd_error = NULL; /* error from fd_xfer_ok() */
/*
* Private per device data
*/
struct fd_softc {
device_t sc_dev; /* generic device info */
struct disk dkdev; /* generic disk info */
struct bufq_state *bufq; /* queue of buf's */
struct callout sc_motor_ch;
int unit; /* unit for atari controlling hw*/
int nheads; /* number of heads in use */
int nsectors; /* number of sectors/track */
int density; /* density code */
int nblocks; /* number of blocks on disk */
int curtrk; /* track head positioned on */
short flags; /* misc flags */
short part; /* Current open partition */
int sector; /* logical sector for I/O */
uint8_t *io_data; /* KVA for data transfer */
int io_bytes; /* bytes left for I/O */
int io_dir; /* B_READ/B_WRITE */
int errcnt; /* current error count */
uint8_t *bounceb; /* Bounce buffer */
};
/*
* Flags in fd_softc:
*/
#define FLPF_NOTRESP 0x001 /* Unit not responding */
#define FLPF_ISOPEN 0x002 /* Unit is open */
#define FLPF_SPARE 0x004 /* Not used */
#define FLPF_HAVELAB 0x008 /* We have a valid label */
#define FLPF_BOUNCE 0x010 /* Now using the bounce buffer */
#define FLPF_WRTPROT 0x020 /* Unit is write-protected */
#define FLPF_EMPTY 0x040 /* Unit is empty */
#define FLPF_INOPEN 0x080 /* Currently being opened */
#define FLPF_GETSTAT 0x100 /* Getting unit status */
struct fd_types {
int nheads; /* Heads in use */
int nsectors; /* sectors per track */
int nblocks; /* number of blocks */
int density; /* density code */
const char *descr; /* type description */
} fdtypes[NR_TYPES] = {
{ 1, 9, 720 , FLP_DD , "360KB" }, /* 360 Kb */
{ 2, 9, 1440 , FLP_DD , "720KB" }, /* 720 Kb */
{ 2, 18, 2880 , FLP_HD , "1.44MB" }, /* 1.44 Mb */
};
#define FLP_TYPE_360 0 /* XXX: Please keep these in */
#define FLP_TYPE_720 1 /* sync with the numbering in */
#define FLP_TYPE_144 2 /* 'fdtypes' right above! */
/*
* This is set only once at attach time. The value is determined by reading
* the configuration switches and is one of the FLP_TYPE_*'s.
* This is similar to the way Atari handles the _FLP cookie.
*/
static short def_type = 0; /* Reflects config-switches */
#define FLP_DEFTYPE 1 /* 720Kb, reasonable default */
#define FLP_TYPE(dev) ( DISKPART(dev) == 0 ? def_type : DISKPART(dev) - 1 )
typedef void (*FPV)(void *);
static dev_type_open(fdopen);
static dev_type_close(fdclose);
static dev_type_read(fdread);
static dev_type_write(fdwrite);
static dev_type_ioctl(fdioctl);
static dev_type_strategy(fdstrategy);
/*
* Private drive functions....
*/
static void fdstart(struct fd_softc *);
static void fddone(struct fd_softc *);
static void fdstatus(struct fd_softc *);
static void fd_xfer(struct fd_softc *);
static void fdcint(struct fd_softc *);
static int fd_xfer_ok(struct fd_softc *);
static void fdmotoroff(struct fd_softc *);
static void fdminphys(struct buf *);
static void fdtestdrv(struct fd_softc *);
static void fdgetdefaultlabel(struct fd_softc *, struct disklabel *,
int);
static int fdgetdisklabel(struct fd_softc *, dev_t);
static int fdselect(int, int, int);
static void fddeselect(void);
static void fdmoff(struct fd_softc *);
static u_short rd_cfg_switch(void);
static inline uint8_t read_fdreg(u_short);
static inline void write_fdreg(u_short, u_short);
static inline uint8_t read_dmastat(void);
static inline
uint8_t read_fdreg(u_short regno)
{
DMA->dma_mode = regno;
return DMA->dma_data;
}
static inline
void write_fdreg(u_short regno, u_short val)
{
DMA->dma_mode = regno;
DMA->dma_data = val;
}
static inline
uint8_t read_dmastat(void)
{
DMA->dma_mode = FDC_CS | DMA_SCREG;
return DMA->dma_stat;
}
/*
* Config switch stuff. Used only for the floppy type for now. That's
* why it's here...
* XXX: If needed in more places, it should be moved to its own include file.
* Note: This location _must_ be read as an u_short. Failure to do so
* will return garbage!
*/
static u_short
rd_cfg_switch(void)
{
return *(volatile u_short *)AD_CFG_SWITCH;
}
/*
* Switch definitions.
* Note: ON reads as a zero bit!
*/
#define CFG_SWITCH_NOHD 0x4000
/*
* Autoconfig stuff....
*/
static int fdcmatch(device_t, cfdata_t, void *);
static int fdcprint(void *, const char *);
static void fdcattach(device_t, device_t, void *);
CFATTACH_DECL_NEW(fdc, 0,
fdcmatch, fdcattach, NULL, NULL);
const struct bdevsw fd_bdevsw = {
.d_open = fdopen,
.d_close = fdclose,
.d_strategy = fdstrategy,
.d_ioctl = fdioctl,
.d_dump = nodump,
.d_psize = nosize,
.d_discard = nodiscard,
.d_flag = D_DISK
};
const struct cdevsw fd_cdevsw = {
.d_open = fdopen,
.d_close = fdclose,
.d_read = fdread,
.d_write = fdwrite,
.d_ioctl = fdioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = nopoll,
.d_mmap = nommap,
.d_kqfilter = nokqfilter,
.d_discard = nodiscard,
.d_flag = D_DISK
};
static int
fdcmatch(device_t parent, cfdata_t match, void *aux)
{
static int fdc_matched = 0;
/* Match only once */
if (strcmp("fdc", aux) || fdc_matched)
return 0;
fdc_matched = 1;
return 1;
}
static void
fdcattach(device_t parent, device_t self, void *aux)
{
struct fd_softc fdsoftc;
int i, nfound, first_found;
nfound = first_found = 0;
aprint_normal("\n");
fddeselect();
for (i = 0; i < NR_DRIVES; i++) {
/*
* Test if unit is present
*/
fdsoftc.unit = i;
fdsoftc.flags = 0;
st_dmagrab((dma_farg)fdcint, (dma_farg)fdtestdrv, &fdsoftc,
&lock_stat, 0, NULL);
st_dmafree(&fdsoftc, &lock_stat);
if ((fdsoftc.flags & FLPF_NOTRESP) == 0) {
if (nfound == 0)
first_found = i;
nfound++;
config_found(self, (void *)i, fdcprint, CFARGS_NONE);
}
}
if (nfound != 0) {
struct fd_softc *fdsc =
device_lookup_private(&fd_cd, first_found);
/*
* Make sure motor will be turned of when a floppy is
* inserted in the first selected drive.
*/
fdselect(first_found, 0, FLP_DD);
fd_state = FLP_MON;
callout_reset(&fdsc->sc_motor_ch, 0, (FPV)fdmotoroff, fdsc);
/*
* enable disk related interrupts
*/
MFP->mf_ierb |= IB_DINT;
MFP->mf_iprb = (uint8_t)~IB_DINT;
MFP->mf_imrb |= IB_DINT;
}
}
static int
fdcprint(void *aux, const char *pnp)
{
if (pnp != NULL)
aprint_normal("fd%d at %s:", (int)aux, pnp);
return UNCONF;
}
static int fdmatch(device_t, cfdata_t, void *);
static void fdattach(device_t, device_t, void *);
struct dkdriver fddkdriver = {
.d_strategy = fdstrategy
};
CFATTACH_DECL_NEW(fd, sizeof(struct fd_softc),
fdmatch, fdattach, NULL, NULL);
static int
fdmatch(device_t parent, cfdata_t match, void *aux)
{
return 1;
}
static void
fdattach(device_t parent, device_t self, void *aux)
{
struct fd_softc *sc;
struct fd_types *type;
u_short swtch;
sc = device_private(self);
sc->sc_dev = self;
callout_init(&sc->sc_motor_ch, 0);
/*
* Find out if an Ajax chip might be installed. Set the default
* floppy type accordingly.
*/
swtch = rd_cfg_switch();
def_type = (swtch & CFG_SWITCH_NOHD) ? FLP_TYPE_720 : FLP_TYPE_144;
type = &fdtypes[def_type];
aprint_normal(": %s %d cyl, %d head, %d sec\n", type->descr,
type->nblocks / (type->nsectors * type->nheads), type->nheads,
type->nsectors);
/*
* Initialize and attach the disk structure.
*/
disk_init(&sc->dkdev, device_xname(sc->sc_dev), &fddkdriver);
disk_attach(&sc->dkdev);
}
static int
fdioctl(dev_t dev, u_long cmd, void * addr, int flag, struct lwp *l)
{
struct fd_softc *sc;
int error;
sc = device_lookup_private(&fd_cd, DISKUNIT(dev));
if ((sc->flags & FLPF_HAVELAB) == 0)
return EBADF;
error = disk_ioctl(&sc->dkdev, RAW_PART, cmd, addr, flag, l);
if (error != EPASSTHROUGH)
return error;
switch (cmd) {
case DIOCSBAD:
return EINVAL;
#ifdef notyet /* XXX LWP */
case DIOCSRETRIES:
case DIOCSSTEP:
case DIOCSDINFO:
case DIOCWDINFO:
case DIOCWLABEL:
break;
#endif /* notyet */
case DIOCGDEFLABEL:
fdgetdefaultlabel(sc, (struct disklabel *)addr, RAW_PART);
return 0;
}
return ENOTTY;
}
/*
* Open the device. If this is the first open on both the floppy devices,
* initialize the controller.
* Note that partition info on the floppy device is used to distinguise
* between 780Kb and 360Kb floppy's.
* partition 0: 360Kb
* partition 1: 780Kb
*/
static int
fdopen(dev_t dev, int flags, int devtype, struct lwp *l)
{
struct fd_softc *sc;
int s;
#ifdef FLP_DEBUG
printf("fdopen dev=0x%llx\n", dev);
#endif
if (FLP_TYPE(dev) >= NR_TYPES)
return ENXIO;
if ((sc = device_lookup_private(&fd_cd, DISKUNIT(dev))) == NULL)
return ENXIO;
/*
* If no floppy currently open, reset the controller and select
* floppy type.
*/
if (nopens == 0) {
#ifdef FLP_DEBUG
printf("fdopen device not yet open\n");
#endif
nopens++;
write_fdreg(FDC_CS, IRUPT);
delay(40);
}
/*
* Sleep while other process is opening the device
*/
s = splbio();
while (sc->flags & FLPF_INOPEN)
tsleep((void *)sc, PRIBIO, "fdopen", 0);
splx(s);
if ((sc->flags & FLPF_ISOPEN) == 0) {
/*
* Initialise some driver values.
*/
int type;
void *addr;
type = FLP_TYPE(dev);
bufq_alloc(&sc->bufq, "disksort", BUFQ_SORT_RAWBLOCK);
sc->unit = DISKUNIT(dev);
sc->part = RAW_PART;
sc->nheads = fdtypes[type].nheads;
sc->nsectors = fdtypes[type].nsectors;
sc->nblocks = fdtypes[type].nblocks;
sc->density = fdtypes[type].density;
sc->curtrk = INV_TRK;
sc->sector = 0;
sc->errcnt = 0;
sc->bounceb = alloc_stmem(SECTOR_SIZE, &addr);
if (sc->bounceb == NULL)
return ENOMEM; /* XXX */
/*
* Go get write protect + loaded status
*/
sc->flags |= FLPF_INOPEN|FLPF_GETSTAT;
s = splbio();
st_dmagrab((dma_farg)fdcint, (dma_farg)fdstatus, sc,
&lock_stat, 0, NULL);
while ((sc->flags & FLPF_GETSTAT) != 0)
tsleep((void *)sc, PRIBIO, "fdopen", 0);
splx(s);
wakeup((void *)sc);
if ((sc->flags & FLPF_WRTPROT) != 0 &&
(flags & FWRITE) != 0) {
sc->flags = 0;
return EPERM;
}
if ((sc->flags & FLPF_EMPTY) != 0) {
sc->flags = 0;
return ENXIO;
}
sc->flags &= ~(FLPF_INOPEN|FLPF_GETSTAT);
sc->flags |= FLPF_ISOPEN;
} else {
/*
* Multiply opens are granted when accessing the same type of
* floppy (eq. the same partition).
*/
if (sc->density != fdtypes[DISKPART(dev)].density)
return ENXIO; /* XXX temporarily out of business */
}
fdgetdisklabel(sc, dev);
#ifdef FLP_DEBUG
printf("fdopen open succeeded on type %d\n", sc->part);
#endif
return 0;
}
static int
fdclose(dev_t dev, int flags, int devtype, struct lwp *l)
{
struct fd_softc *sc;
sc = device_lookup_private(&fd_cd, DISKUNIT(dev));
free_stmem(sc->bounceb);
sc->flags = 0;
nopens--;
#ifdef FLP_DEBUG
printf("Closed floppy device -- nopens: %d\n", nopens);
#endif
return 0;
}
static void
fdstrategy(struct buf *bp)
{
struct fd_softc *sc;
struct disklabel *lp;
int s, sz;
sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev));
#ifdef FLP_DEBUG
printf("fdstrategy: %p, b_bcount: %d\n", bp, bp->b_bcount);
#endif
/*
* check for valid partition and bounds
*/
lp = sc->dkdev.dk_label;
if ((sc->flags & FLPF_HAVELAB) == 0) {
bp->b_error = EIO;
goto done;
}
if (bp->b_blkno < 0 || (bp->b_bcount % SECTOR_SIZE) != 0) {
bp->b_error = EINVAL;
goto done;
}
if (bp->b_bcount == 0)
goto done;
sz = howmany(bp->b_bcount, SECTOR_SIZE);
if (bp->b_blkno + sz > sc->nblocks) {
sz = sc->nblocks - bp->b_blkno;
if (sz == 0) /* Exactly at EndOfDisk */
goto done;
if (sz < 0) { /* Past EndOfDisk */
bp->b_error = EINVAL;
goto done;
}
/* Truncate it */
if (bp->b_flags & B_RAW)
bp->b_bcount = sz << DEV_BSHIFT;
else
bp->b_bcount = sz * lp->d_secsize;
}
/* No partition translation. */
bp->b_rawblkno = bp->b_blkno;
/*
* queue the buf and kick the low level code
*/
s = splbio();
bufq_put(sc->bufq, bp); /* XXX disksort_cylinder */
if (!lock_stat) {
if (fd_state & FLP_MON)
callout_stop(&sc->sc_motor_ch);
fd_state = FLP_IDLE;
st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc,
&lock_stat, 0, NULL);
}
splx(s);
return;
done:
bp->b_resid = bp->b_bcount;
biodone(bp);
}
static int
fdread(dev_t dev, struct uio *uio, int flags)
{
return physio(fdstrategy, NULL, dev, B_READ, fdminphys, uio);
}
static int
fdwrite(dev_t dev, struct uio *uio, int flags)
{
return physio(fdstrategy, NULL, dev, B_WRITE, fdminphys, uio);
}
/*
* Called through DMA-dispatcher, get status.
*/
static void
fdstatus(struct fd_softc *sc)
{
#ifdef FLP_DEBUG
printf("fdstatus\n");
#endif
sc->errcnt = 0;
fd_state = FLP_STAT;
fd_xfer(sc);
}
/*
* Called through the DMA-dispatcher. So we know we are the only ones
* messing with the floppy-controller.
* Initialize some fields in the fdsoftc for the state-machine and get
* it going.
*/
static void
fdstart(struct fd_softc *sc)
{
struct buf *bp;
bp = bufq_peek(sc->bufq);
sc->sector = bp->b_blkno; /* Start sector for I/O */
sc->io_data = bp->b_data; /* KVA base for I/O */
sc->io_bytes = bp->b_bcount; /* Transfer size in bytes */
sc->io_dir = bp->b_flags & B_READ;/* Direction of transfer */
sc->errcnt = 0; /* No errors yet */
fd_state = FLP_XFER; /* Yes, we're going to transfer */
/* Instrumentation. */
disk_busy(&sc->dkdev);
fd_xfer(sc);
}
/*
* The current transaction is finished (for good or bad). Let go of
* the DMA-resources. Call biodone() to finish the transaction.
* Find a new transaction to work on.
*/
static void
fddone(register struct fd_softc *sc)
{
struct buf *bp;
struct fd_softc *sc1;
int i, s;
/*
* Give others a chance to use the DMA.
*/
st_dmafree(sc, &lock_stat);
if (fd_state != FLP_STAT) {
/*
* Finish current transaction.
*/
s = splbio();
bp = bufq_get(sc->bufq);
if (bp == NULL)
panic("fddone");
splx(s);
#ifdef FLP_DEBUG
printf("fddone: unit: %d, buf: %p, resid: %d\n",sc->unit, bp,
sc->io_bytes);
#endif
bp->b_resid = sc->io_bytes;
disk_unbusy(&sc->dkdev, (bp->b_bcount - bp->b_resid),
(bp->b_flags & B_READ));
biodone(bp);
}
fd_state = FLP_MON;
if (lock_stat)
return; /* XXX Is this possible? */
/*
* Find a new transaction on round-robin basis.
*/
for (i = sc->unit + 1;; i++) {
if (i >= fd_cd.cd_ndevs)
i = 0;
if ((sc1 = device_lookup_private(&fd_cd, i)) == NULL)
continue;
if (bufq_peek(sc1->bufq) != NULL)
break;
if (i == sc->unit) {
callout_reset(&sc->sc_motor_ch, FLP_MONDELAY,
(FPV)fdmotoroff, sc);
#ifdef FLP_DEBUG
printf("fddone: Nothing to do\n");
#endif
return; /* No work */
}
}
fd_state = FLP_IDLE;
#ifdef FLP_DEBUG
printf("fddone: Staring job on unit %d\n", sc1->unit);
#endif
st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc1, &lock_stat, 0,
NULL);
}
static int
fdselect(int drive, int head, int dense)
{
int i, spinning;
#ifdef FLP_DEBUG
printf("fdselect: drive=%d, head=%d, dense=%d\n", drive, head, dense);
#endif
i = ((drive == 1) ? PA_FLOP1 : PA_FLOP0) | head;
spinning = motoron;
motoron = 1;
switch (dense) {
case FLP_DD:
DMA->dma_drvmode = 0;
break;
case FLP_HD:
DMA->dma_drvmode = (FDC_HDSET|FDC_HDSIG);
break;
default:
panic("fdselect: unknown density code");
}
if (i != selected) {
selected = i;
ym2149_fd_select((i ^ PA_FDSEL));
}
return spinning;
}
static void
fddeselect(void)
{
ym2149_fd_select(PA_FDSEL);
motoron = selected = 0;
DMA->dma_drvmode = 0;
}
/****************************************************************************
* The following functions assume to be running as a result of a *
* disk-interrupt (e.q. spl = splbio). *
* They form the finit-state machine, the actual driver. *
* *
* fdstart()/ --> fd_xfer() -> activate hardware *
* fdopen() ^ *
* | *
* +-- not ready -<------------+ *
* | *
* fdmotoroff()/ --> fdcint() -> fd_xfer_ok() ---+ *
* h/w interrupt | *
* \|/ *
* finished ---> fdone() *
* *
****************************************************************************/
static void
fd_xfer(struct fd_softc *sc)
{
int head;
int track, sector, hbit;
paddr_t phys_addr;
head = track = 0;
switch (fd_state) {
case FLP_XFER:
/*
* Calculate head/track values
*/
track = sc->sector / sc->nsectors;
head = track % sc->nheads;
track = track / sc->nheads;
#ifdef FLP_DEBUG
printf("fd_xfer: sector:%d,head:%d,track:%d\n",
sc->sector, head, track);
#endif
break;
case FLP_STAT:
/*
* FLP_STAT only wants to recalibrate
*/
sc->curtrk = INV_TRK;
break;
default:
panic("fd_xfer: wrong state (0x%x)", fd_state);
}
/*
* Select the drive.
*/
hbit = fdselect(sc->unit, head, sc->density) ? HBIT : 0;
if (sc->curtrk == INV_TRK) {
/*
* Recalibrate, since we lost track of head positioning.
* The floppy disk controller has no way of determining its
* absolute arm position (track). Instead, it steps the
* arm a track at a time and keeps track of where it
* thinks it is (in software). However, after a SEEK, the
* hardware reads information from the diskette telling
* where the arm actually is. If the arm is in the wrong place,
* a recalibration is done, which forces the arm to track 0.
* This way the controller can get back into sync with reality.
*/
fd_cmd = RESTORE;
write_fdreg(FDC_CS, RESTORE|VBIT|hbit);
callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY,
(FPV)fdmotoroff, sc);
#ifdef FLP_DEBUG
printf("fd_xfer:Recalibrating drive %d\n", sc->unit);
#endif
return;
}
write_fdreg(FDC_TR, sc->curtrk);
/*
* Issue a SEEK command on the indicated drive unless the arm is
* already positioned on the correct track.
*/
if (track != sc->curtrk) {
sc->curtrk = track; /* be optimistic */
write_fdreg(FDC_DR, track);
write_fdreg(FDC_CS, SEEK|RATE6|VBIT|hbit);
callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY,
(FPV)fdmotoroff, sc);
fd_cmd = SEEK;
#ifdef FLP_DEBUG
printf("fd_xfer:Seek to track %d on drive %d\n",
track, sc->unit);
#endif
return;
}
/*
* The drive is now on the proper track. Read or write 1 block.
*/
sector = sc->sector % sc->nsectors;
sector++; /* start numbering at 1 */
write_fdreg(FDC_SR, sector);
phys_addr = (paddr_t)kvtop(sc->io_data);
if (phys_addr >= FDC_MAX_DMA_AD) {
/*
* We _must_ bounce this address
*/
phys_addr = (paddr_t)kvtop(sc->bounceb);
if (sc->io_dir == B_WRITE)
memcpy(sc->bounceb, sc->io_data, SECTOR_SIZE);
sc->flags |= FLPF_BOUNCE;
}
st_dmaaddr_set((void *)phys_addr); /* DMA address setup */
#ifdef FLP_DEBUG
printf("fd_xfer:Start io (io_addr:%lx)\n", (u_long)kvtop(sc->io_data));
#endif
if (sc->io_dir == B_READ) {
/* Issue the command */
st_dmacomm(DMA_FDC | DMA_SCREG, 1);
write_fdreg(FDC_CS, F_READ|hbit);
fd_cmd = F_READ;
} else {
/* Issue the command */
st_dmacomm(DMA_WRBIT | DMA_FDC | DMA_SCREG, 1);
write_fdreg(DMA_WRBIT | FDC_CS, F_WRITE|hbit|EBIT|PBIT);
fd_cmd = F_WRITE;
}
callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY, (FPV)fdmotoroff, sc);
}
/* return values of fd_xfer_ok(): */
#define X_OK 0
#define X_AGAIN 1
#define X_ERROR 2
#define X_FAIL 3
/*
* Hardware interrupt function.
*/
static void
fdcint(struct fd_softc *sc)
{
struct buf *bp;
#ifdef FLP_DEBUG
printf("fdcint: unit = %d\n", sc->unit);
#endif
/*
* Cancel timeout (we made it, didn't we)
*/
callout_stop(&sc->sc_motor_ch);
switch (fd_xfer_ok(sc)) {
case X_ERROR:
if (++sc->errcnt < MAX_ERRORS) {
/*
* Command failed but still retries left.
*/
break;
}
/* FALL THROUGH */
case X_FAIL:
/*
* Non recoverable error. Fall back to motor-on
* idle-state.
*/
if (fd_error != NULL) {
printf("Floppy error: %s\n", fd_error);
fd_error = NULL;
}
if (fd_state == FLP_STAT) {
sc->flags |= FLPF_EMPTY;
sc->flags &= ~FLPF_GETSTAT;
wakeup((void *)sc);
fddone(sc);
return;
}
bp = bufq_peek(sc->bufq);
bp->b_error = EIO;
fd_state = FLP_MON;
break;
case X_AGAIN:
/*
* Start next part of state machine.
*/
break;
case X_OK:
/*
* Command ok and finished. Reset error-counter.
* If there are no more bytes to transfer fall back
* to motor-on idle state.
*/
sc->errcnt = 0;
if (fd_state == FLP_STAT) {
sc->flags &= ~FLPF_GETSTAT;
wakeup((void *)sc);
fddone(sc);
return;
}
if ((sc->flags & FLPF_BOUNCE) != 0 &&
sc->io_dir == B_READ)
memcpy(sc->io_data, sc->bounceb, SECTOR_SIZE);
sc->flags &= ~FLPF_BOUNCE;
sc->sector++;
sc->io_data += SECTOR_SIZE;
sc->io_bytes -= SECTOR_SIZE;
if (sc->io_bytes <= 0)
fd_state = FLP_MON;
}
if (fd_state == FLP_MON)
fddone(sc);
else
fd_xfer(sc);
}
/*
* Determine status of last command. Should only be called through
* 'fdcint()'.
* Returns:
* X_ERROR : Error on command; might succeed next time.
* X_FAIL : Error on command; will never succeed.
* X_AGAIN : Part of a command succeeded, call 'fd_xfer()' to complete.
* X_OK : Command succeeded and is complete.
*
* This function only affects sc->curtrk.
*/
static int
fd_xfer_ok(register struct fd_softc *sc)
{
int status;
#ifdef FLP_DEBUG
printf("fd_xfer_ok: cmd: 0x%x, state: 0x%x\n", fd_cmd, fd_state);
#endif
switch (fd_cmd) {
case IRUPT:
/*
* Timeout. Force a recalibrate before we try again.
*/
status = read_fdreg(FDC_CS);
fd_error = "Timeout";
sc->curtrk = INV_TRK;
return X_ERROR;
case F_READ:
/*
* Test for DMA error
*/
status = read_dmastat();
if ((status & DMAOK) == 0) {
fd_error = "DMA error";
return X_ERROR;
}
/*
* Get controller status and check for errors.
*/
status = read_fdreg(FDC_CS);
if ((status & (RNF | CRCERR | LD_T00)) != 0) {
fd_error = "Read error";
if ((status & RNF) != 0)
sc->curtrk = INV_TRK;
return X_ERROR;
}
break;
case F_WRITE:
/*
* Test for DMA error
*/
status = read_dmastat();
if ((status & DMAOK) == 0) {
fd_error = "DMA error";
return X_ERROR;
}
/*
* Get controller status and check for errors.
*/
status = read_fdreg(FDC_CS);
if ((status & WRI_PRO) != 0) {
fd_error = "Write protected";
return X_FAIL;
}
if ((status & (RNF | CRCERR | LD_T00)) != 0) {
fd_error = "Write error";
sc->curtrk = INV_TRK;
return X_ERROR;
}
break;
case SEEK:
status = read_fdreg(FDC_CS);
if ((status & (RNF | CRCERR)) != 0) {
fd_error = "Seek error";
sc->curtrk = INV_TRK;
return X_ERROR;
}
return X_AGAIN;
case RESTORE:
/*
* Determine if the recalibration succeeded.
*/
status = read_fdreg(FDC_CS);
if ((status & RNF) != 0) {
fd_error = "Recalibrate error";
/* reset controller */
write_fdreg(FDC_CS, IRUPT);
sc->curtrk = INV_TRK;
return X_ERROR;
}
sc->curtrk = 0;
if (fd_state == FLP_STAT) {
if ((status & WRI_PRO) != 0)
sc->flags |= FLPF_WRTPROT;
break;
}
return X_AGAIN;
default:
fd_error = "Driver error: fd_xfer_ok : Unknown state";
return X_FAIL;
}
return X_OK;
}
/*
* All timeouts will call this function.
*/
static void
fdmotoroff(struct fd_softc *sc)
{
int s;
/*
* Get at hardware interrupt level
*/
s = splbio();
#if FLP_DEBUG
printf("fdmotoroff, state = 0x%x\n", fd_state);
#endif
switch (fd_state) {
case FLP_STAT:
case FLP_XFER:
/*
* Timeout during a transfer; cancel transaction
* set command to 'IRUPT'.
* A drive-interrupt is simulated to trigger the state
* machine.
*/
/*
* Cancel current transaction
*/
fd_cmd = IRUPT;
write_fdreg(FDC_CS, IRUPT);
delay(20);
(void)read_fdreg(FDC_CS);
write_fdreg(FDC_CS, RESTORE);
break;
case FLP_MON:
/*
* Turn motor off.
*/
if (selected) {
int tmp;
st_dmagrab((dma_farg)fdcint, (dma_farg)fdmoff, sc,
&tmp, 0, NULL);
} else
fd_state = FLP_IDLE;
break;
}
splx(s);
}
/*
* min byte count to whats left of the track in question
*/
static void
fdminphys(struct buf *bp)
{
struct fd_softc *sc;
int sec, toff, tsz;
if ((sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev))) == NULL)
panic("fdminphys: couldn't get softc");
sec = bp->b_blkno % (sc->nsectors * sc->nheads);
toff = sec * SECTOR_SIZE;
tsz = sc->nsectors * sc->nheads * SECTOR_SIZE;
#ifdef FLP_DEBUG
printf("fdminphys: before %d", bp->b_bcount);
#endif
bp->b_bcount = uimin(bp->b_bcount, tsz - toff);
#ifdef FLP_DEBUG
printf(" after %d\n", bp->b_bcount);
#endif
minphys(bp);
}
/*
* Called from fdmotoroff to turn the motor actually off....
* This can't be done in fdmotoroff itself, because exclusive access to the
* DMA controller is needed to read the FDC-status register. The function
* 'fdmoff()' always runs as the result of a 'dmagrab()'.
* We need to test the status-register because we want to be sure that the
* drive motor is really off before deselecting the drive. The FDC only
* turns off the drive motor after having seen 10 index-pulses. You only
* get index-pulses when a drive is selected....This means that if the
* drive is deselected when the motor is still spinning, it will continue
* to spin _even_ when you insert a floppy later on...
*/
static void
fdmoff(struct fd_softc *fdsoftc)
{
int tmp;
if ((fd_state == FLP_MON) && selected) {
tmp = read_fdreg(FDC_CS);
if ((tmp & MOTORON) == 0) {
fddeselect();
fd_state = FLP_IDLE;
} else
callout_reset(&fdsoftc->sc_motor_ch, 10 * FLP_MONDELAY,
(FPV)fdmotoroff, fdsoftc);
}
st_dmafree(fdsoftc, &tmp);
}
/*
* Used to find out which drives are actually connected. We do this by issuing
* is 'RESTORE' command and check if the 'track-0' bit is set. This also works
* if the drive is present but no floppy is inserted.
*/
static void
fdtestdrv(struct fd_softc *fdsoftc)
{
int status;
/*
* Select the right unit and head.
*/
fdselect(fdsoftc->unit, 0, FLP_DD);
write_fdreg(FDC_CS, RESTORE|HBIT);
/*
* Wait for about 2 seconds.
*/
delay(2000000);
status = read_fdreg(FDC_CS);
if ((status & (RNF|BUSY)) != 0) {
write_fdreg(FDC_CS, IRUPT); /* reset controller */
delay(40);
}
if ((status & LD_T00) == 0)
fdsoftc->flags |= FLPF_NOTRESP;
fddeselect();
}
static void
fdgetdefaultlabel(struct fd_softc *sc, struct disklabel *lp, int part)
{
memset(lp, 0, sizeof(struct disklabel));
lp->d_secsize = SECTOR_SIZE;
lp->d_ntracks = sc->nheads;
lp->d_nsectors = sc->nsectors;
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp->d_ncylinders = sc->nblocks / lp->d_secpercyl;
lp->d_secperunit = sc->nblocks;
lp->d_type = DKTYPE_FLOPPY;
lp->d_rpm = 300; /* good guess I suppose. */
lp->d_interleave = 1; /* FIXME: is this OK? */
lp->d_bbsize = 0;
lp->d_sbsize = 0;
lp->d_npartitions = part + 1;
lp->d_trkseek = STEP_DELAY;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
lp->d_partitions[part].p_size = lp->d_secperunit;
lp->d_partitions[part].p_fstype = FS_UNUSED;
lp->d_partitions[part].p_fsize = 1024;
lp->d_partitions[part].p_frag = 8;
}
/*
* Build disk label. For now we only create a label from what we know
* from 'sc'.
*/
static int
fdgetdisklabel(struct fd_softc *sc, dev_t dev)
{
struct disklabel *lp;
int part;
/*
* If we already got one, get out.
*/
if ((sc->flags & FLPF_HAVELAB) != 0)
return 0;
#ifdef FLP_DEBUG
printf("fdgetdisklabel()\n");
#endif
part = RAW_PART;
lp = sc->dkdev.dk_label;
fdgetdefaultlabel(sc, lp, part);
sc->flags |= FLPF_HAVELAB;
return 0;
}
